#include <InputGmsh.h>

Inheritance diagram for Nektar::Utilities::InputGmsh:

Public Member Functions
	InputGmsh (NekMeshUtils::MeshSharedPtr m)
	Set up InputGmsh object. More...

virtual	~InputGmsh ()

virtual void	Process ()

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

NEKMESHUTILS_EXPORT void	OpenStream ()
	Open a file for input. 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=std::string())
	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 NekMeshUtils::ModuleSharedPtr	create (NekMeshUtils::MeshSharedPtr m)
	Creates an instance of this class. More...

static std::map< unsigned int, NekMeshUtils::ElmtConfig >	GenElmMap ()

static std::vector< int >	CreateReordering (unsigned int InputGmshEntity)
	Create a reordering map for a given element. More...

Static Public Attributes
static NekMeshUtils::ModuleKey	className
	ModuleKey for class. More...

static std::map< unsigned int, NekMeshUtils::ElmtConfig >	elmMap = InputGmsh::GenElmMap()

Private Member Functions
int	GetNnodes (unsigned int InputGmshEntity)

void	ReadNextNode ()

void	ReadNextNodeBlock (int nVertices=0)

void	SaveNode (int id, NekDouble x=0, NekDouble y=0, NekDouble z=0)

void	ReadNextElement (int tag=0, int elm_type=0)

Static Private Member Functions
static std::vector< int >	TriReordering (NekMeshUtils::ElmtConfig conf)
	Create a reordering for triangles. More...

static std::vector< int >	QuadReordering (NekMeshUtils::ElmtConfig conf)
	Create a reordering for quadrilaterals. More...

static std::vector< int >	HexReordering (NekMeshUtils::ElmtConfig conf)
	Create a reordering for hexahedra. More...

static std::vector< int >	PrismReordering (NekMeshUtils::ElmtConfig conf)
	Create a reordering for prisms. More...

static std::vector< int >	TetReordering (NekMeshUtils::ElmtConfig conf)
	Create a reordering for tetrahedra. More...

static std::vector< int >	LineReordering (NekMeshUtils::ElmtConfig conf)

Private Attributes
NekDouble	m_version

int	m_prevId

std::map< int, int >	m_idMap

int	m_maxTagId

std::unordered_map< int, std::vector< int > >	m_orderingMap

Additional Inherited Members
Protected Member Functions inherited from Nektar::NekMeshUtils::InputModule
NEKMESHUTILS_EXPORT void	PrintSummary ()
	Print summary of elements. More...

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::InputModule
io::filtering_istream	m_mshFile
	Input stream. More...

std::ifstream	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 48 of file InputGmsh.h.

Constructor & Destructor Documentation

◆ InputGmsh()

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

Set up InputGmsh object.

Definition at line 700 of file InputGmsh.cpp.

     : InputModule(m), m_version(0.0), m_prevId(-1), m_maxTagId(-1)
 {
 }

◆ ~InputGmsh()

Nektar::Utilities::InputGmsh::~InputGmsh ( )

virtual

Definition at line 705 of file InputGmsh.cpp.

706 {

707 }

Member Function Documentation

◆ create()

static NekMeshUtils::ModuleSharedPtr Nektar::Utilities::InputGmsh::create ( NekMeshUtils::MeshSharedPtr m )

inlinestatic

Creates an instance of this class.

Definition at line 56 of file InputGmsh.h.

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

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

◆ CreateReordering()

vector< int > Nektar::Utilities::InputGmsh::CreateReordering ( unsigned int InputGmshEntity )

static

Create a reordering map for a given element.

Since Gmsh and Nektar++ have different vertex, edge and face orientations, we need to reorder the nodes in a Gmsh MSH file so that they work with the Nektar++ orderings, since this is what is used in the elements defined in the converter.

Definition at line 1218 of file InputGmsh.cpp.

References Nektar::LibUtilities::eHexahedron, elmMap, Nektar::LibUtilities::ePrism, Nektar::LibUtilities::eQuadrilateral, Nektar::LibUtilities::eSegment, Nektar::LibUtilities::eTetrahedron, Nektar::LibUtilities::eTriangle, HexReordering(), LineReordering(), PrismReordering(), QuadReordering(), TetReordering(), and TriReordering().

Referenced by Nektar::Utilities::OutputGmsh::Process(), and ReadNextElement().

 {
     auto it = elmMap.find(InputGmshEntity);
 
     if (it == elmMap.end())
     {
         cerr << "Unknown element type " << InputGmshEntity << endl;
         abort();
     }
 
     // For specific elements, call the appropriate function to perform
     // the renumbering.
     switch (it->second.m_e)
     {
         case LibUtilities::eTriangle:
             return TriReordering(it->second);
             break;
         case LibUtilities::eQuadrilateral:
             return QuadReordering(it->second);
             break;
         case LibUtilities::eTetrahedron:
             return TetReordering(it->second);
             break;
         case LibUtilities::ePrism:
             return PrismReordering(it->second);
             break;
         case LibUtilities::eHexahedron:
             return HexReordering(it->second);
             break;
         case LibUtilities::eSegment:
             return LineReordering(it->second);
         default:
             break;
     }
 
     // Default: no reordering.
     vector<int> returnVal;
     return returnVal;
 }

◆ GenElmMap()

std::map< unsigned int, ElmtConfig > Nektar::Utilities::InputGmsh::GenElmMap ( )

static

Definition at line 1890 of file InputGmsh.cpp.

References Nektar::LibUtilities::eHexahedron, Nektar::ePoint, Nektar::LibUtilities::ePrism, Nektar::LibUtilities::ePyramid, Nektar::LibUtilities::eQuadrilateral, Nektar::LibUtilities::eSegment, Nektar::LibUtilities::eTetrahedron, and Nektar::LibUtilities::eTriangle.

Referenced by Nektar::Utilities::OutputGmsh::OutputGmsh().

 {
     using namespace LibUtilities;
     std::map<unsigned int, ElmtConfig> tmp;
 
     //                    Elmt type,   order,  face, volume
     tmp[  1] = ElmtConfig(eSegment,        1, false, false);
     tmp[  2] = ElmtConfig(eTriangle,       1, false, false);
     tmp[  3] = ElmtConfig(eQuadrilateral,  1, false, false);
     tmp[  4] = ElmtConfig(eTetrahedron,    1, false, false);
     tmp[  5] = ElmtConfig(eHexahedron,     1, false, false);
     tmp[  6] = ElmtConfig(ePrism,          1, false, false);
     tmp[  7] = ElmtConfig(ePyramid,        1, false, false);
     tmp[  8] = ElmtConfig(eSegment,        2,  true, false);
     tmp[  9] = ElmtConfig(eTriangle,       2, false, false);
     tmp[ 10] = ElmtConfig(eQuadrilateral,  2,  true, false);
     tmp[ 11] = ElmtConfig(eTetrahedron,    2, false, false);
     tmp[ 12] = ElmtConfig(eHexahedron,     2,  true,  true);
     tmp[ 13] = ElmtConfig(ePrism,          2,  true, false);
     tmp[ 14] = ElmtConfig(ePyramid,        2,  true, false);
     tmp[ 15] = ElmtConfig(ePoint,          1, false, false);
     tmp[ 16] = ElmtConfig(eQuadrilateral,  2, false, false);
     tmp[ 17] = ElmtConfig(eHexahedron,     2, false, false);
     tmp[ 18] = ElmtConfig(ePrism,          2, false, false);
     tmp[ 19] = ElmtConfig(ePyramid,        2, false, false);
     tmp[ 20] = ElmtConfig(eTriangle,       3, false, false);
     tmp[ 21] = ElmtConfig(eTriangle,       3,  true, false);
     tmp[ 22] = ElmtConfig(eTriangle,       4, false, false);
     tmp[ 23] = ElmtConfig(eTriangle,       4,  true, false);
     tmp[ 24] = ElmtConfig(eTriangle,       5, false, false);
     tmp[ 25] = ElmtConfig(eTriangle,       5,  true, false);
     tmp[ 26] = ElmtConfig(eSegment,        3,  true, false);
     tmp[ 27] = ElmtConfig(eSegment,        4,  true, false);
     tmp[ 28] = ElmtConfig(eSegment,        5,  true, false);
     tmp[ 29] = ElmtConfig(eTetrahedron,    3,  true, false);
     tmp[ 30] = ElmtConfig(eTetrahedron,    4,  true,  true);
     tmp[ 31] = ElmtConfig(eTetrahedron,    5,  true,  true);
     tmp[ 32] = ElmtConfig(eTetrahedron,    4,  true, false);
     tmp[ 33] = ElmtConfig(eTetrahedron,    5,  true, false);
     tmp[ 36] = ElmtConfig(eQuadrilateral,  3,  true, false);
     tmp[ 37] = ElmtConfig(eQuadrilateral,  4,  true, false);
     tmp[ 38] = ElmtConfig(eQuadrilateral,  5,  true, false);
     tmp[ 39] = ElmtConfig(eQuadrilateral,  3, false, false);
     tmp[ 40] = ElmtConfig(eQuadrilateral,  4, false, false);
     tmp[ 41] = ElmtConfig(eQuadrilateral,  5, false, false);
     tmp[ 42] = ElmtConfig(eTriangle,       6,  true, false);
     tmp[ 43] = ElmtConfig(eTriangle,       7,  true, false);
     tmp[ 44] = ElmtConfig(eTriangle,       8,  true, false);
     tmp[ 45] = ElmtConfig(eTriangle,       9,  true, false);
     tmp[ 46] = ElmtConfig(eTriangle,      10,  true, false);
     tmp[ 47] = ElmtConfig(eQuadrilateral,  6,  true, false);
     tmp[ 48] = ElmtConfig(eQuadrilateral,  7,  true, false);
     tmp[ 49] = ElmtConfig(eQuadrilateral,  8,  true, false);
     tmp[ 50] = ElmtConfig(eQuadrilateral,  9,  true, false);
     tmp[ 51] = ElmtConfig(eQuadrilateral, 10,  true, false);
     tmp[ 52] = ElmtConfig(eTriangle,       6, false, false);
     tmp[ 53] = ElmtConfig(eTriangle,       7, false, false);
     tmp[ 54] = ElmtConfig(eTriangle,       8, false, false);
     tmp[ 55] = ElmtConfig(eTriangle,       9, false, false);
     tmp[ 56] = ElmtConfig(eTriangle,      10, false, false);
     tmp[ 57] = ElmtConfig(eQuadrilateral,  6, false, false);
     tmp[ 58] = ElmtConfig(eQuadrilateral,  7, false, false);
     tmp[ 59] = ElmtConfig(eQuadrilateral,  8, false, false);
     tmp[ 60] = ElmtConfig(eQuadrilateral,  9, false, false);
     tmp[ 61] = ElmtConfig(eQuadrilateral, 10, false, false);
     tmp[ 62] = ElmtConfig(eSegment,        6,  true, false);
     tmp[ 63] = ElmtConfig(eSegment,        7,  true, false);
     tmp[ 64] = ElmtConfig(eSegment,        8,  true, false);
     tmp[ 65] = ElmtConfig(eSegment,        9,  true, false);
     tmp[ 66] = ElmtConfig(eSegment,       10,  true, false);
     tmp[ 71] = ElmtConfig(eTetrahedron,    6,  true,  true);
     tmp[ 72] = ElmtConfig(eTetrahedron,    7,  true,  true);
     tmp[ 73] = ElmtConfig(eTetrahedron,    8,  true,  true);
     tmp[ 74] = ElmtConfig(eTetrahedron,    9,  true,  true);
     tmp[ 75] = ElmtConfig(eTetrahedron,   10,  true,  true);
     tmp[ 79] = ElmtConfig(eTetrahedron,    6,  true, false);
     tmp[ 80] = ElmtConfig(eTetrahedron,    7,  true, false);
     tmp[ 81] = ElmtConfig(eTetrahedron,    8,  true, false);
     tmp[ 82] = ElmtConfig(eTetrahedron,    9,  true, false);
     tmp[ 83] = ElmtConfig(eTetrahedron,   10,  true, false);
     tmp[ 90] = ElmtConfig(ePrism,          3,  true,  true);
     tmp[ 91] = ElmtConfig(ePrism,          4,  true,  true);
     tmp[ 92] = ElmtConfig(eHexahedron,     3,  true,  true);
     tmp[ 93] = ElmtConfig(eHexahedron,     4,  true,  true);
     tmp[ 94] = ElmtConfig(eHexahedron,     5,  true,  true);
     tmp[ 95] = ElmtConfig(eHexahedron,     6,  true,  true);
     tmp[ 96] = ElmtConfig(eHexahedron,     7,  true,  true);
     tmp[ 97] = ElmtConfig(eHexahedron,     8,  true,  true);
     tmp[ 98] = ElmtConfig(eHexahedron,     9,  true,  true);
     tmp[ 99] = ElmtConfig(eHexahedron,     3,  true, false);
     tmp[100] = ElmtConfig(eHexahedron,     4,  true, false);
     tmp[101] = ElmtConfig(eHexahedron,     5,  true, false);
     tmp[102] = ElmtConfig(eHexahedron,     6,  true, false);
     tmp[103] = ElmtConfig(eHexahedron,     7,  true, false);
     tmp[104] = ElmtConfig(eHexahedron,     8,  true, false);
     tmp[105] = ElmtConfig(eHexahedron,     9,  true, false);
     tmp[106] = ElmtConfig(ePrism,          5,  true,  true);
     tmp[107] = ElmtConfig(ePrism,          6,  true,  true);
     tmp[108] = ElmtConfig(ePrism,          7,  true,  true);
     tmp[109] = ElmtConfig(ePrism,          8,  true,  true);
     tmp[110] = ElmtConfig(ePrism,          9,  true,  true);
     tmp[111] = ElmtConfig(ePrism,          3,  true, false);
     tmp[112] = ElmtConfig(ePrism,          4,  true, false);
     tmp[113] = ElmtConfig(ePrism,          5,  true, false);
     tmp[114] = ElmtConfig(ePrism,          6,  true, false);
     tmp[115] = ElmtConfig(ePrism,          7,  true, false);
     tmp[116] = ElmtConfig(ePrism,          8,  true, false);
     tmp[117] = ElmtConfig(ePrism,          9,  true, false);
     tmp[118] = ElmtConfig(ePyramid,        3,  true,  true);
     tmp[119] = ElmtConfig(ePyramid,        4,  true,  true);
     tmp[120] = ElmtConfig(ePyramid,        5,  true,  true);
     tmp[121] = ElmtConfig(ePyramid,        6,  true,  true);
     tmp[122] = ElmtConfig(ePyramid,        7,  true,  true);
     tmp[123] = ElmtConfig(ePyramid,        8,  true,  true);
     tmp[124] = ElmtConfig(ePyramid,        9,  true,  true);
     tmp[125] = ElmtConfig(ePyramid,        3,  true, false);
     tmp[126] = ElmtConfig(ePyramid,        4,  true, false);
     tmp[127] = ElmtConfig(ePyramid,        5,  true, false);
     tmp[128] = ElmtConfig(ePyramid,        6,  true, false);
     tmp[129] = ElmtConfig(ePyramid,        7,  true, false);
     tmp[130] = ElmtConfig(ePyramid,        7,  true, false);
     tmp[131] = ElmtConfig(ePyramid,        8,  true, false);
 
     return tmp;
 }

◆ GetNnodes()

int Nektar::Utilities::InputGmsh::GetNnodes ( unsigned int InputGmshEntity )

private

For a given msh ID, return the corresponding number of nodes.

Definition at line 1162 of file InputGmsh.cpp.

Referenced by ReadNextElement().

 {
     int nNodes;
 
     auto it = elmMap.find(InputGmshEntity);
 
     if (it == elmMap.end())
     {
         cerr << "Unknown element type " << InputGmshEntity << endl;
         abort();
     }
 
     switch (it->second.m_e)
     {
         case LibUtilities::ePoint:
             nNodes = Point::GetNumNodes(it->second);
             break;
         case LibUtilities::eSegment:
             nNodes = Line::GetNumNodes(it->second);
             break;
         case LibUtilities::eTriangle:
             nNodes = Triangle::GetNumNodes(it->second);
             break;
         case LibUtilities::eQuadrilateral:
             nNodes = Quadrilateral::GetNumNodes(it->second);
             break;
         case LibUtilities::eTetrahedron:
             nNodes = Tetrahedron::GetNumNodes(it->second);
             it->second.m_faceCurveType = LibUtilities::eNodalTriEvenlySpaced;
             break;
         case LibUtilities::ePyramid:
             nNodes = Pyramid::GetNumNodes(it->second);
             break;
         case LibUtilities::ePrism:
             nNodes = Prism::GetNumNodes(it->second);
             break;
         case LibUtilities::eHexahedron:
             nNodes = Hexahedron::GetNumNodes(it->second);
             break;
         default:
             cerr << "Unknown element type!" << endl;
             abort();
             break;
     }
 
     return nNodes;
 }

◆ HexReordering()

vector< int > Nektar::Utilities::InputGmsh::HexReordering ( NekMeshUtils::ElmtConfig conf )

staticprivate

Create a reordering for hexahedra.

Definition at line 1742 of file InputGmsh.cpp.

References Nektar::StdRegions::eDir1BwdDir1_Dir2FwdDir2, Nektar::StdRegions::eDir1FwdDir1_Dir2FwdDir2, Nektar::StdRegions::eDir1FwdDir2_Dir2FwdDir1, Nektar::Utilities::hexTensorNodeOrdering(), Nektar::NekMeshUtils::ElmtConfig::m_faceNodes, Nektar::NekMeshUtils::ElmtConfig::m_order, Nektar::NekMeshUtils::ElmtConfig::m_volumeNodes, and Nektar::Utilities::quadTensorNodeOrdering().

Referenced by CreateReordering().

 {
     const int order = conf.m_order;
     const int n     = order - 1;
     const int n2    = n * n;
     int i, j, k;
 
     vector<int> mapping;
 
     // Map taking Gmsh edges to Nektar++ edges.
     static int gmshToNekEdge[12] = {0, -3, 4, 1, 5, 2, 6, 7, 8, -11, 9, 10};
 
     // Push back vertices.
     mapping.resize(8);
     for (i = 0; i < 8; ++i)
     {
         mapping[i] = i;
     }
 
     if (order == 1)
     {
         return mapping;
     }
 
     // Curvilinear edges
     mapping.resize(8 + 12 * n);
 
     // Reorder edges.
     int cnt = 8, offset;
     for (i = 0; i < 12; ++i)
     {
         int edge = gmshToNekEdge[i];
         offset   = 8 + n * abs(edge);
 
         if (edge < 0)
         {
             for (int j = 0; j < n; ++j)
             {
                 mapping[offset + n - j - 1] = cnt++;
             }
         }
         else
         {
             for (int j = 0; j < n; ++j)
             {
                 mapping[offset + j] = cnt++;
             }
         }
     }
 
     if (conf.m_faceNodes == false || n2 == 0)
     {
         return mapping;
     }
 
     // Curvilinear face nodes.
     mapping.resize(8 + 12 * n + 6 * n2);
 
     // Map which takes Gmsh -> Nektar++ faces in the local element.
     static int gmsh2NekFace[6] = {0, 1, 4, 2, 3, 5};
 
     // Map which defines orientation between Gmsh and Nektar++ faces.
     StdRegions::Orientation faceOrient[6] = {
         StdRegions::eDir1FwdDir2_Dir2FwdDir1,
         StdRegions::eDir1FwdDir1_Dir2FwdDir2,
         StdRegions::eDir1FwdDir2_Dir2FwdDir1,
         StdRegions::eDir1FwdDir1_Dir2FwdDir2,
         StdRegions::eDir1BwdDir1_Dir2FwdDir2,
         StdRegions::eDir1FwdDir1_Dir2FwdDir2};
 
     for (i = 0; i < 6; ++i)
     {
         int face    = gmsh2NekFace[i];
         int offset2 = 8 + 12 * n + i * n2;
         offset      = 8 + 12 * n + face * n2;
 
         // Create a list of interior face nodes for this face only.
         vector<int> faceNodes(n2);
         for (j = 0; j < n2; ++j)
         {
             faceNodes[j] = offset2 + j;
         }
 
         // Now get the reordering of this face, which puts Gmsh
         // recursive ordering into Nektar++ row-by-row order.
         vector<int> tmp = quadTensorNodeOrdering(faceNodes, n);
 
         // Finally reorient the face according to the geometry
         // differences.
         if (faceOrient[i] == StdRegions::eDir1FwdDir1_Dir2FwdDir2)
         {
             // Orientation is the same, just copy.
             for (j = 0; j < n2; ++j)
             {
                 mapping[offset + j] = tmp[j];
             }
         }
         else if (faceOrient[i] == StdRegions::eDir1FwdDir2_Dir2FwdDir1)
         {
             // Tranposed faces
             for (j = 0; j < n; ++j)
             {
                 for (k = 0; k < n; ++k)
                 {
                     mapping[offset + j * n + k] = tmp[k * n + j];
                 }
             }
         }
         else if (faceOrient[i] == StdRegions::eDir1BwdDir1_Dir2FwdDir2)
         {
             for (j = 0; j < n; ++j)
             {
                 for (k = 0; k < n; ++k)
                 {
                     mapping[offset + j * n + k] = tmp[j * n + (n - k - 1)];
                 }
             }
         }
     }
 
     if (conf.m_volumeNodes == false)
     {
         return mapping;
     }
 
     const int totPoints = (order + 1) * (order + 1) * (order + 1);
     vector<int> interior;
     for (i = 8 + 12 * n + 6 * n2; i < totPoints; ++i)
     {
         interior.push_back(i);
     }
 
     interior = hexTensorNodeOrdering(interior, order - 1);
     mapping.insert(mapping.end(), interior.begin(), interior.end());
 
     return mapping;
 }

◆ LineReordering()

vector< int > Nektar::Utilities::InputGmsh::LineReordering ( NekMeshUtils::ElmtConfig conf )

staticprivate

Definition at line 1258 of file InputGmsh.cpp.

References Nektar::NekMeshUtils::ElmtConfig::m_order.

Referenced by CreateReordering().

 {
     const int order = conf.m_order;
 
     vector<int> mapping(order+1);
     for(int i = 0; i < order+1; i++)
     {
         mapping[i] = i;
     }
 
     return mapping;
 }

◆ PrismReordering()

vector< int > Nektar::Utilities::InputGmsh::PrismReordering ( NekMeshUtils::ElmtConfig conf )

staticprivate

Create a reordering for prisms.

Note that whilst Gmsh MSH files have the capability to support high-order prisms, presently Gmsh does not seem to be capable of generating higher than second-order prismatic meshes, so most of the following is untested.

Definition at line 1523 of file InputGmsh.cpp.

References Nektar::NekMeshUtils::HOTriangle< T >::Align(), Nektar::NekMeshUtils::HOQuadrilateral< T >::Align(), Nektar::NekMeshUtils::ElmtConfig::m_faceNodes, Nektar::NekMeshUtils::ElmtConfig::m_order, Nektar::NekMeshUtils::ElmtConfig::m_volumeNodes, Nektar::Utilities::prismTensorNodeOrdering(), Nektar::Utilities::quadTensorNodeOrdering(), Nektar::NekMeshUtils::HOTriangle< T >::surfVerts, Nektar::NekMeshUtils::HOQuadrilateral< T >::surfVerts, and Nektar::Utilities::triTensorNodeOrdering().

Referenced by CreateReordering().

 {
     const int order = conf.m_order;
     const int n     = order - 1;
 
     int i;
     vector<int> mapping(6);
 
     // To get from Gmsh -> Nektar++ prism, coordinates axes are
     // different; need to mirror in the triangular faces, and then
     // reorder vertices to make ordering anticlockwise on base quad.
     static int nekToGmshVerts[6] = {3, 4, 1, 0, 5, 2};
     // Inverse (gmsh vert -> Nektar++ vert): 3->0, 4->1, 1->2, 0->3, 5->4, 2->5
 
     for (i = 0; i < 6; ++i)
     {
         mapping[i] = nekToGmshVerts[i];
     }
 
     if (order == 1)
     {
         return mapping;
     }
 
     // Curvilinear edges.
     mapping.resize(6 + 9 * n);
 
     // Nektar++ edges:
     //   0 =    1 =    2 =    3 =    4 =    5 =    6 =    7 =    8 =
     //   {0,1}, {1,2}, {3,2}, {0,3}, {0,4}, {1,4}, {2,5}, {3,5}, {4,5}
     // Gmsh edges (from Geo/MPrism.h of Gmsh source):
     //   {0,1}, {0,2}, {0,3}, {1,2}, {1,4}, {2,5}, {3,4}, {3,5}, {4,5}
     // Apply inverse of gmshToNekVerts map:
     //   {3,2}, {3,5}, {3,0}, {2,5}, {2,1}, {5,4}, {0,1}, {0,4}, {1,4}
     // Nektar++ mapping (negative indicates reverse orientation):
     //   = 2    = 7    = -3   = 6    = -1   = -8   = 0    = 4    = 5
     static int gmshToNekEdge[9] = {2, 7, 3, 6, 1, 8, 0, 4, 5};
     static int gmshToNekRev[9]  = {0, 0, 1, 0, 1, 1, 0, 0, 0};
 
     // Reorder edges.
     int offset, cnt = 6;
     for (i = 0; i < 9; ++i)
     {
         offset = 6 + n * gmshToNekEdge[i];
 
         if (gmshToNekRev[i])
         {
             for (int j = 0; j < n; ++j)
             {
                 mapping[offset + n - j - 1] = cnt++;
             }
         }
         else
         {
             for (int j = 0; j < n; ++j)
             {
                 mapping[offset + j] = cnt++;
             }
         }
     }
 
     if (conf.m_faceNodes == false)
     {
         return mapping;
     }
 
     int nTriInt  = n * (n - 1) / 2;
     int nQuadInt = n * n;
 
     // Nektar++ faces:
     //   0 = {0,1,2,3}, 1 = {0,1,4}, 2 = {1,2,5,4}, 3 = {3,2,5}, 4 = {0,3,5,4}
     // Gmsh faces (from Geo/MPrism.h of Gmsh source):
     //   {0,2,1}, {3,4,5}, {0,1,4,3}, {0,3,5,2}, {1,2,5,4}
     // Apply inverse of gmshToNekVerts map:
     //   {3,5,2}, {0,1,4}, {3,2,1,0}, {3,0,4,5}, {2,5,4,1}
     //   = 3      = 1      = 0        = 4        = 2
     // This gives gmsh -> Nektar++ faces:
     static int gmshToNekFace[5] = {3, 1, 0, 4, 2};
 
     // Face offsets
     vector<int> offsets(5), offsets2(5);
     offset = 6 + 9 * n;
 
     // Offsets in the gmsh order: face ordering is TTQQQ
     offsets[0] = offset;
     offsets[1] = offset + nTriInt;
     offsets[2] = offset + 2 * nTriInt;
     offsets[3] = offset + 2 * nTriInt + nQuadInt;
     offsets[4] = offset + 2 * nTriInt + 2 * nQuadInt;
 
     // Offsets in the Nektar++ order: face ordering is QTQTQ
     offsets2[0] = offset;
     offsets2[1] = offset + nQuadInt;
     offsets2[2] = offset + nQuadInt + nTriInt;
     offsets2[3] = offset + 2 * nQuadInt + nTriInt;
     offsets2[4] = offset + 2 * nQuadInt + 2 * nTriInt;
 
     mapping.resize(6 + 9 * n + 3 * nQuadInt + 2 * nTriInt);
 
     offset = 6 + 9 * n;
 
     vector<int> triVertId(3);
     triVertId[0] = 0;
     triVertId[1] = 1;
     triVertId[2] = 2;
 
     vector<int> quadVertId(4);
     quadVertId[0] = 0;
     quadVertId[1] = 1;
     quadVertId[2] = 2;
     quadVertId[3] = 3;
 
     for (i = 0; i < 5; ++i)
     {
         int face    = gmshToNekFace[i];
         int offset2 = offsets[i];
         offset      = offsets2[face];
 
         bool tri = i < 2;
         int nFacePts = tri ? nTriInt : nQuadInt;
 
         if (nFacePts == 0)
         {
             continue;
         }
 
         // Create a list of interior face nodes for this face only.
         vector<int> faceNodes(nFacePts);
         vector<int> toAlign(tri ? 3 : 4);
         for (int j = 0; j < nFacePts; ++j)
         {
             faceNodes[j] = offset2 + j;
         }
 
         if (tri)
         {
             // Now get the reordering of this face, which puts Gmsh
             // recursive ordering into Nektar++ row-by-row order.
             vector<int> tmp = triTensorNodeOrdering(faceNodes, n - 1);
             HOTriangle<int> hoTri(triVertId, tmp);
 
             // Apply reorientation
             if (i == 0)
             {
                 // Triangle verts {0,2,1} --> {0,1,2}
                 toAlign[0] = 0;
                 toAlign[1] = 2;
                 toAlign[2] = 1;
                 hoTri.Align(toAlign);
             }
 
             // Fill in mapping.
             for (int j = 0; j < nTriInt; ++j)
             {
                 mapping[offset + j] = hoTri.surfVerts[j];
             }
         }
         else
         {
             vector<int> tmp = quadTensorNodeOrdering(faceNodes, n);
             HOQuadrilateral<int> hoQuad(quadVertId, tmp);
 
             // Apply reorientation
             if (i == 2)
             {
                 toAlign[0] = 3;
                 toAlign[1] = 2;
                 toAlign[2] = 1;
                 toAlign[3] = 0;
             }
             else if (i == 3)
             {
                 toAlign[0] = 1;
                 toAlign[1] = 0;
                 toAlign[2] = 3;
                 toAlign[3] = 2;
             }
             else if (i == 4)
             {
                 toAlign[0] = 3;
                 toAlign[1] = 0;
                 toAlign[2] = 1;
                 toAlign[3] = 2;
             }
 
             hoQuad.Align(toAlign);
 
             // Fill in mapping.
             for (int j = 0; j < nQuadInt; ++j)
             {
                 mapping[offset + j] = hoQuad.surfVerts[j];
             }
         }
     }
 
     if (conf.m_volumeNodes == false)
     {
         return mapping;
     }
 
     // Interior points
     offset = offsets[4] + nQuadInt;
     vector<int> intPoints, tmp;
 
     for (int i = offset; i < (order+1) * (order+1) * (order+2) / 2; ++i)
     {
         intPoints.push_back(i);
     }
 
     // Reorder interior points
     tmp = prismTensorNodeOrdering(intPoints, order - 1);
     mapping.insert(mapping.end(), tmp.begin(), tmp.end());
 
     return mapping;
 }

◆ Process()

void Nektar::Utilities::InputGmsh::Process ( )

virtual

Gmsh file contains a list of nodes and their coordinates, along with a list of elements and those nodes which define them. We read in and store the list of nodes in #m_node and store the list of elements in #m_element. Each new element is supplied with a list of entries from m_node which defines the element. Finally some mesh statistics are printed.

Parameters

pFilename Filename of Gmsh file to read.

Implements Nektar::NekMeshUtils::Module.

Definition at line 728 of file InputGmsh.cpp.

 {
     // Open the file stream.
     OpenStream();
 
     m_mesh->m_expDim   = 0;
     m_mesh->m_spaceDim = 0;
     string line;
     int fileType      = 0;
     int nVBlocks      = 0;
     int nVertices     = 0;
     int nEBlocks      = 0;
     int nElements     = 0;
     int tag           = 0;
     int elm_type      = 0;
     int tmp           = 0;
 
     if (m_mesh->m_verbose)
     {
         cout << "InputGmsh: Start reading file..." << endl;
     }
 
     std::vector<std::map<int, GmshEntity>> entityMap(4);
 
     while (!m_mshFile.eof())
     {
         getline(m_mshFile, line);
         stringstream s(line);
         string word;
         s >> word;
 
         // Process file format.
         if (word == "$MeshFormat")
         {
             getline(m_mshFile, line);
             stringstream s(line);
             s >> m_version;
             s >> fileType;
             ASSERTL0(fileType == 0, "Cannot read binary Gmsh files.")
             ASSERTL0(m_version <= 4.1, ".msh file format versions greater than 4.1 are not currently supported.")
         }
         // Process entities (v4+)
         else if (word == "$Entities")
         {
             size_t nEntity[4];
             getline(m_mshFile, line);
             stringstream s(line);
 
             s >> nEntity[0] >> nEntity[1] >> nEntity[2] >> nEntity[3];
 
             for (int i = 0; i < 4; ++i)
             {
                 for (int j = 0; j < nEntity[i]; ++j)
                 {
                     getline(m_mshFile, line);
                     stringstream si(line);
                     GmshEntity ent;
 
                     int entityId;
                     si >> entityId >> ent.minX >> ent.minY >> ent.minZ;
 
                     if (i > 0)
                     {
                         si >> ent.maxX >> ent.maxY >> ent.maxZ;
                     }
 
                     int nPhysTags, tmp;
                     si >> nPhysTags;
 
                     for (int k = 0; k < nPhysTags; ++k)
                     {
                         si >> tmp;
                         ent.physicalTags.push_back(tmp);
                     }
 
                     entityMap[i][entityId] = ent;
                 }
             }
         }
         // Process nodes.
         else if (word == "$Nodes")
         {
             getline(m_mshFile, line);
             stringstream s(line);
 
             if (m_version >= 4.0)
             {
                 s >> nVBlocks;
 
                 for (int i = 0; i < nVBlocks; ++i)
                 {
                     getline(m_mshFile, line);
                     stringstream si(line);
                     si >> tmp >> tmp >> tmp >> nVertices;
 
                     if (m_version == 4.0)
                     {
                         for (int i = 0; i < nVertices; ++i)
                         {
                             ReadNextNode();
                         }
                     }
                     else if (m_version == 4.1)
                     {
                         ReadNextNodeBlock(nVertices);
                     }
                 }
             }
             else
             {
                 s >> nVertices;
 
                 for (int i = 0; i < nVertices; ++i)
                 {
                     ReadNextNode();
                 }
             }
         }
         // Process elements
         else if (word == "$Elements")
         {
             getline(m_mshFile, line);
             stringstream s(line);
 
             if (m_version >= 4.0)
             {
                 s >> nEBlocks;
 
                 for (int i = 0; i < nEBlocks; ++i)
                 {
                     getline(m_mshFile, line);
                     stringstream si(line);
 
                     int tagDim;
                     if (m_version == 4.0)
                     {
                         si >> tag >> tagDim >> elm_type >> nElements;
                     }
                     else
                     {
                         si >> tagDim >> tag >> elm_type >> nElements;
                     }
                     // Query tag in map & don't bother constructing non-physical
                     // surfaces.
                     std::vector<int> physIds = entityMap[tagDim][tag].physicalTags;
 
                     if (physIds.size() == 0)
                     {
                         for (int j = 0; j < nElements; ++j)
                         {
                             getline(m_mshFile, line);
                         }
                     }
                     else
                     {
                         tag = physIds[0];
                         for (int j = 0; j < nElements; ++j)
                         {
                             ReadNextElement(tag, elm_type);
                         }
                     }
 
                 }
             }
             else
             {
                 s >> nElements;
                 for (int i = 0; i < nElements; ++i)
                 {
                     ReadNextElement();
                 }
             }
         }
     }
     m_mshFile.reset();
 
     // Go through element and remap tags if necessary.
     map<int, map<LibUtilities::ShapeType, int> > compMap;
 
     for (int i = 0; i < m_mesh->m_element[m_mesh->m_expDim].size(); ++i)
     {
         ElementSharedPtr el          = m_mesh->m_element[m_mesh->m_expDim][i];
         LibUtilities::ShapeType type = el->GetConf().m_e;
 
         vector<int> tags = el->GetTagList();
         int tag          = tags[0];
 
         auto cIt = compMap.find(tag);
 
         if (cIt == compMap.end())
         {
             compMap[tag][type] = tag;
             continue;
         }
 
         // Reset tag for this element.
         auto sIt = cIt->second.find(type);
         if (sIt == cIt->second.end())
         {
             m_maxTagId++;
             cIt->second[type] = m_maxTagId;
             tags[0] = m_maxTagId;
             el->SetTagList(tags);
         }
         else if (sIt->second != tag)
         {
             tags[0] = sIt->second;
             el->SetTagList(tags);
         }
     }
 
     bool printInfo = false;
     for (auto &cIt : compMap)
     {
         if (cIt.second.size() > 1)
         {
             printInfo = true;
             break;
         }
     }
 
     if (printInfo)
     {
         cout << "Multiple elements in composite detected; remapped:" << endl;
         for (auto &cIt : compMap)
         {
             if (cIt.second.size() > 1)
             {
                 auto sIt = cIt.second.begin();
                 cout << "- Tag " << cIt.first << " => " << sIt->second << " ("
                      << LibUtilities::ShapeTypeMap[sIt->first] << ")";
                 sIt++;
 
                 for (; sIt != cIt.second.end(); ++sIt)
                 {
                     cout << ", " << sIt->second << " ("
                          << LibUtilities::ShapeTypeMap[sIt->first] << ")";
                 }
 
                 cout << endl;
             }
         }
     }
 
     // Process rest of mesh.
     ProcessVertices();
     ProcessEdges();
     ProcessFaces();
     ProcessElements();
     ProcessComposites();
 }

◆ QuadReordering()

vector< int > Nektar::Utilities::InputGmsh::QuadReordering ( NekMeshUtils::ElmtConfig conf )

staticprivate

Create a reordering for quadrilaterals.

Definition at line 1323 of file InputGmsh.cpp.

References Nektar::NekMeshUtils::ElmtConfig::m_faceNodes, Nektar::NekMeshUtils::ElmtConfig::m_order, and Nektar::Utilities::quadTensorNodeOrdering().

Referenced by CreateReordering().

 {
     const int order = conf.m_order;
     const int n     = order - 1;
 
     // Copy vertices.
     vector<int> mapping(4);
     for (int i = 0; i < 4; ++i)
     {
         mapping[i] = i;
     }
 
     if (order == 1)
     {
         return mapping;
     }
 
     // Curvilinear edges.
     mapping.resize(4 + 4 * n);
 
     for (int i = 4; i < 4 + 4 * n; ++i)
     {
         mapping[i] = i;
     }
 
     if (!conf.m_faceNodes)
     {
         return mapping;
     }
 
     // Interior nodes.
     vector<int> interior(n * n);
     for (int i = 0; i < interior.size(); ++i)
     {
         interior[i] = i + 4 + 4 * n;
     }
 
     if (interior.size() > 0)
     {
         interior = quadTensorNodeOrdering(interior, n);
     }
     mapping.insert(mapping.end(), interior.begin(), interior.end());
     return mapping;
 }

◆ ReadNextElement()

void Nektar::Utilities::InputGmsh::ReadNextElement	(	int	tag = `0`,
		int	elm_type = `0`
	)

private

Read in next element

Definition at line 1069 of file InputGmsh.cpp.

References Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::CreateInstance(), CreateReordering(), elmMap, Nektar::NekMeshUtils::GetElementFactory(), GetNnodes(), m_idMap, m_maxTagId, Nektar::NekMeshUtils::Module::m_mesh, Nektar::NekMeshUtils::InputModule::m_mshFile, m_orderingMap, and m_version.

Referenced by Process().

 {
     string line;
     getline(m_mshFile, line);
     stringstream st(line);
     int id = 0, num_tag = 0, num_nodes = 0;
 
     st >> id;
     id -= 1; // counter starts at 0
 
     if (m_version < 4.0)
     {
         st >> elm_type >> num_tag;
     }
 
     auto it = elmMap.find(elm_type);
     if (it == elmMap.end())
     {
         cerr << "Error: element type " << elm_type << " not supported" << endl;
         abort();
     }
 
     // Read element tags (version 2 only)
     vector<int> tags;
     for (int j = 0; j < num_tag; ++j)
     {
         int tag = 0;
         st >> tag;
         tags.push_back(tag);
     }
     if (m_version >= 4.0)
     {
         tags.push_back(tag);
     }
     tags.resize(1);
 
     m_maxTagId = max(m_maxTagId, tags[0]);
 
     // Read element node list
     vector<NodeSharedPtr> nodeList;
     num_nodes = GetNnodes(elm_type);
     for (int k = 0; k < num_nodes; ++k)
     {
         int node = 0;
         st >> node;
         node -= 1; // counter starts at 0
         if (!m_idMap.size())
         {
             nodeList.push_back(m_mesh->m_node[node]);
         }
         else
         {
             nodeList.push_back(m_mesh->m_node[m_idMap[node]]);
         }
     }
 
     // Look up reordering.
     auto oIt = m_orderingMap.find(elm_type);
 
     // If it's not created, then create it.
     if (oIt == m_orderingMap.end())
     {
         oIt =
             m_orderingMap.insert(make_pair(elm_type, CreateReordering(elm_type)))
                 .first;
     }
 
     // Apply reordering map where necessary.
     if (oIt->second.size() > 0)
     {
         vector<int> &mapping      = oIt->second;
         vector<NodeSharedPtr> tmp = nodeList;
         for (int i = 0; i < mapping.size(); ++i)
         {
             nodeList[i] = tmp[mapping[i]];
         }
     }
 
     // Create element
     ElementSharedPtr E = GetElementFactory().CreateInstance(
         it->second.m_e, it->second, nodeList, tags);
 
     // Determine mesh expansion dimension
     if (E->GetDim() > m_mesh->m_expDim)
     {
         m_mesh->m_expDim = E->GetDim();
     }
     m_mesh->m_element[E->GetDim()].push_back(E);
 }

◆ ReadNextNode()

void Nektar::Utilities::InputGmsh::ReadNextNode ( )

private

Read in next node

Definition at line 1009 of file InputGmsh.cpp.

References Nektar::NekMeshUtils::InputModule::m_mshFile, and SaveNode().

Referenced by Process().

 {
     string line;
     getline(m_mshFile, line);
     stringstream st(line);
     double x = 0, y = 0, z = 0;
     int id = 0;
     st >> id >> x >> y >> z;
 
     SaveNode(id, x, y, z);
 }

◆ ReadNextNodeBlock()

void Nektar::Utilities::InputGmsh::ReadNextNodeBlock ( int nVertices = 0 )

private

Read in next node block for v4 format

Definition at line 983 of file InputGmsh.cpp.

References Nektar::NekMeshUtils::InputModule::m_mshFile, and SaveNode().

Referenced by Process().

 {
     string line;
     double x = 0, y = 0, z = 0;
     vector<int> id(nVertices);
 
     for (int i = 0; i < nVertices; ++i)
     {
         getline(m_mshFile, line);
         stringstream st(line);
         st >> id[i];
     }
 
     for (int i = 0; i < nVertices; ++i)
     {
         getline(m_mshFile, line);
         stringstream st(line);
         st >> x >> y >> z;
 
         SaveNode(id[i], x, y, z);
     }
 }

◆ SaveNode()

void Nektar::Utilities::InputGmsh::SaveNode	(	int	id,
		NekDouble	x = `0`,
		NekDouble	y = `0`,
		NekDouble	z = `0`
	)

private

Save node into mesh

Definition at line 1024 of file InputGmsh.cpp.

References m_idMap, Nektar::NekMeshUtils::Module::m_mesh, m_prevId, and class_topology::Node.

Referenced by ReadNextNode(), and ReadNextNodeBlock().

 {
     if ((x * x) > 0.000001 && m_mesh->m_spaceDim < 1)
     {
         m_mesh->m_spaceDim = 1;
     }
     if ((y * y) > 0.000001 && m_mesh->m_spaceDim < 2)
     {
         m_mesh->m_spaceDim = 2;
     }
     if ((z * z) > 0.000001 && m_mesh->m_spaceDim < 3)
     {
         m_mesh->m_spaceDim = 3;
     }
 
     id -= 1; // counter starts at 0
 
     if (!m_idMap.size())
     {
         if (id - m_prevId == 1)
         {
             m_prevId = id;
         }
         else
         {
             // Build m_idMap so far
             for (int i = 0; i < m_mesh->m_node.size(); ++i)
             {
                 m_idMap[i] = i;
             }
 
             m_idMap[id] = m_mesh->m_node.size();
         }
     }
     else
     {
         m_idMap[id] = m_mesh->m_node.size();
     }
 
     m_mesh->m_node.push_back(std::shared_ptr<Node>(new Node(id, x, y, z)));
 }

◆ TetReordering()

vector< int > Nektar::Utilities::InputGmsh::TetReordering ( NekMeshUtils::ElmtConfig conf )

staticprivate

Create a reordering for tetrahedra.

Definition at line 1371 of file InputGmsh.cpp.

References Nektar::NekMeshUtils::HOTriangle< T >::Align(), Nektar::NekMeshUtils::ElmtConfig::m_faceNodes, Nektar::NekMeshUtils::ElmtConfig::m_order, Nektar::NekMeshUtils::ElmtConfig::m_volumeNodes, Nektar::NekMeshUtils::HOTriangle< T >::surfVerts, Nektar::Utilities::tetTensorNodeOrdering(), and Nektar::Utilities::triTensorNodeOrdering().

Referenced by CreateReordering().

 {
     const int order = conf.m_order;
     const int n     = order - 1;
     const int n2    = n * (n - 1) / 2;
 
     int i, j;
     vector<int> mapping(4);
 
     // Copy vertices.
     for (i = 0; i < 4; ++i)
     {
         mapping[i] = i;
     }
 
     if (order == 1)
     {
         return mapping;
     }
 
     // Curvilinear edges.
     mapping.resize(4 + 6 * n);
 
     // Curvilinear edges.
     static int gmshToNekEdge[6] = {0, 1, 2, 3, 5, 4};
     static int gmshToNekRev[6]  = {0, 0, 1, 1, 1, 1};
 
     // Reorder edges.
     int offset, cnt = 4;
     for (i = 0; i < 6; ++i)
     {
         offset = 4 + n * gmshToNekEdge[i];
 
         if (gmshToNekRev[i])
         {
             for (int j = 0; j < n; ++j)
             {
                 mapping[offset + n - j - 1] = cnt++;
             }
         }
         else
         {
             for (int j = 0; j < n; ++j)
             {
                 mapping[offset + j] = cnt++;
             }
         }
     }
 
     if (conf.m_faceNodes == false || n2 == 0)
     {
         return mapping;
     }
 
     // Curvilinear faces.
     mapping.resize(4 + 6 * n + 4 * n2);
 
     static int gmshToNekFace[4] = {0, 1, 3, 2};
 
     vector<int> triVertId(3);
     triVertId[0] = 0;
     triVertId[1] = 1;
     triVertId[2] = 2;
 
     // Loop over Gmsh faces
     for (i = 0; i < 4; ++i)
     {
         int face    = gmshToNekFace[i];
         int offset2 = 4 + 6 * n + i * n2;
         offset      = 4 + 6 * n + face * n2;
 
         // Create a list of interior face nodes for this face only.
         vector<int> faceNodes(n2);
         vector<int> toAlign(3);
         for (j = 0; j < n2; ++j)
         {
             faceNodes[j] = offset2 + j;
         }
 
         // Now get the reordering of this face, which puts Gmsh
         // recursive ordering into Nektar++ row-by-row order.
         vector<int> tmp = triTensorNodeOrdering(faceNodes, n - 1);
         HOTriangle<int> hoTri(triVertId, tmp);
 
         // Apply reorientation
         if (i == 0 || i == 2)
         {
             // Triangle verts {0,2,1} --> {0,1,2}
             toAlign[0] = 0;
             toAlign[1] = 2;
             toAlign[2] = 1;
             hoTri.Align(toAlign);
         }
         else if (i == 3)
         {
             // Triangle verts {1,2,0} --> {0,1,2}
             toAlign[0] = 1;
             toAlign[1] = 2;
             toAlign[2] = 0;
             hoTri.Align(toAlign);
         }
 
         // Fill in mapping.
         for (j = 0; j < n2; ++j)
         {
             mapping[offset + j] = hoTri.surfVerts[j];
         }
     }
 
     if (conf.m_volumeNodes == false)
     {
         return mapping;
     }
 
     const int nInt = (order - 3) * (order - 2) * (order - 1) / 6;
     if (nInt <= 0)
     {
         return mapping;
     }
 
     if (nInt == 1)
     {
         mapping.push_back(mapping.size());
         return mapping;
     }
 
     int ntot = (order+1)*(order+2)*(order+3)/6;
     vector<int> interior;
 
     for (int i = 4 + 6 * n + 4 * n2; i < ntot; ++i)
     {
         interior.push_back(i);
     }
 
     if (interior.size() > 0)
     {
         interior = tetTensorNodeOrdering(interior, order-3);
     }
 
     mapping.insert(mapping.end(), interior.begin(), interior.end());
 
     return mapping;
 }

◆ TriReordering()

vector< int > Nektar::Utilities::InputGmsh::TriReordering ( NekMeshUtils::ElmtConfig conf )

staticprivate

Create a reordering for triangles.

Definition at line 1274 of file InputGmsh.cpp.

References Nektar::NekMeshUtils::ElmtConfig::m_faceNodes, Nektar::NekMeshUtils::ElmtConfig::m_order, and Nektar::Utilities::triTensorNodeOrdering().

Referenced by CreateReordering().

 {
     const int order = conf.m_order;
     const int n     = order - 1;
 
     // Copy vertices.
     vector<int> mapping(3);
     for (int i = 0; i < 3; ++i)
     {
         mapping[i] = i;
     }
 
     if (order == 1)
     {
         return mapping;
     }
 
     // Curvilinear edges.
     mapping.resize(3 + 3 * n);
 
     for (int i = 3; i < 3 + 3 * n; ++i)
     {
         mapping[i] = i;
     }
 
     if (!conf.m_faceNodes)
     {
         return mapping;
     }
 
     // Interior nodes.
     vector<int> interior(n * (n - 1) / 2);
     for (int i = 0; i < interior.size(); ++i)
     {
         interior[i] = i + 3 + 3 * n;
     }
 
     if (interior.size() > 0)
     {
         interior = triTensorNodeOrdering(interior, n - 1);
     }
 
     mapping.insert(mapping.end(), interior.begin(), interior.end());
     return mapping;
 }

Member Data Documentation

◆ className

ModuleKey Nektar::Utilities::InputGmsh::className

static

Initial value:

= GetModuleFactory().RegisterCreatorFunction(

ModuleKey(eInputModule, "msh"), InputGmsh::create, "Reads Gmsh msh file.")

ModuleKey for class.

Definition at line 61 of file InputGmsh.h.

◆ elmMap

std::map< unsigned int, ElmtConfig > Nektar::Utilities::InputGmsh::elmMap = InputGmsh::GenElmMap()

static

Element map; takes a msh id to an ElmtConfig object.

Definition at line 67 of file InputGmsh.h.

Referenced by CreateReordering(), GetNnodes(), and ReadNextElement().

◆ m_idMap

std::map<int, int> Nektar::Utilities::InputGmsh::m_idMap

private

Definition at line 84 of file InputGmsh.h.

Referenced by ReadNextElement(), and SaveNode().

◆ m_maxTagId

int Nektar::Utilities::InputGmsh::m_maxTagId

private

Definition at line 86 of file InputGmsh.h.

Referenced by Process(), and ReadNextElement().

◆ m_orderingMap

std::unordered_map<int, std::vector<int> > Nektar::Utilities::InputGmsh::m_orderingMap

private

Definition at line 90 of file InputGmsh.h.

Referenced by ReadNextElement().

◆ m_prevId

int Nektar::Utilities::InputGmsh::m_prevId

private

Definition at line 82 of file InputGmsh.h.

Referenced by SaveNode().

◆ m_version

NekDouble Nektar::Utilities::InputGmsh::m_version

private

Definition at line 80 of file InputGmsh.h.

Referenced by Process(), and ReadNextElement().

Public Member Functions

Static Public Member Functions

Static Public Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ InputGmsh()

◆ ~InputGmsh()

Member Function Documentation

◆ create()

◆ CreateReordering()

◆ GenElmMap()

◆ GetNnodes()

◆ HexReordering()

◆ LineReordering()

◆ PrismReordering()

◆ Process()

◆ QuadReordering()

◆ ReadNextElement()

◆ ReadNextNode()

◆ ReadNextNodeBlock()

◆ SaveNode()

◆ TetReordering()

◆ TriReordering()

Member Data Documentation

◆ className

◆ elmMap

◆ m_idMap

◆ m_maxTagId

◆ m_orderingMap

◆ m_prevId

◆ m_version