#include <HexGeom.h>

Inheritance diagram for Nektar::SpatialDomains::HexGeom:

Public Member Functions
	HexGeom ()

	HexGeom (int id, const QuadGeomSharedPtr faces[])

	~HexGeom ()

Public Member Functions inherited from Nektar::SpatialDomains::Geometry3D
	Geometry3D ()

	Geometry3D (const int coordim)

virtual	~Geometry3D ()

int	GetDir (const int faceidx, const int facedir) const
	Returns the element coordinate direction corresponding to a given face coordinate direction. More...

Public Member Functions inherited from Nektar::SpatialDomains::Geometry
	Geometry ()
	Default constructor. More...

	Geometry (int coordim)
	Constructor when supplied a coordinate dimension. More...

virtual	~Geometry ()
	Default destructor. More...

int	GetCoordim () const
	Return the coordinate dimension of this object (i.e. the dimension of the space in which this object is embedded). More...

void	SetCoordim (int coordim)
	Sets the coordinate dimension of this object (i.e. the dimension of the space in which this object is embedded). More...

GeomFactorsSharedPtr	GetGeomFactors ()
	Get the geometric factors for this object, generating them if required. More...

GeomFactorsSharedPtr	GetRefGeomFactors (const Array< OneD, const LibUtilities::BasisSharedPtr > &tbasis)

GeomFactorsSharedPtr	GetMetricInfo ()
	Get the geometric factors for this object. More...

LibUtilities::ShapeType	GetShapeType (void)
	Get the geometric shape type of this object. More...

int	GetGlobalID (void) const
	Get the ID of this object. More...

void	SetGlobalID (int globalid)
	Set the ID of this object. More...

int	GetVid (int i) const
	Get the ID of vertex `i` of this object. More...

int	GetEid (int i) const
	Get the ID of edge `i` of this object. More...

int	GetFid (int i) const
	Get the ID of face `i` of this object. More...

int	GetTid (int i) const
	Get the ID of trace `i` of this object. More...

PointGeomSharedPtr	GetVertex (int i) const
	Returns vertex `i` of this object. More...

Geometry1DSharedPtr	GetEdge (int i) const
	Returns edge `i` of this object. More...

Geometry2DSharedPtr	GetFace (int i) const
	Returns face `i` of this object. More...

StdRegions::Orientation	GetEorient (const int i) const
	Returns the orientation of edge `i` with respect to the ordering of edges in the standard element. More...

StdRegions::Orientation	GetForient (const int i) const
	Returns the orientation of face `i` with respect to the ordering of faces in the standard element. More...

int	GetNumVerts () const
	Get the number of vertices of this object. More...

int	GetNumEdges () const
	Get the number of edges of this object. More...

int	GetNumFaces () const
	Get the number of faces of this object. More...

int	GetShapeDim () const
	Get the object's shape dimension. More...

StdRegions::StdExpansionSharedPtr	GetXmap () const
	Return the mapping object Geometry::m_xmap that represents the coordinate transformation from standard element to physical element. More...

const Array< OneD, const NekDouble > &	GetCoeffs (const int i) const
	Return the coefficients of the transformation Geometry::m_xmap in coordinate direction `i`. More...

void	FillGeom ()
	Populate the coordinate mapping Geometry::m_coeffs information from any children geometry elements. More...

std::array< NekDouble, 6 >	GetBoundingBox ()
	Generates the bounding box for the element. More...

bool	ContainsPoint (const Array< OneD, const NekDouble > &gloCoord, NekDouble tol=0.0)
	Determine whether an element contains a particular Cartesian coordinate \((x,y,z)\). More...

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)\). More...

bool	ContainsPoint (const Array< OneD, const NekDouble > &gloCoord, Array< OneD, NekDouble > &locCoord, NekDouble tol, NekDouble &resid)
	Determine whether an element contains a particular Cartesian coordinate \(\vec{x} = (x,y,z)\). More...

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. More...

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`. More...

bool	MinMaxCheck (const Array< OneD, const NekDouble > &gloCoord)
	Check if given global coord is within twice the min/max distance of the element. More...

void	ClampLocCoords (Array< OneD, NekDouble > &locCoord, NekDouble tol)
	Clamp local coords to be within standard regions [-1, 1]^dim. More...

int	GetVertexEdgeMap (int i, int j) const
	Returns the standard element edge IDs that are connected to a given vertex. More...

int	GetVertexFaceMap (int i, int j) const
	Returns the standard element face IDs that are connected to a given vertex. More...

int	GetEdgeFaceMap (int i, int j) const
	Returns the standard element edge IDs that are connected to a given face. More...

void	Reset (CurveMap &curvedEdges, CurveMap &curvedFaces)
	Reset this geometry object: unset the current state, zero Geometry::m_coeffs and remove allocated GeomFactors. More...

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 std::string	XMLElementType

Static Public Attributes inherited from Nektar::SpatialDomains::Geometry3D
static const int	kDim = 3

Protected Member Functions
virtual void	v_GenGeomFactors ()

virtual NekDouble	v_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. More...

virtual bool	v_ContainsPoint (const Array< OneD, const NekDouble > &gloCoord, Array< OneD, NekDouble > &locCoord, NekDouble tol, NekDouble &resid)

virtual int	v_GetVertexEdgeMap (const int i, const int j) const
	Returns the standard element edge IDs that are connected to a given vertex. More...

virtual int	v_GetVertexFaceMap (const int i, const int j) const
	Returns the standard element face IDs that are connected to a given vertex. More...

virtual int	v_GetEdgeFaceMap (const int i, const int j) const
	Returns the standard element edge IDs that are connected to a given face. More...

virtual int	v_GetDir (const int faceidx, const int facedir) const

virtual void	v_Reset (CurveMap &curvedEdges, CurveMap &curvedFaces)
	Reset this geometry object: unset the current state, zero Geometry::m_coeffs and remove allocated GeomFactors. More...

virtual void	v_Setup ()

Protected Member Functions inherited from Nektar::SpatialDomains::Geometry3D
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 &resid)

virtual void	v_FillGeom ()
	Put all quadrature information into face/edge structure and backward transform. More...

virtual NekDouble	v_GetCoord (const int i, const Array< OneD, const NekDouble > &Lcoord)
	Given local collapsed coordinate Lcoord return the value of physical coordinate in direction i. More...

virtual int	v_GetShapeDim () const
	Get the object's shape dimension. More...

virtual int	v_GetNumVerts () const
	Get the number of vertices of this object. More...

virtual int	v_GetNumEdges () const
	Get the number of edges of this object. More...

virtual int	v_GetNumFaces () const
	Get the number of faces of this object. More...

virtual PointGeomSharedPtr	v_GetVertex (int i) const

virtual Geometry1DSharedPtr	v_GetEdge (int i) const
	Returns edge `i` of this object. More...

virtual Geometry2DSharedPtr	v_GetFace (int i) const
	Returns face `i` of this object. More...

virtual StdRegions::Orientation	v_GetEorient (const int i) const
	Returns the orientation of edge `i` with respect to the ordering of edges in the standard element. More...

virtual StdRegions::Orientation	v_GetForient (const int i) const
	Returns the orientation of face `i` with respect to the ordering of faces in the standard element. More...

Protected Member Functions inherited from Nektar::SpatialDomains::Geometry
void	GenGeomFactors ()
	Handles generation of geometry factors. More...

virtual StdRegions::StdExpansionSharedPtr	v_GetXmap () const
	Return the mapping object Geometry::m_xmap that represents the coordinate transformation from standard element to physical element. More...

void	SetUpCoeffs (const int nCoeffs)
	Initialise the Geometry::m_coeffs array. More...

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. More...

Static Private Attributes
static const unsigned int	VertexEdgeConnectivity [8][3]

static const unsigned int	VertexFaceConnectivity [8][3]

static const unsigned int	EdgeFaceConnectivity [12][2]

Additional Inherited Members
Static Protected Member Functions inherited from Nektar::SpatialDomains::Geometry
static GeomFactorsSharedPtr	ValidateRegGeomFactor (GeomFactorsSharedPtr geomFactor)
	Check to see if a geometric factor has already been created that contains the same regular information. More...

Protected Attributes inherited from Nektar::SpatialDomains::Geometry3D
PointGeomVector	m_verts

SegGeomVector	m_edges

Geometry2DVector	m_faces

std::vector< StdRegions::Orientation >	m_eorient

std::vector< StdRegions::Orientation >	m_forient

int	m_eid

bool	m_ownverts

Protected Attributes inherited from Nektar::SpatialDomains::Geometry
int	m_coordim
	Coordinate dimension of this geometry object. More...

GeomFactorsSharedPtr	m_geomFactors
	Geometric factors. More...

GeomState	m_geomFactorsState
	State of the geometric factors. More...

StdRegions::StdExpansionSharedPtr	m_xmap
	\(\chi\) mapping containing isoparametric transformation. More...

GeomState	m_state
	Enumeration to dictate whether coefficients are filled. More...

bool	m_setupState
	Wether or not the setup routines have been run. More...

GeomType	m_geomType
	Type of geometry. More...

LibUtilities::ShapeType	m_shapeType
	Type of shape. More...

int	m_globalID
	Global ID. More...

Array< OneD, Array< OneD, NekDouble > >	m_coeffs
	Array containing expansion coefficients of `m_xmap`. More...

Static Protected Attributes inherited from Nektar::SpatialDomains::Geometry
static GeomFactorsVector	m_regGeomFactorsManager

Detailed Description

Definition at line 49 of file HexGeom.h.

Constructor & Destructor Documentation

◆ HexGeom() [1/2]

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

Definition at line 59 of file HexGeom.cpp.

References Nektar::LibUtilities::eHexahedron.

 {
     m_shapeType = LibUtilities::eHexahedron;
 }

◆ HexGeom() [2/2]

Nektar::SpatialDomains::HexGeom::HexGeom	(	int	id,
		const QuadGeomSharedPtr	faces[]
	)

Copy the face shared pointers

Set up orientation vectors with correct amount of elements.

Definition at line 64 of file HexGeom.cpp.

References Nektar::LibUtilities::eHexahedron, kNedges, kNfaces, Nektar::SpatialDomains::Geometry3D::m_eorient, Nektar::SpatialDomains::Geometry3D::m_faces, Nektar::SpatialDomains::Geometry3D::m_forient, Nektar::SpatialDomains::Geometry::m_globalID, Nektar::SpatialDomains::Geometry::m_shapeType, SetUpEdgeOrientation(), SetUpFaceOrientation(), SetUpLocalEdges(), and SetUpLocalVertices().

     : Geometry3D(faces[0]->GetEdge(0)->GetVertex(0)->GetCoordim())
 {
     m_shapeType = LibUtilities::eHexahedron;
     m_globalID = id;
 
     /// Copy the face shared pointers
     m_faces.insert(m_faces.begin(), faces, faces + HexGeom::kNfaces);
 
     /// Set up orientation vectors with correct amount of elements.
     m_eorient.resize(kNedges);
     m_forient.resize(kNfaces);
 
     SetUpLocalEdges();
     SetUpLocalVertices();
     SetUpEdgeOrientation();
     SetUpFaceOrientation();
 }

◆ ~HexGeom()

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

Definition at line 83 of file HexGeom.cpp.

84 {

85 }

Member Function Documentation

◆ SetUpEdgeOrientation()

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

private

Definition at line 785 of file HexGeom.cpp.

References ASSERTL0, Nektar::StdRegions::eBackwards, Nektar::StdRegions::eForwards, Nektar::SpatialDomains::Geometry::GetGlobalID(), Nektar::SpatialDomains::Geometry::GetVid(), kNedges, Nektar::SpatialDomains::Geometry3D::m_edges, Nektar::SpatialDomains::Geometry3D::m_eorient, and Nektar::SpatialDomains::Geometry3D::m_verts.

Referenced by HexGeom().

 {
 
     // 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
         {
             ASSERTL0(false, "Could not find matching vertex for the edge");
         }
     }
 }

◆ SetUpFaceOrientation()

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

private

Definition at line 557 of file HexGeom.cpp.

References ASSERTL0, ASSERTL1, Nektar::SpatialDomains::Geometry::GetGlobalID(), Nektar::SpatialDomains::Geometry::GetVertex(), Nektar::NekConstants::kNekZeroTol, kNfaces, kNqfaces, kNtfaces, Nektar::SpatialDomains::QuadGeom::kNverts, Nektar::SpatialDomains::Geometry::m_coordim, Nektar::SpatialDomains::Geometry3D::m_faces, Nektar::SpatialDomains::Geometry3D::m_forient, and Nektar::SpatialDomains::Geometry3D::m_verts.

Referenced by HexGeom().

 {
     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
         {
             ASSERTL0(false, "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 = sqrt(elementAaxis_length);
         elementBaxis_length = sqrt(elementBaxis_length);
         faceAaxis_length = sqrt(faceAaxis_length);
         faceBaxis_length = 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
             ASSERTL1(fabs(norm - 1.0) < NekConstants::kNekZeroTol,
                      "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
             ASSERTL1(fabs(norm - 1.0) < NekConstants::kNekZeroTol,
                      "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
             ASSERTL1(fabs(norm - 1.0) < NekConstants::kNekZeroTol,
                      "These vectors should be parallel");
 
             if (dotproduct2 < 0.0)
             {
                 orientation++;
             }
         }
 
         orientation = orientation + 5;
         // Fill the m_forient array
         m_forient[f] = (StdRegions::Orientation)orientation;
     }
 }

◆ SetUpLocalEdges()

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

private

Definition at line 318 of file HexGeom.cpp.

References ASSERTL0, Nektar::SpatialDomains::Geometry::GetEdge(), Nektar::SpatialDomains::Geometry::GetEid(), Nektar::SpatialDomains::Geometry::GetGlobalID(), Nektar::SpatialDomains::Geometry3D::m_edges, and Nektar::SpatialDomains::Geometry3D::m_faces.

Referenced by HexGeom().

 {
     // find edge 0
     int i, j;
     unsigned int check;
 
     SegGeomSharedPtr edge;
 
     // 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))
                 {
                     edge = std::dynamic_pointer_cast<SegGeom>(
                         (m_faces[0])->GetEdge(i));
                     m_edges.push_back(edge);
                     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();
             ASSERTL0(false, 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();
             ASSERTL0(false, 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))
             {
                 edge = std::dynamic_pointer_cast<SegGeom>(
                     (m_faces[1])->GetEdge(i));
                 m_edges.push_back(edge);
                 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();
         ASSERTL0(false, 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();
         ASSERTL0(false, 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))
                 {
                     edge = std::dynamic_pointer_cast<SegGeom>(
                         (m_faces[f])->GetEdge(i));
                     m_edges.push_back(edge);
                     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();
             ASSERTL0(false, 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();
             ASSERTL0(false, 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))
                 {
                     edge = std::dynamic_pointer_cast<SegGeom>(
                         (m_faces[5])->GetEdge(i));
                     m_edges.push_back(edge);
                     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();
             ASSERTL0(false, 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();
             ASSERTL0(false, errstrm.str());
         }
     }
 }

◆ SetUpLocalVertices()

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

private

Definition at line 466 of file HexGeom.cpp.

References ASSERTL0, Nektar::SpatialDomains::Geometry::GetGlobalID(), Nektar::SpatialDomains::Geometry::GetVertex(), Nektar::SpatialDomains::Geometry::GetVid(), Nektar::SpatialDomains::Geometry3D::m_edges, and Nektar::SpatialDomains::Geometry3D::m_verts.

Referenced by HexGeom().

 {
     // 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.push_back(m_edges[0]->GetVertex(1));
         m_verts.push_back(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.push_back(m_edges[0]->GetVertex(0));
         m_verts.push_back(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();
         ASSERTL0(false, 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.push_back(m_edges[i]->GetVertex(1));
         }
         else if (m_edges[i]->GetVid(1) == m_verts[i]->GetGlobalID())
         {
             m_verts.push_back(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();
             ASSERTL0(false, 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.push_back(m_edges[8]->GetVertex(1));
         m_verts.push_back(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.push_back(m_edges[8]->GetVertex(0));
         m_verts.push_back(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();
         ASSERTL0(false, 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.push_back(m_edges[i]->GetVertex(1));
         }
         else if (m_edges[i]->GetVid(1) == m_verts[i - 4]->GetGlobalID())
         {
             m_verts.push_back(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();
             ASSERTL0(false, errstrm.str());
         }
     }
 }

◆ 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 853 of file HexGeom.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eModified_A, Nektar::SpatialDomains::Geometry::GetXmap(), Nektar::SpatialDomains::Geometry3D::m_faces, Nektar::SpatialDomains::Geometry3D::m_forient, and Nektar::SpatialDomains::Geometry::m_xmap.

Referenced by v_Reset(), and v_Setup().

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

◆ v_ContainsPoint()

bool Nektar::SpatialDomains::HexGeom::v_ContainsPoint	(	const Array< OneD, const NekDouble > &	gloCoord,
		Array< OneD, NekDouble > &	locCoord,
		NekDouble	tol,
		NekDouble &	resid
	)

protectedvirtual

For curvilinear and non-affine elements (i.e. where the Jacobian varies as a function of the standard element coordinates), this is a non-linear optimisation problem that requires the use of a Newton iteration. Note therefore that this can be an expensive operation.

The parameter tol which is by default 0, can be used to expand the coordinate range of the standard element from \([-1,1]^d\) to \([-1-\epsilon,1+\epsilon\) to handle challenging edge cases. The function also returns the local coordinates corresponding to gloCoord that can be used to speed up subsequent searches.

Parameters

gloCoord	The coordinate \( (x,y,z) \).
locCoord	On exit, this is the local coordinate \(\vec{\xi}\) such that \(\chi(\vec{\xi}) = \vec{x}\).
tol	The tolerance used to dictate the bounding box of the standard coordinates \(\vec{\xi}\).
resid	On exit, returns the minimum distance between `gloCoord` and the quadrature points inside the element.

Returns: true if the coordinate gloCoord is contained in the element; false otherwise.

See also: Geometry::GetLocCoords.

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 254 of file HexGeom.cpp.

References Nektar::SpatialDomains::Geometry::ClampLocCoords(), Nektar::SpatialDomains::eRegular, Nektar::SpatialDomains::Geometry::GetLocCoords(), Nektar::SpatialDomains::Geometry::GetMetricInfo(), and Nektar::SpatialDomains::Geometry::MinMaxCheck().

 {
     boost::ignore_unused(resid);
     
     //Rough check if within twice min/max point
     if (GetMetricInfo()->GetGtype() != eRegular)
     {
         if (!MinMaxCheck(gloCoord))
         {
             return false;
         }
     }
 
     // Convert to the local Cartesian coordinates.
     resid = GetLocCoords(gloCoord, locCoord);
 
     // Check local coordinate is within cartesian bounds.
     if (locCoord[0] >= -(1 + tol) && locCoord[0] <= 1 + tol &&
         locCoord[1] >= -(1 + tol) && locCoord[1] <= 1 + tol &&
         locCoord[2] >= -(1 + tol) && locCoord[2] <= 1 + tol)
     {
         return true;
     }
 
     //Clamp local coords
     ClampLocCoords(locCoord, tol);
 
     return false;
 }

◆ v_GenGeomFactors()

void Nektar::SpatialDomains::HexGeom::v_GenGeomFactors ( )

protectedvirtual

Implements Nektar::SpatialDomains::Geometry.

Definition at line 87 of file HexGeom.cpp.

 {
     if(!m_setupState)
     {
         HexGeom::v_Setup();
     }
 
     if (m_geomFactorsState != ePtsFilled)
     {
         int i, f;
         GeomType Gtype = eRegular;
 
         v_FillGeom();
 
         // check to see if expansions are linear
         for (i = 0; i < m_coordim; ++i)
         {
             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)
         {
             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}};
 
             for (f = 0; f < kNfaces; f++)
             {
                 // Ensure each face is a parallelogram? Check this.
                 for (i = 0; i < m_coordim; i++)
                 {
                     if (fabs((*m_verts[faceVerts[f][0]])(i) -
                              (*m_verts[faceVerts[f][1]])(i) +
                              (*m_verts[faceVerts[f][2]])(i) -
                              (*m_verts[faceVerts[f][3]])(i)) >
                         NekConstants::kNekZeroTol)
                     {
                         Gtype = eDeformed;
                         break;
                     }
                 }
 
                 if (Gtype == eDeformed)
                 {
                     break;
                 }
             }
         }
 
         m_geomFactors = MemoryManager<GeomFactors>::AllocateSharedPtr(
             Gtype, m_coordim, m_xmap, m_coeffs);
         m_geomFactorsState = ePtsFilled;
     }
 }

◆ v_GetDir()

int Nektar::SpatialDomains::HexGeom::v_GetDir	(	const int	faceidx,
		const int	facedir
	)		const

protectedvirtual

Implements Nektar::SpatialDomains::Geometry3D.

Definition at line 302 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_GetEdgeFaceMap()

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

protectedvirtual

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 297 of file HexGeom.cpp.

References EdgeFaceConnectivity.

 {
     return EdgeFaceConnectivity[i][j];
 }

◆ v_GetLocCoords()

NekDouble Nektar::SpatialDomains::HexGeom::v_GetLocCoords	(	const Array< OneD, const NekDouble > &	coords,
		Array< OneD, NekDouble > &	Lcoords
	)

protectedvirtual

Determine the local collapsed coordinates that correspond to a given Cartesian coordinate for this geometry object.

For curvilinear and non-affine elements (i.e. where the Jacobian varies as a function of the standard element coordinates), this is a non-linear optimisation problem that requires the use of a Newton iteration. Note therefore that this can be an expensive operation.

Note that, clearly, the provided Cartesian coordinate lie outside the element. The function therefore returns the minimum distance from some position in the element to . Lcoords will also be constrained to fit within the range \([-1,1]^d\) where \( d \) is the dimension of the element.

Parameters

coords	Input Cartesian global coordinates
Lcoords	Corresponding local coordinates

Returns: Distance between obtained coordinates and provided ones.

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 152 of file HexGeom.cpp.

References Nektar::SpatialDomains::PointGeom::dist(), Nektar::SpatialDomains::eRegular, Nektar::SpatialDomains::Geometry::GetMetricInfo(), Vmath::Imin(), Nektar::SpatialDomains::Geometry::m_coeffs, Nektar::SpatialDomains::Geometry::m_coordim, Nektar::SpatialDomains::Geometry3D::m_verts, Nektar::SpatialDomains::Geometry::m_xmap, Nektar::SpatialDomains::Geometry3D::NewtonIterationForLocCoord(), Vmath::Sadd(), Nektar::SpatialDomains::Geometry3D::v_FillGeom(), Vmath::Vmul(), and Vmath::Vvtvp().

 {
     NekDouble ptdist = 1e6;
     int i;
 
     v_FillGeom();
 
     // calculate local coordinate for coord
     if (GetMetricInfo()->GetGtype() == eRegular)
     {
         NekDouble len0 = 0.0;
         NekDouble len1 = 0.0;
         NekDouble len2 = 0.0;
         NekDouble xi0 = 0.0;
         NekDouble xi1 = 0.0;
         NekDouble xi2 = 0.0;
         Array<OneD, NekDouble> pts(m_xmap->GetTotPoints());
         int nq0, nq1, nq2;
 
         // get points;
         // find end points
         for (i = 0; i < m_coordim; ++i)
         {
             nq0 = m_xmap->GetNumPoints(0);
             nq1 = m_xmap->GetNumPoints(1);
             nq2 = m_xmap->GetNumPoints(2);
 
             m_xmap->BwdTrans(m_coeffs[i], pts);
 
             // use projection to side 1 to determine xi_1 coordinate based on
             // length
             len0 += (pts[nq0 - 1] - pts[0]) * (pts[nq0 - 1] - pts[0]);
             xi0 += (coords[i] - pts[0]) * (pts[nq0 - 1] - pts[0]);
 
             // use projection to side 4 to determine xi_2 coordinate based on
             // length
             len1 += (pts[nq0 * (nq1 - 1)] - pts[0]) *
                     (pts[nq0 * (nq1 - 1)] - pts[0]);
             xi1 += (coords[i] - pts[0]) * (pts[nq0 * (nq1 - 1)] - pts[0]);
 
             // use projection to side 4 to determine xi_3 coordinate based on
             // length
             len2 += (pts[nq0 * nq1 * (nq2 - 1)] - pts[0]) *
                     (pts[nq0 * nq1 * (nq2 - 1)] - pts[0]);
             xi2 += (coords[i] - pts[0]) * (pts[nq0 * nq1 * (nq2 - 1)] - pts[0]);
         }
 
         Lcoords[0] = 2 * xi0 / len0 - 1.0;
         Lcoords[1] = 2 * xi1 / len1 - 1.0;
         Lcoords[2] = 2 * xi2 / len2 - 1.0;
 
         // Set ptdist to distance to nearest vertex
         // Point inside tetrahedron
         PointGeom r(m_coordim, 0, coords[0], coords[1], coords[2]);
         for (int i = 0; i < 8; ++i)
         {
             ptdist = min(ptdist, r.dist(*m_verts[i]));
         }
     }
     else
     {
         // Determine nearest point of coords  to values in m_xmap
         int npts = m_xmap->GetTotPoints();
         Array<OneD, NekDouble> ptsx(npts), ptsy(npts), ptsz(npts);
         Array<OneD, NekDouble> tmp1(npts), tmp2(npts);
 
         m_xmap->BwdTrans(m_coeffs[0], ptsx);
         m_xmap->BwdTrans(m_coeffs[1], ptsy);
         m_xmap->BwdTrans(m_coeffs[2], ptsz);
 
         const Array<OneD, const NekDouble> za = m_xmap->GetPoints(0);
         const Array<OneD, const NekDouble> zb = m_xmap->GetPoints(1);
         const Array<OneD, const NekDouble> zc = m_xmap->GetPoints(2);
 
         // guess the first local coords based on nearest point
         Vmath::Sadd(npts, -coords[0], ptsx, 1, tmp1, 1);
         Vmath::Vmul(npts, tmp1, 1, tmp1, 1, tmp1, 1);
         Vmath::Sadd(npts, -coords[1], ptsy, 1, tmp2, 1);
         Vmath::Vvtvp(npts, tmp2, 1, tmp2, 1, tmp1, 1, tmp1, 1);
         Vmath::Sadd(npts, -coords[2], ptsz, 1, tmp2, 1);
         Vmath::Vvtvp(npts, tmp2, 1, tmp2, 1, tmp1, 1, tmp1, 1);
 
         int min_i = Vmath::Imin(npts, tmp1, 1);
 
         // distance from coordinate to nearest point for return value.
         ptdist = sqrt(tmp1[min_i]);
 
         // Get Local coordinates
         int qa = za.num_elements(), qb = zb.num_elements();
         Lcoords[2] = zc[min_i / (qa * qb)];
         min_i = min_i % (qa * qb);
         Lcoords[1] = zb[min_i / qa];
         Lcoords[0] = za[min_i % qa];
 
         // Perform newton iteration to find local coordinates
         NekDouble resid = 0.0;
         NewtonIterationForLocCoord(coords, ptsx, ptsy, ptsz, Lcoords, resid);
     }
     return ptdist;
 }

◆ v_GetVertexEdgeMap()

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

protectedvirtual

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 287 of file HexGeom.cpp.

References VertexEdgeConnectivity.

 {
     return VertexEdgeConnectivity[i][j];
 }

◆ v_GetVertexFaceMap()

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

protectedvirtual

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 292 of file HexGeom.cpp.

References VertexFaceConnectivity.

 {
     return VertexFaceConnectivity[i][j];
 }

◆ v_Reset()

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

protectedvirtual

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

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 822 of file HexGeom.cpp.

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

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

◆ v_Setup()

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

protectedvirtual

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 835 of file HexGeom.cpp.

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

Referenced by v_GenGeomFactors().

 {
     if(!m_setupState)
     {
         for (int i = 0; i < 6; ++i)
         {
             m_faces[i]->Setup();
         }
         SetUpXmap();
         SetUpCoeffs(m_xmap->GetNcoeffs());
         m_setupState = true;
     }
 }

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 87 of file HexGeom.h.

Referenced by v_GetEdgeFaceMap().

◆ kNedges

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

static

Definition at line 57 of file HexGeom.h.

Referenced by HexGeom(), and SetUpEdgeOrientation().

◆ kNfaces

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

static

Definition at line 60 of file HexGeom.h.

Referenced by HexGeom(), SetUpFaceOrientation(), and v_GenGeomFactors().

◆ kNqfaces

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

static

Definition at line 58 of file HexGeom.h.

Referenced by SetUpFaceOrientation().

◆ kNtfaces

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

static

Definition at line 59 of file HexGeom.h.

Referenced by SetUpFaceOrientation().

◆ kNverts

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

static

Definition at line 56 of file HexGeom.h.

◆ 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 85 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 86 of file HexGeom.h.

Referenced by v_GetVertexFaceMap().

◆ XMLElementType

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

static

Definition at line 61 of file HexGeom.h.

Public Member Functions

Static Public Attributes

Protected Member Functions

Private Member Functions

Static Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ HexGeom() [1/2]

◆ HexGeom() [2/2]

◆ ~HexGeom()

Member Function Documentation

◆ SetUpEdgeOrientation()

◆ SetUpFaceOrientation()

◆ SetUpLocalEdges()

◆ SetUpLocalVertices()

◆ SetUpXmap()

◆ v_ContainsPoint()

◆ v_GenGeomFactors()

◆ v_GetDir()

◆ v_GetEdgeFaceMap()

◆ v_GetLocCoords()

◆ v_GetVertexEdgeMap()

◆ v_GetVertexFaceMap()

◆ v_Reset()

◆ v_Setup()

Member Data Documentation

◆ EdgeFaceConnectivity

◆ kNedges

◆ kNfaces

◆ kNqfaces

◆ kNtfaces

◆ kNverts

◆ VertexEdgeConnectivity

◆ VertexFaceConnectivity

◆ XMLElementType