Commit ac981f1b authored by Tomáš Oberhuber's avatar Tomáš Oberhuber
Browse files

Fixing tnl-quickstart.

parent 69d3240a

src/mesh/grids/CMakeLists.txt

+12 −8
Original line number Diff line number Diff line 
SET( headers tnlBoundaryGridEntityChecker.h

             tnlBoundaryGridEntityChecker.h

             tnlGrid1D.h

             tnlGrid1D_impl.h

             tnlGrid2D.h

             tnlGrid2D_impl.h

             tnlGrid3D.h

             tnlGrid3D_impl.h

             tnlGridEntityTopology.h

             tnlGridEntity.h

             tnlGridEntity_impl.h

             tnlGridEntityConfig.h

             tnlGridEntityCenterGetter.h

             tnlGridEntityConfig.h

             tnlGridEntityGetter.h

             tnlGridEntityGetter_impl.h

             tnlGridEntity.h

             tnlGridEntity_impl.h

             tnlGridEntityMeasureGetter.h

             tnlNeighbourGridEntityGetter.h

             tnlGridEntityTopology.h

             tnlGridTraverser.h

             tnlGridTraverser_impl.h

             tnlNeighbourGridEntitiesStorage.h

             tnlNeighbourGridEntityGetter1D_impl.h

             tnlNeighbourGridEntityGetter2D_impl.h

             tnlNeighbourGridEntityGetter3D_impl.h

             tnlNeighbourGridEntityGetter.h

             tnlTraverser_Grid1D.h

             tnlTraverser_Grid1D_impl.h

             tnlTraverser_Grid2D.h

src/operators/CMakeLists.txt

+11 −4
Original line number Diff line number Diff line
@@ -4,12 +4,19 @@ ADD_SUBDIRECTORY( interpolants ) 
ADD_SUBDIRECTORY( operator-Q )

ADD_SUBDIRECTORY( operator-curvature )



SET( headers tnlFiniteDifferences.h

             tnlFiniteDifferences_impl.h

             tnlDirichletBoundaryConditions.h

SET( headers tnlDirichletBoundaryConditions.h

             tnlDirichletBoundaryConditions_impl.h

             tnlExactFunctionInverseOperator.h

             tnlExactIdentityOperator.h

             tnlExactOperatorComposition.h

             tnlFiniteDifferences.h

             tnlFiniteDifferences_impl.h

             tnlFunctionInverseOperator.h

             tnlIdentityOperator.h

             tnlNeumannBoundaryConditions.h

             tnlNeumannBoundaryConditions_impl.h )

             tnlNeumannBoundaryConditions_impl.h

             tnlOperatorComposition.h

             tnlOperator.h )

             

SET( CURRENT_DIR ${CMAKE_SOURCE_DIR}/src/operators )

src/solvers/pde/CMakeLists.txt

+11 −8
Original line number Diff line number Diff line 
SET( headers tnlPDESolver.h

             tnlPDESolver_impl.h

SET( headers tnlBackwardTimeDiscretisation.h

             tnlBoundaryConditionsSetter.h

             tnlBoundaryConditionsSetter_impl.h

             tnlExplicitTimeStepper.h

             tnlExplicitTimeStepper_impl.h

             tnlExplicitUpdater.h

             tnlExplicitUpdater_impl.h

             tnlSemiImplicitTimeStepper.h

             tnlSemiImplicitTimeStepper_impl.h

             tnlLinearSystemAssembler.h

             tnlLinearSystemAssembler_impl.h

             tnlBackwardTimeDiscretisation.h

             tnlNoTimeDiscretisation.h  )

             tnlNoTimeDiscretisation.h

             tnlPDESolver.h

             tnlPDESolver_impl.h

             tnlSemiImplicitTimeStepper.h

             tnlSemiImplicitTimeStepper_impl.h )



             

INSTALL( FILES ${headers} DESTINATION include/tnl-${tnlVersion}/solvers/pde )

src/solvers/tnlBuildConfigTags.h

+24 −24
Original line number Diff line number Diff line 
/***************************************************************************

                          tnlMeshConfigs.h  -  description

                          tnlBuildConfigTags.h  -  description

                             -------------------

    begin                : Jul 7, 2014

    copyright            : (C) 2014 by Tomas Oberhuber
@@ -15,8 +15,8 @@ 
 *                                                                         *

 ***************************************************************************/



#ifndef TNLMeshConfigS_H_

#define TNLMeshConfigS_H_

#ifndef TNLBUILDCONFIGTAGS_H_

#define TNLBUILDCONFIGTAGS_H_



#include <mesh/tnlGrid.h>

#include <solvers/ode/tnlMersonSolver.h>
@@ -28,54 +28,54 @@ 
#include <solvers/linear/krylov/tnlTFQMRSolver.h>

#include <solvers/preconditioners/tnlDummyPreconditioner.h>



class tnlDefaultBuildMeshConfig{};

class tnlDefaultBuildConfigTag{};



/****

 * All devices are enabled by default. Those which are not available

 * are disabled.

 */

template< typename MeshConfig, typename Device > struct tnlMeshConfigDevice{ enum { enabled = true }; };

template< typename ConfigTag, typename Device > struct tnlConfigTagDevice{ enum { enabled = true }; };

#ifndef HAVE_CUDA

template< typename MeshConfig > struct tnlMeshConfigDevice< MeshConfig, tnlCuda >{ enum { enabled = false }; };

template< typename ConfigTag > struct tnlConfigTagDevice< ConfigTag, tnlCuda >{ enum { enabled = false }; };

#endif



/****

 * All real types are enabled by default.

 */

template< typename MeshConfig, typename Real > struct tnlMeshConfigReal{ enum { enabled = true }; };

template< typename ConfigTag, typename Real > struct tnlConfigTagReal{ enum { enabled = true }; };



/****

 * All index types are enabled by default.

 */

template< typename MeshConfig, typename Index > struct tnlMeshConfigIndex{ enum { enabled = true }; };

template< typename ConfigTag, typename Index > struct tnlConfigTagIndex{ enum { enabled = true }; };



/****

 * The mesh type will be resolved by the tnlSolver by default.

 */

template< typename MeshConfig > struct tnlMeshConfigMeshResolve{ enum { enabled = true }; };

template< typename ConfigTag > struct tnlConfigTagMeshResolve{ enum { enabled = true }; };



/****

 * 1, 2, and 3 dimensions are enabled by default

 */

template< typename MeshConfig, int Dimensions > struct tnlMeshConfigDimensions{ enum { enabled = false }; };

   template< typename MeshConfig > struct tnlMeshConfigDimensions< MeshConfig, 1 >{ enum { enabled = true }; };

   template< typename MeshConfig > struct tnlMeshConfigDimensions< MeshConfig, 2 >{ enum { enabled = true }; };

   template< typename MeshConfig > struct tnlMeshConfigDimensions< MeshConfig, 3 >{ enum { enabled = true }; };

template< typename ConfigTag, int Dimensions > struct tnlConfigTagDimensions{ enum { enabled = false }; };

   template< typename ConfigTag > struct tnlConfigTagDimensions< ConfigTag, 1 >{ enum { enabled = true }; };

   template< typename ConfigTag > struct tnlConfigTagDimensions< ConfigTag, 2 >{ enum { enabled = true }; };

   template< typename ConfigTag > struct tnlConfigTagDimensions< ConfigTag, 3 >{ enum { enabled = true }; };



/****

 * Up to the exceptions enlisted below, all mesh types are disabled by default.

 */

template< typename MeshConfig, typename MeshType > struct tnlMeshConfigMesh{ enum { enabled = false }; };

template< typename ConfigTag, typename MeshType > struct tnlConfigTagMesh{ enum { enabled = false }; };



/****

 * Use of tnlGrid is enabled for allowed dimensions and Real, Device and Index types.

 */

template< typename MeshConfig, int Dimensions, typename Real, typename Device, typename Index >

   struct tnlMeshConfigMesh< MeshConfig, tnlGrid< Dimensions, Real, Device, Index > >

      { enum { enabled = tnlMeshConfigDimensions< MeshConfig, Dimensions >::enabled  &&

                         tnlMeshConfigReal< MeshConfig, Real >::enabled &&

                         tnlMeshConfigDevice< MeshConfig, Device >::enabled &&

                         tnlMeshConfigIndex< MeshConfig, Index >::enabled }; };

template< typename ConfigTag, int Dimensions, typename Real, typename Device, typename Index >

   struct tnlConfigTagMesh< ConfigTag, tnlGrid< Dimensions, Real, Device, Index > >

      { enum { enabled = tnlConfigTagDimensions< ConfigTag, Dimensions >::enabled  &&

                         tnlConfigTagReal< ConfigTag, Real >::enabled &&

                         tnlConfigTagDevice< ConfigTag, Device >::enabled &&

                         tnlConfigTagIndex< ConfigTag, Index >::enabled }; };



/****

 * All time discretisations (explicit, semi-impicit and implicit ) are
@@ -85,7 +85,7 @@ class tnlExplicitTimeDiscretisationTag{}; 
class tnlSemiImplicitTimeDiscretisationTag{};

class tnlImplicitTimeDiscretisationTag{};



template< typename MeshConfig, typename TimeDiscretisation > struct tnlConfigTagTimeDiscretisation{ enum { enabled = true }; };

template< typename ConfigTag, typename TimeDiscretisation > struct tnlConfigTagTimeDiscretisation{ enum { enabled = true }; };



/****

 * All explicit solvers are enabled by default
@@ -104,7 +104,7 @@ public: 
    using Template = tnlMersonSolver< Problem >;

};



template< typename MeshConfig, typename ExplicitSolver > struct tnlMeshConfigExplicitSolver{ enum { enabled = true }; };

template< typename ConfigTag, typename ExplicitSolver > struct tnlConfigTagExplicitSolver{ enum { enabled = true }; };



/****

 * All semi-implicit solvers are enabled by default
@@ -154,6 +154,6 @@ public: 
    using Template = tnlTFQMRSolver< Matrix, Preconditioner >;

};



template< typename MeshConfig, typename SemiImplicitSolver > struct tnlMeshConfigSemiImplicitSolver{ enum { enabled = true }; };

template< typename ConfigTag, typename SemiImplicitSolver > struct tnlConfigTagSemiImplicitSolver{ enum { enabled = true }; };



#endif /* TNLMeshConfigS_H_ */
 
#endif /* TNLBUILDCONFIGTAGS_H_ */

src/solvers/tnlFastBuildConfigTag.h

+10 −10
Original line number Diff line number Diff line
@@ -30,24 +30,24 @@ class tnlFastBuildConfig 
/****

 * Turn off support for float and long double.

 */

template<> struct tnlMeshConfigReal< tnlFastBuildConfig, float > { enum { enabled = false }; };

template<> struct tnlMeshConfigReal< tnlFastBuildConfig, long double > { enum { enabled = false }; };

template<> struct tnlConfigTagReal< tnlFastBuildConfig, float > { enum { enabled = false }; };

template<> struct tnlConfigTagReal< tnlFastBuildConfig, long double > { enum { enabled = false }; };



/****

 * Turn off support for short int and long int indexing.

 */

template<> struct tnlMeshConfigIndex< tnlFastBuildConfig, short int >{ enum { enabled = false }; };

template<> struct tnlMeshConfigIndex< tnlFastBuildConfig, long int >{ enum { enabled = false }; };

template<> struct tnlConfigTagIndex< tnlFastBuildConfig, short int >{ enum { enabled = false }; };

template<> struct tnlConfigTagIndex< tnlFastBuildConfig, long int >{ enum { enabled = false }; };



/****

 * Use of tnlGrid is enabled for allowed dimensions and Real, Device and Index types.

 */

template< int Dimensions, typename Real, typename Device, typename Index >

   struct tnlMeshConfigMesh< tnlFastBuildConfig, tnlGrid< Dimensions, Real, Device, Index > >

      { enum { enabled = tnlMeshConfigDimensions< tnlFastBuildConfig, Dimensions >::enabled  &&

                         tnlMeshConfigReal< tnlFastBuildConfig, Real >::enabled &&

                         tnlMeshConfigDevice< tnlFastBuildConfig, Device >::enabled &&

                         tnlMeshConfigIndex< tnlFastBuildConfig, Index >::enabled }; };

   struct tnlConfigTagMesh< tnlFastBuildConfig, tnlGrid< Dimensions, Real, Device, Index > >

      { enum { enabled = tnlConfigTagDimensions< tnlFastBuildConfig, Dimensions >::enabled  &&

                         tnlConfigTagReal< tnlFastBuildConfig, Real >::enabled &&

                         tnlConfigTagDevice< tnlFastBuildConfig, Device >::enabled &&

                         tnlConfigTagIndex< tnlFastBuildConfig, Index >::enabled }; };



/****

 * Please, chose your preferred time discretisation  here.
@@ -59,6 +59,6 @@ template<> struct tnlConfigTagTimeDiscretisation< tnlFastBuildConfig, tnlImplici 
/****

 * Only the Runge-Kutta-Merson solver is enabled by default.

 */

//template<> struct tnlMeshConfigExplicitSolver< tnlFastBuildConfig, tnlExplicitEulerSolverTag >{ enum { enabled = false }; };

//template<> struct tnlConfigTagExplicitSolver< tnlFastBuildConfig, tnlExplicitEulerSolverTag >{ enum { enabled = false }; };



#endif /* TNLFASTBUILDCONFIGTAG_H_ */