Classes
class	Array3D

struct	BoundaryConditionBase

class	BoundaryConditions

struct	Composite

struct	Curve

struct	DirichletBoundaryCondition

class	EntityHolder

class	EntityHolder1D

struct	ExpansionInfo

class	Geometry
	Base class for shape geometry information. More...

class	Geometry0D
	1D geometry information More...

class	Geometry1D
	1D geometry information More...

class	Geometry2D
	2D geometry information More...

class	Geometry3D
	3D geometry information More...

struct	GeometryHash
	Unary function that constructs a hash of a Geometry object, based on the vertex IDs. More...

class	GeomFactors
	Calculation and storage of geometric factors associated with the mapping from StdRegions reference elements to a given LocalRegions physical element in the mesh. More...

struct	GeomFactorsHash
	A hash functor for geometric factors. Utilises GeomFactors::GetHash. More...

class	GeomMapView

class	HexGeom

struct	Interface
	A interface which is a single edge on a zone for handling non-conformality. More...

struct	InterfacePair

class	LinearMeshGraph

struct	MeshCurvedInfo

struct	MeshCurvedPts

struct	MeshEdge

struct	MeshEntity

class	MeshGraph
	Base class for a spectral/hp element mesh. More...

class	MeshGraphIO

class	MeshGraphIOHDF5

class	MeshGraphIOXml

class	MeshGraphIOXmlCompressed

struct	MeshHex

class	MeshPartition

class	MeshPartitionMetis

class	MeshPartitionPtScotch

class	MeshPartitionScotch

struct	MeshPrism

struct	MeshPyr

struct	MeshQuad

struct	MeshTet

struct	MeshTri

struct	MeshVertex

class	Movement

struct	NeumannBoundaryCondition

struct	NotDefinedBoundaryCondition

struct	PeriodicBoundaryCondition

class	PointGeom

class	PrismGeom

class	PyrGeom

class	QuadGeom

class	RefRegion
	Abstract base class for the refinement surface region. More...

class	RefRegionCylinder
	Derived class for the refinement surface region. More...

class	RefRegionLine
	Derived class for the refinement surface region. More...

class	RefRegionParallelogram
	Derived class for the refinement surface region. More...

class	RefRegionSphere
	Derived class for the refinement surface region. More...

struct	RobinBoundaryCondition

class	SegGeom

class	TetGeom

class	TriGeom

class	XmapFactory
	A simple factory for Xmap objects that is based on the element type, the basis and quadrature selection. More...

struct	ZoneBase
	Zone base: Contains the shared functions and variables. More...

struct	ZoneFixed
	Fixed zone: does not move. More...

struct	ZoneRotate
	Rotating zone: Motion of every point around a given axis on an origin. More...

struct	ZoneTranslate
	Translating zone: addition of a constant vector to every point. More...

Typedefs
typedef std::map< int, CompositeSharedPtr >	BoundaryRegion

typedef std::shared_ptr< BoundaryRegion >	BoundaryRegionShPtr

typedef std::shared_ptr< const BoundaryRegion >	ConstBoundaryRegionShPtr

typedef std::map< int, BoundaryRegionShPtr >	BoundaryRegionCollection

typedef std::shared_ptr< BoundaryConditionBase >	BoundaryConditionShPtr

typedef std::shared_ptr< DirichletBoundaryCondition >	DirichletBCShPtr

typedef std::shared_ptr< NeumannBoundaryCondition >	NeumannBCShPtr

typedef std::shared_ptr< RobinBoundaryCondition >	RobinBCShPtr

typedef std::map< std::string, BoundaryConditionShPtr >	BoundaryConditionMap

typedef std::shared_ptr< BoundaryConditionMap >	BoundaryConditionMapShPtr

typedef std::map< int, BoundaryConditionMapShPtr >	BoundaryConditionCollection

typedef std::shared_ptr< BoundaryConditions >	BoundaryConditionsSharedPtr

typedef unique_ptr_objpool< Geometry >	GeometryUniquePtr

typedef unique_ptr_objpool< GeomFactors >	GeomFactorsUniquePtr

typedef unique_ptr_objpool< Curve >	CurveUniquePtr

typedef std::map< int, CurveUniquePtr >	CurveMap

typedef std::vector< GeomFactors * >	GeomFactorsVector
	A vector of GeomFactor pointers.

typedef std::unordered_set< GeomFactors * >	GeomFactorsSet
	An unordered set of GeomFactor pointers.

typedef Array< OneD, Array< OneD, Array< OneD, NekDouble > > >	DerivStorage
	Storage type for derivative of mapping.

template<typename T >
using	GeomMap = std::map< int, unique_ptr_objpool< T > >

typedef unique_ptr_objpool< PointGeom >	PointGeomUniquePtr

typedef unique_ptr_objpool< SegGeom >	SegGeomUniquePtr

typedef unique_ptr_objpool< TriGeom >	TriGeomUniquePtr

typedef unique_ptr_objpool< QuadGeom >	QuadGeomUniquePtr

typedef unique_ptr_objpool< TetGeom >	TetGeomUniquePtr

typedef unique_ptr_objpool< PyrGeom >	PyrGeomUniquePtr

typedef unique_ptr_objpool< PrismGeom >	PrismGeomUniquePtr

typedef unique_ptr_objpool< HexGeom >	HexGeomUniquePtr

typedef unique_ptr_objpool< Geometry2D >	Geometry2DUniquePtr

typedef unique_ptr_objpool< Geometry3D >	Geometry3DUniquePtr

typedef std::map< int, std::pair< LibUtilities::ShapeType, std::vector< int > > >	CompositeDescriptor

typedef std::map< int, std::vector< unsigned int > >	CompositeOrdering

typedef std::map< int, std::vector< unsigned int > >	BndRegionOrdering

typedef std::shared_ptr< Composite >	CompositeSharedPtr

typedef std::map< int, CompositeSharedPtr >	CompositeMap

typedef std::shared_ptr< ExpansionInfo >	ExpansionInfoShPtr

typedef std::map< int, ExpansionInfoShPtr >	ExpansionInfoMap

typedef std::shared_ptr< ExpansionInfoMap >	ExpansionInfoMapShPtr

typedef std::map< std::string, ExpansionInfoMapShPtr >	ExpansionInfoMapShPtrMap

typedef std::map< std::string, std::string >	GeomInfoMap

typedef std::shared_ptr< std::vector< std::pair< Geometry *, int > > >	GeometryLinkSharedPtr

typedef std::map< std::string, std::string >	MeshMetaDataMap

typedef std::shared_ptr< MeshGraph >	MeshGraphSharedPtr

typedef std::shared_ptr< Movement >	MovementSharedPtr

typedef LibUtilities::NekFactory< std::string, MeshGraph >	MeshGraphFactory

typedef std::shared_ptr< MeshGraphIO >	MeshGraphIOSharedPtr

typedef LibUtilities::NekFactory< std::string, MeshGraphIO >	MeshGraphIOFactory

typedef LibUtilities::NekFactory< std::string, MeshPartition, const LibUtilities::SessionReaderSharedPtr, LibUtilities::CommSharedPtr, int, std::map< int, MeshEntity >, CompositeDescriptor >	MeshPartitionFactory
	Datatype of the NekFactory used to instantiate classes derived from the EquationSystem class.

typedef std::shared_ptr< MeshPartition >	MeshPartitionSharedPtr

typedef std::shared_ptr< Interface >	InterfaceShPtr

typedef std::shared_ptr< InterfacePair >	InterfacePairShPtr

typedef std::map< std::pair< int, std::string >, InterfacePairShPtr >	InterfaceCollection

typedef std::shared_ptr< ZoneBase >	ZoneBaseShPtr

typedef std::shared_ptr< ZoneRotate >	ZoneRotateShPtr

typedef std::shared_ptr< ZoneTranslate >	ZoneTranslateShPtr

typedef std::shared_ptr< ZoneFixed >	ZoneFixedShPtr

Enumerations
enum	BoundaryConditionType { eDirichlet , eNeumann , eRobin , ePeriodic , eNotDefined }

enum	ExpansionType { eNoExpansionType , eModified , eModifiedQuadPlus1 , eModifiedQuadPlus2 , eModifiedGLLRadau10 , eOrthogonal , eGLL_Lagrange , eGLL_Lagrange_SEM , eGauss_Lagrange , eGauss_Lagrange_SEM , eFourier , eFourierSingleMode , eFourierHalfModeRe , eFourierHalfModeIm , eChebyshev , eFourierChebyshev , eChebyshevFourier , eFourierModified , eExpansionTypeSize }

enum	MovementType { eNone , eFixed , eRotate , eTranslate , SIZE_MovementType }
	Enum of zone movement type. More...

enum	GeomType { eNoGeomType , eRegular , eDeformed , eMovingRegular }
	Indicates the type of element geometry. More...

enum	GeomState { eNotFilled , ePtsFilled }
	Indicates if the geometric information for an element has been populated. More...

enum	GeomMMF { eTangentX , eTangentY , eTangentXY , eTangentZ , eTangentCircular , eTangentIrregular , eTangentNonconvex , eLOCAL }
	Principle direction for MMF. More...

Functions
Array< OneD, int >	ToArray (const std::set< int > &set)

std::set< int >	ShareAllBoundaryIDs (const BoundaryRegionCollection &boundaryRegions, LibUtilities::CommSharedPtr comm)

bool	SortByGlobalId (const Geometry &lhs, const Geometry &rhs)
	Less than operator to sort Geometry objects by global id when sorting STL containers.

bool	GlobalIdEquality (const Geometry &lhs, const Geometry &rhs)

bool	operator== (const GeomFactors &lhs, const GeomFactors &rhs)
	Equivalence test for GeomFactors objects.

XmapFactory< StdRegions::StdHexExp, 3 > &	GetStdHexFactory ()

MeshGraphFactory &	GetMeshGraphFactory ()

MeshGraphIOFactory &	GetMeshGraphIOFactory ()

std::pair< size_t, size_t >	SplitWork (size_t vecsize, int rank, int nprocs)
	Utility function to split a vector equally amongst a number of processors.

template<class T , typename std::enable_if< T::kDim==0, int >::type = 0>
int	GetGeomDataDim (GeomMapView< T > &geomMap)

template<class... T>
void	UniqueValues (std::unordered_set< int > &unique)

template<class... T>
void	UniqueValues (std::unordered_set< int > &unique, const std::vector< int > &input, T &...args)

template<class T , typename std::enable_if< T::kDim==0, int >::type = 0>
NekDouble	GetGeomData (T *geom, int i)

template<class T , typename std::enable_if< T::kDim==1, int >::type = 0>
int	GetGeomData (T *geom, int i)

void	WriteVert (PointGeom vert, TiXmlElement vertTag)

void	WriteEdge (SegGeom seg, TiXmlElement edgeTag, std::string &tag, int edgeID)

void	WriteTri (TriGeom tri, TiXmlElement faceTag, std::string &tag, int triID)

void	WriteQuad (QuadGeom quad, TiXmlElement faceTag, std::string &tag, int quadID)

void	WriteHex (HexGeom hex, TiXmlElement elmtTag, std::string &tag, int hexID)

void	WritePrism (PrismGeom pri, TiXmlElement elmtTag, std::string &tag, int priID)

void	WritePyr (PyrGeom pyr, TiXmlElement elmtTag, std::string &tag, int pyrID)

void	WriteTet (TetGeom tet, TiXmlElement elmtTag, std::string &tag, int tetID)

void	WriteCurvedEdge (CurveUniquePtr &curve, TiXmlElement *curveTag, int &curveId)

void	WriteCurvedFace (CurveUniquePtr &curve, TiXmlElement *curveTag, int &curveId)

void	WriteVert (PointGeom *vert, std::vector< MeshVertex > &vertInfo, int vertID)

void	WriteEdge (SegGeom *seg, std::vector< MeshEdge > &edgeInfo, int edgeID)

void	WriteTri (TriGeom *tri, std::vector< MeshTri > &triInfo, int triID)

void	WriteQuad (QuadGeom *quad, std::vector< MeshQuad > &quadInfo, int quadID)

void	WriteHex (HexGeom *hex, std::vector< MeshHex > &elementInfo, int hexID)

void	WritePrism (PrismGeom *prism, std::vector< MeshPrism > &elementInfo, int prismID)

void	WritePyr (PyrGeom *pyr, std::vector< MeshPyr > &elementInfo, int pyrID)

void	WriteTet (TetGeom *tet, std::vector< MeshTet > &elementInfo, int tetID)

void	WriteCurvedEdge (CurveUniquePtr &curve, int key, std::vector< MeshCurvedInfo > &edgeInfo, int &edgeCnt, int &ptOffset, int &newIdx, MeshCurvedPts &curvedPts)

void	WriteCurvedFace (CurveUniquePtr &curve, int key, std::vector< MeshCurvedInfo > &faceInfo, int &faceCnt, int &ptOffset, int &newIdx, MeshCurvedPts &curvedPts)

MeshPartitionFactory &	GetMeshPartitionFactory ()

static std::string	ReadTag (std::string &tagStr)

static std::string	StripParentheses (const std::string &str)

bool	operator== (const PointGeom &x, const PointGeom &y)
	Determine equivalence by the ids. No matter what the position, if the ids are the same, then they are equivalent, and vice versa.

bool	operator== (const PointGeom &x, const PointGeom *y)

bool	operator== (const PointGeom *x, const PointGeom &y)

bool	operator!= (const PointGeom &x, const PointGeom &y)

bool	operator!= (const PointGeom &x, const PointGeom *y)

bool	operator!= (const PointGeom *x, const PointGeom &y)

XmapFactory< StdRegions::StdPrismExp, 3 > &	GetStdPrismFactory ()

XmapFactory< StdRegions::StdPyrExp, 3 > &	GetStdPyrFactory ()

XmapFactory< StdRegions::StdQuadExp, 2 > &	GetStdQuadFactory ()

XmapFactory< StdRegions::StdSegExp, 1 > &	GetStdSegFactory ()

XmapFactory< StdRegions::StdTetExp, 3 > &	GetStdTetFactory ()

XmapFactory< StdRegions::StdTriExp, 2 > &	GetStdTriFactory ()

Variables
static const Array< OneD, BoundaryConditionShPtr >	NullBoundaryConditionShPtrArray

const std::string	kExpansionTypeStr []

const std::string	MovementTypeStr []
	Map of zone movement type to movement type string.

const char *const	GeomMMFMap []
	Session file names associated with tangent principle directions.

Typedef Documentation

◆ BndRegionOrdering

typedef std::map<int, std::vector<unsigned int> > Nektar::SpatialDomains::BndRegionOrdering

Definition at line 178 of file MeshGraph.h.

◆ BoundaryConditionCollection

typedef std::map<int, BoundaryConditionMapShPtr> Nektar::SpatialDomains::BoundaryConditionCollection

Definition at line 258 of file Conditions.h.

◆ BoundaryConditionMap

typedef std::map<std::string, BoundaryConditionShPtr> Nektar::SpatialDomains::BoundaryConditionMap

Definition at line 256 of file Conditions.h.

◆ BoundaryConditionMapShPtr

typedef std::shared_ptr<BoundaryConditionMap> Nektar::SpatialDomains::BoundaryConditionMapShPtr

Definition at line 257 of file Conditions.h.

◆ BoundaryConditionShPtr

typedef std::shared_ptr<BoundaryConditionBase> Nektar::SpatialDomains::BoundaryConditionShPtr

Definition at line 251 of file Conditions.h.

◆ BoundaryConditionsSharedPtr

typedef std::shared_ptr<BoundaryConditions> Nektar::SpatialDomains::BoundaryConditionsSharedPtr

Definition at line 327 of file Conditions.h.

◆ BoundaryRegion

typedef std::map<int, CompositeSharedPtr> Nektar::SpatialDomains::BoundaryRegion

Definition at line 246 of file Conditions.h.

◆ BoundaryRegionCollection

typedef std::map<int, BoundaryRegionShPtr> Nektar::SpatialDomains::BoundaryRegionCollection

Definition at line 249 of file Conditions.h.

◆ BoundaryRegionShPtr

typedef std::shared_ptr<BoundaryRegion> Nektar::SpatialDomains::BoundaryRegionShPtr

Definition at line 247 of file Conditions.h.

◆ CompositeDescriptor

typedef std::map< int, std::pair< LibUtilities::ShapeType, std::vector< int > > > Nektar::SpatialDomains::CompositeDescriptor

Definition at line 131 of file MeshGraph.h.

◆ CompositeMap

typedef std::map< int, CompositeSharedPtr > Nektar::SpatialDomains::CompositeMap

Definition at line 186 of file MeshGraph.h.

◆ CompositeOrdering

typedef std::map<int, std::vector<unsigned int> > Nektar::SpatialDomains::CompositeOrdering

Definition at line 177 of file MeshGraph.h.

◆ CompositeSharedPtr

typedef std::shared_ptr< Composite > Nektar::SpatialDomains::CompositeSharedPtr

Definition at line 185 of file MeshGraph.h.

◆ ConstBoundaryRegionShPtr

typedef std::shared_ptr<const BoundaryRegion> Nektar::SpatialDomains::ConstBoundaryRegionShPtr

Definition at line 248 of file Conditions.h.

◆ CurveMap

typedef std::map<int, CurveUniquePtr> Nektar::SpatialDomains::CurveMap

Definition at line 71 of file Geometry.h.

◆ CurveUniquePtr

typedef unique_ptr_objpool< Curve > Nektar::SpatialDomains::CurveUniquePtr

Definition at line 70 of file Geometry.h.

◆ DerivStorage

typedef Array<OneD, Array<OneD, Array<OneD, NekDouble> > > Nektar::SpatialDomains::DerivStorage

Storage type for derivative of mapping.

Definition at line 62 of file GeomFactors.h.

◆ DirichletBCShPtr

typedef std::shared_ptr<DirichletBoundaryCondition> Nektar::SpatialDomains::DirichletBCShPtr

Definition at line 252 of file Conditions.h.

◆ ExpansionInfoMap

typedef std::map<int, ExpansionInfoShPtr> Nektar::SpatialDomains::ExpansionInfoMap

Definition at line 191 of file MeshGraph.h.

◆ ExpansionInfoMapShPtr

typedef std::shared_ptr<ExpansionInfoMap> Nektar::SpatialDomains::ExpansionInfoMapShPtr

Definition at line 193 of file MeshGraph.h.

◆ ExpansionInfoMapShPtrMap

typedef std::map<std::string, ExpansionInfoMapShPtr> Nektar::SpatialDomains::ExpansionInfoMapShPtrMap

Definition at line 194 of file MeshGraph.h.

◆ ExpansionInfoShPtr

typedef std::shared_ptr<ExpansionInfo> Nektar::SpatialDomains::ExpansionInfoShPtr

Definition at line 190 of file MeshGraph.h.

◆ Geometry2DUniquePtr

typedef unique_ptr_objpool<Geometry2D> Nektar::SpatialDomains::Geometry2DUniquePtr

Definition at line 109 of file MeshGraph.h.

◆ Geometry3DUniquePtr

typedef unique_ptr_objpool<Geometry3D> Nektar::SpatialDomains::Geometry3DUniquePtr

Definition at line 110 of file MeshGraph.h.

◆ GeometryLinkSharedPtr

typedef std::shared_ptr<std::vector<std::pair<Geometry *, int> > > Nektar::SpatialDomains::GeometryLinkSharedPtr

Definition at line 216 of file MeshGraph.h.

◆ GeometryUniquePtr

typedef unique_ptr_objpool<Geometry> Nektar::SpatialDomains::GeometryUniquePtr

Definition at line 61 of file Geometry.h.

◆ GeomFactorsSet

typedef std::unordered_set<GeomFactors *> Nektar::SpatialDomains::GeomFactorsSet

An unordered set of GeomFactor pointers.

Definition at line 60 of file GeomFactors.h.

◆ GeomFactorsUniquePtr

typedef unique_ptr_objpool< GeomFactors > Nektar::SpatialDomains::GeomFactorsUniquePtr

Definition at line 62 of file Geometry.h.

◆ GeomFactorsVector

typedef std::vector<GeomFactors *> Nektar::SpatialDomains::GeomFactorsVector

A vector of GeomFactor pointers.

Definition at line 58 of file GeomFactors.h.

◆ GeomInfoMap

typedef std::map<std::string, std::string> Nektar::SpatialDomains::GeomInfoMap

Definition at line 214 of file MeshGraph.h.

◆ GeomMap

template<typename T >

using Nektar::SpatialDomains::GeomMap = typedef std::map<int, unique_ptr_objpool<T> >

Definition at line 96 of file MeshGraph.h.

◆ HexGeomUniquePtr

typedef unique_ptr_objpool<HexGeom> Nektar::SpatialDomains::HexGeomUniquePtr

Definition at line 108 of file MeshGraph.h.

◆ InterfaceCollection

typedef std::map<std::pair<int, std::string>, InterfacePairShPtr> Nektar::SpatialDomains::InterfaceCollection

Definition at line 50 of file Movement.h.

◆ InterfacePairShPtr

typedef std::shared_ptr<InterfacePair> Nektar::SpatialDomains::InterfacePairShPtr

Definition at line 167 of file InterfaceInterpolation.h.

◆ InterfaceShPtr

typedef std::shared_ptr<Interface> Nektar::SpatialDomains::InterfaceShPtr

Definition at line 128 of file InterfaceInterpolation.h.

◆ MeshGraphFactory

typedef LibUtilities::NekFactory<std::string, MeshGraph> Nektar::SpatialDomains::MeshGraphFactory

Definition at line 972 of file MeshGraph.h.

◆ MeshGraphIOFactory

typedef LibUtilities::NekFactory<std::string, MeshGraphIO> Nektar::SpatialDomains::MeshGraphIOFactory

Definition at line 110 of file MeshGraphIO.h.

◆ MeshGraphIOSharedPtr

typedef std::shared_ptr<MeshGraphIO> Nektar::SpatialDomains::MeshGraphIOSharedPtr

Definition at line 46 of file MeshGraphIO.h.

◆ MeshGraphSharedPtr

typedef std::shared_ptr< MeshGraph > Nektar::SpatialDomains::MeshGraphSharedPtr

Definition at line 224 of file MeshGraph.h.

◆ MeshMetaDataMap

typedef std::map<std::string, std::string> Nektar::SpatialDomains::MeshMetaDataMap

Definition at line 221 of file MeshGraph.h.

◆ MeshPartitionFactory

typedef LibUtilities::NekFactory<std::string, MeshPartition, const LibUtilities::SessionReaderSharedPtr, LibUtilities::CommSharedPtr, int, std::map<int, MeshEntity>, CompositeDescriptor> Nektar::SpatialDomains::MeshPartitionFactory

Datatype of the NekFactory used to instantiate classes derived from the EquationSystem class.

Definition at line 61 of file MeshPartition.h.

◆ MeshPartitionSharedPtr

typedef std::shared_ptr<MeshPartition> Nektar::SpatialDomains::MeshPartitionSharedPtr

Definition at line 174 of file MeshPartition.h.

◆ MovementSharedPtr

typedef std::shared_ptr< Movement > Nektar::SpatialDomains::MovementSharedPtr

Definition at line 227 of file MeshGraph.h.

◆ NeumannBCShPtr

typedef std::shared_ptr<NeumannBoundaryCondition> Nektar::SpatialDomains::NeumannBCShPtr

Definition at line 253 of file Conditions.h.

◆ PointGeomUniquePtr

typedef unique_ptr_objpool< PointGeom > Nektar::SpatialDomains::PointGeomUniquePtr

Definition at line 99 of file MeshGraph.h.

◆ PrismGeomUniquePtr

typedef unique_ptr_objpool<PrismGeom> Nektar::SpatialDomains::PrismGeomUniquePtr

Definition at line 107 of file MeshGraph.h.

◆ PyrGeomUniquePtr

typedef unique_ptr_objpool<PyrGeom> Nektar::SpatialDomains::PyrGeomUniquePtr

Definition at line 106 of file MeshGraph.h.

◆ QuadGeomUniquePtr

typedef unique_ptr_objpool<QuadGeom> Nektar::SpatialDomains::QuadGeomUniquePtr

Definition at line 104 of file MeshGraph.h.

◆ RobinBCShPtr

typedef std::shared_ptr<RobinBoundaryCondition> Nektar::SpatialDomains::RobinBCShPtr

Definition at line 254 of file Conditions.h.

◆ SegGeomUniquePtr

typedef unique_ptr_objpool< SegGeom > Nektar::SpatialDomains::SegGeomUniquePtr

Definition at line 102 of file MeshGraph.h.

◆ TetGeomUniquePtr

typedef unique_ptr_objpool<TetGeom> Nektar::SpatialDomains::TetGeomUniquePtr

Definition at line 105 of file MeshGraph.h.

◆ TriGeomUniquePtr

typedef unique_ptr_objpool<TriGeom> Nektar::SpatialDomains::TriGeomUniquePtr

Definition at line 103 of file MeshGraph.h.

◆ ZoneBaseShPtr

typedef std::shared_ptr<ZoneBase> Nektar::SpatialDomains::ZoneBaseShPtr

Definition at line 177 of file Zones.h.

◆ ZoneFixedShPtr

typedef std::shared_ptr<ZoneFixed> Nektar::SpatialDomains::ZoneFixedShPtr

Definition at line 377 of file Zones.h.

◆ ZoneRotateShPtr

typedef std::shared_ptr<ZoneRotate> Nektar::SpatialDomains::ZoneRotateShPtr

Definition at line 375 of file Zones.h.

◆ ZoneTranslateShPtr

typedef std::shared_ptr<ZoneTranslate> Nektar::SpatialDomains::ZoneTranslateShPtr

Definition at line 376 of file Zones.h.

Enumeration Type Documentation

◆ BoundaryConditionType

enum Nektar::SpatialDomains::BoundaryConditionType

Enumerator
eDirichlet
eNeumann
eRobin
ePeriodic
eNotDefined

Definition at line 52 of file Conditions.h.

{
    eDirichlet,
    eNeumann,
    eRobin,
    ePeriodic,
    eNotDefined
};

◆ ExpansionType

enum Nektar::SpatialDomains::ExpansionType

Enumerator
eNoExpansionType
eModified
eModifiedQuadPlus1
eModifiedQuadPlus2
eModifiedGLLRadau10
eOrthogonal
eGLL_Lagrange
eGLL_Lagrange_SEM
eGauss_Lagrange
eGauss_Lagrange_SEM
eFourier
eFourierSingleMode
eFourierHalfModeRe
eFourierHalfModeIm
eChebyshev
eFourierChebyshev
eChebyshevFourier
eFourierModified
eExpansionTypeSize

Definition at line 133 of file MeshGraph.h.

{
    eNoExpansionType,
    eModified,
    eModifiedQuadPlus1,
    eModifiedQuadPlus2,
    eModifiedGLLRadau10,
    eOrthogonal,
    eGLL_Lagrange,
    eGLL_Lagrange_SEM,
    eGauss_Lagrange,
    eGauss_Lagrange_SEM,
    eFourier,
    eFourierSingleMode,
    eFourierHalfModeRe,
    eFourierHalfModeIm,
    eChebyshev,
    eFourierChebyshev,
    eChebyshevFourier,
    eFourierModified,
    eExpansionTypeSize
};

◆ GeomMMF

enum Nektar::SpatialDomains::GeomMMF

Principle direction for MMF.

Enumerator
eTangentX	X coordinate direction.
eTangentY	Y coordinate direction.
eTangentXY	XY direction.
eTangentZ	Z coordinate direction.
eTangentCircular	Circular around the centre of domain.
eTangentIrregular	Circular around the centre of domain.
eTangentNonconvex	Circular around the centre of domain.
eLOCAL	No Principal direction.

Definition at line 71 of file SpatialDomains.hpp.

{
    eTangentX,         ///< X coordinate direction.
    eTangentY,         ///< Y coordinate direction.
    eTangentXY,        ///< XY direction.
    eTangentZ,         ///< Z coordinate direction.
    eTangentCircular,  ///< Circular around the centre of domain.
    eTangentIrregular, ///< Circular around the centre of domain.
    eTangentNonconvex, ///< Circular around the centre of domain.
    eLOCAL,            ///< No Principal direction.
};

◆ GeomState

enum Nektar::SpatialDomains::GeomState

Indicates if the geometric information for an element has been populated.

Enumerator
eNotFilled	Geometric information has not been generated.
ePtsFilled	Geometric information has been generated.

Definition at line 62 of file SpatialDomains.hpp.

{
    eNotFilled, ///< Geometric information has not been generated.
    ePtsFilled  ///< Geometric information has been generated.
};

◆ GeomType

enum Nektar::SpatialDomains::GeomType

Indicates the type of element geometry.

This property of the element geometry is used to indicate the necessary storage for the element's geometric information and its corresponding computational complexity. In many cases significant savings in both cases can be made based on this information, in comparison to the most generic case.

Enumerator
eNoGeomType	No type defined.
eRegular	Geometry is straight-sided with constant geometric factors.
eDeformed	Geometry is curved or has non-constant factors.
eMovingRegular	Currently unused.

Definition at line 49 of file SpatialDomains.hpp.

{
    eNoGeomType,    ///< No type defined.
    eRegular,       ///< Geometry is straight-sided with constant
                    ///  geometric factors.
    eDeformed,      ///< Geometry is curved or has non-constant factors.
    eMovingRegular, ///< Currently unused.
};

◆ MovementType

enum Nektar::SpatialDomains::MovementType

Enum of zone movement type.

Enumerator
eNone
eFixed
eRotate
eTranslate
SIZE_MovementType

Definition at line 47 of file Zones.h.

{
    eNone,
    eFixed,
    eRotate,
    eTranslate,
    SIZE_MovementType
};

Function Documentation

◆ GetGeomData() [1/2]

template<class T , typename std::enable_if< T::kDim==0, int >::type = 0>

NekDouble Nektar::SpatialDomains::GetGeomData	(	T *	geom,
		int	i
	)

inline

Definition at line 1521 of file MeshGraphIOHDF5.cpp.

{
    return (*geom)(i);
}

Referenced by Nektar::SpatialDomains::MeshGraphIOHDF5::WriteGeometryMap().

◆ GetGeomData() [2/2]

template<class T , typename std::enable_if< T::kDim==1, int >::type = 0>

int Nektar::SpatialDomains::GetGeomData	(	T *	geom,
		int	i
	)

inline

Definition at line 1527 of file MeshGraphIOHDF5.cpp.

{
    return geom->GetVid(i);
}

◆ GetGeomDataDim()

template<class T , typename std::enable_if< T::kDim==0, int >::type = 0>

int Nektar::SpatialDomains::GetGeomDataDim ( GeomMapView< T > & geomMap )

inline

Definition at line 110 of file MeshGraphIOHDF5.cpp.

{
    return 3;
}

Referenced by Nektar::SpatialDomains::MeshGraphIOHDF5::FillGeomMap(), Nektar::SpatialDomains::MeshGraphIOHDF5::ReadGeometryData(), and Nektar::SpatialDomains::MeshGraphIOHDF5::WriteGeometryMap().

◆ GetMeshGraphFactory()

MeshGraphFactory & Nektar::SpatialDomains::GetMeshGraphFactory ( )

Returns an instance of the MeshGraph factory, held as a singleton.

Definition at line 88 of file MeshGraph.cpp.

{
    static MeshGraphFactory instance;
    return instance;
}

◆ GetMeshGraphIOFactory()

MeshGraphIOFactory & Nektar::SpatialDomains::GetMeshGraphIOFactory ( )

Returns an instance of the MeshGraphIO factory, held as a singleton.

Definition at line 45 of file MeshGraphIO.cpp.

{
    static MeshGraphIOFactory instance;
    return instance;
}

Referenced by MeshGraphIO_Create(), Nektar::SpatialDomains::MeshGraphIO::Read(), Nektar::FieldUtils::OutputXml::v_Process(), and Nektar::IterativeElasticSystem::WriteGeometry().

◆ GetMeshPartitionFactory()

MeshPartitionFactory & Nektar::SpatialDomains::GetMeshPartitionFactory ( )

Definition at line 66 of file MeshPartition.cpp.

{
    static MeshPartitionFactory instance;
    return instance;
}

Referenced by Nektar::SpatialDomains::MeshGraphIOHDF5::v_PartitionMesh(), and Nektar::SpatialDomains::MeshGraphIOXml::v_PartitionMesh().

◆ GetStdHexFactory()

XmapFactory< StdRegions::StdHexExp, 3 > & Nektar::SpatialDomains::GetStdHexFactory ( )

Definition at line 46 of file HexGeom.cpp.

{
    static XmapFactory<StdRegions::StdHexExp, 3> factory;
    return factory;
}

Referenced by Nektar::SpatialDomains::HexGeom::SetUpXmap().

◆ GetStdPrismFactory()

XmapFactory< StdRegions::StdPrismExp, 3 > & Nektar::SpatialDomains::GetStdPrismFactory ( )

Definition at line 55 of file PrismGeom.cpp.

{
    static XmapFactory<StdRegions::StdPrismExp, 3> factory;
    return factory;
}

Referenced by Nektar::SpatialDomains::PrismGeom::SetUpXmap().

◆ GetStdPyrFactory()

XmapFactory< StdRegions::StdPyrExp, 3 > & Nektar::SpatialDomains::GetStdPyrFactory ( )

Definition at line 49 of file PyrGeom.cpp.

{
    static XmapFactory<StdRegions::StdPyrExp, 3> factory;
    return factory;
}

Referenced by Nektar::SpatialDomains::PyrGeom::SetUpXmap().

◆ GetStdQuadFactory()

XmapFactory< StdRegions::StdQuadExp, 2 > & Nektar::SpatialDomains::GetStdQuadFactory ( )

Definition at line 48 of file QuadGeom.cpp.

{
    static XmapFactory<StdRegions::StdQuadExp, 2> factory;
    return factory;
}

Referenced by Nektar::SpatialDomains::QuadGeom::SetUpXmap().

◆ GetStdSegFactory()

XmapFactory< StdRegions::StdSegExp, 1 > & Nektar::SpatialDomains::GetStdSegFactory ( )

Definition at line 59 of file SegGeom.cpp.

{
    static XmapFactory<StdRegions::StdSegExp, 1> factory;
    return factory;
}

◆ GetStdTetFactory()

XmapFactory< StdRegions::StdTetExp, 3 > & Nektar::SpatialDomains::GetStdTetFactory ( )

Definition at line 53 of file TetGeom.cpp.

{
    static XmapFactory<StdRegions::StdTetExp, 3> factory;
    return factory;
}

Referenced by Nektar::SpatialDomains::TetGeom::SetUpXmap().

◆ GetStdTriFactory()

XmapFactory< StdRegions::StdTriExp, 2 > & Nektar::SpatialDomains::GetStdTriFactory ( )

Definition at line 48 of file TriGeom.cpp.

{
    static XmapFactory<StdRegions::StdTriExp, 2> factory;
    return factory;
}

Referenced by Nektar::SpatialDomains::TriGeom::SetUpXmap().

◆ GlobalIdEquality()

bool Nektar::SpatialDomains::GlobalIdEquality	(	const Geometry *&	lhs,
		const Geometry *&	rhs
	)

Definition at line 67 of file Geometry.cpp.

{
    return lhs->GetGlobalID() == rhs->GetGlobalID();
}

References Nektar::SpatialDomains::Geometry::GetGlobalID().

◆ operator!=() [1/3]

bool Nektar::SpatialDomains::operator!=	(	const PointGeom &	x,
		const PointGeom &	y
	)

Definition at line 203 of file PointGeom.cpp.

{
    return (x.m_globalID != y.m_globalID);
}

◆ operator!=() [2/3]

bool Nektar::SpatialDomains::operator!=	(	const PointGeom &	x,
		const PointGeom *	y
	)

Definition at line 208 of file PointGeom.cpp.

{
    return (x.m_globalID != y->m_globalID);
}

◆ operator!=() [3/3]

bool Nektar::SpatialDomains::operator!=	(	const PointGeom *	x,
		const PointGeom &	y
	)

Definition at line 213 of file PointGeom.cpp.

{
    return (x->m_globalID != y.m_globalID);
}

◆ operator==() [1/4]

bool Nektar::SpatialDomains::operator==	(	const GeomFactors &	lhs,
		const GeomFactors &	rhs
	)

Equivalence test for GeomFactors objects.

Tests if two GeomFactors classes are equal.

Member data equivalence is tested in the following order: shape type, expansion dimension, coordinate dimension and coordinates.

Definition at line 113 of file GeomFactors.cpp.

{
    if (!(lhs.m_type == rhs.m_type))
    {
        return false;
    }
 
    if (!(lhs.m_expDim == rhs.m_expDim))
    {
        return false;
    }
 
    if (!(lhs.m_coordDim == rhs.m_coordDim))
    {
        return false;
    }
 
    const Array<OneD, const NekDouble> jac_lhs =
        lhs.ComputeJac(lhs.m_xmap->GetPointsKeys());
    const Array<OneD, const NekDouble> jac_rhs =
        rhs.ComputeJac(rhs.m_xmap->GetPointsKeys());
    if (!(jac_lhs == jac_rhs))
    {
        return false;
    }
 
    return true;
}

◆ operator==() [2/4]

bool Nektar::SpatialDomains::operator==	(	const PointGeom &	x,
		const PointGeom &	y
	)

Determine equivalence by the ids. No matter what the position, if the ids are the same, then they are equivalent, and vice versa.

Definition at line 188 of file PointGeom.cpp.

{
    return (x.m_globalID == y.m_globalID);
}

◆ operator==() [3/4]

bool Nektar::SpatialDomains::operator==	(	const PointGeom &	x,
		const PointGeom *	y
	)

Definition at line 193 of file PointGeom.cpp.

{
    return (x.m_globalID == y->m_globalID);
}

◆ operator==() [4/4]

bool Nektar::SpatialDomains::operator==	(	const PointGeom *	x,
		const PointGeom &	y
	)

Definition at line 198 of file PointGeom.cpp.

{
    return (x->m_globalID == y.m_globalID);
}

◆ ReadTag()

static std::string Nektar::SpatialDomains::ReadTag ( std::string & tagStr )

inlinestatic

Definition at line 50 of file Movement/Movement.cpp.

{
    std::string::size_type indxBeg = tagStr.find_first_of('[') + 1;
    std::string::size_type indxEnd = tagStr.find_last_of(']') - 1;
 
    ASSERTL0(
        indxBeg <= indxEnd,
        (std::string("Error reading interface region definition:") + tagStr)
            .c_str());
 
    std::string indxStr = tagStr.substr(indxBeg, indxEnd - indxBeg + 1);
 
    return indxStr;
}

References ASSERTL0.

Referenced by Nektar::SpatialDomains::Movement::ReadInterfaces(), and Nektar::SpatialDomains::Movement::ReadZones().

◆ ShareAllBoundaryIDs()

std::set< int > Nektar::SpatialDomains::ShareAllBoundaryIDs	(	const BoundaryRegionCollection &	boundaryRegions,
		LibUtilities::CommSharedPtr	comm
	)

Definition at line 78 of file Conditions.cpp.

{
    // Turn the keys of boundaryRegions into set.
    std::set<int> ids;
    auto it = boundaryRegions.begin(), end = boundaryRegions.end();
    int i = 0;
    for (; it != end; ++it, ++i)
    {
        ids.insert(it->first);
    }
 
    int np = comm->GetSize();
    int ip = comm->GetRank();
 
    int half_size = 1;
    bool involved = true;
    while (involved && half_size < np)
    {
        if (ip & half_size)
        {
            // I'm sender
 
            // The receiver rank
            int receiver = ip - half_size;
 
            Array<OneD, int> idsArray = ToArray(ids);
            // Send my size (to alloc the reciever array)
            Array<OneD, int> sender_size(1);
            sender_size[0] = idsArray.size();
            comm->Send(receiver, sender_size);
 
            // Send my data
            comm->Send(receiver, idsArray);
 
            // Once we've sent, we're no longer involved.
            involved = false;
        }
        else
        {
            // I'm receiver
 
            // The sender rank
            int sender = ip + half_size;
 
            if (sender < np)
            {
                // Receive the size
                Array<OneD, int> sender_size(1);
                comm->Recv(sender, sender_size);
 
                // Receive the data
                Array<OneD, int> other_ids(sender_size[0]);
                comm->Recv(sender, other_ids);
 
                // Merge
                ids.insert(other_ids.begin(), other_ids.end());
            }
        }
        half_size *= 2;
    }
 
    // Bcast the size
    int nIds;
    if (ip == 0)
    {
        nIds = ids.size();
    }
 
    comm->Bcast(nIds, 0);
 
    // Bcast the data
    Array<OneD, int> idsArray;
    if (ip == 0)
    {
        idsArray = ToArray(ids);
    }
    else
    {
        idsArray = Array<OneD, int>(nIds);
    }
 
    comm->Bcast(idsArray, 0);
 
    return std::set<int>(idsArray.begin(), idsArray.end());
}

References ToArray().

Referenced by Nektar::SpatialDomains::BoundaryConditions::CreateBoundaryComms().

◆ SortByGlobalId()

bool Nektar::SpatialDomains::SortByGlobalId	(	const Geometry *&	lhs,
		const Geometry *&	rhs
	)

Less than operator to sort Geometry objects by global id when sorting STL containers.

Definition at line 62 of file Geometry.cpp.

{
    return lhs->GetGlobalID() < rhs->GetGlobalID();
}

References Nektar::SpatialDomains::Geometry::GetGlobalID().

◆ SplitWork()

std::pair< size_t, size_t > Nektar::SpatialDomains::SplitWork	(	size_t	vecsize,
		int	rank,
		int	nprocs
	)

Utility function to split a vector equally amongst a number of processors.

Parameters

vecsize	Size of the total amount of work
rank	Rank of this process
nprocs	Number of processors in the group

Returns: A pair with the offset this process should occupy, along with the count for the amount of work.

Definition at line 95 of file MeshGraphIOHDF5.cpp.

{
    size_t div = vecsize / nprocs;
    size_t rem = vecsize % nprocs;
    if (rank < rem)
    {
        return std::make_pair(rank * (div + 1), div + 1);
    }
    else
    {
        return std::make_pair((rank - rem) * div + rem * (div + 1), div);
    }
}

Referenced by Nektar::SpatialDomains::MeshGraphIOHDF5::v_PartitionMesh().

◆ StripParentheses()

static std::string Nektar::SpatialDomains::StripParentheses ( const std::string & str )

inlinestatic

Definition at line 65 of file Movement/Movement.cpp.

{
    auto length = str.length();
    return str.substr(1, length - 2);
}

Referenced by Nektar::SpatialDomains::Movement::WriteMovement().

◆ ToArray()

Array< OneD, int > Nektar::SpatialDomains::ToArray ( const std::set< int > & set )

Helper that turns a set into an array.

Definition at line 58 of file Conditions.cpp.

{
    Array<OneD, int> ans(set.size());
    auto it = set.begin(), end = set.end();
    for (int i = 0; it != end; ++it, ++i)
    {
        ans[i] = *it;
    }
    return ans;
}

Referenced by ShareAllBoundaryIDs().

◆ UniqueValues() [1/2]

template<class... T>

void Nektar::SpatialDomains::UniqueValues ( std::unordered_set< int > & unique )

inline

Definition at line 134 of file MeshGraphIOHDF5.cpp.

135{

136}

Referenced by UniqueValues(), and Nektar::SpatialDomains::MeshGraphIOHDF5::v_PartitionMesh().

◆ UniqueValues() [2/2]

template<class... T>

void Nektar::SpatialDomains::UniqueValues	(	std::unordered_set< int > &	unique,
		const std::vector< int > &	input,
		T &...	args
	)

inline

Definition at line 139 of file MeshGraphIOHDF5.cpp.

{
    for (auto i : input)
    {
        unique.insert(i);
    }
 
    UniqueValues(unique, args...);
}

References UniqueValues().

◆ WriteCurvedEdge() [1/2]

void Nektar::SpatialDomains::WriteCurvedEdge	(	CurveUniquePtr &	curve,
		int	key,
		std::vector< MeshCurvedInfo > &	edgeInfo,
		int &	edgeCnt,
		int &	ptOffset,
		int &	newIdx,
		MeshCurvedPts &	curvedPts
	)

Definition at line 1466 of file MeshGraphIOXmlCompressed.cpp.

{
    MeshCurvedInfo cinfo;
    cinfo.id       = edgeCnt++;
    cinfo.entityid = key;
    cinfo.npoints  = curve->m_points.size();
    cinfo.ptype    = curve->m_ptype;
    cinfo.ptid     = 0;
    cinfo.ptoffset = ptOffset;
 
    edgeInfo.push_back(cinfo);
 
    for (int j = 0; j < curve->m_points.size(); j++)
    {
        MeshVertex v;
        v.id = newIdx;
        v.x  = curve->m_points[j]->x();
        v.y  = curve->m_points[j]->y();
        v.z  = curve->m_points[j]->z();
        curvedPts.pts.push_back(v);
        curvedPts.index.push_back(newIdx);
        newIdx++;
    }
    ptOffset += cinfo.npoints;
}

◆ WriteCurvedEdge() [2/2]

void Nektar::SpatialDomains::WriteCurvedEdge	(	CurveUniquePtr &	curve,
		TiXmlElement *	curveTag,
		int &	curveId
	)

Definition at line 2834 of file MeshGraphIOXml.cpp.

{
    TiXmlElement *c = new TiXmlElement("E");
    std::stringstream s;
    s.precision(8);
 
    for (int j = 0; j < curve->m_points.size(); ++j)
    {
        PointGeom *p = curve->m_points[j];
        s << std::scientific << (*p)(0) << " " << (*p)(1) << " " << (*p)(2)
          << "   ";
    }
 
    c->SetAttribute("ID", curveId++);
    c->SetAttribute("EDGEID", curve->m_curveID);
    c->SetAttribute("NUMPOINTS", curve->m_points.size());
    c->SetAttribute("TYPE", LibUtilities::kPointsTypeStr[curve->m_ptype]);
    c->LinkEndChild(new TiXmlText(s.str()));
    curveTag->LinkEndChild(c);
}

References Nektar::LibUtilities::kPointsTypeStr.

Referenced by Nektar::SpatialDomains::MeshGraphIOXml::v_WriteCurves(), and Nektar::SpatialDomains::MeshGraphIOXmlCompressed::v_WriteCurves().

◆ WriteCurvedFace() [1/2]

void Nektar::SpatialDomains::WriteCurvedFace	(	CurveUniquePtr &	curve,
		int	key,
		std::vector< MeshCurvedInfo > &	faceInfo,
		int &	faceCnt,
		int &	ptOffset,
		int &	newIdx,
		MeshCurvedPts &	curvedPts
	)

Definition at line 1493 of file MeshGraphIOXmlCompressed.cpp.

{
    MeshCurvedInfo cinfo;
    cinfo.id       = faceCnt++;
    cinfo.entityid = key;
    cinfo.npoints  = curve->m_points.size();
    cinfo.ptype    = curve->m_ptype;
    cinfo.ptid     = 0;
    cinfo.ptoffset = ptOffset;
 
    faceInfo.push_back(cinfo);
 
    for (int j = 0; j < curve->m_points.size(); j++)
    {
        MeshVertex v;
        v.id = newIdx;
        v.x  = curve->m_points[j]->x();
        v.y  = curve->m_points[j]->y();
        v.z  = curve->m_points[j]->z();
        curvedPts.pts.push_back(v);
        curvedPts.index.push_back(newIdx);
        newIdx++;
    }
    ptOffset += cinfo.npoints;
}

◆ WriteCurvedFace() [2/2]

void Nektar::SpatialDomains::WriteCurvedFace	(	CurveUniquePtr &	curve,
		TiXmlElement *	curveTag,
		int &	curveId
	)

Definition at line 2855 of file MeshGraphIOXml.cpp.

{
    TiXmlElement *c = new TiXmlElement("F");
    std::stringstream s;
    s.precision(8);
 
    for (int j = 0; j < curve->m_points.size(); ++j)
    {
        PointGeom *p = curve->m_points[j];
        s << std::scientific << (*p)(0) << " " << (*p)(1) << " " << (*p)(2)
          << "   ";
    }
 
    c->SetAttribute("ID", curveId++);
    c->SetAttribute("FACEID", curve->m_curveID);
    c->SetAttribute("NUMPOINTS", curve->m_points.size());
    c->SetAttribute("TYPE", LibUtilities::kPointsTypeStr[curve->m_ptype]);
    c->LinkEndChild(new TiXmlText(s.str()));
    curveTag->LinkEndChild(c);
}

References Nektar::LibUtilities::kPointsTypeStr.

Referenced by Nektar::SpatialDomains::MeshGraphIOXml::v_WriteCurves(), and Nektar::SpatialDomains::MeshGraphIOXmlCompressed::v_WriteCurves().

◆ WriteEdge() [1/2]

void Nektar::SpatialDomains::WriteEdge	(	SegGeom *	seg,
		std::vector< MeshEdge > &	edgeInfo,
		int	edgeID
	)

Definition at line 1090 of file MeshGraphIOXmlCompressed.cpp.

{
    MeshEdge e;
    e.id = edgeID;
    e.v0 = seg->GetVid(0);
    e.v1 = seg->GetVid(1);
    edgeInfo.push_back(e);
}

References Nektar::SpatialDomains::Geometry::GetVid(), Nektar::SpatialDomains::MeshEdge::id, Nektar::SpatialDomains::MeshEdge::v0, and Nektar::SpatialDomains::MeshEdge::v1.

◆ WriteEdge() [2/2]

void Nektar::SpatialDomains::WriteEdge	(	SegGeom *	seg,
		TiXmlElement *	edgeTag,
		std::string &	tag,
		int	edgeID
	)

Definition at line 2608 of file MeshGraphIOXml.cpp.

{
    std::stringstream s;
    s << seg->GetVid(0) << " " << seg->GetVid(1);
    TiXmlElement *e = new TiXmlElement(tag);
    e->SetAttribute("ID", edgeID);
    e->LinkEndChild(new TiXmlText(s.str()));
    edgeTag->LinkEndChild(e);
}

References Nektar::SpatialDomains::Geometry::GetVid().

Referenced by Nektar::SpatialDomains::MeshGraphIOXml::v_WriteEdges(), and Nektar::SpatialDomains::MeshGraphIOXmlCompressed::v_WriteEdges().

◆ WriteHex() [1/2]

void Nektar::SpatialDomains::WriteHex	(	HexGeom *	hex,
		std::vector< MeshHex > &	elementInfo,
		int	hexID
	)

Definition at line 1253 of file MeshGraphIOXmlCompressed.cpp.

{
    MeshHex e;
    e.id   = hexID;
    e.f[0] = hex->GetFid(0);
    e.f[1] = hex->GetFid(1);
    e.f[2] = hex->GetFid(2);
    e.f[3] = hex->GetFid(3);
    e.f[4] = hex->GetFid(4);
    e.f[5] = hex->GetFid(5);
    elementInfo.push_back(e);
}

References Nektar::SpatialDomains::MeshHex::f, Nektar::SpatialDomains::Geometry::GetFid(), and Nektar::SpatialDomains::MeshHex::id.

◆ WriteHex() [2/2]

void Nektar::SpatialDomains::WriteHex	(	HexGeom *	hex,
		TiXmlElement *	elmtTag,
		std::string &	tag,
		int	hexID
	)

Definition at line 2708 of file MeshGraphIOXml.cpp.

{
    std::stringstream s;
    s << hex->GetFid(0) << " " << hex->GetFid(1) << " " << hex->GetFid(2) << " "
      << hex->GetFid(3) << " " << hex->GetFid(4) << " " << hex->GetFid(5)
      << " ";
    TiXmlElement *h = new TiXmlElement(tag);
    h->SetAttribute("ID", hexID);
    h->LinkEndChild(new TiXmlText(s.str()));
    elmtTag->LinkEndChild(h);
}

References Nektar::SpatialDomains::Geometry::GetFid().

Referenced by Nektar::SpatialDomains::MeshGraphIOXml::v_WriteHexs(), and Nektar::SpatialDomains::MeshGraphIOXmlCompressed::v_WriteHexs().

◆ WritePrism() [1/2]

void Nektar::SpatialDomains::WritePrism	(	PrismGeom *	pri,
		TiXmlElement *	elmtTag,
		std::string &	tag,
		int	priID
	)

Definition at line 2740 of file MeshGraphIOXml.cpp.

{
    std::stringstream s;
    s << pri->GetFid(0) << " " << pri->GetFid(1) << " " << pri->GetFid(2) << " "
      << pri->GetFid(3) << " " << pri->GetFid(4) << " ";
    TiXmlElement *p = new TiXmlElement(tag);
    p->SetAttribute("ID", priID);
    p->LinkEndChild(new TiXmlText(s.str()));
    elmtTag->LinkEndChild(p);
}

References Nektar::SpatialDomains::Geometry::GetFid().

Referenced by Nektar::SpatialDomains::MeshGraphIOXml::v_WritePrisms(), and Nektar::SpatialDomains::MeshGraphIOXmlCompressed::v_WritePrisms().

◆ WritePrism() [2/2]

void Nektar::SpatialDomains::WritePrism	(	PrismGeom *	prism,
		std::vector< MeshPrism > &	elementInfo,
		int	prismID
	)

Definition at line 1307 of file MeshGraphIOXmlCompressed.cpp.

{
    MeshPrism e;
    e.id   = prismID;
    e.f[0] = prism->GetFid(0);
    e.f[1] = prism->GetFid(1);
    e.f[2] = prism->GetFid(2);
    e.f[3] = prism->GetFid(3);
    e.f[4] = prism->GetFid(4);
    elementInfo.push_back(e);
}

References Nektar::SpatialDomains::MeshPrism::f, Nektar::SpatialDomains::Geometry::GetFid(), and Nektar::SpatialDomains::MeshPrism::id.

◆ WritePyr() [1/2]

void Nektar::SpatialDomains::WritePyr	(	PyrGeom *	pyr,
		std::vector< MeshPyr > &	elementInfo,
		int	pyrID
	)

Definition at line 1361 of file MeshGraphIOXmlCompressed.cpp.

{
    MeshPyr e;
    e.id   = pyrID;
    e.f[0] = pyr->GetFid(0);
    e.f[1] = pyr->GetFid(1);
    e.f[2] = pyr->GetFid(2);
    e.f[3] = pyr->GetFid(3);
    e.f[4] = pyr->GetFid(4);
    elementInfo.push_back(e);
}

References Nektar::SpatialDomains::MeshPyr::f, Nektar::SpatialDomains::Geometry::GetFid(), and Nektar::SpatialDomains::MeshPyr::id.

◆ WritePyr() [2/2]

void Nektar::SpatialDomains::WritePyr	(	PyrGeom *	pyr,
		TiXmlElement *	elmtTag,
		std::string &	tag,
		int	pyrID
	)

Definition at line 2772 of file MeshGraphIOXml.cpp.

{
    std::stringstream s;
    s << pyr->GetFid(0) << " " << pyr->GetFid(1) << " " << pyr->GetFid(2) << " "
      << pyr->GetFid(3) << " " << pyr->GetFid(4) << " ";
    TiXmlElement *p = new TiXmlElement(tag);
    p->SetAttribute("ID", pyrID);
    p->LinkEndChild(new TiXmlText(s.str()));
    elmtTag->LinkEndChild(p);
}

References Nektar::SpatialDomains::Geometry::GetFid().

Referenced by Nektar::SpatialDomains::MeshGraphIOXml::v_WritePyrs(), and Nektar::SpatialDomains::MeshGraphIOXmlCompressed::v_WritePyrs().

◆ WriteQuad() [1/2]

void Nektar::SpatialDomains::WriteQuad	(	QuadGeom *	quad,
		std::vector< MeshQuad > &	quadInfo,
		int	quadID
	)

Definition at line 1201 of file MeshGraphIOXmlCompressed.cpp.

{
    MeshQuad q;
    q.id   = quadID;
    q.e[0] = quad->GetEid(0);
    q.e[1] = quad->GetEid(1);
    q.e[2] = quad->GetEid(2);
    q.e[3] = quad->GetEid(3);
    quadInfo.push_back(q);
}

References Nektar::SpatialDomains::Geometry::GetEid().

◆ WriteQuad() [2/2]

void Nektar::SpatialDomains::WriteQuad	(	QuadGeom *	quad,
		TiXmlElement *	faceTag,
		std::string &	tag,
		int	quadID
	)

Definition at line 2676 of file MeshGraphIOXml.cpp.

{
    std::stringstream s;
    s << quad->GetEid(0) << " " << quad->GetEid(1) << " " << quad->GetEid(2)
      << " " << quad->GetEid(3);
    TiXmlElement *q = new TiXmlElement(tag);
    q->SetAttribute("ID", quadID);
    q->LinkEndChild(new TiXmlText(s.str()));
    faceTag->LinkEndChild(q);
}

References Nektar::SpatialDomains::Geometry::GetEid().

Referenced by Nektar::SpatialDomains::MeshGraphIOXml::v_WriteQuads(), and Nektar::SpatialDomains::MeshGraphIOXmlCompressed::v_WriteQuads().

◆ WriteTet() [1/2]

void Nektar::SpatialDomains::WriteTet	(	TetGeom *	tet,
		std::vector< MeshTet > &	elementInfo,
		int	tetID
	)

Definition at line 1414 of file MeshGraphIOXmlCompressed.cpp.

{
    MeshTet e;
    e.id   = tetID;
    e.f[0] = tet->GetFid(0);
    e.f[1] = tet->GetFid(1);
    e.f[2] = tet->GetFid(2);
    e.f[3] = tet->GetFid(3);
    elementInfo.push_back(e);
}

References Nektar::SpatialDomains::MeshTet::f, Nektar::SpatialDomains::Geometry::GetFid(), and Nektar::SpatialDomains::MeshTet::id.

◆ WriteTet() [2/2]

void Nektar::SpatialDomains::WriteTet	(	TetGeom *	tet,
		TiXmlElement *	elmtTag,
		std::string &	tag,
		int	tetID
	)

Definition at line 2803 of file MeshGraphIOXml.cpp.

{
    std::stringstream s;
    s << tet->GetFid(0) << " " << tet->GetFid(1) << " " << tet->GetFid(2) << " "
      << tet->GetFid(3) << " ";
    TiXmlElement *t = new TiXmlElement(tag);
    t->SetAttribute("ID", tetID);
    t->LinkEndChild(new TiXmlText(s.str()));
    elmtTag->LinkEndChild(t);
}

References Nektar::SpatialDomains::Geometry::GetFid().

Referenced by Nektar::SpatialDomains::MeshGraphIOXml::v_WriteTets(), and Nektar::SpatialDomains::MeshGraphIOXmlCompressed::v_WriteTets().

◆ WriteTri() [1/2]

void Nektar::SpatialDomains::WriteTri	(	TriGeom *	tri,
		std::vector< MeshTri > &	triInfo,
		int	triID
	)

Definition at line 1150 of file MeshGraphIOXmlCompressed.cpp.

{
    MeshTri t;
    t.id   = triID;
    t.e[0] = tri->GetEid(0);
    t.e[1] = tri->GetEid(1);
    t.e[2] = tri->GetEid(2);
    triInfo.push_back(t);
}

References Nektar::SpatialDomains::MeshTri::e, Nektar::SpatialDomains::Geometry::GetEid(), and Nektar::SpatialDomains::MeshTri::id.

◆ WriteTri() [2/2]

void Nektar::SpatialDomains::WriteTri	(	TriGeom *	tri,
		TiXmlElement *	faceTag,
		std::string &	tag,
		int	triID
	)

Definition at line 2646 of file MeshGraphIOXml.cpp.

{
    std::stringstream s;
    s << tri->GetEid(0) << " " << tri->GetEid(1) << " " << tri->GetEid(2);
    TiXmlElement *t = new TiXmlElement(tag);
    t->SetAttribute("ID", triID);
    t->LinkEndChild(new TiXmlText(s.str()));
    faceTag->LinkEndChild(t);
}

References Nektar::SpatialDomains::Geometry::GetEid().

Referenced by Nektar::SpatialDomains::MeshGraphIOXml::v_WriteTris(), and Nektar::SpatialDomains::MeshGraphIOXmlCompressed::v_WriteTris().

◆ WriteVert() [1/2]

void Nektar::SpatialDomains::WriteVert	(	PointGeom *	vert,
		std::vector< MeshVertex > &	vertInfo,
		int	vertID
	)

Definition at line 1040 of file MeshGraphIOXmlCompressed.cpp.

{
    MeshVertex v;
    v.id = vertID;
    v.x  = vert->x();
    v.y  = vert->y();
    v.z  = vert->z();
    vertInfo.push_back(v);
}

References Nektar::SpatialDomains::MeshVertex::id, Nektar::NekPoint< data_type >::x(), Nektar::SpatialDomains::MeshVertex::x, Nektar::NekPoint< data_type >::y(), Nektar::SpatialDomains::MeshVertex::y, Nektar::NekPoint< data_type >::z(), and Nektar::SpatialDomains::MeshVertex::z.

◆ WriteVert() [2/2]

void Nektar::SpatialDomains::WriteVert	(	PointGeom *	vert,
		TiXmlElement *	vertTag
	)

Definition at line 2574 of file MeshGraphIOXml.cpp.

{
    std::stringstream s;
    s << std::scientific << std::setprecision(8) << (*vert)(0) << " "
      << (*vert)(1) << " " << (*vert)(2);
    TiXmlElement *v = new TiXmlElement("V");
    v->SetAttribute("ID", vert->GetGlobalID());
    v->LinkEndChild(new TiXmlText(s.str()));
    vertTag->LinkEndChild(v);
}

References Nektar::SpatialDomains::Geometry::GetGlobalID().

Referenced by Nektar::SpatialDomains::MeshGraphIOXml::v_WriteVertices(), and Nektar::SpatialDomains::MeshGraphIOXmlCompressed::v_WriteVertices().

Variable Documentation

◆ GeomMMFMap

const char* const Nektar::SpatialDomains::GeomMMFMap[]

Initial value:

= {
    "TangentX",        "TangentY",         "TangentXY",        "TangentZ",
    "TangentCircular", "TangentIrregular", "TangentNonconvex", "LOCAL",
}

Session file names associated with tangent principle directions.

Definition at line 87 of file SpatialDomains.hpp.

                                 {
    "TangentX",        "TangentY",         "TangentXY",        "TangentZ",
    "TangentCircular", "TangentIrregular", "TangentNonconvex", "LOCAL",
};

Referenced by Nektar::SolverUtils::MMFSystem::CheckMovingFrames(), and Nektar::SolverUtils::MMFSystem::v_GenerateSummary().

◆ kExpansionTypeStr

const std::string Nektar::SpatialDomains::kExpansionTypeStr[]

Initial value:

= {"NOTYPE",
                                         "MODIFIED",
                                         "MODIFIEDQUADPLUS1",
                                         "MODIFIEDQUADPLUS2",
                                         "MODIFIEDGLLRADAU10",
                                         "ORTHOGONAL",
                                         "GLL_LAGRANGE",
                                         "GLL_LAGRANGE_SEM",
                                         "GAUSS_LAGRANGE",
                                         "GAUSS_LAGRANGE_SEM",
                                         "FOURIER",
                                         "FOURIERSINGLEMODE",
                                         "FOURIERHALFMODERE",
                                         "FOURIERHALFMODEIM",
                                         "CHEBYSHEV",
                                         "FOURIER-CHEBYSHEV",
                                         "CHEBYSHEV-FOURIER",
                                         "FOURIER-MODIFIED"}

Definition at line 158 of file MeshGraph.h.

                                      {"NOTYPE",
                                         "MODIFIED",
                                         "MODIFIEDQUADPLUS1",
                                         "MODIFIEDQUADPLUS2",
                                         "MODIFIEDGLLRADAU10",
                                         "ORTHOGONAL",
                                         "GLL_LAGRANGE",
                                         "GLL_LAGRANGE_SEM",
                                         "GAUSS_LAGRANGE",
                                         "GAUSS_LAGRANGE_SEM",
                                         "FOURIER",
                                         "FOURIERSINGLEMODE",
                                         "FOURIERHALFMODERE",
                                         "FOURIERHALFMODEIM",
                                         "CHEBYSHEV",
                                         "FOURIER-CHEBYSHEV",
                                         "CHEBYSHEV-FOURIER",
                                         "FOURIER-MODIFIED"};

Referenced by Nektar::SpatialDomains::MeshGraph::ReadExpansionInfo().

◆ MovementTypeStr

const std::string Nektar::SpatialDomains::MovementTypeStr[]

Initial value:

= {"None", "Fixed", "Rotated",

"Translated"}

Map of zone movement type to movement type string.

Definition at line 57 of file Zones.h.

57 {"None", "Fixed", "Rotated",

58 "Translated"};

Referenced by export_Zones(), Nektar::SpatialDomains::Movement::Movement(), and Nektar::SpatialDomains::Movement::WriteMovement().

◆ NullBoundaryConditionShPtrArray

const Array<OneD, BoundaryConditionShPtr> Nektar::SpatialDomains::NullBoundaryConditionShPtrArray

static

Definition at line 261 of file Conditions.h.

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ BndRegionOrdering

◆ BoundaryConditionCollection

◆ BoundaryConditionMap

◆ BoundaryConditionMapShPtr

◆ BoundaryConditionShPtr

◆ BoundaryConditionsSharedPtr

◆ BoundaryRegion

◆ BoundaryRegionCollection

◆ BoundaryRegionShPtr

◆ CompositeDescriptor

◆ CompositeMap

◆ CompositeOrdering

◆ CompositeSharedPtr

◆ ConstBoundaryRegionShPtr

◆ CurveMap

◆ CurveUniquePtr

◆ DerivStorage

◆ DirichletBCShPtr

◆ ExpansionInfoMap

◆ ExpansionInfoMapShPtr

◆ ExpansionInfoMapShPtrMap

◆ ExpansionInfoShPtr

◆ Geometry2DUniquePtr

◆ Geometry3DUniquePtr

◆ GeometryLinkSharedPtr

◆ GeometryUniquePtr

◆ GeomFactorsSet

◆ GeomFactorsUniquePtr

◆ GeomFactorsVector

◆ GeomInfoMap

◆ GeomMap

◆ HexGeomUniquePtr

◆ InterfaceCollection

◆ InterfacePairShPtr

◆ InterfaceShPtr

◆ MeshGraphFactory

◆ MeshGraphIOFactory

◆ MeshGraphIOSharedPtr

◆ MeshGraphSharedPtr

◆ MeshMetaDataMap

◆ MeshPartitionFactory

◆ MeshPartitionSharedPtr

◆ MovementSharedPtr

◆ NeumannBCShPtr

◆ PointGeomUniquePtr

◆ PrismGeomUniquePtr

◆ PyrGeomUniquePtr

◆ QuadGeomUniquePtr

◆ RobinBCShPtr

◆ SegGeomUniquePtr

◆ TetGeomUniquePtr

◆ TriGeomUniquePtr

◆ ZoneBaseShPtr

◆ ZoneFixedShPtr

◆ ZoneRotateShPtr

◆ ZoneTranslateShPtr

Enumeration Type Documentation

◆ BoundaryConditionType

◆ ExpansionType

◆ GeomMMF

◆ GeomState

◆ GeomType

◆ MovementType

Function Documentation

◆ GetGeomData() [1/2]

◆ GetGeomData() [2/2]

◆ GetGeomDataDim()

◆ GetMeshGraphFactory()

◆ GetMeshGraphIOFactory()

◆ GetMeshPartitionFactory()

◆ GetStdHexFactory()

◆ GetStdPrismFactory()

◆ GetStdPyrFactory()

◆ GetStdQuadFactory()