Converter for Gmsh files. More...

#include <OutputGmsh.h>

Inheritance diagram for Nektar::Utilities::OutputGmsh:

Collaboration diagram for Nektar::Utilities::OutputGmsh:

Public Member Functions
	OutputGmsh (NekMeshUtils::MeshSharedPtr m)

virtual	~OutputGmsh ()

virtual void	Process ()
	Write mesh to output file. More...

Public Member Functions inherited from Nektar::NekMeshUtils::OutputModule
NEKMESHUTILS_EXPORT	OutputModule (MeshSharedPtr p_m)

NEKMESHUTILS_EXPORT void	OpenStream ()
	Open a file for output. More...

Public Member Functions inherited from Nektar::NekMeshUtils::Module
NEKMESHUTILS_EXPORT	Module (MeshSharedPtr p_m)

NEKMESHUTILS_EXPORT void	RegisterConfig (std::string key, std::string value)
	Register a configuration option with a module. More...

NEKMESHUTILS_EXPORT void	PrintConfig ()
	Print out all configuration options for a module. More...

NEKMESHUTILS_EXPORT void	SetDefaults ()
	Sets default configuration options for those which have not been set. More...

NEKMESHUTILS_EXPORT MeshSharedPtr	GetMesh ()

virtual NEKMESHUTILS_EXPORT void	ProcessVertices ()
	Extract element vertices. More...

virtual NEKMESHUTILS_EXPORT void	ProcessEdges (bool ReprocessEdges=true)
	Extract element edges. More...

virtual NEKMESHUTILS_EXPORT void	ProcessFaces (bool ReprocessFaces=true)
	Extract element faces. More...

virtual NEKMESHUTILS_EXPORT void	ProcessElements ()
	Generate element IDs. More...

virtual NEKMESHUTILS_EXPORT void	ProcessComposites ()
	Generate composites. More...

virtual NEKMESHUTILS_EXPORT void	ClearElementLinks ()

Static Public Member Functions
static boost::shared_ptr< Module >	create (NekMeshUtils::MeshSharedPtr m)
	Creates an instance of this class. More...

Static Public Attributes
static NekMeshUtils::ModuleKey	className

Private Attributes
boost::unordered_map < NekMeshUtils::ElmtConfig, unsigned int, ElmtConfigHash >	elmMap

Additional Inherited Members
Protected Member Functions inherited from Nektar::NekMeshUtils::Module
NEKMESHUTILS_EXPORT void	ReorderPrisms (PerMap &perFaces)
	Reorder node IDs so that prisms and tetrahedra are aligned correctly. More...

NEKMESHUTILS_EXPORT void	PrismLines (int prism, PerMap &perFaces, std::set< int > &prismsDone, std::vector< ElementSharedPtr > &line)

Protected Attributes inherited from Nektar::NekMeshUtils::OutputModule
io::filtering_ostream	m_mshFile
	Output stream. More...

std::ofstream	m_mshFileStream
	Input stream. More...

Protected Attributes inherited from Nektar::NekMeshUtils::Module
MeshSharedPtr	m_mesh
	Mesh object. More...

std::map< std::string, ConfigOption >	m_config
	List of configuration values. More...

Detailed Description

Converter for Gmsh files.

Definition at line 70 of file OutputGmsh.h.

Constructor & Destructor Documentation

Nektar::Utilities::OutputGmsh::OutputGmsh ( NekMeshUtils::MeshSharedPtr m )

Definition at line 56 of file OutputGmsh.cpp.

References elmMap, Nektar::Utilities::InputGmsh::GenElmMap(), Nektar::iterator, and Nektar::NekMeshUtils::Module::m_config.

                                       : OutputModule(m)
 {
     map<unsigned int, ElmtConfig> igelmap = InputGmsh::GenElmMap();
     map<unsigned int, ElmtConfig>::iterator it;
 
     // Populate #InputGmsh::elmMap and use this to construct an
     // inverse mapping from %ElmtConfig to Gmsh ID.
     for (it = igelmap.begin(); it != igelmap.end(); ++it)
     {
         elmMap[it->second] = it->first;
     }
 
     m_config["order"] = ConfigOption(false, "-1", "Enforce a polynomial order");
 }

Nektar::Utilities::OutputGmsh::~OutputGmsh ( )

virtual

Definition at line 71 of file OutputGmsh.cpp.

72 {

73 }

Member Function Documentation

static boost::shared_ptr<Module> Nektar::Utilities::OutputGmsh::create ( NekMeshUtils::MeshSharedPtr m )

inlinestatic

Creates an instance of this class.

Definition at line 74 of file OutputGmsh.h.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr().

                                                                        {
         return MemoryManager<OutputGmsh>::AllocateSharedPtr(m);
     }

void Nektar::Utilities::OutputGmsh::Process ( )

virtual

Write mesh to output file.

Process a mesh to output to Gmsh MSH format.

Gmsh output is fairly straightforward. The file first contains a list of nodes, followed by a list of elements. Since Mesh::vertexSet only contains vertices of the linear elements, we first loop over the elements so that any high-order vertices can be enumerated and then added to the node list. We then print out the list of nodes and finally print the element list.

Implements Nektar::NekMeshUtils::Module.

Definition at line 85 of file OutputGmsh.cpp.

 {
     if (m_mesh->m_verbose)
     {
         cout << "OutputGmsh: Writing file..." << endl;
     }
 
     boost::unordered_map<int, vector<int> > orderingMap;
     boost::unordered_map<int, vector<int> >::iterator oIt;
 
     // Open the file stream.
     OpenStream();
 
     // Write MSH header
     m_mshFile << "$MeshFormat" << endl
               << "2.2 0 8" << endl
               << "$EndMeshFormat" << endl;
 
     int id = m_mesh->m_vertexSet.size();
     vector<ElementSharedPtr> toComplete;
 
     int order = m_config["order"].as<int>();
 
     if (order != -1)
     {
         if (m_mesh->m_verbose)
         {
             cout << "Making mesh of order " << order << endl;
         }
     }
     else
     {
         // Do first pass over elements of expansion dimension to determine
         // which elements need completion.
         for (int i = 0; i < m_mesh->m_element[m_mesh->m_expDim].size(); ++i)
         {
             ElementSharedPtr e = m_mesh->m_element[m_mesh->m_expDim][i];
             if (e->GetMaxOrder() > order)
             {
                 order = e->GetMaxOrder();
             }
         }
     }
 
     // Convert this mesh into a high-order mesh of uniform order.
     if (m_mesh->m_verbose)
     {
         cout << "Mesh order of " << order << " detected" << endl;
     }
 
     m_mesh->MakeOrder(order, LibUtilities::ePolyEvenlySpaced);
 
     // Add edge- and face-interior nodes to vertex set.
     EdgeSet::iterator eIt;
     FaceSet::iterator fIt;
 
     for (eIt = m_mesh->m_edgeSet.begin(); eIt != m_mesh->m_edgeSet.end(); ++eIt)
     {
         m_mesh->m_vertexSet.insert((*eIt)->m_edgeNodes.begin(),
                                    (*eIt)->m_edgeNodes.end());
     }
 
     for (fIt = m_mesh->m_faceSet.begin(); fIt != m_mesh->m_faceSet.end(); ++fIt)
     {
         m_mesh->m_vertexSet.insert((*fIt)->m_faceNodes.begin(),
                                    (*fIt)->m_faceNodes.end());
     }
 
     // Do second pass over elements for volume nodes.
     for (int d = 1; d <= 3; ++d)
     {
         for (int i = 0; i < m_mesh->m_element[d].size(); ++i)
         {
             ElementSharedPtr e = m_mesh->m_element[d][i];
             vector<NodeSharedPtr> volList = e->GetVolumeNodes();
             m_mesh->m_vertexSet.insert(volList.begin(), volList.end());
         }
     }
 
     // Create ordered set of nodes - not required but looks nicer.
     std::set<NodeSharedPtr>::iterator it;
     std::set<NodeSharedPtr> tmp(m_mesh->m_vertexSet.begin(),
                                 m_mesh->m_vertexSet.end());
 
     // Write out nodes section.
     m_mshFile << "$Nodes" << endl << m_mesh->m_vertexSet.size() << endl;
 
     for (it = tmp.begin(); it != tmp.end(); ++it)
     {
         m_mshFile << (*it)->m_id+1 << " " << scientific << setprecision(10)
                   << (*it)->m_x << " " << (*it)->m_y << " " << (*it)->m_z
                   << endl;
     }
 
     m_mshFile << "$EndNodes" << endl;
 
     // Write elements section. All other sections are not currently
     // supported (physical names etc).
     m_mshFile << "$Elements" << endl;
     m_mshFile << m_mesh->GetNumEntities() << endl;
 
     id = 1;
 
     for (int d = 1; d <= 3; ++d)
     {
         for (int i = 0; i < m_mesh->m_element[d].size(); ++i, ++id)
         {
             ElementSharedPtr e = m_mesh->m_element[d][i];
 
             // First output element ID and type.
             int elmtType = elmMap[e->GetConf()];
             m_mshFile << id << " " << elmtType << " ";
 
             // Write out number of element tags and then the tags
             // themselves.
             vector<int> tags = e->GetTagList();
 
             if (tags.size() == 1)
             {
                 tags.push_back(tags[0]);
                 tags.push_back(0);
             }
 
             m_mshFile << tags.size() << " ";
 
             for (int j = 0; j < tags.size(); ++j)
             {
                 m_mshFile << tags[j] << " ";
             }
 
             // Finally write out node list. First write vertices, then
             // internal edge nodes, then face nodes.
             vector<NodeSharedPtr> nodeList = e->GetVertexList();
             vector<EdgeSharedPtr> edgeList = e->GetEdgeList();
             vector<FaceSharedPtr> faceList = e->GetFaceList();
             vector<NodeSharedPtr> volList  = e->GetVolumeNodes();
 
             tags.clear();
 
             for (int j = 0; j < nodeList.size(); ++j)
             {
                 tags.push_back(nodeList[j]->m_id);
             }
 
             // Process edge-interior points
             for (int j = 0; j < edgeList.size(); ++j)
             {
                 nodeList = edgeList[j]->m_edgeNodes;
 
                 if (e->GetEdgeOrient(j, edgeList[j]) == StdRegions::eForwards)
                 {
                     for (int k = 0; k < nodeList.size(); ++k)
                     {
                         tags.push_back(nodeList[k]->m_id);
                     }
                 }
                 else
                 {
                     for (int k = nodeList.size() - 1; k >= 0; --k)
                     {
                         tags.push_back(nodeList[k]->m_id);
                     }
                 }
             }
 
             // Process face-interior points
             for (int j = 0; j < faceList.size(); ++j)
             {
                 nodeList = faceList[j]->m_faceNodes;
                 int nFaceVerts = faceList[j]->m_vertexList.size();
                 vector<int> faceIds(nFaceVerts), volFaceIds(nFaceVerts);
 
                 for (int k = 0; k < nFaceVerts; ++k)
                 {
                     faceIds   [k] = faceList[j]->m_vertexList[k]->m_id;
                     volFaceIds[k] =
                         e->GetVertexList()[e->GetFaceVertex(j, k)]->m_id;
                 }
 
                 if (nFaceVerts == 3)
                 {
                     HOTriangle<NodeSharedPtr> hoTri(faceIds, nodeList);
                     hoTri.Align(volFaceIds);
                     for (int k = 0; k < hoTri.surfVerts.size(); ++k)
                     {
                         tags.push_back(hoTri.surfVerts[k]->m_id);
                     }
                 }
                 else
                 {
                     HOQuadrilateral<NodeSharedPtr> hoQuad(faceIds, nodeList);
                     hoQuad.Align(volFaceIds);
 
                     for (int k = 0; k < hoQuad.surfVerts.size(); ++k)
                     {
                         tags.push_back(hoQuad.surfVerts[k]->m_id);
                     }
                 }
             }
 
             // Process volume nodes
             for (int j = 0; j < volList.size(); ++j)
             {
                 tags.push_back(volList[j]->m_id);
             }
 
             // Construct inverse of input reordering. First try to find it in
             // our cache.
             oIt = orderingMap.find(elmtType);
 
             // If it's not created, then create it.
             if (oIt == orderingMap.end())
             {
                 vector<int> reordering = InputGmsh::CreateReordering(elmtType);
                 vector<int> inv(tags.size());
 
                 ASSERTL1(tags.size() == reordering.size(),
                          "Reordering map size not equal to element tags 1.");
 
                 for (int j = 0; j < tags.size(); ++j)
                 {
                     inv[reordering[j]] = j;
                 }
 
                 oIt = orderingMap.insert(make_pair(elmtType, inv)).first;
             }
 
             ASSERTL1(tags.size() == oIt->second.size(),
                      "Reordering map size not equal to element tags 2.");
 
             // Finally write element nodes.
             for (int j = 0; j < tags.size(); ++j)
             {
                 m_mshFile << tags[oIt->second[j]] + 1 << " ";
             }
 
             m_mshFile << endl;
         }
     }
     m_mshFile << "$EndElements" << endl;
 }

Member Data Documentation

ModuleKey Nektar::Utilities::OutputGmsh::className

static

Initial value:

=
    GetModuleFactory().RegisterCreatorFunction(ModuleKey(eOutputModule, "msh"),
                                               OutputGmsh::create,
                                               "Writes Gmsh msh file.")

Definition at line 77 of file OutputGmsh.h.

boost::unordered_map<NekMeshUtils::ElmtConfig, unsigned int, ElmtConfigHash> Nektar::Utilities::OutputGmsh::elmMap

private

Definition at line 86 of file OutputGmsh.h.

Referenced by OutputGmsh(), and Process().

Public Member Functions

Static Public Member Functions

Static Public Attributes

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation