40 #include <boost/tuple/tuple.hpp>
64 std::map<unsigned int, ElmtConfig> InputGmsh::elmMap = InputGmsh::GenElmMap();
95 std::vector<int> nodeList;
98 nodeList.resize(nodes.size());
101 nodeList[0] = nodes[0];
104 nodeList[n - 1] = nodes[1];
105 nodeList[n * n - 1] = nodes[2];
106 nodeList[n * (n - 1)] = nodes[3];
108 for (
int i = 1; i < n - 1; ++i)
110 nodeList[i] = nodes[4 + i - 1];
112 for (
int i = 1; i < n - 1; ++i)
114 nodeList[n * n - 1 - i] = nodes[4 + 2 * (n - 2) + i - 1];
121 std::vector<int> interior((n - 2) * (n - 2));
123 nodes.begin() + 4 + 4 * (n - 2), nodes.end(), interior.begin());
127 for (
int j = 1; j < n - 1; ++j)
129 nodeList[j * n] = nodes[4 + 3 * (n - 2) + n - 2 - j];
130 for (
int i = 1; i < n - 1; ++i)
132 nodeList[j * n + i] = interior[(j - 1) * (n - 2) + (i - 1)];
134 nodeList[(j + 1) * n - 1] = nodes[4 + (n - 2) + j - 1];
172 std::vector<int> nodeList;
175 nodeList.resize(nodes.size());
178 nodeList[0] = nodes[0];
181 nodeList[n - 1] = nodes[1];
182 nodeList[n * (n + 1) / 2 - 1] = nodes[2];
187 for (
int i = 1; i < n - 1; ++i)
189 nodeList[i] = nodes[3 + i - 1];
190 nodeList[cnt] = nodes[3 + 3 * (n - 2) - i];
191 nodeList[cnt + n - i - 1] = nodes[3 + (n - 2) + i - 1];
199 std::vector<int> interior((n - 3) * (n - 2) / 2);
201 nodes.begin() + 3 + 3 * (n - 2), nodes.end(), interior.begin());
207 for (
int j = 1; j < n - 2; ++j)
209 for (
int i = 0; i < n - j - 2; ++i)
211 nodeList[cnt + i + 1] = interior[cnt2 + i];
221 typedef boost::tuple<int, int, int>
Mode;
226 if (a.get<0>() < b.get<0>())
230 if (a.get<0>() > b.get<0>())
234 if (a.get<1>() < b.get<1>())
238 if (a.get<1>() > b.get<1>())
242 if (a.get<2>() < b.get<2>())
287 std::vector<int> nodeList;
288 int nTri = n*(n+1)/2;
289 int nTet = n*(n+1)*(n+2)/6;
291 nodeList.resize(nodes.size());
292 nodeList[0] = nodes[0];
300 nodeList[n - 1] = nodes[1];
301 nodeList[nTri - 1] = nodes[2];
302 nodeList[nTet - 1] = nodes[3];
311 std::map<Mode, int, cmpop> tmp;
313 for (
int k = 0, cnt = 0; k < n; ++k)
315 for (
int j = 0; j < n - k; ++j)
317 for (
int i = 0; i < n - k - j; ++i)
319 tmp[
Mode(i,j,k)] = cnt++;
325 for (
int i = 1; i < n-1; ++i)
328 nodeList[tmp[
Mode(i,0,0)]] = nodes[4 + eI];
329 nodeList[tmp[
Mode(n-1-i,i,0)]] = nodes[4 + (n-2) + eI];
330 nodeList[tmp[
Mode(0,n-1-i,0)]] = nodes[4 + 2*(n-2) + eI];
331 nodeList[tmp[
Mode(0,0,n-1-i)]] = nodes[4 + 3*(n-2) + eI];
332 nodeList[tmp[
Mode(0,i,n-1-i)]] = nodes[4 + 4*(n-2) + eI];
333 nodeList[tmp[
Mode(i,0,n-1-i)]] = nodes[4 + 5*(n-2) + eI];
343 int nFacePts = (n-3)*(n-2)/2;
346 vector<vector<int> > tmpNodes(4);
347 int offset = 4 + 6*(n-2);
349 for (
int i = 0; i < 4; ++i)
351 tmpNodes[i].resize(nFacePts);
352 for (
int j = 0; j < nFacePts; ++j)
354 tmpNodes[i][j] = nodes[offset++];
362 vector<int> triVertId(3), toAlign(3);
373 hoTri.
Align(toAlign);
377 hoTri.
Align(toAlign);
386 hoTri.
Align(toAlign);
392 for (
int j = 1, cnt = 0; j < n-2; ++j)
394 for (
int i = 1; i < n-j-1; ++i, ++cnt)
396 nodeList[tmp[
Mode(i,j,0)]] = tmpNodes[0][cnt];
397 nodeList[tmp[
Mode(i,0,j)]] = tmpNodes[1][cnt];
398 nodeList[tmp[
Mode(n-1-i-j,i,j)]] = tmpNodes[3][cnt];
399 nodeList[tmp[
Mode(0,i,j)]] = tmpNodes[2][cnt];
409 vector<int> intNodes, tmpInt;
410 for (
int i = offset; i < nTet; ++i)
412 intNodes.push_back(nodes[i]);
416 for (
int k = 1, cnt = 0; k < n - 2; ++k)
418 for (
int j = 1; j < n - k - 1; ++j)
420 for (
int i = 1; i < n - k - j - 1; ++i)
422 nodeList[tmp[
Mode(i,j,k)]] = tmpInt[cnt++];
466 std::vector<int> nodeList;
473 nodeList.resize(nodes.size());
477 nodeList[0] = nodes[1];
478 nodeList[1] = nodes[0];
490 nodeList[0] = nodes[1];
491 nodeList[1] = nodes[4];
492 nodeList[2] = nodes[2];
493 nodeList[3] = nodes[5];
494 nodeList[4] = nodes[0];
495 nodeList[5] = nodes[3];
496 nodeList[6] = nodes[7];
497 nodeList[7] = nodes[8];
498 nodeList[8] = nodes[6];
501 ASSERTL0(n < 4,
"Prism Gmsh input and output is incomplete for orders "
543 std::vector<int> nodeList;
545 nodeList.resize(nodes.size());
546 nodeList[0] = nodes[0];
554 nodeList[n - 1] = nodes[1];
555 nodeList[n*n -1] = nodes[2];
556 nodeList[n*(n-1)] = nodes[3];
557 nodeList[n*n*(n-1)] = nodes[4];
558 nodeList[n - 1 + n*n*(n-1)] = nodes[5];
559 nodeList[n*n -1 + n*n*(n-1)] = nodes[6];
560 nodeList[n*(n-1) + n*n*(n-1)] = nodes[7];
567 int hexEdges[12][2] = {
568 { 0, 1 }, { n-1, n }, { n*n-1, -1 }, { n*(n-1), -n },
569 { 0, n*n }, { n-1, n*n }, { n*n - 1, n*n }, { n*(n-1), n*n },
570 { n*n*(n-1), 1 }, { n*n*(n-1) + n-1, n }, { n*n*n-1, -1 },
571 { n*n*(n-1) + n*(n-1), -n }
573 int hexFaces[6][3] = {
574 { 0, 1, n }, { 0, 1, n*n }, { n-1, n, n*n },
575 { n*(n-1), 1, n*n }, { 0, n, n*n }, { n*n*(n-1), 1, n }
577 int gmshToNekEdge[12] = {0, -3, 4, 1, 5, 2, 6, 7, 8, -11, 9, 10};
581 for (
int i = 0; i < 12; ++i)
583 int e = abs(gmshToNekEdge[i]);
585 if (gmshToNekEdge[i] >= 0)
587 for (
int j = 1; j < n-1; ++j)
589 nodeList[hexEdges[e][0] + j*hexEdges[e][1]] = nodes[offset++];
594 for (
int j = 1; j < n-1; ++j)
596 nodeList[hexEdges[e][0] + (n-j-1)*hexEdges[e][1]] = nodes[offset++];
602 int gmsh2NekFace[6] = {0, 1, 4, 2, 3, 5};
611 StdRegions::eDir1FwdDir1_Dir2FwdDir2};
613 for (i = 0; i < 6; ++i)
615 int n2 = (n-2)*(n-2);
616 int face = gmsh2NekFace[i];
617 offset = 8 + 12 * (n-2) + i * n2;
620 vector<int> faceNodes(n2);
621 for (j = 0; j < n2; ++j)
623 faceNodes[j] = nodes[offset + j];
641 for (j = 0; j < n-2; ++j)
643 for (k = 0; k < n-2; ++k)
645 tmp[j * (n-2) + k] = faceNodes[k * (n-2) + j];
651 for (j = 0; j < n-2; ++j)
653 for (k = 0; k < n-2; ++k)
655 tmp[j * (n-2) + k] = faceNodes[j * (n-2) + (n - k - 3)];
661 for (k = 1; k < n-1; ++k)
663 for (j = 1; j < n-1; ++j)
665 nodeList[hexFaces[face][0] + j*hexFaces[face][1] + k*hexFaces[face][2]]
666 = faceNodes[(k-1)*(n-2) + j-1];
672 vector<int> intNodes, tmpInt;
673 for (
int i = 8 + 12 * (n-2) + 6 * (n-2) * (n-2); i < n*n*n; ++i)
675 intNodes.push_back(nodes[i]);
681 for (
int k = 1, cnt = 0; k < n - 1; ++k)
683 for (
int j = 1; j < n - 1; ++j)
685 for (
int i = 1; i < n - 1; ++i)
687 nodeList[i + j * n + k * n * n] = tmpInt[cnt++];
737 boost::unordered_map<int, vector<int> > orderingMap;
738 boost::unordered_map<int, vector<int> >
::iterator oIt;
742 cout <<
"InputGmsh: Start reading file..." << endl;
748 stringstream s(line);
753 if (word ==
"$Nodes")
756 stringstream s(line);
759 for (
int i = 0; i < nVertices; ++i)
762 stringstream st(line);
763 double x = 0, y = 0, z = 0;
764 st >>
id >> x >> y >> z;
766 if ((x * x) > 0.000001 &&
m_mesh->m_spaceDim < 1)
770 if ((y * y) > 0.000001 &&
m_mesh->m_spaceDim < 2)
774 if ((z * z) > 0.000001 &&
m_mesh->m_spaceDim < 3)
781 if (
id - prevId != 1)
783 cerr <<
"Gmsh vertex ids should be contiguous" << endl;
788 boost::shared_ptr<Node>(
new Node(
id, x, y, z)));
792 else if (word ==
"$Elements")
795 stringstream s(line);
797 for (
int i = 0; i < nEntities; ++i)
800 stringstream st(line);
801 int id = 0, num_tag = 0, num_nodes = 0;
803 st >>
id >> elm_type >> num_tag;
806 it =
elmMap.find(elm_type);
809 cerr <<
"Error: element type " << elm_type
810 <<
" not supported" << endl;
816 for (
int j = 0; j < num_tag; ++j)
824 maxTagId = max(maxTagId, tags[0]);
827 vector<NodeSharedPtr> nodeList;
829 for (
int k = 0; k < num_nodes; ++k)
834 nodeList.push_back(
m_mesh->m_node[node]);
838 oIt = orderingMap.find(elm_type);
841 if (oIt == orderingMap.end())
843 oIt = orderingMap.insert(
848 if (oIt->second.size() > 0)
850 vector<int> &mapping = oIt->second;
851 vector<NodeSharedPtr> tmp = nodeList;
852 for (
int i = 0; i < mapping.size(); ++i)
854 nodeList[i] = tmp[mapping[i]];
860 it->second.m_e, it->second, nodeList, tags);
863 if (E->GetDim() >
m_mesh->m_expDim)
865 m_mesh->m_expDim = E->GetDim();
867 m_mesh->m_element[E->GetDim()].push_back(E);
874 map<int, map<LibUtilities::ShapeType, int> > compMap;
875 map<int, map<LibUtilities::ShapeType, int> >
::iterator cIt;
878 for (
int i = 0; i <
m_mesh->m_element[
m_mesh->m_expDim].size(); ++i)
883 vector<int> tags = el->GetTagList();
886 cIt = compMap.find(tag);
888 if (cIt == compMap.end())
890 compMap[tag][type] = tag;
895 sIt = cIt->second.find(type);
896 if (sIt == cIt->second.end())
899 cIt->second[type] = maxTagId;
901 el->SetTagList(tags);
903 else if (sIt->second != tag)
905 tags[0] = sIt->second;
906 el->SetTagList(tags);
910 bool printInfo =
false;
911 for (cIt = compMap.begin(); cIt != compMap.end(); ++cIt)
913 if (cIt->second.size() > 1)
922 cout <<
"Multiple elements in composite detected; remapped:" << endl;
923 for (cIt = compMap.begin(); cIt != compMap.end(); ++cIt)
925 if (cIt->second.size() > 1)
927 sIt = cIt->second.begin();
928 cout <<
"- Tag " << cIt->first <<
" => " << sIt->second <<
" ("
932 for (; sIt != cIt->second.end(); ++sIt)
934 cout <<
", " << sIt->second <<
" ("
959 it =
elmMap.find(InputGmshEntity);
963 cerr <<
"Unknown element type " << InputGmshEntity << endl;
967 switch (it->second.m_e)
995 cerr <<
"Unknown element type!" << endl;
1015 it =
elmMap.find(InputGmshEntity);
1019 cerr <<
"Unknown element type " << InputGmshEntity << endl;
1025 switch (it->second.m_e)
1049 vector<int> returnVal;
1055 const int order = conf.
m_order;
1057 vector<int> mapping(order+1);
1058 for(
int i = 0; i < order+1; i++)
1071 const int order = conf.
m_order;
1072 const int n = order - 1;
1075 vector<int> mapping(3);
1076 for (
int i = 0; i < 3; ++i)
1087 mapping.resize(3 + 3 * n);
1089 for (
int i = 3; i < 3 + 3 * n; ++i)
1100 vector<int> interior(n * (n - 1) / 2);
1101 for (
int i = 0; i < interior.size(); ++i)
1103 interior[i] = i + 3 + 3 * n;
1106 if (interior.size() > 0)
1111 mapping.insert(mapping.end(), interior.begin(), interior.end());
1120 const int order = conf.
m_order;
1121 const int n = order - 1;
1124 vector<int> mapping(4);
1125 for (
int i = 0; i < 4; ++i)
1136 mapping.resize(4 + 4 * n);
1138 for (
int i = 4; i < 4 + 4 * n; ++i)
1149 vector<int> interior(n * n);
1150 for (
int i = 0; i < interior.size(); ++i)
1152 interior[i] = i + 4 + 4 * n;
1155 if (interior.size() > 0)
1159 mapping.insert(mapping.end(), interior.begin(), interior.end());
1168 const int order = conf.
m_order;
1169 const int n = order - 1;
1170 const int n2 = n * (n - 1) / 2;
1173 vector<int> mapping(4);
1176 for (i = 0; i < 4; ++i)
1187 mapping.resize(4 + 6 * n);
1190 static int gmshToNekEdge[6] = {0, 1, 2, 3, 5, 4};
1191 static int gmshToNekRev[6] = {0, 0, 1, 1, 1, 1};
1194 int offset, cnt = 4;
1195 for (i = 0; i < 6; ++i)
1197 offset = 4 + n * gmshToNekEdge[i];
1199 if (gmshToNekRev[i])
1201 for (
int j = 0; j < n; ++j)
1203 mapping[offset + n - j - 1] = cnt++;
1208 for (
int j = 0; j < n; ++j)
1210 mapping[offset + j] = cnt++;
1221 mapping.resize(4 + 6 * n + 4 * n2);
1223 static int gmshToNekFace[4] = {0, 1, 3, 2};
1225 vector<int> triVertId(3);
1231 for (i = 0; i < 4; ++i)
1233 int face = gmshToNekFace[i];
1234 int offset2 = 4 + 6 * n + i * n2;
1235 offset = 4 + 6 * n + face * n2;
1238 vector<int> faceNodes(n2);
1239 vector<int> toAlign(3);
1240 for (j = 0; j < n2; ++j)
1242 faceNodes[j] = offset2 + j;
1251 if (i == 0 || i == 2)
1257 hoTri.
Align(toAlign);
1265 hoTri.
Align(toAlign);
1269 for (j = 0; j < n2; ++j)
1271 mapping[offset + j] = hoTri.
surfVerts[j];
1280 const int nInt = (order - 3) * (order - 2) * (order - 1) / 6;
1288 mapping.push_back(mapping.size());
1292 int ntot = (order+1)*(order+2)*(order+3)/6;
1293 vector<int> interior;
1295 for (
int i = 4 + 6 * n + 4 * n2; i < ntot; ++i)
1297 interior.push_back(i);
1300 if (interior.size() > 0)
1305 mapping.insert(mapping.end(), interior.begin(), interior.end());
1320 const int order = conf.
m_order;
1321 const int n = order - 1;
1324 vector<int> mapping(6);
1329 static int nekToGmshVerts[6] = {3, 4, 1, 0, 5, 2};
1332 for (i = 0; i < 6; ++i)
1334 mapping[i] = nekToGmshVerts[i];
1343 mapping.resize(6 + 9 * n);
1354 static int gmshToNekEdge[9] = {2, 7, 3, 6, 1, 8, 0, 4, 5};
1355 static int gmshToNekRev[9] = {0, 0, 1, 0, 1, 1, 0, 0, 0};
1358 int offset, cnt = 6;
1359 for (i = 0; i < 9; ++i)
1361 offset = 6 + n * gmshToNekEdge[i];
1363 if (gmshToNekRev[i])
1365 for (
int j = 0; j < n; ++j)
1367 mapping[offset + n - j - 1] = cnt++;
1372 for (
int j = 0; j < n; ++j)
1374 mapping[offset + j] = cnt++;
1384 int nTriInt = n * (n - 1) / 2;
1385 int nQuadInt = n * n;
1395 static int gmshToNekFace[5] = {3, 1, 0, 4, 2};
1398 vector<int> offsets(5), offsets2(5);
1402 offsets[0] = offset;
1403 offsets[1] = offset + nTriInt;
1404 offsets[2] = offset + 2 * nTriInt;
1405 offsets[3] = offset + 2 * nTriInt + nQuadInt;
1406 offsets[4] = offset + 2 * nTriInt + 2 * nQuadInt;
1409 offsets2[0] = offset;
1410 offsets2[1] = offset + nQuadInt;
1411 offsets2[2] = offset + nQuadInt + nTriInt;
1412 offsets2[3] = offset + 2 * nQuadInt + nTriInt;
1413 offsets2[4] = offset + 2 * nQuadInt + 2 * nTriInt;
1415 mapping.resize(6 + 9 * n + 3 * nQuadInt + 2 * nTriInt);
1419 vector<int> triVertId(3);
1424 vector<int> quadVertId(4);
1430 for (i = 0; i < 5; ++i)
1432 int face = gmshToNekFace[i];
1433 int offset2 = offsets[i];
1434 offset = offsets2[face];
1437 int nFacePts = tri ? nTriInt : nQuadInt;
1445 vector<int> faceNodes(nFacePts);
1446 vector<int> toAlign(tri ? 3 : 4);
1447 for (
int j = 0; j < nFacePts; ++j)
1449 faceNodes[j] = offset2 + j;
1466 hoTri.
Align(toAlign);
1470 for (
int j = 0; j < nTriInt; ++j)
1472 mapping[offset + j] = hoTri.
surfVerts[j];
1503 hoQuad.
Align(toAlign);
1506 for (
int j = 0; j < nQuadInt; ++j)
1508 mapping[offset + j] = hoQuad.
surfVerts[j];
1519 offset = offsets[4] + nQuadInt;
1520 vector<int> intPoints, tmp;
1522 for (
int i = offset; i < (order+1) * (order+1) * (order+2) / 2; ++i)
1524 intPoints.push_back(i);
1529 mapping.insert(mapping.end(), tmp.begin(), tmp.end());
1539 const int order = conf.
m_order;
1540 const int n = order - 1;
1541 const int n2 = n * n;
1544 vector<int> mapping;
1547 static int gmshToNekEdge[12] = {0, -3, 4, 1, 5, 2, 6, 7, 8, -11, 9, 10};
1551 for (i = 0; i < 8; ++i)
1562 mapping.resize(8 + 12 * n);
1565 int cnt = 8, offset;
1566 for (i = 0; i < 12; ++i)
1568 int edge = gmshToNekEdge[i];
1569 offset = 8 + n * abs(edge);
1573 for (
int j = 0; j < n; ++j)
1575 mapping[offset + n - j - 1] = cnt++;
1580 for (
int j = 0; j < n; ++j)
1582 mapping[offset + j] = cnt++;
1593 mapping.resize(8 + 12 * n + 6 * n2);
1596 static int gmsh2NekFace[6] = {0, 1, 4, 2, 3, 5};
1605 StdRegions::eDir1FwdDir1_Dir2FwdDir2};
1607 for (i = 0; i < 6; ++i)
1609 int face = gmsh2NekFace[i];
1610 int offset2 = 8 + 12 * n + i * n2;
1611 offset = 8 + 12 * n + face * n2;
1614 vector<int> faceNodes(n2);
1615 for (j = 0; j < n2; ++j)
1617 faceNodes[j] = offset2 + j;
1629 for (j = 0; j < n2; ++j)
1631 mapping[offset + j] = tmp[j];
1637 for (j = 0; j < n; ++j)
1639 for (k = 0; k < n; ++k)
1641 mapping[offset + j * n + k] = tmp[k * n + j];
1647 for (j = 0; j < n; ++j)
1649 for (k = 0; k < n; ++k)
1651 mapping[offset + j * n + k] = tmp[j * n + (n - k - 1)];
1662 const int totPoints = (order + 1) * (order + 1) * (order + 1);
1663 vector<int> interior;
1664 for (i = 8 + 12 * n + 6 * n2; i < totPoints; ++i)
1666 interior.push_back(i);
1670 mapping.insert(mapping.end(), interior.begin(), interior.end());
1687 using namespace LibUtilities;
1688 std::map<unsigned int, ElmtConfig> tmp;
bool m_faceNodes
Denotes whether the element contains face nodes. For 2D elements, if this is true then the element co...
std::vector< int > prismTensorNodeOrdering(const std::vector< int > &nodes, int n)
Reorder Gmsh nodes so that they appear in a "tensor product" format suitable for the interior of a Ne...
#define ASSERTL0(condition, msg)
std::vector< int > triTensorNodeOrdering(const std::vector< int > &nodes, int n)
Reorder Gmsh nodes so that they appear in a "tensor product" format suitable for the interior of a Ne...
Basic information about an element.
tBaseSharedPtr CreateInstance(tKey idKey BOOST_PP_COMMA_IF(MAX_PARAM) BOOST_PP_ENUM_BINARY_PARAMS(MAX_PARAM, tParam, x))
Create an instance of the class referred to by idKey.
void Align(std::vector< int > vertId)
Align this surface to a given vertex ID.
static NEKMESHUTILS_EXPORT unsigned int GetNumNodes(ElmtConfig pConf)
Return the number of nodes defining a quadrilateral.
std::vector< int > quadTensorNodeOrdering(const std::vector< int > &nodes, int n)
Reorder Gmsh nodes so that they appear in a tensor product format suitable for the interior of a Nekt...
std::vector< T > surfVerts
The quadrilateral surface vertices – templated so that this can either be nodes or IDs...
std::vector< T > surfVerts
The triangle surface vertices – templated so that this can either be nodes or IDs.
pair< ModuleType, string > ModuleKey
MeshSharedPtr m_mesh
Mesh object.
ElementFactory & GetElementFactory()
std::vector< int > hexTensorNodeOrdering(const std::vector< int > &nodes, int n)
Reorder Gmsh nodes so that they appear in a "tensor product" format suitable for the interior of a Ne...
const char *const ShapeTypeMap[]
unsigned int m_order
Order of the element.
static NEKMESHUTILS_EXPORT unsigned int GetNumNodes(ElmtConfig pConf)
Return the number of nodes defining a line.
static NEKMESHUTILS_EXPORT unsigned int GetNumNodes(ElmtConfig pConf)
Return the number of nodes defining a prism.
bool m_volumeNodes
Denotes whether the element contains volume (i.e. interior) nodes. These are not supported by either ...
virtual NEKMESHUTILS_EXPORT void ProcessFaces(bool ReprocessFaces=true)
Extract element faces.
virtual NEKMESHUTILS_EXPORT void ProcessElements()
Generate element IDs.
bool operator()(Mode const &a, Mode const &b) const
void Align(std::vector< int > vertId)
Align this surface to a given vertex ID.
static NEKMESHUTILS_EXPORT unsigned int GetNumNodes(ElmtConfig pConf)
Return the number of nodes defining a triangle.
A lightweight struct for dealing with high-order triangle alignment.
static NEKMESHUTILS_EXPORT unsigned int GetNumNodes(ElmtConfig pConf)
Return the number of nodes defining a hexahedron.
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs typedef NekMatrix< LhsDataType, StandardMatrixTag >::iterator iterator
boost::shared_ptr< Mesh > MeshSharedPtr
Shared pointer to a mesh.
boost::tuple< int, int, int > Mode
A lightweight struct for dealing with high-order quadrilateral alignment.
static NEKMESHUTILS_EXPORT unsigned int GetNumNodes(ElmtConfig pConf)
Return the number of nodes defining a tetrahedron.
virtual NEKMESHUTILS_EXPORT void ProcessVertices()
Extract element vertices.
std::vector< int > tetTensorNodeOrdering(const std::vector< int > &nodes, int n)
Reorder Gmsh nodes so that they appear in a "tensor product" format suitable for the interior of a Ne...
static NEKMESHUTILS_EXPORT unsigned int GetNumNodes(ElmtConfig pConf)
Return the number of nodes defining a pyramid.
virtual NEKMESHUTILS_EXPORT void ProcessEdges(bool ReprocessEdges=true)
Extract element edges.
static NEKMESHUTILS_EXPORT unsigned int GetNumNodes(ElmtConfig pConf)
Return the number of nodes defining a point (i.e. return 1).
2D Evenly-spaced points on a Triangle
boost::shared_ptr< Element > ElementSharedPtr
std::pair< ModuleType, std::string > ModuleKey
virtual NEKMESHUTILS_EXPORT void ProcessComposites()
Generate composites.
ModuleFactory & GetModuleFactory()
tKey RegisterCreatorFunction(tKey idKey, CreatorFunction classCreator, tDescription pDesc="")
Register a class with the factory.