Nektar::SpatialDomains::MeshGraph Class Reference

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

#include <MeshGraph.h>

Inheritance diagram for Nektar::SpatialDomains::MeshGraph:

Classes
struct	GeomRTree

Public Member Functions
	MeshGraph ()
virtual	~MeshGraph ()
void	WriteGeometry (const std::string &outfilename, bool defaultExp=false, const LibUtilities::FieldMetaDataMap &metadata=LibUtilities::NullFieldMetaDataMap)
void	Empty (int dim, int space)
void	FillGraph ()
void	FillBoundingBoxTree ()
std::vector< int >	GetElementsContainingPoint (PointGeomSharedPtr p)
void	ReadExpansionInfo ()
void	ReadRefinementInfo ()
	Read refinement info. More...
int	GetMeshDimension ()
	Dimension of the mesh (can be a 1D curve in 3D space). More...
int	GetSpaceDimension ()
	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...
CompositeSharedPtr	GetComposite (int whichComposite)
GeometrySharedPtr	GetCompositeItem (int whichComposite, int whichItem)
void	GetCompositeList (const std::string &compositeStr, CompositeMap &compositeVector) const
std::map< int, CompositeSharedPtr > &	GetComposites ()
std::map< int, std::string > &	GetCompositesLabels ()
std::map< int, std::map< int, CompositeSharedPtr > > &	GetDomain ()
std::map< int, CompositeSharedPtr > &	GetDomain (int domain)
const ExpansionInfoMap &	GetExpansionInfo (const std::string variable="DefaultVar")
ExpansionInfoShPtr	GetExpansionInfo (GeometrySharedPtr geom, const std::string variable="DefaultVar")
void	SetExpansionInfo (std::vector< LibUtilities::FieldDefinitionsSharedPtr > &fielddef)
	Sets expansions given field definitions. More...
void	SetExpansionInfo (std::vector< LibUtilities::FieldDefinitionsSharedPtr > &fielddef, std::vector< std::vector< LibUtilities::PointsType > > &pointstype)
	Sets expansions given field definition, quadrature points. More...
void	SetExpansionInfoToEvenlySpacedPoints (int npoints=0)
	Sets expansions to have equispaced points. More...
void	SetExpansionInfoToNumModes (int nmodes)
	Reset expansion to have specified polynomial order nmodes. More...
void	SetExpansionInfoToPointOrder (int npts)
	Reset expansion to have specified point order npts. More...
void	SetRefinementInfo (ExpansionInfoMapShPtr &expansionMap)
	This function sets the expansion #exp in map with entry #variable. More...
void	PRefinementElmts (ExpansionInfoMapShPtr &expansionMap, RefRegion *&region, GeometrySharedPtr geomVecIter)
	Perform the p-refinement in the selected elements. More...
void	SetExpansionInfo (const std::string variable, ExpansionInfoMapShPtr &exp)
void	SetSession (LibUtilities::SessionReaderSharedPtr pSession)
void	SetBasisKey (LibUtilities::ShapeType shape, LibUtilities::BasisKeyVector &keys, std::string var="DefaultVar")
	Sets the basis key for all expansions of the given shape. More...
void	ResetExpansionInfoToBasisKey (ExpansionInfoMapShPtr &expansionMap, LibUtilities::ShapeType shape, LibUtilities::BasisKeyVector &keys)
bool	SameExpansionInfo (const std::string var1, const std::string var2)
bool	ExpansionInfoDefined (const std::string var)
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 ()
PointGeomSharedPtr	GetVertex (int id)
SegGeomSharedPtr	GetSegGeom (int id)
CurveMap &	GetCurvedEdges ()
CurveMap &	GetCurvedFaces ()
std::map< int, PointGeomSharedPtr > &	GetAllPointGeoms ()
std::map< int, SegGeomSharedPtr > &	GetAllSegGeoms ()
TriGeomMap &	GetAllTriGeoms ()
QuadGeomMap &	GetAllQuadGeoms ()
TetGeomMap &	GetAllTetGeoms ()
PyrGeomMap &	GetAllPyrGeoms ()
PrismGeomMap &	GetAllPrismGeoms ()
HexGeomMap &	GetAllHexGeoms ()
std::unordered_map< int, GeometryLinkSharedPtr > &	GetAllFaceToElMap ()
int	GetNumElements ()
Geometry2DSharedPtr	GetGeometry2D (int gID)
GeometryLinkSharedPtr	GetElementsFromEdge (Geometry1DSharedPtr edge)
GeometryLinkSharedPtr	GetElementsFromFace (Geometry2DSharedPtr face)
void	SetPartition (SpatialDomains::MeshGraphSharedPtr graph)
CompositeOrdering &	GetCompositeOrdering ()
void	SetCompositeOrdering (CompositeOrdering p_compOrder)
BndRegionOrdering &	GetBndRegionOrdering ()
void	SetBndRegionOrdering (BndRegionOrdering p_bndRegOrder)
void	ReadGeometry (LibUtilities::DomainRangeShPtr rng, bool fillGraph)
void	PartitionMesh (LibUtilities::SessionReaderSharedPtr session)
std::map< int, MeshEntity >	CreateMeshEntities ()
	Create mesh entities for this graph. More...
CompositeDescriptor	CreateCompositeDescriptor ()
MovementSharedPtr &	GetMovement ()

Static Public Member Functions
static MeshGraphSharedPtr	Read (const LibUtilities::SessionReaderSharedPtr pSession, LibUtilities::DomainRangeShPtr rng=LibUtilities::NullDomainRangeShPtr, bool fillGraph=true, SpatialDomains::MeshGraphSharedPtr partitionedGraph=nullptr)
static LibUtilities::BasisKeyVector	DefineBasisKeyFromExpansionType (GeometrySharedPtr in, ExpansionType type, const int order)

Protected Member Functions
virtual void	v_WriteGeometry (const std::string &outfilename, bool defaultExp=false, const LibUtilities::FieldMetaDataMap &metadata=LibUtilities::NullFieldMetaDataMap)=0
virtual void	v_ReadGeometry (LibUtilities::DomainRangeShPtr rng, bool fillGraph)=0
virtual void	v_PartitionMesh (LibUtilities::SessionReaderSharedPtr session)=0
void	PopulateFaceToElMap (Geometry3DSharedPtr element, int kNfaces)
	Given a 3D geometry object #element, populate the face to element map m_faceToElMap which maps faces to their corresponding element(s). More...
ExpansionInfoMapShPtr	SetUpExpansionInfoMap ()
std::string	GetCompositeString (CompositeSharedPtr comp)
	Returns a string representation of a composite. More...

Protected Attributes
LibUtilities::SessionReaderSharedPtr	m_session
PointGeomMap	m_vertSet
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 = false
bool	m_useExpansionType
std::map< int, CompositeMap >	m_refComposite
	Link the refinement id with the composites. More...
std::map< int, RefRegion * >	m_refRegion
	Link the refinement id with the surface region data. More...
bool	m_refFlag = false
CompositeMap	m_meshComposites
std::map< int, std::string >	m_compositesLabels
std::map< int, CompositeMap >	m_domain
LibUtilities::DomainRangeShPtr	m_domainRange
ExpansionInfoMapShPtrMap	m_expansionMapShPtrMap
std::unordered_map< int, GeometryLinkSharedPtr >	m_faceToElMap
TiXmlElement *	m_xmlGeom
CompositeOrdering	m_compOrder
BndRegionOrdering	m_bndRegOrder
std::unique_ptr< GeomRTree >	m_boundingBoxTree
MovementSharedPtr	m_movement

Detailed Description

Base class for a spectral/hp element mesh.

Definition at line 180 of file MeshGraph.h.

Constructor & Destructor Documentation

MeshGraph()

Nektar::SpatialDomains::MeshGraph::MeshGraph

(

)

Definition at line 101 of file MeshGraph.cpp.

{
    m_boundingBoxTree =
        std::unique_ptr<MeshGraph::GeomRTree>(new MeshGraph::GeomRTree());
    m_movement = std::make_shared<Movement>();
}

References m_boundingBoxTree, and m_movement.

~MeshGraph()

Nektar::SpatialDomains::MeshGraph::~MeshGraph ( )

virtual

Definition at line 111 of file MeshGraph.cpp.

{
}

Member Function Documentation

CheckForGeomInfo()

bool Nektar::SpatialDomains::MeshGraph::CheckForGeomInfo ( std::string  parameter )

inline

CheckRange() [1/2]

bool Nektar::SpatialDomains::MeshGraph::CheckRange

(

Geometry2D &

geom

)

Check if goemetry is in range definition if activated.

Definition at line 353 of file MeshGraph.cpp.

{
    bool returnval = true;
 
    if (m_domainRange != LibUtilities::NullDomainRangeShPtr)
    {
        int nverts  = geom.GetNumVerts();
        int coordim = geom.GetCoordim();
 
        // exclude elements outside x range if all vertices not in region
        if (m_domainRange->m_doXrange)
        {
            int ncnt_low = 0;
            int ncnt_up  = 0;
            for (int i = 0; i < nverts; ++i)
            {
                NekDouble xval = (*geom.GetVertex(i))[0];
                if (xval < m_domainRange->m_xmin)
                {
                    ncnt_low++;
                }
 
                if (xval > m_domainRange->m_xmax)
                {
                    ncnt_up++;
                }
            }
 
            // check for all verts to be less or greater than
            // range so that if element spans thin range then
            // it is still included
            if ((ncnt_up == nverts) || (ncnt_low == nverts))
            {
                returnval = false;
            }
        }
 
        // exclude elements outside y range if all vertices not in region
        if (m_domainRange->m_doYrange)
        {
            int ncnt_low = 0;
            int ncnt_up  = 0;
            for (int i = 0; i < nverts; ++i)
            {
                NekDouble yval = (*geom.GetVertex(i))[1];
                if (yval < m_domainRange->m_ymin)
                {
                    ncnt_low++;
                }
 
                if (yval > m_domainRange->m_ymax)
                {
                    ncnt_up++;
                }
            }
 
            // check for all verts to be less or greater than
            // range so that if element spans thin range then
            // it is still included
            if ((ncnt_up == nverts) || (ncnt_low == nverts))
            {
                returnval = false;
            }
        }
 
        if (coordim > 2)
        {
            // exclude elements outside z range if all vertices not in region
            if (m_domainRange->m_doZrange)
            {
                int ncnt_low = 0;
                int ncnt_up  = 0;
 
                for (int i = 0; i < nverts; ++i)
                {
                    NekDouble zval = (*geom.GetVertex(i))[2];
 
                    if (zval < m_domainRange->m_zmin)
                    {
                        ncnt_low++;
                    }
 
                    if (zval > m_domainRange->m_zmax)
                    {
                        ncnt_up++;
                    }
                }
 
                // check for all verts to be less or greater than
                // range so that if element spans thin range then
                // it is still included
                if ((ncnt_up == nverts) || (ncnt_low == nverts))
                {
                    returnval = false;
                }
            }
        }
    }
    return returnval;
}

References Nektar::SpatialDomains::Geometry::GetCoordim(), Nektar::SpatialDomains::Geometry::GetNumVerts(), Nektar::SpatialDomains::Geometry::GetVertex(), m_domainRange, and Nektar::LibUtilities::NullDomainRangeShPtr.

Referenced by Nektar::SpatialDomains::MeshGraphHDF5::ReadComposites(), Nektar::SpatialDomains::MeshGraphXml::ResolveGeomRef2D(), and Nektar::SpatialDomains::MeshGraphXml::ResolveGeomRef3D().

CheckRange() [2/2]

bool Nektar::SpatialDomains::MeshGraph::CheckRange

(

Geometry3D &

geom

)

Check if goemetry is in range definition if activated.

Definition at line 455 of file MeshGraph.cpp.

{
    bool returnval = true;
 
    if (m_domainRange != LibUtilities::NullDomainRangeShPtr)
    {
        int nverts = geom.GetNumVerts();
 
        if (m_domainRange->m_doXrange)
        {
            int ncnt_low = 0;
            int ncnt_up  = 0;
 
            for (int i = 0; i < nverts; ++i)
            {
                NekDouble xval = (*geom.GetVertex(i))[0];
                if (xval < m_domainRange->m_xmin)
                {
                    ncnt_low++;
                }
 
                if (xval > m_domainRange->m_xmax)
                {
                    ncnt_up++;
                }
            }
 
            // check for all verts to be less or greater than
            // range so that if element spans thin range then
            // it is still included
            if ((ncnt_up == nverts) || (ncnt_low == nverts))
            {
                returnval = false;
            }
        }
 
        if (m_domainRange->m_doYrange)
        {
            int ncnt_low = 0;
            int ncnt_up  = 0;
            for (int i = 0; i < nverts; ++i)
            {
                NekDouble yval = (*geom.GetVertex(i))[1];
                if (yval < m_domainRange->m_ymin)
                {
                    ncnt_low++;
                }
 
                if (yval > m_domainRange->m_ymax)
                {
                    ncnt_up++;
                }
            }
 
            // check for all verts to be less or greater than
            // range so that if element spans thin range then
            // it is still included
            if ((ncnt_up == nverts) || (ncnt_low == nverts))
            {
                returnval = false;
            }
        }
 
        if (m_domainRange->m_doZrange)
        {
            int ncnt_low = 0;
            int ncnt_up  = 0;
            for (int i = 0; i < nverts; ++i)
            {
                NekDouble zval = (*geom.GetVertex(i))[2];
 
                if (zval < m_domainRange->m_zmin)
                {
                    ncnt_low++;
                }
 
                if (zval > m_domainRange->m_zmax)
                {
                    ncnt_up++;
                }
            }
 
            // check for all verts to be less or greater than
            // range so that if element spans thin range then
            // it is still included
            if ((ncnt_up == nverts) || (ncnt_low == nverts))
            {
                returnval = false;
            }
        }
 
        if (m_domainRange->m_checkShape)
        {
            if (geom.GetShapeType() != m_domainRange->m_shapeType)
            {
                returnval = false;
            }
        }
    }
 
    return returnval;
}

References Nektar::SpatialDomains::Geometry::GetNumVerts(), Nektar::SpatialDomains::Geometry::GetShapeType(), Nektar::SpatialDomains::Geometry::GetVertex(), m_domainRange, and Nektar::LibUtilities::NullDomainRangeShPtr.

CreateCompositeDescriptor()

CompositeDescriptor Nektar::SpatialDomains::MeshGraph::CreateCompositeDescriptor

(

)

Definition at line 4108 of file MeshGraph.cpp.

{
    CompositeDescriptor ret;
 
    for (auto &comp : m_meshComposites)
    {
        std::pair<LibUtilities::ShapeType, vector<int>> tmp;
        tmp.first = comp.second->m_geomVec[0]->GetShapeType();
 
        tmp.second.resize(comp.second->m_geomVec.size());
        for (size_t i = 0; i < tmp.second.size(); ++i)
        {
            tmp.second[i] = comp.second->m_geomVec[i]->GetGlobalID();
        }
 
        ret[comp.first] = tmp;
    }
 
    return ret;
}

References m_meshComposites.

Referenced by Nektar::SpatialDomains::MeshGraphHDF5::v_PartitionMesh(), and Nektar::SpatialDomains::MeshGraphXml::v_PartitionMesh().

CreateMeshEntities()

std::map< int, MeshEntity > Nektar::SpatialDomains::MeshGraph::CreateMeshEntities

(

)

Create mesh entities for this graph.

This function will create a map of all mesh entities of the current graph, which can then be used within the mesh partitioner to construct an appropriate partitioning.

Definition at line 4008 of file MeshGraph.cpp.

{
    std::map<int, MeshEntity> elements;
    switch (m_meshDimension)
    {
        case 1:
        {
            for (auto &i : m_segGeoms)
            {
                MeshEntity e;
                e.id = e.origId = i.first;
                e.list.push_back(i.second->GetVertex(0)->GetGlobalID());
                e.list.push_back(i.second->GetVertex(1)->GetGlobalID());
                e.ghost        = false;
                elements[e.id] = e;
            }
        }
        break;
        case 2:
        {
            for (auto &i : m_triGeoms)
            {
                MeshEntity e;
                e.id = e.origId = i.first;
                e.list.push_back(i.second->GetEdge(0)->GetGlobalID());
                e.list.push_back(i.second->GetEdge(1)->GetGlobalID());
                e.list.push_back(i.second->GetEdge(2)->GetGlobalID());
                e.ghost        = false;
                elements[e.id] = e;
            }
            for (auto &i : m_quadGeoms)
            {
                MeshEntity e;
                e.id = e.origId = i.first;
                e.list.push_back(i.second->GetEdge(0)->GetGlobalID());
                e.list.push_back(i.second->GetEdge(1)->GetGlobalID());
                e.list.push_back(i.second->GetEdge(2)->GetGlobalID());
                e.list.push_back(i.second->GetEdge(3)->GetGlobalID());
                e.ghost        = false;
                elements[e.id] = e;
            }
        }
        break;
        case 3:
        {
            for (auto &i : m_tetGeoms)
            {
                MeshEntity e;
                e.id = e.origId = i.first;
                e.list.push_back(i.second->GetFace(0)->GetGlobalID());
                e.list.push_back(i.second->GetFace(1)->GetGlobalID());
                e.list.push_back(i.second->GetFace(2)->GetGlobalID());
                e.list.push_back(i.second->GetFace(3)->GetGlobalID());
                e.ghost        = false;
                elements[e.id] = e;
            }
            for (auto &i : m_pyrGeoms)
            {
                MeshEntity e;
                e.id = e.origId = i.first;
                e.list.push_back(i.second->GetFace(0)->GetGlobalID());
                e.list.push_back(i.second->GetFace(1)->GetGlobalID());
                e.list.push_back(i.second->GetFace(2)->GetGlobalID());
                e.list.push_back(i.second->GetFace(3)->GetGlobalID());
                e.list.push_back(i.second->GetFace(4)->GetGlobalID());
                e.ghost        = false;
                elements[e.id] = e;
            }
            for (auto &i : m_prismGeoms)
            {
                MeshEntity e;
                e.id = e.origId = i.first;
                e.list.push_back(i.second->GetFace(0)->GetGlobalID());
                e.list.push_back(i.second->GetFace(1)->GetGlobalID());
                e.list.push_back(i.second->GetFace(2)->GetGlobalID());
                e.list.push_back(i.second->GetFace(3)->GetGlobalID());
                e.list.push_back(i.second->GetFace(4)->GetGlobalID());
                e.ghost        = false;
                elements[e.id] = e;
            }
            for (auto &i : m_hexGeoms)
            {
                MeshEntity e;
                e.id = e.origId = i.first;
                e.list.push_back(i.second->GetFace(0)->GetGlobalID());
                e.list.push_back(i.second->GetFace(1)->GetGlobalID());
                e.list.push_back(i.second->GetFace(2)->GetGlobalID());
                e.list.push_back(i.second->GetFace(3)->GetGlobalID());
                e.list.push_back(i.second->GetFace(4)->GetGlobalID());
                e.list.push_back(i.second->GetFace(5)->GetGlobalID());
                e.ghost        = false;
                elements[e.id] = e;
            }
        }
        break;
    }
 
    return elements;
}

References Nektar::SpatialDomains::MeshEntity::ghost, Nektar::SpatialDomains::MeshEntity::id, Nektar::SpatialDomains::MeshEntity::list, m_hexGeoms, m_meshDimension, m_prismGeoms, m_pyrGeoms, m_quadGeoms, m_segGeoms, m_tetGeoms, m_triGeoms, and Nektar::SpatialDomains::MeshEntity::origId.

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

DefineBasisKeyFromExpansionType()

LibUtilities::BasisKeyVector Nektar::SpatialDomains::MeshGraph::DefineBasisKeyFromExpansionType ( GeometrySharedPtr  in, ExpansionType  type, const int  order  )

static

Definition at line 1632 of file MeshGraph.cpp.

{
    LibUtilities::BasisKeyVector returnval;
 
    LibUtilities::ShapeType shape = in->GetShapeType();
 
    int quadoffset = 1;
    switch (type)
    {
        case eModified:
        case eModifiedGLLRadau10:
            quadoffset = 1;
            break;
        case eModifiedQuadPlus1:
            quadoffset = 2;
            break;
        case eModifiedQuadPlus2:
            quadoffset = 3;
            break;
        default:
            break;
    }
 
    switch (type)
    {
        case eModified:
        case eModifiedQuadPlus1:
        case eModifiedQuadPlus2:
        case eModifiedGLLRadau10:
        {
            switch (shape)
            {
                case LibUtilities::eSegment:
                {
                    const LibUtilities::PointsKey pkey(
                        nummodes + quadoffset,
                        LibUtilities::eGaussLobattoLegendre);
                    LibUtilities::BasisKey bkey(LibUtilities::eModified_A,
                                                nummodes, pkey);
                    returnval.push_back(bkey);
                }
                break;
                case LibUtilities::eQuadrilateral:
                {
                    const LibUtilities::PointsKey pkey(
                        nummodes + quadoffset,
                        LibUtilities::eGaussLobattoLegendre);
                    LibUtilities::BasisKey bkey(LibUtilities::eModified_A,
                                                nummodes, pkey);
                    returnval.push_back(bkey);
                    returnval.push_back(bkey);
                }
                break;
                case LibUtilities::eHexahedron:
                {
                    const LibUtilities::PointsKey pkey(
                        nummodes + quadoffset,
                        LibUtilities::eGaussLobattoLegendre);
                    LibUtilities::BasisKey bkey(LibUtilities::eModified_A,
                                                nummodes, pkey);
                    returnval.push_back(bkey);
                    returnval.push_back(bkey);
                    returnval.push_back(bkey);
                }
                break;
                case LibUtilities::eTriangle:
                {
                    const LibUtilities::PointsKey pkey(
                        nummodes + quadoffset,
                        LibUtilities::eGaussLobattoLegendre);
                    LibUtilities::BasisKey bkey(LibUtilities::eModified_A,
                                                nummodes, pkey);
                    returnval.push_back(bkey);
 
                    const LibUtilities::PointsKey pkey1(
                        nummodes + quadoffset - 1,
                        LibUtilities::eGaussRadauMAlpha1Beta0);
                    LibUtilities::BasisKey bkey1(LibUtilities::eModified_B,
                                                 nummodes, pkey1);
 
                    returnval.push_back(bkey1);
                }
                break;
                case LibUtilities::eTetrahedron:
                {
                    const LibUtilities::PointsKey pkey(
                        nummodes + quadoffset,
                        LibUtilities::eGaussLobattoLegendre);
                    LibUtilities::BasisKey bkey(LibUtilities::eModified_A,
                                                nummodes, pkey);
                    returnval.push_back(bkey);
 
                    const LibUtilities::PointsKey pkey1(
                        nummodes + quadoffset - 1,
                        LibUtilities::eGaussRadauMAlpha1Beta0);
                    LibUtilities::BasisKey bkey1(LibUtilities::eModified_B,
                                                 nummodes, pkey1);
                    returnval.push_back(bkey1);
 
                    if (type == eModifiedGLLRadau10)
                    {
                        const LibUtilities::PointsKey pkey2(
                            nummodes + quadoffset - 1,
                            LibUtilities::eGaussRadauMAlpha1Beta0);
                        LibUtilities::BasisKey bkey2(LibUtilities::eModified_C,
                                                     nummodes, pkey2);
                        returnval.push_back(bkey2);
                    }
                    else
                    {
                        const LibUtilities::PointsKey pkey2(
                            nummodes + quadoffset - 1,
                            LibUtilities::eGaussRadauMAlpha2Beta0);
                        LibUtilities::BasisKey bkey2(LibUtilities::eModified_C,
                                                     nummodes, pkey2);
                        returnval.push_back(bkey2);
                    }
                }
                break;
                case LibUtilities::ePyramid:
                {
                    const LibUtilities::PointsKey pkey(
                        nummodes + quadoffset,
                        LibUtilities::eGaussLobattoLegendre);
                    LibUtilities::BasisKey bkey(LibUtilities::eModified_A,
                                                nummodes, pkey);
                    returnval.push_back(bkey);
                    returnval.push_back(bkey);
 
                    const LibUtilities::PointsKey pkey1(
                        nummodes + quadoffset,
                        LibUtilities::eGaussRadauMAlpha2Beta0);
                    LibUtilities::BasisKey bkey1(LibUtilities::eModifiedPyr_C,
                                                 nummodes, pkey1);
                    returnval.push_back(bkey1);
                }
                break;
                case LibUtilities::ePrism:
                {
                    const LibUtilities::PointsKey pkey(
                        nummodes + quadoffset,
                        LibUtilities::eGaussLobattoLegendre);
                    LibUtilities::BasisKey bkey(LibUtilities::eModified_A,
                                                nummodes, pkey);
                    returnval.push_back(bkey);
                    returnval.push_back(bkey);
 
                    const LibUtilities::PointsKey pkey1(
                        nummodes + quadoffset - 1,
                        LibUtilities::eGaussRadauMAlpha1Beta0);
                    LibUtilities::BasisKey bkey1(LibUtilities::eModified_B,
                                                 nummodes, pkey1);
                    returnval.push_back(bkey1);
                }
                break;
                default:
                {
                    ASSERTL0(false,
                             "Expansion not defined in switch for this shape");
                }
                break;
            }
        }
        break;
 
        case eGLL_Lagrange:
        {
            switch (shape)
            {
                case LibUtilities::eSegment:
                {
                    const LibUtilities::PointsKey pkey(
                        nummodes + 1, LibUtilities::eGaussLobattoLegendre);
                    LibUtilities::BasisKey bkey(LibUtilities::eGLL_Lagrange,
                                                nummodes, pkey);
                    returnval.push_back(bkey);
                }
                break;
                case LibUtilities::eQuadrilateral:
                {
                    const LibUtilities::PointsKey pkey(
                        nummodes + 1, LibUtilities::eGaussLobattoLegendre);
                    LibUtilities::BasisKey bkey(LibUtilities::eGLL_Lagrange,
                                                nummodes, pkey);
                    returnval.push_back(bkey);
                    returnval.push_back(bkey);
                }
                break;
                case LibUtilities::eTriangle: // define with corrects points key
                    // and change to Ortho on construction
                    {
                        const LibUtilities::PointsKey pkey(
                            nummodes + 1, LibUtilities::eGaussLobattoLegendre);
                        LibUtilities::BasisKey bkey(LibUtilities::eGLL_Lagrange,
                                                    nummodes, pkey);
                        returnval.push_back(bkey);
 
                        const LibUtilities::PointsKey pkey1(
                            nummodes, LibUtilities::eGaussRadauMAlpha1Beta0);
                        LibUtilities::BasisKey bkey1(LibUtilities::eOrtho_B,
                                                     nummodes, pkey1);
                        returnval.push_back(bkey1);
                    }
                    break;
                case LibUtilities::eHexahedron:
                {
                    const LibUtilities::PointsKey pkey(
                        nummodes + 1, LibUtilities::eGaussLobattoLegendre);
                    LibUtilities::BasisKey bkey(LibUtilities::eGLL_Lagrange,
                                                nummodes, pkey);
 
                    returnval.push_back(bkey);
                    returnval.push_back(bkey);
                    returnval.push_back(bkey);
                }
                break;
                default:
                {
                    ASSERTL0(false,
                             "Expansion not defined in switch  for this shape");
                }
                break;
            }
        }
        break;
 
        case eGauss_Lagrange:
        {
            switch (shape)
            {
                case LibUtilities::eSegment:
                {
                    const LibUtilities::PointsKey pkey(
                        nummodes, LibUtilities::eGaussGaussLegendre);
                    LibUtilities::BasisKey bkey(LibUtilities::eGauss_Lagrange,
                                                nummodes, pkey);
 
                    returnval.push_back(bkey);
                }
                break;
                case LibUtilities::eQuadrilateral:
                {
                    const LibUtilities::PointsKey pkey(
                        nummodes, LibUtilities::eGaussGaussLegendre);
                    LibUtilities::BasisKey bkey(LibUtilities::eGauss_Lagrange,
                                                nummodes, pkey);
 
                    returnval.push_back(bkey);
                    returnval.push_back(bkey);
                }
                break;
                case LibUtilities::eHexahedron:
                {
                    const LibUtilities::PointsKey pkey(
                        nummodes, LibUtilities::eGaussGaussLegendre);
                    LibUtilities::BasisKey bkey(LibUtilities::eGauss_Lagrange,
                                                nummodes, pkey);
 
                    returnval.push_back(bkey);
                    returnval.push_back(bkey);
                    returnval.push_back(bkey);
                }
                break;
                default:
                {
                    ASSERTL0(false,
                             "Expansion not defined in switch  for this shape");
                }
                break;
            }
        }
        break;
 
        case eOrthogonal:
        {
            switch (shape)
            {
                case LibUtilities::eSegment:
                {
                    const LibUtilities::PointsKey pkey(
                        nummodes + 1, LibUtilities::eGaussLobattoLegendre);
                    LibUtilities::BasisKey bkey(LibUtilities::eOrtho_A,
                                                nummodes, pkey);
 
                    returnval.push_back(bkey);
                }
                break;
                case LibUtilities::eTriangle:
                {
                    const LibUtilities::PointsKey pkey(
                        nummodes + 1, LibUtilities::eGaussLobattoLegendre);
                    LibUtilities::BasisKey bkey(LibUtilities::eOrtho_A,
                                                nummodes, pkey);
 
                    returnval.push_back(bkey);
 
                    const LibUtilities::PointsKey pkey1(
                        nummodes, LibUtilities::eGaussRadauMAlpha1Beta0);
                    LibUtilities::BasisKey bkey1(LibUtilities::eOrtho_B,
                                                 nummodes, pkey1);
 
                    returnval.push_back(bkey1);
                }
                break;
                case LibUtilities::eQuadrilateral:
                {
                    const LibUtilities::PointsKey pkey(
                        nummodes + 1, LibUtilities::eGaussLobattoLegendre);
                    LibUtilities::BasisKey bkey(LibUtilities::eOrtho_A,
                                                nummodes, pkey);
 
                    returnval.push_back(bkey);
                    returnval.push_back(bkey);
                }
                break;
                case LibUtilities::eTetrahedron:
                {
                    const LibUtilities::PointsKey pkey(
                        nummodes + 1, LibUtilities::eGaussLobattoLegendre);
                    LibUtilities::BasisKey bkey(LibUtilities::eOrtho_A,
                                                nummodes, pkey);
 
                    returnval.push_back(bkey);
 
                    const LibUtilities::PointsKey pkey1(
                        nummodes, LibUtilities::eGaussRadauMAlpha1Beta0);
                    LibUtilities::BasisKey bkey1(LibUtilities::eOrtho_B,
                                                 nummodes, pkey1);
 
                    returnval.push_back(bkey1);
 
                    const LibUtilities::PointsKey pkey2(
                        nummodes, LibUtilities::eGaussRadauMAlpha2Beta0);
                    LibUtilities::BasisKey bkey2(LibUtilities::eOrtho_C,
                                                 nummodes, pkey2);
                }
                break;
                default:
                {
                    ASSERTL0(false,
                             "Expansion not defined in switch  for this shape");
                }
                break;
            }
        }
        break;
 
        case eGLL_Lagrange_SEM:
        {
            switch (shape)
            {
                case LibUtilities::eSegment:
                {
                    const LibUtilities::PointsKey pkey(
                        nummodes, LibUtilities::eGaussLobattoLegendre);
                    LibUtilities::BasisKey bkey(LibUtilities::eGLL_Lagrange,
                                                nummodes, pkey);
 
                    returnval.push_back(bkey);
                }
                break;
                case LibUtilities::eQuadrilateral:
                {
                    const LibUtilities::PointsKey pkey(
                        nummodes, LibUtilities::eGaussLobattoLegendre);
                    LibUtilities::BasisKey bkey(LibUtilities::eGLL_Lagrange,
                                                nummodes, pkey);
 
                    returnval.push_back(bkey);
                    returnval.push_back(bkey);
                }
                break;
                case LibUtilities::eHexahedron:
                {
                    const LibUtilities::PointsKey pkey(
                        nummodes, LibUtilities::eGaussLobattoLegendre);
                    LibUtilities::BasisKey bkey(LibUtilities::eGLL_Lagrange,
                                                nummodes, pkey);
 
                    returnval.push_back(bkey);
                    returnval.push_back(bkey);
                    returnval.push_back(bkey);
                }
                break;
                default:
                {
                    ASSERTL0(false,
                             "Expansion not defined in switch  for this shape");
                }
                break;
            }
        }
        break;
 
        case eFourier:
        {
            switch (shape)
            {
                case LibUtilities::eSegment:
                {
                    const LibUtilities::PointsKey pkey(
                        nummodes, LibUtilities::eFourierEvenlySpaced);
                    LibUtilities::BasisKey bkey(LibUtilities::eFourier,
                                                nummodes, pkey);
                    returnval.push_back(bkey);
                }
                break;
                case LibUtilities::eQuadrilateral:
                {
                    const LibUtilities::PointsKey pkey(
                        nummodes, LibUtilities::eFourierEvenlySpaced);
                    LibUtilities::BasisKey bkey(LibUtilities::eFourier,
                                                nummodes, pkey);
                    returnval.push_back(bkey);
                    returnval.push_back(bkey);
                }
                break;
                case LibUtilities::eHexahedron:
                {
                    const LibUtilities::PointsKey pkey(
                        nummodes, LibUtilities::eFourierEvenlySpaced);
                    LibUtilities::BasisKey bkey(LibUtilities::eFourier,
                                                nummodes, pkey);
                    returnval.push_back(bkey);
                    returnval.push_back(bkey);
                    returnval.push_back(bkey);
                }
                break;
                default:
                {
                    ASSERTL0(false,
                             "Expansion not defined in switch  for this shape");
                }
                break;
            }
        }
        break;
 
        case eFourierSingleMode:
        {
            switch (shape)
            {
                case LibUtilities::eSegment:
                {
                    const LibUtilities::PointsKey pkey(
                        nummodes, LibUtilities::eFourierSingleModeSpaced);
                    LibUtilities::BasisKey bkey(
                        LibUtilities::eFourierSingleMode, nummodes, pkey);
                    returnval.push_back(bkey);
                }
                break;
                case LibUtilities::eQuadrilateral:
                {
                    const LibUtilities::PointsKey pkey(
                        nummodes, LibUtilities::eFourierSingleModeSpaced);
                    LibUtilities::BasisKey bkey(
                        LibUtilities::eFourierSingleMode, nummodes, pkey);
                    returnval.push_back(bkey);
                    returnval.push_back(bkey);
                }
                break;
                case LibUtilities::eHexahedron:
                {
                    const LibUtilities::PointsKey pkey(
                        nummodes, LibUtilities::eFourierSingleModeSpaced);
                    LibUtilities::BasisKey bkey(
                        LibUtilities::eFourierSingleMode, nummodes, pkey);
                    returnval.push_back(bkey);
                    returnval.push_back(bkey);
                    returnval.push_back(bkey);
                }
                break;
                default:
                {
                    ASSERTL0(false,
                             "Expansion not defined in switch  for this shape");
                }
                break;
            }
        }
        break;
 
        case eFourierHalfModeRe:
        {
            switch (shape)
            {
                case LibUtilities::eSegment:
                {
                    const LibUtilities::PointsKey pkey(
                        nummodes, LibUtilities::eFourierSingleModeSpaced);
                    LibUtilities::BasisKey bkey(
                        LibUtilities::eFourierHalfModeRe, nummodes, pkey);
                    returnval.push_back(bkey);
                }
                break;
                case LibUtilities::eQuadrilateral:
                {
                    const LibUtilities::PointsKey pkey(
                        nummodes, LibUtilities::eFourierSingleModeSpaced);
                    LibUtilities::BasisKey bkey(
                        LibUtilities::eFourierHalfModeRe, nummodes, pkey);
                    returnval.push_back(bkey);
                    returnval.push_back(bkey);
                }
                break;
                case LibUtilities::eHexahedron:
                {
                    const LibUtilities::PointsKey pkey(
                        nummodes, LibUtilities::eFourierSingleModeSpaced);
                    LibUtilities::BasisKey bkey(
                        LibUtilities::eFourierHalfModeRe, nummodes, pkey);
                    returnval.push_back(bkey);
                    returnval.push_back(bkey);
                    returnval.push_back(bkey);
                }
                break;
                default:
                {
                    ASSERTL0(false,
                             "Expansion not defined in switch  for this shape");
                }
                break;
            }
        }
        break;
 
        case eFourierHalfModeIm:
        {
            switch (shape)
            {
                case LibUtilities::eSegment:
                {
                    const LibUtilities::PointsKey pkey(
                        nummodes, LibUtilities::eFourierSingleModeSpaced);
                    LibUtilities::BasisKey bkey(
                        LibUtilities::eFourierHalfModeIm, nummodes, pkey);
                    returnval.push_back(bkey);
                }
                break;
                case LibUtilities::eQuadrilateral:
                {
                    const LibUtilities::PointsKey pkey(
                        nummodes, LibUtilities::eFourierSingleModeSpaced);
                    LibUtilities::BasisKey bkey(
                        LibUtilities::eFourierHalfModeIm, nummodes, pkey);
                    returnval.push_back(bkey);
                    returnval.push_back(bkey);
                }
                break;
                case LibUtilities::eHexahedron:
                {
                    const LibUtilities::PointsKey pkey(
                        nummodes, LibUtilities::eFourierSingleModeSpaced);
                    LibUtilities::BasisKey bkey(
                        LibUtilities::eFourierHalfModeIm, nummodes, pkey);
                    returnval.push_back(bkey);
                    returnval.push_back(bkey);
                    returnval.push_back(bkey);
                }
                break;
                default:
                {
                    ASSERTL0(false,
                             "Expansion not defined in switch  for this shape");
                }
                break;
            }
        }
        break;
 
        case eChebyshev:
        {
            switch (shape)
            {
                case LibUtilities::eSegment:
                {
                    const LibUtilities::PointsKey pkey(
                        nummodes, LibUtilities::eGaussGaussChebyshev);
                    LibUtilities::BasisKey bkey(LibUtilities::eChebyshev,
                                                nummodes, pkey);
                    returnval.push_back(bkey);
                }
                break;
                case LibUtilities::eQuadrilateral:
                {
                    const LibUtilities::PointsKey pkey(
                        nummodes, LibUtilities::eGaussGaussChebyshev);
                    LibUtilities::BasisKey bkey(LibUtilities::eChebyshev,
                                                nummodes, pkey);
                    returnval.push_back(bkey);
                    returnval.push_back(bkey);
                }
                break;
                case LibUtilities::eHexahedron:
                {
                    const LibUtilities::PointsKey pkey(
                        nummodes, LibUtilities::eGaussGaussChebyshev);
                    LibUtilities::BasisKey bkey(LibUtilities::eChebyshev,
                                                nummodes, pkey);
                    returnval.push_back(bkey);
                    returnval.push_back(bkey);
                    returnval.push_back(bkey);
                }
                break;
                default:
                {
                    ASSERTL0(false,
                             "Expansion not defined in switch  for this shape");
                }
                break;
            }
        }
        break;
 
        case eFourierChebyshev:
        {
            switch (shape)
            {
                case LibUtilities::eQuadrilateral:
                {
                    const LibUtilities::PointsKey pkey(
                        nummodes, LibUtilities::eFourierEvenlySpaced);
                    LibUtilities::BasisKey bkey(LibUtilities::eFourier,
                                                nummodes, pkey);
                    returnval.push_back(bkey);
 
                    const LibUtilities::PointsKey pkey1(
                        nummodes, LibUtilities::eGaussGaussChebyshev);
                    LibUtilities::BasisKey bkey1(LibUtilities::eChebyshev,
                                                 nummodes, pkey1);
                    returnval.push_back(bkey1);
                }
                break;
                default:
                {
                    ASSERTL0(false,
                             "Expansion not defined in switch  for this shape");
                }
                break;
            }
        }
        break;
 
        case eChebyshevFourier:
        {
            switch (shape)
            {
                case LibUtilities::eQuadrilateral:
                {
                    const LibUtilities::PointsKey pkey1(
                        nummodes, LibUtilities::eGaussGaussChebyshev);
                    LibUtilities::BasisKey bkey1(LibUtilities::eChebyshev,
                                                 nummodes, pkey1);
                    returnval.push_back(bkey1);
 
                    const LibUtilities::PointsKey pkey(
                        nummodes, LibUtilities::eFourierEvenlySpaced);
                    LibUtilities::BasisKey bkey(LibUtilities::eFourier,
                                                nummodes, pkey);
                    returnval.push_back(bkey);
                }
                break;
                default:
                {
                    ASSERTL0(false,
                             "Expansion not defined in switch  for this shape");
                }
                break;
            }
        }
        break;
 
        case eFourierModified:
        {
            switch (shape)
            {
                case LibUtilities::eQuadrilateral:
                {
                    const LibUtilities::PointsKey pkey(
                        nummodes, LibUtilities::eFourierEvenlySpaced);
                    LibUtilities::BasisKey bkey(LibUtilities::eFourier,
                                                nummodes, pkey);
                    returnval.push_back(bkey);
 
                    const LibUtilities::PointsKey pkey1(
                        nummodes + 1, LibUtilities::eGaussLobattoLegendre);
                    LibUtilities::BasisKey bkey1(LibUtilities::eModified_A,
                                                 nummodes, pkey1);
                    returnval.push_back(bkey1);
                }
                break;
                default:
                {
                    ASSERTL0(false,
                             "Expansion not defined in switch  for this shape");
                }
                break;
            }
        }
        break;
 
        default:
        {
            ASSERTL0(false, "Expansion type not defined");
        }
        break;
    }
 
    return returnval;
}

References ASSERTL0, Nektar::LibUtilities::eChebyshev, Nektar::SpatialDomains::eChebyshev, Nektar::SpatialDomains::eChebyshevFourier, Nektar::LibUtilities::eFourier, Nektar::SpatialDomains::eFourier, Nektar::SpatialDomains::eFourierChebyshev, Nektar::LibUtilities::eFourierEvenlySpaced, Nektar::LibUtilities::eFourierHalfModeIm, Nektar::SpatialDomains::eFourierHalfModeIm, Nektar::LibUtilities::eFourierHalfModeRe, Nektar::SpatialDomains::eFourierHalfModeRe, Nektar::SpatialDomains::eFourierModified, Nektar::LibUtilities::eFourierSingleMode, Nektar::SpatialDomains::eFourierSingleMode, Nektar::LibUtilities::eFourierSingleModeSpaced, Nektar::LibUtilities::eGauss_Lagrange, Nektar::SpatialDomains::eGauss_Lagrange, Nektar::LibUtilities::eGaussGaussChebyshev, Nektar::LibUtilities::eGaussGaussLegendre, Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eGLL_Lagrange, Nektar::SpatialDomains::eGLL_Lagrange, Nektar::SpatialDomains::eGLL_Lagrange_SEM, Nektar::LibUtilities::eHexahedron, Nektar::SpatialDomains::eModified, Nektar::LibUtilities::eModified_A, Nektar::LibUtilities::eModified_B, Nektar::LibUtilities::eModified_C, Nektar::SpatialDomains::eModifiedGLLRadau10, Nektar::LibUtilities::eModifiedPyr_C, Nektar::SpatialDomains::eModifiedQuadPlus1, Nektar::SpatialDomains::eModifiedQuadPlus2, Nektar::LibUtilities::eOrtho_A, Nektar::LibUtilities::eOrtho_B, Nektar::LibUtilities::eOrtho_C, Nektar::SpatialDomains::eOrthogonal, Nektar::LibUtilities::ePrism, Nektar::LibUtilities::ePyramid, Nektar::LibUtilities::eQuadrilateral, Nektar::LibUtilities::eSegment, Nektar::LibUtilities::eTetrahedron, and Nektar::LibUtilities::eTriangle.

Referenced by PRefinementElmts(), and ReadExpansionInfo().

DefineBasisKeyFromExpansionTypeHomo()

LibUtilities::BasisKeyVector Nektar::SpatialDomains::MeshGraph::DefineBasisKeyFromExpansionTypeHomo	(	GeometrySharedPtr	in,
		ExpansionType	type_x,
		ExpansionType	type_y,
		ExpansionType	type_z,
		const int	nummodes_x,
		const int	nummodes_y,
		const int	nummodes_z
	)

Definition at line 2347 of file MeshGraph.cpp.

{
    LibUtilities::BasisKeyVector returnval;
 
    LibUtilities::ShapeType shape = in->GetShapeType();
 
    switch (shape)
    {
        case LibUtilities::eSegment:
        {
            ASSERTL0(false, "Homogeneous expansion not defined for this shape");
        }
        break;
 
        case LibUtilities::eQuadrilateral:
        {
            ASSERTL0(false, "Homogeneous expansion not defined for this shape");
        }
        break;
 
        case LibUtilities::eHexahedron:
        {
            switch (type_x)
            {
                case eFourier:
                {
                    const LibUtilities::PointsKey pkey1(
                        nummodes_x, LibUtilities::eFourierEvenlySpaced);
                    LibUtilities::BasisKey bkey1(LibUtilities::eFourier,
                                                 nummodes_x, pkey1);
                    returnval.push_back(bkey1);
                }
                break;
 
                case eFourierSingleMode:
                {
                    const LibUtilities::PointsKey pkey1(
                        nummodes_x, LibUtilities::eFourierSingleModeSpaced);
                    LibUtilities::BasisKey bkey1(
                        LibUtilities::eFourierSingleMode, nummodes_x, pkey1);
                    returnval.push_back(bkey1);
                }
                break;
 
                case eFourierHalfModeRe:
                {
                    const LibUtilities::PointsKey pkey1(
                        nummodes_x, LibUtilities::eFourierSingleModeSpaced);
                    LibUtilities::BasisKey bkey1(
                        LibUtilities::eFourierHalfModeRe, nummodes_x, pkey1);
                    returnval.push_back(bkey1);
                }
                break;
 
                case eFourierHalfModeIm:
                {
                    const LibUtilities::PointsKey pkey1(
                        nummodes_x, LibUtilities::eFourierSingleModeSpaced);
                    LibUtilities::BasisKey bkey1(
                        LibUtilities::eFourierHalfModeIm, nummodes_x, pkey1);
                    returnval.push_back(bkey1);
                }
                break;
 
                case eChebyshev:
                {
                    const LibUtilities::PointsKey pkey1(
                        nummodes_x, LibUtilities::eGaussGaussChebyshev);
                    LibUtilities::BasisKey bkey1(LibUtilities::eChebyshev,
                                                 nummodes_x, pkey1);
                    returnval.push_back(bkey1);
                }
                break;
 
                default:
                {
                    ASSERTL0(false, "Homogeneous expansion can be of Fourier "
                                    "or Chebyshev type only");
                }
                break;
            }
 
            switch (type_y)
            {
                case eFourier:
                {
                    const LibUtilities::PointsKey pkey2(
                        nummodes_y, LibUtilities::eFourierEvenlySpaced);
                    LibUtilities::BasisKey bkey2(LibUtilities::eFourier,
                                                 nummodes_y, pkey2);
                    returnval.push_back(bkey2);
                }
                break;
 
                case eFourierSingleMode:
                {
                    const LibUtilities::PointsKey pkey2(
                        nummodes_y, LibUtilities::eFourierSingleModeSpaced);
                    LibUtilities::BasisKey bkey2(
                        LibUtilities::eFourierSingleMode, nummodes_y, pkey2);
                    returnval.push_back(bkey2);
                }
                break;
 
                case eFourierHalfModeRe:
                {
                    const LibUtilities::PointsKey pkey2(
                        nummodes_y, LibUtilities::eFourierSingleModeSpaced);
                    LibUtilities::BasisKey bkey2(
                        LibUtilities::eFourierHalfModeRe, nummodes_y, pkey2);
                    returnval.push_back(bkey2);
                }
                break;
 
                case eFourierHalfModeIm:
                {
                    const LibUtilities::PointsKey pkey2(
                        nummodes_y, LibUtilities::eFourierSingleModeSpaced);
                    LibUtilities::BasisKey bkey2(
                        LibUtilities::eFourierHalfModeIm, nummodes_y, pkey2);
                    returnval.push_back(bkey2);
                }
                break;
 
                case eChebyshev:
                {
                    const LibUtilities::PointsKey pkey2(
                        nummodes_y, LibUtilities::eGaussGaussChebyshev);
                    LibUtilities::BasisKey bkey2(LibUtilities::eChebyshev,
                                                 nummodes_y, pkey2);
                    returnval.push_back(bkey2);
                }
                break;
 
                default:
                {
                    ASSERTL0(false, "Homogeneous expansion can be of Fourier "
                                    "or Chebyshev type only");
                }
                break;
            }
 
            switch (type_z)
            {
                case eFourier:
                {
                    const LibUtilities::PointsKey pkey3(
                        nummodes_z, LibUtilities::eFourierEvenlySpaced);
                    LibUtilities::BasisKey bkey3(LibUtilities::eFourier,
                                                 nummodes_z, pkey3);
                    returnval.push_back(bkey3);
                }
                break;
 
                case eFourierSingleMode:
                {
                    const LibUtilities::PointsKey pkey3(
                        nummodes_z, LibUtilities::eFourierSingleModeSpaced);
                    LibUtilities::BasisKey bkey3(
                        LibUtilities::eFourierSingleMode, nummodes_z, pkey3);
                    returnval.push_back(bkey3);
                }
                break;
 
                case eFourierHalfModeRe:
                {
                    const LibUtilities::PointsKey pkey3(
                        nummodes_z, LibUtilities::eFourierSingleModeSpaced);
                    LibUtilities::BasisKey bkey3(
                        LibUtilities::eFourierHalfModeRe, nummodes_z, pkey3);
                    returnval.push_back(bkey3);
                }
                break;
 
                case eFourierHalfModeIm:
                {
                    const LibUtilities::PointsKey pkey3(
                        nummodes_z, LibUtilities::eFourierSingleModeSpaced);
                    LibUtilities::BasisKey bkey3(
                        LibUtilities::eFourierHalfModeIm, nummodes_z, pkey3);
                    returnval.push_back(bkey3);
                }
                break;
 
                case eChebyshev:
                {
                    const LibUtilities::PointsKey pkey3(
                        nummodes_z, LibUtilities::eGaussGaussChebyshev);
                    LibUtilities::BasisKey bkey3(LibUtilities::eChebyshev,
                                                 nummodes_z, pkey3);
                    returnval.push_back(bkey3);
                }
                break;
 
                default:
                {
                    ASSERTL0(false, "Homogeneous expansion can be of Fourier "
                                    "or Chebyshev type only");
                }
                break;
            }
        }
        break;
 
        case LibUtilities::eTriangle:
        {
            ASSERTL0(false, "Homogeneous expansion not defined for this shape");
        }
        break;
 
        case LibUtilities::eTetrahedron:
        {
            ASSERTL0(false, "Homogeneous expansion not defined for this shape");
        }
        break;
 
        default:
            ASSERTL0(false, "Expansion not defined in switch  for this shape");
            break;
    }
 
    return returnval;
}

References ASSERTL0, Nektar::LibUtilities::eChebyshev, Nektar::SpatialDomains::eChebyshev, Nektar::LibUtilities::eFourier, Nektar::SpatialDomains::eFourier, Nektar::LibUtilities::eFourierEvenlySpaced, Nektar::LibUtilities::eFourierHalfModeIm, Nektar::SpatialDomains::eFourierHalfModeIm, Nektar::LibUtilities::eFourierHalfModeRe, Nektar::SpatialDomains::eFourierHalfModeRe, Nektar::LibUtilities::eFourierSingleMode, Nektar::SpatialDomains::eFourierSingleMode, Nektar::LibUtilities::eFourierSingleModeSpaced, Nektar::LibUtilities::eGaussGaussChebyshev, Nektar::LibUtilities::eHexahedron, Nektar::LibUtilities::eQuadrilateral, Nektar::LibUtilities::eSegment, Nektar::LibUtilities::eTetrahedron, and Nektar::LibUtilities::eTriangle.

Referenced by ReadExpansionInfo().

Empty()

void Nektar::SpatialDomains::MeshGraph::Empty ( int  dim, int  space  )

inline

Definition at line 197 of file MeshGraph.h.

    {
        m_meshDimension  = dim;
        m_spaceDimension = space;
    }

References m_meshDimension, and m_spaceDimension.

ExpansionInfoDefined()

bool Nektar::SpatialDomains::MeshGraph::ExpansionInfoDefined ( const std::string  var )

inline

Definition at line 609 of file MeshGraph.h.

{
    return m_expansionMapShPtrMap.count(var);
}

References m_expansionMapShPtrMap.

FillBoundingBoxTree()

void Nektar::SpatialDomains::MeshGraph::FillBoundingBoxTree

(

)

Definition at line 254 of file MeshGraph.cpp.

{
 
    m_boundingBoxTree->m_bgTree.clear();
    switch (m_meshDimension)
    {
        case 1:
            for (auto &x : m_segGeoms)
            {
                m_boundingBoxTree->InsertGeom(x.second);
            }
            break;
        case 2:
            for (auto &x : m_triGeoms)
            {
                m_boundingBoxTree->InsertGeom(x.second);
            }
            for (auto &x : m_quadGeoms)
            {
                m_boundingBoxTree->InsertGeom(x.second);
            }
            break;
        case 3:
            for (auto &x : m_tetGeoms)
            {
                m_boundingBoxTree->InsertGeom(x.second);
            }
            for (auto &x : m_prismGeoms)
            {
                m_boundingBoxTree->InsertGeom(x.second);
            }
            for (auto &x : m_pyrGeoms)
            {
                m_boundingBoxTree->InsertGeom(x.second);
            }
            for (auto &x : m_hexGeoms)
            {
                m_boundingBoxTree->InsertGeom(x.second);
            }
            break;
        default:
            ASSERTL0(false, "Unknown dim");
    }
}

References ASSERTL0, m_boundingBoxTree, m_hexGeoms, m_meshDimension, m_prismGeoms, m_pyrGeoms, m_quadGeoms, m_segGeoms, m_tetGeoms, and m_triGeoms.

Referenced by GetElementsContainingPoint().

FillGraph()

void Nektar::SpatialDomains::MeshGraph::FillGraph

(

)

Definition at line 201 of file MeshGraph.cpp.

{
    ReadExpansionInfo();
 
    switch (m_meshDimension)
    {
        case 3:
        {
            for (auto &x : m_pyrGeoms)
            {
                x.second->Setup();
            }
            for (auto &x : m_prismGeoms)
            {
                x.second->Setup();
            }
            for (auto &x : m_tetGeoms)
            {
                x.second->Setup();
            }
            for (auto &x : m_hexGeoms)
            {
                x.second->Setup();
            }
        }
        break;
        case 2:
        {
            for (auto &x : m_triGeoms)
            {
                x.second->Setup();
            }
            for (auto &x : m_quadGeoms)
            {
                x.second->Setup();
            }
        }
        break;
        case 1:
        {
            for (auto &x : m_segGeoms)
            {
                x.second->Setup();
            }
        }
        break;
    }
 
    // Populate the movement object
    m_movement = MemoryManager<SpatialDomains::Movement>::AllocateSharedPtr(
        m_session, this);
}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), m_hexGeoms, m_meshDimension, m_movement, m_prismGeoms, m_pyrGeoms, m_quadGeoms, m_segGeoms, m_session, m_tetGeoms, m_triGeoms, and ReadExpansionInfo().

Referenced by Nektar::SpatialDomains::MeshGraphHDF5::v_ReadGeometry(), and Nektar::SpatialDomains::MeshGraphXml::v_ReadGeometry().

GetAllFaceToElMap()

std::unordered_map< int, GeometryLinkSharedPtr > & Nektar::SpatialDomains::MeshGraph::GetAllFaceToElMap ( )

inline

Definition at line 409 of file MeshGraph.h.

    {
        return m_faceToElMap;
    }

References m_faceToElMap.

GetAllHexGeoms()

HexGeomMap & Nektar::SpatialDomains::MeshGraph::GetAllHexGeoms ( )

inline

Definition at line 404 of file MeshGraph.h.

    {
        return m_hexGeoms;
    }

References m_hexGeoms.

GetAllPointGeoms()

std::map< int, PointGeomSharedPtr > & Nektar::SpatialDomains::MeshGraph::GetAllPointGeoms ( )

inline

Definition at line 376 of file MeshGraph.h.

    {
        return m_vertSet;
    }

References m_vertSet.

GetAllPrismGeoms()

PrismGeomMap & Nektar::SpatialDomains::MeshGraph::GetAllPrismGeoms ( )

inline

Definition at line 400 of file MeshGraph.h.

    {
        return m_prismGeoms;
    }

References m_prismGeoms.

GetAllPyrGeoms()

PyrGeomMap & Nektar::SpatialDomains::MeshGraph::GetAllPyrGeoms ( )

inline

Definition at line 396 of file MeshGraph.h.

    {
        return m_pyrGeoms;
    }

References m_pyrGeoms.

GetAllQuadGeoms()

QuadGeomMap & Nektar::SpatialDomains::MeshGraph::GetAllQuadGeoms ( )

inline

Definition at line 388 of file MeshGraph.h.

    {
        return m_quadGeoms;
    }

References m_quadGeoms.

GetAllSegGeoms()

std::map< int, SegGeomSharedPtr > & Nektar::SpatialDomains::MeshGraph::GetAllSegGeoms ( )

inline

Definition at line 380 of file MeshGraph.h.

    {
        return m_segGeoms;
    }

References m_segGeoms.

GetAllTetGeoms()

TetGeomMap & Nektar::SpatialDomains::MeshGraph::GetAllTetGeoms ( )

inline

Definition at line 392 of file MeshGraph.h.

    {
        return m_tetGeoms;
    }

References m_tetGeoms.

GetAllTriGeoms()

TriGeomMap & Nektar::SpatialDomains::MeshGraph::GetAllTriGeoms ( )

inline

Definition at line 384 of file MeshGraph.h.

    {
        return m_triGeoms;
    }

References m_triGeoms.

GetBndRegionOrdering()

BndRegionOrdering & Nektar::SpatialDomains::MeshGraph::GetBndRegionOrdering ( )

inline

Definition at line 451 of file MeshGraph.h.

    {
        return m_bndRegOrder;
    }

References m_bndRegOrder.

GetComposite()

CompositeSharedPtr Nektar::SpatialDomains::MeshGraph::GetComposite ( int  whichComposite )

inline

Definition at line 245 of file MeshGraph.h.

    {
        ASSERTL0(m_meshComposites.find(whichComposite) !=
                     m_meshComposites.end(),
                 "Composite not found.");
        return m_meshComposites.find(whichComposite)->second;
    }

References ASSERTL0, and m_meshComposites.

GetCompositeItem()

GeometrySharedPtr Nektar::SpatialDomains::MeshGraph::GetCompositeItem	(	int	whichComposite,
		int	whichItem
	)

Definition at line 561 of file MeshGraph.cpp.

{
    GeometrySharedPtr returnval;
    bool error = false;
 
    if (whichComposite >= 0 && whichComposite < int(m_meshComposites.size()))
    {
        if (whichItem >= 0 &&
            whichItem < int(m_meshComposites[whichComposite]->m_geomVec.size()))
        {
            returnval = m_meshComposites[whichComposite]->m_geomVec[whichItem];
        }
        else
        {
            error = true;
        }
    }
    else
    {
        error = true;
    }
 
    if (error)
    {
        std::ostringstream errStream;
        errStream << "Unable to access composite item [" << whichComposite
                  << "][" << whichItem << "].";
 
        std::string testStr = errStream.str();
 
        NEKERROR(ErrorUtil::efatal, testStr.c_str());
    }
 
    return returnval;
}

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

GetCompositeList()

void Nektar::SpatialDomains::MeshGraph::GetCompositeList	(	const std::string &	compositeStr,
		CompositeMap &	compositeVector
	)		const

Definition at line 600 of file MeshGraph.cpp.

{
    // Parse the composites into a list.
    vector<unsigned int> seqVector;
    bool parseGood =
        ParseUtils::GenerateSeqVector(compositeStr.c_str(), seqVector);
 
    ASSERTL0(
        parseGood && !seqVector.empty(),
        (std::string("Unable to read composite index range: ") + compositeStr)
            .c_str());
 
    vector<unsigned int> addedVector; // Vector of those composites already
                                      // added to compositeVector;
    for (auto iter = seqVector.begin(); iter != seqVector.end(); ++iter)
    {
        // Only add a new one if it does not already exist in vector.
        // Can't go back and delete with a vector, so prevent it from
        // being added in the first place.
        if (std::find(addedVector.begin(), addedVector.end(), *iter) ==
            addedVector.end())
        {
 
            // If the composite listed is not found and we are working
            // on a partitioned mesh, silently ignore it.
            if (m_meshComposites.find(*iter) == m_meshComposites.end() &&
                m_meshPartitioned)
            {
                continue;
            }
 
            addedVector.push_back(*iter);
            ASSERTL0(m_meshComposites.find(*iter) != m_meshComposites.end(),
                     "Composite not found.");
            CompositeSharedPtr composite = m_meshComposites.find(*iter)->second;
 
            if (composite)
            {
                compositeVector[*iter] = composite;
            }
            else
            {
                NEKERROR(ErrorUtil::ewarning,
                         ("Undefined composite: " + std::to_string(*iter)));
            }
        }
    }
}

References ASSERTL0, Nektar::ErrorUtil::ewarning, Nektar::StdRegions::find(), Nektar::ParseUtils::GenerateSeqVector(), m_meshComposites, m_meshPartitioned, and NEKERROR.

Referenced by Nektar::SpatialDomains::MeshGraphHDF5::ReadDomain(), Nektar::SpatialDomains::MeshGraphXml::ReadDomain(), ReadExpansionInfo(), and Nektar::SpatialDomains::Movement::ReadInterfaces().

GetCompositeOrdering()

CompositeOrdering & Nektar::SpatialDomains::MeshGraph::GetCompositeOrdering ( )

inline

Definition at line 441 of file MeshGraph.h.

    {
        return m_compOrder;
    }

References m_compOrder.

GetComposites()

std::map< int, CompositeSharedPtr > & Nektar::SpatialDomains::MeshGraph::GetComposites ( )

inline

Definition at line 259 of file MeshGraph.h.

    {
        return m_meshComposites;
    }

References m_meshComposites.

GetCompositesLabels()

std::map< int, std::string > & Nektar::SpatialDomains::MeshGraph::GetCompositesLabels ( )

inline

Definition at line 264 of file MeshGraph.h.

    {
        return m_compositesLabels;
    }

References m_compositesLabels.

GetCompositeString()

std::string Nektar::SpatialDomains::MeshGraph::GetCompositeString ( CompositeSharedPtr  comp )

protected

Returns a string representation of a composite.

Definition at line 2625 of file MeshGraph.cpp.

{
    if (comp->m_geomVec.size() == 0)
    {
        return "";
    }
 
    // Create a map that gets around the issue of mapping faces -> F and edges
    // -> E inside the tag.
    map<LibUtilities::ShapeType, pair<string, string>> compMap;
    compMap[LibUtilities::ePoint]         = make_pair("V", "V");
    compMap[LibUtilities::eSegment]       = make_pair("S", "E");
    compMap[LibUtilities::eQuadrilateral] = make_pair("Q", "F");
    compMap[LibUtilities::eTriangle]      = make_pair("T", "F");
    compMap[LibUtilities::eTetrahedron]   = make_pair("A", "A");
    compMap[LibUtilities::ePyramid]       = make_pair("P", "P");
    compMap[LibUtilities::ePrism]         = make_pair("R", "R");
    compMap[LibUtilities::eHexahedron]    = make_pair("H", "H");
 
    stringstream s;
 
    GeometrySharedPtr firstGeom = comp->m_geomVec[0];
    int shapeDim                = firstGeom->GetShapeDim();
    string tag                  = (shapeDim < m_meshDimension)
                                      ? compMap[firstGeom->GetShapeType()].second
                                      : compMap[firstGeom->GetShapeType()].first;
 
    std::vector<unsigned int> idxList;
    std::transform(comp->m_geomVec.begin(), comp->m_geomVec.end(),
                   std::back_inserter(idxList),
                   [](GeometrySharedPtr geom) { return geom->GetGlobalID(); });
 
    s << " " << tag << "[" << ParseUtils::GenerateSeqString(idxList) << "] ";
    return s.str();
}

References Nektar::LibUtilities::eHexahedron, Nektar::LibUtilities::ePoint, Nektar::LibUtilities::ePrism, Nektar::LibUtilities::ePyramid, Nektar::LibUtilities::eQuadrilateral, Nektar::LibUtilities::eSegment, Nektar::LibUtilities::eTetrahedron, Nektar::LibUtilities::eTriangle, Nektar::ParseUtils::GenerateSeqString(), and m_meshDimension.

Referenced by Nektar::SpatialDomains::MeshGraphHDF5::WriteComposites(), and Nektar::SpatialDomains::MeshGraphXml::WriteComposites().

GetCurvedEdges()

CurveMap & Nektar::SpatialDomains::MeshGraph::GetCurvedEdges ( )

inline

Definition at line 367 of file MeshGraph.h.

    {
        return m_curvedEdges;
    }

References m_curvedEdges.

GetCurvedFaces()

CurveMap & Nektar::SpatialDomains::MeshGraph::GetCurvedFaces ( )

inline

Definition at line 371 of file MeshGraph.h.

    {
        return m_curvedFaces;
    }

References m_curvedFaces.

GetDomain() [1/2]

std::map< int, std::map< int, CompositeSharedPtr > > & Nektar::SpatialDomains::MeshGraph::GetDomain ( )

inline

Definition at line 269 of file MeshGraph.h.

    {
        return m_domain;
    }

References m_domain.

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

GetDomain() [2/2]

std::map< int, CompositeSharedPtr > & Nektar::SpatialDomains::MeshGraph::GetDomain ( int  domain )

inline

Definition at line 274 of file MeshGraph.h.

    {
        ASSERTL1(m_domain.count(domain),
                 "Request for domain which does not exist");
        return m_domain[domain];
    }

References ASSERTL1, and m_domain.

GetElementsContainingPoint()

std::vector< int > Nektar::SpatialDomains::MeshGraph::GetElementsContainingPoint

(

PointGeomSharedPtr

p

)

Definition at line 299 of file MeshGraph.cpp.

{
    if (m_boundingBoxTree->m_bgTree.empty())
    {
        FillBoundingBoxTree();
    }
 
    NekDouble x = 0.0;
    NekDouble y = 0.0;
    NekDouble z = 0.0;
    std::vector<GeomRTree::BgRtreeValue> matches;
 
    p->GetCoords(x, y, z);
 
    GeomRTree::BgBox b(GeomRTree::BgPoint(x, y, z),
                       GeomRTree::BgPoint(x, y, z));
 
    m_boundingBoxTree->m_bgTree.query(bg::index::intersects(b),
                                      std::back_inserter(matches));
 
    std::vector<int> vals(matches.size());
 
    for (int i = 0; i < matches.size(); ++i)
    {
        vals[i] = matches[i].second;
    }
 
    return vals;
}

References FillBoundingBoxTree(), m_boundingBoxTree, CellMLToNektar.cellml_metadata::p, and Nektar::UnitTests::z().

GetElementsFromEdge()

GeometryLinkSharedPtr Nektar::SpatialDomains::MeshGraph::GetElementsFromEdge

(

Geometry1DSharedPtr

edge

)

Definition at line 3904 of file MeshGraph.cpp.

{
    // Search tris and quads
    // Need to iterate through vectors because there may be multiple
    // occurrences.
 
    GeometryLinkSharedPtr ret =
        GeometryLinkSharedPtr(new vector<pair<GeometrySharedPtr, int>>);
 
    TriGeomSharedPtr triGeomShPtr;
    QuadGeomSharedPtr quadGeomShPtr;
 
    for (auto &d : m_domain)
    {
        for (auto &compIter : d.second)
        {
            for (auto &geomIter : compIter.second->m_geomVec)
            {
                triGeomShPtr  = std::dynamic_pointer_cast<TriGeom>(geomIter);
                quadGeomShPtr = std::dynamic_pointer_cast<QuadGeom>(geomIter);
 
                if (triGeomShPtr || quadGeomShPtr)
                {
                    if (triGeomShPtr)
                    {
                        for (int i = 0; i < triGeomShPtr->GetNumEdges(); i++)
                        {
                            if (triGeomShPtr->GetEdge(i)->GetGlobalID() ==
                                edge->GetGlobalID())
                            {
                                ret->push_back(make_pair(triGeomShPtr, i));
                                break;
                            }
                        }
                    }
                    else if (quadGeomShPtr)
                    {
                        for (int i = 0; i < quadGeomShPtr->GetNumEdges(); i++)
                        {
                            if (quadGeomShPtr->GetEdge(i)->GetGlobalID() ==
                                edge->GetGlobalID())
                            {
                                ret->push_back(make_pair(quadGeomShPtr, i));
                                break;
                            }
                        }
                    }
                }
            }
        }
    }
 
    return ret;
}

References Nektar::UnitTests::d(), and m_domain.

GetElementsFromFace()

GeometryLinkSharedPtr Nektar::SpatialDomains::MeshGraph::GetElementsFromFace

(

Geometry2DSharedPtr

face

)

Definition at line 3959 of file MeshGraph.cpp.

{
    auto it = m_faceToElMap.find(face->GetGlobalID());
 
    ASSERTL0(it != m_faceToElMap.end(), "Unable to find corresponding face!");
 
    return it->second;
}

References ASSERTL0, and m_faceToElMap.

GetExpansionInfo() [1/2]

const ExpansionInfoMap & Nektar::SpatialDomains::MeshGraph::GetExpansionInfo

(

const std::string

variable = "DefaultVar"

)

Definition at line 653 of file MeshGraph.cpp.

{
    ExpansionInfoMapShPtr returnval;
 
    if (m_expansionMapShPtrMap.count(variable))
    {
        returnval = m_expansionMapShPtrMap.find(variable)->second;
    }
    else
    {
        if (m_expansionMapShPtrMap.count("DefaultVar") == 0)
        {
            NEKERROR(
                ErrorUtil::efatal,
                (std::string(
                     "Unable to find expansion vector definition for field: ") +
                 variable)
                    .c_str());
        }
        returnval = m_expansionMapShPtrMap.find("DefaultVar")->second;
        m_expansionMapShPtrMap[variable] = returnval;
 
        NEKERROR(
            ErrorUtil::ewarning,
            (std::string(
                 "Using Default variable expansion definition for field: ") +
             variable)
                .c_str());
    }
 
    return *returnval;
}

References Nektar::ErrorUtil::efatal, Nektar::ErrorUtil::ewarning, m_expansionMapShPtrMap, and NEKERROR.

GetExpansionInfo() [2/2]

ExpansionInfoShPtr Nektar::SpatialDomains::MeshGraph::GetExpansionInfo	(	GeometrySharedPtr	geom,
		const std::string	variable = "DefaultVar"
	)

Definition at line 689 of file MeshGraph.cpp.

{
    ExpansionInfoMapShPtr expansionMap =
        m_expansionMapShPtrMap.find(variable)->second;
 
    auto iter = expansionMap->find(geom->GetGlobalID());
    ASSERTL1(iter != expansionMap->end(),
             "Could not find expansion " +
                 boost::lexical_cast<string>(geom->GetGlobalID()) +
                 " in expansion for variable " + variable);
    return iter->second;
}

References ASSERTL1, and m_expansionMapShPtrMap.

GetGeometry2D()

Geometry2DSharedPtr Nektar::SpatialDomains::MeshGraph::GetGeometry2D ( int  gID )

inline

Definition at line 416 of file MeshGraph.h.

    {
        auto it1 = m_triGeoms.find(gID);
        if (it1 != m_triGeoms.end())
        {
            return it1->second;
        }
 
        auto it2 = m_quadGeoms.find(gID);
        if (it2 != m_quadGeoms.end())
        {
            return it2->second;
        }
 
        return Geometry2DSharedPtr();
    };

References m_quadGeoms, and m_triGeoms.

Referenced by Nektar::SpatialDomains::MeshGraphHDF5::ConstructGeomObject(), Nektar::SpatialDomains::MeshGraphXml::ResolveGeomRef3D(), Nektar::SpatialDomains::MeshGraphXml::v_ReadElements3D(), and Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadElements3D().

GetGeomInfo()

const std::string Nektar::SpatialDomains::MeshGraph::GetGeomInfo ( std::string  parameter )

inline

GetMeshDimension()

int Nektar::SpatialDomains::MeshGraph::GetMeshDimension ( )

inline

Dimension of the mesh (can be a 1D curve in 3D space).

Definition at line 219 of file MeshGraph.h.

    {
        return m_meshDimension;
    }

References m_meshDimension.

GetMovement()

MovementSharedPtr & Nektar::SpatialDomains::MeshGraph::GetMovement ( )

inline

Definition at line 470 of file MeshGraph.h.

    {
        return m_movement;
    }

References m_movement.

GetNumElements()

int Nektar::SpatialDomains::MeshGraph::GetNumElements

(

)

Definition at line 329 of file MeshGraph.cpp.

{
    switch (m_meshDimension)
    {
        case 1:
        {
            return m_segGeoms.size();
        }
        break;
        case 2:
        {
            return m_triGeoms.size() + m_quadGeoms.size();
        }
        break;
        case 3:
        {
            return m_tetGeoms.size() + m_pyrGeoms.size() + m_prismGeoms.size() +
                   m_hexGeoms.size();
        }
    }
 
    return 0;
}

References m_hexGeoms, m_meshDimension, m_prismGeoms, m_pyrGeoms, m_quadGeoms, m_segGeoms, m_tetGeoms, and m_triGeoms.

GetNvertices()

int Nektar::SpatialDomains::MeshGraph::GetNvertices ( )

inline

Definition at line 352 of file MeshGraph.h.

    {
        return m_vertSet.size();
    }

References m_vertSet.

GetSegGeom()

SegGeomSharedPtr Nektar::SpatialDomains::MeshGraph::GetSegGeom ( int  id )

inline

Definition at line 362 of file MeshGraph.h.

    {
        return m_segGeoms[id];
    }

References m_segGeoms.

Referenced by Nektar::SpatialDomains::MeshGraphHDF5::ConstructGeomObject(), Nektar::SpatialDomains::MeshGraphXml::v_ReadElements2D(), Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadElements2D(), Nektar::SpatialDomains::MeshGraphXml::v_ReadFaces(), and Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadFaces().

GetSpaceDimension()

int Nektar::SpatialDomains::MeshGraph::GetSpaceDimension ( )

inline

Dimension of the space (can be a 1D curve in 3D space).

Definition at line 225 of file MeshGraph.h.

    {
        return m_spaceDimension;
    }

References m_spaceDimension.

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

GetVertex()

PointGeomSharedPtr Nektar::SpatialDomains::MeshGraph::GetVertex ( int  id )

inline

Definition at line 357 of file MeshGraph.h.

    {
        return m_vertSet[id];
    }

References m_vertSet.

Referenced by Nektar::SpatialDomains::MeshGraphHDF5::ConstructGeomObject(), Nektar::SpatialDomains::MeshGraphXml::v_ReadEdges(), Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadEdges(), Nektar::SpatialDomains::MeshGraphXml::v_ReadElements1D(), and Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadElements1D().

PartitionMesh()

void Nektar::SpatialDomains::MeshGraph::PartitionMesh ( LibUtilities::SessionReaderSharedPtr  session )

inline

Definition at line 563 of file MeshGraph.h.

{
    v_PartitionMesh(session);
}

References v_PartitionMesh().

PopulateFaceToElMap()

void Nektar::SpatialDomains::MeshGraph::PopulateFaceToElMap ( Geometry3DSharedPtr  element, int  kNfaces  )

protected

Given a 3D geometry object #element, populate the face to element map m_faceToElMap which maps faces to their corresponding element(s).

Parameters

element	Element to process.
kNfaces	Number of faces of #element. Should be removed and put into Geometry3D as a virtual member function.

Definition at line 3977 of file MeshGraph.cpp.

{
    // Set up face -> element map
    for (int i = 0; i < kNfaces; ++i)
    {
        int faceId = element->GetFace(i)->GetGlobalID();
 
        // Search map to see if face already exists.
        auto it = m_faceToElMap.find(faceId);
 
        if (it == m_faceToElMap.end())
        {
            GeometryLinkSharedPtr tmp =
                GeometryLinkSharedPtr(new vector<pair<GeometrySharedPtr, int>>);
            tmp->push_back(make_pair(element, i));
            m_faceToElMap[faceId] = tmp;
        }
        else
        {
            it->second->push_back(make_pair(element, i));
        }
    }
}

References m_faceToElMap.

Referenced by Nektar::SpatialDomains::MeshGraphHDF5::ConstructGeomObject(), Nektar::SpatialDomains::MeshGraphXml::v_ReadElements3D(), and Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadElements3D().

PRefinementElmts()

void Nektar::SpatialDomains::MeshGraph::PRefinementElmts	(	ExpansionInfoMapShPtr &	expansionMap,
		RefRegion *&	region,
		GeometrySharedPtr	geomVecIter
	)

Perform the p-refinement in the selected elements.

Refine the elements which has at least one vertex inside the surface region.

Parameters

expansionMap	shared pointer for the ExpansionInfoMap.
region	Object which holds the information provided by the user. For example, the radius, coordinates, etc.
geomVecIter	shared pointer for the Geometry.

Definition at line 2670 of file MeshGraph.cpp.

{
    bool updateExpansion = false;
    Array<OneD, NekDouble> coords(m_spaceDimension, 0.0);
 
    for (int i = 0; i < geomVecIter->GetNumVerts(); ++i)
    {
        // Get coordinates from the vertex
        geomVecIter->GetVertex(i)->GetCoords(coords);
        updateExpansion = region->v_Contains(coords);
 
        // Update expansion
        // Change number of modes and number of points (if needed).
        if (updateExpansion)
        {
            // Information of the expansion for a specific element
            auto expInfoID = expansionMap->find(geomVecIter->GetGlobalID());
            if (m_useExpansionType)
            {
                std::vector<unsigned int> nModes = region->GetNumModes();
                (expInfoID->second)->m_basisKeyVector =
                    MeshGraph::DefineBasisKeyFromExpansionType(
                        geomVecIter,
                        (ExpansionType)(expInfoID->second)
                            ->m_basisKeyVector.begin()
                            ->GetBasisType(),
                        nModes[0]);
            }
            else
            {
                int cnt = 0;
                LibUtilities::BasisKeyVector updatedBasisKey;
                std::vector<unsigned int> nModes  = region->GetNumModes();
                std::vector<unsigned int> nPoints = region->GetNumPoints();
                for (auto basis = expInfoID->second->m_basisKeyVector.begin();
                     basis != expInfoID->second->m_basisKeyVector.end();
                     ++basis)
                {
                    // Generate Basis key using information
                    const LibUtilities::PointsKey pkey(nPoints[cnt],
                                                       basis->GetPointsType());
                    updatedBasisKey.push_back(LibUtilities::BasisKey(
                        basis->GetBasisType(), nModes[cnt], pkey));
                    cnt++;
                }
                (expInfoID->second)->m_basisKeyVector = updatedBasisKey;
            }
            updateExpansion = false;
        }
    }
}

References DefineBasisKeyFromExpansionType(), Nektar::SpatialDomains::RefRegion::GetNumModes(), Nektar::SpatialDomains::RefRegion::GetNumPoints(), m_spaceDimension, m_useExpansionType, and Nektar::SpatialDomains::RefRegion::v_Contains().

Referenced by SetRefinementInfo().

Read()

MeshGraphSharedPtr Nektar::SpatialDomains::MeshGraph::Read ( const LibUtilities::SessionReaderSharedPtr  pSession, LibUtilities::DomainRangeShPtr  rng = LibUtilities::NullDomainRangeShPtr, bool  fillGraph = true, SpatialDomains::MeshGraphSharedPtr  partitionedGraph = nullptr  )

static

Definition at line 115 of file MeshGraph.cpp.

{
    LibUtilities::CommSharedPtr comm = session->GetComm();
    ASSERTL0(comm.get(), "Communication not initialised.");
 
    // Populate SessionReader. This should be done only on the root process so
    // that we can partition appropriately without all processes having to read
    // in the input file.
    const bool isRoot = comm->TreatAsRankZero();
    std::string geomType;
 
    if (isRoot)
    {
        // Parse the XML document.
        session->InitSession();
 
        // Get geometry type, i.e. XML (compressed/uncompressed) or HDF5.
        geomType = session->GetGeometryType();
 
        // Convert to a vector of chars so that we can broadcast.
        std::vector<char> v(geomType.c_str(),
                            geomType.c_str() + geomType.length());
 
        size_t length = v.size();
        comm->Bcast(length, 0);
        comm->Bcast(v, 0);
    }
    else
    {
        size_t length;
        comm->Bcast(length, 0);
 
        std::vector<char> v(length);
        comm->Bcast(v, 0);
 
        geomType = std::string(v.begin(), v.end());
    }
 
    // Every process then creates a mesh. Partitioning logic takes place inside
    // the PartitionMesh function so that we can support different options for
    // XML and HDF5.
    MeshGraphSharedPtr mesh = GetMeshGraphFactory().CreateInstance(geomType);
 
    // For Parallel-in-Time
    //    In contrast to XML, a pre-paritioned mesh directory (_xml) is not
    //    produced when partitionning the mesh for the fine solver when using
    //    HDF5. In order to guaranting the same partition on all time level,
    //    the fine mesh partition has to be copied explicitly.
    if (partitionedGraph && geomType == "HDF5")
    {
        mesh->SetPartition(partitionedGraph);
    }
 
    mesh->PartitionMesh(session);
 
    // Finally, read the geometry information.
    mesh->ReadGeometry(rng, fillGraph);
 
    return mesh;
}

References ASSERTL0, Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::CreateInstance(), and Nektar::SpatialDomains::GetMeshGraphFactory().

Referenced by Diffusion::Diffusion(), Nektar::SolverUtils::DriverParallelInTime::SetParallelInTimeEquationSystem(), Nektar::VarcoeffHashingTest::setupContFieldSolve(), Nektar::SolverUtils::CouplingCwipi::SetupReceive(), Nektar::SolverUtils::Driver::v_InitObject(), Nektar::FieldUtils::InputXml::v_Process(), Nektar::FieldUtils::ProcessDisplacement::v_Process(), Nektar::FieldUtils::ProcessInterpField::v_Process(), Nektar::FieldUtils::ProcessInterpPoints::v_Process(), Nektar::SolverUtils::FilterModalEnergy::v_Update(), and Nektar::VortexWaveInteraction::VortexWaveInteraction().

ReadExpansionInfo()

void Nektar::SpatialDomains::MeshGraph::ReadExpansionInfo

(

)

Expansiontypes will contain composite, nummodes, and expansiontype (eModified, or eOrthogonal) Or a full list of data of basistype, nummodes, pointstype, numpoints;

Expansiontypes may also contain a list of fields that this expansion relates to. If this does not exist the variable is set to "DefaultVar". "DefaultVar" is used as the default for any variables not explicitly listed in FIELDS.

Mandatory components...optional are to follow later.

Todo:

solvers break the pattern 'instantiate Session -> instantiate MeshGraph' and parse command line arguments by themselves; one needs to unify command line arguments handling. Solvers tend to call MeshGraph::Read statically -> m_session is not defined -> no info about command line arguments presented ASSERTL0(m_session != 0, "One needs to instantiate SessionReader first");

Mandatory components...optional are to follow later.

Definition at line 2966 of file MeshGraph.cpp.

{
    // Find the Expansions tag
    TiXmlElement *expansionTypes = m_session->GetElement("NEKTAR/EXPANSIONS");
    LibUtilities::SessionReader::GetXMLElementTimeLevel(
        expansionTypes, m_session->GetTimeLevel());
 
    ASSERTL0(expansionTypes, "Unable to find EXPANSIONS tag in file.");
 
    if (expansionTypes)
    {
        // Find the Expansion type
        TiXmlElement *expansion = expansionTypes->FirstChildElement();
        ASSERTL0(expansion, "Unable to find entries in EXPANSIONS tag in "
                            "file.");
        std::string expType           = expansion->Value();
        std::vector<std::string> vars = m_session->GetVariables();
 
        if (expType == "E")
        {
            int i;
            m_expansionMapShPtrMap.clear();
            ExpansionInfoMapShPtr expansionMap;
 
            /// Expansiontypes will contain composite,
            /// nummodes, and expansiontype (eModified, or
            /// eOrthogonal) Or a full list of data of
            /// basistype, nummodes, pointstype, numpoints;
 
            /// Expansiontypes may also contain a list of
            /// fields that this expansion relates to. If this
            /// does not exist the variable is set to "DefaultVar".
            /// "DefaultVar" is used as the default for any
            /// variables not explicitly listed in FIELDS.
 
            // Collect all composites of the domain to control which
            // composites are defined for each variable.
            map<int, bool> domainCompList;
            for (auto &d : m_domain)
            {
                for (auto &c : d.second)
                {
                    domainCompList[c.first] = false;
                }
            }
            map<std::string, map<int, bool>> fieldDomainCompList;
 
            while (expansion)
            {
                // Extract Composites
                std::string compositeStr = expansion->Attribute("COMPOSITE");
                ASSERTL0(compositeStr.length() > 3,
                         "COMPOSITE must be specified in expansion definition");
                int beg = compositeStr.find_first_of("[");
                int end = compositeStr.find_first_of("]");
                std::string compositeListStr =
                    compositeStr.substr(beg + 1, end - beg - 1);
 
                map<int, CompositeSharedPtr> compositeVector;
                GetCompositeList(compositeListStr, compositeVector);
 
                // Extract Fields if any
                const char *fStr = expansion->Attribute("FIELDS");
                std::vector<std::string> fieldStrings;
 
                if (fStr) // extract fields.
                {
                    std::string fieldStr = fStr;
                    bool valid = ParseUtils::GenerateVector(fieldStr.c_str(),
                                                            fieldStrings);
                    ASSERTL0(valid, "Unable to correctly parse the field "
                                    "string in ExpansionTypes.");
 
                    // see if field exists
                    if (m_expansionMapShPtrMap.count(fieldStrings[0]))
                    {
                        expansionMap =
                            m_expansionMapShPtrMap.find(fieldStrings[0])
                                ->second;
                    }
                    else
                    {
                        expansionMap = SetUpExpansionInfoMap();
                    }
 
                    // make sure all fields in this search point
                    // are asigned to same expansion map
                    for (i = 0; i < fieldStrings.size(); ++i)
                    {
                        if (vars.size() && std::count(vars.begin(), vars.end(),
                                                      fieldStrings[i]) == 0)
                        {
                            ASSERTL0(false, "Variable '" + fieldStrings[i] +
                                                "' defined in EXPANSIONS is not"
                                                " defined in VARIABLES.");
                        }
 
                        if (m_expansionMapShPtrMap.count(fieldStrings[i]) == 0)
                        {
                            m_expansionMapShPtrMap[fieldStrings[i]] =
                                expansionMap;
 
                            // set true to the composites where expansion is
                            // defined
                            fieldDomainCompList[fieldStrings[i]] =
                                domainCompList;
                            for (auto c = compositeVector.begin();
                                 c != compositeVector.end(); ++c)
                            {
                                fieldDomainCompList.find(fieldStrings[i])
                                    ->second.find(c->first)
                                    ->second = true;
                            }
                        }
                        else
                        {
                            for (auto c = compositeVector.begin();
                                 c != compositeVector.end(); ++c)
                            {
                                if (fieldDomainCompList.find(fieldStrings[i])
                                        ->second.find(c->first)
                                        ->second == false)
                                {
                                    fieldDomainCompList.find(fieldStrings[i])
                                        ->second.find(c->first)
                                        ->second = true;
                                }
                                else
                                {
                                    ASSERTL0(false,
                                             "Expansion vector for "
                                             "variable '" +
                                                 fieldStrings[i] +
                                                 "' is already setup for C[" +
                                                 to_string(c->first) + "].");
                                }
                            }
                            expansionMap =
                                m_expansionMapShPtrMap.find(fieldStrings[i])
                                    ->second;
                        }
                    }
                }
                else // If no FIELDS attribute, DefaultVar is genereted.
                {
                    if (m_expansionMapShPtrMap.count("DefaultVar") == 0)
                    {
                        expansionMap = SetUpExpansionInfoMap();
                        m_expansionMapShPtrMap["DefaultVar"] = expansionMap;
 
                        fieldDomainCompList["DefaultVar"] = domainCompList;
                        for (auto c = compositeVector.begin();
                             c != compositeVector.end(); ++c)
                        {
                            fieldDomainCompList.find("DefaultVar")
                                ->second.find(c->first)
                                ->second = true;
                        }
                    }
                    else
                    {
                        for (auto c = compositeVector.begin();
                             c != compositeVector.end(); ++c)
                        {
                            if (fieldDomainCompList.find("DefaultVar")
                                    ->second.find(c->first)
                                    ->second == false)
                            {
                                fieldDomainCompList.find("DefaultVar")
                                    ->second.find(c->first)
                                    ->second = true;
                            }
                            else
                            {
                                ASSERTL0(false, "Default expansion already "
                                                "defined for C[" +
                                                    to_string(c->first) + "].");
                            }
                        }
                        expansionMap =
                            m_expansionMapShPtrMap.find("DefaultVar")->second;
                    }
                }
 
                /// Mandatory components...optional are to follow later.
                m_useExpansionType           = false;
                ExpansionType expansion_type = eNoExpansionType;
                int num_modes                = 0;
 
                LibUtilities::BasisKeyVector basiskeyvec;
                const char *tStr = expansion->Attribute("TYPE");
 
                if (tStr) // use type string to define expansion
                {
                    std::string typeStr       = tStr;
                    const std::string *begStr = kExpansionTypeStr;
                    const std::string *endStr =
                        kExpansionTypeStr + eExpansionTypeSize;
                    const std::string *expStr =
                        std::find(begStr, endStr, typeStr);
 
                    ASSERTL0(expStr != endStr, "Invalid expansion type.");
                    expansion_type = (ExpansionType)(expStr - begStr);
 
                    /// \todo solvers break the pattern 'instantiate Session ->
                    /// instantiate MeshGraph'
                    /// and parse command line arguments by themselves; one
                    /// needs to unify command
                    /// line arguments handling.
                    /// Solvers tend to call MeshGraph::Read statically ->
                    /// m_session
                    /// is not defined -> no info about command line arguments
                    /// presented
                    /// ASSERTL0(m_session != 0, "One needs to instantiate
                    /// SessionReader first");
 
                    const char *nStr = expansion->Attribute("NUMMODES");
                    ASSERTL0(nStr, "NUMMODES was not defined in EXPANSION "
                                   "section of input");
                    std::string nummodesStr = nStr;
 
                    // ASSERTL0(m_session,"Session should be defined to evaluate
                    // nummodes ");
                    if (m_session)
                    {
                        LibUtilities::Equation nummodesEqn(
                            m_session->GetInterpreter(), nummodesStr);
                        num_modes = (int)nummodesEqn.Evaluate();
                    }
                    else
                    {
                        num_modes = boost::lexical_cast<int>(nummodesStr);
                    }
 
                    m_useExpansionType = true;
                }
                else // assume expansion is defined individually
                {
                    // Extract the attributes.
                    const char *bTypeStr = expansion->Attribute("BASISTYPE");
                    ASSERTL0(bTypeStr, "TYPE or BASISTYPE was not defined in "
                                       "EXPANSION section of input");
                    std::string basisTypeStr = bTypeStr;
 
                    // interpret the basis type string.
                    std::vector<std::string> basisStrings;
                    std::vector<LibUtilities::BasisType> basis;
                    bool valid = ParseUtils::GenerateVector(
                        basisTypeStr.c_str(), basisStrings);
                    ASSERTL0(valid,
                             "Unable to correctly parse the basis types.");
                    for (vector<std::string>::size_type i = 0;
                         i < basisStrings.size(); i++)
                    {
                        valid = false;
                        for (unsigned int j = 0;
                             j < LibUtilities::SIZE_BasisType; j++)
                        {
                            if (LibUtilities::BasisTypeMap[j] ==
                                basisStrings[i])
                            {
                                basis.push_back((LibUtilities::BasisType)j);
                                valid = true;
                                break;
                            }
                        }
                        ASSERTL0(
                            valid,
                            std::string(
                                "Unable to correctly parse the basis type: ")
                                .append(basisStrings[i])
                                .c_str());
                    }
                    const char *nModesStr = expansion->Attribute("NUMMODES");
                    ASSERTL0(nModesStr, "NUMMODES was not defined in EXPANSION "
                                        "section of input");
 
                    std::string numModesStr = nModesStr;
                    std::vector<unsigned int> numModes;
                    valid = ParseUtils::GenerateVector(numModesStr.c_str(),
                                                       numModes);
                    ASSERTL0(valid,
                             "Unable to correctly parse the number of modes.");
                    ASSERTL0(numModes.size() == basis.size(),
                             "information for num modes does not match the "
                             "number of basis");
 
                    const char *pTypeStr = expansion->Attribute("POINTSTYPE");
                    ASSERTL0(pTypeStr, "POINTSTYPE was not defined in "
                                       "EXPANSION section of input");
                    std::string pointsTypeStr = pTypeStr;
                    // interpret the points type string.
                    std::vector<std::string> pointsStrings;
                    std::vector<LibUtilities::PointsType> points;
                    valid = ParseUtils::GenerateVector(pointsTypeStr.c_str(),
                                                       pointsStrings);
                    ASSERTL0(valid,
                             "Unable to correctly parse the points types.");
                    for (vector<std::string>::size_type i = 0;
                         i < pointsStrings.size(); i++)
                    {
                        valid = false;
                        for (unsigned int j = 0;
                             j < LibUtilities::SIZE_PointsType; j++)
                        {
                            if (LibUtilities::kPointsTypeStr[j] ==
                                pointsStrings[i])
                            {
                                points.push_back((LibUtilities::PointsType)j);
                                valid = true;
                                break;
                            }
                        }
                        ASSERTL0(
                            valid,
                            std::string(
                                "Unable to correctly parse the points type: ")
                                .append(pointsStrings[i])
                                .c_str());
                    }
 
                    const char *nPointsStr = expansion->Attribute("NUMPOINTS");
                    ASSERTL0(nPointsStr, "NUMPOINTS was not defined in "
                                         "EXPANSION section of input");
                    std::string numPointsStr = nPointsStr;
                    std::vector<unsigned int> numPoints;
                    valid = ParseUtils::GenerateVector(numPointsStr.c_str(),
                                                       numPoints);
                    ASSERTL0(valid,
                             "Unable to correctly parse the number of points.");
                    ASSERTL0(numPoints.size() == numPoints.size(),
                             "information for num points does not match the "
                             "number of basis");
 
                    for (int i = 0; i < basis.size(); ++i)
                    {
                        // Generate Basis key  using information
                        const LibUtilities::PointsKey pkey(numPoints[i],
                                                           points[i]);
                        basiskeyvec.push_back(LibUtilities::BasisKey(
                            basis[i], numModes[i], pkey));
                    }
                }
 
                // Extract refinement id if any
                const char *refIDsStr = expansion->Attribute("REFIDS");
                if (refIDsStr)
                {
                    vector<NekDouble> refIDsVector;
                    string refIDsString = refIDsStr;
                    bool valid =
                        ParseUtils::GenerateVector(refIDsString, refIDsVector);
                    ASSERTL0(valid, "Unable to correctly parse the ids "
                                    "values of input");
 
                    // Map to link the refinement ids and composites
                    for (auto iter = refIDsVector.begin();
                         iter != refIDsVector.end(); ++iter)
                    {
                        m_refComposite[*iter] = compositeVector;
                    }
                    m_refFlag = true;
                }
 
                // Now have composite and basiskeys.  Cycle through
                // all composites for the geomShPtrs and set the modes
                // and types for the elements contained in the element
                // list.
                for (auto compVecIter = compositeVector.begin();
                     compVecIter != compositeVector.end(); ++compVecIter)
                {
                    for (auto geomVecIter =
                             compVecIter->second->m_geomVec.begin();
                         geomVecIter != compVecIter->second->m_geomVec.end();
                         ++geomVecIter)
                    {
                        auto x =
                            expansionMap->find((*geomVecIter)->GetGlobalID());
                        ASSERTL0(
                            x != expansionMap->end(),
                            "Expansion " +
                                std::to_string((*geomVecIter)->GetGlobalID()) +
                                " not found!!");
                        if (m_useExpansionType)
                        {
                            (x->second)->m_basisKeyVector =
                                MeshGraph::DefineBasisKeyFromExpansionType(
                                    *geomVecIter, expansion_type, num_modes);
                        }
                        else
                        {
                            ASSERTL0((*geomVecIter)->GetShapeDim() ==
                                         basiskeyvec.size(),
                                     " There is an incompatible expansion "
                                     "dimension with geometry dimension");
                            (x->second)->m_basisKeyVector = basiskeyvec;
                        }
                    }
                }
 
                expansion = expansion->NextSiblingElement("E");
            }
 
            // Check if all the domain has been defined for the existing fields
            // excluding DefaultVar. Fill the absent composites of a field if
            // the DefaultVar is defined for that composite
            for (auto f = fieldDomainCompList.begin();
                 f != fieldDomainCompList.end(); ++f)
            {
                if (f->first != "DefaultVar")
                {
                    for (auto c = f->second.begin(); c != f->second.end(); ++c)
                    {
                        if (c->second == false &&
                            fieldDomainCompList.find("DefaultVar")
                                    ->second.find(c->first)
                                    ->second == true)
                        {
                            // Copy DefaultVar into the missing composite
                            // by cycling through the element list.
                            for (auto geomVecIter =
                                     m_meshComposites.find(c->first)
                                         ->second->m_geomVec.begin();
                                 geomVecIter != m_meshComposites.find(c->first)
                                                    ->second->m_geomVec.end();
                                 ++geomVecIter)
                            {
                                auto xDefaultVar =
                                    m_expansionMapShPtrMap.find("DefaultVar")
                                        ->second->find(
                                            (*geomVecIter)->GetGlobalID());
 
                                auto xField =
                                    m_expansionMapShPtrMap.find(f->first)
                                        ->second->find(
                                            (*geomVecIter)->GetGlobalID());
 
                                (xField->second)->m_basisKeyVector =
                                    (xDefaultVar->second)->m_basisKeyVector;
                            }
                            c->second = true;
                            NEKERROR(
                                ErrorUtil::ewarning,
                                (std::string(
                                     "Using Default expansion definition for "
                                     "field '") +
                                 f->first +
                                 "' in composite "
                                 "C[" +
                                 to_string(c->first) + "].")
                                    .c_str());
                        }
                        ASSERTL0(c->second, "There is no expansion defined for "
                                            "variable '" +
                                                f->first + "' in C[" +
                                                to_string(c->first) + "].");
                    }
                }
            }
            // Ensure m_expansionMapShPtrMap has an entry for all variables
            // listed in CONDITIONS/VARIABLES section if DefaultVar is defined.
            for (i = 0; i < vars.size(); ++i)
            {
                if (m_expansionMapShPtrMap.count(vars[i]) == 0)
                {
                    if (m_expansionMapShPtrMap.count("DefaultVar"))
                    {
                        expansionMap =
                            m_expansionMapShPtrMap.find("DefaultVar")->second;
                        m_expansionMapShPtrMap[vars[i]] = expansionMap;
 
                        NEKERROR(
                            ErrorUtil::ewarning,
                            (std::string(
                                 "Using Default expansion definition for field "
                                 "'") +
                             vars[i] + "'.")
                                .c_str());
                    }
                    else
                    {
                        ASSERTL0(false, "Variable '" + vars[i] +
                                            "' is missing"
                                            " in FIELDS attribute of EXPANSIONS"
                                            " tag.");
                    }
                }
            }
            // Define "DefaultVar" if not set by user.
            if (m_expansionMapShPtrMap.count("DefaultVar") == 0)
            {
                // Originally assignment was using
                // m_expansionMapShPtrMap["DefaultVar"] =
                // m_expansionMapShPtrMap.begin()->second; but on certain macOS
                // versions, this was causing a seg fault so switched to storing
                // addr first - see #271
                ExpansionInfoMapShPtr firstEntryAddr =
                    m_expansionMapShPtrMap.begin()->second;
                m_expansionMapShPtrMap["DefaultVar"] = firstEntryAddr;
            }
 
            // If the user defined the refinement section correctly,
            // the refinement secion is going to be uploaded and set.
            if (m_refFlag)
            {
                // Read refinement info
                ReadRefinementInfo();
 
                // Set refinement info in the given region
                // Verify and set the elements which needs p-refinement
                SetRefinementInfo(expansionMap);
            }
        }
        else if (expType == "H")
        {
            int i;
            m_expansionMapShPtrMap.clear();
            ExpansionInfoMapShPtr expansionMap;
 
            // Collect all composites of the domain to control which
            // composites are defined for each variable.
            map<int, bool> domainCompList;
            for (auto &d : m_domain)
            {
                for (auto &c : d.second)
                {
                    domainCompList[c.first] = false;
                }
            }
            map<std::string, map<int, bool>> fieldDomainCompList;
 
            while (expansion)
            {
                // Extract Composites
                std::string compositeStr = expansion->Attribute("COMPOSITE");
                ASSERTL0(compositeStr.length() > 3,
                         "COMPOSITE must be specified in expansion definition");
                int beg = compositeStr.find_first_of("[");
                int end = compositeStr.find_first_of("]");
                std::string compositeListStr =
                    compositeStr.substr(beg + 1, end - beg - 1);
 
                map<int, CompositeSharedPtr> compositeVector;
                GetCompositeList(compositeListStr, compositeVector);
 
                // Extract Fields if any
                const char *fStr = expansion->Attribute("FIELDS");
                std::vector<std::string> fieldStrings;
 
                if (fStr) // extract fields.
                {
                    std::string fieldStr = fStr;
                    bool valid = ParseUtils::GenerateVector(fieldStr.c_str(),
                                                            fieldStrings);
                    ASSERTL0(valid, "Unable to correctly parse the field "
                                    "string in ExpansionTypes.");
 
                    // see if field exists
                    if (m_expansionMapShPtrMap.count(fieldStrings[0]))
                    {
                        expansionMap =
                            m_expansionMapShPtrMap.find(fieldStrings[0])
                                ->second;
                    }
                    else
                    {
                        expansionMap = SetUpExpansionInfoMap();
                    }
 
                    // make sure all fields in this search point
                    // are asigned to same expansion map
                    for (i = 0; i < fieldStrings.size(); ++i)
                    {
                        if (vars.size() && std::count(vars.begin(), vars.end(),
                                                      fieldStrings[i]) == 0)
                        {
                            ASSERTL0(false, "Variable '" + fieldStrings[i] +
                                                "' defined in EXPANSIONS is not"
                                                " defined in VARIABLES.");
                        }
 
                        if (m_expansionMapShPtrMap.count(fieldStrings[i]) == 0)
                        {
                            m_expansionMapShPtrMap[fieldStrings[i]] =
                                expansionMap;
 
                            // set true to the composites where expansion is
                            // defined
                            fieldDomainCompList[fieldStrings[i]] =
                                domainCompList;
                            for (auto c = compositeVector.begin();
                                 c != compositeVector.end(); ++c)
                            {
                                fieldDomainCompList.find(fieldStrings[i])
                                    ->second.find(c->first)
                                    ->second = true;
                            }
                        }
                        else
                        {
                            for (auto c = compositeVector.begin();
                                 c != compositeVector.end(); ++c)
                            {
                                if (fieldDomainCompList.find(fieldStrings[i])
                                        ->second.find(c->first)
                                        ->second == false)
                                {
                                    fieldDomainCompList.find(fieldStrings[i])
                                        ->second.find(c->first)
                                        ->second = true;
                                }
                                else
                                {
                                    ASSERTL0(false,
                                             "Expansion vector for "
                                             "variable '" +
                                                 fieldStrings[i] +
                                                 "' is already setup for C[" +
                                                 to_string(c->first) + "].");
                                }
                            }
                            expansionMap =
                                m_expansionMapShPtrMap.find(fieldStrings[i])
                                    ->second;
                        }
                    }
                }
                else // If no FIELDS attribute, DefaultVar is genereted.
                {
                    if (m_expansionMapShPtrMap.count("DefaultVar") == 0)
                    {
                        expansionMap = SetUpExpansionInfoMap();
                        m_expansionMapShPtrMap["DefaultVar"] = expansionMap;
 
                        fieldDomainCompList["DefaultVar"] = domainCompList;
                        for (auto c = compositeVector.begin();
                             c != compositeVector.end(); ++c)
                        {
                            fieldDomainCompList.find("DefaultVar")
                                ->second.find(c->first)
                                ->second = true;
                        }
                    }
                    else
                    {
                        for (auto c = compositeVector.begin();
                             c != compositeVector.end(); ++c)
                        {
                            if (fieldDomainCompList.find("DefaultVar")
                                    ->second.find(c->first)
                                    ->second == false)
                            {
                                fieldDomainCompList.find("DefaultVar")
                                    ->second.find(c->first)
                                    ->second = true;
                            }
                            else
                            {
                                ASSERTL0(false, "Default expansion already "
                                                "defined for C[" +
                                                    to_string(c->first) + "].");
                            }
                        }
                        expansionMap =
                            m_expansionMapShPtrMap.find("DefaultVar")->second;
                    }
                }
 
                /// Mandatory components...optional are to follow later.
                ExpansionType expansion_type_x = eNoExpansionType;
                ExpansionType expansion_type_y = eNoExpansionType;
                ExpansionType expansion_type_z = eNoExpansionType;
                int num_modes_x                = 0;
                int num_modes_y                = 0;
                int num_modes_z                = 0;
 
                LibUtilities::BasisKeyVector basiskeyvec;
 
                const char *tStr_x = expansion->Attribute("TYPE-X");
 
                if (tStr_x) // use type string to define expansion
                {
                    std::string typeStr       = tStr_x;
                    const std::string *begStr = kExpansionTypeStr;
                    const std::string *endStr =
                        kExpansionTypeStr + eExpansionTypeSize;
                    const std::string *expStr =
                        std::find(begStr, endStr, typeStr);
 
                    ASSERTL0(expStr != endStr, "Invalid expansion type.");
                    expansion_type_x = (ExpansionType)(expStr - begStr);
 
                    const char *nStr = expansion->Attribute("NUMMODES-X");
                    ASSERTL0(nStr, "NUMMODES-X was not defined in EXPANSION "
                                   "section of input");
                    std::string nummodesStr = nStr;
 
                    // ASSERTL0(m_session,"Session should be defined to evaluate
                    // nummodes ");
 
                    if (m_session)
                    {
                        LibUtilities::Equation nummodesEqn(
                            m_session->GetInterpreter(), nummodesStr);
                        num_modes_x = (int)nummodesEqn.Evaluate();
                    }
                    else
                    {
                        num_modes_x = boost::lexical_cast<int>(nummodesStr);
                    }
                }
 
                const char *tStr_y = expansion->Attribute("TYPE-Y");
 
                if (tStr_y) // use type string to define expansion
                {
                    std::string typeStr       = tStr_y;
                    const std::string *begStr = kExpansionTypeStr;
                    const std::string *endStr =
                        kExpansionTypeStr + eExpansionTypeSize;
                    const std::string *expStr =
                        std::find(begStr, endStr, typeStr);
 
                    ASSERTL0(expStr != endStr, "Invalid expansion type.");
                    expansion_type_y = (ExpansionType)(expStr - begStr);
 
                    const char *nStr = expansion->Attribute("NUMMODES-Y");
                    ASSERTL0(nStr, "NUMMODES-Y was not defined in EXPANSION "
                                   "section of input");
                    std::string nummodesStr = nStr;
 
                    // ASSERTL0(m_session,"Session should be defined to evaluate
                    // nummodes ");
                    if (m_session)
                    {
                        LibUtilities::Equation nummodesEqn(
                            m_session->GetInterpreter(), nummodesStr);
                        num_modes_y = (int)nummodesEqn.Evaluate();
                    }
                    else
                    {
                        num_modes_y = boost::lexical_cast<int>(nummodesStr);
                    }
                }
 
                const char *tStr_z = expansion->Attribute("TYPE-Z");
 
                if (tStr_z) // use type string to define expansion
                {
                    std::string typeStr       = tStr_z;
                    const std::string *begStr = kExpansionTypeStr;
                    const std::string *endStr =
                        kExpansionTypeStr + eExpansionTypeSize;
                    const std::string *expStr =
                        std::find(begStr, endStr, typeStr);
 
                    ASSERTL0(expStr != endStr, "Invalid expansion type.");
                    expansion_type_z = (ExpansionType)(expStr - begStr);
 
                    const char *nStr = expansion->Attribute("NUMMODES-Z");
                    ASSERTL0(nStr, "NUMMODES-Z was not defined in EXPANSION "
                                   "section of input");
                    std::string nummodesStr = nStr;
 
                    // ASSERTL0(m_session,"Session should be defined to evaluate
                    // nummodes ");
                    if (m_session)
                    {
                        LibUtilities::Equation nummodesEqn(
                            m_session->GetInterpreter(), nummodesStr);
                        num_modes_z = (int)nummodesEqn.Evaluate();
                    }
                    else
                    {
                        num_modes_z = boost::lexical_cast<int>(nummodesStr);
                    }
                }
 
                for (auto compVecIter = compositeVector.begin();
                     compVecIter != compositeVector.end(); ++compVecIter)
                {
                    for (auto geomVecIter =
                             compVecIter->second->m_geomVec.begin();
                         geomVecIter != compVecIter->second->m_geomVec.end();
                         ++geomVecIter)
                    {
                        for (auto expVecIter = expansionMap->begin();
                             expVecIter != expansionMap->end(); ++expVecIter)
                        {
 
                            (expVecIter->second)->m_basisKeyVector =
                                DefineBasisKeyFromExpansionTypeHomo(
                                    *geomVecIter, expansion_type_x,
                                    expansion_type_y, expansion_type_z,
                                    num_modes_x, num_modes_y, num_modes_z);
                        }
                    }
                }
 
                expansion = expansion->NextSiblingElement("H");
            }
 
            // Check if all the domain has been defined for the existing fields
            // excluding DefaultVar. Fill the absent composites of a field if
            // the DefaultVar is defined for that composite
            for (auto f = fieldDomainCompList.begin();
                 f != fieldDomainCompList.end(); ++f)
            {
                if (f->first != "DefaultVar")
                {
                    for (auto c = f->second.begin(); c != f->second.end(); ++c)
                    {
                        if (c->second == false &&
                            fieldDomainCompList.find("DefaultVar")
                                    ->second.find(c->first)
                                    ->second == true)
                        {
                            // Copy DefaultVar into the missing composite
                            // by cycling through the element list.
                            for (auto geomVecIter =
                                     m_meshComposites.find(c->first)
                                         ->second->m_geomVec.begin();
                                 geomVecIter != m_meshComposites.find(c->first)
                                                    ->second->m_geomVec.end();
                                 ++geomVecIter)
                            {
                                auto xDefaultVar =
                                    m_expansionMapShPtrMap.find("DefaultVar")
                                        ->second->find(
                                            (*geomVecIter)->GetGlobalID());
 
                                auto xField =
                                    m_expansionMapShPtrMap.find(f->first)
                                        ->second->find(
                                            (*geomVecIter)->GetGlobalID());
 
                                (xField->second)->m_basisKeyVector =
                                    (xDefaultVar->second)->m_basisKeyVector;
                            }
                            c->second = true;
                            NEKERROR(
                                ErrorUtil::ewarning,
                                (std::string(
                                     "Using Default expansion definition for "
                                     "field '") +
                                 f->first +
                                 "' in composite "
                                 "C[" +
                                 to_string(c->first) + "].")
                                    .c_str());
                        }
                        ASSERTL0(c->second, "There is no expansion defined for "
                                            "variable '" +
                                                f->first + "' in C[" +
                                                to_string(c->first) + "].");
                    }
                }
            }
            // Ensure m_expansionMapShPtrMap has an entry for all variables
            // listed in CONDITIONS/VARIABLES section if DefaultVar is defined.
            for (i = 0; i < vars.size(); ++i)
            {
                if (m_expansionMapShPtrMap.count(vars[i]) == 0)
                {
                    if (m_expansionMapShPtrMap.count("DefaultVar"))
                    {
                        expansionMap =
                            m_expansionMapShPtrMap.find("DefaultVar")->second;
                        m_expansionMapShPtrMap[vars[i]] = expansionMap;
 
                        NEKERROR(
                            ErrorUtil::ewarning,
                            (std::string(
                                 "Using Default expansion definition for field "
                                 "'") +
                             vars[i] + "'.")
                                .c_str());
                    }
                    else
                    {
                        ASSERTL0(false, "Variable '" + vars[i] +
                                            "' is missing"
                                            " in FIELDS attribute of EXPANSIONS"
                                            " tag.");
                    }
                }
            }
            // Define "DefaultVar" if not set by user.
            if (m_expansionMapShPtrMap.count("DefaultVar") == 0)
            {
                // Originally assignment was using
                // m_expansionMapShPtrMap["DefaultVar"] =
                // m_expansionMapShPtrMap.begin()->second; but on certain macOS
                // versions, This was causing a seg fault so switched to
                // storing addr first - see #271
                ExpansionInfoMapShPtr firstEntryAddr =
                    m_expansionMapShPtrMap.begin()->second;
                m_expansionMapShPtrMap["DefaultVar"] = firstEntryAddr;
            }
        }
        else if (expType ==
                 "ELEMENTS") // Reading a file with the expansion definition
        {
            std::vector<LibUtilities::FieldDefinitionsSharedPtr> fielddefs;
 
            // This has to use the XML reader since we are treating the already
            // parsed XML as a standard FLD file.
            std::shared_ptr<LibUtilities::FieldIOXml> f =
                make_shared<LibUtilities::FieldIOXml>(m_session->GetComm(),
                                                      false);
            f->ImportFieldDefs(
                LibUtilities::XmlDataSource::create(m_session->GetDocument()),
                fielddefs, true);
            cout << "    Number of elements: " << fielddefs.size() << endl;
            SetExpansionInfo(fielddefs);
        }
        else if (expType == "F")
        {
            ASSERTL0(expansion->Attribute("FILE"),
                     "Attribute FILE expected for type F expansion");
            std::string filenameStr = expansion->Attribute("FILE");
            ASSERTL0(!filenameStr.empty(),
                     "A filename must be specified for the FILE "
                     "attribute of expansion");
 
            std::vector<LibUtilities::FieldDefinitionsSharedPtr> fielddefs;
            LibUtilities::FieldIOSharedPtr f =
                LibUtilities::FieldIO::CreateForFile(m_session, filenameStr);
            f->Import(filenameStr, fielddefs);
            SetExpansionInfo(fielddefs);
        }
        else
        {
            ASSERTL0(false, "Expansion type not defined");
        }
    }
}

References ASSERTL0, Nektar::LibUtilities::BasisTypeMap, Nektar::LibUtilities::XmlDataSource::create(), Nektar::LibUtilities::FieldIO::CreateForFile(), Nektar::UnitTests::d(), DefineBasisKeyFromExpansionType(), DefineBasisKeyFromExpansionTypeHomo(), Nektar::SpatialDomains::eExpansionTypeSize, Nektar::SpatialDomains::eNoExpansionType, Nektar::LibUtilities::Equation::Evaluate(), Nektar::ErrorUtil::ewarning, Nektar::StdRegions::find(), Nektar::ParseUtils::GenerateVector(), GetCompositeList(), Nektar::LibUtilities::SessionReader::GetXMLElementTimeLevel(), Nektar::SpatialDomains::kExpansionTypeStr, Nektar::LibUtilities::kPointsTypeStr, m_domain, m_expansionMapShPtrMap, m_meshComposites, m_refComposite, m_refFlag, m_session, m_useExpansionType, NEKERROR, ReadRefinementInfo(), SetExpansionInfo(), SetRefinementInfo(), SetUpExpansionInfoMap(), Nektar::LibUtilities::SIZE_BasisType, and Nektar::LibUtilities::SIZE_PointsType.

Referenced by FillGraph().

ReadGeometry()

void Nektar::SpatialDomains::MeshGraph::ReadGeometry ( LibUtilities::DomainRangeShPtr  rng, bool  fillGraph  )

inline

Definition at line 554 of file MeshGraph.h.

{
    v_ReadGeometry(rng, fillGraph);
}

References v_ReadGeometry().

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

ReadRefinementInfo()

void Nektar::SpatialDomains::MeshGraph::ReadRefinementInfo

(

)

Read refinement info.

Read refinement information provided by the user in the xml file. In this function, it reads the reference id, the radius, the coordinates, the type of the method, number of modes, and number of quadrature points if necessary.

Definition at line 2774 of file MeshGraph.cpp.

{
    // Find the Refinement tag
    TiXmlElement *refinementTypes = m_session->GetElement("NEKTAR/REFINEMENTS");
 
    if (refinementTypes)
    {
        TiXmlElement *refinement = refinementTypes->FirstChildElement();
        ASSERTL0(refinement, "Unable to find entries in REFINEMENTS tag "
                             "in file");
        std::string refType = refinement->Value();
 
        if (refType == "R")
        {
            while (refinement)
            {
                std::vector<NekDouble> coord1Vector, coord2Vector;
                std::vector<unsigned int> nModesVector, nPointsVector;
 
                // Extract Refinement ID
                const char *idStr = refinement->Attribute("REF");
                ASSERTL0(idStr, "REF was not defined in REFINEMENT section "
                                "of input");
 
                unsigned id = boost::lexical_cast<unsigned int>(idStr);
 
                // Extract Radius
                const char *radiusStr = refinement->Attribute("RADIUS");
                ASSERTL0(radiusStr, "RADIUS was not defined in REFINEMENT "
                                    "section of input");
 
                NekDouble radius = boost::lexical_cast<NekDouble>(radiusStr);
 
                // Extract Coordinate 1
                const char *c1Str = refinement->Attribute("COORDINATE1");
                ASSERTL0(c1Str, "COORDINATE1 was not defined in REFINEMENT"
                                "section of input");
 
                std::string coord1String = c1Str;
                bool valid =
                    ParseUtils::GenerateVector(coord1String, coord1Vector);
                ASSERTL0(valid, "Unable to correctly parse the axes "
                                "values for COORDINATE1");
 
                ASSERTL0(coord1Vector.size() == m_spaceDimension,
                         "Number of coordinates do not match the space "
                         "dimension for COORDINATE1");
 
                // Refinement Type
                const char *rType = refinement->Attribute("TYPE");
                ASSERTL0(rType, "TYPE was not defined in REFINEMENT "
                                "section of input");
 
                // Extract Coordinate 2
                const char *c2Str = refinement->Attribute("COORDINATE2");
 
                if (strcmp(rType, "STANDARD") == 0)
                {
                    ASSERTL0(c2Str, "COORDINATE2 was not defined in REFINEMENT "
                                    "section of input");
 
                    std::string coord2String = c2Str;
                    valid =
                        ParseUtils::GenerateVector(coord2String, coord2Vector);
                    ASSERTL0(valid, "Unable to correctly parse the axes "
                                    "values for COORDINATE2");
                    ASSERTL0(coord2Vector.size() == m_spaceDimension,
                             "Number of coordinates do not match the space "
                             "dimension for COORDINATE2");
 
                    // The STANDARD TYPE approach only accepts meshes that have
                    // the same dimension as the space dimension.
                    ASSERTL0(
                        m_spaceDimension == m_meshDimension,
                        "The mesh dimension must match the space dimension");
                }
                else if (strcmp(rType, "SPHERE") == 0)
                {
                    // COORDINATE2 is not necessary for this TYPE.
                    ASSERTL0(!c2Str, "COORDINATE2 should not be defined in "
                                     "REFINEMENT section of input for the "
                                     "SPHERE TYPE");
 
                    coord2Vector.clear();
                }
                else
                {
                    NEKERROR(Nektar::ErrorUtil::efatal,
                             "Invalid refinement type");
                }
 
                // Extract number of modes
                // Check if the expansion was defined individually
                if (m_useExpansionType == false)
                {
                    const char *nModesStr = refinement->Attribute("NUMMODES");
                    ASSERTL0(nModesStr, "NUMMODES was not defined in "
                                        "Refinement section of input");
 
                    std::string numModesStr = nModesStr;
                    valid =
                        ParseUtils::GenerateVector(numModesStr, nModesVector);
                    ASSERTL0(valid,
                             "Unable to correctly parse the number of modes");
 
                    // Extract number of points
                    const char *nPointsStr = refinement->Attribute("NUMPOINTS");
                    ASSERTL0(nPointsStr, "NUMPOINTS was not defined in "
                                         "Refinement section of input");
 
                    std::string numPointsStr = nPointsStr;
                    valid =
                        ParseUtils::GenerateVector(numPointsStr, nPointsVector);
                    ASSERTL0(valid,
                             "Unable to correctly parse the number of modes");
                }
                else // if m_useExpansionType=true
                {
                    const char *nModesStr = refinement->Attribute("NUMMODES");
                    ASSERTL0(nModesStr,
                             "NUMMODES was not defined in Refinement "
                             "section of input");
 
                    std::string numModesStr = nModesStr;
                    int n_modesRef;
                    if (m_session)
                    {
                        LibUtilities::Equation nummodesEqn(
                            m_session->GetInterpreter(), numModesStr);
                        n_modesRef = (int)nummodesEqn.Evaluate();
                    }
                    else
                    {
                        n_modesRef = boost::lexical_cast<int>(numModesStr);
                    }
                    nModesVector.push_back(n_modesRef);
                    nPointsVector.clear(); // No points.
                }
 
                // Instantiate an object
                if (strcmp(rType, "STANDARD") == 0)
                {
                    switch (m_spaceDimension)
                    {
                        case 3:
                        {
                            // Polymorphism of object
                            // Instantiate RefRegionCylinder object
                            RefRegion *refInfo = new RefRegionCylinder(
                                m_spaceDimension, radius, coord1Vector,
                                coord2Vector, nModesVector, nPointsVector);
                            // Map: refinement ID, refinement region object
                            m_refRegion[id] = refInfo;
                            break;
                        }
                        case 2:
                        {
                            RefRegion *refInfo = new RefRegionParallelogram(
                                m_spaceDimension, radius, coord1Vector,
                                coord2Vector, nModesVector, nPointsVector);
                            m_refRegion[id] = refInfo;
                            break;
                        }
                        case 1:
                        {
                            RefRegion *refInfo = new RefRegionLine(
                                m_spaceDimension, radius, coord1Vector,
                                coord2Vector, nModesVector, nPointsVector);
                            m_refRegion[id] = refInfo;
                            break;
                        }
                    }
                }
                else
                {
                    RefRegion *refInfo = new RefRegionSphere(
                        m_spaceDimension, radius, coord1Vector, coord2Vector,
                        nModesVector, nPointsVector);
                    m_refRegion[id] = refInfo;
                }
 
                refinement = refinement->NextSiblingElement("R");
            }
        }
    }
    else
    {
        NEKERROR(Nektar::ErrorUtil::efatal,
                 "Unable to find REFINEMENTS tag in file");
    }
}

References ASSERTL0, Nektar::ErrorUtil::efatal, Nektar::LibUtilities::Equation::Evaluate(), Nektar::ParseUtils::GenerateVector(), m_meshDimension, m_refRegion, m_session, m_spaceDimension, m_useExpansionType, and NEKERROR.

Referenced by ReadExpansionInfo().

ResetExpansionInfoToBasisKey()

void Nektar::SpatialDomains::MeshGraph::ResetExpansionInfoToBasisKey	(	ExpansionInfoMapShPtr &	expansionMap,
		LibUtilities::ShapeType	shape,
		LibUtilities::BasisKeyVector &	keys
	)

Definition at line 1615 of file MeshGraph.cpp.

{
    for (auto elemIter = expansionMap->begin(); elemIter != expansionMap->end();
         ++elemIter)
    {
        if ((elemIter->second)->m_geomShPtr->GetShapeType() == shape)
        {
            (elemIter->second)->m_basisKeyVector = keys;
        }
    }
}

Referenced by SetBasisKey().

SameExpansionInfo()

bool Nektar::SpatialDomains::MeshGraph::SameExpansionInfo ( const std::string  var1, const std::string  var2  )

inline

Definition at line 592 of file MeshGraph.h.

{
    ExpansionInfoMapShPtr expVec1 = m_expansionMapShPtrMap.find(var1)->second;
    ExpansionInfoMapShPtr expVec2 = m_expansionMapShPtrMap.find(var2)->second;
 
    if (expVec1.get() == expVec2.get())
    {
        return true;
    }
 
    return false;
}

References m_expansionMapShPtrMap.

SetBasisKey()

void Nektar::SpatialDomains::MeshGraph::SetBasisKey	(	LibUtilities::ShapeType	shape,
		LibUtilities::BasisKeyVector &	keys,
		std::string	var = "DefaultVar"
	)

Sets the basis key for all expansions of the given shape.

For each element of shape given by shape in field var, replace the current BasisKeyVector describing the expansion in each dimension, with the one provided by keys.

@TODO: Allow selection of elements through a CompositeVector, as well as by type.

Parameters

shape	The shape of elements to be changed.
keys	The new basis vector to apply to those elements.

Definition at line 1607 of file MeshGraph.cpp.

{
    ExpansionInfoMapShPtr expansionMap =
        m_expansionMapShPtrMap.find(var)->second;
    ResetExpansionInfoToBasisKey(expansionMap, shape, keys);
}

References m_expansionMapShPtrMap, and ResetExpansionInfoToBasisKey().

SetBndRegionOrdering()

void Nektar::SpatialDomains::MeshGraph::SetBndRegionOrdering ( BndRegionOrdering  p_bndRegOrder )

inline

Definition at line 456 of file MeshGraph.h.

    {
        m_bndRegOrder = p_bndRegOrder;
    }

References m_bndRegOrder.

SetCompositeOrdering()

void Nektar::SpatialDomains::MeshGraph::SetCompositeOrdering ( CompositeOrdering  p_compOrder )

inline

Definition at line 446 of file MeshGraph.h.

    {
        m_compOrder = p_compOrder;
    }

References m_compOrder.

SetDomainRange()

void Nektar::SpatialDomains::MeshGraph::SetDomainRange	(	NekDouble	xmin,
		NekDouble	xmax,
		NekDouble	ymin = NekConstants::kNekUnsetDouble,
		NekDouble	ymax = NekConstants::kNekUnsetDouble,
		NekDouble	zmin = NekConstants::kNekUnsetDouble,
		NekDouble	zmax = NekConstants::kNekUnsetDouble
	)

Definition at line 4129 of file MeshGraph.cpp.

{
    m_domainRange->m_checkShape = false;
 
    if (m_domainRange == LibUtilities::NullDomainRangeShPtr)
    {
        m_domainRange =
            MemoryManager<LibUtilities::DomainRange>::AllocateSharedPtr();
        m_domainRange->m_doXrange = true;
    }
 
    m_domainRange->m_xmin = xmin;
    m_domainRange->m_xmax = xmax;
 
    if (ymin == NekConstants::kNekUnsetDouble)
    {
        m_domainRange->m_doYrange = false;
    }
    else
    {
        m_domainRange->m_doYrange = true;
        m_domainRange->m_ymin     = ymin;
        m_domainRange->m_ymax     = ymax;
    }
 
    if (zmin == NekConstants::kNekUnsetDouble)
    {
        m_domainRange->m_doZrange = false;
    }
    else
    {
        m_domainRange->m_doZrange = true;
        m_domainRange->m_zmin     = zmin;
        m_domainRange->m_zmax     = zmax;
    }
}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::NekConstants::kNekUnsetDouble, m_domainRange, and Nektar::LibUtilities::NullDomainRangeShPtr.

SetExpansionInfo() [1/3]

void Nektar::SpatialDomains::MeshGraph::SetExpansionInfo ( const std::string  variable, ExpansionInfoMapShPtr &  exp  )

inline

Definition at line 572 of file MeshGraph.h.

{
    if (m_expansionMapShPtrMap.count(variable) != 0)
    {
        ASSERTL0(
            false,
            (std::string("ExpansionInfo field is already set for variable ") +
             variable)
                .c_str());
    }
    else
    {
        m_expansionMapShPtrMap[variable] = exp;
    }
}

References ASSERTL0, and m_expansionMapShPtrMap.

SetExpansionInfo() [2/3]

void Nektar::SpatialDomains::MeshGraph::SetExpansionInfo

(

std::vector< LibUtilities::FieldDefinitionsSharedPtr > &

fielddef

)

Sets expansions given field definitions.

Definition at line 706 of file MeshGraph.cpp.

{
    int i, j, k, cnt, id;
    GeometrySharedPtr geom;
 
    ExpansionInfoMapShPtr expansionMap;
 
    // Loop over fields and determine unique fields string and
    // declare whole expansion list
    for (i = 0; i < fielddef.size(); ++i)
    {
        for (j = 0; j < fielddef[i]->m_fields.size(); ++j)
        {
            std::string field = fielddef[i]->m_fields[j];
            if (m_expansionMapShPtrMap.count(field) == 0)
            {
                expansionMap                  = SetUpExpansionInfoMap();
                m_expansionMapShPtrMap[field] = expansionMap;
 
                // check to see if DefaultVar also not set and
                // if so assign it to this expansion
                if (m_expansionMapShPtrMap.count("DefaultVar") == 0)
                {
                    m_expansionMapShPtrMap["DefaultVar"] = expansionMap;
                }
            }
        }
    }
 
    // loop over all elements find the geometry shared ptr and
    // set up basiskey vector
    for (i = 0; i < fielddef.size(); ++i)
    {
        cnt                                        = 0;
        std::vector<std::string> fields            = fielddef[i]->m_fields;
        std::vector<unsigned int> nmodes           = fielddef[i]->m_numModes;
        std::vector<LibUtilities::BasisType> basis = fielddef[i]->m_basis;
        bool pointDef                              = fielddef[i]->m_pointsDef;
        bool numPointDef = fielddef[i]->m_numPointsDef;
 
        // Check points and numpoints
        std::vector<unsigned int> npoints            = fielddef[i]->m_numPoints;
        std::vector<LibUtilities::PointsType> points = fielddef[i]->m_points;
 
        bool UniOrder = fielddef[i]->m_uniOrder;
 
        for (j = 0; j < fielddef[i]->m_elementIDs.size(); ++j)
        {
 
            LibUtilities::BasisKeyVector bkeyvec;
            id = fielddef[i]->m_elementIDs[j];
 
            switch (fielddef[i]->m_shapeType)
            {
                case LibUtilities::eSegment:
                {
                    if (m_segGeoms.count(fielddef[i]->m_elementIDs[j]) == 0)
                    {
                        // skip element likely from parallel read
                        if (!UniOrder)
                        {
                            cnt++;
                            cnt += fielddef[i]->m_numHomogeneousDir;
                        }
                        continue;
                    }
                    geom = m_segGeoms[fielddef[i]->m_elementIDs[j]];
 
                    LibUtilities::PointsKey pkey(
                        nmodes[cnt] + 1, LibUtilities::eGaussLobattoLegendre);
 
                    if (numPointDef && pointDef)
                    {
                        const LibUtilities::PointsKey pkey1(npoints[cnt],
                                                            points[0]);
                        pkey = pkey1;
                    }
                    else if (!numPointDef && pointDef)
                    {
                        const LibUtilities::PointsKey pkey1(nmodes[cnt] + 1,
                                                            points[0]);
                        pkey = pkey1;
                    }
                    else if (numPointDef && !pointDef)
                    {
                        const LibUtilities::PointsKey pkey1(
                            npoints[cnt], LibUtilities::eGaussLobattoLegendre);
                        pkey = pkey1;
                    }
 
                    LibUtilities::BasisKey bkey(basis[0], nmodes[cnt], pkey);
 
                    if (!UniOrder)
                    {
                        cnt++;
                        cnt += fielddef[i]->m_numHomogeneousDir;
                    }
                    bkeyvec.push_back(bkey);
                }
                break;
                case LibUtilities::eTriangle:
                {
                    if (m_triGeoms.count(fielddef[i]->m_elementIDs[j]) == 0)
                    {
                        // skip element likely from parallel read
                        if (!UniOrder)
                        {
                            cnt += 2;
                            cnt += fielddef[i]->m_numHomogeneousDir;
                        }
                        continue;
                    }
                    geom = m_triGeoms[fielddef[i]->m_elementIDs[j]];
 
                    LibUtilities::PointsKey pkey(
                        nmodes[cnt] + 1, LibUtilities::eGaussLobattoLegendre);
                    if (numPointDef && pointDef)
                    {
                        const LibUtilities::PointsKey pkey2(npoints[cnt],
                                                            points[0]);
                        pkey = pkey2;
                    }
                    else if (!numPointDef && pointDef)
                    {
                        const LibUtilities::PointsKey pkey2(nmodes[cnt] + 1,
                                                            points[0]);
                        pkey = pkey2;
                    }
                    else if (numPointDef && !pointDef)
                    {
                        const LibUtilities::PointsKey pkey2(
                            npoints[cnt], LibUtilities::eGaussLobattoLegendre);
                        pkey = pkey2;
                    }
                    LibUtilities::BasisKey bkey(basis[0], nmodes[cnt], pkey);
 
                    bkeyvec.push_back(bkey);
 
                    LibUtilities::PointsKey pkey1(
                        nmodes[cnt + 1], LibUtilities::eGaussRadauMAlpha1Beta0);
                    if (numPointDef && pointDef)
                    {
                        const LibUtilities::PointsKey pkey2(npoints[cnt + 1],
                                                            points[1]);
                        pkey1 = pkey2;
                    }
                    else if (!numPointDef && pointDef)
                    {
                        const LibUtilities::PointsKey pkey2(nmodes[cnt + 1],
                                                            points[1]);
                        pkey1 = pkey2;
                    }
                    else if (numPointDef && !pointDef)
                    {
                        const LibUtilities::PointsKey pkey2(
                            npoints[cnt + 1],
                            LibUtilities::eGaussRadauMAlpha1Beta0);
                        pkey1 = pkey2;
                    }
                    LibUtilities::BasisKey bkey1(basis[1], nmodes[cnt + 1],
                                                 pkey1);
                    bkeyvec.push_back(bkey1);
 
                    if (!UniOrder)
                    {
                        cnt += 2;
                        cnt += fielddef[i]->m_numHomogeneousDir;
                    }
                }
                break;
                case LibUtilities::eQuadrilateral:
                {
                    if (m_quadGeoms.count(fielddef[i]->m_elementIDs[j]) == 0)
                    {
                        // skip element likely from parallel read
                        if (!UniOrder)
                        {
                            cnt += 2;
                            cnt += fielddef[i]->m_numHomogeneousDir;
                        }
                        continue;
                    }
 
                    geom = m_quadGeoms[fielddef[i]->m_elementIDs[j]];
 
                    for (int b = 0; b < 2; ++b)
                    {
                        LibUtilities::PointsKey pkey(
                            nmodes[cnt + b] + 1,
                            LibUtilities::eGaussLobattoLegendre);
 
                        if (numPointDef && pointDef)
                        {
                            const LibUtilities::PointsKey pkey2(
                                npoints[cnt + b], points[b]);
                            pkey = pkey2;
                        }
                        else if (!numPointDef && pointDef)
                        {
                            const LibUtilities::PointsKey pkey2(
                                nmodes[cnt + b] + 1, points[b]);
                            pkey = pkey2;
                        }
                        else if (numPointDef && !pointDef)
                        {
                            const LibUtilities::PointsKey pkey2(
                                npoints[cnt + b],
                                LibUtilities::eGaussLobattoLegendre);
                            pkey = pkey2;
                        }
                        LibUtilities::BasisKey bkey(basis[b], nmodes[cnt + b],
                                                    pkey);
                        bkeyvec.push_back(bkey);
                    }
 
                    if (!UniOrder)
                    {
                        cnt += 2;
                        cnt += fielddef[i]->m_numHomogeneousDir;
                    }
                }
                break;
 
                case LibUtilities::eTetrahedron:
                {
                    k = fielddef[i]->m_elementIDs[j];
 
                    // allow for possibility that fielddef is
                    // larger than m_graph which can happen in
                    // parallel runs
                    if (m_tetGeoms.count(k) == 0)
                    {
                        if (!UniOrder)
                        {
                            cnt += 3;
                        }
                        continue;
                    }
                    geom = m_tetGeoms[k];
 
                    {
                        LibUtilities::PointsKey pkey(
                            nmodes[cnt] + 1,
                            LibUtilities::eGaussLobattoLegendre);
 
                        if (numPointDef && pointDef)
                        {
                            const LibUtilities::PointsKey pkey2(npoints[cnt],
                                                                points[0]);
                            pkey = pkey2;
                        }
                        else if (!numPointDef && pointDef)
                        {
                            const LibUtilities::PointsKey pkey2(nmodes[cnt] + 1,
                                                                points[0]);
                            pkey = pkey2;
                        }
                        else if (numPointDef && !pointDef)
                        {
                            const LibUtilities::PointsKey pkey2(
                                npoints[cnt],
                                LibUtilities::eGaussLobattoLegendre);
                            pkey = pkey2;
                        }
 
                        LibUtilities::BasisKey bkey(basis[0], nmodes[cnt],
                                                    pkey);
 
                        bkeyvec.push_back(bkey);
                    }
                    {
                        LibUtilities::PointsKey pkey(
                            nmodes[cnt + 1],
                            LibUtilities::eGaussRadauMAlpha1Beta0);
 
                        if (numPointDef && pointDef)
                        {
                            const LibUtilities::PointsKey pkey2(
                                npoints[cnt + 1], points[1]);
                            pkey = pkey2;
                        }
                        else if (!numPointDef && pointDef)
                        {
                            const LibUtilities::PointsKey pkey2(
                                nmodes[cnt + 1] + 1, points[1]);
                            pkey = pkey2;
                        }
                        else if (numPointDef && !pointDef)
                        {
                            const LibUtilities::PointsKey pkey2(
                                npoints[cnt + 1],
                                LibUtilities::eGaussRadauMAlpha1Beta0);
                            pkey = pkey2;
                        }
 
                        LibUtilities::BasisKey bkey(basis[1], nmodes[cnt + 1],
                                                    pkey);
 
                        bkeyvec.push_back(bkey);
                    }
 
                    {
                        LibUtilities::PointsKey pkey(
                            nmodes[cnt + 2],
                            LibUtilities::eGaussRadauMAlpha2Beta0);
 
                        if (numPointDef && pointDef)
                        {
                            const LibUtilities::PointsKey pkey2(
                                npoints[cnt + 2], points[2]);
                            pkey = pkey2;
                        }
                        else if (!numPointDef && pointDef)
                        {
                            const LibUtilities::PointsKey pkey2(
                                nmodes[cnt + 2] + 1, points[2]);
                            pkey = pkey2;
                        }
                        else if (numPointDef && !pointDef)
                        {
                            const LibUtilities::PointsKey pkey2(
                                npoints[cnt + 2],
                                LibUtilities::eGaussRadauMAlpha1Beta0);
                            pkey = pkey2;
                        }
 
                        LibUtilities::BasisKey bkey(basis[2], nmodes[cnt + 2],
                                                    pkey);
 
                        bkeyvec.push_back(bkey);
                    }
 
                    if (!UniOrder)
                    {
                        cnt += 3;
                    }
                }
                break;
                case LibUtilities::ePrism:
                {
                    k = fielddef[i]->m_elementIDs[j];
                    if (m_prismGeoms.count(k) == 0)
                    {
                        if (!UniOrder)
                        {
                            cnt += 3;
                        }
                        continue;
                    }
                    geom = m_prismGeoms[k];
 
                    for (int b = 0; b < 2; ++b)
                    {
                        LibUtilities::PointsKey pkey(
                            nmodes[cnt + b] + 1,
                            LibUtilities::eGaussLobattoLegendre);
 
                        if (numPointDef && pointDef)
                        {
                            const LibUtilities::PointsKey pkey2(
                                npoints[cnt + b], points[b]);
                            pkey = pkey2;
                        }
                        else if (!numPointDef && pointDef)
                        {
                            const LibUtilities::PointsKey pkey2(
                                nmodes[cnt + b] + 1, points[b]);
                            pkey = pkey2;
                        }
                        else if (numPointDef && !pointDef)
                        {
                            const LibUtilities::PointsKey pkey2(
                                npoints[cnt + b],
                                LibUtilities::eGaussLobattoLegendre);
                            pkey = pkey2;
                        }
 
                        LibUtilities::BasisKey bkey(basis[b], nmodes[cnt + b],
                                                    pkey);
                        bkeyvec.push_back(bkey);
                    }
 
                    {
                        LibUtilities::PointsKey pkey(
                            nmodes[cnt + 2],
                            LibUtilities::eGaussRadauMAlpha1Beta0);
 
                        if (numPointDef && pointDef)
                        {
                            const LibUtilities::PointsKey pkey2(
                                npoints[cnt + 2], points[2]);
                            pkey = pkey2;
                        }
                        else if (!numPointDef && pointDef)
                        {
                            const LibUtilities::PointsKey pkey2(
                                nmodes[cnt + 2] + 1, points[2]);
                            pkey = pkey2;
                        }
                        else if (numPointDef && !pointDef)
                        {
                            const LibUtilities::PointsKey pkey2(
                                npoints[cnt + 2],
                                LibUtilities::eGaussLobattoLegendre);
                            pkey = pkey2;
                        }
 
                        LibUtilities::BasisKey bkey(basis[2], nmodes[cnt + 2],
                                                    pkey);
                        bkeyvec.push_back(bkey);
                    }
 
                    if (!UniOrder)
                    {
                        cnt += 3;
                    }
                }
                break;
                case LibUtilities::ePyramid:
                {
                    k = fielddef[i]->m_elementIDs[j];
                    ASSERTL0(m_pyrGeoms.find(k) != m_pyrGeoms.end(),
                             "Failed to find geometry with same global id");
                    geom = m_pyrGeoms[k];
 
                    for (int b = 0; b < 2; ++b)
                    {
                        LibUtilities::PointsKey pkey(
                            nmodes[cnt + b] + 1,
                            LibUtilities::eGaussLobattoLegendre);
 
                        if (numPointDef && pointDef)
                        {
                            const LibUtilities::PointsKey pkey2(
                                npoints[cnt + b], points[b]);
                            pkey = pkey2;
                        }
                        else if (!numPointDef && pointDef)
                        {
                            const LibUtilities::PointsKey pkey2(
                                nmodes[cnt + b] + 1, points[b]);
                            pkey = pkey2;
                        }
                        else if (numPointDef && !pointDef)
                        {
                            const LibUtilities::PointsKey pkey2(
                                npoints[cnt + b],
                                LibUtilities::eGaussLobattoLegendre);
                            pkey = pkey2;
                        }
 
                        LibUtilities::BasisKey bkey(basis[b], nmodes[cnt + b],
                                                    pkey);
                        bkeyvec.push_back(bkey);
                    }
 
                    {
                        LibUtilities::PointsKey pkey(
                            nmodes[cnt + 2],
                            LibUtilities::eGaussRadauMAlpha2Beta0);
 
                        if (numPointDef && pointDef)
                        {
                            const LibUtilities::PointsKey pkey2(
                                npoints[cnt + 2], points[2]);
                            pkey = pkey2;
                        }
                        else if (!numPointDef && pointDef)
                        {
                            const LibUtilities::PointsKey pkey2(
                                nmodes[cnt + 2] + 1, points[2]);
                            pkey = pkey2;
                        }
                        else if (numPointDef && !pointDef)
                        {
                            const LibUtilities::PointsKey pkey2(
                                npoints[cnt + 2],
                                LibUtilities::eGaussLobattoLegendre);
                            pkey = pkey2;
                        }
 
                        LibUtilities::BasisKey bkey(basis[2], nmodes[cnt + 2],
                                                    pkey);
                        bkeyvec.push_back(bkey);
                    }
 
                    if (!UniOrder)
                    {
                        cnt += 3;
                    }
                }
                break;
                case LibUtilities::eHexahedron:
                {
                    k = fielddef[i]->m_elementIDs[j];
                    if (m_hexGeoms.count(k) == 0)
                    {
                        if (!UniOrder)
                        {
                            cnt += 3;
                        }
                        continue;
                    }
 
                    geom = m_hexGeoms[k];
 
                    for (int b = 0; b < 3; ++b)
                    {
                        LibUtilities::PointsKey pkey(
                            nmodes[cnt + b],
                            LibUtilities::eGaussLobattoLegendre);
 
                        if (numPointDef && pointDef)
                        {
                            const LibUtilities::PointsKey pkey2(
                                npoints[cnt + b], points[b]);
                            pkey = pkey2;
                        }
                        else if (!numPointDef && pointDef)
                        {
                            const LibUtilities::PointsKey pkey2(
                                nmodes[cnt + b] + 1, points[b]);
                            pkey = pkey2;
                        }
                        else if (numPointDef && !pointDef)
                        {
                            const LibUtilities::PointsKey pkey2(
                                npoints[cnt + b],
                                LibUtilities::eGaussLobattoLegendre);
                            pkey = pkey2;
                        }
 
                        LibUtilities::BasisKey bkey(basis[b], nmodes[cnt + b],
                                                    pkey);
                        bkeyvec.push_back(bkey);
                    }
 
                    if (!UniOrder)
                    {
                        cnt += 3;
                    }
                }
                break;
                default:
                    ASSERTL0(false, "Need to set up for pyramid and prism 3D "
                                    "ExpansionInfo");
                    break;
            }
 
            for (k = 0; k < fields.size(); ++k)
            {
                expansionMap = m_expansionMapShPtrMap.find(fields[k])->second;
                if ((*expansionMap).find(id) != (*expansionMap).end())
                {
                    (*expansionMap)[id]->m_geomShPtr      = geom;
                    (*expansionMap)[id]->m_basisKeyVector = bkeyvec;
                }
            }
        }
    }
}

References ASSERTL0, Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eHexahedron, Nektar::LibUtilities::ePrism, Nektar::LibUtilities::ePyramid, Nektar::LibUtilities::eQuadrilateral, Nektar::LibUtilities::eSegment, Nektar::LibUtilities::eTetrahedron, Nektar::LibUtilities::eTriangle, FilterPython_Function::field, m_expansionMapShPtrMap, m_hexGeoms, m_prismGeoms, m_pyrGeoms, m_quadGeoms, m_segGeoms, m_tetGeoms, m_triGeoms, and SetUpExpansionInfoMap().

Referenced by ReadExpansionInfo().

SetExpansionInfo() [3/3]

void Nektar::SpatialDomains::MeshGraph::SetExpansionInfo	(	std::vector< LibUtilities::FieldDefinitionsSharedPtr > &	fielddef,
		std::vector< std::vector< LibUtilities::PointsType > > &	pointstype
	)

Sets expansions given field definition, quadrature points.

Definition at line 1272 of file MeshGraph.cpp.

{
    int i, j, k, cnt, id;
    GeometrySharedPtr geom;
 
    ExpansionInfoMapShPtr expansionMap;
 
    // Loop over fields and determine unique fields string and
    // declare whole expansion list
    for (i = 0; i < fielddef.size(); ++i)
    {
        for (j = 0; j < fielddef[i]->m_fields.size(); ++j)
        {
            std::string field = fielddef[i]->m_fields[j];
            if (m_expansionMapShPtrMap.count(field) == 0)
            {
                expansionMap                  = SetUpExpansionInfoMap();
                m_expansionMapShPtrMap[field] = expansionMap;
 
                // check to see if DefaultVar also not set and
                // if so assign it to this expansion
                if (m_expansionMapShPtrMap.count("DefaultVar") == 0)
                {
                    m_expansionMapShPtrMap["DefaultVar"] = expansionMap;
                }
            }
        }
    }
 
    // loop over all elements find the geometry shared ptr and
    // set up basiskey vector
    for (i = 0; i < fielddef.size(); ++i)
    {
        cnt                                        = 0;
        std::vector<std::string> fields            = fielddef[i]->m_fields;
        std::vector<unsigned int> nmodes           = fielddef[i]->m_numModes;
        std::vector<LibUtilities::BasisType> basis = fielddef[i]->m_basis;
        bool UniOrder                              = fielddef[i]->m_uniOrder;
 
        for (j = 0; j < fielddef[i]->m_elementIDs.size(); ++j)
        {
            LibUtilities::BasisKeyVector bkeyvec;
            id = fielddef[i]->m_elementIDs[j];
 
            switch (fielddef[i]->m_shapeType)
            {
                case LibUtilities::eSegment:
                {
                    k = fielddef[i]->m_elementIDs[j];
                    ASSERTL0(m_segGeoms.find(k) != m_segGeoms.end(),
                             "Failed to find geometry with same global id.");
                    geom = m_segGeoms[k];
 
                    const LibUtilities::PointsKey pkey(nmodes[cnt],
                                                       pointstype[i][0]);
                    LibUtilities::BasisKey bkey(basis[0], nmodes[cnt], pkey);
                    if (!UniOrder)
                    {
                        cnt++;
                        cnt += fielddef[i]->m_numHomogeneousDir;
                    }
                    bkeyvec.push_back(bkey);
                }
                break;
                case LibUtilities::eTriangle:
                {
                    k = fielddef[i]->m_elementIDs[j];
                    ASSERTL0(m_triGeoms.find(k) != m_triGeoms.end(),
                             "Failed to find geometry with same global id.");
                    geom = m_triGeoms[k];
                    for (int b = 0; b < 2; ++b)
                    {
                        const LibUtilities::PointsKey pkey(nmodes[cnt + b],
                                                           pointstype[i][b]);
                        LibUtilities::BasisKey bkey(basis[b], nmodes[cnt + b],
                                                    pkey);
                        bkeyvec.push_back(bkey);
                    }
 
                    if (!UniOrder)
                    {
                        cnt += 2;
                        cnt += fielddef[i]->m_numHomogeneousDir;
                    }
                }
                break;
                case LibUtilities::eQuadrilateral:
                {
                    k = fielddef[i]->m_elementIDs[j];
                    ASSERTL0(m_quadGeoms.find(k) != m_quadGeoms.end(),
                             "Failed to find geometry with same global id");
                    geom = m_quadGeoms[k];
 
                    for (int b = 0; b < 2; ++b)
                    {
                        const LibUtilities::PointsKey pkey(nmodes[cnt + b],
                                                           pointstype[i][b]);
                        LibUtilities::BasisKey bkey(basis[b], nmodes[cnt + b],
                                                    pkey);
                        bkeyvec.push_back(bkey);
                    }
 
                    if (!UniOrder)
                    {
                        cnt += 2;
                        cnt += fielddef[i]->m_numHomogeneousDir;
                    }
                }
                break;
                case LibUtilities::eTetrahedron:
                {
                    k = fielddef[i]->m_elementIDs[j];
                    ASSERTL0(m_tetGeoms.find(k) != m_tetGeoms.end(),
                             "Failed to find geometry with same global id");
                    geom = m_tetGeoms[k];
 
                    for (int b = 0; b < 3; ++b)
                    {
                        const LibUtilities::PointsKey pkey(nmodes[cnt + b],
                                                           pointstype[i][b]);
                        LibUtilities::BasisKey bkey(basis[b], nmodes[cnt + b],
                                                    pkey);
                        bkeyvec.push_back(bkey);
                    }
 
                    if (!UniOrder)
                    {
                        cnt += 3;
                    }
                }
                break;
                case LibUtilities::ePyramid:
                {
                    k = fielddef[i]->m_elementIDs[j];
                    ASSERTL0(m_pyrGeoms.find(k) != m_pyrGeoms.end(),
                             "Failed to find geometry with same global id");
                    geom = m_pyrGeoms[k];
 
                    for (int b = 0; b < 3; ++b)
                    {
                        const LibUtilities::PointsKey pkey(nmodes[cnt + b],
                                                           pointstype[i][b]);
                        LibUtilities::BasisKey bkey(basis[b], nmodes[cnt + b],
                                                    pkey);
                        bkeyvec.push_back(bkey);
                    }
 
                    if (!UniOrder)
                    {
                        cnt += 3;
                    }
                }
                break;
                case LibUtilities::ePrism:
                {
                    k = fielddef[i]->m_elementIDs[j];
                    ASSERTL0(m_prismGeoms.find(k) != m_prismGeoms.end(),
                             "Failed to find geometry with same global id");
                    geom = m_prismGeoms[k];
 
                    for (int b = 0; b < 3; ++b)
                    {
                        const LibUtilities::PointsKey pkey(nmodes[cnt + b],
                                                           pointstype[i][b]);
                        LibUtilities::BasisKey bkey(basis[b], nmodes[cnt + b],
                                                    pkey);
                        bkeyvec.push_back(bkey);
                    }
 
                    if (!UniOrder)
                    {
                        cnt += 3;
                    }
                }
                break;
                case LibUtilities::eHexahedron:
                {
                    k = fielddef[i]->m_elementIDs[j];
                    ASSERTL0(m_hexGeoms.find(k) != m_hexGeoms.end(),
                             "Failed to find geometry with same global id");
                    geom = m_hexGeoms[k];
 
                    for (int b = 0; b < 3; ++b)
                    {
                        const LibUtilities::PointsKey pkey(nmodes[cnt + b],
                                                           pointstype[i][b]);
                        LibUtilities::BasisKey bkey(basis[b], nmodes[cnt + b],
                                                    pkey);
                        bkeyvec.push_back(bkey);
                    }
 
                    if (!UniOrder)
                    {
                        cnt += 3;
                    }
                }
                break;
                default:
                    ASSERTL0(false, "Need to set up for pyramid and prism 3D "
                                    "ExpansionInfo");
                    break;
            }
 
            for (k = 0; k < fields.size(); ++k)
            {
                expansionMap = m_expansionMapShPtrMap.find(fields[k])->second;
                if ((*expansionMap).find(id) != (*expansionMap).end())
                {
                    (*expansionMap)[id]->m_geomShPtr      = geom;
                    (*expansionMap)[id]->m_basisKeyVector = bkeyvec;
                }
            }
        }
    }
}

References ASSERTL0, Nektar::LibUtilities::eHexahedron, Nektar::LibUtilities::ePrism, Nektar::LibUtilities::ePyramid, Nektar::LibUtilities::eQuadrilateral, Nektar::LibUtilities::eSegment, Nektar::LibUtilities::eTetrahedron, Nektar::LibUtilities::eTriangle, FilterPython_Function::field, m_expansionMapShPtrMap, m_hexGeoms, m_prismGeoms, m_pyrGeoms, m_quadGeoms, m_segGeoms, m_tetGeoms, m_triGeoms, and SetUpExpansionInfoMap().

SetExpansionInfoToEvenlySpacedPoints()

void Nektar::SpatialDomains::MeshGraph::SetExpansionInfoToEvenlySpacedPoints

(

int

npoints = 0

)

Sets expansions to have equispaced points.

Reset all points keys to have equispaced points with optional arguemt of npoints which redefines how many points are to be used.

Definition at line 1495 of file MeshGraph.cpp.

{
    // iterate over all defined expansions
    for (auto it = m_expansionMapShPtrMap.begin();
         it != m_expansionMapShPtrMap.end(); ++it)
    {
        for (auto expIt = it->second->begin(); expIt != it->second->end();
             ++expIt)
        {
            for (int i = 0; i < expIt->second->m_basisKeyVector.size(); ++i)
            {
                LibUtilities::BasisKey bkeyold =
                    expIt->second->m_basisKeyVector[i];
 
                int npts;
 
                if (npoints) // use input
                {
                    npts = npoints;
                }
                else
                {
                    npts = bkeyold.GetNumModes();
                }
                npts = max(npts, 2);
 
                const LibUtilities::PointsKey pkey(
                    npts, LibUtilities::ePolyEvenlySpaced);
                LibUtilities::BasisKey bkeynew(bkeyold.GetBasisType(),
                                               bkeyold.GetNumModes(), pkey);
                expIt->second->m_basisKeyVector[i] = bkeynew;
            }
        }
    }
}

References Nektar::LibUtilities::ePolyEvenlySpaced, Nektar::LibUtilities::BasisKey::GetBasisType(), Nektar::LibUtilities::BasisKey::GetNumModes(), and m_expansionMapShPtrMap.

SetExpansionInfoToNumModes()

void Nektar::SpatialDomains::MeshGraph::SetExpansionInfoToNumModes

(

int

nmodes

)

Reset expansion to have specified polynomial order nmodes.

Reset all points keys to have expansion order of nmodes. we keep the point distribution the same and make the number of points the same difference from the number of modes as the original expansion definition.

Definition at line 1537 of file MeshGraph.cpp.

{
    // iterate over all defined expansions
    for (auto it = m_expansionMapShPtrMap.begin();
         it != m_expansionMapShPtrMap.end(); ++it)
    {
        for (auto expIt = it->second->begin(); expIt != it->second->end();
             ++expIt)
        {
            for (int i = 0; i < expIt->second->m_basisKeyVector.size(); ++i)
            {
                LibUtilities::BasisKey bkeyold =
                    expIt->second->m_basisKeyVector[i];
 
                int npts =
                    nmodes + (bkeyold.GetNumPoints() - bkeyold.GetNumModes());
 
                const LibUtilities::PointsKey pkey(npts,
                                                   bkeyold.GetPointsType());
                LibUtilities::BasisKey bkeynew(bkeyold.GetBasisType(), nmodes,
                                               pkey);
                expIt->second->m_basisKeyVector[i] = bkeynew;
            }
        }
    }
}

References Nektar::LibUtilities::BasisKey::GetBasisType(), Nektar::LibUtilities::BasisKey::GetNumModes(), Nektar::LibUtilities::BasisKey::GetNumPoints(), Nektar::LibUtilities::BasisKey::GetPointsType(), and m_expansionMapShPtrMap.

SetExpansionInfoToPointOrder()

void Nektar::SpatialDomains::MeshGraph::SetExpansionInfoToPointOrder

(

int

npts

)

Reset expansion to have specified point order npts.

Reset all points keys to have expansion order of nmodes. we keep the point distribution the same and make the number of points the same difference from the number of modes as the original expansion definition.

Definition at line 1570 of file MeshGraph.cpp.

{
    // iterate over all defined expansions
    for (auto it = m_expansionMapShPtrMap.begin();
         it != m_expansionMapShPtrMap.end(); ++it)
    {
        for (auto expIt = it->second->begin(); expIt != it->second->end();
             ++expIt)
        {
            for (int i = 0; i < expIt->second->m_basisKeyVector.size(); ++i)
            {
                LibUtilities::BasisKey bkeyold =
                    expIt->second->m_basisKeyVector[i];
 
                const LibUtilities::PointsKey pkey(npts,
                                                   bkeyold.GetPointsType());
 
                LibUtilities::BasisKey bkeynew(bkeyold.GetBasisType(),
                                               bkeyold.GetNumModes(), pkey);
                expIt->second->m_basisKeyVector[i] = bkeynew;
            }
        }
    }
}

References Nektar::LibUtilities::BasisKey::GetBasisType(), Nektar::LibUtilities::BasisKey::GetNumModes(), Nektar::LibUtilities::BasisKey::GetPointsType(), and m_expansionMapShPtrMap.

SetPartition()

void Nektar::SpatialDomains::MeshGraph::SetPartition

(

SpatialDomains::MeshGraphSharedPtr

graph

)

Definition at line 179 of file MeshGraph.cpp.

{
    m_meshPartitioned = true;
 
    m_meshDimension  = graph->GetMeshDimension();
    m_spaceDimension = graph->GetSpaceDimension();
 
    m_vertSet     = graph->GetAllPointGeoms();
    m_curvedFaces = graph->GetCurvedFaces();
    m_curvedEdges = graph->GetCurvedEdges();
 
    m_segGeoms   = graph->GetAllSegGeoms();
    m_triGeoms   = graph->GetAllTriGeoms();
    m_quadGeoms  = graph->GetAllQuadGeoms();
    m_hexGeoms   = graph->GetAllHexGeoms();
    m_prismGeoms = graph->GetAllPrismGeoms();
    m_pyrGeoms   = graph->GetAllPyrGeoms();
    m_tetGeoms   = graph->GetAllTetGeoms();
 
    m_faceToElMap = graph->GetAllFaceToElMap();
}

References m_curvedEdges, m_curvedFaces, m_faceToElMap, m_hexGeoms, m_meshDimension, m_meshPartitioned, m_prismGeoms, m_pyrGeoms, m_quadGeoms, m_segGeoms, m_spaceDimension, m_tetGeoms, m_triGeoms, and m_vertSet.

SetRefinementInfo()

void Nektar::SpatialDomains::MeshGraph::SetRefinementInfo

(

ExpansionInfoMapShPtr &

expansionMap

)

This function sets the expansion #exp in map with entry #variable.

Set the refinement information. This function selects the composites and the corresponding surface regions that must be used to refine the elements.

Set refinement info.

Parameters

expansionMap

shared pointer for the ExpansionInfoMap

Definition at line 2731 of file MeshGraph.cpp.

{
    // Loop over the refinement ids
    for (auto pRefinement = m_refComposite.begin();
         pRefinement != m_refComposite.end(); ++pRefinement)
    {
        // For each refinement id, there might be more than one composite,
        // since each refinement id can be related to more than one
        // composite.
        for (auto compVecIter = pRefinement->second.begin();
             compVecIter != pRefinement->second.end(); ++compVecIter)
        {
            for (auto geomVecIter = compVecIter->second->m_geomVec.begin();
                 geomVecIter != compVecIter->second->m_geomVec.end();
                 ++geomVecIter)
            {
                // Loop over the refinements provided by the user storage
                // in the m_refRegion in order to provide the correct
                // refinement region data to PRefinementElmts function.
                for (auto region = m_refRegion.begin();
                     region != m_refRegion.end(); ++region)
                {
                    // Check if the refID are the same in order to refine
                    // the region.
                    if (region->first == pRefinement->first)
                    {
                        // The geomVecIter corresponds the geometry information
                        // of the composite to be refined.
                        PRefinementElmts(expansionMap, region->second,
                                         *geomVecIter);
                    }
                }
            }
        }
    }
}

References m_refComposite, m_refRegion, and PRefinementElmts().

Referenced by ReadExpansionInfo().

SetSession()

void Nektar::SpatialDomains::MeshGraph::SetSession ( LibUtilities::SessionReaderSharedPtr  pSession )

inline

SetUpExpansionInfoMap()

ExpansionInfoMapShPtr Nektar::SpatialDomains::MeshGraph::SetUpExpansionInfoMap ( void  )

protected

Generate a single vector of ExpansionInfo structs mapping global element ID to a corresponding Geometry shared pointer and basis key.

ExpansionInfo map ensures elements which appear in multiple composites within the domain are only listed once.

Definition at line 2581 of file MeshGraph.cpp.

{
    ExpansionInfoMapShPtr returnval;
    returnval = MemoryManager<ExpansionInfoMap>::AllocateSharedPtr();
 
    for (auto &d : m_domain)
    {
        for (auto &compIter : d.second)
        {
            // regular elements first
            for (auto &x : compIter.second->m_geomVec)
            {
                if (x->GetGeomFactors()->GetGtype() !=
                    SpatialDomains::eDeformed)
                {
                    LibUtilities::BasisKeyVector def;
                    ExpansionInfoShPtr expansionElementShPtr =
                        MemoryManager<ExpansionInfo>::AllocateSharedPtr(x, def);
                    int id           = x->GetGlobalID();
                    (*returnval)[id] = expansionElementShPtr;
                }
            }
            // deformed elements
            for (auto &x : compIter.second->m_geomVec)
            {
                if (x->GetGeomFactors()->GetGtype() ==
                    SpatialDomains::eDeformed)
                {
                    LibUtilities::BasisKeyVector def;
                    ExpansionInfoShPtr expansionElementShPtr =
                        MemoryManager<ExpansionInfo>::AllocateSharedPtr(x, def);
                    int id           = x->GetGlobalID();
                    (*returnval)[id] = expansionElementShPtr;
                }
            }
        }
    }
 
    return returnval;
}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::UnitTests::d(), Nektar::SpatialDomains::eDeformed, and m_domain.

Referenced by ReadExpansionInfo(), and SetExpansionInfo().

v_PartitionMesh()

virtual void Nektar::SpatialDomains::MeshGraph::v_PartitionMesh ( LibUtilities::SessionReaderSharedPtr  session )

protectedpure virtual

Implemented in Nektar::SpatialDomains::MeshGraphHDF5, and Nektar::SpatialDomains::MeshGraphXml.

Referenced by PartitionMesh().

v_ReadGeometry()

virtual void Nektar::SpatialDomains::MeshGraph::v_ReadGeometry ( LibUtilities::DomainRangeShPtr  rng, bool  fillGraph  )

protectedpure virtual

Implemented in Nektar::SpatialDomains::MeshGraphHDF5, and Nektar::SpatialDomains::MeshGraphXml.

Referenced by ReadGeometry().

v_WriteGeometry()

virtual void Nektar::SpatialDomains::MeshGraph::v_WriteGeometry ( const std::string &  outfilename, bool  defaultExp = false, const LibUtilities::FieldMetaDataMap &  metadata = LibUtilities::NullFieldMetaDataMap  )

protectedpure virtual

Implemented in Nektar::SpatialDomains::MeshGraphHDF5, and Nektar::SpatialDomains::MeshGraphXml.

Referenced by WriteGeometry().

WriteGeometry()

void Nektar::SpatialDomains::MeshGraph::WriteGeometry ( const std::string &  outfilename, bool  defaultExp = false, const LibUtilities::FieldMetaDataMap &  metadata = LibUtilities::NullFieldMetaDataMap  )

inline

Definition at line 544 of file MeshGraph.h.

{
    v_WriteGeometry(outfilename, defaultExp, metadata);
}

References v_WriteGeometry().

Member Data Documentation

m_bndRegOrder

BndRegionOrdering Nektar::SpatialDomains::MeshGraph::m_bndRegOrder

protected

Definition at line 530 of file MeshGraph.h.

Referenced by GetBndRegionOrdering(), SetBndRegionOrdering(), Nektar::SpatialDomains::MeshGraphHDF5::v_PartitionMesh(), Nektar::SpatialDomains::MeshGraphXml::v_PartitionMesh(), and Nektar::SpatialDomains::MeshGraphXml::WriteXMLGeometry().

m_boundingBoxTree

std::unique_ptr<GeomRTree> Nektar::SpatialDomains::MeshGraph::m_boundingBoxTree

protected

Definition at line 533 of file MeshGraph.h.

Referenced by FillBoundingBoxTree(), GetElementsContainingPoint(), and MeshGraph().

m_compOrder

CompositeOrdering Nektar::SpatialDomains::MeshGraph::m_compOrder

protected

Definition at line 529 of file MeshGraph.h.

Referenced by GetCompositeOrdering(), Nektar::SpatialDomains::MeshGraphHDF5::ReadComposites(), SetCompositeOrdering(), and Nektar::SpatialDomains::MeshGraphXml::v_PartitionMesh().

m_compositesLabels

std::map<int, std::string> Nektar::SpatialDomains::MeshGraph::m_compositesLabels

protected

Definition at line 519 of file MeshGraph.h.

Referenced by GetCompositesLabels(), Nektar::SpatialDomains::MeshGraphXml::ReadComposites(), Nektar::SpatialDomains::MeshGraphXml::v_ReadGeometry(), Nektar::SpatialDomains::MeshGraphXml::v_WriteGeometry(), Nektar::SpatialDomains::MeshGraphXml::WriteComposites(), and Nektar::SpatialDomains::MeshGraphXml::WriteXMLGeometry().

m_curvedEdges

CurveMap Nektar::SpatialDomains::MeshGraph::m_curvedEdges

protected

Definition at line 492 of file MeshGraph.h.

Referenced by GetCurvedEdges(), SetPartition(), Nektar::SpatialDomains::MeshGraphHDF5::v_PartitionMesh(), Nektar::SpatialDomains::MeshGraphXml::v_ReadCurves(), Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadCurves(), Nektar::SpatialDomains::MeshGraphXml::v_ReadEdges(), Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadEdges(), Nektar::SpatialDomains::MeshGraphXml::v_ReadElements1D(), Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadElements1D(), Nektar::SpatialDomains::MeshGraphXml::v_ReadGeometry(), Nektar::SpatialDomains::MeshGraphHDF5::v_WriteGeometry(), Nektar::SpatialDomains::MeshGraphXml::v_WriteGeometry(), and Nektar::SpatialDomains::MeshGraphXml::WriteXMLGeometry().

m_curvedFaces

CurveMap Nektar::SpatialDomains::MeshGraph::m_curvedFaces

protected

Definition at line 493 of file MeshGraph.h.

Referenced by GetCurvedFaces(), SetPartition(), Nektar::SpatialDomains::MeshGraphHDF5::v_PartitionMesh(), Nektar::SpatialDomains::MeshGraphXml::v_ReadCurves(), Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadCurves(), Nektar::SpatialDomains::MeshGraphXml::v_ReadElements2D(), Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadElements2D(), Nektar::SpatialDomains::MeshGraphXml::v_ReadFaces(), Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadFaces(), Nektar::SpatialDomains::MeshGraphXml::v_ReadGeometry(), Nektar::SpatialDomains::MeshGraphHDF5::v_WriteGeometry(), Nektar::SpatialDomains::MeshGraphXml::v_WriteGeometry(), and Nektar::SpatialDomains::MeshGraphXml::WriteXMLGeometry().

m_domain

std::map<int, CompositeMap> Nektar::SpatialDomains::MeshGraph::m_domain

protected

Definition at line 520 of file MeshGraph.h.

Referenced by Nektar::SpatialDomains::MeshGraphXml::CreateCompositeOrdering(), GetDomain(), GetElementsFromEdge(), Nektar::SpatialDomains::MeshGraphHDF5::ReadDomain(), Nektar::SpatialDomains::MeshGraphXml::ReadDomain(), ReadExpansionInfo(), SetUpExpansionInfoMap(), Nektar::SpatialDomains::MeshGraphXml::v_ReadGeometry(), Nektar::SpatialDomains::MeshGraphHDF5::v_WriteGeometry(), Nektar::SpatialDomains::MeshGraphXml::v_WriteGeometry(), and Nektar::SpatialDomains::MeshGraphXml::WriteXMLGeometry().

m_domainRange

LibUtilities::DomainRangeShPtr Nektar::SpatialDomains::MeshGraph::m_domainRange

protected

Definition at line 521 of file MeshGraph.h.

Referenced by CheckRange(), SetDomainRange(), Nektar::SpatialDomains::MeshGraphHDF5::v_ReadGeometry(), and Nektar::SpatialDomains::MeshGraphXml::v_ReadGeometry().

m_expansionMapShPtrMap

ExpansionInfoMapShPtrMap Nektar::SpatialDomains::MeshGraph::m_expansionMapShPtrMap

protected

Definition at line 523 of file MeshGraph.h.

Referenced by ExpansionInfoDefined(), GetExpansionInfo(), ReadExpansionInfo(), SameExpansionInfo(), SetBasisKey(), SetExpansionInfo(), SetExpansionInfoToEvenlySpacedPoints(), SetExpansionInfoToNumModes(), SetExpansionInfoToPointOrder(), and Nektar::SpatialDomains::MeshGraphXml::v_ReadGeometry().

m_faceToElMap

std::unordered_map<int, GeometryLinkSharedPtr> Nektar::SpatialDomains::MeshGraph::m_faceToElMap

protected

Definition at line 525 of file MeshGraph.h.

Referenced by GetAllFaceToElMap(), GetElementsFromFace(), PopulateFaceToElMap(), SetPartition(), and Nektar::SpatialDomains::MeshGraphXml::v_ReadGeometry().

m_hexGeoms

HexGeomMap Nektar::SpatialDomains::MeshGraph::m_hexGeoms

protected

Definition at line 502 of file MeshGraph.h.

Referenced by CreateMeshEntities(), FillBoundingBoxTree(), FillGraph(), GetAllHexGeoms(), GetNumElements(), Nektar::SpatialDomains::MeshGraphHDF5::ReadComposites(), Nektar::SpatialDomains::MeshGraphXml::ResolveGeomRef3D(), SetExpansionInfo(), SetPartition(), Nektar::SpatialDomains::MeshGraphHDF5::v_PartitionMesh(), Nektar::SpatialDomains::MeshGraphXml::v_ReadElements3D(), Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadElements3D(), Nektar::SpatialDomains::MeshGraphXml::v_ReadGeometry(), Nektar::SpatialDomains::MeshGraphHDF5::v_WriteGeometry(), Nektar::SpatialDomains::MeshGraphXml::v_WriteGeometry(), and Nektar::SpatialDomains::MeshGraphXml::WriteXMLGeometry().

m_meshComposites

CompositeMap Nektar::SpatialDomains::MeshGraph::m_meshComposites

protected

Definition at line 518 of file MeshGraph.h.

Referenced by CreateCompositeDescriptor(), Nektar::SpatialDomains::MeshGraphXml::CreateCompositeOrdering(), GetComposite(), GetCompositeItem(), GetCompositeList(), GetComposites(), Nektar::SpatialDomains::MeshGraphHDF5::ReadComposites(), Nektar::SpatialDomains::MeshGraphXml::ReadComposites(), ReadExpansionInfo(), Nektar::SpatialDomains::MeshGraphXml::v_ReadGeometry(), Nektar::SpatialDomains::MeshGraphHDF5::v_WriteGeometry(), Nektar::SpatialDomains::MeshGraphXml::v_WriteGeometry(), Nektar::SpatialDomains::MeshGraphXml::WriteDefaultExpansion(), and Nektar::SpatialDomains::MeshGraphXml::WriteXMLGeometry().

m_meshDimension

int Nektar::SpatialDomains::MeshGraph::m_meshDimension

protected

Definition at line 504 of file MeshGraph.h.

Referenced by CreateMeshEntities(), Empty(), FillBoundingBoxTree(), FillGraph(), GetCompositeString(), GetMeshDimension(), GetNumElements(), Nektar::SpatialDomains::MeshGraphXml::ReadElements(), ReadRefinementInfo(), Nektar::SpatialDomains::MeshGraphXml::ResolveGeomRef(), SetPartition(), Nektar::SpatialDomains::MeshGraphHDF5::v_PartitionMesh(), Nektar::SpatialDomains::MeshGraphXml::v_PartitionMesh(), Nektar::SpatialDomains::MeshGraphXml::v_ReadCurves(), Nektar::SpatialDomains::MeshGraphXml::v_ReadGeometry(), Nektar::SpatialDomains::MeshGraphXml::v_WriteEdges(), Nektar::SpatialDomains::MeshGraphXmlCompressed::v_WriteEdges(), Nektar::SpatialDomains::MeshGraphHDF5::v_WriteGeometry(), Nektar::SpatialDomains::MeshGraphXml::v_WriteGeometry(), Nektar::SpatialDomains::MeshGraphXml::WriteDefaultExpansion(), and Nektar::SpatialDomains::MeshGraphXml::WriteXMLGeometry().

m_meshPartitioned

bool Nektar::SpatialDomains::MeshGraph::m_meshPartitioned = false

protected

Definition at line 507 of file MeshGraph.h.

Referenced by GetCompositeList(), SetPartition(), Nektar::SpatialDomains::MeshGraphHDF5::v_PartitionMesh(), and Nektar::SpatialDomains::MeshGraphXml::v_ReadGeometry().

m_movement

MovementSharedPtr Nektar::SpatialDomains::MeshGraph::m_movement

protected

Definition at line 534 of file MeshGraph.h.

Referenced by FillGraph(), GetMovement(), MeshGraph(), Nektar::SpatialDomains::MeshGraphHDF5::v_WriteGeometry(), and Nektar::SpatialDomains::MeshGraphXml::v_WriteGeometry().

m_partition

int Nektar::SpatialDomains::MeshGraph::m_partition

protected

Definition at line 506 of file MeshGraph.h.

Referenced by Nektar::SpatialDomains::MeshGraphXml::v_ReadGeometry().

m_prismGeoms

PrismGeomMap Nektar::SpatialDomains::MeshGraph::m_prismGeoms

protected

Definition at line 501 of file MeshGraph.h.

Referenced by CreateMeshEntities(), FillBoundingBoxTree(), FillGraph(), GetAllPrismGeoms(), GetNumElements(), Nektar::SpatialDomains::MeshGraphHDF5::ReadComposites(), Nektar::SpatialDomains::MeshGraphXml::ResolveGeomRef3D(), SetExpansionInfo(), SetPartition(), Nektar::SpatialDomains::MeshGraphHDF5::v_PartitionMesh(), Nektar::SpatialDomains::MeshGraphXml::v_ReadElements3D(), Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadElements3D(), Nektar::SpatialDomains::MeshGraphXml::v_ReadGeometry(), Nektar::SpatialDomains::MeshGraphHDF5::v_WriteGeometry(), Nektar::SpatialDomains::MeshGraphXml::v_WriteGeometry(), and Nektar::SpatialDomains::MeshGraphXml::WriteXMLGeometry().

m_pyrGeoms

PyrGeomMap Nektar::SpatialDomains::MeshGraph::m_pyrGeoms

protected

Definition at line 500 of file MeshGraph.h.

Referenced by CreateMeshEntities(), FillBoundingBoxTree(), FillGraph(), GetAllPyrGeoms(), GetNumElements(), Nektar::SpatialDomains::MeshGraphHDF5::ReadComposites(), Nektar::SpatialDomains::MeshGraphXml::ResolveGeomRef3D(), SetExpansionInfo(), SetPartition(), Nektar::SpatialDomains::MeshGraphHDF5::v_PartitionMesh(), Nektar::SpatialDomains::MeshGraphXml::v_ReadElements3D(), Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadElements3D(), Nektar::SpatialDomains::MeshGraphXml::v_ReadGeometry(), Nektar::SpatialDomains::MeshGraphHDF5::v_WriteGeometry(), Nektar::SpatialDomains::MeshGraphXml::v_WriteGeometry(), and Nektar::SpatialDomains::MeshGraphXml::WriteXMLGeometry().

m_quadGeoms

QuadGeomMap Nektar::SpatialDomains::MeshGraph::m_quadGeoms

protected

Definition at line 498 of file MeshGraph.h.

Referenced by CreateMeshEntities(), FillBoundingBoxTree(), FillGraph(), GetAllQuadGeoms(), GetGeometry2D(), GetNumElements(), Nektar::SpatialDomains::MeshGraphHDF5::ReadComposites(), Nektar::SpatialDomains::MeshGraphXml::ResolveGeomRef2D(), Nektar::SpatialDomains::MeshGraphXml::ResolveGeomRef3D(), SetExpansionInfo(), SetPartition(), Nektar::SpatialDomains::MeshGraphHDF5::v_PartitionMesh(), Nektar::SpatialDomains::MeshGraphXml::v_ReadElements2D(), Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadElements2D(), Nektar::SpatialDomains::MeshGraphXml::v_ReadFaces(), Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadFaces(), Nektar::SpatialDomains::MeshGraphXml::v_ReadGeometry(), Nektar::SpatialDomains::MeshGraphHDF5::v_WriteGeometry(), Nektar::SpatialDomains::MeshGraphXml::v_WriteGeometry(), and Nektar::SpatialDomains::MeshGraphXml::WriteXMLGeometry().

m_refComposite

std::map<int, CompositeMap> Nektar::SpatialDomains::MeshGraph::m_refComposite

protected

Link the refinement id with the composites.

Definition at line 512 of file MeshGraph.h.

Referenced by ReadExpansionInfo(), and SetRefinementInfo().

m_refFlag

bool Nektar::SpatialDomains::MeshGraph::m_refFlag = false

protected

Definition at line 516 of file MeshGraph.h.

Referenced by ReadExpansionInfo().

m_refRegion

std::map<int, RefRegion *> Nektar::SpatialDomains::MeshGraph::m_refRegion

protected

Link the refinement id with the surface region data.

Definition at line 515 of file MeshGraph.h.

Referenced by ReadRefinementInfo(), and SetRefinementInfo().

m_segGeoms

SegGeomMap Nektar::SpatialDomains::MeshGraph::m_segGeoms

protected

Definition at line 495 of file MeshGraph.h.

Referenced by CreateMeshEntities(), FillBoundingBoxTree(), FillGraph(), GetAllSegGeoms(), GetNumElements(), GetSegGeom(), Nektar::SpatialDomains::MeshGraphHDF5::ReadComposites(), Nektar::SpatialDomains::MeshGraphXml::ResolveGeomRef1D(), Nektar::SpatialDomains::MeshGraphXml::ResolveGeomRef2D(), Nektar::SpatialDomains::MeshGraphXml::ResolveGeomRef3D(), SetExpansionInfo(), SetPartition(), Nektar::SpatialDomains::MeshGraphHDF5::v_PartitionMesh(), Nektar::SpatialDomains::MeshGraphXml::v_ReadEdges(), Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadEdges(), Nektar::SpatialDomains::MeshGraphXml::v_ReadElements1D(), Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadElements1D(), Nektar::SpatialDomains::MeshGraphXml::v_ReadGeometry(), Nektar::SpatialDomains::MeshGraphHDF5::v_WriteGeometry(), Nektar::SpatialDomains::MeshGraphXml::v_WriteGeometry(), and Nektar::SpatialDomains::MeshGraphXml::WriteXMLGeometry().

m_session

LibUtilities::SessionReaderSharedPtr Nektar::SpatialDomains::MeshGraph::m_session

protected

Definition at line 489 of file MeshGraph.h.

Referenced by FillGraph(), Nektar::SpatialDomains::MeshGraphHDF5::ReadCurveMap(), ReadExpansionInfo(), ReadRefinementInfo(), Nektar::SpatialDomains::MeshGraphHDF5::v_PartitionMesh(), Nektar::SpatialDomains::MeshGraphXml::v_PartitionMesh(), Nektar::SpatialDomains::MeshGraphXml::v_ReadGeometry(), Nektar::SpatialDomains::MeshGraphXml::v_WriteGeometry(), and Nektar::SpatialDomains::MeshGraphXml::WriteXMLGeometry().

m_spaceDimension

int Nektar::SpatialDomains::MeshGraph::m_spaceDimension

protected

Definition at line 505 of file MeshGraph.h.

Referenced by Nektar::SpatialDomains::MeshGraphHDF5::ConstructGeomObject(), Empty(), GetSpaceDimension(), PRefinementElmts(), Nektar::SpatialDomains::MeshGraphHDF5::ReadCurveMap(), ReadRefinementInfo(), SetPartition(), Nektar::SpatialDomains::MeshGraphHDF5::v_PartitionMesh(), Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadCurves(), Nektar::SpatialDomains::MeshGraphXml::v_ReadEdges(), Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadEdges(), Nektar::SpatialDomains::MeshGraphXml::v_ReadElements1D(), Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadElements1D(), Nektar::SpatialDomains::MeshGraphXml::v_ReadGeometry(), Nektar::SpatialDomains::MeshGraphXml::v_ReadVertices(), Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadVertices(), Nektar::SpatialDomains::MeshGraphHDF5::v_WriteGeometry(), Nektar::SpatialDomains::MeshGraphXml::v_WriteGeometry(), and Nektar::SpatialDomains::MeshGraphXml::WriteXMLGeometry().

m_tetGeoms

TetGeomMap Nektar::SpatialDomains::MeshGraph::m_tetGeoms

protected

Definition at line 499 of file MeshGraph.h.

Referenced by CreateMeshEntities(), FillBoundingBoxTree(), FillGraph(), GetAllTetGeoms(), GetNumElements(), Nektar::SpatialDomains::MeshGraphHDF5::ReadComposites(), Nektar::SpatialDomains::MeshGraphXml::ResolveGeomRef3D(), SetExpansionInfo(), SetPartition(), Nektar::SpatialDomains::MeshGraphHDF5::v_PartitionMesh(), Nektar::SpatialDomains::MeshGraphXml::v_ReadElements3D(), Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadElements3D(), Nektar::SpatialDomains::MeshGraphXml::v_ReadGeometry(), Nektar::SpatialDomains::MeshGraphHDF5::v_WriteGeometry(), Nektar::SpatialDomains::MeshGraphXml::v_WriteGeometry(), and Nektar::SpatialDomains::MeshGraphXml::WriteXMLGeometry().

m_triGeoms

TriGeomMap Nektar::SpatialDomains::MeshGraph::m_triGeoms

protected

Definition at line 497 of file MeshGraph.h.

Referenced by CreateMeshEntities(), FillBoundingBoxTree(), FillGraph(), GetAllTriGeoms(), GetGeometry2D(), GetNumElements(), Nektar::SpatialDomains::MeshGraphHDF5::ReadComposites(), Nektar::SpatialDomains::MeshGraphXml::ResolveGeomRef2D(), Nektar::SpatialDomains::MeshGraphXml::ResolveGeomRef3D(), SetExpansionInfo(), SetPartition(), Nektar::SpatialDomains::MeshGraphHDF5::v_PartitionMesh(), Nektar::SpatialDomains::MeshGraphXml::v_ReadElements2D(), Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadElements2D(), Nektar::SpatialDomains::MeshGraphXml::v_ReadFaces(), Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadFaces(), Nektar::SpatialDomains::MeshGraphXml::v_ReadGeometry(), Nektar::SpatialDomains::MeshGraphHDF5::v_WriteGeometry(), Nektar::SpatialDomains::MeshGraphXml::v_WriteGeometry(), and Nektar::SpatialDomains::MeshGraphXml::WriteXMLGeometry().

m_useExpansionType

bool Nektar::SpatialDomains::MeshGraph::m_useExpansionType

protected

Definition at line 508 of file MeshGraph.h.

Referenced by PRefinementElmts(), ReadExpansionInfo(), and ReadRefinementInfo().

m_vertSet

PointGeomMap Nektar::SpatialDomains::MeshGraph::m_vertSet

protected

Definition at line 490 of file MeshGraph.h.

Referenced by GetAllPointGeoms(), GetNvertices(), GetVertex(), Nektar::SpatialDomains::MeshGraphHDF5::ReadComposites(), Nektar::SpatialDomains::MeshGraphXml::ResolveGeomRef1D(), Nektar::SpatialDomains::MeshGraphXml::ResolveGeomRef2D(), Nektar::SpatialDomains::MeshGraphXml::ResolveGeomRef3D(), SetPartition(), Nektar::SpatialDomains::MeshGraphHDF5::v_PartitionMesh(), Nektar::SpatialDomains::MeshGraphXml::v_ReadGeometry(), Nektar::SpatialDomains::MeshGraphXml::v_ReadVertices(), Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadVertices(), Nektar::SpatialDomains::MeshGraphHDF5::v_WriteGeometry(), Nektar::SpatialDomains::MeshGraphXml::v_WriteGeometry(), and Nektar::SpatialDomains::MeshGraphXml::WriteXMLGeometry().

m_xmlGeom

TiXmlElement* Nektar::SpatialDomains::MeshGraph::m_xmlGeom

protected

Definition at line 527 of file MeshGraph.h.

Referenced by Nektar::SpatialDomains::MeshGraphXml::ReadComposites(), Nektar::SpatialDomains::MeshGraphXml::ReadDomain(), Nektar::SpatialDomains::MeshGraphHDF5::v_PartitionMesh(), Nektar::SpatialDomains::MeshGraphXml::v_ReadCurves(), Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadCurves(), Nektar::SpatialDomains::MeshGraphXml::v_ReadEdges(), Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadEdges(), Nektar::SpatialDomains::MeshGraphXml::v_ReadElements1D(), Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadElements1D(), Nektar::SpatialDomains::MeshGraphXml::v_ReadElements2D(), Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadElements2D(), Nektar::SpatialDomains::MeshGraphXml::v_ReadElements3D(), Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadElements3D(), Nektar::SpatialDomains::MeshGraphXml::v_ReadFaces(), Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadFaces(), Nektar::SpatialDomains::MeshGraphXml::v_ReadGeometry(), Nektar::SpatialDomains::MeshGraphXml::v_ReadVertices(), and Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadVertices().