Commit 83a8642d authored by Jakub Klinkovský's avatar Jakub Klinkovský
Browse files

Updated tnl-view for unstructured meshes

parent fc1ac94b

src/Tools/tnl-view.cpp

+50 −60
Original line number Diff line number Diff line
@@ -15,6 +15,50 @@ 
#include <TNL/Config/ParameterContainer.h>

#include <TNL/Meshes/DummyMesh.h>

#include <TNL/Meshes/Grid.h>

#include <TNL/Meshes/TypeResolver/TypeResolver.h>



struct TNLViewBuildConfigTag {};



namespace TNL {

namespace Meshes {

namespace BuildConfigTags {



/****

 * Turn off support for float and long double.

 */

template<> struct GridRealTag< TNLViewBuildConfigTag, float > { enum { enabled = false }; };

template<> struct GridRealTag< TNLViewBuildConfigTag, long double > { enum { enabled = false }; };



/****

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

 */

template<> struct GridIndexTag< TNLViewBuildConfigTag, short int >{ enum { enabled = false }; };

template<> struct GridIndexTag< TNLViewBuildConfigTag, long int >{ enum { enabled = false }; };



/****

 * Unstructured meshes.

 */

template<> struct MeshCellTopologyTag< TNLViewBuildConfigTag, MeshEdgeTopology > { enum { enabled = true }; };



// Meshes are enabled only for the world dimension equal to the cell dimension.

template< typename CellTopology, int WorldDimension >

struct MeshWorldDimensionTag< TNLViewBuildConfigTag, CellTopology, WorldDimension >

{ enum { enabled = ( WorldDimension == CellTopology::dimension ) }; };



// Meshes are enabled only for types explicitly listed below.

template< typename Real > struct MeshRealTag< TNLViewBuildConfigTag, Real > { enum { enabled = false }; };

template< typename GlobalIndex > struct MeshGlobalIndexTag< TNLViewBuildConfigTag, GlobalIndex > { enum { enabled = false }; };

template< typename LocalIndex > struct MeshLocalIndexTag< TNLViewBuildConfigTag, LocalIndex > { enum { enabled = false }; };

template< typename GlobalIndex, typename Id > struct MeshIdTag< TNLViewBuildConfigTag, GlobalIndex, Id > { enum { enabled = false }; };

template<> struct MeshRealTag< TNLViewBuildConfigTag, double > { enum { enabled = true }; };

template<> struct MeshGlobalIndexTag< TNLViewBuildConfigTag, int > { enum { enabled = true }; };

template<> struct MeshLocalIndexTag< TNLViewBuildConfigTag, short int > { enum { enabled = true }; };

template< typename GlobalIndex > struct MeshIdTag< TNLViewBuildConfigTag, GlobalIndex, void > { enum { enabled = false }; };

template< typename GlobalIndex > struct MeshIdTag< TNLViewBuildConfigTag, GlobalIndex, GlobalIndex > { enum { enabled = true }; };



} // namespace BuildConfigTags

} // namespace Meshes

} // namespace TNL



void setupConfig( Config::ConfigDescription& config )

{
@@ -55,64 +99,10 @@ int main( int argc, char* argv[] ) 
   if( ! parseCommandLine( argc, argv, conf_desc, parameters ) )

      return EXIT_FAILURE;





   int verbose = parameters. getParameter< int >( "verbose" );

   String meshFile = parameters.getParameter< String >( "mesh" );

   if( meshFile == "" )

   {

      //if( ! processFiles< DummyMesh< double, Devices::Host, int > >( parameters ) )

      //   return EXIT_FAILURE;

      //return EXIT_SUCCESS;

   }

   String meshType;

   if( ! getObjectType( meshFile, meshType ) )

   {

      std::cerr << "I am not able to detect the mesh type from the file " << meshFile << "." << std::endl;

      return EXIT_FAILURE;

   }

   std::cout << meshType << " detected in " << meshFile << " file." << std::endl;

   Containers::List< String > parsedMeshType;

   if( ! parseObjectType( meshType, parsedMeshType ) )

   {

      std::cerr << "Unable to parse the mesh type " << meshType << "." << std::endl;

      return EXIT_FAILURE;

   }

   if( parsedMeshType[ 0 ] == "Meshes::Grid" ||

       parsedMeshType[ 0 ] == "tnlGrid" )   //  TODO: remove deprecated type name

   {

      int dimensions = atoi( parsedMeshType[ 1 ].getString() );

      if( dimensions == 1 )

      {

         typedef Meshes::Grid< 1, double, Devices::Host, int > MeshType;

         if( ! processFiles< MeshType >( parameters ) )

            return EXIT_FAILURE;

      }

      if( dimensions == 2 )

      {

         typedef Meshes::Grid< 2, double, Devices::Host, int > MeshType;

         if( ! processFiles< MeshType >( parameters ) )

            return EXIT_FAILURE;

      }

      if( dimensions == 3 )

      {

         typedef Meshes::Grid< 3, double, Devices::Host, int > MeshType;

         if( ! processFiles< MeshType >( parameters ) )

            return EXIT_FAILURE;

      }

      return EXIT_SUCCESS;

   }

   if( parsedMeshType[ 0 ] == "Meshes::Mesh" )

   {

      /*String meshFile = parameters. getParameter< String >( "mesh" );

      struct MeshConfig : public MeshConfigBase< 2 >

      {

         typedef MeshTriangleTopology CellType;

      };

      Mesh< MeshConfig > mesh;

      if( ! mesh.load( meshFile ) )

         return EXIT_FAILURE;

      if( ! MeshWriterNetgen::writeMesh( "tnl-mesh.ng", mesh, true ) )

         return EXIT_FAILURE;*/

   }

   return EXIT_FAILURE;

   return ! TNL::Meshes::resolveMeshType< TNLViewBuildConfigTag,

                                          Devices::Host,

                                          FilesProcessor >

                                             ( meshFile,

                                                parameters );

}

src/Tools/tnl-view.h

+94 −134
Original line number Diff line number Diff line
@@ -117,7 +117,8 @@ bool setMeshFunctionRealType( const MeshPointer& meshPointer, 


template< typename MeshPointer,

          int EntityDimension,

          int VectorFieldSize >

          int VectorFieldSize,

          typename = typename std::enable_if< EntityDimension <= MeshPointer::ObjectType::getMeshDimension() >::type >

bool setMeshEntityType( const MeshPointer& meshPointer,

                        const String& inputFileName,

                        const Containers::List< String >& parsedObjectType,
@@ -133,69 +134,27 @@ bool setMeshEntityType( const MeshPointer& meshPointer, 
   return false;

}



template< typename MeshReal,

          typename MeshIndex,

          int VectorFieldSize >

bool setMeshEntityDimension( const SharedPointer< Meshes::Grid< 1, MeshReal, Devices::Host, MeshIndex > >& meshPointer,

                              const String& inputFileName,

                              const Containers::List< String >& parsedObjectType,

                              const Config::ParameterContainer& parameters )

{

   typedef Meshes::Grid< 1, MeshReal, Devices::Host, MeshIndex > Mesh;

   typedef SharedPointer< Mesh > MeshPointer;

   int meshEntityDimension = atoi( parsedObjectType[ 2 ].getString() );

   switch( meshEntityDimension )

   {

      case 0:

         return setMeshEntityType< MeshPointer, 0, VectorFieldSize >( meshPointer, inputFileName, parsedObjectType, parameters );

         break;      

      case 1:

         return setMeshEntityType< MeshPointer, 1, VectorFieldSize >( meshPointer, inputFileName, parsedObjectType, parameters );

         break;

      default:

         std::cerr << "Unsupported mesh functions entity dimension count " << meshEntityDimension << "." << std::endl;

         return false;

   }

}



template< typename MeshReal,

          typename MeshIndex,

          int VectorFieldSize >

bool setMeshEntityDimension( const SharedPointer< Meshes::Grid< 2, MeshReal, Devices::Host, MeshIndex > >& meshPointer,

template< typename MeshPointer,

          int EntityDimension,

          int VectorFieldSize,

          typename = typename std::enable_if< ( EntityDimension > MeshPointer::ObjectType::getMeshDimension() ) >::type,

          typename = void >

bool setMeshEntityType( const MeshPointer& meshPointer,

                        const String& inputFileName,

                        const Containers::List< String >& parsedObjectType,

                        const Config::ParameterContainer& parameters )

{

   typedef Meshes::Grid< 2, MeshReal, Devices::Host, MeshIndex > Mesh;

   typedef SharedPointer< Mesh > MeshPointer;

   int meshEntityDimension = atoi( parsedObjectType[ 2 ].getString() );

   switch( meshEntityDimension )

   {

      case 0:

         return setMeshEntityType< MeshPointer, 0, VectorFieldSize >( meshPointer, inputFileName, parsedObjectType, parameters );

         break;            

      case 1:

         return setMeshEntityType< MeshPointer, 1, VectorFieldSize >( meshPointer, inputFileName, parsedObjectType, parameters );

         break;

      case 2:

         return setMeshEntityType< MeshPointer, 2, VectorFieldSize >( meshPointer, inputFileName, parsedObjectType, parameters );

         break;

      default:

         std::cerr << "Unsupported mesh functions entity dimension count " << meshEntityDimension << "." << std::endl;

   std::cerr << "Unsupported mesh functions entity dimension: " << EntityDimension << "." << std::endl;

   return false;

}

}



template< typename MeshReal,

          typename MeshIndex,

          int VectorFieldSize >

bool setMeshEntityDimension( const SharedPointer< Meshes::Grid< 3, MeshReal, Devices::Host, MeshIndex > >& meshPointer,

template< int VectorFieldSize,

          typename MeshPointer >

bool setMeshEntityDimension( const MeshPointer& meshPointer,

                             const String& inputFileName,

                             const Containers::List< String >& parsedObjectType,

                             const Config::ParameterContainer& parameters )

{

   typedef Meshes::Grid< 3, MeshReal, Devices::Host, MeshIndex > Mesh;

   typedef SharedPointer< Mesh > MeshPointer;

   int meshEntityDimension = atoi( parsedObjectType[ 2 ].getString() );

   switch( meshEntityDimension )

   {
@@ -212,7 +171,7 @@ bool setMeshEntityDimension( const SharedPointer< Meshes::Grid< 3, MeshReal, Dev 
         return setMeshEntityType< MeshPointer, 3, VectorFieldSize >( meshPointer, inputFileName, parsedObjectType, parameters );

         break;

      default:

         std::cerr << "Unsupported mesh functions entity dimension count " << meshEntityDimension << "." << std::endl;

         std::cerr << "Unsupported mesh functions entity dimension: " << meshEntityDimension << "." << std::endl;

         return false;

   }

}
@@ -229,9 +188,7 @@ bool setMeshFunction( const MeshPointer& meshPointer, 
      std::cerr << "Incompatible mesh type for the mesh function " << inputFileName << "." << std::endl;

      return false;

   }

   typedef typename MeshPointer::ObjectType::RealType RealType;

   typedef typename MeshPointer::ObjectType::IndexType IndexType;

   return setMeshEntityDimension< RealType, IndexType, VectorFieldSize >( meshPointer, inputFileName, parsedObjectType, parameters );

   return setMeshEntityDimension< VectorFieldSize >( meshPointer, inputFileName, parsedObjectType, parameters );

}



template< typename MeshPointer >
@@ -314,7 +271,7 @@ bool convertObject( const MeshPointer& meshPointer, 
}



template< typename MeshPointer, typename Element, typename Real, typename Index >

bool setDimensions( const MeshPointer& meshPointer,

bool setDimension( const MeshPointer& meshPointer,

                    const String& inputFileName,

                    const Containers::List< String >& parsedObjectType,

                    const Config::ParameterContainer& parameters )
@@ -358,9 +315,9 @@ bool setIndexType( const MeshPointer& meshPointer, 
      indexType = parsedObjectType[ 3 ];



   if( indexType == "int" )

      return setDimensions< MeshPointer, Element, Real, int >( meshPointer, inputFileName, parsedObjectType, parameters );

      return setDimension< MeshPointer, Element, Real, int >( meshPointer, inputFileName, parsedObjectType, parameters );

   if( indexType == "long-int" )

      return setDimensions< MeshPointer, Element, Real, long int >( meshPointer, inputFileName, parsedObjectType, parameters );

      return setDimension< MeshPointer, Element, Real, long int >( meshPointer, inputFileName, parsedObjectType, parameters );

   std::cerr << "Unknown index type " << indexType << "." << std::endl;

   return false;

}
@@ -456,7 +413,9 @@ bool setElementType( const MeshPointer& meshPointer, 
}



template< typename Mesh >

bool processFiles( const Config::ParameterContainer& parameters )

struct FilesProcessor

{

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

   {

      int verbose = parameters. getParameter< int >( "verbose");

      String meshFile = parameters. getParameter< String >( "mesh" );
@@ -470,7 +429,7 @@ bool processFiles( const Config::ParameterContainer& parameters ) 
            std::cerr << "I am not able to load mesh from the file " << meshFile << "." << std::endl;

            return false;

         }

   meshPointer->writeMesh( "mesh.asy", "asymptote" );

      //meshPointer->writeMesh( "mesh.asy", "asymptote" );



      bool checkOutputFile = parameters. getParameter< bool >( "check-output-file" );

      Containers::List< String > inputFiles = parameters. getParameter< Containers::List< String > >( "input-files" );
@@ -534,5 +493,6 @@ bool processFiles( const Config::ParameterContainer& parameters ) 
        std::cout << std::endl;

      return ! error;

   }

};



#endif /* TNL_VIEW_H_ */