Commit ae7a48c5 authored by Jakub Klinkovský's avatar Jakub Klinkovský
Browse files

Next iteration of MeshTypeResolver generalization

parent f8eb6d9b

src/TNL/Solvers/MeshTypeResolver.h

+20 −14
Original line number Diff line number Diff line
@@ -17,11 +17,9 @@ 
namespace TNL {

namespace Solvers {



template< template< typename Real, typename Device, typename Index, typename MeshType, typename ConfigTag, typename SolverStarter > class ProblemSetter,

          typename Real,

template< typename ConfigTag,

          typename Device,

          typename Index,

          typename ConfigTag >

          template< typename MeshType > class ProblemSetter >

class MeshTypeResolver

{

   public:
@@ -78,10 +76,18 @@ class MeshTypeResolver 
   static bool resolveMeshType( const Config::ParameterContainer& parameters,

                                Meshes::Readers::TNL& reader );



   // Overload for disabled mesh types

   template< typename MeshType,

             typename = typename std::enable_if< ! ConfigTagMesh< ConfigTag, MeshType >::enabled >::type,

             typename = void >

   static bool resolveTerminate( const Config::ParameterContainer& parameters,

                                 Meshes::Readers::TNL& reader );





   template< int Dimension, bool DimensionSupport, typename MeshTypeResolver >

    friend class MeshTypeResolverDimensionSupportChecker;

   // Overload for enabled mesh types

   template< typename MeshType,

             typename = typename std::enable_if< ConfigTagMesh< ConfigTag, MeshType >::enabled >::type >

   static bool resolveTerminate( const Config::ParameterContainer& parameters,

                                 Meshes::Readers::TNL& reader );

};



} // namespace Solvers

src/TNL/Solvers/MeshTypeResolver_impl.h

+45 −76
Original line number Diff line number Diff line
@@ -13,28 +13,15 @@ 
#include <TNL/String.h>

#include <TNL/Meshes/Grid.h>

#include <TNL/Solvers/MeshTypeResolver.h>

#include <TNL/Solvers/SolverStarter.h>



namespace TNL {

namespace Solvers {   



template< template< typename Real, typename Device, typename Index, typename MeshType, typename ConfigTag, typename SolverStarter > class ProblemSetter,

          typename Real,

template< typename ConfigTag,

          typename Device,

          typename Index,

          typename MeshType,

          typename ConfigTag,

          bool MeshTypeSupported = ConfigTagMesh< ConfigTag, MeshType >::enabled >

class MeshResolverTerminator {};





template< template< typename Real, typename Device, typename Index, typename MeshType, typename ConfigTag, typename SolverStarter > class ProblemSetter,

          typename Real,

          typename Device,

          typename Index,

          typename ConfigTag >

          template< typename MeshType > class ProblemSetter >

bool

MeshTypeResolver< ProblemSetter, Real, Device, Index, ConfigTag >::

MeshTypeResolver< ConfigTag, Device, ProblemSetter >::

run( const Config::ParameterContainer& parameters )

{

   const String& meshFileName = parameters.getParameter< String >( "mesh" );
@@ -44,13 +31,11 @@ run( const Config::ParameterContainer& parameters ) 
   return resolveMeshDimension( parameters, reader );

}



template< template< typename Real, typename Device, typename Index, typename MeshType, typename ConfigTag, typename SolverStarter > class ProblemSetter,

          typename Real,

template< typename ConfigTag,

          typename Device,

          typename Index,

          typename ConfigTag >

          template< typename MeshType > class ProblemSetter >

bool

MeshTypeResolver< ProblemSetter, Real, Device, Index, ConfigTag >::

MeshTypeResolver< ConfigTag, Device, ProblemSetter >::

resolveMeshDimension( const Config::ParameterContainer& parameters,

                       Meshes::Readers::TNL& reader )

{
@@ -64,14 +49,12 @@ resolveMeshDimension( const Config::ParameterContainer& parameters, 
   return false;

}



template< template< typename Real, typename Device, typename Index, typename MeshType, typename ConfigTag, typename SolverStarter > class ProblemSetter,

          typename Real,

template< typename ConfigTag,

          typename Device,

          typename Index,

          typename ConfigTag >

          template< typename MeshType > class ProblemSetter >

   template< int MeshDimension, typename, typename >

bool

MeshTypeResolver< ProblemSetter, Real, Device, Index, ConfigTag >::

MeshTypeResolver< ConfigTag, Device, ProblemSetter >::

resolveMeshRealType( const Config::ParameterContainer& parameters,

                     Meshes::Readers::TNL& reader )

{
@@ -79,14 +62,12 @@ resolveMeshRealType( const Config::ParameterContainer& parameters, 
   return false;

}



template< template< typename Real, typename Device, typename Index, typename MeshType, typename ConfigTag, typename SolverStarter > class ProblemSetter,

          typename Real,

template< typename ConfigTag,

          typename Device,

          typename Index,

          typename ConfigTag >

          template< typename MeshType > class ProblemSetter >

   template< int MeshDimension, typename >

bool

MeshTypeResolver< ProblemSetter, Real, Device, Index, ConfigTag >::

MeshTypeResolver< ConfigTag, Device, ProblemSetter >::

resolveMeshRealType( const Config::ParameterContainer& parameters,

                     Meshes::Readers::TNL& reader )

{
@@ -100,16 +81,14 @@ resolveMeshRealType( const Config::ParameterContainer& parameters, 
   return false;

}



template< template< typename Real, typename Device, typename Index, typename MeshType, typename ConfigTag, typename SolverStarter > class ProblemSetter,

          typename Real,

template< typename ConfigTag,

          typename Device,

          typename Index,

          typename ConfigTag >

          template< typename MeshType > class ProblemSetter >

   template< int MeshDimension,

             typename MeshRealType,

             typename, typename >

bool

MeshTypeResolver< ProblemSetter, Real, Device, Index, ConfigTag >::

MeshTypeResolver< ConfigTag, Device, ProblemSetter >::

resolveMeshIndexType( const Config::ParameterContainer& parameters,

                      Meshes::Readers::TNL& reader )

{
@@ -117,16 +96,14 @@ resolveMeshIndexType( const Config::ParameterContainer& parameters, 
   return false;

}



template< template< typename Real, typename Device, typename Index, typename MeshType, typename ConfigTag, typename SolverStarter > class ProblemSetter,

          typename Real,

template< typename ConfigTag,

          typename Device,

          typename Index,

          typename ConfigTag >

          template< typename MeshType > class ProblemSetter >

   template< int MeshDimension,

             typename MeshRealType,

             typename >

bool

MeshTypeResolver< ProblemSetter, Real, Device, Index, ConfigTag >::

MeshTypeResolver< ConfigTag, Device, ProblemSetter >::

resolveMeshIndexType( const Config::ParameterContainer& parameters,

                      Meshes::Readers::TNL& reader )

{
@@ -140,17 +117,15 @@ resolveMeshIndexType( const Config::ParameterContainer& parameters, 
   return false;

}



template< template< typename Real, typename Device, typename Index, typename MeshType, typename ConfigTag, typename SolverStarter > class ProblemSetter,

          typename Real,

template< typename ConfigTag,

          typename Device,

          typename Index,

          typename ConfigTag >

          template< typename MeshType > class ProblemSetter >

   template< int MeshDimension,

             typename MeshRealType,

             typename MeshIndexType,

             typename, typename >

bool

MeshTypeResolver< ProblemSetter, Real, Device, Index, ConfigTag >::

MeshTypeResolver< ConfigTag, Device, ProblemSetter >::

resolveMeshType( const Config::ParameterContainer& parameters,

                 Meshes::Readers::TNL& reader )

{
@@ -158,59 +133,53 @@ resolveMeshType( const Config::ParameterContainer& parameters, 
   return false;

}



template< template< typename Real, typename Device, typename Index, typename MeshType, typename ConfigTag, typename SolverStarter > class ProblemSetter,

          typename Real,

template< typename ConfigTag,

          typename Device,

          typename Index,

          typename ConfigTag >

          template< typename MeshType > class ProblemSetter >

   template< int MeshDimension,

             typename MeshRealType,

             typename MeshIndexType,

             typename >

bool

MeshTypeResolver< ProblemSetter, Real, Device, Index, ConfigTag >::

MeshTypeResolver< ConfigTag, Device, ProblemSetter >::

resolveMeshType( const Config::ParameterContainer& parameters,

                 Meshes::Readers::TNL& reader )

{

   if( reader.getMeshType() == "Meshes::Grid" )

   {

      using MeshType = Meshes::Grid< MeshDimension, MeshRealType, Device, MeshIndexType >;

      // TODO: the mesh can be loaded here (this will be probably necessary for unstructured meshes anyway)

      return MeshResolverTerminator< ProblemSetter, Real, Device, Index, MeshType, ConfigTag >::run( parameters );

      return resolveTerminate< MeshType >( parameters, reader );

   }

   std::cerr << "Unknown mesh type " << reader.getMeshType() << "." << std::endl;

   return false;

}



template< template< typename Real, typename Device, typename Index, typename MeshType, typename ConfigTag, typename SolverStarter > class ProblemSetter,

          typename Real,

template< typename ConfigTag,

          typename Device,

          typename Index,

          typename MeshType,

          typename ConfigTag >

class MeshResolverTerminator< ProblemSetter, Real, Device, Index, MeshType, ConfigTag, false >

{

   public:

      static bool run( const Config::ParameterContainer& parameters )

          template< typename MeshType > class ProblemSetter >

   template< typename MeshType,

             typename, typename >

bool

MeshTypeResolver< ConfigTag, Device, ProblemSetter >::

resolveTerminate( const Config::ParameterContainer& parameters,

                  Meshes::Readers::TNL& reader )

{

   std::cerr << "The mesh type " << TNL::getType< MeshType >() << " is not supported." << std::endl;

   return false;

};

};



template< template< typename Real, typename Device, typename Index, typename MeshType, typename ConfigTag, typename SolverStarter > class ProblemSetter,

          typename Real,

template< typename ConfigTag,

          typename Device,

          typename Index,

          typename MeshType,

          typename ConfigTag >

class MeshResolverTerminator< ProblemSetter, Real, Device, Index, MeshType, ConfigTag, true >

{

   public:

      static bool run( const Config::ParameterContainer& parameters )

          template< typename MeshType > class ProblemSetter >

   template< typename MeshType,

             typename >

bool

MeshTypeResolver< ConfigTag, Device, ProblemSetter >::

resolveTerminate( const Config::ParameterContainer& parameters,

                  Meshes::Readers::TNL& reader )

{

         return ProblemSetter< Real, Device, Index, MeshType, ConfigTag, SolverStarter< ConfigTag > >::run( parameters );

      }

   // TODO: the mesh can be loaded here (this will be probably necessary for unstructured meshes anyway)

   return ProblemSetter< MeshType >::run( parameters );

};



} // namespace Solvers

src/TNL/Solvers/SolverInitiator_impl.h

+6 −1
Original line number Diff line number Diff line
@@ -20,6 +20,7 @@ 
#include <TNL/Solvers/Linear/CG.h>

#include <TNL/Solvers/Linear/BICGStab.h>

#include <TNL/Solvers/Linear/GMRES.h>

#include <TNL/Solvers/SolverStarter.h>

#include <TNL/Meshes/DummyMesh.h>



namespace TNL {
@@ -204,10 +205,14 @@ template< template< typename Real, typename Device, typename Index, typename Mes 
          typename ConfigTag >

class SolverInitiatorMeshResolver< ProblemSetter, Real, Device, Index, ConfigTag, true >

{

   // wrapper for MeshTypeResolver

   template< typename MeshType >

   using ProblemSetterWrapper = ProblemSetter< Real, Device, Index, MeshType, ConfigTag, SolverStarter< ConfigTag > >;



   public:

      static bool run( const Config::ParameterContainer& parameters )

      {

         return MeshTypeResolver< ProblemSetter, Real, Device, Index, ConfigTag >::run( parameters );

         return MeshTypeResolver< ConfigTag, Device, ProblemSetterWrapper >::run( parameters );

      }

};