Nektar::SpatialDomains::HexGeom Class Reference

#include <HexGeom.h>

Inheritance diagram for Nektar::SpatialDomains::HexGeom:

Public Member Functions
	HexGeom ()
	HexGeom (int id, QuadGeom *faces[])
	HexGeom (int id, std::array< QuadGeom *, kNfaces > faces)
	~HexGeom () override=default
Public Member Functions inherited from Nektar::SpatialDomains::Geometry3D
	Geometry3D ()
	Geometry3D (const int coordim)
	~Geometry3D () override=default
Public Member Functions inherited from Nektar::SpatialDomains::Geometry
	Geometry ()
	Default constructor.
	Geometry (int coordim)
	Constructor when supplied a coordinate dimension.
virtual	~Geometry ()=default
int	GetCoordim () const
	Return the coordinate dimension of this object (i.e. the dimension of the space in which this object is embedded).
void	SetCoordim (int coordim)
	Sets the coordinate dimension of this object (i.e. the dimension of the space in which this object is embedded).
GeomFactorsUniquePtr	GenGeomFactors (LibUtilities::PointsKeyVector &keyTgt)
	Used by Expansion to generate associated GeomFactors.
LibUtilities::ShapeType	GetShapeType (void)
	Get the geometric shape type of this object.
int	GetGlobalID (void) const
	Get the ID of this object.
void	SetGlobalID (int globalid)
	Set the ID of this object.
int	GetVid (int i) const
	Returns global id of vertex i of this object.
int	GetEid (int i) const
	Get the ID of edge i of this object.
int	GetFid (int i) const
	Get the ID of face i of this object.
int	GetTid (int i) const
	Get the ID of trace i of this object.
PointGeom *	GetVertex (int i) const
	Returns vertex i of this object.
Geometry1D *	GetEdge (int i) const
	Returns edge i of this object.
Geometry2D *	GetFace (int i) const
	Returns face i of this object.
StdRegions::Orientation	GetEorient (const int i) const
	Returns the orientation of edge i with respect to the ordering of edges in the standard element.
StdRegions::Orientation	GetForient (const int i) const
	Returns the orientation of face i with respect to the ordering of faces in the standard element.
int	GetNumVerts () const
	Get the number of vertices of this object.
int	GetNumEdges () const
	Get the number of edges of this object.
int	GetNumFaces () const
	Get the number of faces of this object.
int	GetShapeDim () const
	Get the object's shape dimension.
StdRegions::StdExpansionSharedPtr	GetXmap () const
	Return the mapping object Geometry::m_xmap that represents the coordinate transformation from standard element to physical element.
const Array< OneD, const NekDouble > &	GetCoeffs (const int i) const
	Return the coefficients of the transformation Geometry::m_xmap in coordinate direction i.
void	FillGeom ()
	Populate the coordinate mapping Geometry::m_coeffs information from any children geometry elements.
std::array< NekDouble, 6 >	GetBoundingBox ()
	Generates the bounding box for the element.
void	ClearBoundingBox ()
bool	ContainsPoint (const Array< OneD, const NekDouble > &gloCoord, NekDouble tol=0.0)
	Determine whether an element contains a particular Cartesian coordinate \((x,y,z)\).
bool	ContainsPoint (const Array< OneD, const NekDouble > &gloCoord, Array< OneD, NekDouble > &locCoord, NekDouble tol)
	Determine whether an element contains a particular Cartesian coordinate \((x,y,z)\).
bool	ContainsPoint (const Array< OneD, const NekDouble > &gloCoord, Array< OneD, NekDouble > &locCoord, NekDouble tol, NekDouble &dist)
	Determine whether an element contains a particular Cartesian coordinate \(\vec{x} = (x,y,z)\).
NekDouble	GetLocCoords (const Array< OneD, const NekDouble > &coords, Array< OneD, NekDouble > &Lcoords)
	Determine the local collapsed coordinates that correspond to a given Cartesian coordinate for this geometry object.
NekDouble	GetCoord (const int i, const Array< OneD, const NekDouble > &Lcoord)
	Given local collapsed coordinate Lcoord, return the value of physical coordinate in direction i.
int	PreliminaryCheck (const Array< OneD, const NekDouble > &gloCoord)
	A fast and robust check if a given global coord is outside of a deformed element. For regular elements, this check is unnecessary.
bool	MinMaxCheck (const Array< OneD, const NekDouble > &gloCoord)
	Check if given global coord is within the BoundingBox of the element.
bool	ClampLocCoords (Array< OneD, NekDouble > &locCoord, NekDouble tol=std::numeric_limits< NekDouble >::epsilon())
	Clamp local coords to be within standard regions [-1, 1]^dim.
NekDouble	FindDistance (const Array< OneD, const NekDouble > &xs, Array< OneD, NekDouble > &xi)
int	GetVertexEdgeMap (int i, int j) const
	Returns the standard element edge IDs that are connected to a given vertex.
int	GetVertexFaceMap (int i, int j) const
	Returns the standard element face IDs that are connected to a given vertex.
int	GetEdgeFaceMap (int i, int j) const
	Returns the standard element edge IDs that are connected to a given face.
int	GetEdgeNormalToFaceVert (int i, int j) const
	Returns the standard lement edge IDs that are normal to a given face vertex.
int	GetDir (const int i, const int j=0) const
	Returns the element coordinate direction corresponding to a given face coordinate direction.
GeomType	CalcGeomType ()
void	Reset (CurveMap &curvedEdges, CurveMap &curvedFaces)
	Reset this geometry object: unset the current state, zero Geometry::m_coeffs and remove allocated GeomFactors.
void	ResetNonRecursive (CurveMap &curvedEdges, CurveMap &curvedFaces)
	Reset this geometry object non-recursively: unset the current state, zero Geometry::m_coeffs and remove allocated GeomFactors.
void	Setup ()

Static Public Attributes
static const int	kNverts = 8
static const int	kNedges = 12
static const int	kNqfaces = 6
static const int	kNtfaces = 0
static const int	kNfaces = kNqfaces + kNtfaces
static const int	kNfacets = kNfaces
static const std::string	XMLElementType
Static Public Attributes inherited from Nektar::SpatialDomains::Geometry3D
static const int	kDim = 3

Protected Member Functions
GeomType	v_CalcGeomType () override
GeomFactorsUniquePtr	v_GenGeomFactors (LibUtilities::PointsKeyVector &keyTgt) override
	Used by Expansion to generate associated GeomFactors.
int	v_GetVertexEdgeMap (const int i, const int j) const override
	Returns the standard element edge IDs that are connected to a given vertex.
int	v_GetVertexFaceMap (const int i, const int j) const override
	Returns the standard element face IDs that are connected to a given vertex.
int	v_GetEdgeFaceMap (const int i, const int j) const override
	Returns the standard element edge IDs that are connected to a given face.
int	v_GetEdgeNormalToFaceVert (const int i, const int j) const override
	Returns the standard lement edge IDs that are normal to a given face vertex.
int	v_GetDir (const int faceidx, const int facedir) const override
	Returns the element coordinate direction corresponding to a given face coordinate direction.
void	v_Reset (CurveMap &curvedEdges, CurveMap &curvedFaces) override
	Reset this geometry object: unset the current state, zero Geometry::m_coeffs and remove allocated GeomFactors.
void	v_Setup () override
void	v_FillGeom () override
	Put all quadrature information into face/edge structure and backward transform.
int	v_GetNumVerts () const final
	Get the number of vertices of this object.
int	v_GetNumEdges () const final
	Get the number of edges of this object.
int	v_GetNumFaces () const final
	Get the number of faces of this object.
PointGeom *	v_GetVertex (const int i) const final
	Returns vertex i of this object.
Geometry1D *	v_GetEdge (const int i) const final
	Returns edge i of this object.
Geometry2D *	v_GetFace (const int i) const final
	Returns face i of this object.
StdRegions::Orientation	v_GetEorient (const int i) const final
	Returns the orientation of edge i with respect to the ordering of edges in the standard element.
StdRegions::Orientation	v_GetForient (const int i) const final
	Returns the orientation of face i with respect to the ordering of faces in the standard element.
Protected Member Functions inherited from Nektar::SpatialDomains::Geometry3D
NekDouble	v_GetLocCoords (const Array< OneD, const NekDouble > &coords, Array< OneD, NekDouble > &Lcoords) override
	Determine the local collapsed coordinates that correspond to a given Cartesian coordinate for this geometry object.
void	NewtonIterationForLocCoord (const Array< OneD, const NekDouble > &coords, const Array< OneD, const NekDouble > &ptsx, const Array< OneD, const NekDouble > &ptsy, const Array< OneD, const NekDouble > &ptsz, Array< OneD, NekDouble > &Lcoords, NekDouble &dist)
void	NewtonIterationForLocCoord (const Array< OneD, const NekDouble > &coords, Array< OneD, NekDouble > &Lcoords)
NekDouble	v_GetCoord (const int i, const Array< OneD, const NekDouble > &Lcoord) override
	Given local collapsed coordinate Lcoord return the value of physical coordinate in direction i.
void	v_CalculateInverseIsoParam () override
int	v_AllLeftCheck (const Array< OneD, const NekDouble > &gloCoord) override
int	v_GetShapeDim () const override
	Get the object's shape dimension.
Protected Member Functions inherited from Nektar::SpatialDomains::Geometry
virtual int	v_GetVid (int i) const
	Get the ID of vertex i of this object.
virtual StdRegions::StdExpansionSharedPtr	v_GetXmap () const
	Return the mapping object Geometry::m_xmap that represents the coordinate transformation from standard element to physical element.
virtual bool	v_ContainsPoint (const Array< OneD, const NekDouble > &gloCoord, Array< OneD, NekDouble > &locCoord, NekDouble tol, NekDouble &dist)
	Determine whether an element contains a particular Cartesian coordinate \(\vec{x} = (x,y,z)\).
virtual NekDouble	v_FindDistance (const Array< OneD, const NekDouble > &xs, Array< OneD, NekDouble > &xi)
void	SetUpCoeffs (const int nCoeffs)
	Initialise the Geometry::m_coeffs array.

Protected Attributes
std::array< PointGeom *, kNverts >	m_verts
std::array< SegGeom *, kNedges >	m_edges
std::array< QuadGeom *, kNfaces >	m_faces
std::array< StdRegions::Orientation, kNedges >	m_eorient
std::array< StdRegions::Orientation, kNfaces >	m_forient
Protected Attributes inherited from Nektar::SpatialDomains::Geometry3D
int	m_eid
bool	m_ownverts
Protected Attributes inherited from Nektar::SpatialDomains::Geometry
int	m_coordim
	Coordinate dimension of this geometry object.
StdRegions::StdExpansionSharedPtr	m_xmap
	\(\chi\) mapping containing isoparametric transformation.
GeomState	m_state
	Enumeration to dictate whether coefficients are filled.
bool	m_setupState
	Wether or not the setup routines have been run.
LibUtilities::ShapeType	m_shapeType
	Type of shape.
int	m_globalID
	Global ID.
std::vector< Array< OneD, NekDouble > >	m_coeffs
	Array containing expansion coefficients of m_xmap.
Array< OneD, NekDouble >	m_boundingBox
	Array containing bounding box.
Array< OneD, Array< OneD, NekDouble > >	m_isoParameter
Array< OneD, Array< OneD, NekDouble > >	m_invIsoParam
int	m_straightEdge

Private Member Functions
void	SetUpLocalEdges ()
void	SetUpLocalVertices ()
void	SetUpEdgeOrientation ()
void	SetUpFaceOrientation ()
void	SetUpXmap ()
	Set up the m_xmap object by determining the order of each direction from derived faces.

Static Private Attributes
static const unsigned int	VertexEdgeConnectivity [8][3]
static const unsigned int	VertexFaceConnectivity [8][3]
static const unsigned int	EdgeFaceConnectivity [12][2]
static const unsigned int	EdgeNormalToFaceVert [6][4]

Detailed Description

Definition at line 45 of file HexGeom.h.

Constructor & Destructor Documentation

HexGeom() [1/3]

Nektar::SpatialDomains::HexGeom::HexGeom

(

)

Definition at line 65 of file HexGeom.cpp.

{
    m_shapeType = LibUtilities::eHexahedron;
}

References Nektar::LibUtilities::eHexahedron, and Nektar::SpatialDomains::Geometry::m_shapeType.

HexGeom() [2/3]

Nektar::SpatialDomains::HexGeom::HexGeom	(	int	id,
		QuadGeom *	faces[]
	)

HexGeom() [3/3]

Nektar::SpatialDomains::HexGeom::HexGeom	(	int	id,
		std::array< QuadGeom *, kNfaces >	faces
	)

Definition at line 70 of file HexGeom.cpp.

    : Geometry3D(faces[0]->GetEdge(0)->GetVertex(0)->GetCoordim())
{
    m_shapeType = LibUtilities::eHexahedron;
    m_globalID  = id;
    m_faces     = faces;
 
    SetUpLocalEdges();
    SetUpLocalVertices();
    SetUpEdgeOrientation();
    SetUpFaceOrientation();
}

References Nektar::LibUtilities::eHexahedron, m_faces, Nektar::SpatialDomains::Geometry::m_globalID, Nektar::SpatialDomains::Geometry::m_shapeType, SetUpEdgeOrientation(), SetUpFaceOrientation(), SetUpLocalEdges(), and SetUpLocalVertices().

~HexGeom()

Nektar::SpatialDomains::HexGeom::~HexGeom ( )

overridedefault

Member Function Documentation

SetUpEdgeOrientation()

void Nektar::SpatialDomains::HexGeom::SetUpEdgeOrientation ( )

private

Definition at line 666 of file HexGeom.cpp.

{
 
    // This 2D array holds the local id's of all the vertices
    // for every edge. For every edge, they are ordered to what we
    // define as being Forwards
    const unsigned int edgeVerts[kNedges][2] = {{0, 1}, {1, 2}, {2, 3}, {3, 0},
                                                {0, 4}, {1, 5}, {2, 6}, {3, 7},
                                                {4, 5}, {5, 6}, {6, 7}, {7, 4}};
 
    int i;
    for (i = 0; i < kNedges; i++)
    {
        if (m_edges[i]->GetVid(0) == m_verts[edgeVerts[i][0]]->GetGlobalID())
        {
            m_eorient[i] = StdRegions::eForwards;
        }
        else if (m_edges[i]->GetVid(0) ==
                 m_verts[edgeVerts[i][1]]->GetGlobalID())
        {
            m_eorient[i] = StdRegions::eBackwards;
        }
        else
        {
            NEKERROR(ErrorUtil::efatal,
                     "Could not find matching vertex for the edge");
        }
    }
}

References Nektar::StdRegions::eBackwards, Nektar::ErrorUtil::efatal, Nektar::StdRegions::eForwards, Nektar::SpatialDomains::Geometry::GetGlobalID(), Nektar::SpatialDomains::Geometry::GetVid(), kNedges, m_edges, m_eorient, m_verts, and NEKERROR.

Referenced by HexGeom().

SetUpFaceOrientation()

void Nektar::SpatialDomains::HexGeom::SetUpFaceOrientation ( )

private

Definition at line 432 of file HexGeom.cpp.

{
    int f, i;
 
    // These arrays represent the vector of the A and B
    // coordinate of the local elemental coordinate system
    // where A corresponds with the coordinate direction xi_i
    // with the lowest index i (for that particular face)
    // Coordinate 'B' then corresponds to the other local
    // coordinate (i.e. with the highest index)
    Array<OneD, NekDouble> elementAaxis(m_coordim);
    Array<OneD, NekDouble> elementBaxis(m_coordim);
 
    // These arrays correspond to the local coordinate
    // system of the face itself (i.e. the Geometry2D)
    // faceAaxis correspond to the xi_0 axis
    // faceBaxis correspond to the xi_1 axis
    Array<OneD, NekDouble> faceAaxis(m_coordim);
    Array<OneD, NekDouble> faceBaxis(m_coordim);
 
    // This is the base vertex of the face (i.e. the Geometry2D)
    // This corresponds to thevertex with local ID 0 of the
    // Geometry2D
    unsigned int baseVertex;
 
    // The lenght of the vectors above
    NekDouble elementAaxis_length;
    NekDouble elementBaxis_length;
    NekDouble faceAaxis_length;
    NekDouble faceBaxis_length;
 
    // This 2D array holds the local id's of all the vertices
    // for every face. For every face, they are ordered in such
    // a way that the implementation below allows a unified approach
    // for all faces.
    const unsigned int faceVerts[kNfaces][QuadGeom::kNverts] = {
        {0, 1, 2, 3}, {0, 1, 5, 4}, {1, 2, 6, 5},
        {3, 2, 6, 7}, {0, 3, 7, 4}, {4, 5, 6, 7}};
 
    NekDouble dotproduct1 = 0.0;
    NekDouble dotproduct2 = 0.0;
 
    unsigned int orientation;
 
    // Loop over all the faces to set up the orientation
    for (f = 0; f < kNqfaces + kNtfaces; f++)
    {
        // initialisation
        elementAaxis_length = 0.0;
        elementBaxis_length = 0.0;
        faceAaxis_length    = 0.0;
        faceBaxis_length    = 0.0;
 
        dotproduct1 = 0.0;
        dotproduct2 = 0.0;
 
        baseVertex = m_faces[f]->GetVid(0);
 
        // We are going to construct the vectors representing the A
        // and B axis of every face. These vectors will be constructed
        // as a vector-representation of the edges of the
        // face. However, for both coordinate directions, we can
        // represent the vectors by two different edges. That's why we
        // need to make sure that we pick the edge to which the
        // baseVertex of the Geometry2D-representation of the face
        // belongs...
        if (baseVertex == m_verts[faceVerts[f][0]]->GetGlobalID())
        {
            for (i = 0; i < m_coordim; i++)
            {
                elementAaxis[i] = (*m_verts[faceVerts[f][1]])[i] -
                                  (*m_verts[faceVerts[f][0]])[i];
                elementBaxis[i] = (*m_verts[faceVerts[f][3]])[i] -
                                  (*m_verts[faceVerts[f][0]])[i];
            }
        }
        else if (baseVertex == m_verts[faceVerts[f][1]]->GetGlobalID())
        {
            for (i = 0; i < m_coordim; i++)
            {
                elementAaxis[i] = (*m_verts[faceVerts[f][1]])[i] -
                                  (*m_verts[faceVerts[f][0]])[i];
                elementBaxis[i] = (*m_verts[faceVerts[f][2]])[i] -
                                  (*m_verts[faceVerts[f][1]])[i];
            }
        }
        else if (baseVertex == m_verts[faceVerts[f][2]]->GetGlobalID())
        {
            for (i = 0; i < m_coordim; i++)
            {
                elementAaxis[i] = (*m_verts[faceVerts[f][2]])[i] -
                                  (*m_verts[faceVerts[f][3]])[i];
                elementBaxis[i] = (*m_verts[faceVerts[f][2]])[i] -
                                  (*m_verts[faceVerts[f][1]])[i];
            }
        }
        else if (baseVertex == m_verts[faceVerts[f][3]]->GetGlobalID())
        {
            for (i = 0; i < m_coordim; i++)
            {
                elementAaxis[i] = (*m_verts[faceVerts[f][2]])[i] -
                                  (*m_verts[faceVerts[f][3]])[i];
                elementBaxis[i] = (*m_verts[faceVerts[f][3]])[i] -
                                  (*m_verts[faceVerts[f][0]])[i];
            }
        }
        else
        {
            NEKERROR(ErrorUtil::efatal,
                     "Could not find matching vertex for the face");
        }
 
        // Now, construct the edge-vectors of the local coordinates of
        // the Geometry2D-representation of the face
        for (i = 0; i < m_coordim; i++)
        {
            faceAaxis[i] =
                (*m_faces[f]->GetVertex(1))[i] - (*m_faces[f]->GetVertex(0))[i];
            faceBaxis[i] =
                (*m_faces[f]->GetVertex(3))[i] - (*m_faces[f]->GetVertex(0))[i];
 
            elementAaxis_length += pow(elementAaxis[i], 2);
            elementBaxis_length += pow(elementBaxis[i], 2);
            faceAaxis_length += pow(faceAaxis[i], 2);
            faceBaxis_length += pow(faceBaxis[i], 2);
        }
 
        elementAaxis_length = std::sqrt(elementAaxis_length);
        elementBaxis_length = std::sqrt(elementBaxis_length);
        faceAaxis_length    = std::sqrt(faceAaxis_length);
        faceBaxis_length    = std::sqrt(faceBaxis_length);
 
        // Calculate the inner product of both the A-axis
        // (i.e. Elemental A axis and face A axis)
        for (i = 0; i < m_coordim; i++)
        {
            dotproduct1 += elementAaxis[i] * faceAaxis[i];
        }
 
        NekDouble norm =
            fabs(dotproduct1) / elementAaxis_length / faceAaxis_length;
        orientation = 0;
 
        // if the innerproduct is equal to the (absolute value of the ) products
        // of the lengths of both vectors, then, the coordinate systems will NOT
        // be transposed
        if (fabs(norm - 1.0) < NekConstants::kNekZeroTol)
        {
            // if the inner product is negative, both A-axis point
            // in reverse direction
            if (dotproduct1 < 0.0)
            {
                orientation += 2;
            }
 
            // calculate the inner product of both B-axis
            for (i = 0; i < m_coordim; i++)
            {
                dotproduct2 += elementBaxis[i] * faceBaxis[i];
            }
 
            norm = fabs(dotproduct2) / elementBaxis_length / faceBaxis_length;
 
            // check that both these axis are indeed parallel
            if (fabs(norm - 1.0) >= NekConstants::kNekZeroTol)
            {
                NEKERROR(ErrorUtil::ewarning,
                         "These vectors should be parallel");
            }
 
            // if the inner product is negative, both B-axis point
            // in reverse direction
            if (dotproduct2 < 0.0)
            {
                orientation++;
            }
        }
        // The coordinate systems are transposed
        else
        {
            orientation = 4;
 
            // Calculate the inner product between the elemental A-axis
            // and the B-axis of the face (which are now the corresponding axis)
            dotproduct1 = 0.0;
            for (i = 0; i < m_coordim; i++)
            {
                dotproduct1 += elementAaxis[i] * faceBaxis[i];
            }
 
            norm = fabs(dotproduct1) / elementAaxis_length / faceBaxis_length;
 
            // check that both these axis are indeed parallel
            if (fabs(norm - 1.0) >= NekConstants::kNekZeroTol)
            {
                NEKERROR(ErrorUtil::ewarning,
                         "These vectors should be parallel");
            }
 
            // if the result is negative, both axis point in reverse
            // directions
            if (dotproduct1 < 0.0)
            {
                orientation += 2;
            }
 
            // Do the same for the other two corresponding axis
            dotproduct2 = 0.0;
            for (i = 0; i < m_coordim; i++)
            {
                dotproduct2 += elementBaxis[i] * faceAaxis[i];
            }
 
            norm = fabs(dotproduct2) / elementBaxis_length / faceAaxis_length;
 
            // check that both these axis are indeed parallel
            if (fabs(norm - 1.0) >= NekConstants::kNekZeroTol)
            {
                NEKERROR(ErrorUtil::ewarning,
                         "These vectors should be parallel");
            }
 
            if (dotproduct2 < 0.0)
            {
                orientation++;
            }
        }
 
        orientation = orientation + 5;
        // Fill the m_forient array
        m_forient[f] = (StdRegions::Orientation)orientation;
    }
}

References Nektar::ErrorUtil::efatal, Nektar::ErrorUtil::ewarning, Nektar::SpatialDomains::Geometry::GetGlobalID(), Nektar::SpatialDomains::Geometry::GetVertex(), Nektar::NekConstants::kNekZeroTol, kNfaces, kNqfaces, kNtfaces, Nektar::SpatialDomains::QuadGeom::kNverts, Nektar::SpatialDomains::Geometry::m_coordim, m_faces, m_forient, m_verts, and NEKERROR.

Referenced by HexGeom().

SetUpLocalEdges()

void Nektar::SpatialDomains::HexGeom::SetUpLocalEdges ( )

private

Definition at line 200 of file HexGeom.cpp.

{
    // find edge 0
    int i, j;
    unsigned int check;
 
    // First set up the 4 bottom edges
    int f;
    for (f = 1; f < 5; f++)
    {
        check = 0;
        for (i = 0; i < 4; i++)
        {
            for (j = 0; j < 4; j++)
            {
                if ((m_faces[0])->GetEid(i) == (m_faces[f])->GetEid(j))
                {
                    m_edges[f - 1] =
                        static_cast<SegGeom *>((m_faces[0])->GetEdge(i));
                    check++;
                }
            }
        }
 
        if (check < 1)
        {
            std::ostringstream errstrm;
            errstrm << "Connected faces do not share an edge. Faces ";
            errstrm << (m_faces[0])->GetGlobalID() << ", "
                    << (m_faces[f])->GetGlobalID();
            NEKERROR(ErrorUtil::efatal, errstrm.str());
        }
        else if (check > 1)
        {
            std::ostringstream errstrm;
            errstrm << "Connected faces share more than one edge. Faces ";
            errstrm << (m_faces[0])->GetGlobalID() << ", "
                    << (m_faces[f])->GetGlobalID();
            NEKERROR(ErrorUtil::efatal, errstrm.str());
        }
    }
 
    // Then, set up the 4 vertical edges
    check = 0;
    for (i = 0; i < 4; i++)
    {
        for (j = 0; j < 4; j++)
        {
            if ((m_faces[1])->GetEid(i) == (m_faces[4])->GetEid(j))
            {
                m_edges[4] = static_cast<SegGeom *>((m_faces[1])->GetEdge(i));
                check++;
            }
        }
    }
    if (check < 1)
    {
        std::ostringstream errstrm;
        errstrm << "Connected faces do not share an edge. Faces ";
        errstrm << (m_faces[1])->GetGlobalID() << ", "
                << (m_faces[4])->GetGlobalID();
        NEKERROR(ErrorUtil::efatal, errstrm.str());
    }
    else if (check > 1)
    {
        std::ostringstream errstrm;
        errstrm << "Connected faces share more than one edge. Faces ";
        errstrm << (m_faces[1])->GetGlobalID() << ", "
                << (m_faces[4])->GetGlobalID();
        NEKERROR(ErrorUtil::efatal, errstrm.str());
    }
    for (f = 1; f < 4; f++)
    {
        check = 0;
        for (i = 0; i < 4; i++)
        {
            for (j = 0; j < 4; j++)
            {
                if ((m_faces[f])->GetEid(i) == (m_faces[f + 1])->GetEid(j))
                {
                    m_edges[f + 4] =
                        static_cast<SegGeom *>((m_faces[f])->GetEdge(i));
                    check++;
                }
            }
        }
 
        if (check < 1)
        {
            std::ostringstream errstrm;
            errstrm << "Connected faces do not share an edge. Faces ";
            errstrm << (m_faces[f])->GetGlobalID() << ", "
                    << (m_faces[f + 1])->GetGlobalID();
            NEKERROR(ErrorUtil::efatal, errstrm.str());
        }
        else if (check > 1)
        {
            std::ostringstream errstrm;
            errstrm << "Connected faces share more than one edge. Faces ";
            errstrm << (m_faces[f])->GetGlobalID() << ", "
                    << (m_faces[f + 1])->GetGlobalID();
            NEKERROR(ErrorUtil::efatal, errstrm.str());
        }
    }
 
    // Finally, set up the 4 top vertices
    for (f = 1; f < 5; f++)
    {
        check = 0;
        for (i = 0; i < 4; i++)
        {
            for (j = 0; j < 4; j++)
            {
                if ((m_faces[5])->GetEid(i) == (m_faces[f])->GetEid(j))
                {
                    m_edges[f + 7] =
                        static_cast<SegGeom *>((m_faces[5])->GetEdge(i));
                    check++;
                }
            }
        }
 
        if (check < 1)
        {
            std::ostringstream errstrm;
            errstrm << "Connected faces do not share an edge. Faces ";
            errstrm << (m_faces[5])->GetGlobalID() << ", "
                    << (m_faces[f])->GetGlobalID();
            NEKERROR(ErrorUtil::efatal, errstrm.str());
        }
        else if (check > 1)
        {
            std::ostringstream errstrm;
            errstrm << "Connected faces share more than one edge. Faces ";
            errstrm << (m_faces[5])->GetGlobalID() << ", "
                    << (m_faces[f])->GetGlobalID();
            NEKERROR(ErrorUtil::efatal, errstrm.str());
        }
    }
}

References Nektar::ErrorUtil::efatal, Nektar::SpatialDomains::Geometry::GetEdge(), Nektar::SpatialDomains::Geometry::GetEid(), Nektar::SpatialDomains::Geometry::GetGlobalID(), m_edges, m_faces, and NEKERROR.

Referenced by HexGeom().

SetUpLocalVertices()

void Nektar::SpatialDomains::HexGeom::SetUpLocalVertices ( )

private

Definition at line 341 of file HexGeom.cpp.

{
    // Set up the first 2 vertices (i.e. vertex 0,1)
    if ((m_edges[0]->GetVid(0) == m_edges[1]->GetVid(0)) ||
        (m_edges[0]->GetVid(0) == m_edges[1]->GetVid(1)))
    {
        m_verts[0] = m_edges[0]->GetVertex(1);
        m_verts[1] = m_edges[0]->GetVertex(0);
    }
    else if ((m_edges[0]->GetVid(1) == m_edges[1]->GetVid(0)) ||
             (m_edges[0]->GetVid(1) == m_edges[1]->GetVid(1)))
    {
        m_verts[0] = m_edges[0]->GetVertex(0);
        m_verts[1] = m_edges[0]->GetVertex(1);
    }
    else
    {
        std::ostringstream errstrm;
        errstrm << "Connected edges do not share a vertex. Edges ";
        errstrm << m_edges[0]->GetGlobalID() << ", "
                << m_edges[1]->GetGlobalID();
        NEKERROR(ErrorUtil::efatal, errstrm.str());
    }
 
    // set up the other bottom vertices (i.e. vertex 2,3)
    int i;
    for (i = 1; i < 3; i++)
    {
        if (m_edges[i]->GetVid(0) == m_verts[i]->GetGlobalID())
        {
            m_verts[i + 1] = m_edges[i]->GetVertex(1);
        }
        else if (m_edges[i]->GetVid(1) == m_verts[i]->GetGlobalID())
        {
            m_verts[i + 1] = m_edges[i]->GetVertex(0);
        }
        else
        {
            std::ostringstream errstrm;
            errstrm << "Connected edges do not share a vertex. Edges ";
            errstrm << m_edges[i]->GetGlobalID() << ", "
                    << m_edges[i - 1]->GetGlobalID();
            NEKERROR(ErrorUtil::efatal, errstrm.str());
        }
    }
 
    // set up top vertices
    // First, set up vertices 4,5
    if ((m_edges[8]->GetVid(0) == m_edges[9]->GetVid(0)) ||
        (m_edges[8]->GetVid(0) == m_edges[9]->GetVid(1)))
    {
        m_verts[4] = m_edges[8]->GetVertex(1);
        m_verts[5] = m_edges[8]->GetVertex(0);
    }
    else if ((m_edges[8]->GetVid(1) == m_edges[9]->GetVid(0)) ||
             (m_edges[8]->GetVid(1) == m_edges[9]->GetVid(1)))
    {
        m_verts[4] = m_edges[8]->GetVertex(0);
        m_verts[5] = m_edges[8]->GetVertex(1);
    }
    else
    {
        std::ostringstream errstrm;
        errstrm << "Connected edges do not share a vertex. Edges ";
        errstrm << m_edges[8]->GetGlobalID() << ", "
                << m_edges[9]->GetGlobalID();
        NEKERROR(ErrorUtil::efatal, errstrm.str());
    }
 
    // set up the other top vertices (i.e. vertex 6,7)
    for (i = 9; i < 11; i++)
    {
        if (m_edges[i]->GetVid(0) == m_verts[i - 4]->GetGlobalID())
        {
            m_verts[i - 3] = m_edges[i]->GetVertex(1);
        }
        else if (m_edges[i]->GetVid(1) == m_verts[i - 4]->GetGlobalID())
        {
            m_verts[i - 3] = m_edges[i]->GetVertex(0);
        }
        else
        {
            std::ostringstream errstrm;
            errstrm << "Connected edges do not share a vertex. Edges ";
            errstrm << m_edges[i]->GetGlobalID() << ", "
                    << m_edges[i - 1]->GetGlobalID();
            NEKERROR(ErrorUtil::efatal, errstrm.str());
        }
    }
}

References Nektar::ErrorUtil::efatal, Nektar::SpatialDomains::Geometry::GetGlobalID(), Nektar::SpatialDomains::Geometry::GetVid(), m_edges, m_verts, and NEKERROR.

Referenced by HexGeom().

SetUpXmap()

void Nektar::SpatialDomains::HexGeom::SetUpXmap ( )

private

Set up the m_xmap object by determining the order of each direction from derived faces.

Definition at line 737 of file HexGeom.cpp.

{
    // Determine necessary order for standard region. This can almost certainly
    // be simplified but works for now!
    std::vector<int> tmp1;
 
    if (m_forient[0] < 9)
    {
        tmp1.push_back(m_faces[0]->GetXmap()->GetTraceNcoeffs(0));
        tmp1.push_back(m_faces[0]->GetXmap()->GetTraceNcoeffs(2));
    }
    else
    {
        tmp1.push_back(m_faces[0]->GetXmap()->GetTraceNcoeffs(1));
        tmp1.push_back(m_faces[0]->GetXmap()->GetTraceNcoeffs(3));
    }
 
    if (m_forient[5] < 9)
    {
        tmp1.push_back(m_faces[5]->GetXmap()->GetTraceNcoeffs(0));
        tmp1.push_back(m_faces[5]->GetXmap()->GetTraceNcoeffs(2));
    }
    else
    {
        tmp1.push_back(m_faces[5]->GetXmap()->GetTraceNcoeffs(1));
        tmp1.push_back(m_faces[5]->GetXmap()->GetTraceNcoeffs(3));
    }
 
    int order0 = *std::max_element(tmp1.begin(), tmp1.end());
 
    tmp1.clear();
 
    if (m_forient[0] < 9)
    {
        tmp1.push_back(m_faces[0]->GetXmap()->GetTraceNcoeffs(1));
        tmp1.push_back(m_faces[0]->GetXmap()->GetTraceNcoeffs(3));
    }
    else
    {
        tmp1.push_back(m_faces[0]->GetXmap()->GetTraceNcoeffs(0));
        tmp1.push_back(m_faces[0]->GetXmap()->GetTraceNcoeffs(2));
    }
 
    if (m_forient[5] < 9)
    {
        tmp1.push_back(m_faces[5]->GetXmap()->GetTraceNcoeffs(1));
        tmp1.push_back(m_faces[5]->GetXmap()->GetTraceNcoeffs(3));
    }
    else
    {
        tmp1.push_back(m_faces[5]->GetXmap()->GetTraceNcoeffs(0));
        tmp1.push_back(m_faces[5]->GetXmap()->GetTraceNcoeffs(2));
    }
 
    int order1 = *std::max_element(tmp1.begin(), tmp1.end());
 
    tmp1.clear();
 
    if (m_forient[1] < 9)
    {
        tmp1.push_back(m_faces[1]->GetXmap()->GetTraceNcoeffs(1));
        tmp1.push_back(m_faces[1]->GetXmap()->GetTraceNcoeffs(3));
    }
    else
    {
        tmp1.push_back(m_faces[1]->GetXmap()->GetTraceNcoeffs(0));
        tmp1.push_back(m_faces[1]->GetXmap()->GetTraceNcoeffs(2));
    }
 
    if (m_forient[3] < 9)
    {
        tmp1.push_back(m_faces[3]->GetXmap()->GetTraceNcoeffs(1));
        tmp1.push_back(m_faces[3]->GetXmap()->GetTraceNcoeffs(3));
    }
    else
    {
        tmp1.push_back(m_faces[3]->GetXmap()->GetTraceNcoeffs(0));
        tmp1.push_back(m_faces[3]->GetXmap()->GetTraceNcoeffs(2));
    }
 
    int order2 = *std::max_element(tmp1.begin(), tmp1.end());
 
    std::array<LibUtilities::BasisKey, 3> basis = {
        LibUtilities::BasisKey(
            LibUtilities::eModified_A, order0,
            LibUtilities::PointsKey(order0 + 1,
                                    LibUtilities::eGaussLobattoLegendre)),
        LibUtilities::BasisKey(
            LibUtilities::eModified_A, order1,
            LibUtilities::PointsKey(order1 + 1,
                                    LibUtilities::eGaussLobattoLegendre)),
        LibUtilities::BasisKey(
            LibUtilities::eModified_A, order2,
            LibUtilities::PointsKey(order2 + 1,
                                    LibUtilities::eGaussLobattoLegendre))};
 
    m_xmap = GetStdHexFactory().CreateInstance(basis);
}

References Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eModified_A, Nektar::SpatialDomains::GetStdHexFactory(), Nektar::SpatialDomains::Geometry::GetXmap(), m_faces, m_forient, and Nektar::SpatialDomains::Geometry::m_xmap.

Referenced by v_Reset(), and v_Setup().

v_CalcGeomType()

GeomType Nektar::SpatialDomains::HexGeom::v_CalcGeomType ( )

overrideprotectedvirtual

Calculates the GeomType (deformed, regular etc).

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 83 of file HexGeom.cpp.

{
    if (!m_setupState)
    {
        v_Setup();
    }
    v_FillGeom();
 
    GeomType Gtype = eRegular;
 
    // check to see if expansions are linear
    if (m_xmap->GetBasisNumModes(0) != 2 || m_xmap->GetBasisNumModes(1) != 2 ||
        m_xmap->GetBasisNumModes(2) != 2)
    {
        Gtype = eDeformed;
    }
 
    // check to see if all faces are parallelograms
    if (Gtype == eRegular)
    {
        m_isoParameter = Array<OneD, Array<OneD, NekDouble>>(3);
        for (int i = 0; i < 3; ++i)
        {
            m_isoParameter[i]    = Array<OneD, NekDouble>(8, 0.);
            NekDouble A          = (*m_verts[0])(i);
            NekDouble B          = (*m_verts[1])(i);
            NekDouble C          = (*m_verts[2])(i);
            NekDouble D          = (*m_verts[3])(i);
            NekDouble E          = (*m_verts[4])(i);
            NekDouble F          = (*m_verts[5])(i);
            NekDouble G          = (*m_verts[6])(i);
            NekDouble H          = (*m_verts[7])(i);
            m_isoParameter[i][0] = 0.125 * (A + B + C + D + E + F + G + H); // 1
 
            m_isoParameter[i][1] =
                0.125 * (-A + B + C - D - E + F + G - H); // xi1
            m_isoParameter[i][2] =
                0.125 * (-A - B + C + D - E - F + G + H); // xi2
            m_isoParameter[i][3] =
                0.125 * (-A - B - C - D + E + F + G + H); // xi3
 
            m_isoParameter[i][4] =
                0.125 * (A - B + C - D + E - F + G - H); // xi1*xi2
            m_isoParameter[i][5] =
                0.125 * (A + B - C - D - E - F + G + H); // xi2*xi3
            m_isoParameter[i][6] =
                0.125 * (A - B - C + D - E + F + G - H); // xi1*xi3
 
            m_isoParameter[i][7] =
                0.125 * (-A + B - C + D + E - F + G - H); // xi1*xi2*xi3
            NekDouble tmp = fabs(m_isoParameter[i][1]) +
                            fabs(m_isoParameter[i][2]) +
                            fabs(m_isoParameter[i][3]);
            tmp *= NekConstants::kNekZeroTol;
            for (int d = 4; d < 8; ++d)
            {
                if (fabs(m_isoParameter[i][d]) > tmp)
                {
                    Gtype = eDeformed;
                }
            }
        }
    }
 
    if (Gtype == eRegular)
    {
        v_CalculateInverseIsoParam();
    }
 
    return Gtype;
}

References Nektar::SpatialDomains::eDeformed, Nektar::SpatialDomains::eRegular, Nektar::NekConstants::kNekZeroTol, Nektar::SpatialDomains::Geometry::m_isoParameter, Nektar::SpatialDomains::Geometry::m_setupState, m_verts, Nektar::SpatialDomains::Geometry::m_xmap, Nektar::SpatialDomains::Geometry3D::v_CalculateInverseIsoParam(), v_FillGeom(), and v_Setup().

v_FillGeom()

void Nektar::SpatialDomains::HexGeom::v_FillGeom ( )

overrideprotectedvirtual

Put all quadrature information into face/edge structure and backward transform.

Note verts, edges, and faces are listed according to anticlockwise convention but points in _coeffs have to be in array format from left to right.

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 844 of file HexGeom.cpp.

{
    if (m_state == ePtsFilled)
    {
        return;
    }
 
    int i, j, k;
 
    for (i = 0; i < kNfaces; i++)
    {
        m_faces[i]->FillGeom();
 
        int nFaceCoeffs = m_faces[i]->GetXmap()->GetNcoeffs();
 
        Array<OneD, unsigned int> mapArray(nFaceCoeffs);
        Array<OneD, int> signArray(nFaceCoeffs);
 
        if (m_forient[i] < 9)
        {
            m_xmap->GetTraceToElementMap(
                i, mapArray, signArray, m_forient[i],
                m_faces[i]->GetXmap()->GetTraceNcoeffs(0),
                m_faces[i]->GetXmap()->GetTraceNcoeffs(1));
        }
        else
        {
            m_xmap->GetTraceToElementMap(
                i, mapArray, signArray, m_forient[i],
                m_faces[i]->GetXmap()->GetTraceNcoeffs(1),
                m_faces[i]->GetXmap()->GetTraceNcoeffs(0));
        }
 
        for (j = 0; j < m_coordim; j++)
        {
            const Array<OneD, const NekDouble> &coeffs =
                m_faces[i]->GetCoeffs(j);
 
            for (k = 0; k < nFaceCoeffs; k++)
            {
                NekDouble v              = signArray[k] * coeffs[k];
                m_coeffs[j][mapArray[k]] = v;
            }
        }
    }
 
    m_state = ePtsFilled;
}

References Nektar::SpatialDomains::ePtsFilled, Nektar::SpatialDomains::Geometry::GetXmap(), kNfaces, Nektar::SpatialDomains::Geometry::m_coeffs, Nektar::SpatialDomains::Geometry::m_coordim, m_faces, m_forient, Nektar::SpatialDomains::Geometry::m_state, and Nektar::SpatialDomains::Geometry::m_xmap.

Referenced by v_CalcGeomType().

v_GenGeomFactors()

GeomFactorsUniquePtr Nektar::SpatialDomains::HexGeom::v_GenGeomFactors ( LibUtilities::PointsKeyVector &  keyTgt )

overrideprotectedvirtual

Used by Expansion to generate associated GeomFactors.

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 155 of file HexGeom.cpp.

{
    GeomType Gtype = CalcGeomType();
 
    return ObjPoolManager<GeomFactors>::AllocateUniquePtr(
        Gtype, m_coordim, m_xmap, m_coeffs, keyTgt);
}

References Nektar::ObjPoolManager< DataType >::AllocateUniquePtr(), Nektar::SpatialDomains::Geometry::CalcGeomType(), Nektar::SpatialDomains::Geometry::m_coeffs, Nektar::SpatialDomains::Geometry::m_coordim, and Nektar::SpatialDomains::Geometry::m_xmap.

v_GetDir()

int Nektar::SpatialDomains::HexGeom::v_GetDir ( const int  i, const int  j  ) const

overrideprotectedvirtual

Returns the element coordinate direction corresponding to a given face coordinate direction.

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 184 of file HexGeom.cpp.

{
    if (faceidx == 0 || faceidx == 5)
    {
        return facedir;
    }
    else if (faceidx == 1 || faceidx == 3)
    {
        return 2 * facedir;
    }
    else
    {
        return 1 + facedir;
    }
}

v_GetEdge()

Geometry1D * Nektar::SpatialDomains::HexGeom::v_GetEdge ( const int  i ) const

inlinefinalprotectedvirtual

Returns edge i of this object.

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 96 of file HexGeom.h.

    {
        return static_cast<Geometry1D *>(m_edges[i]);
    }

References m_edges.

v_GetEdgeFaceMap()

int Nektar::SpatialDomains::HexGeom::v_GetEdgeFaceMap ( const int  i, const int  j  ) const

overrideprotectedvirtual

Returns the standard element edge IDs that are connected to a given face.

For example, on a prism, edge 0 is connnected to faces 0 and 1; GetEdgeFaceMap(0,j) would therefore return the values 0 and 1 respectively. We assume that j runs between 0 and 1 inclusive, since every face is connected to precisely two faces for all 3D elements.

This function is used in the construction of the low-energy preconditioner.

Parameters

i	The edge to query connectivity for.
j	The local face index between 0 and 1 connected to this element.

See also

MultiRegions::PreconditionerLowEnergy

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 174 of file HexGeom.cpp.

{
    return EdgeFaceConnectivity[i][j];
}

References EdgeFaceConnectivity.

v_GetEdgeNormalToFaceVert()

int Nektar::SpatialDomains::HexGeom::v_GetEdgeNormalToFaceVert ( const int  i, const int  j  ) const

overrideprotectedvirtual

Returns the standard lement edge IDs that are normal to a given face vertex.

For example, on a hexahedron, on face 0 at vertices 0,1,2,3 the edges normal to that face are 4,5,6,7, ; so GetEdgeNormalToFaceVert(0,j) would therefore return the values 4, 5, 6 and 7 respectively. We assume that j runs between 0 and 3 inclusive on a quadrilateral face and between 0 and 2 inclusive on a triangular face.

This is used to help set up a length scale normal to an face

Parameters

i	The face to query for the normal edge
j	The local vertex index between 0 and nverts on this face

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 179 of file HexGeom.cpp.

{
    return EdgeNormalToFaceVert[i][j];
}

References EdgeNormalToFaceVert.

v_GetEorient()

StdRegions::Orientation Nektar::SpatialDomains::HexGeom::v_GetEorient ( const int  i ) const

inlinefinalprotectedvirtual

Returns the orientation of edge i with respect to the ordering of edges in the standard element.

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 106 of file HexGeom.h.

    {
        return m_eorient[i];
    }

References m_eorient.

v_GetFace()

Geometry2D * Nektar::SpatialDomains::HexGeom::v_GetFace ( const int  i ) const

inlinefinalprotectedvirtual

Returns face i of this object.

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 101 of file HexGeom.h.

    {
        return static_cast<Geometry2D *>(m_faces[i]);
    }

References m_faces.

v_GetForient()

StdRegions::Orientation Nektar::SpatialDomains::HexGeom::v_GetForient ( const int  i ) const

inlinefinalprotectedvirtual

Returns the orientation of face i with respect to the ordering of faces in the standard element.

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 111 of file HexGeom.h.

    {
        return m_forient[i];
    }

References m_forient.

v_GetNumEdges()

int Nektar::SpatialDomains::HexGeom::v_GetNumEdges ( ) const

inlinefinalprotectedvirtual

Get the number of edges of this object.

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 81 of file HexGeom.h.

    {
        return kNedges;
    }

References kNedges.

v_GetNumFaces()

int Nektar::SpatialDomains::HexGeom::v_GetNumFaces ( ) const

inlinefinalprotectedvirtual

Get the number of faces of this object.

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 86 of file HexGeom.h.

    {
        return kNfaces;
    }

References kNfaces.

v_GetNumVerts()

int Nektar::SpatialDomains::HexGeom::v_GetNumVerts ( ) const

inlinefinalprotectedvirtual

Get the number of vertices of this object.

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 76 of file HexGeom.h.

    {
        return kNverts;
    }

References kNverts.

v_GetVertex()

PointGeom * Nektar::SpatialDomains::HexGeom::v_GetVertex ( const int  i ) const

inlinefinalprotectedvirtual

Returns vertex i of this object.

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 91 of file HexGeom.h.

    {
        return m_verts[i];
    }

References m_verts.

v_GetVertexEdgeMap()

int Nektar::SpatialDomains::HexGeom::v_GetVertexEdgeMap ( const int  i, const int  j  ) const

overrideprotectedvirtual

Returns the standard element edge IDs that are connected to a given vertex.

For example, on a prism, vertex 0 is connnected to edges 0, 3, and 4; GetVertexEdgeMap(0,j) would therefore return the values 0, 1 and 4 respectively. We assume that j runs between 0 and 2 inclusive, which is true for every 3D element asides from the pyramid.

This function is used in the construction of the low-energy preconditioner.

Parameters

i	The vertex to query connectivity for.
j	The local edge index between 0 and 2 connected to this element.

Todo:

Expand to work with pyramid elements.

See also

MultiRegions::PreconditionerLowEnergy

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 164 of file HexGeom.cpp.

{
    return VertexEdgeConnectivity[i][j];
}

References VertexEdgeConnectivity.

v_GetVertexFaceMap()

int Nektar::SpatialDomains::HexGeom::v_GetVertexFaceMap ( const int  i, const int  j  ) const

overrideprotectedvirtual

Returns the standard element face IDs that are connected to a given vertex.

For example, on a hexahedron, vertex 0 is connnected to faces 0, 1, and 4; GetVertexFaceMap(0,j) would therefore return the values 0, 1 and 4 respectively. We assume that j runs between 0 and 2 inclusive, which is true for every 3D element asides from the pyramid.

This is used in the construction of the low-energy preconditioner.

Parameters

i	The vertex to query connectivity for.
j	The local face index between 0 and 2 connected to this element.

Todo:

Expand to work with pyramid elements.

See also

MultiRegions::PreconditionerLowEnergy

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 169 of file HexGeom.cpp.

{
    return VertexFaceConnectivity[i][j];
}

References VertexFaceConnectivity.

v_Reset()

void Nektar::SpatialDomains::HexGeom::v_Reset ( CurveMap &  curvedEdges, CurveMap &  curvedFaces  )

overrideprotectedvirtual

Reset this geometry object: unset the current state, zero Geometry::m_coeffs and remove allocated GeomFactors.

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 696 of file HexGeom.cpp.

{
    Geometry::v_Reset(curvedEdges, curvedFaces);
 
    for (int i = 0; i < 6; ++i)
    {
        m_faces[i]->Reset(curvedEdges, curvedFaces);
    }
 
    SetUpXmap();
    SetUpCoeffs(m_xmap->GetNcoeffs());
}

References m_faces, Nektar::SpatialDomains::Geometry::m_xmap, Nektar::SpatialDomains::Geometry::SetUpCoeffs(), SetUpXmap(), and Nektar::SpatialDomains::Geometry::v_Reset().

v_Setup()

void Nektar::SpatialDomains::HexGeom::v_Setup ( )

overrideprotectedvirtual

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 709 of file HexGeom.cpp.

{
    if (!m_setupState)
    {
        for (int i = 0; i < 6; ++i)
        {
            m_faces[i]->Setup();
        }
        SetUpXmap();
        SetUpCoeffs(m_xmap->GetNcoeffs());
 
        // check to see if expansions are linear
        m_straightEdge = 1;
        if (m_xmap->GetBasisNumModes(0) != 2 ||
            m_xmap->GetBasisNumModes(1) != 2 ||
            m_xmap->GetBasisNumModes(2) != 2)
        {
            m_straightEdge = 0;
        }
 
        m_setupState = true;
    }
}

References m_faces, Nektar::SpatialDomains::Geometry::m_setupState, Nektar::SpatialDomains::Geometry::m_straightEdge, Nektar::SpatialDomains::Geometry::m_xmap, Nektar::SpatialDomains::Geometry::SetUpCoeffs(), and SetUpXmap().

Referenced by v_CalcGeomType().

Member Data Documentation

EdgeFaceConnectivity

const unsigned int Nektar::SpatialDomains::HexGeom::EdgeFaceConnectivity

staticprivate

Initial value:

= {
    {0, 1}, {0, 2}, {0, 3}, {0, 4}, {1, 4}, {1, 2},
    {2, 3}, {3, 4}, {1, 5}, {2, 5}, {3, 5}, {4, 5}}

Definition at line 131 of file HexGeom.h.

Referenced by v_GetEdgeFaceMap().

EdgeNormalToFaceVert

const unsigned int Nektar::SpatialDomains::HexGeom::EdgeNormalToFaceVert

staticprivate

Initial value:

= {
    {4, 5, 6, 7},  {1, 3, 9, 11}, {0, 2, 8, 10},
    {1, 3, 9, 11}, {0, 2, 8, 10}, {4, 5, 6, 7}}

Definition at line 132 of file HexGeom.h.

Referenced by v_GetEdgeNormalToFaceVert().

kNedges

const int Nektar::SpatialDomains::HexGeom::kNedges = 12

static

Definition at line 52 of file HexGeom.h.

Referenced by SetUpEdgeOrientation(), and v_GetNumEdges().

kNfaces

const int Nektar::SpatialDomains::HexGeom::kNfaces = kNqfaces + kNtfaces

static

Definition at line 55 of file HexGeom.h.

Referenced by Nektar::SpatialDomains::MeshGraphIOHDF5::ConstructGeomObject(), SetUpFaceOrientation(), v_FillGeom(), v_GetNumFaces(), and Nektar::SpatialDomains::MeshGraphIOXml::v_ReadElements3D().

kNfacets

const int Nektar::SpatialDomains::HexGeom::kNfacets = kNfaces

static

Definition at line 56 of file HexGeom.h.

kNqfaces

const int Nektar::SpatialDomains::HexGeom::kNqfaces = 6

static

Definition at line 53 of file HexGeom.h.

Referenced by SetUpFaceOrientation(), and Nektar::SpatialDomains::MeshGraphIOXml::v_ReadElements3D().

kNtfaces

const int Nektar::SpatialDomains::HexGeom::kNtfaces = 0

static

Definition at line 54 of file HexGeom.h.

Referenced by SetUpFaceOrientation(), and Nektar::SpatialDomains::MeshGraphIOXml::v_ReadElements3D().

kNverts

const int Nektar::SpatialDomains::HexGeom::kNverts = 8

static

Definition at line 51 of file HexGeom.h.

Referenced by v_GetNumVerts().

m_edges

std::array<SegGeom *, kNedges> Nektar::SpatialDomains::HexGeom::m_edges

protected

Definition at line 117 of file HexGeom.h.

Referenced by SetUpEdgeOrientation(), SetUpLocalEdges(), SetUpLocalVertices(), and v_GetEdge().

m_eorient

std::array<StdRegions::Orientation, kNedges> Nektar::SpatialDomains::HexGeom::m_eorient

protected

Definition at line 119 of file HexGeom.h.

Referenced by SetUpEdgeOrientation(), and v_GetEorient().

m_faces

std::array<QuadGeom *, kNfaces> Nektar::SpatialDomains::HexGeom::m_faces

protected

Definition at line 118 of file HexGeom.h.

Referenced by HexGeom(), SetUpFaceOrientation(), SetUpLocalEdges(), SetUpXmap(), v_FillGeom(), v_GetFace(), v_Reset(), and v_Setup().

m_forient

std::array<StdRegions::Orientation, kNfaces> Nektar::SpatialDomains::HexGeom::m_forient

protected

Definition at line 120 of file HexGeom.h.

Referenced by SetUpFaceOrientation(), SetUpXmap(), v_FillGeom(), and v_GetForient().

m_verts

std::array<PointGeom *, kNverts> Nektar::SpatialDomains::HexGeom::m_verts

protected

Definition at line 116 of file HexGeom.h.

Referenced by SetUpEdgeOrientation(), SetUpFaceOrientation(), SetUpLocalVertices(), v_CalcGeomType(), and v_GetVertex().

VertexEdgeConnectivity

const unsigned int Nektar::SpatialDomains::HexGeom::VertexEdgeConnectivity

staticprivate

Initial value:

= {
    {0, 3, 4},  {0, 1, 5}, {1, 2, 6},  {2, 3, 7},
    {4, 8, 11}, {5, 8, 9}, {6, 9, 10}, {7, 10, 11}}

Definition at line 129 of file HexGeom.h.

Referenced by v_GetVertexEdgeMap().

VertexFaceConnectivity

const unsigned int Nektar::SpatialDomains::HexGeom::VertexFaceConnectivity

staticprivate

Initial value:

= {
    {0, 1, 4}, {0, 1, 2}, {0, 2, 3}, {0, 3, 4},
    {1, 4, 5}, {1, 2, 5}, {2, 3, 5}, {3, 4, 5}}

Definition at line 130 of file HexGeom.h.

Referenced by v_GetVertexFaceMap().

XMLElementType

const std::string Nektar::SpatialDomains::HexGeom::XMLElementType

static

Definition at line 57 of file HexGeom.h.