Nektar++
MeshGraph.h
Go to the documentation of this file.
1 ////////////////////////////////////////////////////////////////////////////////
2 //
3 // File: MeshGraph.h
4 //
5 // For more information, please see: http://www.nektar.info/
6 //
7 // The MIT License
8 //
9 // Copyright (c) 2006 Division of Applied Mathematics, Brown University (USA),
10 // Department of Aeronautics, Imperial College London (UK), and Scientific
11 // Computing and Imaging Institute, University of Utah (USA).
12 //
13 // License for the specific language governing rights and limitations under
14 // Permission is hereby granted, free of charge, to any person obtaining a
15 // copy of this software and associated documentation files (the "Software"),
16 // to deal in the Software without restriction, including without limitation
17 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
18 // and/or sell copies of the Software, and to permit persons to whom the
19 // Software is furnished to do so, subject to the following conditions:
20 //
21 // The above copyright notice and this permission notice shall be included
22 // in all copies or substantial portions of the Software.
23 //
24 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
25 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
26 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
27 // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
28 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
29 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
30 // DEALINGS IN THE SOFTWARE.
31 //
32 // Description:
33 //
34 ////////////////////////////////////////////////////////////////////////////////
35 #ifndef NEKTAR_SPATIALDOMAINS_MESHGRAPH_H
36 #define NEKTAR_SPATIALDOMAINS_MESHGRAPH_H
37 
38 #include <boost/unordered_map.hpp>
39 
42 
43 #include <SpatialDomains/SegGeom.h>
44 #include <SpatialDomains/TriGeom.h>
46 #include <SpatialDomains/TetGeom.h>
47 #include <SpatialDomains/PyrGeom.h>
49 #include <SpatialDomains/HexGeom.h>
50 
51 #include <SpatialDomains/Curve.hpp>
53 
54 class TiXmlDocument;
55 
56 namespace Nektar
57 {
58  namespace SpatialDomains
59  {
61  {
80  };
81 
82  // Keep this consistent with the enums in ExpansionType.
83  // This is used in the BC file to specify the expansion type.
84  const std::string kExpansionTypeStr[] =
85  {
86  "NOTYPE",
87  "MODIFIED",
88  "MODIFIEDQUADPLUS1",
89  "MODIFIEDQUADPLUS2",
90  "ORTHOGONAL",
91  "GLL_LAGRANGE",
92  "GLL_LAGRANGE_SEM",
93  "GAUSS_LAGRANGE",
94  "GAUSS_LAGRANGE_SEM",
95  "FOURIER",
96  "FOURIERSINGLEMODE",
97  "FOURIERHALFMODERE",
98  "FOURIERHALFMODEIM",
99  "CHEBYSHEV",
100  "FOURIER-CHEBYSHEV",
101  "CHEBYSHEV-FOURIER",
102  "FOURIER-MODIFIED"
103  };
104 
106  typedef boost::shared_ptr< InterfaceComponent > SharedInterfaceCompPtr;
107  typedef std::vector< PointGeomSharedPtr > PointGeomVector;
108  typedef std::map<int, PointGeomSharedPtr> PointGeomMap;
109  typedef std::list< SharedInterfaceCompPtr > InterfaceCompList;
110 
111  typedef boost::shared_ptr< GeometryVector > Composite;
112  typedef std::map<int, Composite> CompositeMap;
114  typedef std::map<int, Composite>::const_iterator CompositeMapConstIter;
115 
116  struct ElementEdge
117  {
120  };
121 
122  struct ElementFace
123  {
126  };
127 
128 
129  typedef boost::shared_ptr<ElementEdge> ElementEdgeSharedPtr;
130  typedef std::vector<ElementEdgeSharedPtr> ElementEdgeVector;
131  typedef boost::shared_ptr<ElementEdgeVector> ElementEdgeVectorSharedPtr;
132 
133  typedef boost::shared_ptr<ElementFace> ElementFaceSharedPtr;
134  typedef std::vector<ElementFaceSharedPtr> ElementFaceVector;
135  typedef boost::shared_ptr<ElementFaceVector> ElementFaceVectorSharedPtr;
136 
137  // set restriction on domain range for post-processing.
138  struct DomainRange
139  {
149 
152  };
153 
154  typedef boost::shared_ptr<DomainRange> DomainRangeShPtr;
155  static DomainRangeShPtr NullDomainRangeShPtr;
156 
157  struct Expansion
158  {
160  const LibUtilities::BasisKeyVector basiskeyvec):
161  m_geomShPtr(geomShPtr),
162  m_basisKeyVector(basiskeyvec)
163  {
164  }
165 
168  };
169 
170  typedef boost::shared_ptr<Expansion> ExpansionShPtr;
171  typedef std::map<int, ExpansionShPtr> ExpansionMap;
173  typedef std::map<int, ExpansionShPtr>::const_iterator ExpansionMapConstIter;
174 
175  typedef boost::shared_ptr<ExpansionMap> ExpansionMapShPtr;
176  typedef std::map<std::string, ExpansionMapShPtr> ExpansionMapShPtrMap;
178 
179 
180  typedef std::map<std::string, std::string> GeomInfoMap;
181 
182  /// Base class for a spectral/hp element mesh.
183  class MeshGraph
184  {
185  public:
187 
189  unsigned int meshDimension,
190  unsigned int spaceDimension);
191 
193  const LibUtilities::SessionReaderSharedPtr &pSession,
194  const DomainRangeShPtr &rng = NullDomainRangeShPtr);
195 
196 
198 
199 
200  /* ---- Mesh Reading routines ---- */
201  SPATIAL_DOMAINS_EXPORT static boost::shared_ptr<MeshGraph> Read(
202  const LibUtilities::SessionReaderSharedPtr &pSession,
203  DomainRangeShPtr &rng = NullDomainRangeShPtr);
204 
205  /// \todo Remove updated routine
206  SPATIAL_DOMAINS_EXPORT static boost::shared_ptr<MeshGraph> Read(
207  const std::string& infilename,
208  bool pReadExpansions = true);
209 
210 
211  /// Read will read the meshgraph vertices given a filename.
213  const std::string& infilename);
214 
215  /// Read will read the meshgraph vertices given a TiXmlDocument.
217  TiXmlDocument &doc);
218 
219  /// Read geometric information from a file.
221  const std::string &infilename);
222 
223  /// Read geometric information from an XML document.
225  TiXmlDocument &doc);
226 
227  /// Read the expansions given the XML file path.
229  const std::string &infilename);
230 
231  /// Read the expansions given the XML document reference.
233  TiXmlDocument &doc);
234 
236  TiXmlDocument &doc);
237 
239  TiXmlDocument &doc);
240 
242  std::string &infilename);
243 
245  std::string &outfilename);
246 
248  TiXmlDocument &doc);
249 
250  /* ---- Helper functions ---- */
251  /// Dimension of the mesh (can be a 1D curve in 3D space).
252  inline int GetMeshDimension() const;
253 
254  /// Dimension of the space (can be a 1D curve in 3D space).
255  inline int GetSpaceDimension() const;
256 
257 
258  /* Range definitions for postprorcessing */
260  (NekDouble xmin, NekDouble xmax,
265 
266  /// Check if goemetry is in range definition if activated
267  bool CheckRange(Geometry2D &geom);
268 
269  /// Check if goemetry is in range definition if activated
270  bool CheckRange(Geometry3D &geom);
271 
272  /* ---- Composites and Domain ---- */
273  inline Composite GetComposite(int whichComposite) const;
274 
276  int whichComposite,
277  int whichItem);
278 
280  const std::string &compositeStr,
281  CompositeMap &compositeVector) const;
282 
283  inline const CompositeMap &GetComposites() const;
284 
285  inline const std::vector<CompositeMap> &GetDomain(void) const;
286 
287  inline const CompositeMap &GetDomain(int domain) const;
288 
289 
290  /* ---- Expansions ---- */
291  inline const ExpansionMap &GetExpansions();
292 
293  SPATIAL_DOMAINS_EXPORT const ExpansionMap &GetExpansions(
294  const std::string variable);
295 
296  SPATIAL_DOMAINS_EXPORT ExpansionShPtr GetExpansion(
297  GeometrySharedPtr geom, const std::string variable = "DefaultVar");
298 
299  /// Sets expansions given field definitions
301  std::vector<LibUtilities::FieldDefinitionsSharedPtr>
302  &fielddef);
303 
304  /// Sets expansions given field definition, quadrature points.
306  std::vector<LibUtilities::FieldDefinitionsSharedPtr>
307  &fielddef,
308  std::vector< std::vector<LibUtilities::PointsType> >
309  &pointstype );
310 
311  /// Sets expansions to have equispaced points
313  int npoints = 0);
314 
315  /// Reset expansion to have specified polynomial order \a nmodes
317 
318  /// This function sets the expansion #exp in map with entry #variable
319 
320  inline void SetExpansions(
321  const std::string variable,
322  ExpansionMapShPtr &exp);
323 
324  /// Sets the basis key for all expansions of the given shape.
328  std::string var = "DefaultVar");
329 
330  inline bool SameExpansions(
331  const std::string var1,
332  const std::string var2);
333 
334  inline bool CheckForGeomInfo(std::string parameter);
335 
336  inline const std::string GetGeomInfo(std::string parameter);
337 
341  ExpansionType type,
342  const int order);
343 
347  ExpansionType type_x,
348  ExpansionType type_y,
349  ExpansionType type_z,
350  const int nummodes_x,
351  const int nummodes_y,
352  const int nummodes_z);
353 
354 
355  /* ---- Manipulation of mesh ---- */
356  inline int GetNvertices() const;
357 
358  inline PointGeomSharedPtr GetVertex(int id);
359  /// Adds a vertex to the with the next available ID.
361  NekDouble x,
362  NekDouble y,
363  NekDouble z);
364 
365  /// \brief Adds an edge between two points. If curveDefinition is
366  /// null, then the edge is straight, otherwise it is curved according
367  /// to the curveDefinition.
369  CurveSharedPtr curveDefinition = CurveSharedPtr());
371 
380 
381  SPATIAL_DOMAINS_EXPORT const PointGeomMap& GetVertSet() const { return m_vertSet; }
382 
385 
386  // void AddExpansion(ExpansionShPtr expansion) { m_expansions[expansion->m_geomShPtr->GetGlobalID()] = expansion; }
394 
395  /// Convenience method for ElVis.
396  template<typename ElementType>
397  const std::map<int, boost::shared_ptr<ElementType> >& GetAllElementsOfType() const;
398 
399  protected:
401  PointGeomMap m_vertSet;
402  InterfaceCompList m_iComps;
403 
406 
408 
415 
420 
421  CompositeMap m_meshComposites;
422  std::vector<CompositeMap> m_domain;
423  DomainRangeShPtr m_domainRange;
424 
425  ExpansionMapShPtrMap m_expansionMapShPtrMap;
426 
427  GeomInfoMap m_geomInfo;
428 
429 
430  ExpansionMapShPtr SetUpExpansionMap(void);
431  };
432  typedef boost::shared_ptr<MeshGraph> MeshGraphSharedPtr;
433 
434 
435  /**
436  *
437  */
438  inline int MeshGraph::GetMeshDimension(void) const
439  {
440  return m_meshDimension;
441  }
442 
443 
444  /**
445  *
446  */
447  inline int MeshGraph::GetSpaceDimension(void) const
448  {
449  return m_spaceDimension;
450  }
451 
452 
453  /**
454  *
455  */
456  inline Composite MeshGraph::GetComposite(int whichComposite) const
457  {
458  Composite returnval;
459  ASSERTL0(m_meshComposites.find(whichComposite) != m_meshComposites.end(),
460  "Composite not found.");
461  return m_meshComposites.find(whichComposite)->second;
462  }
463 
464 
465  /**
466  *
467  */
468  inline const CompositeMap &MeshGraph::GetComposites() const
469  {
470  return m_meshComposites;
471  }
472 
473 
474  /**
475  *
476  */
477  inline const std::vector<CompositeMap> &MeshGraph::GetDomain(void) const
478  {
479  return m_domain;
480  }
481 
482  /**
483  *
484  */
485  inline const CompositeMap &MeshGraph::GetDomain(const int domain) const
486  {
487  ASSERTL1(domain < m_domain.size(),"Request for domain which does not exist");
488  return m_domain[domain];
489  }
490 
491 
492  /**
493  *
494  */
495  inline const ExpansionMap &MeshGraph::GetExpansions()
496  {
497  std::string defstr = "DefaultVar";
498  return GetExpansions(defstr);
499  }
500 
501 
502  /**
503  *
504  */
505  void MeshGraph::SetExpansions(const std::string variable, ExpansionMapShPtr &exp)
506  {
507  if(m_expansionMapShPtrMap.count(variable) != 0)
508  {
509  ASSERTL0(false,(std::string("Expansion field is already set for variable ") + variable).c_str());
510  }
511  else
512  {
513  m_expansionMapShPtrMap[variable] = exp;
514  }
515  }
516 
517 
518  /**
519  *
520  */
521  inline bool MeshGraph::SameExpansions(const std::string var1, const std::string var2)
522  {
523  ExpansionMapShPtr expVec1 = m_expansionMapShPtrMap.find(var1)->second;
524  ExpansionMapShPtr expVec2 = m_expansionMapShPtrMap.find(var2)->second;
525 
526  if(expVec1.get() == expVec2.get())
527  {
528  return true;
529  }
530 
531  return false;
532  }
533 
534 
535  /**
536  *
537  */
538  inline bool MeshGraph::CheckForGeomInfo(std::string parameter)
539  {
540  return m_geomInfo.find(parameter) != m_geomInfo.end();
541  }
542 
543 
544  /**
545  *
546  */
547  inline const std::string MeshGraph::GetGeomInfo(std::string parameter)
548  {
549  ASSERTL1(m_geomInfo.find(parameter) != m_geomInfo.end(),
550  "Parameter " + parameter + " does not exist.");
551  return m_geomInfo[parameter];
552  }
553 
554 
555  /**
556  *
557  */
558  inline int MeshGraph::GetNvertices() const
559  {
560  return int(m_vertSet.size());
561  }
562 
563 
564  /**
565  *
566  */
568  {
569  PointGeomSharedPtr returnval;
570  PointGeomMap::iterator x = m_vertSet.find(id);
571  ASSERTL0(x != m_vertSet.end(),
572  "Vertex " + boost::lexical_cast<string>(id)
573  + " not found.");
574  return x->second;
575  }
576 
577 
578  /**
579  *
580  */
581  template<>
582  inline const std::map<int, boost::shared_ptr<HexGeom> >& MeshGraph::GetAllElementsOfType() const
583  {
584  return GetAllHexGeoms();
585  }
586 
587 
588  /**
589  *
590  */
591  template<>
592  inline const std::map<int, boost::shared_ptr<PrismGeom> >& MeshGraph::GetAllElementsOfType() const
593  {
594  return GetAllPrismGeoms();
595  }
596 
597 
598  /**
599  *
600  */
601  template<>
602  inline const std::map<int, boost::shared_ptr<TetGeom> >& MeshGraph::GetAllElementsOfType() const
603  {
604  return GetAllTetGeoms();
605  }
606 
607 
608  /**
609  *
610  */
611  template<>
612  inline const std::map<int, boost::shared_ptr<PyrGeom> >& MeshGraph::GetAllElementsOfType() const
613  {
614  return GetAllPyrGeoms();
615  }
616  };
617 };
618 
619 #endif
620 
const std::map< int, boost::shared_ptr< ElementType > > & GetAllElementsOfType() const
Convenience method for ElVis.
std::map< std::string, std::string > GeomInfoMap
Definition: MeshGraph.h:180
void SetExpansions(std::vector< LibUtilities::FieldDefinitionsSharedPtr > &fielddef)
Sets expansions given field definitions.
Definition: MeshGraph.cpp:2158
boost::shared_ptr< PyrGeom > PyrGeomSharedPtr
Definition: PyrGeom.h:83
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:161
const std::vector< CompositeMap > & GetDomain(void) const
Definition: MeshGraph.h:477
LibUtilities::ShapeType m_shapeType
Definition: MeshGraph.h:151
LibUtilities::SessionReaderSharedPtr m_session
Definition: MeshGraph.h:400
int GetSpaceDimension() const
Dimension of the space (can be a 1D curve in 3D space).
Definition: MeshGraph.h:447
boost::shared_ptr< ElementFaceVector > ElementFaceVectorSharedPtr
Definition: MeshGraph.h:135
std::map< int, ExpansionShPtr >::const_iterator ExpansionMapConstIter
Definition: MeshGraph.h:173
const PrismGeomMap & GetAllPrismGeoms() const
Definition: MeshGraph.h:392
void SetExpansionsToPolyOrder(int nmodes)
Reset expansion to have specified polynomial order nmodes.
Definition: MeshGraph.cpp:2937
static boost::shared_ptr< MeshGraph > Read(const LibUtilities::SessionReaderSharedPtr &pSession, DomainRangeShPtr &rng=NullDomainRangeShPtr)
Definition: MeshGraph.cpp:119
void ReadCurves(TiXmlDocument &doc)
Definition: MeshGraph.cpp:1103
std::vector< PointGeomSharedPtr > PointGeomVector
Definition: Geometry3D.h:61
PrismGeomSharedPtr AddPrism(TriGeomSharedPtr tfaces[PrismGeom::kNtfaces], QuadGeomSharedPtr qfaces[PrismGeom::kNqfaces])
Definition: MeshGraph.cpp:3847
boost::shared_ptr< QuadGeom > QuadGeomSharedPtr
Definition: QuadGeom.h:54
int GetMeshDimension() const
Dimension of the mesh (can be a 1D curve in 3D space).
Definition: MeshGraph.h:438
PointGeomSharedPtr GetVertex(int id)
Definition: MeshGraph.h:567
boost::shared_ptr< InterfaceComponent > SharedInterfaceCompPtr
Definition: MeshGraph.h:105
std::map< int, PrismGeomSharedPtr > PrismGeomMap
Definition: PrismGeom.h:112
std::vector< ElementFaceSharedPtr > ElementFaceVector
Definition: MeshGraph.h:134
bool SameExpansions(const std::string var1, const std::string var2)
Definition: MeshGraph.h:521
const SegGeomMap & GetAllSegGeoms() const
Definition: MeshGraph.h:387
static const int kNtfaces
Definition: TetGeom.h:59
boost::shared_ptr< HexGeom > HexGeomSharedPtr
Definition: HexGeom.h:110
PointGeomSharedPtr AddVertex(NekDouble x, NekDouble y, NekDouble z)
Adds a vertex to the with the next available ID.
Definition: MeshGraph.cpp:3784
std::map< int, PyrGeomSharedPtr > PyrGeomMap
Definition: PyrGeom.h:86
Expansion(GeometrySharedPtr geomShPtr, const LibUtilities::BasisKeyVector basiskeyvec)
Definition: MeshGraph.h:159
QuadGeomSharedPtr AddQuadrilateral(SegGeomSharedPtr edges[], StdRegions::Orientation orient[])
Definition: MeshGraph.cpp:3833
boost::shared_ptr< SessionReader > SessionReaderSharedPtr
Definition: MeshPartition.h:50
virtual void ReadGeometry(const std::string &infilename)
Read will read the meshgraph vertices given a filename.
Definition: MeshGraph.cpp:230
boost::shared_ptr< Curve > CurveSharedPtr
Definition: Curve.hpp:62
const ExpansionMap & GetExpansions()
Definition: MeshGraph.h:495
static LibUtilities::BasisKeyVector DefineBasisKeyFromExpansionType(GeometrySharedPtr in, ExpansionType type, const int order)
Definition: MeshGraph.cpp:2996
std::map< int, TetGeomSharedPtr > TetGeomMap
Definition: TetGeom.h:109
bool CheckForGeomInfo(std::string parameter)
Definition: MeshGraph.h:538
std::map< int, TriGeomSharedPtr > TriGeomMap
Definition: TriGeom.h:62
const PyrGeomMap & GetAllPyrGeoms() const
Definition: MeshGraph.h:391
TriGeomSharedPtr AddTriangle(SegGeomSharedPtr edges[], StdRegions::Orientation orient[])
Definition: MeshGraph.cpp:3818
DomainRangeShPtr m_domainRange
Definition: MeshGraph.h:423
boost::shared_ptr< ElementEdge > ElementEdgeSharedPtr
Definition: MeshGraph.h:129
void WriteGeometry(std::string &outfilename)
Write out an XML file containing the GEOMETRY block representing this MeshGraph instance inside a NEK...
Definition: MeshGraph.cpp:1761
std::map< int, PointGeomSharedPtr > PointGeomMap
Definition: MeshGraph.h:108
GeometrySharedPtr GetCompositeItem(int whichComposite, int whichItem)
Definition: MeshGraph.cpp:2023
boost::shared_ptr< ExpansionMap > ExpansionMapShPtr
Definition: MeshGraph.h:175
SegGeomSharedPtr AddEdge(PointGeomSharedPtr v0, PointGeomSharedPtr v1, CurveSharedPtr curveDefinition=CurveSharedPtr())
Adds an edge between two points. If curveDefinition is null, then the edge is straight, otherwise it is curved according to the curveDefinition.
Definition: MeshGraph.cpp:3795
Composite GetComposite(int whichComposite) const
Definition: MeshGraph.h:456
boost::shared_ptr< SegGeom > SegGeomSharedPtr
Definition: Geometry2D.h:60
std::map< std::string, ExpansionMapShPtr >::iterator ExpansionMapShPtrMapIter
Definition: MeshGraph.h:177
const HexGeomMap & GetAllHexGeoms() const
Definition: MeshGraph.h:393
std::map< int, Composite >::const_iterator CompositeMapConstIter
Definition: MeshGraph.h:114
std::map< int, SegGeomSharedPtr > SegGeomMap
Definition: SegGeom.h:54
boost::shared_ptr< DomainRange > DomainRangeShPtr
Definition: MeshGraph.h:154
PyrGeomSharedPtr AddPyramid(TriGeomSharedPtr tfaces[PyrGeom::kNtfaces], QuadGeomSharedPtr qfaces[PyrGeom::kNqfaces])
Definition: MeshGraph.cpp:3878
std::map< int, Composite >::iterator CompositeMapIter
Definition: MeshGraph.h:113
GeometrySharedPtr m_geomShPtr
Definition: MeshGraph.h:166
double NekDouble
LibUtilities::BasisKeyVector DefineBasisKeyFromExpansionTypeHomo(GeometrySharedPtr in, ExpansionType type_x, ExpansionType type_y, ExpansionType type_z, const int nummodes_x, const int nummodes_y, const int nummodes_z)
Definition: MeshGraph.cpp:3577
std::vector< BasisKey > BasisKeyVector
Name for a vector of BasisKeys.
std::map< std::string, ExpansionMapShPtr > ExpansionMapShPtrMap
Definition: MeshGraph.h:176
boost::shared_ptr< GeometryVector > Composite
Definition: MeshGraph.h:111
static const NekDouble kNekUnsetDouble
boost::shared_ptr< ElementFace > ElementFaceSharedPtr
Definition: MeshGraph.h:133
std::map< int, Composite > CompositeMap
Definition: MeshGraph.h:112
const std::string GetGeomInfo(std::string parameter)
Definition: MeshGraph.h:547
const PointGeomMap & GetVertSet() const
Definition: MeshGraph.h:381
static const int kNtfaces
Definition: PyrGeom.h:59
SegGeomSharedPtr GetEdge(unsigned int id)
Definition: MeshGraph.h:370
const QuadGeomMap & GetAllQuadGeoms() const
Definition: MeshGraph.h:389
boost::shared_ptr< ElementEdgeVector > ElementEdgeVectorSharedPtr
Definition: MeshGraph.h:131
void ReadGeometryInfo(const std::string &infilename)
Read geometric information from a file.
Definition: MeshGraph.cpp:470
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs typedef NekMatrix< LhsDataType, StandardMatrixTag >::iterator iterator
std::map< int, QuadGeomSharedPtr > QuadGeomMap
Definition: QuadGeom.h:57
static const int kNqfaces
Definition: PyrGeom.h:58
3D geometry information
Definition: Geometry3D.h:70
std::vector< CompositeMap > m_domain
Definition: MeshGraph.h:422
void GetCompositeList(const std::string &compositeStr, CompositeMap &compositeVector) const
Definition: MeshGraph.cpp:2061
static DomainRangeShPtr NullDomainRangeShPtr
Definition: MeshGraph.h:155
2D geometry information
Definition: Geometry2D.h:65
boost::shared_ptr< Expansion > ExpansionShPtr
Definition: MeshGraph.h:170
ExpansionMapShPtrMap m_expansionMapShPtrMap
Definition: MeshGraph.h:425
Base class for a spectral/hp element mesh.
Definition: MeshGraph.h:183
std::list< SharedInterfaceCompPtr > InterfaceCompList
Definition: MeshGraph.h:109
void ReadDomain(TiXmlDocument &doc)
Definition: MeshGraph.cpp:1009
boost::shared_ptr< PrismGeom > PrismGeomSharedPtr
Definition: PrismGeom.h:109
void SetDomainRange(NekDouble xmin, NekDouble xmax, NekDouble ymin=NekConstants::kNekUnsetDouble, NekDouble ymax=NekConstants::kNekUnsetDouble, NekDouble zmin=NekConstants::kNekUnsetDouble, NekDouble zmax=NekConstants::kNekUnsetDouble)
Definition: MeshGraph.cpp:1775
bool CheckRange(Geometry2D &geom)
Check if goemetry is in range definition if activated.
Definition: MeshGraph.cpp:1813
void SetBasisKey(LibUtilities::ShapeType shape, LibUtilities::BasisKeyVector &keys, std::string var="DefaultVar")
Sets the basis key for all expansions of the given shape.
Definition: MeshGraph.cpp:2975
ExpansionShPtr GetExpansion(GeometrySharedPtr geom, const std::string variable="DefaultVar")
Definition: MeshGraph.cpp:2136
boost::shared_ptr< TetGeom > TetGeomSharedPtr
Definition: TetGeom.h:106
boost::shared_ptr< TriGeom > TriGeomSharedPtr
Definition: TriGeom.h:58
HexGeomSharedPtr AddHexahedron(QuadGeomSharedPtr qfaces[HexGeom::kNqfaces])
Definition: MeshGraph.cpp:3895
ExpansionMapShPtr SetUpExpansionMap(void)
Definition: MeshGraph.cpp:3912
void ReadExpansions(const std::string &infilename)
Read the expansions given the XML file path.
Definition: MeshGraph.cpp:525
boost::unordered_map< int, CurveSharedPtr > CurveMap
Definition: Curve.hpp:63
static const int kNqfaces
Definition: HexGeom.h:62
const CompositeMap & GetComposites() const
Definition: MeshGraph.h:468
const std::string kExpansionTypeStr[]
Definition: MeshGraph.h:84
const TetGeomMap & GetAllTetGeoms() const
Definition: MeshGraph.h:390
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:191
boost::shared_ptr< MeshGraph > MeshGraphSharedPtr
Definition: MeshGraph.h:432
std::map< int, HexGeomSharedPtr > HexGeomMap
Definition: HexGeom.h:113
boost::shared_ptr< Geometry > GeometrySharedPtr
Definition: Geometry.h:53
void SetExpansionsToEvenlySpacedPoints(int npoints=0)
Sets expansions to have equispaced points.
Definition: MeshGraph.cpp:2895
boost::shared_ptr< PointGeom > PointGeomSharedPtr
Definition: Geometry.h:60
#define SPATIAL_DOMAINS_EXPORT
LibUtilities::BasisKeyVector m_basisKeyVector
Definition: MeshGraph.h:167
std::map< int, ExpansionShPtr > ExpansionMap
Definition: MeshGraph.h:171
TetGeomSharedPtr AddTetrahedron(TriGeomSharedPtr tfaces[TetGeom::kNtfaces])
Definition: MeshGraph.cpp:3864
std::map< int, ExpansionShPtr >::iterator ExpansionMapIter
Definition: MeshGraph.h:172
std::vector< ElementEdgeSharedPtr > ElementEdgeVector
Definition: MeshGraph.h:130
const TriGeomMap & GetAllTriGeoms() const
Definition: MeshGraph.h:388