Feel++  0.91.4
Public Member Functions | List of all members
Feel::ImporterGmsh< MeshType > Class Template Reference

gmsh importer class More...

#include <importergmsh.hpp>

Inheritance diagram for Feel::ImporterGmsh< MeshType >:
Feel::Importer< MeshType > Feel::VisitorBase Feel::Visitor< MeshType >

Public Types

Typedefs
typedef super::mesh_type mesh_type
 
typedef super::point_type point_type
 
typedef super::node_type node_type
 
typedef super::edge_type edge_type
 
typedef super::face_type face_type
 
typedef super::element_type element_type
 
typedef mesh_type::face_iterator face_iterator
 
- Public Types inherited from Feel::Importer< MeshType >
typedef MeshType mesh_type
 
typedef mesh_type::point_type point_type
 
typedef point_type::node_type node_type
 
typedef mesh_type::edge_type edge_type
 
typedef mesh_type::face_type face_type
 
typedef mesh_type::element_type element_type
 
- Public Types inherited from Feel::Visitor< MeshType >
typedef void return_type
 

Public Member Functions

void setElementRegionAsPhysicalRegion (const bool param)
 
Constructors, destructor
 ImporterGmsh (WorldComm const &_worldcomm=WorldComm())
 
 ImporterGmsh (std::string const &_fname, std::string _version=FEELPP_GMSH_FORMAT_VERSION, WorldComm const &_worldcomm=WorldComm())
 
 ImporterGmsh (ImporterGmsh const &i)
 
 ~ImporterGmsh ()
 
Accessors
std::string version () const
 
boost::tuple< bool,
boost::tuple< bool, int > > 
isElementOnProcessor (std::vector< int > const &tags) const
 
Mutators
void setVersion (std::string const &version)
 
void setIgnorePhysicalGroup (int i)
 
void setIgnorePhysicalName (std::string s)
 
Methods
void visit (mesh_type *mesh)
 visit a data structure
 
void showMe () const
 
- Public Member Functions inherited from Feel::Importer< MeshType >
 Importer (MeshFormat const &_format=GMSH, WorldComm const &_worldcomm=WorldComm())
 
 Importer (std::string const &_filename, MeshFormat const &_format=GMSH, WorldComm const &_worldcomm=WorldComm())
 
void setFilename (std::string const &__filename)
 
void setFormat (MeshFormat const &__format)
 
std::string const & filename () const
 
MeshFormat format () const
 
WorldComm const & worldComm () const
 
- Public Member Functions inherited from Feel::Visitor< MeshType >
virtual ~Visitor ()
 virtual base destructor
 
return_type visit (MeshType &__t)
 visit a data structure
 

Static Public Attributes

Constants
static const uint16_type npoints_per_edge
 
static const uint16_type npoints_per_face
 
static const uint16_type npoints_per_element = element_type::numPoints
 

Detailed Description

template<typename MeshType>
class Feel::ImporterGmsh< MeshType >

gmsh importer class

the importer concept follows the visitor pattern

typename Mesh2D<LinearTetra> mesh_type;
mesh_type mesh;
ImporterGmsh<mesh_type> import( "mesh.msh");
mesh.accept( import );
Author
Christophe Prud'homme

Member Function Documentation

template<typename MeshType >
boost::tuple< bool, boost::tuple< bool, int > > Feel::ImporterGmsh< MeshType >::isElementOnProcessor ( std::vector< int > const &  tags) const
Returns
true if the element is on processor or is a ghost cell true if a ghost cell
template<typename MeshType>
void Feel::ImporterGmsh< MeshType >::setElementRegionAsPhysicalRegion ( const bool  param)
inline

setElementRegionAsPhysicalRegion(bool parameter)

change reading for importing specific meshes for which the gmsh reader consider the Physical flag as null

Referenced by Feel::BOOST_PARAMETER_FUNCTION().

template<typename MeshType>
std::string Feel::ImporterGmsh< MeshType >::version ( ) const
inline
Returns
the file format version

Member Data Documentation

template<typename MeshType>
const uint16_type Feel::ImporterGmsh< MeshType >::npoints_per_edge
static
Initial value:
= ( edge_type::numVertices*edge_type::nbPtsPerVertex+
edge_type::numEdges*edge_type::nbPtsPerEdge+
edge_type::numFaces*edge_type::nbPtsPerFace )
template<typename MeshType>
const uint16_type Feel::ImporterGmsh< MeshType >::npoints_per_face
static
Initial value:
= ( face_type::numVertices*face_type::nbPtsPerVertex+
face_type::numEdges*face_type::nbPtsPerEdge+
face_type::numFaces*face_type::nbPtsPerFace )