Nektar++
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
Nektar::Utilities::Module Class Referenceabstract

#include <Module.h>

Inheritance diagram for Nektar::Utilities::Module:
Inheritance graph
[legend]
Collaboration diagram for Nektar::Utilities::Module:
Collaboration graph
[legend]

Public Member Functions

 Module (FieldSharedPtr p_f)
 
virtual void Process (po::variables_map &vm)=0
 
void RegisterConfig (string key, string value)
 Register a configuration option with a module. More...
 
void PrintConfig ()
 Print out all configuration options for a module. More...
 
void SetDefaults ()
 Sets default configuration options for those which have not been set. More...
 
bool GetRequireEquiSpaced (void)
 
void SetRequireEquiSpaced (bool pVal)
 
void EvaluateTriFieldAtEquiSpacedPts (LocalRegions::ExpansionSharedPtr &exp, const Array< OneD, const NekDouble > &infield, Array< OneD, NekDouble > &outfield)
 
 Module (MeshSharedPtr p_m)
 
virtual void Process ()=0
 
void RegisterConfig (string key, string value)
 
void PrintConfig ()
 
void SetDefaults ()
 
MeshSharedPtr GetMesh ()
 
virtual void ProcessVertices ()
 Extract element vertices. More...
 
virtual void ProcessEdges (bool ReprocessEdges=true)
 Extract element edges. More...
 
virtual void ProcessFaces (bool ReprocessFaces=true)
 Extract element faces. More...
 
virtual void ProcessElements ()
 Generate element IDs. More...
 
virtual void ProcessComposites ()
 Generate composites. More...
 
virtual void ClearElementLinks ()
 

Protected Member Functions

 Module ()
 
void ReorderPrisms (PerMap &perFaces)
 Reorder node IDs so that prisms and tetrahedra are aligned correctly. More...
 
void PrismLines (int prism, PerMap &perFaces, set< int > &prismsDone, vector< ElementSharedPtr > &line)
 

Protected Attributes

FieldSharedPtr m_f
 Field object. More...
 
map< string, ConfigOptionm_config
 List of configuration values. More...
 
bool m_requireEquiSpaced
 
MeshSharedPtr m_mesh
 Mesh object. More...
 

Detailed Description

Abstract base class for mesh converter modules. Each subclass implements the Process() function, which in some way alters the mesh #m.

Definition at line 137 of file FieldConvert/Module.h.

Constructor & Destructor Documentation

Nektar::Utilities::Module::Module ( FieldSharedPtr  p_f)
inline

Definition at line 140 of file FieldConvert/Module.h.

140 : m_f(p_f), m_requireEquiSpaced(false) {}
FieldSharedPtr m_f
Field object.
Nektar::Utilities::Module::Module ( )
inlineprotected

Definition at line 163 of file FieldConvert/Module.h.

163 {};
Nektar::Utilities::Module::Module ( MeshSharedPtr  p_m)
inline

Definition at line 156 of file NekMesh/Module.h.

156 : m_mesh(p_m) {}
MeshSharedPtr m_mesh
Mesh object.

Member Function Documentation

void Nektar::Utilities::Module::ClearElementLinks ( )
virtual

clear all element link information from mesh entities to be able to reprocess new mesh

Definition at line 399 of file NekMesh/Module.cpp.

References Nektar::iterator, and m_mesh.

Referenced by Nektar::Utilities::InputCAD::Process(), and Nektar::Utilities::ProcessOptiExtract::Process().

400 {
401  EdgeSet::iterator eit;
402 
403  for(eit = m_mesh->m_edgeSet.begin(); eit != m_mesh->m_edgeSet.end(); eit++)
404  {
405  (*eit)->m_elLink.clear();
406  }
407 
408  FaceSet::iterator fit;
409 
410  for(fit = m_mesh->m_faceSet.begin(); fit != m_mesh->m_faceSet.end(); fit++)
411  {
412  (*fit)->m_elLink.clear();
413  }
414 }
MeshSharedPtr m_mesh
Mesh object.
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs typedef NekMatrix< LhsDataType, StandardMatrixTag >::iterator iterator
void Nektar::Utilities::Module::EvaluateTriFieldAtEquiSpacedPts ( LocalRegions::ExpansionSharedPtr exp,
const Array< OneD, const NekDouble > &  infield,
Array< OneD, NekDouble > &  outfield 
)
MeshSharedPtr Nektar::Utilities::Module::GetMesh ( )
inline

Definition at line 162 of file NekMesh/Module.h.

163  {
164  return m_mesh;
165  }
MeshSharedPtr m_mesh
Mesh object.
bool Nektar::Utilities::Module::GetRequireEquiSpaced ( void  )
inline

Definition at line 147 of file FieldConvert/Module.h.

148  {
149  return m_requireEquiSpaced;
150  }
void Nektar::Utilities::Module::PrintConfig ( )

Print out all configuration options for a module.

Definition at line 128 of file FieldConvert/Module.cpp.

References Nektar::iterator, and m_config.

129  {
131 
132  if (m_config.size() == 0)
133  {
134  cerr << "No configuration options for this module." << endl;
135  return;
136  }
137 
138  for (it = m_config.begin(); it != m_config.end(); ++it)
139  {
140  cerr << setw(10) << it->first << ": " << it->second.m_desc
141  << endl;
142  }
143  }
map< string, ConfigOption > m_config
List of configuration values.
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs typedef NekMatrix< LhsDataType, StandardMatrixTag >::iterator iterator
void Nektar::Utilities::Module::PrintConfig ( )
void Nektar::Utilities::Module::PrismLines ( int  prism,
PerMap perFaces,
set< int > &  prismsDone,
vector< ElementSharedPtr > &  line 
)
protected

Definition at line 734 of file NekMesh/Module.cpp.

References Nektar::iterator, and m_mesh.

Referenced by ReorderPrisms().

738 {
739  int i;
740  set<int>::iterator it = prismsDone.find(prism);
741  PerMap::iterator it2;
742 
743  if (it == prismsDone.end())
744  {
745  return;
746  }
747 
748  // Remove this prism from the list.
749  prismsDone.erase(it);
750  line.push_back(m_mesh->m_element[3][prism]);
751 
752  // Now find prisms connected to this one through a triangular face.
753  for (i = 1; i <= 3; i += 2)
754  {
755  FaceSharedPtr f = m_mesh->m_element[3][prism]->GetFace(i);
756  int nextId;
757 
758  // See if this face is periodic.
759  it2 = perFaces.find(f->m_id);
760 
761  if (it2 != perFaces.end())
762  {
763  int id2 = it2->second.first->m_id;
764  nextId = it2->second.first->m_elLink[0].first->GetId();
765  perFaces.erase(it2);
766  perFaces.erase(id2);
767  PrismLines(nextId, perFaces, prismsDone, line);
768  }
769 
770  // Nothing else connected to this face.
771  if (f->m_elLink.size() == 1)
772  {
773  continue;
774  }
775 
776  nextId = f->m_elLink[0].first->GetId();
777  if (nextId == m_mesh->m_element[3][prism]->GetId())
778  {
779  nextId = f->m_elLink[1].first->GetId();
780  }
781 
782  PrismLines(nextId, perFaces, prismsDone, line);
783  }
784 }
MeshSharedPtr m_mesh
Mesh object.
void PrismLines(int prism, PerMap &perFaces, set< int > &prismsDone, vector< ElementSharedPtr > &line)
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs typedef NekMatrix< LhsDataType, StandardMatrixTag >::iterator iterator
boost::shared_ptr< Face > FaceSharedPtr
Shared pointer to a face.
Definition: Face.h:378
virtual void Nektar::Utilities::Module::Process ( po::variables_map &  vm)
pure virtual
virtual void Nektar::Utilities::Module::Process ( )
pure virtual
void Nektar::Utilities::Module::ProcessComposites ( )
virtual

Generate composites.

Generate a list of composites (groups of elements) from tag IDs stored in mesh vertices/edges/faces/elements.

Each element is assigned to a composite ID by an input module. First we scan the element list and generate a list of composite IDs. We then generate the composite objects and populate them with a second scan through the element list.

Definition at line 349 of file NekMesh/Module.cpp.

References Nektar::iterator, and m_mesh.

Referenced by Nektar::Utilities::InputCAD::Process(), Nektar::Utilities::InputGmsh::Process(), Nektar::Utilities::InputNekpp::Process(), Nektar::Utilities::InputSem::Process(), Nektar::Utilities::InputTec::Process(), Nektar::Utilities::ProcessOptiExtract::Process(), Nektar::Utilities::InputVtk::Process(), Nektar::Utilities::InputSwan::Process(), Nektar::Utilities::InputPly::Process(), Nektar::Utilities::InputStar::Process(), Nektar::Utilities::InputNek::Process(), Nektar::Utilities::ProcessExtractTetPrismInterface::Process(), Nektar::Utilities::ProcessTetSplit::Process(), Nektar::Utilities::ProcessBL::Process(), and Nektar::Utilities::ProcessJac::Process().

350 {
351  m_mesh->m_composite.clear();
352 
353  // For each element, check to see if a composite has been
354  // created. If not, create a new composite. Otherwise, add the
355  // element to the composite.
356  for (int d = 0; d <= m_mesh->m_expDim; ++d)
357  {
358  vector<ElementSharedPtr> &elmt = m_mesh->m_element[d];
359 
360  for (int i = 0; i < elmt.size(); ++i)
361  {
363  unsigned int tagid = elmt[i]->GetTagList()[0];
364 
365  it = m_mesh->m_composite.find(tagid);
366 
367  if (it == m_mesh->m_composite.end())
368  {
369  CompositeSharedPtr tmp = boost::shared_ptr<Composite>(
370  new Composite());
371  pair<CompositeMap::iterator, bool> testIns;
372  tmp->m_id = tagid;
373  tmp->m_tag = elmt[i]->GetTag();
374  if(m_mesh->m_faceLabels.count(tmp->m_id) != 0)
375  {
376  tmp->m_label = m_mesh->m_faceLabels[tmp->m_id];
377  }
378 
379  testIns = m_mesh->m_composite.insert(
380  pair<unsigned int, CompositeSharedPtr>(tagid,tmp));
381  it = testIns.first;
382  }
383 
384  if (elmt[i]->GetTag() != it->second->m_tag)
385  {
386  cout << "Different types of elements in same composite!" << endl;
387  cout << " -> Composite uses " << it->second->m_tag << endl;
388  cout << " -> Element uses " << elmt[i]->GetTag() << endl;
389  cout << "Have you specified physical volumes and surfaces?" << endl;
390  }
391  it->second->m_items.push_back(elmt[i]);
392  }
393  }
394 }
MeshSharedPtr m_mesh
Mesh object.
boost::shared_ptr< Composite > CompositeSharedPtr
Shared pointer to a composite.
Definition: Composite.h:121
boost::shared_ptr< GeometryVector > Composite
Definition: MeshGraph.h:114
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs typedef NekMatrix< LhsDataType, StandardMatrixTag >::iterator iterator
void Nektar::Utilities::Module::ProcessEdges ( bool  ReprocessEdges = true)
virtual

Extract element edges.

Create a unique set of mesh edges from elements stored in Mesh::element.

All elements are first scanned and a list of unique, enumerated edges produced in #m_edgeSet. Since each element generated its edges independently, we must now ensure that each element only uses edge objects from the #m_edgeSet set This ensures there are no duplicate edge objects. Finally, we scan the list of elements for 1-D boundary elements which correspond to an edge in #m_edgeSet. For such elements, we set its edgeLink to reference the corresponding edge in #m_edgeSet.

This routine only proceeds if the expansion dimension is 2 or 3.

Definition at line 151 of file NekMesh/Module.cpp.

References Nektar::iterator, and m_mesh.

Referenced by Nektar::Utilities::InputCAD::Process(), Nektar::Utilities::InputGmsh::Process(), Nektar::Utilities::InputNekpp::Process(), Nektar::Utilities::InputSem::Process(), Nektar::Utilities::InputTec::Process(), Nektar::Utilities::InputSwan::Process(), Nektar::Utilities::InputPly::Process(), Nektar::Utilities::InputVtk::Process(), Nektar::Utilities::InputStar::Process(), Nektar::Utilities::InputNek::Process(), Nektar::Utilities::ProcessTetSplit::Process(), Nektar::Utilities::ProcessJac::Process(), Nektar::Utilities::ProcessBL::Process(), Nektar::Utilities::ProcessExtractTetPrismInterface::Process(), and ReorderPrisms().

152 {
153  if (m_mesh->m_expDim < 2) return;
154 
155  if(ReprocessEdges)
156  {
157  vector<ElementSharedPtr> &elmt = m_mesh->m_element[m_mesh->m_expDim];
158 
159  m_mesh->m_edgeSet.clear();
160 
161  // Clear all edge links
162 
163  // Scan all elements and generate list of unique edges
164  for (int i = 0, eid = 0; i < elmt.size(); ++i)
165  {
166  for (int j = 0; j < elmt[i]->GetEdgeCount(); ++j)
167  {
168  pair<EdgeSet::iterator,bool> testIns;
169  EdgeSharedPtr ed = elmt[i]->GetEdge(j);
170  testIns = m_mesh->m_edgeSet.insert(ed);
171 
172  if (testIns.second)
173  {
174  EdgeSharedPtr ed2 = *testIns.first;
175  ed2->m_id = eid++;
176  ed2->m_elLink.push_back(
177  pair<ElementSharedPtr,int>(elmt[i],j));
178  }
179  else
180  {
181  EdgeSharedPtr e2 = *(testIns.first);
182  elmt[i]->SetEdge(j, e2);
183  if (e2->m_edgeNodes.size() == 0 &&
184  ed->m_edgeNodes.size() > 0)
185  {
186  e2->m_curveType = ed->m_curveType;
187  e2->m_edgeNodes = ed->m_edgeNodes;
188 
189  // Reverse nodes if appropriate.
190  if (e2->m_n1->m_id != ed->m_n1->m_id)
191  {
192  reverse(e2->m_edgeNodes.begin(),
193  e2->m_edgeNodes.end());
194  }
195  }
196 
197 #ifdef NEKTAR_USE_MESHGEN
198  if(ed->onCurve)
199  {
200  e2->onCurve = ed->onCurve;
201  e2->CADCurveId = ed->CADCurveId;
202  e2->CADCurve = ed->CADCurve;
203  }
204 #endif
205 
206  // Update edge to element map.
207  e2->m_elLink.push_back(
208  pair<ElementSharedPtr,int>(elmt[i],j));
209  }
210  }
211  }
212  }
213 
214  // Create links for 1D elements
215  for (int i = 0; i < m_mesh->m_element[1].size(); ++i)
216  {
217  NodeSharedPtr v0 = m_mesh->m_element[1][i]->GetVertex(0);
218  NodeSharedPtr v1 = m_mesh->m_element[1][i]->GetVertex(1);
219  vector<NodeSharedPtr> edgeNodes;
220  EdgeSharedPtr E = boost::shared_ptr<Edge>(
221  new Edge(v0, v1, edgeNodes,
222  m_mesh->m_element[1][i]->GetConf().m_edgeCurveType));
223  EdgeSet::iterator it = m_mesh->m_edgeSet.find(E);
224  if (it == m_mesh->m_edgeSet.end())
225  {
226  cerr << "Cannot find corresponding element edge for "
227  << "1D element " << i << endl;
228  abort();
229  }
230  m_mesh->m_element[1][i]->SetEdgeLink(*it);
231 
232  // Update 2D element boundary map.
233  pair<ElementSharedPtr, int> eMap = (*it)->m_elLink.at(0);
234  eMap.first->SetBoundaryLink(eMap.second, i);
235 
236  // Copy curvature to edge.
237  if ((*it)->m_edgeNodes.size() > 0)
238  {
239  ElementSharedPtr edge = m_mesh->m_element[1][i];
240  if (edge->GetVertex(0) == (*it)->m_n1)
241  {
242  edge->SetVolumeNodes((*it)->m_edgeNodes);
243  }
244  }
245  }
246 }
Represents an edge which joins two points.
Definition: Edge.h:61
MeshSharedPtr m_mesh
Mesh object.
boost::shared_ptr< Node > NodeSharedPtr
Definition: Node.h:50
boost::shared_ptr< Edge > EdgeSharedPtr
Shared pointer to an edge.
Definition: Edge.h:196
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs typedef NekMatrix< LhsDataType, StandardMatrixTag >::iterator iterator
boost::shared_ptr< Element > ElementSharedPtr
Definition: Edge.h:52
void Nektar::Utilities::Module::ProcessElements ( )
virtual

Generate element IDs.

Enumerate elements stored in Mesh::element.

For all elements of equal dimension to the mesh dimension, we enumerate sequentially. All other elements in the list should be of lower dimension and have ID set by a corresponding edgeLink or faceLink (as set in ProcessEdges or ProcessFaces).

Definition at line 331 of file NekMesh/Module.cpp.

References m_mesh.

Referenced by Nektar::Utilities::InputCAD::Process(), Nektar::Utilities::InputGmsh::Process(), Nektar::Utilities::InputSem::Process(), Nektar::Utilities::InputTec::Process(), Nektar::Utilities::InputPly::Process(), Nektar::Utilities::InputSwan::Process(), Nektar::Utilities::InputVtk::Process(), Nektar::Utilities::InputStar::Process(), Nektar::Utilities::InputNek::Process(), Nektar::Utilities::ProcessBL::Process(), Nektar::Utilities::ProcessTetSplit::Process(), Nektar::Utilities::ProcessJac::Process(), Nektar::Utilities::ProcessExtractTetPrismInterface::Process(), and ReorderPrisms().

332 {
333  int cnt = 0;
334  for (int i = 0; i < m_mesh->m_element[m_mesh->m_expDim].size(); ++i)
335  {
336  m_mesh->m_element[m_mesh->m_expDim][i]->SetId(cnt++);
337  }
338 }
MeshSharedPtr m_mesh
Mesh object.
void Nektar::Utilities::Module::ProcessFaces ( bool  ReprocessFaces = true)
virtual

Extract element faces.

Create a unique set of mesh faces from elements stored in Mesh::element.

All elements are scanned and a unique list of enumerated faces is produced in #m_faceSet. Since elements created their own faces independently, we examine each element only uses face objects from #m_faceSet. Duplicate faces of those in #m_face are replaced with the corresponding entry in #m_faceSet. Finally, we scan the list of elements for 2-D boundary faces which correspond to faces in #m_faceSet. For such elements, we set its faceLink to reference the corresponding face in #m_faceSet.

This routine only proceeds if the expansion dimension is 3.

Definition at line 264 of file NekMesh/Module.cpp.

References Nektar::iterator, and m_mesh.

Referenced by Nektar::Utilities::InputCAD::Process(), Nektar::Utilities::InputGmsh::Process(), Nektar::Utilities::InputNekpp::Process(), Nektar::Utilities::InputSem::Process(), Nektar::Utilities::InputTec::Process(), Nektar::Utilities::ProcessOptiExtract::Process(), Nektar::Utilities::InputSwan::Process(), Nektar::Utilities::InputPly::Process(), Nektar::Utilities::InputVtk::Process(), Nektar::Utilities::InputStar::Process(), Nektar::Utilities::InputNek::Process(), Nektar::Utilities::ProcessBL::Process(), Nektar::Utilities::ProcessTetSplit::Process(), Nektar::Utilities::ProcessExtractTetPrismInterface::Process(), Nektar::Utilities::ProcessJac::Process(), and ReorderPrisms().

265 {
266  if (m_mesh->m_expDim < 3) return;
267 
268  if(ReprocessFaces)
269  {
270  vector<ElementSharedPtr> &elmt = m_mesh->m_element[m_mesh->m_expDim];
271 
272  m_mesh->m_faceSet.clear();
273 
274  // Scan all elements and generate list of unique faces
275  for (int i = 0, fid = 0; i < elmt.size(); ++i)
276  {
277  for (int j = 0; j < elmt[i]->GetFaceCount(); ++j)
278  {
279  pair<FaceSet::iterator,bool> testIns;
280  testIns = m_mesh->m_faceSet.insert(elmt[i]->GetFace(j));
281 
282  if (testIns.second)
283  {
284  (*(testIns.first))->m_id = fid++;
285  (*(testIns.first))->m_elLink.push_back(
286  pair<ElementSharedPtr,int>(elmt[i],j));
287  }
288  else
289  {
290  elmt[i]->SetFace(j,*testIns.first);
291  // Update face to element map.
292  (*(testIns.first))->m_elLink.push_back(
293  pair<ElementSharedPtr,int>(elmt[i],j));
294  }
295  }
296  }
297  }
298 
299  // Create links for 2D elements
300  for (int i = 0; i < m_mesh->m_element[2].size(); ++i)
301  {
302  vector<NodeSharedPtr> vertices = m_mesh->m_element[2][i]->GetVertexList();
303  vector<NodeSharedPtr> faceNodes;
304  vector<EdgeSharedPtr> edgeList = m_mesh->m_element[2][i]->GetEdgeList();
305  FaceSharedPtr F = boost::shared_ptr<Face>(
306  new Face(vertices, faceNodes, edgeList,
307  m_mesh->m_element[2][i]->GetConf().m_faceCurveType));
308  FaceSet::iterator it = m_mesh->m_faceSet.find(F);
309  if (it == m_mesh->m_faceSet.end())
310  {
311  cout << "Cannot find corresponding element face for 2D "
312  << "element " << i << endl;
313  abort();
314  }
315  m_mesh->m_element[2][i]->SetFaceLink(*it);
316 
317  // Update 3D element boundary map.
318  pair<ElementSharedPtr, int> eMap = (*it)->m_elLink.at(0);
319  eMap.first->SetBoundaryLink(eMap.second, i);
320  }
321 }
Represents a face comprised of three or more edges.
Definition: Face.h:60
MeshSharedPtr m_mesh
Mesh object.
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs typedef NekMatrix< LhsDataType, StandardMatrixTag >::iterator iterator
boost::shared_ptr< Face > FaceSharedPtr
Shared pointer to a face.
Definition: Face.h:378
void Nektar::Utilities::Module::ProcessVertices ( )
virtual

Extract element vertices.

Create a unique set of mesh vertices from elements stored in Mesh::element.

Each element is processed in turn and the vertices extracted and inserted into #m_vertexSet, which at the end of the routine contains all unique vertices in the mesh.

Definition at line 111 of file NekMesh/Module.cpp.

References m_mesh.

Referenced by Nektar::Utilities::InputCAD::Process(), Nektar::Utilities::InputGmsh::Process(), Nektar::Utilities::InputSem::Process(), Nektar::Utilities::InputVtk::Process(), Nektar::Utilities::InputPly::Process(), Nektar::Utilities::InputSwan::Process(), Nektar::Utilities::ProcessJac::Process(), Nektar::Utilities::ProcessBL::Process(), Nektar::Utilities::ProcessExtractTetPrismInterface::Process(), Nektar::Utilities::ProcessTetSplit::Process(), Nektar::Utilities::InputTec::ReadZone(), and Nektar::Utilities::InputStar::SetupElements().

112 {
113  vector<ElementSharedPtr> &elmt = m_mesh->m_element[m_mesh->m_expDim];
114 
115  m_mesh->m_vertexSet.clear();
116 
117  for (int i = 0, vid = 0; i < elmt.size(); ++i)
118  {
119  for (int j = 0; j < elmt[i]->GetVertexCount(); ++j)
120  {
121  pair<NodeSet::iterator,bool> testIns =
122  m_mesh->m_vertexSet.insert(elmt[i]->GetVertex(j));
123 
124  if (testIns.second)
125  {
126  (*(testIns.first))->m_id = vid++;
127  }
128  else
129  {
130  elmt[i]->SetVertex(j,*testIns.first);
131  }
132  }
133  }
134 }
MeshSharedPtr m_mesh
Mesh object.
void Nektar::Utilities::Module::RegisterConfig ( string  key,
string  value 
)

Register a configuration option with a module.

Definition at line 104 of file FieldConvert/Module.cpp.

References Nektar::iterator, and m_config.

Referenced by Nektar::Utilities::ProcessMeanMode::Process().

105  {
107  if (it == m_config.end())
108  {
109  cerr << "WARNING: Unrecognised config option " << key
110  << ", proceeding anyway." << endl;
111  }
112 
113  it->second.m_beenSet = true;
114 
115  if (it->second.m_isBool)
116  {
117  it->second.m_value = "1";
118  }
119  else
120  {
121  it->second.m_value = val;
122  }
123  }
map< string, ConfigOption > m_config
List of configuration values.
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs typedef NekMatrix< LhsDataType, StandardMatrixTag >::iterator iterator
void Nektar::Utilities::Module::RegisterConfig ( string  key,
string  value 
)
void Nektar::Utilities::Module::ReorderPrisms ( PerMap perFaces)
protected

Reorder node IDs so that prisms and tetrahedra are aligned correctly.

Orientation of prism lines (i.e. a large prism which has been split into subprisms) cannot be guaranteed when elements are created one-by-one, or when periodic boundary conditions are used. This routine uses the following strategy:

  • Destroy the existing node numbering.
  • Detect a line of prisms using the PrismLines routine.
  • For each line, renumber node IDs consistently so that highest ID per-element corresponds to the line of collapsed coordinate points.
  • Recreate each prism in the line using the new ordering, and apply the existing OrientPrism routine to orient nodes accordingly.
  • When all prism lines are processed, recreate all tetrahedra using the existing orientation code.
  • Finally renumber any other nodes (i.e. those belonging to hexahedra).

The last step is to eliminate duplicate edges/faces and reenumerate.

NOTE: This routine does not copy face-interior high-order information yet!

Definition at line 442 of file NekMesh/Module.cpp.

References ASSERTL0, ASSERTL1, Nektar::LibUtilities::NekFactory< tKey, tBase, >::CreateInstance(), Nektar::LibUtilities::ePrism, Nektar::LibUtilities::eTetrahedron, Nektar::NekMeshUtils::GetElementFactory(), Nektar::iterator, m_mesh, PrismLines(), ProcessEdges(), ProcessElements(), and ProcessFaces().

Referenced by Nektar::Utilities::ProcessPerAlign::Process().

443 {
444  // Loop over elements and extract any that are prisms.
445  int i, j, k;
446 
447  if (m_mesh->m_expDim < 3)
448  {
449  return;
450  }
451 
452  map<int, int> lines;
453  set<int> prismsDone, tetsDone;
454  PerMap::iterator pIt;
455 
456  // Compile list of prisms and tets.
457  for (i = 0; i < m_mesh->m_element[3].size(); ++i)
458  {
459  ElementSharedPtr el = m_mesh->m_element[3][i];
460 
461  if (el->GetConf().m_e == LibUtilities::ePrism)
462  {
463  prismsDone.insert(i);
464  }
465  else if (el->GetConf().m_e == LibUtilities::eTetrahedron)
466  {
467  tetsDone.insert(i);
468  }
469  }
470 
471  // Destroy existing node numbering.
473  for (it = m_mesh->m_vertexSet.begin(); it != m_mesh->m_vertexSet.end(); ++it)
474  {
475  (*it)->m_id = -1;
476  }
477 
478  // Counter for new node IDs.
479  int nodeId = 0;
480  int prismTris[2][3] = {{0,1,4}, {3,2,5}};
481 
482  // Warning flag for high-order curvature information.
483  bool warnCurvature = false;
484 
485  // facesDone tracks face IDs inside prisms which have already been
486  // aligned.
487  boost::unordered_set<int> facesDone;
489 
490  // Loop over prisms until we've found all lines of prisms.
491  while (prismsDone.size() > 0)
492  {
493  vector<ElementSharedPtr> line;
494 
495  // Call PrismLines to identify all prisms connected to
496  // prismDone.begin() and place them in line[].
497  PrismLines(*prismsDone.begin(), perFaces, prismsDone, line);
498 
499  // Loop over each prism, figure out which line of vertices
500  // contains the vertex with highest ID.
501  for (i = 0; i < line.size(); ++i)
502  {
503  // Copy tags and nodes from existing element.
504  vector<int> tags = line[i]->GetTagList();
505  vector<NodeSharedPtr> nodes = line[i]->GetVertexList();
506 
507  // See if either face of this prism has been renumbered
508  // already.
509  FaceSharedPtr f[2] = {
510  line[i]->GetFace(1), line[i]->GetFace(3)
511  };
512 
513  fIt[0] = facesDone.find(f[0]->m_id);
514  fIt[1] = facesDone.find(f[1]->m_id);
515 
516  // See if either of these faces is periodic. If it is, then
517  // assign ids accordingly.
518  for (j = 0; j < 2; ++j)
519  {
520  pIt = perFaces.find(f[j]->m_id);
521 
522  if (pIt == perFaces.end())
523  {
524  continue;
525  }
526 
527  fIt2 = facesDone.find(pIt->second.first->m_id);
528 
529  if (fIt[j] == facesDone.end() &&
530  fIt2 != facesDone.end())
531  {
532  fIt[j] = fIt2;
533  }
534  }
535 
536  if (fIt[0] != facesDone.end() &&
537  fIt[1] != facesDone.end())
538  {
539  // Should not be the case that both faces have already
540  // been renumbered.
541  ASSERTL0(false, "Renumbering error!");
542  }
543  else if (fIt[0] == facesDone.end() &&
544  fIt[1] == facesDone.end())
545  {
546  // Renumber both faces.
547  for (j = 0; j < 2; ++j)
548  {
549  for (k = 0; k < 3; ++k)
550  {
551  NodeSharedPtr n = nodes[prismTris[j][k]];
552  if (n->m_id == -1)
553  {
554  n->m_id = nodeId++;
555  }
556  }
557  }
558 
559  facesDone.insert(f[0]->m_id);
560  facesDone.insert(f[1]->m_id);
561  }
562  else
563  {
564  // Renumber face. t identifies the face not yet
565  // numbered, o identifies the other face.
566  int t = fIt[0] == facesDone.end() ? 0 : 1;
567  int o = (t+1) % 2;
568  ASSERTL1(fIt[o] != facesDone.end(),"Renumbering error");
569 
570  // Determine which of the three vertices on the 'other'
571  // face corresponds to the highest ID - this signifies
572  // the singular point of the line of prisms.
573  int tmp1[3] = {
574  nodes[prismTris[o][0]]->m_id,
575  nodes[prismTris[o][1]]->m_id,
576  nodes[prismTris[o][2]]->m_id
577  };
578  int tmp2[3] = {0,1,2};
579 
580  if (tmp1[0] > tmp1[1])
581  {
582  swap(tmp1[0], tmp1[1]);
583  swap(tmp2[0], tmp2[1]);
584  }
585 
586  if (tmp1[1] > tmp1[2])
587  {
588  swap(tmp1[1], tmp1[2]);
589  swap(tmp2[1], tmp2[2]);
590  }
591 
592  if (tmp1[0] > tmp1[2])
593  {
594  swap(tmp1[0], tmp1[2]);
595  swap(tmp2[0], tmp2[2]);
596  }
597 
598  // Renumber this face so that highest ID matches.
599  for (j = 0; j < 3; ++j)
600  {
601  NodeSharedPtr n = nodes[prismTris[t][tmp2[j]]];
602  if (n->m_id == -1)
603  {
604  n->m_id = nodeId++;
605  }
606  }
607 
608  facesDone.insert(f[t]->m_id);
609  }
610 
611  for (j = 0; j < 6; ++j)
612  {
613  ASSERTL1(nodes[j]->m_id != -1, "Renumbering error");
614  }
615 
616  // Recreate prism with the new ordering.
617  ElmtConfig conf(LibUtilities::ePrism, 1, false, false, true);
619  LibUtilities::ePrism, conf, nodes, tags);
620 
621  // Now transfer high-order information back into
622  // place. TODO: Face curvature.
623  for (j = 0; j < 9; ++j)
624  {
625  EdgeSharedPtr e1 = line[i]->GetEdge(j);
626  for (k = 0; k < 9; ++k)
627  {
628  EdgeSharedPtr e2 = el->GetEdge(k);
629  if (e1->m_n1 == e2->m_n1 && e1->m_n2 == e2->m_n2)
630  {
631  e2->m_edgeNodes = e1->m_edgeNodes;
632  }
633  else if (e1->m_n1 == e2->m_n1 && e1->m_n2 == e2->m_n2)
634  {
635  e2->m_edgeNodes = e1->m_edgeNodes;
636  std::reverse(e2->m_edgeNodes.begin(),
637  e2->m_edgeNodes.end());
638  }
639  }
640  }
641 
642  // Warn users that we're throwing away face curvature
643  if (!warnCurvature)
644  {
645  for (j = 0; j < 5; ++j)
646  {
647  if (line[i]->GetFace(j)->m_faceNodes.size() > 0)
648  {
649  warnCurvature = true;
650  break;
651  }
652  }
653  }
654 
655  // Replace old prism.
656  m_mesh->m_element[3][line[i]->GetId()] = el;
657  }
658  }
659 
660  if (warnCurvature)
661  {
662  cerr << "[ReorderPrisms] WARNING: Face curvature detected in "
663  << "some prisms; this will be ignored in further module "
664  << "evaluations."
665  << endl;
666  }
667 
668  // Loop over periodic faces, enumerate vertices.
669  for (pIt = perFaces.begin(); pIt != perFaces.end(); ++pIt)
670  {
671  FaceSharedPtr f2 = pIt->second.first;
672  FaceSharedPtr f1 = perFaces[f2->m_id].first;
673  vector<int> perVerts = pIt->second.second;
674  int nVerts = perVerts.size();
675 
676  // Number periodic vertices first.
677  for (j = 0; j < nVerts; ++j)
678  {
679  NodeSharedPtr n1 = f1->m_vertexList[j];
680  NodeSharedPtr n2 = f2->m_vertexList[perVerts[j]];
681 
682  if (n1->m_id == -1 && n2->m_id == -1)
683  {
684  n1->m_id = nodeId++;
685  n2->m_id = nodeId++;
686  }
687  else if (n1->m_id != -1 && n2->m_id != -1)
688  {
689  continue;
690  }
691  else
692  {
693  ASSERTL0(false, "Periodic face renumbering error");
694  }
695  }
696  }
697 
698  // Recreate tets.
699  set<int>::iterator it2;
700  for (it2 = tetsDone.begin(); it2 != tetsDone.end(); ++it2)
701  {
702  ElementSharedPtr el = m_mesh->m_element[3][*it2];
703  vector<NodeSharedPtr> nodes = el->GetVertexList();
704  vector<int> tags = el->GetTagList();
705 
706  for (i = 0; i < 4; ++i)
707  {
708  if (nodes[i]->m_id == -1)
709  {
710  nodes[i]->m_id = nodeId++;
711  }
712  }
713 
714  // Recreate tet.
715  ElmtConfig conf(LibUtilities::eTetrahedron, 1, false, false, true);
716  m_mesh->m_element[3][*it2] = GetElementFactory().CreateInstance(
717  LibUtilities::eTetrahedron, conf, nodes, tags);
718  }
719 
720  // Enumerate rest of vertices.
721  for (it = m_mesh->m_vertexSet.begin(); it != m_mesh->m_vertexSet.end(); ++it)
722  {
723  if ((*it)->m_id == -1)
724  {
725  (*it)->m_id = nodeId++;
726  }
727  }
728 
729  ProcessEdges ();
730  ProcessFaces ();
731  ProcessElements();
732 }
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:161
Basic information about an element.
Definition: Element.h:58
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.
Definition: NekFactory.hpp:162
MeshSharedPtr m_mesh
Mesh object.
ElementFactory & GetElementFactory()
Definition: Element.cpp:47
virtual void ProcessEdges(bool ReprocessEdges=true)
Extract element edges.
virtual void ProcessElements()
Generate element IDs.
boost::shared_ptr< Node > NodeSharedPtr
Definition: Node.h:50
void PrismLines(int prism, PerMap &perFaces, set< int > &prismsDone, vector< ElementSharedPtr > &line)
boost::shared_ptr< Edge > EdgeSharedPtr
Shared pointer to an edge.
Definition: Edge.h:196
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs typedef NekMatrix< LhsDataType, StandardMatrixTag >::iterator iterator
virtual void ProcessFaces(bool ReprocessFaces=true)
Extract element faces.
boost::shared_ptr< Element > ElementSharedPtr
Definition: Edge.h:52
boost::shared_ptr< Face > FaceSharedPtr
Shared pointer to a face.
Definition: Face.h:378
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:191
void Nektar::Utilities::Module::SetDefaults ( )

Sets default configuration options for those which have not been set.

Definition at line 149 of file FieldConvert/Module.cpp.

References Nektar::iterator, and m_config.

150  {
152 
153  for (it = m_config.begin(); it != m_config.end(); ++it)
154  {
155  if (!it->second.m_beenSet)
156  {
157  it->second.m_value = it->second.m_defValue;
158  }
159  }
160  }
map< string, ConfigOption > m_config
List of configuration values.
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs typedef NekMatrix< LhsDataType, StandardMatrixTag >::iterator iterator
void Nektar::Utilities::Module::SetDefaults ( )
void Nektar::Utilities::Module::SetRequireEquiSpaced ( bool  pVal)
inline

Definition at line 152 of file FieldConvert/Module.h.

153  {
154  m_requireEquiSpaced = pVal;
155  }

Member Data Documentation

map< string, ConfigOption > Nektar::Utilities::Module::m_config
protected

List of configuration values.

Definition at line 168 of file FieldConvert/Module.h.

Referenced by Nektar::Utilities::ProcessCyl::GenerateEdgeNodes(), Nektar::Utilities::InputStar::InitCCM(), Nektar::Utilities::InputModule::InputModule(), Nektar::Utilities::InputStar::InputStar(), Nektar::Utilities::ProcessInterpPoints::InterpolateFieldToPts(), Nektar::Utilities::InputModule::OpenStream(), Nektar::Utilities::OutputModule::OpenStream(), Nektar::Utilities::OutputModule::OutputModule(), Nektar::Utilities::OutputNekpp::OutputNekpp(), PrintConfig(), Nektar::Utilities::InputCAD::Process(), Nektar::Utilities::InputNekpp::Process(), Nektar::Utilities::InputSem::Process(), Nektar::Utilities::ProcessDisplacement::Process(), Nektar::Utilities::OutputInfo::Process(), Nektar::Utilities::ProcessOptiExtract::Process(), Nektar::Utilities::ProcessPerAlign::Process(), Nektar::Utilities::ProcessCyl::Process(), Nektar::Utilities::OutputXml::Process(), Nektar::Utilities::ProcessBoundaryExtract::Process(), Nektar::Utilities::OutputStdOut::Process(), Nektar::Utilities::OutputVtk::Process(), Nektar::Utilities::InputVtk::Process(), Nektar::Utilities::OutputFld::Process(), Nektar::Utilities::ProcessSpherigon::Process(), Nektar::Utilities::OutputPts::Process(), Nektar::Utilities::ProcessInterpField::Process(), Nektar::Utilities::ProcessInterpPoints::Process(), Nektar::Utilities::ProcessLinear::Process(), Nektar::Utilities::ProcessMultiShear::Process(), Nektar::Utilities::OutputNekpp::Process(), Nektar::Utilities::ProcessScalGrad::Process(), Nektar::Utilities::ProcessSurfDistance::Process(), Nektar::Utilities::ProcessWSS::Process(), Nektar::Utilities::ProcessPointDataToFld::Process(), Nektar::Utilities::ProcessC0Projection::Process(), Nektar::Utilities::ProcessScaleInFld::Process(), Nektar::Utilities::ProcessHomogeneousPlane::Process(), Nektar::Utilities::ProcessInnerProduct::Process(), Nektar::Utilities::ProcessInterpPointDataToFld::Process(), Nektar::Utilities::ProcessAddFld::Process(), Nektar::Utilities::ProcessBL::Process(), Nektar::Utilities::ProcessScalar::Process(), Nektar::Utilities::ProcessTetSplit::Process(), Nektar::Utilities::ProcessDetectSurf::Process(), Nektar::Utilities::ProcessExtractSurf::Process(), Nektar::Utilities::ProcessJac::Process(), Nektar::Utilities::OutputTecplot::Process(), Nektar::Utilities::ProcessIsoContour::Process(), Nektar::Utilities::ProcessAddFld::ProcessAddFld(), Nektar::Utilities::ProcessBL::ProcessBL(), Nektar::Utilities::ProcessBoundaryExtract::ProcessBoundaryExtract(), Nektar::Utilities::ProcessC0Projection::ProcessC0Projection(), Nektar::Utilities::ProcessCyl::ProcessCyl(), Nektar::Utilities::ProcessDetectSurf::ProcessDetectSurf(), Nektar::Utilities::ProcessDisplacement::ProcessDisplacement(), Nektar::Utilities::ProcessEquiSpacedOutput::ProcessEquiSpacedOutput(), Nektar::Utilities::ProcessExtractSurf::ProcessExtractSurf(), Nektar::Utilities::ProcessHomogeneousPlane::ProcessHomogeneousPlane(), Nektar::Utilities::ProcessInnerProduct::ProcessInnerProduct(), Nektar::Utilities::ProcessInterpField::ProcessInterpField(), Nektar::Utilities::ProcessInterpPointDataToFld::ProcessInterpPointDataToFld(), Nektar::Utilities::ProcessInterpPoints::ProcessInterpPoints(), Nektar::Utilities::ProcessIsoContour::ProcessIsoContour(), Nektar::Utilities::ProcessJac::ProcessJac(), Nektar::Utilities::ProcessJacobianEnergy::ProcessJacobianEnergy(), Nektar::Utilities::ProcessLinear::ProcessLinear(), Nektar::Utilities::ProcessMultiShear::ProcessMultiShear(), Nektar::Utilities::ProcessOptiExtract::ProcessOptiExtract(), Nektar::Utilities::ProcessPerAlign::ProcessPerAlign(), Nektar::Utilities::ProcessPointDataToFld::ProcessPointDataToFld(), Nektar::Utilities::ProcessScalar::ProcessScalar(), Nektar::Utilities::ProcessScaleInFld::ProcessScaleInFld(), Nektar::Utilities::ProcessScalGrad::ProcessScalGrad(), Nektar::Utilities::ProcessSpherigon::ProcessSpherigon(), Nektar::Utilities::ProcessSurfDistance::ProcessSurfDistance(), Nektar::Utilities::ProcessTetSplit::ProcessTetSplit(), Nektar::Utilities::ProcessWSS::ProcessWSS(), RegisterConfig(), SetDefaults(), Nektar::Utilities::InputStar::SetupElements(), Nektar::Utilities::ProcessEquiSpacedOutput::SetupEquiSpacedField(), Nektar::Utilities::OutputNekpp::WriteXmlCurves(), Nektar::Utilities::OutputNekpp::WriteXmlEdges(), Nektar::Utilities::OutputNekpp::WriteXmlElements(), Nektar::Utilities::OutputNekpp::WriteXmlFaces(), and Nektar::Utilities::OutputNekpp::WriteXmlNodes().

FieldSharedPtr Nektar::Utilities::Module::m_f
protected

Field object.

Definition at line 163 of file FieldConvert/Module.h.

Referenced by Nektar::Utilities::InputModule::AddFile(), Nektar::Utilities::ProcessIsoContour::ExtractContour(), Nektar::Utilities::ProcessEquiSpacedOutput::GenOrthoModes(), Nektar::Utilities::OutputTecplot::GetNumTecplotBlocks(), Nektar::Utilities::ProcessInterpPoints::InterpolateFieldToPts(), Nektar::Utilities::ProcessInnerProduct::IProduct(), Nektar::Utilities::InputModule::PrintSummary(), Nektar::Utilities::InputDat::Process(), Nektar::Utilities::InputXml::Process(), Nektar::Utilities::InputFld::Process(), Nektar::Utilities::InputPts::Process(), Nektar::Utilities::ProcessDeform::Process(), Nektar::Utilities::ProcessDisplacement::Process(), Nektar::Utilities::OutputInfo::Process(), Nektar::Utilities::OutputXml::Process(), Nektar::Utilities::OutputVtk::Process(), Nektar::Utilities::OutputStdOut::Process(), Nektar::Utilities::ProcessBoundaryExtract::Process(), Nektar::Utilities::ProcessJacobianEnergy::Process(), Nektar::Utilities::ProcessConcatenateFld::Process(), Nektar::Utilities::ProcessQualityMetric::Process(), Nektar::Utilities::OutputFld::Process(), Nektar::Utilities::ProcessInterpField::Process(), Nektar::Utilities::ProcessInterpPoints::Process(), Nektar::Utilities::OutputPts::Process(), Nektar::Utilities::ProcessNumModes::Process(), Nektar::Utilities::ProcessVorticity::Process(), Nektar::Utilities::ProcessMultiShear::Process(), Nektar::Utilities::ProcessWSS::Process(), Nektar::Utilities::ProcessPrintFldNorms::Process(), Nektar::Utilities::ProcessQCriterion::Process(), Nektar::Utilities::ProcessScalGrad::Process(), Nektar::Utilities::ProcessSurfDistance::Process(), Nektar::Utilities::ProcessGrad::Process(), Nektar::Utilities::ProcessInterpPointDataToFld::Process(), Nektar::Utilities::ProcessAddFld::Process(), Nektar::Utilities::ProcessMeanMode::Process(), Nektar::Utilities::ProcessC0Projection::Process(), Nektar::Utilities::ProcessScaleInFld::Process(), Nektar::Utilities::ProcessPointDataToFld::Process(), Nektar::Utilities::ProcessHomogeneousPlane::Process(), Nektar::Utilities::ProcessInnerProduct::Process(), Nektar::Utilities::ProcessMapping::Process(), Nektar::Utilities::OutputTecplot::Process(), Nektar::Utilities::ProcessIsoContour::Process(), Nektar::Utilities::ProcessMultiShear::ProcessMultiShear(), Nektar::Utilities::ProcessScalGrad::ProcessScalGrad(), Nektar::Utilities::ProcessSurfDistance::ProcessSurfDistance(), Nektar::Utilities::ProcessWSS::ProcessWSS(), Nektar::Utilities::ProcessIsoContour::ResetFieldPts(), Nektar::Utilities::ProcessEquiSpacedOutput::SetHomogeneousConnectivity(), Nektar::Utilities::ProcessEquiSpacedOutput::SetupEquiSpacedField(), Nektar::Utilities::ProcessIsoContour::SetupIsoFromFieldPts(), Nektar::Utilities::OutputTecplot::WriteTecplotConnectivity(), Nektar::Utilities::OutputTecplot::WriteTecplotField(), Nektar::Utilities::OutputTecplot::WriteTecplotHeader(), and Nektar::Utilities::OutputTecplot::WriteTecplotZone().

MeshSharedPtr Nektar::Utilities::Module::m_mesh
protected

Mesh object.

Definition at line 182 of file NekMesh/Module.h.

Referenced by ClearElementLinks(), Nektar::Utilities::InputTec::GenElement2D(), Nektar::Utilities::InputStar::GenElement2D(), Nektar::Utilities::InputTec::GenElement3D(), Nektar::Utilities::InputStar::GenElement3D(), Nektar::Utilities::InputSem::insertEdge(), Nektar::Utilities::InputNek::LoadHOSurfaces(), PrismLines(), Nektar::Utilities::InputCAD::Process(), Nektar::Utilities::InputGmsh::Process(), Nektar::Utilities::InputNekpp::Process(), Nektar::Utilities::InputSem::Process(), Nektar::Utilities::ProcessCyl::Process(), Nektar::Utilities::ProcessOptiExtract::Process(), Nektar::Utilities::ProcessPerAlign::Process(), Nektar::Utilities::InputTec::Process(), Nektar::Utilities::InputSwan::Process(), Nektar::Utilities::InputVtk::Process(), Nektar::Utilities::OutputVtk::Process(), Nektar::Utilities::InputStar::Process(), Nektar::Utilities::ProcessSpherigon::Process(), Nektar::Utilities::ProcessLinear::Process(), Nektar::Utilities::OutputNekpp::Process(), Nektar::Utilities::InputNek::Process(), Nektar::Utilities::ProcessExtractTetPrismInterface::Process(), Nektar::Utilities::ProcessJac::Process(), Nektar::Utilities::ProcessDetectSurf::Process(), Nektar::Utilities::ProcessExtractSurf::Process(), Nektar::Utilities::ProcessBL::Process(), Nektar::Utilities::ProcessTetSplit::Process(), Nektar::Utilities::ProcessScalar::Process(), Nektar::Utilities::OutputGmsh::Process(), ProcessComposites(), ProcessEdges(), ProcessElements(), ProcessFaces(), ProcessVertices(), Nektar::Utilities::InputPly::ReadPly(), Nektar::Utilities::InputTec::ReadZone(), ReorderPrisms(), Nektar::Utilities::InputStar::SetupElements(), Nektar::Utilities::OutputNekpp::WriteXmlComposites(), Nektar::Utilities::OutputNekpp::WriteXmlConditions(), Nektar::Utilities::OutputNekpp::WriteXmlCurves(), Nektar::Utilities::OutputNekpp::WriteXmlDomain(), Nektar::Utilities::OutputNekpp::WriteXmlEdges(), Nektar::Utilities::OutputNekpp::WriteXmlElements(), Nektar::Utilities::OutputNekpp::WriteXmlExpansions(), Nektar::Utilities::OutputNekpp::WriteXmlFaces(), and Nektar::Utilities::OutputNekpp::WriteXmlNodes().

bool Nektar::Utilities::Module::m_requireEquiSpaced
protected