Nektar++
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Public Member Functions | Protected Member Functions | List of all members
Nektar::SpatialDomains::MeshGraph2D Class Reference

#include <MeshGraph2D.h>

Inheritance diagram for Nektar::SpatialDomains::MeshGraph2D:
Inheritance graph
[legend]
Collaboration diagram for Nektar::SpatialDomains::MeshGraph2D:
Collaboration graph
[legend]

Public Member Functions

 MeshGraph2D ()
 
 MeshGraph2D (const LibUtilities::SessionReaderSharedPtr &pSession, const DomainRangeShPtr &rng=NullDomainRangeShPtr)
 
virtual ~MeshGraph2D ()
 
void ReadGeometry (const std::string &infilename)
 Read will read the meshgraph vertices given a filename. More...
 
void ReadGeometry (TiXmlDocument &doc)
 Read will read the meshgraph vertices given a TiXmlDocument. More...
 
SegGeomSharedPtr GetSegGeom (int eID)
 
int GetCoordim (void)
 
const TriGeomMap & GetTrigeoms (void) const
 
const QuadGeomMap & GetQuadgeoms (void) const
 
void GenXGeoFac ()
 
int GetNseggeoms () const
 
int GetVidFromElmt (LibUtilities::ShapeType shape, const int vert, const int elmt) const
 
int GetEidFromElmt (LibUtilities::ShapeType shape, const int edge, const int elmt) const
 
StdRegions::Orientation GetEorientFromElmt (LibUtilities::ShapeType shape, const int edge, const int elmt) const
 
StdRegions::Orientation GetCartesianEorientFromElmt (LibUtilities::ShapeType shape, const int edge, const int elmt) const
 
int GetNumComposites (void)
 
int GetNumCompositeItems (int whichComposite)
 
ElementEdgeVectorSharedPtr GetElementsFromEdge (SegGeomSharedPtr edge)
 Return the elements (shared ptrs) that have this edge. More...
 
ElementEdgeVectorSharedPtr GetElementsFromEdge (Geometry1DSharedPtr edge)
 
LibUtilities::BasisKey GetEdgeBasisKey (SegGeomSharedPtr edge, const std::string variable="DefaultVar")
 Return the BasisKey corresponding to an edge of an element If the expansion is a triangle the Modified_B direction is modified to be one-dimensional Modified_A,GaussLobattoLegendre. More...
 
- Public Member Functions inherited from Nektar::SpatialDomains::MeshGraph
 MeshGraph ()
 
 MeshGraph (unsigned int meshDimension, unsigned int spaceDimension)
 
 MeshGraph (const LibUtilities::SessionReaderSharedPtr &pSession, const DomainRangeShPtr &rng=NullDomainRangeShPtr)
 
virtual ~MeshGraph ()
 
void ReadGeometryInfo (const std::string &infilename)
 Read geometric information from a file. More...
 
void ReadGeometryInfo (TiXmlDocument &doc)
 Read geometric information from an XML document. More...
 
void ReadExpansions (const std::string &infilename)
 Read the expansions given the XML file path. More...
 
void ReadExpansions (TiXmlDocument &doc)
 Read the expansions given the XML document reference. More...
 
void ReadDomain (TiXmlDocument &doc)
 
void ReadCurves (TiXmlDocument &doc)
 
void ReadCurves (std::string &infilename)
 
void WriteGeometry (std::string &outfilename)
 Write out an XML file containing the GEOMETRY block representing this MeshGraph instance inside a NEKTAR tag. More...
 
void WriteGeometry (TiXmlDocument &doc)
 Populate a TinyXML document with a GEOMETRY tag inside the NEKTAR tag. More...
 
int GetMeshDimension () const
 Dimension of the mesh (can be a 1D curve in 3D space). More...
 
int GetSpaceDimension () const
 Dimension of the space (can be a 1D curve in 3D space). More...
 
void SetDomainRange (NekDouble xmin, NekDouble xmax, NekDouble ymin=NekConstants::kNekUnsetDouble, NekDouble ymax=NekConstants::kNekUnsetDouble, NekDouble zmin=NekConstants::kNekUnsetDouble, NekDouble zmax=NekConstants::kNekUnsetDouble)
 
bool CheckRange (Geometry2D &geom)
 Check if goemetry is in range definition if activated. More...
 
bool CheckRange (Geometry3D &geom)
 Check if goemetry is in range definition if activated. More...
 
Composite GetComposite (int whichComposite) const
 
GeometrySharedPtr GetCompositeItem (int whichComposite, int whichItem)
 
void GetCompositeList (const std::string &compositeStr, CompositeMap &compositeVector) const
 
const CompositeMap & GetComposites () const
 
const map< int, string > & GetCompositesLabels () const
 Return a map of integers and strings containing the labels of each composite. More...
 
const std::vector< CompositeMap > & GetDomain (void) const
 
const CompositeMap & GetDomain (int domain) const
 
const ExpansionMap & GetExpansions ()
 
const ExpansionMap & GetExpansions (const std::string variable)
 
ExpansionShPtr GetExpansion (GeometrySharedPtr geom, const std::string variable="DefaultVar")
 
void SetExpansions (std::vector< LibUtilities::FieldDefinitionsSharedPtr > &fielddef)
 Sets expansions given field definitions. More...
 
void SetExpansions (std::vector< LibUtilities::FieldDefinitionsSharedPtr > &fielddef, std::vector< std::vector< LibUtilities::PointsType > > &pointstype)
 Sets expansions given field definition, quadrature points. More...
 
void SetExpansionsToEvenlySpacedPoints (int npoints=0)
 Sets expansions to have equispaced points. More...
 
void SetExpansionsToPolyOrder (int nmodes)
 Reset expansion to have specified polynomial order nmodes. More...
 
void SetExpansionsToPointOrder (int npts)
 Reset expansion to have specified point order npts. More...
 
void SetExpansions (const std::string variable, ExpansionMapShPtr &exp)
 This function sets the expansion #exp in map with entry #variable. More...
 
void SetBasisKey (LibUtilities::ShapeType shape, LibUtilities::BasisKeyVector &keys, std::string var="DefaultVar")
 Sets the basis key for all expansions of the given shape. More...
 
bool SameExpansions (const std::string var1, const std::string var2)
 
bool CheckForGeomInfo (std::string parameter)
 
const std::string GetGeomInfo (std::string parameter)
 
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)
 
int GetNvertices () const
 
PointGeomSharedPtr GetVertex (int id)
 
PointGeomSharedPtr AddVertex (NekDouble x, NekDouble y, NekDouble z)
 Adds a vertex to the with the next available ID. More...
 
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. More...
 
SegGeomSharedPtr GetEdge (unsigned int id)
 
TriGeomSharedPtr AddTriangle (SegGeomSharedPtr edges[], StdRegions::Orientation orient[])
 
QuadGeomSharedPtr AddQuadrilateral (SegGeomSharedPtr edges[], StdRegions::Orientation orient[])
 
TetGeomSharedPtr AddTetrahedron (TriGeomSharedPtr tfaces[TetGeom::kNtfaces])
 
PyrGeomSharedPtr AddPyramid (TriGeomSharedPtr tfaces[PyrGeom::kNtfaces], QuadGeomSharedPtr qfaces[PyrGeom::kNqfaces])
 
PrismGeomSharedPtr AddPrism (TriGeomSharedPtr tfaces[PrismGeom::kNtfaces], QuadGeomSharedPtr qfaces[PrismGeom::kNqfaces])
 
HexGeomSharedPtr AddHexahedron (QuadGeomSharedPtr qfaces[HexGeom::kNqfaces])
 
const PointGeomMap & GetVertSet () const
 
CurveMap & GetCurvedEdges ()
 
CurveMap & GetCurvedFaces ()
 
const PointGeomMap & GetAllPointGeoms () const
 
const SegGeomMap & GetAllSegGeoms () const
 
const TriGeomMap & GetAllTriGeoms () const
 
const QuadGeomMap & GetAllQuadGeoms () const
 
const TetGeomMap & GetAllTetGeoms () const
 
const PyrGeomMap & GetAllPyrGeoms () const
 
const PrismGeomMap & GetAllPrismGeoms () const
 
const HexGeomMap & GetAllHexGeoms () const
 
template<typename ElementType >
const std::map< int,
boost::shared_ptr< ElementType > > & 		GetAllElementsOfType () const
 Convenience method for ElVis. More...
 
template<>
const std::map< int,
boost::shared_ptr< SegGeom > > & 		GetAllElementsOfType () const
 
template<>
const std::map< int,
boost::shared_ptr< TriGeom > > & 		GetAllElementsOfType () const
 
template<>
const std::map< int,
boost::shared_ptr< QuadGeom > > & 		GetAllElementsOfType () const
 
template<>
const std::map< int,
boost::shared_ptr< HexGeom > > & 		GetAllElementsOfType () const
 
template<>
const std::map< int,
boost::shared_ptr< PrismGeom > > & 		GetAllElementsOfType () const
 
template<>
const std::map< int,
boost::shared_ptr< TetGeom > > & 		GetAllElementsOfType () const
 
template<>
const std::map< int,
boost::shared_ptr< PyrGeom > > & 		GetAllElementsOfType () const
 

Protected Member Functions

void ReadEdges (TiXmlDocument &doc)
 
void ReadElements (TiXmlDocument &doc)
 
void ReadComposites (TiXmlDocument &doc)
 
void ResolveGeomRef (const std::string &prevToken, const std::string &token, Composite &composite)
 
- Protected Member Functions inherited from Nektar::SpatialDomains::MeshGraph
ExpansionMapShPtr SetUpExpansionMap (void)
 

Additional Inherited Members

- Static Public Member Functions inherited from Nektar::SpatialDomains::MeshGraph
static boost::shared_ptr
< MeshGraph > 		Read (const LibUtilities::SessionReaderSharedPtr &pSession, DomainRangeShPtr &rng=NullDomainRangeShPtr)
 
static boost::shared_ptr
< MeshGraph > 		Read (const std::string &infilename, bool pReadExpansions=true)
 
static LibUtilities::BasisKeyVector DefineBasisKeyFromExpansionType (GeometrySharedPtr in, ExpansionType type, const int order)
 
- Protected Attributes inherited from Nektar::SpatialDomains::MeshGraph
LibUtilities::SessionReaderSharedPtr m_session
 
PointGeomMap m_vertSet
 
InterfaceCompList m_iComps
 
CurveMap m_curvedEdges
 
CurveMap m_curvedFaces
 
SegGeomMap m_segGeoms
 
TriGeomMap m_triGeoms
 
QuadGeomMap m_quadGeoms
 
TetGeomMap m_tetGeoms
 
PyrGeomMap m_pyrGeoms
 
PrismGeomMap m_prismGeoms
 
HexGeomMap m_hexGeoms
 
int m_meshDimension
 
int m_spaceDimension
 
int m_partition
 
bool m_meshPartitioned
 
CompositeMap m_meshComposites
 
map< int, string > m_compositesLabels
 
std::vector< CompositeMap > m_domain
 
DomainRangeShPtr m_domainRange
 
ExpansionMapShPtrMap m_expansionMapShPtrMap
 
GeomInfoMap m_geomInfo
 

Detailed Description

Definition at line 54 of file MeshGraph2D.h.

Constructor & Destructor Documentation

Nektar::SpatialDomains::MeshGraph2D::MeshGraph2D ( )

Definition at line 46 of file MeshGraph2D.cpp.

47  {
48  }
Nektar::SpatialDomains::MeshGraph2D::MeshGraph2D ( const LibUtilities::SessionReaderSharedPtr &  pSession,
const DomainRangeShPtr &  rng = NullDomainRangeShPtr 
)

Definition at line 54 of file MeshGraph2D.cpp.

References Nektar::SpatialDomains::MeshGraph::ReadExpansions(), and ReadGeometry().

56  : MeshGraph(pSession,rng)
57  {
58  ReadGeometry(pSession->GetDocument());
59  ReadExpansions(pSession->GetDocument());
60  }
Nektar::SpatialDomains::MeshGraph2D::ReadGeometry
void ReadGeometry(const std::string &infilename)
Read will read the meshgraph vertices given a filename.
Definition: MeshGraph2D.cpp:62
Nektar::SpatialDomains::MeshGraph::ReadExpansions
void ReadExpansions(const std::string &infilename)
Read the expansions given the XML file path.
Definition: MeshGraph.cpp:580
Nektar::SpatialDomains::MeshGraph2D::~MeshGraph2D ( )
virtual

Definition at line 50 of file MeshGraph2D.cpp.

51  {
52  }

Member Function Documentation

void Nektar::SpatialDomains::MeshGraph2D::GenXGeoFac ( )
StdRegions::Orientation Nektar::SpatialDomains::MeshGraph2D::GetCartesianEorientFromElmt ( LibUtilities::ShapeType  shape,
const int  edge,
const int  elmt 
) const
inline

Definition at line 154 of file MeshGraph2D.h.

References ASSERTL2, Nektar::StdRegions::eBackwards, Nektar::StdRegions::eForwards, Nektar::LibUtilities::eTriangle, Nektar::SpatialDomains::MeshGraph::m_quadGeoms, and Nektar::SpatialDomains::MeshGraph::m_triGeoms.

155  {
156  StdRegions::Orientation returnval;
157 
158  if(shape == LibUtilities::eTriangle)
159  {
160  ASSERTL2(m_triGeoms.find(elmt) != m_triGeoms.end(),
161  "eid is out of range");
162 
163  returnval = m_triGeoms.find(elmt)->second->GetEorient(edge);
164  }
165  else
166  {
167  ASSERTL2(m_quadGeoms.find(elmt) != m_quadGeoms.end(),
168  "eid is out of range");
169 
170  returnval = m_quadGeoms.find(elmt)->second->GetEorient(edge);
171  }
172 
173  // swap orientation if on edge 2 & 3 (if quad)
174  if(edge >= 2)
175  {
176  if(returnval == StdRegions::eForwards)
177  {
178  returnval = StdRegions::eBackwards;
179  }
180  else
181  {
182  returnval = StdRegions::eForwards;
183  }
184  }
185  return returnval;
186  }
ASSERTL2
#define ASSERTL2(condition, msg)
Assert Level 2 – Debugging which is used FULLDEBUG compilation mode. This level assert is designed t...
Definition: ErrorUtil.hpp:213
int Nektar::SpatialDomains::MeshGraph2D::GetCoordim ( void  )
inline

Definition at line 69 of file MeshGraph2D.h.

References Nektar::SpatialDomains::MeshGraph::GetSpaceDimension().

69  {
70  return GetSpaceDimension();
71  }
Nektar::SpatialDomains::MeshGraph::GetSpaceDimension
int GetSpaceDimension() const
Dimension of the space (can be a 1D curve in 3D space).
Definition: MeshGraph.h:457
LibUtilities::BasisKey Nektar::SpatialDomains::MeshGraph2D::GetEdgeBasisKey ( SegGeomSharedPtr  edge,
const std::string  variable = "DefaultVar" 
)

Return the BasisKey corresponding to an edge of an element If the expansion is a triangle the Modified_B direction is modified to be one-dimensional Modified_A,GaussLobattoLegendre.

Definition at line 819 of file MeshGraph2D.cpp.

References ASSERTL0, Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eGaussRadauMAlpha1Beta0, Nektar::LibUtilities::eGLL_Lagrange, Nektar::LibUtilities::eModified_A, Nektar::LibUtilities::eModified_B, Nektar::LibUtilities::eOrtho_B, Nektar::LibUtilities::eTriangle, GetElementsFromEdge(), Nektar::SpatialDomains::MeshGraph::GetExpansion(), and Nektar::LibUtilities::NullBasisKey().

820  {
821  ElementEdgeVectorSharedPtr elements = GetElementsFromEdge(edge);
822  // Perhaps, a check should be done here to ensure that
823  // in case elements->size!=1, all elements to which
824  // the edge belongs have the same type and order of
825  // expansion such that no confusion can arise.
826  ExpansionShPtr expansion = GetExpansion((*elements)[0]->m_Element, variable);
827 
828  int edge_id = (*elements)[0]->m_EdgeIndx;
829 
830  if((*elements)[0]->m_Element->GetShapeType() == LibUtilities::eTriangle)
831  {
832  edge_id = (edge_id)? 1:0;
833  }
834  else
835  {
836  edge_id = edge_id%2;
837  }
838 
839  int nummodes = expansion->m_basisKeyVector[edge_id].GetNumModes();
840  int numpoints = expansion->m_basisKeyVector[edge_id].GetNumPoints();
841 
842  if((*elements)[0]->m_Element->GetShapeType() == LibUtilities::eTriangle)
843  {
844  // Use edge 0 to define basis of order relevant to edge
845  switch(expansion->m_basisKeyVector[edge_id].GetBasisType())
846  {
847  case LibUtilities::eGLL_Lagrange:
848  {
849  switch(expansion->m_basisKeyVector[edge_id].GetPointsType())
850  {
851  case LibUtilities::eGaussLobattoLegendre:
852  {
853  const LibUtilities::PointsKey pkey(numpoints,LibUtilities::eGaussLobattoLegendre);
854  return LibUtilities::BasisKey(expansion->m_basisKeyVector[0].GetBasisType(),nummodes,pkey);
855  }
856  break;
857 
858  default:
859  ASSERTL0(false,"Unexpected points distribution");
860 
861  // It doesn't matter what we return
862  // here since the ASSERT will stop
863  // execution. Just return something
864  // to prevent warnings messages.
865  const LibUtilities::PointsKey pkey(numpoints,LibUtilities::eGaussLobattoLegendre);
866  return LibUtilities::BasisKey(expansion->m_basisKeyVector[0].GetBasisType(),nummodes,pkey);
867  break;
868  }
869  }
870  break;
871  case LibUtilities::eOrtho_B: // Assume this is called from nodal triangular basis
872  {
873  switch(expansion->m_basisKeyVector[edge_id].GetPointsType())
874  {
875  case LibUtilities::eGaussRadauMAlpha1Beta0:
876  {
877  const LibUtilities::PointsKey pkey(numpoints+1,LibUtilities::eGaussLobattoLegendre);
878  return LibUtilities::BasisKey(LibUtilities::eGLL_Lagrange,nummodes,pkey);
879  }
880  break;
881 
882  default:
883  ASSERTL0(false,"Unexpected points distribution");
884 
885  // It doesn't matter what we return
886  // here since the ASSERT will stop
887  // execution. Just return something
888  // to prevent warnings messages.
889  const LibUtilities::PointsKey pkey(numpoints+1,LibUtilities::eGaussLobattoLegendre);
890  return LibUtilities::BasisKey(expansion->m_basisKeyVector[0].GetBasisType(),nummodes,pkey);
891  break;
892  }
893  }
894  break;
895  case LibUtilities::eModified_B:
896  {
897  switch(expansion->m_basisKeyVector[edge_id].GetPointsType())
898  {
899  case LibUtilities::eGaussRadauMAlpha1Beta0:
900  {
901  const LibUtilities::PointsKey pkey(numpoints+1,LibUtilities::eGaussLobattoLegendre);
902  return LibUtilities::BasisKey(expansion->m_basisKeyVector[0].GetBasisType(),nummodes,pkey);
903  }
904  break;
905  case LibUtilities::eGaussLobattoLegendre:
906  {
907  const LibUtilities::PointsKey pkey(numpoints,LibUtilities::eGaussLobattoLegendre);
908  return LibUtilities::BasisKey(expansion->m_basisKeyVector[0].GetBasisType(),nummodes,pkey);
909  }
910  break;
911 
912  default:
913  ASSERTL0(false,"Unexpected points distribution");
914 
915  // It doesn't matter what we return
916  // here since the ASSERT will stop
917  // execution. Just return something
918  // to prevent warnings messages.
919  const LibUtilities::PointsKey pkey(numpoints+1,LibUtilities::eGaussLobattoLegendre);
920  return LibUtilities::BasisKey(expansion->m_basisKeyVector[0].GetBasisType(),nummodes,pkey);
921  break;
922  }
923  }
924  break;
925  case LibUtilities::eModified_A:
926  {
927  switch(expansion->m_basisKeyVector[edge_id].GetPointsType())
928  {
929  case LibUtilities::eGaussLobattoLegendre:
930  {
931  const LibUtilities::PointsKey pkey(numpoints,LibUtilities::eGaussLobattoLegendre);
932  return LibUtilities::BasisKey(expansion->m_basisKeyVector[0].GetBasisType(),nummodes,pkey);
933  }
934  break;
935  default:
936  ASSERTL0(false,"Unexpected points distribution");
937  // It doesn't matter what we return here
938  // since the ASSERT will stop execution.
939  // Just return something to prevent
940  // warnings messages.
941  const LibUtilities::PointsKey pkey(numpoints,LibUtilities::eGaussLobattoLegendre);
942  return LibUtilities::BasisKey(expansion->m_basisKeyVector[0].GetBasisType(),nummodes,pkey);
943  break;
944  }
945  }
946  break;
947 
948  default:
949  ASSERTL0(false,"Unexpected basis distribution");
950  // It doesn't matter what we return here since the
951  // ASSERT will stop execution. Just return
952  // something to prevent warnings messages.
953  const LibUtilities::PointsKey pkey(numpoints+1,LibUtilities::eGaussLobattoLegendre);
954  return LibUtilities::BasisKey(expansion->m_basisKeyVector[0].GetBasisType(),nummodes,pkey);
955  }
956  }
957  else
958  {
959  // Quadrilateral
960  const LibUtilities::PointsKey pkey(numpoints,expansion->m_basisKeyVector[edge_id].GetPointsType());
961  return LibUtilities::BasisKey(expansion->m_basisKeyVector[edge_id].GetBasisType(),nummodes,pkey);
962  }
963 
964  ASSERTL0(false, "Unable to determine edge points type.");
965  return LibUtilities::NullBasisKey;
966  }
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:161
Nektar::LibUtilities::eModified_A
Principle Modified Functions .
Definition: BasisType.h:49
Nektar::LibUtilities::eGaussRadauMAlpha1Beta0
Gauss Radau pinned at x=-1, .
Definition: PointsType.h:57
Nektar::LibUtilities::eOrtho_B
Principle Orthogonal Functions .
Definition: BasisType.h:47
Nektar::LibUtilities::eModified_B
Principle Modified Functions .
Definition: BasisType.h:50
Nektar::SpatialDomains::MeshGraph2D::GetElementsFromEdge
ElementEdgeVectorSharedPtr GetElementsFromEdge(SegGeomSharedPtr edge)
Return the elements (shared ptrs) that have this edge.
Definition: MeshGraph2D.cpp:763
Nektar::SpatialDomains::ElementEdgeVectorSharedPtr
boost::shared_ptr< ElementEdgeVector > ElementEdgeVectorSharedPtr
Definition: MeshGraph.h:134
Nektar::SpatialDomains::ExpansionShPtr
boost::shared_ptr< Expansion > ExpansionShPtr
Definition: MeshGraph.h:173
Nektar::SpatialDomains::MeshGraph::GetExpansion
ExpansionShPtr GetExpansion(GeometrySharedPtr geom, const std::string variable="DefaultVar")
Definition: MeshGraph.cpp:2323
Nektar::LibUtilities::NullBasisKey
static const BasisKey NullBasisKey(eNoBasisType, 0, NullPointsKey)
Defines a null basis with no type or points.
Nektar::LibUtilities::eGLL_Lagrange
Lagrange for SEM basis .
Definition: BasisType.h:53
Nektar::LibUtilities::eGaussLobattoLegendre
1D Gauss-Lobatto-Legendre quadrature points
Definition: PointsType.h:50
int Nektar::SpatialDomains::MeshGraph2D::GetEidFromElmt ( LibUtilities::ShapeType  shape,
const int  edge,
const int  elmt 
) const
inline

Definition at line 116 of file MeshGraph2D.h.

References ASSERTL2, Nektar::LibUtilities::eTriangle, Nektar::SpatialDomains::MeshGraph::m_quadGeoms, and Nektar::SpatialDomains::MeshGraph::m_triGeoms.

118  {
119  if(shape == LibUtilities::eTriangle)
120  {
121  ASSERTL2(m_triGeoms.find(elmt) != m_triGeoms.end(),
122  "eid is out of range");
123 
124  return m_triGeoms.find(elmt)->second->GetEid(edge);
125  }
126  else
127  {
128  ASSERTL2(m_quadGeoms.find(elmt) != m_quadGeoms.end(),
129  "eid is out of range");
130 
131  return m_quadGeoms.find(elmt)->second->GetEid(edge);
132  }
133  }
ASSERTL2
#define ASSERTL2(condition, msg)
Assert Level 2 – Debugging which is used FULLDEBUG compilation mode. This level assert is designed t...
Definition: ErrorUtil.hpp:213
ElementEdgeVectorSharedPtr Nektar::SpatialDomains::MeshGraph2D::GetElementsFromEdge ( SegGeomSharedPtr  edge)

Return the elements (shared ptrs) that have this edge.

Definition at line 763 of file MeshGraph2D.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), and Nektar::SpatialDomains::MeshGraph::m_domain.

Referenced by GetEdgeBasisKey(), and GetElementsFromEdge().

764  {
765  // Search tris and quads
766  // Need to iterate through vectors because there may be multiple
767  // occurrences.
768  ElementEdgeSharedPtr elementEdge;
769  //TriGeomVectorIter triIter;
770 
771  ElementEdgeVectorSharedPtr returnval = MemoryManager<ElementEdgeVector>::AllocateSharedPtr();
772 
773  CompositeMapIter compIter;
774  TriGeomSharedPtr triGeomShPtr;
775  QuadGeomSharedPtr quadGeomShPtr;
776 
777  GeometryVectorIter geomIter;
778 
779  for(int d = 0; d < m_domain.size(); ++d)
780  {
781  for (compIter = m_domain[d].begin(); compIter != m_domain[d].end(); ++compIter)
782  {
783  for (geomIter = (compIter->second)->begin(); geomIter != (compIter->second)->end(); ++geomIter)
784  {
785  triGeomShPtr = boost::dynamic_pointer_cast<TriGeom>(*geomIter);
786  quadGeomShPtr = boost::dynamic_pointer_cast<QuadGeom>(*geomIter);
787 
788  if (triGeomShPtr || quadGeomShPtr)
789  {
790  int edgeNum;
791  if (triGeomShPtr)
792  {
793  if ((edgeNum = triGeomShPtr->WhichEdge(edge)) > -1)
794  {
795  elementEdge = MemoryManager<ElementEdge>::AllocateSharedPtr();
796  elementEdge->m_Element = triGeomShPtr;
797  elementEdge->m_EdgeIndx = edgeNum;
798  returnval->push_back(elementEdge);
799  }
800  }
801  else if (quadGeomShPtr)
802  {
803  if ((edgeNum = quadGeomShPtr->WhichEdge(edge)) > -1)
804  {
805  elementEdge = MemoryManager<ElementEdge>::AllocateSharedPtr();
806  elementEdge->m_Element = quadGeomShPtr;
807  elementEdge->m_EdgeIndx = edgeNum;
808  returnval->push_back(elementEdge);
809  }
810  }
811  }
812  }
813  }
814  }
815 
816  return returnval;
817  }
Nektar::MemoryManager::AllocateSharedPtr
static boost::shared_ptr< DataType > AllocateSharedPtr()
Allocate a shared pointer from the memory pool.
Definition: NekMemoryManager.hpp:235
Nektar::SpatialDomains::QuadGeomSharedPtr
boost::shared_ptr< QuadGeom > QuadGeomSharedPtr
Definition: QuadGeom.h:54
Nektar::SpatialDomains::GeometryVectorIter
std::vector< GeometrySharedPtr >::iterator GeometryVectorIter
Definition: Geometry.h:58
Nektar::SpatialDomains::ElementEdgeSharedPtr
boost::shared_ptr< ElementEdge > ElementEdgeSharedPtr
Definition: MeshGraph.h:132
Nektar::SpatialDomains::CompositeMapIter
std::map< int, Composite >::iterator CompositeMapIter
Definition: MeshGraph.h:116
Nektar::SpatialDomains::ElementEdgeVectorSharedPtr
boost::shared_ptr< ElementEdgeVector > ElementEdgeVectorSharedPtr
Definition: MeshGraph.h:134
Nektar::SpatialDomains::MeshGraph::m_domain
std::vector< CompositeMap > m_domain
Definition: MeshGraph.h:432
Nektar::SpatialDomains::TriGeomSharedPtr
boost::shared_ptr< TriGeom > TriGeomSharedPtr
Definition: TriGeom.h:58
ElementEdgeVectorSharedPtr Nektar::SpatialDomains::MeshGraph2D::GetElementsFromEdge ( Geometry1DSharedPtr  edge)

Definition at line 751 of file MeshGraph2D.cpp.

References ASSERTL0, and GetElementsFromEdge().

752  {
753  SegGeomSharedPtr Sedge;
754 
755  if(!(Sedge = boost::dynamic_pointer_cast<SegGeom>(edge)))
756  {
757  ASSERTL0(false,"Dynamics cast failed");
758 
759  }
760  return GetElementsFromEdge(Sedge);
761 
762  }
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:161
Nektar::SpatialDomains::SegGeomSharedPtr
boost::shared_ptr< SegGeom > SegGeomSharedPtr
Definition: Geometry2D.h:60
Nektar::SpatialDomains::MeshGraph2D::GetElementsFromEdge
ElementEdgeVectorSharedPtr GetElementsFromEdge(SegGeomSharedPtr edge)
Return the elements (shared ptrs) that have this edge.
Definition: MeshGraph2D.cpp:763
StdRegions::Orientation Nektar::SpatialDomains::MeshGraph2D::GetEorientFromElmt ( LibUtilities::ShapeType  shape,
const int  edge,
const int  elmt 
) const
inline

Definition at line 135 of file MeshGraph2D.h.

References ASSERTL2, Nektar::LibUtilities::eTriangle, Nektar::SpatialDomains::MeshGraph::m_quadGeoms, and Nektar::SpatialDomains::MeshGraph::m_triGeoms.

136  {
137  if(shape == LibUtilities::eTriangle)
138  {
139  ASSERTL2(m_triGeoms.find(elmt) != m_triGeoms.end(),
140  "eid is out of range");
141 
142  return m_triGeoms.find(elmt)->second->GetEorient(edge);
143  }
144  else
145  {
146  ASSERTL2(m_quadGeoms.find(elmt) != m_quadGeoms.end(),
147  "eid is out of range");
148 
149  return m_quadGeoms.find(elmt)->second->GetEorient(edge);
150  }
151  }
ASSERTL2
#define ASSERTL2(condition, msg)
Assert Level 2 – Debugging which is used FULLDEBUG compilation mode. This level assert is designed t...
Definition: ErrorUtil.hpp:213
int Nektar::SpatialDomains::MeshGraph2D::GetNseggeoms ( ) const
inline

Definition at line 92 of file MeshGraph2D.h.

References Nektar::SpatialDomains::MeshGraph::m_segGeoms.

93  {
94  return int(m_segGeoms.size());
95  }
int Nektar::SpatialDomains::MeshGraph2D::GetNumCompositeItems ( int  whichComposite)
inline

Definition at line 193 of file MeshGraph2D.h.

References ErrorUtil::efatal, Nektar::SpatialDomains::MeshGraph::m_meshComposites, and NEKERROR.

194  {
195  int returnval = -1;
196 
197  try
198  {
199  returnval = int(m_meshComposites[whichComposite]->size());
200  }
201  catch(...)
202  {
203  std::ostringstream errStream;
204  errStream << "Unable to access composite item [" << whichComposite << "].";
205  NEKERROR(ErrorUtil::efatal, errStream.str());
206  }
207 
208  return returnval;
209  }
NEKERROR
#define NEKERROR(type, msg)
Assert Level 0 – Fundamental assert which is used whether in FULLDEBUG, DEBUG or OPT compilation mod...
Definition: ErrorUtil.hpp:158
int Nektar::SpatialDomains::MeshGraph2D::GetNumComposites ( void  )
inline

Definition at line 188 of file MeshGraph2D.h.

References Nektar::SpatialDomains::MeshGraph::m_meshComposites.

189  {
190  return int(m_meshComposites.size());
191  }
const QuadGeomMap& Nektar::SpatialDomains::MeshGraph2D::GetQuadgeoms ( void  ) const
inline

Definition at line 78 of file MeshGraph2D.h.

References Nektar::SpatialDomains::MeshGraph::m_quadGeoms.

79  {
80  return m_quadGeoms;
81  }
SegGeomSharedPtr Nektar::SpatialDomains::MeshGraph2D::GetSegGeom ( int  eID)

Definition at line 609 of file MeshGraph2D.cpp.

References ASSERTL0, Nektar::iterator, and Nektar::SpatialDomains::MeshGraph::m_segGeoms.

Referenced by ReadElements().

610  {
611  SegGeomSharedPtr returnval;
612  SegGeomMap::iterator x = m_segGeoms.find(eID);
613  ASSERTL0(x != m_segGeoms.end(), "Segment not found.");
614  return x->second;
615  };
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:161
Nektar::SpatialDomains::SegGeomSharedPtr
boost::shared_ptr< SegGeom > SegGeomSharedPtr
Definition: Geometry2D.h:60
Nektar::iterator
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs typedef NekMatrix< LhsDataType, StandardMatrixTag >::iterator iterator
Definition: MatrixOperations.cpp:96
const TriGeomMap& Nektar::SpatialDomains::MeshGraph2D::GetTrigeoms ( void  ) const
inline

Definition at line 73 of file MeshGraph2D.h.

References Nektar::SpatialDomains::MeshGraph::m_triGeoms.

74  {
75  return m_triGeoms;
76  }
int Nektar::SpatialDomains::MeshGraph2D::GetVidFromElmt ( LibUtilities::ShapeType  shape,
const int  vert,
const int  elmt 
) const
inline

Definition at line 97 of file MeshGraph2D.h.

References ASSERTL2, Nektar::LibUtilities::eTriangle, Nektar::SpatialDomains::MeshGraph::m_quadGeoms, and Nektar::SpatialDomains::MeshGraph::m_triGeoms.

99  {
100  if(shape == LibUtilities::eTriangle)
101  {
102  ASSERTL2(m_triGeoms.find(elmt) != m_triGeoms.end(),
103  "eid is out of range");
104 
105  return m_triGeoms.find(elmt)->second->GetVid(vert);
106  }
107  else
108  {
109  ASSERTL2(m_quadGeoms.find(elmt) != m_quadGeoms.end(),
110  "eid is out of range");
111 
112  return m_quadGeoms.find(elmt)->second->GetVid(vert);
113  }
114  }
ASSERTL2
#define ASSERTL2(condition, msg)
Assert Level 2 – Debugging which is used FULLDEBUG compilation mode. This level assert is designed t...
Definition: ErrorUtil.hpp:213
void Nektar::SpatialDomains::MeshGraph2D::ReadComposites ( TiXmlDocument &  doc)
protected

We know we have it since we made it this far.

Look for elements in ELEMENT block.

All elements are of the form: "<C ID = "N"> ... </C>". Read the ID field first.

Parse out the element components corresponding to type of element.

Keep looking

Definition at line 515 of file MeshGraph2D.cpp.

References ASSERTL0, ErrorUtil::efatal, Nektar::SpatialDomains::MeshGraph::m_compositesLabels, Nektar::SpatialDomains::MeshGraph::m_meshComposites, NEKERROR, and ResolveGeomRef().

Referenced by ReadGeometry().

516  {
517  TiXmlHandle docHandle(&doc);
518 
519  /// We know we have it since we made it this far.
520  TiXmlElement* mesh = docHandle.FirstChildElement("NEKTAR").FirstChildElement("GEOMETRY").Element();
521  TiXmlElement* field = NULL;
522 
523  ASSERTL0(mesh, "Unable to find GEOMETRY tag in file.");
524 
525  /// Look for elements in ELEMENT block.
526  field = mesh->FirstChildElement("COMPOSITE");
527 
528  ASSERTL0(field, "Unable to find COMPOSITE tag in file.");
529 
530  int nextCompositeNumber = -1;
531 
532  /// All elements are of the form: "<C ID = "N"> ... </C>".
533  /// Read the ID field first.
534  TiXmlElement *composite = field->FirstChildElement("C");
535 
536  while (composite)
537  {
538  nextCompositeNumber++;
539 
540  int indx;
541  int err = composite->QueryIntAttribute("ID", &indx);
542  ASSERTL0(err == TIXML_SUCCESS, "Unable to read attribute ID.");
543 
544  // read and store label if they exist
545  string labelstr;
546  err = composite->QueryStringAttribute("LABEL", &labelstr);
547  if(err == TIXML_SUCCESS)
548  {
549  m_compositesLabels[indx] = labelstr;
550  }
551 
552  TiXmlNode* compositeChild = composite->FirstChild();
553  // This is primarily to skip comments that may be present.
554  // Comments appear as nodes just like elements.
555  // We are specifically looking for text in the body
556  // of the definition.
557  while(compositeChild && compositeChild->Type() != TiXmlNode::TINYXML_TEXT)
558  {
559  compositeChild = compositeChild->NextSibling();
560  }
561 
562  ASSERTL0(compositeChild, "Unable to read composite definition body.");
563  std::string compositeStr = compositeChild->ToText()->ValueStr();
564 
565  /// Parse out the element components corresponding to type of element.
566 
567  std::istringstream compositeDataStrm(compositeStr.c_str());
568 
569  try
570  {
571  bool first = true;
572  std::string prevCompositeElementStr;
573 
574  while (!compositeDataStrm.fail())
575  {
576  std::string compositeElementStr;
577  compositeDataStrm >> compositeElementStr;
578 
579  if (!compositeDataStrm.fail())
580  {
581  if (first)
582  {
583  first = false;
584 
585  Composite curVector(MemoryManager<GeometryVector>::AllocateSharedPtr());
586  m_meshComposites[indx] = curVector;
587  }
588 
589  if (compositeElementStr.length() > 0)
590  {
591  ResolveGeomRef(prevCompositeElementStr, compositeElementStr, m_meshComposites[indx]);
592  }
593  prevCompositeElementStr = compositeElementStr;
594  }
595  }
596  }
597  catch(...)
598  {
599  NEKERROR(ErrorUtil::efatal,
600  (std::string("Unable to read COMPOSITE data for composite: ") + compositeStr).c_str());
601  }
602 
603  /// Keep looking
604  composite = composite->NextSiblingElement("C");
605  }
606  }
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:161
NEKERROR
#define NEKERROR(type, msg)
Assert Level 0 – Fundamental assert which is used whether in FULLDEBUG, DEBUG or OPT compilation mod...
Definition: ErrorUtil.hpp:158
Nektar::SpatialDomains::Composite
boost::shared_ptr< GeometryVector > Composite
Definition: MeshGraph.h:114
Nektar::SpatialDomains::MeshGraph::m_compositesLabels
map< int, string > m_compositesLabels
Definition: MeshGraph.h:431
Nektar::SpatialDomains::MeshGraph2D::ResolveGeomRef
void ResolveGeomRef(const std::string &prevToken, const std::string &token, Composite &composite)
Definition: MeshGraph2D.cpp:624
void Nektar::SpatialDomains::MeshGraph2D::ReadEdges ( TiXmlDocument &  doc)
protected

We know we have it since we made it this far.

Look for elements in ELEMENT block.

All elements are of the form: "<E ID="#"> ... </E>", with ? being the element type. Read the ID field first.

Since all edge data is one big text block, we need to accumulate all TINYXML_TEXT data and then parse it. This approach effectively skips all comments or other node types since we only care about the edge list. We cannot handle missing edge numbers as we could with missing element numbers due to the text block format.

Now parse out the edges, three fields at a time.

Definition at line 97 of file MeshGraph2D.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, ErrorUtil::efatal, Nektar::LibUtilities::CompressData::GetCompressString(), Nektar::SpatialDomains::MeshGraph::GetVertex(), Nektar::iterator, Nektar::SpatialDomains::MeshGraph::m_curvedEdges, Nektar::SpatialDomains::MeshGraph::m_segGeoms, Nektar::SpatialDomains::MeshGraph::m_spaceDimension, NEKERROR, and Nektar::LibUtilities::CompressData::ZlibDecodeFromBase64Str().

Referenced by ReadGeometry().

98  {
99  /// We know we have it since we made it this far.
100  TiXmlHandle docHandle(&doc);
101  TiXmlElement* mesh = docHandle.FirstChildElement("NEKTAR").FirstChildElement("GEOMETRY").Element();
102  TiXmlElement* field = NULL;
103  CurveMap::iterator it;
104 
105  /// Look for elements in ELEMENT block.
106  field = mesh->FirstChildElement("EDGE");
107 
108  ASSERTL0(field, "Unable to find EDGE tag in file.");
109 
110  string IsCompressed;
111  field->QueryStringAttribute("COMPRESSED",&IsCompressed);
112 
113  if(IsCompressed.size())
114  {
115  ASSERTL0(boost::iequals(IsCompressed,
116  LibUtilities::CompressData::GetCompressString()),
117  "Compressed formats do not match. Expected :"
118  + LibUtilities::CompressData::GetCompressString()
119  + " but got " + std::string(IsCompressed));
120 
121  // Extract the edge body
122  TiXmlNode* edgeChild = field->FirstChild();
123  ASSERTL0(edgeChild, "Unable to extract the data from "
124  "the compressed edge tag.");
125 
126  std::string edgeStr;
127  if (edgeChild->Type() == TiXmlNode::TINYXML_TEXT)
128  {
129  edgeStr += edgeChild->ToText()->ValueStr();
130  }
131 
132  std::vector<LibUtilities::MeshEdge> edgeData;
133  LibUtilities::CompressData::ZlibDecodeFromBase64Str(edgeStr,
134  edgeData);
135  int indx;
136  for(int i = 0; i < edgeData.size(); ++i)
137  {
138  indx = edgeData[i].id;
139 
140  PointGeomSharedPtr vertices[2] =
141  {GetVertex(edgeData[i].v0), GetVertex(edgeData[i].v1)};
142  SegGeomSharedPtr edge;
143 
144  it = m_curvedEdges.find(indx);
145  if (it == m_curvedEdges.end())
146  {
147  edge = MemoryManager<SegGeom>::AllocateSharedPtr(
148  indx, m_spaceDimension, vertices);
149  }
150  else
151  {
152  edge = MemoryManager<SegGeom>::AllocateSharedPtr(
153  indx, m_spaceDimension, vertices,
154  it->second);
155  }
156  m_segGeoms[indx] = edge;
157  }
158  }
159  else
160  {
161  /// All elements are of the form: "<E ID="#"> ... </E>", with
162  /// ? being the element type.
163  /// Read the ID field first.
164  TiXmlElement *edge = field->FirstChildElement("E");
165 
166  /// Since all edge data is one big text block, we need to
167  /// accumulate all TINYXML_TEXT data and then parse it. This
168  /// approach effectively skips all comments or other node
169  /// types since we only care about the edge list. We
170  /// cannot handle missing edge numbers as we could with
171  /// missing element numbers due to the text block format.
172  std::string edgeStr;
173  int indx;
174 
175  while(edge)
176  {
177  int err = edge->QueryIntAttribute("ID",&indx);
178  ASSERTL0(err == TIXML_SUCCESS, "Unable to read edge attribute ID.");
179 
180  TiXmlNode *child = edge->FirstChild();
181  edgeStr.clear();
182  if (child->Type() == TiXmlNode::TINYXML_TEXT)
183  {
184  edgeStr += child->ToText()->ValueStr();
185  }
186 
187  /// Now parse out the edges, three fields at a time.
188  int vertex1, vertex2;
189  std::istringstream edgeDataStrm(edgeStr.c_str());
190 
191  try
192  {
193  while (!edgeDataStrm.fail())
194  {
195  edgeDataStrm >> vertex1 >> vertex2;
196 
197  // Must check after the read because we may be
198  // at the end and not know it. If we are at
199  // the end we will add a duplicate of the last
200  // entry if we don't check here.
201  if (!edgeDataStrm.fail())
202  {
203  PointGeomSharedPtr vertices[2] = {GetVertex(vertex1), GetVertex(vertex2)};
204 
205  SegGeomSharedPtr edge;
206 
207  it = m_curvedEdges.find(indx);
208 
209  if(it == m_curvedEdges.end())
210  {
211  edge = MemoryManager<SegGeom>::AllocateSharedPtr(indx, m_spaceDimension, vertices);
212  edge->SetGlobalID(indx); // Set global mesh id
213  }
214  else
215  {
216  edge = MemoryManager<SegGeom>::AllocateSharedPtr(indx, m_spaceDimension, vertices, it->second);
217  edge->SetGlobalID(indx); //Set global mesh id
218  }
219 
220  m_segGeoms[indx] = edge;
221  }
222  }
223  }
224  catch(...)
225  {
226  NEKERROR(ErrorUtil::efatal, (std::string("Unable to read edge data: ") + edgeStr).c_str());
227  }
228 
229  edge = edge->NextSiblingElement("E");
230  }
231  }
232  }
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:161
NEKERROR
#define NEKERROR(type, msg)
Assert Level 0 – Fundamental assert which is used whether in FULLDEBUG, DEBUG or OPT compilation mod...
Definition: ErrorUtil.hpp:158
Nektar::MemoryManager::AllocateSharedPtr
static boost::shared_ptr< DataType > AllocateSharedPtr()
Allocate a shared pointer from the memory pool.
Definition: NekMemoryManager.hpp:235
Nektar::SpatialDomains::MeshGraph::GetVertex
PointGeomSharedPtr GetVertex(int id)
Definition: MeshGraph.h:587
Nektar::SpatialDomains::SegGeomSharedPtr
boost::shared_ptr< SegGeom > SegGeomSharedPtr
Definition: Geometry2D.h:60
Nektar::iterator
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs typedef NekMatrix< LhsDataType, StandardMatrixTag >::iterator iterator
Definition: MatrixOperations.cpp:96
Nektar::SpatialDomains::PointGeomSharedPtr
boost::shared_ptr< PointGeom > PointGeomSharedPtr
Definition: Geometry.h:60
Nektar::LibUtilities::CompressData::ZlibDecodeFromBase64Str
int ZlibDecodeFromBase64Str(std::string &in64, std::vector< T > &out)
Definition: CompressData.h:243
void Nektar::SpatialDomains::MeshGraph2D::ReadElements ( TiXmlDocument &  doc)
protected

We know we have it since we made it this far.

Look for elements in ELEMENT block.

All elements are of the form: "<? ID="#"> ... </?>", with ? being the element type.

See if this face has curves.

Create a TriGeom to hold the new definition.

See if this face has curves.

Create a QuadGeom to hold the new definition.

Read id attribute.

Read text element description.

Parse out the element components corresponding to type of element.

Create a TriGeom to hold the new definition.

Create a QuadGeom to hold the new definition.

Keep looking

Definition at line 234 of file MeshGraph2D.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, ErrorUtil::efatal, Nektar::LibUtilities::CompressData::GetCompressString(), Nektar::SpatialDomains::SegGeom::GetEdgeOrientation(), GetSegGeom(), Nektar::iterator, Nektar::SpatialDomains::TriGeom::kNedges, Nektar::SpatialDomains::QuadGeom::kNedges, Nektar::SpatialDomains::MeshGraph::m_curvedEdges, Nektar::SpatialDomains::MeshGraph::m_curvedFaces, Nektar::SpatialDomains::MeshGraph::m_quadGeoms, Nektar::SpatialDomains::MeshGraph::m_triGeoms, NEKERROR, and Nektar::LibUtilities::CompressData::ZlibDecodeFromBase64Str().

Referenced by ReadGeometry().

235  {
236  /// We know we have it since we made it this far.
237  TiXmlHandle docHandle(&doc);
238  TiXmlElement* mesh = docHandle.FirstChildElement("NEKTAR").FirstChildElement("GEOMETRY").Element();
239  TiXmlElement* field = NULL;
240 
241  /// Look for elements in ELEMENT block.
242  field = mesh->FirstChildElement("ELEMENT");
243 
244  ASSERTL0(field, "Unable to find ELEMENT tag in file.");
245 
246  // Set up curve map for curved elements on an embedded manifold.
247  CurveMap::iterator it;
248 
249  /// All elements are of the form: "<? ID="#"> ... </?>", with
250  /// ? being the element type.
251 
252  TiXmlElement *element = field->FirstChildElement();
253 
254  while (element)
255  {
256  std::string elementType(element->ValueStr());
257 
258  ASSERTL0(elementType == "Q" || elementType == "T",
259  (std::string("Unknown 2D element type: ") + elementType).c_str());
260 
261  string IsCompressed;
262  element->QueryStringAttribute("COMPRESSED",&IsCompressed);
263 
264  if(IsCompressed.size())
265  {
266  ASSERTL0(boost::iequals(IsCompressed,
267  LibUtilities::CompressData:: GetCompressString()),
268  "Compressed formats do not match. Expected :"
269  + LibUtilities::CompressData::GetCompressString()
270  + " but got " + std::string(IsCompressed));
271 
272  // Extract the face body
273  TiXmlNode* faceChild = element->FirstChild();
274  ASSERTL0(faceChild, "Unable to extract the data from "
275  "the compressed face tag.");
276 
277  std::string faceStr;
278  if (faceChild->Type() == TiXmlNode::TINYXML_TEXT)
279  {
280  faceStr += faceChild->ToText()->ValueStr();
281  }
282 
283  int indx;
284  if(elementType == "T")
285  {
286  std::vector<LibUtilities::MeshTri> faceData;
287  LibUtilities::CompressData::ZlibDecodeFromBase64Str(
288  faceStr, faceData);
289 
290  for(int i = 0; i < faceData.size(); ++i)
291  {
292  indx = faceData[i].id;
293 
294  /// See if this face has curves.
295  it = m_curvedFaces.find(indx);
296 
297  /// Create a TriGeom to hold the new definition.
298  SegGeomSharedPtr edges[TriGeom::kNedges] =
299  {
300  GetSegGeom(faceData[i].e[0]),
301  GetSegGeom(faceData[i].e[1]),
302  GetSegGeom(faceData[i].e[2])
303  };
304 
305  StdRegions::Orientation edgeorient[TriGeom::kNedges] =
306  {
307  SegGeom::GetEdgeOrientation(*edges[0], *edges[1]),
308  SegGeom::GetEdgeOrientation(*edges[1], *edges[2]),
309  SegGeom::GetEdgeOrientation(*edges[2], *edges[0])
310  };
311 
312  TriGeomSharedPtr trigeom;
313  if (it == m_curvedFaces.end())
314  {
315  trigeom =
316  MemoryManager<TriGeom>::AllocateSharedPtr(
317  indx, edges, edgeorient);
318  }
319  else
320  {
321  trigeom =
322  MemoryManager<TriGeom>::AllocateSharedPtr(
323  indx, edges, edgeorient,
324  it->second);
325  }
326  trigeom->SetGlobalID(indx);
327  m_triGeoms[indx] = trigeom;
328  }
329  }
330  else if (elementType == "Q")
331  {
332  std::vector<LibUtilities::MeshQuad> faceData;
333  LibUtilities::CompressData::ZlibDecodeFromBase64Str(
334  faceStr,faceData);
335 
336  for(int i = 0; i < faceData.size(); ++i)
337  {
338  indx = faceData[i].id;
339 
340  /// See if this face has curves.
341  it = m_curvedFaces.find(indx);
342 
343  /// Create a QuadGeom to hold the new definition.
344  SegGeomSharedPtr edges[QuadGeom::kNedges] =
345  {GetSegGeom(faceData[i].e[0]),
346  GetSegGeom(faceData[i].e[1]),
347  GetSegGeom(faceData[i].e[2]),
348  GetSegGeom(faceData[i].e[3])};
349 
350  StdRegions::Orientation edgeorient[QuadGeom::kNedges] =
351  {
352  SegGeom::GetEdgeOrientation(*edges[0], *edges[1]),
353  SegGeom::GetEdgeOrientation(*edges[1], *edges[2]),
354  SegGeom::GetEdgeOrientation(*edges[2], *edges[3]),
355  SegGeom::GetEdgeOrientation(*edges[3], *edges[0])
356  };
357 
358  QuadGeomSharedPtr quadgeom;
359  if (it == m_curvedEdges.end())
360  {
361  quadgeom =
362  MemoryManager<QuadGeom>::AllocateSharedPtr(
363  indx, edges, edgeorient);
364  }
365  else
366  {
367  quadgeom =
368  MemoryManager<QuadGeom>::AllocateSharedPtr(
369  indx, edges, edgeorient,
370  it->second);
371  }
372  quadgeom->SetGlobalID(indx);
373  m_quadGeoms[indx] = quadgeom;
374  }
375  }
376  }
377  else
378  {
379  /// Read id attribute.
380  int indx;
381  int err = element->QueryIntAttribute("ID", &indx);
382  ASSERTL0(err == TIXML_SUCCESS, "Unable to read element attribute ID.");
383 
384  it = m_curvedFaces.find(indx);
385 
386  /// Read text element description.
387  TiXmlNode* elementChild = element->FirstChild();
388  std::string elementStr;
389  while(elementChild)
390  {
391  if (elementChild->Type() == TiXmlNode::TINYXML_TEXT)
392  {
393  elementStr += elementChild->ToText()->ValueStr();
394  }
395  elementChild = elementChild->NextSibling();
396  }
397 
398  ASSERTL0(!elementStr.empty(), "Unable to read element description body.");
399 
400  /// Parse out the element components corresponding to type of element.
401  if (elementType == "T")
402  {
403  // Read three edge numbers
404  int edge1, edge2, edge3;
405  std::istringstream elementDataStrm(elementStr.c_str());
406 
407  try
408  {
409  elementDataStrm >> edge1;
410  elementDataStrm >> edge2;
411  elementDataStrm >> edge3;
412 
413  ASSERTL0(!elementDataStrm.fail(), (std::string("Unable to read element data for TRIANGLE: ") + elementStr).c_str());
414 
415  /// Create a TriGeom to hold the new definition.
416  SegGeomSharedPtr edges[TriGeom::kNedges] =
417  {
418  GetSegGeom(edge1),
419  GetSegGeom(edge2),
420  GetSegGeom(edge3)
421  };
422 
423  StdRegions::Orientation edgeorient[TriGeom::kNedges] =
424  {
425  SegGeom::GetEdgeOrientation(*edges[0], *edges[1]),
426  SegGeom::GetEdgeOrientation(*edges[1], *edges[2]),
427  SegGeom::GetEdgeOrientation(*edges[2], *edges[0])
428  };
429 
430  TriGeomSharedPtr trigeom;
431  if (it == m_curvedFaces.end())
432  {
433  trigeom = MemoryManager<TriGeom>
434  ::AllocateSharedPtr(indx,
435  edges,
436  edgeorient);
437  }
438  else
439  {
440  trigeom = MemoryManager<TriGeom>
441  ::AllocateSharedPtr(indx,
442  edges,
443  edgeorient,
444  it->second);
445  }
446  trigeom->SetGlobalID(indx);
447 
448  m_triGeoms[indx] = trigeom;
449  }
450  catch(...)
451  {
452  NEKERROR(ErrorUtil::efatal, (std::string("Unable to read element data for TRIANGLE: ") + elementStr).c_str());
453  }
454  }
455  else if (elementType == "Q")
456  {
457  // Read four edge numbers
458  int edge1, edge2, edge3, edge4;
459  std::istringstream elementDataStrm(elementStr.c_str());
460 
461  try
462  {
463  elementDataStrm >> edge1;
464  elementDataStrm >> edge2;
465  elementDataStrm >> edge3;
466  elementDataStrm >> edge4;
467 
468  ASSERTL0(!elementDataStrm.fail(), (std::string("Unable to read element data for QUAD: ") + elementStr).c_str());
469 
470  /// Create a QuadGeom to hold the new definition.
471  SegGeomSharedPtr edges[QuadGeom::kNedges] =
472  {GetSegGeom(edge1),GetSegGeom(edge2),
473  GetSegGeom(edge3),GetSegGeom(edge4)};
474 
475  StdRegions::Orientation edgeorient[QuadGeom::kNedges] =
476  {
477  SegGeom::GetEdgeOrientation(*edges[0], *edges[1]),
478  SegGeom::GetEdgeOrientation(*edges[1], *edges[2]),
479  SegGeom::GetEdgeOrientation(*edges[2], *edges[3]),
480  SegGeom::GetEdgeOrientation(*edges[3], *edges[0])
481  };
482 
483  QuadGeomSharedPtr quadgeom;
484  if (it == m_curvedFaces.end())
485  {
486  quadgeom = MemoryManager<QuadGeom>
487  ::AllocateSharedPtr(indx,
488  edges,
489  edgeorient);
490  }
491  else
492  {
493  quadgeom = MemoryManager<QuadGeom>
494  ::AllocateSharedPtr(indx,
495  edges,
496  edgeorient,
497  it->second);
498  }
499  quadgeom->SetGlobalID(indx);
500 
501  m_quadGeoms[indx] = quadgeom;
502 
503  }
504  catch(...)
505  {
506  NEKERROR(ErrorUtil::efatal,(std::string("Unable to read element data for QUAD: ") + elementStr).c_str());
507  }
508  }
509  }
510  /// Keep looking
511  element = element->NextSiblingElement();
512  }
513  }
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:161
NEKERROR
#define NEKERROR(type, msg)
Assert Level 0 – Fundamental assert which is used whether in FULLDEBUG, DEBUG or OPT compilation mod...
Definition: ErrorUtil.hpp:158
Nektar::MemoryManager::AllocateSharedPtr
static boost::shared_ptr< DataType > AllocateSharedPtr()
Allocate a shared pointer from the memory pool.
Definition: NekMemoryManager.hpp:235
Nektar::SpatialDomains::QuadGeomSharedPtr
boost::shared_ptr< QuadGeom > QuadGeomSharedPtr
Definition: QuadGeom.h:54
Nektar::SpatialDomains::SegGeom::GetEdgeOrientation
static StdRegions::Orientation GetEdgeOrientation(const SegGeom &edge1, const SegGeom &edge2)
Get the orientation of edge1.
Definition: SegGeom.cpp:293
Nektar::SpatialDomains::SegGeomSharedPtr
boost::shared_ptr< SegGeom > SegGeomSharedPtr
Definition: Geometry2D.h:60
Nektar::SpatialDomains::TriGeom::kNedges
static const int kNedges
Get the orientation of face1.
Definition: TriGeom.h:98
Nektar::iterator
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs typedef NekMatrix< LhsDataType, StandardMatrixTag >::iterator iterator
Definition: MatrixOperations.cpp:96
Nektar::SpatialDomains::TriGeomSharedPtr
boost::shared_ptr< TriGeom > TriGeomSharedPtr
Definition: TriGeom.h:58
Nektar::LibUtilities::CompressData::ZlibDecodeFromBase64Str
int ZlibDecodeFromBase64Str(std::string &in64, std::vector< T > &out)
Definition: CompressData.h:243
Nektar::SpatialDomains::MeshGraph2D::GetSegGeom
SegGeomSharedPtr GetSegGeom(int eID)
Definition: MeshGraph2D.cpp:609
void Nektar::SpatialDomains::MeshGraph2D::ReadGeometry ( const std::string &  infilename)
virtual

Read will read the meshgraph vertices given a filename.

Reimplemented from Nektar::SpatialDomains::MeshGraph.

Definition at line 62 of file MeshGraph2D.cpp.

References ASSERTL0.

Referenced by MeshGraph2D().

63  {
64  TiXmlDocument doc(infilename);
65  bool loadOkay = doc.LoadFile();
66 
67  std::stringstream errstr;
68  errstr << "Unable to load file: " << infilename << "\n";
69  errstr << doc.ErrorDesc() << " (Line " << doc.ErrorRow()
70  << ", Column " << doc.ErrorCol() << ")";
71  ASSERTL0(loadOkay, errstr.str());
72 
73  ReadGeometry(doc);
74  }
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:161
Nektar::SpatialDomains::MeshGraph2D::ReadGeometry
void ReadGeometry(const std::string &infilename)
Read will read the meshgraph vertices given a filename.
Definition: MeshGraph2D.cpp:62
void Nektar::SpatialDomains::MeshGraph2D::ReadGeometry ( TiXmlDocument &  doc)
virtual

Read will read the meshgraph vertices given a TiXmlDocument.

Look for all geometry related data in GEOMETRY block.

Error value returned by TinyXML.

Reimplemented from Nektar::SpatialDomains::MeshGraph.

Definition at line 77 of file MeshGraph2D.cpp.

References ASSERTL0, ReadComposites(), Nektar::SpatialDomains::MeshGraph::ReadCurves(), Nektar::SpatialDomains::MeshGraph::ReadDomain(), ReadEdges(), ReadElements(), and Nektar::SpatialDomains::MeshGraph::ReadGeometry().

78  {
79  // Read mesh first
80  MeshGraph::ReadGeometry(doc);
81  TiXmlHandle docHandle(&doc);
82 
83  TiXmlElement* mesh = NULL;
84 
85  /// Look for all geometry related data in GEOMETRY block.
86  mesh = docHandle.FirstChildElement("NEKTAR").FirstChildElement("GEOMETRY").Element();
87 
88  ASSERTL0(mesh, "Unable to find GEOMETRY tag in file.");
89 
90  ReadCurves(doc);
91  ReadEdges(doc);
92  ReadElements(doc);
93  ReadComposites(doc);
94  ReadDomain(doc);
95  }
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:161
Nektar::SpatialDomains::MeshGraph2D::ReadEdges
void ReadEdges(TiXmlDocument &doc)
Definition: MeshGraph2D.cpp:97
Nektar::SpatialDomains::MeshGraph2D::ReadComposites
void ReadComposites(TiXmlDocument &doc)
Definition: MeshGraph2D.cpp:515
Nektar::SpatialDomains::MeshGraph::ReadCurves
void ReadCurves(TiXmlDocument &doc)
Definition: MeshGraph.cpp:1158
Nektar::SpatialDomains::MeshGraph2D::ReadElements
void ReadElements(TiXmlDocument &doc)
Definition: MeshGraph2D.cpp:234
Nektar::SpatialDomains::MeshGraph::ReadGeometry
virtual void ReadGeometry(const std::string &infilename)
Read will read the meshgraph vertices given a filename.
Definition: MeshGraph.cpp:230
Nektar::SpatialDomains::MeshGraph::ReadDomain
void ReadDomain(TiXmlDocument &doc)
Definition: MeshGraph.cpp:1064
void Nektar::SpatialDomains::MeshGraph2D::ResolveGeomRef ( const std::string &  prevToken,
const std::string &  token,
Composite &  composite 
)
protected

Definition at line 624 of file MeshGraph2D.cpp.

References ASSERTL0, Nektar::SpatialDomains::MeshGraph::CheckRange(), ErrorUtil::efatal, ErrorUtil::ewarning, Nektar::ParseUtils::GenerateSeqVector(), Nektar::iterator, Nektar::SpatialDomains::MeshGraph::m_quadGeoms, Nektar::SpatialDomains::MeshGraph::m_segGeoms, Nektar::SpatialDomains::MeshGraph::m_triGeoms, Nektar::SpatialDomains::MeshGraph::m_vertSet, and NEKERROR.

Referenced by ReadComposites().

626  {
627  try
628  {
629  std::istringstream tokenStream(token);
630  std::istringstream prevTokenStream(prevToken);
631 
632  char type;
633  char prevType;
634 
635  tokenStream >> type;
636 
637  std::string::size_type indxBeg = token.find_first_of('[') + 1;
638  std::string::size_type indxEnd = token.find_last_of(']') - 1;
639 
640  ASSERTL0(indxBeg <= indxEnd, (std::string("Error reading index definition:") + token).c_str());
641 
642  std::string indxStr = token.substr(indxBeg, indxEnd - indxBeg + 1);
643  std::vector<unsigned int> seqVector;
644  std::vector<unsigned int>::iterator seqIter;
645 
646  bool err = ParseUtils::GenerateSeqVector(indxStr.c_str(), seqVector);
647 
648  ASSERTL0(err, (std::string("Error reading composite elements: ") + indxStr).c_str());
649 
650  prevTokenStream >> prevType;
651 
652  // All composites must be of the same dimension.
653  bool validSequence = (prevToken.empty() || // No previous, then current is just fine.
654  (type == 'V' && prevType == 'V') ||
655  (type == 'E' && prevType == 'E') ||
656  ((type == 'T' || type == 'Q') &&
657  (prevType == 'T' || prevType == 'Q')));
658 
659  ASSERTL0(validSequence, (std::string("Invalid combination of composite items: ")
660  + type + " and " + prevType + ".").c_str());
661 
662 
663  switch(type)
664  {
665  case 'E': // Edge
666  for (seqIter = seqVector.begin(); seqIter != seqVector.end(); ++seqIter)
667  {
668  if (m_segGeoms.find(*seqIter) == m_segGeoms.end())
669  {
670  char errStr[16] = "";
671  ::sprintf(errStr, "%d", *seqIter);
672  NEKERROR(ErrorUtil::ewarning, (std::string("Unknown edge index: ") + errStr).c_str());
673  }
674  else
675  {
676  composite->push_back(m_segGeoms[*seqIter]);
677  }
678  }
679  break;
680 
681  case 'T': // Triangle
682  {
683  for (seqIter = seqVector.begin(); seqIter != seqVector.end(); ++seqIter)
684  {
685  if (m_triGeoms.count(*seqIter) == 0 )
686  {
687  char errStr[16] = "";
688  ::sprintf(errStr, "%d", *seqIter);
689  NEKERROR(ErrorUtil::ewarning, (std::string("Unknown triangle index: ") + errStr).c_str());
690  }
691  else
692  {
693  if(CheckRange(*m_triGeoms[*seqIter]))
694  {
695  composite->push_back(m_triGeoms[*seqIter]);
696  }
697  }
698  }
699  }
700  break;
701 
702  case 'Q': // Quad
703  {
704  for (seqIter = seqVector.begin(); seqIter != seqVector.end(); ++seqIter)
705  {
706  if (m_quadGeoms.count(*seqIter) == 0)
707  {
708  char errStr[16] = "";
709  ::sprintf(errStr, "%d", *seqIter);
710  NEKERROR(ErrorUtil::ewarning, (std::string("Unknown quad index: ") + errStr +std::string(" in Composite section")).c_str());
711  }
712  else
713  {
714  if(CheckRange(*m_quadGeoms[*seqIter]))
715  {
716  composite->push_back(m_quadGeoms[*seqIter]);
717  }
718  }
719  }
720  }
721  break;
722 
723  case 'V': // Vertex
724  for (seqIter = seqVector.begin(); seqIter != seqVector.end(); ++seqIter)
725  {
726  if (*seqIter >= m_vertSet.size())
727  {
728  char errStr[16] = "";
729  ::sprintf(errStr, "%d", *seqIter);
730  NEKERROR(ErrorUtil::ewarning, (std::string("Unknown vertex index: ") + errStr).c_str());
731  }
732  else
733  {
734  composite->push_back(m_vertSet[*seqIter]);
735  }
736  }
737  break;
738 
739  default:
740  NEKERROR(ErrorUtil::efatal, (std::string("Unrecognized composite token: ") + token).c_str());
741  }
742  }
743  catch(...)
744  {
745  NEKERROR(ErrorUtil::efatal, (std::string("Problem processing composite token: ") + token).c_str());
746  }
747 
748  return;
749  }
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:161
NEKERROR
#define NEKERROR(type, msg)
Assert Level 0 – Fundamental assert which is used whether in FULLDEBUG, DEBUG or OPT compilation mod...
Definition: ErrorUtil.hpp:158
Nektar::ParseUtils::GenerateSeqVector
static bool GenerateSeqVector(const char *const str, std::vector< unsigned int > &vec)
Definition: ParseUtils.hpp:79
Nektar::iterator
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs typedef NekMatrix< LhsDataType, StandardMatrixTag >::iterator iterator
Definition: MatrixOperations.cpp:96
Nektar::SpatialDomains::MeshGraph::CheckRange
bool CheckRange(Geometry2D &geom)
Check if goemetry is in range definition if activated.
Definition: MeshGraph.cpp:2000
Generated on Wed Mar 23 2016 20:14:37 for Nektar++ by   doxygen 1.8.8