#include <QuadGeom.h>

Inheritance diagram for Nektar::SpatialDomains::QuadGeom:

Public Member Functions
	QuadGeom ()

	QuadGeom (const QuadGeom &in)

	QuadGeom (const int id, const SegGeomSharedPtr edges[], const CurveSharedPtr curve=CurveSharedPtr())

	~QuadGeom () override=default

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

	Geometry2D (const int coordim, CurveSharedPtr curve)

	~Geometry2D () override=default

CurveSharedPtr	GetCurve ()

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

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

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)\). 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 &dist)
	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...

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

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

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

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

int	GetEdgeNormalToFaceVert (int i, int j) const
	Returns the standard lement edge IDs that are normal to a given face vertex. More...

int	GetDir (const int i, const int j=0) const
	Returns the element coordinate direction corresponding to a given face coordinate direction. 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	ResetNonRecursive (CurveMap &curvedEdges, CurveMap &curvedFaces)
	Reset this geometry object non-recursively: unset the current state, zero Geometry::m_coeffs and remove allocated GeomFactors. More...

void	Setup ()

void	GenGeomFactors ()
	Handles generation of geometry factors. More...

Static Public Member Functions
static StdRegions::Orientation	GetFaceOrientation (const QuadGeom &face1, const QuadGeom &face2, bool doRot=false, int dir=0, NekDouble angle=0.0, NekDouble tol=1e-8)
	Get the orientation of face1. More...

static StdRegions::Orientation	GetFaceOrientation (const PointGeomVector &face1, const PointGeomVector &face2, bool doRot=false, int dir=0, NekDouble angle=0.0, NekDouble tol=1e-8)

Static Public Attributes
static const int	kNverts = 4

static const int	kNedges = 4

static const std::string	XMLElementType

Static Public Attributes inherited from Nektar::SpatialDomains::Geometry2D
static const int	kDim = 2

Protected Member Functions
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`. More...

void	v_GenGeomFactors () override

void	v_FillGeom () override

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

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

void	v_Setup () override

void	PreSolveStraightEdge ()

Protected Member Functions inherited from Nektar::SpatialDomains::Geometry2D
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. More...

void	NewtonIterationForLocCoord (const Array< OneD, const NekDouble > &coords, const Array< OneD, const NekDouble > &ptsx, const Array< OneD, const NekDouble > &ptsy, Array< OneD, NekDouble > &Lcoords, NekDouble &dist)

void	SolveStraightEdgeQuad (const Array< OneD, const NekDouble > &coords, Array< OneD, NekDouble > &Lcoords)

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

PointGeomSharedPtr	v_GetVertex (int i) const override

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

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

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

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

NekDouble	v_FindDistance (const Array< OneD, const NekDouble > &xs, Array< OneD, NekDouble > &xi) override

Protected Member Functions inherited from Nektar::SpatialDomains::Geometry
virtual PointGeomSharedPtr	v_GetVertex (int i) const =0

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

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 int	v_GetShapeDim () const
	Get the object's shape dimension. 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...

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

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

virtual int	v_AllLeftCheck (const Array< OneD, const NekDouble > &gloCoord)

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 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 NekDouble	v_FindDistance (const Array< OneD, const NekDouble > &xs, Array< OneD, NekDouble > &xi)

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

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

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

virtual int	v_GetEdgeNormalToFaceVert (const int i, const int j) const
	Returns the standard lement edge IDs that are normal to a given face vertex. More...

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

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 ()

virtual void	v_GenGeomFactors ()=0

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

virtual void	v_CalculateInverseIsoParam ()

Private Member Functions
void	SetUpXmap ()

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::Geometry2D
PointGeomVector	m_verts

SegGeomVector	m_edges

std::vector< StdRegions::Orientation >	m_eorient

CurveSharedPtr	m_curve

Array< OneD, int >	m_manifold

Array< OneD, Array< OneD, NekDouble > >	m_edgeNormal

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

Array< OneD, NekDouble >	m_boundingBox
	Array containing bounding box. More...

Array< OneD, Array< OneD, NekDouble > >	m_isoParameter

Array< OneD, Array< OneD, NekDouble > >	m_invIsoParam

int	m_straightEdge

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

Detailed Description

Definition at line 55 of file QuadGeom.h.

Constructor & Destructor Documentation

◆ QuadGeom() [1/3]

Nektar::SpatialDomains::QuadGeom::QuadGeom ( )

Definition at line 47 of file QuadGeom.cpp.

{
    m_shapeType = LibUtilities::eQuadrilateral;
}

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

◆ QuadGeom() [2/3]

Nektar::SpatialDomains::QuadGeom::QuadGeom ( const QuadGeom & in )

Definition at line 84 of file QuadGeom.cpp.

                                     : Geometry2D(in)
{
    // From Geometry
    m_shapeType = in.m_shapeType;
    m_globalID  = in.m_globalID;
 
    // From QuadGeom
    m_verts = in.m_verts;
    m_edges = in.m_edges;
    for (int i = 0; i < kNedges; i++)
    {
        m_eorient[i] = in.m_eorient[i];
    }
}

References kNedges, Nektar::SpatialDomains::Geometry2D::m_edges, Nektar::SpatialDomains::Geometry2D::m_eorient, Nektar::SpatialDomains::Geometry::m_globalID, Nektar::SpatialDomains::Geometry::m_shapeType, and Nektar::SpatialDomains::Geometry2D::m_verts.

◆ QuadGeom() [3/3]

Nektar::SpatialDomains::QuadGeom::QuadGeom	(	const int	id,
		const SegGeomSharedPtr	edges[],
		const CurveSharedPtr	curve = `CurveSharedPtr()`
	)

Copy the edge shared pointers.

Definition at line 52 of file QuadGeom.cpp.

    : Geometry2D(edges[0]->GetVertex(0)->GetCoordim(), curve)
{
    int j;
 
    m_shapeType = LibUtilities::eQuadrilateral;
    m_globalID  = id;
 
    /// Copy the edge shared pointers.
    m_edges.insert(m_edges.begin(), edges, edges + QuadGeom::kNedges);
    m_eorient.resize(kNedges);
 
    for (j = 0; j < kNedges; ++j)
    {
        m_eorient[j] =
            SegGeom::GetEdgeOrientation(*edges[j], *edges[(j + 1) % kNedges]);
        m_verts.push_back(
            edges[j]->GetVertex(m_eorient[j] == StdRegions::eForwards ? 0 : 1));
    }
 
    for (j = 2; j < kNedges; ++j)
    {
        m_eorient[j] = m_eorient[j] == StdRegions::eBackwards
                           ? StdRegions::eForwards
                           : StdRegions::eBackwards;
    }
 
    m_coordim = edges[0]->GetVertex(0)->GetCoordim();
    ASSERTL0(m_coordim > 1, "Cannot call function with dim == 1");
}

References ASSERTL0, Nektar::StdRegions::eBackwards, Nektar::StdRegions::eForwards, Nektar::LibUtilities::eQuadrilateral, Nektar::SpatialDomains::SegGeom::GetEdgeOrientation(), Nektar::SpatialDomains::Geometry::GetVertex(), kNedges, Nektar::SpatialDomains::Geometry::m_coordim, Nektar::SpatialDomains::Geometry2D::m_edges, Nektar::SpatialDomains::Geometry2D::m_eorient, Nektar::SpatialDomains::Geometry::m_globalID, Nektar::SpatialDomains::Geometry::m_shapeType, and Nektar::SpatialDomains::Geometry2D::m_verts.

◆ ~QuadGeom()

Nektar::SpatialDomains::QuadGeom::~QuadGeom ( )

overridedefault

Member Function Documentation

◆ GetFaceOrientation() [1/2]

StdRegions::Orientation Nektar::SpatialDomains::QuadGeom::GetFaceOrientation	(	const PointGeomVector &	face1,
		const PointGeomVector &	face2,
		bool	doRot = `false`,
		int	dir = `0`,
		NekDouble	angle = `0.0`,
		NekDouble	tol = `1e-8`
	)

static

Calculate the orientation of face2 to face1 (note this is not face1 to face2!).

Definition at line 143 of file QuadGeom.cpp.

{
    int i, j, vmap[4] = {-1, -1, -1, -1};
 
    if (doRot)
    {
        PointGeom rotPt;
 
        for (i = 0; i < 4; ++i)
        {
            rotPt.Rotate((*face1[i]), dir, angle);
            for (j = 0; j < 4; ++j)
            {
                if (rotPt.dist(*face2[j]) < tol)
                {
                    vmap[j] = i;
                    break;
                }
            }
        }
    }
    else
    {
 
        NekDouble x, y, z, x1, y1, z1, cx = 0.0, cy = 0.0, cz = 0.0;
 
        // For periodic faces, we calculate the vector between the centre
        // points of the two faces. (For connected faces this will be
        // zero). We can then use this to determine alignment later in the
        // algorithm.
        for (i = 0; i < 4; ++i)
        {
            cx += (*face2[i])(0) - (*face1[i])(0);
            cy += (*face2[i])(1) - (*face1[i])(1);
            cz += (*face2[i])(2) - (*face1[i])(2);
        }
        cx /= 4;
        cy /= 4;
        cz /= 4;
 
        // Now construct a mapping which takes us from the vertices of one
        // face to the other. That is, vertex j of face2 corresponds to
        // vertex vmap[j] of face1.
        for (i = 0; i < 4; ++i)
        {
            x = (*face1[i])(0);
            y = (*face1[i])(1);
            z = (*face1[i])(2);
            for (j = 0; j < 4; ++j)
            {
                x1 = (*face2[j])(0) - cx;
                y1 = (*face2[j])(1) - cy;
                z1 = (*face2[j])(2) - cz;
                if (sqrt((x1 - x) * (x1 - x) + (y1 - y) * (y1 - y) +
                         (z1 - z) * (z1 - z)) < 1e-8)
                {
                    vmap[j] = i;
                    break;
                }
            }
        }
    }
 
    // Use the mapping to determine the eight alignment options between
    // faces.
    if (vmap[1] == (vmap[0] + 1) % 4)
    {
        switch (vmap[0])
        {
            case 0:
                return StdRegions::eDir1FwdDir1_Dir2FwdDir2;
                break;
            case 1:
                return StdRegions::eDir1BwdDir2_Dir2FwdDir1;
                break;
            case 2:
                return StdRegions::eDir1BwdDir1_Dir2BwdDir2;
                break;
            case 3:
                return StdRegions::eDir1FwdDir2_Dir2BwdDir1;
                break;
        }
    }
    else
    {
        switch (vmap[0])
        {
            case 0:
                return StdRegions::eDir1FwdDir2_Dir2FwdDir1;
                break;
            case 1:
                return StdRegions::eDir1BwdDir1_Dir2FwdDir2;
                break;
            case 2:
                return StdRegions::eDir1BwdDir2_Dir2BwdDir1;
                break;
            case 3:
                return StdRegions::eDir1FwdDir1_Dir2BwdDir2;
                break;
        }
    }
 
    ASSERTL0(false, "unable to determine face orientation");
    return StdRegions::eDir1FwdDir1_Dir2FwdDir2;
}

◆ GetFaceOrientation() [2/2]

StdRegions::Orientation Nektar::SpatialDomains::QuadGeom::GetFaceOrientation	(	const QuadGeom &	face1,
		const QuadGeom &	face2,
		bool	doRot = `false`,
		int	dir = `0`,
		NekDouble	angle = `0.0`,
		NekDouble	tol = `1e-8`
	)

static

Get the orientation of face1.

Definition at line 129 of file QuadGeom.cpp.

{
    return GetFaceOrientation(face1.m_verts, face2.m_verts, doRot, dir, angle,
                              tol);
}

References GetFaceOrientation(), and Nektar::SpatialDomains::Geometry2D::m_verts.

Referenced by Nektar::MultiRegions::DisContField::FindPeriodicTraces(), and GetFaceOrientation().

◆ PreSolveStraightEdge()

void Nektar::SpatialDomains::QuadGeom::PreSolveStraightEdge ( )

protected

Definition at line 458 of file QuadGeom.cpp.

{
    int i0, i1, j1, j2;
    if (fabs(m_isoParameter[0][3]) >= fabs(m_isoParameter[1][3]))
    {
        i0 = 0;
        i1 = 1;
    }
    else
    {
        i1 = 0;
        i0 = 1;
        m_straightEdge |= 2;
    }
    NekDouble gamma = m_isoParameter[i1][3] / m_isoParameter[i0][3];
    std::vector<NekDouble> c(3);
    for (int i = 0; i < 3; ++i)
    {
        c[i] = m_isoParameter[i1][i] - gamma * m_isoParameter[i0][i];
    }
    if (fabs(c[1]) >= fabs(c[2]))
    {
        j1 = 1;
        j2 = 2;
    }
    else
    {
        j1 = 2;
        j2 = 1;
        m_straightEdge |= 4;
    }
    NekDouble beta = c[j2] / c[j1];
    if (i0 == 1)
    {
        Vmath::Vcopy(4, m_isoParameter[1], 1, m_isoParameter[0], 1);
    }
    if (j1 == 2)
    {
        NekDouble temp        = m_isoParameter[0][j1];
        m_isoParameter[0][j1] = m_isoParameter[0][j2];
        m_isoParameter[0][j2] = temp;
    }
    m_isoParameter[0][2] -= m_isoParameter[0][1] * beta;
    m_isoParameter[1][0] = c[0];
    m_isoParameter[1][1] = 1. / c[j1];
    m_isoParameter[1][2] = beta;
    m_isoParameter[1][3] = gamma;
}

References Nektar::LibUtilities::beta, Nektar::SpatialDomains::Geometry::m_isoParameter, Nektar::SpatialDomains::Geometry::m_straightEdge, and Vmath::Vcopy().

Referenced by v_GenGeomFactors().

◆ SetUpXmap()

void Nektar::SpatialDomains::QuadGeom::SetUpXmap ( )

private

Definition at line 99 of file QuadGeom.cpp.

{
    int order0 = std::max(m_edges[0]->GetXmap()->GetBasis(0)->GetNumModes(),
                          m_edges[2]->GetXmap()->GetBasis(0)->GetNumModes());
    int order1 = std::max(m_edges[1]->GetXmap()->GetBasis(0)->GetNumModes(),
                          m_edges[3]->GetXmap()->GetBasis(0)->GetNumModes());
 
    const LibUtilities::BasisKey B0(
        LibUtilities::eModified_A, order0,
        LibUtilities::PointsKey(order0 + 1,
                                LibUtilities::eGaussLobattoLegendre));
    const LibUtilities::BasisKey B1(
        LibUtilities::eModified_A, order1,
        LibUtilities::PointsKey(order1 + 1,
                                LibUtilities::eGaussLobattoLegendre));
 
    m_xmap = MemoryManager<StdRegions::StdQuadExp>::AllocateSharedPtr(B0, B1);
}

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

Referenced by v_Reset(), and v_Setup().

◆ v_FillGeom()

void Nektar::SpatialDomains::QuadGeom::v_FillGeom ( )

overrideprotectedvirtual

Note verts and edges 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 383 of file QuadGeom.cpp.

{
    // check to see if geometry structure is already filled
    if (m_state != ePtsFilled)
    {
        int i, j, k;
        int nEdgeCoeffs;
 
        if (m_curve)
        {
            int npts     = m_curve->m_points.size();
            int nEdgePts = (int)sqrt(static_cast<NekDouble>(npts));
            Array<OneD, NekDouble> tmp(npts);
            Array<OneD, NekDouble> tmp2(m_xmap->GetTotPoints());
            LibUtilities::PointsKey curveKey(nEdgePts, m_curve->m_ptype);
 
            // Sanity checks:
            // - Curved faces should have square number of points;
            // - Each edge should have sqrt(npts) points.
            ASSERTL0(nEdgePts * nEdgePts == npts,
                     "NUMPOINTS should be a square number in"
                     " quadrilteral " +
                         std::to_string(m_globalID));
 
            for (i = 0; i < kNedges; ++i)
            {
                ASSERTL0(m_edges[i]->GetXmap()->GetNcoeffs() == nEdgePts,
                         "Number of edge points does not correspond to "
                         "number of face points in quadrilateral " +
                             std::to_string(m_globalID));
            }
 
            for (i = 0; i < m_coordim; ++i)
            {
                for (j = 0; j < npts; ++j)
                {
                    tmp[j] = (m_curve->m_points[j]->GetPtr())[i];
                }
 
                // Interpolate m_curve points to GLL points
                LibUtilities::Interp2D(curveKey, curveKey, tmp,
                                       m_xmap->GetBasis(0)->GetPointsKey(),
                                       m_xmap->GetBasis(1)->GetPointsKey(),
                                       tmp2);
 
                // Forwards transform to get coefficient space.
                m_xmap->FwdTrans(tmp2, m_coeffs[i]);
            }
        }
 
        // Now fill in edges.
        Array<OneD, unsigned int> mapArray;
        Array<OneD, int> signArray;
 
        for (i = 0; i < kNedges; i++)
        {
            m_edges[i]->FillGeom();
            m_xmap->GetTraceToElementMap(i, mapArray, signArray, m_eorient[i]);
 
            nEdgeCoeffs = m_edges[i]->GetXmap()->GetNcoeffs();
 
            for (j = 0; j < m_coordim; j++)
            {
                for (k = 0; k < nEdgeCoeffs; k++)
                {
                    m_coeffs[j][mapArray[k]] =
                        signArray[k] * (m_edges[i]->GetCoeffs(j))[k];
                }
            }
        }
 
        m_state = ePtsFilled;
    }
}

Referenced by v_GenGeomFactors().

◆ v_GenGeomFactors()

void Nektar::SpatialDomains::QuadGeom::v_GenGeomFactors ( )

overrideprotectedvirtual

Set up GeoFac for this geometry using Coord quadrature distribution

Implements Nektar::SpatialDomains::Geometry.

Definition at line 254 of file QuadGeom.cpp.

{
    if (!m_setupState)
    {
        QuadGeom::v_Setup();
    }
 
    if (m_geomFactorsState != ePtsFilled)
    {
        GeomType Gtype = eRegular;
 
        QuadGeom::v_FillGeom();
 
        // We will first check whether we have a regular or deformed
        // geometry. We will define regular as those cases where the
        // Jacobian and the metric terms of the derivative are constants
        // (i.e. not coordinate dependent)
 
        // Check to see if expansions are linear
        // If not linear => deformed geometry
        m_straightEdge = 1;
        if ((m_xmap->GetBasisNumModes(0) != 2) ||
            (m_xmap->GetBasisNumModes(1) != 2))
        {
            Gtype          = eDeformed;
            m_straightEdge = 0;
        }
 
        // For linear expansions, the mapping from standard to local
        // element is given by the relation:
        // x_i = 0.25 * [ ( x_i^A + x_i^B + x_i^C + x_i^D)       +
        //                (-x_i^A + x_i^B + x_i^C - x_i^D)*xi_1  +
        //                (-x_i^A - x_i^B + x_i^C + x_i^D)*xi_2  +
        //                ( x_i^A - x_i^B + x_i^C - x_i^D)*xi_1*xi_2 ]
        //
        // The jacobian of the transformation and the metric terms
        // dxi_i/dx_j, involve only terms of the form dx_i/dxi_j (both
        // for coordim == 2 or 3). Inspecting the formula above, it can
        // be appreciated that the derivatives dx_i/dxi_j will be
        // constant, if the coefficient of the non-linear term is zero.
        //
        // That is why for regular geometry, we require
        //
        //     x_i^A - x_i^B + x_i^C - x_i^D = 0
        //
        // or equivalently
        //
        //     x_i^A - x_i^B = x_i^D - x_i^C
        //
        // This corresponds to quadrilaterals which are paralellograms.
        m_manifold    = Array<OneD, int>(m_coordim);
        m_manifold[0] = 0;
        m_manifold[1] = 1;
        if (m_coordim == 3)
        {
            PointGeom e01, e21, norm;
            e01.Sub(*m_verts[0], *m_verts[1]);
            e21.Sub(*m_verts[3], *m_verts[1]);
            norm.Mult(e01, e21);
            int tmpi   = 0;
            double tmp = std::fabs(norm[0]);
            if (tmp < fabs(norm[1]))
            {
                tmp  = fabs(norm[1]);
                tmpi = 1;
            }
            if (tmp < fabs(norm[2]))
            {
                tmpi = 2;
            }
            m_manifold[0] = (tmpi + 1) % 3;
            m_manifold[1] = (tmpi + 2) % 3;
            m_manifold[2] = (tmpi + 3) % 3;
        }
 
        if (Gtype == eRegular)
        {
            Array<OneD, Array<OneD, NekDouble>> verts(m_verts.size());
            for (int i = 0; i < m_verts.size(); ++i)
            {
                verts[i] = Array<OneD, NekDouble>(3);
                m_verts[i]->GetCoords(verts[i]);
            }
            // a00 + a01 xi1 + a02 xi2 + a03 xi1 xi2
            // a10 + a11 xi1 + a12 xi2 + a03 xi1 xi2
            m_isoParameter = Array<OneD, Array<OneD, NekDouble>>(2);
            for (int i = 0; i < 2; i++)
            {
                unsigned int d    = m_manifold[i];
                m_isoParameter[i] = Array<OneD, NekDouble>(4, 0.);
                // Karniadakis, Sherwin 2005, Appendix D
                NekDouble A          = verts[0][d];
                NekDouble B          = verts[1][d];
                NekDouble D          = verts[2][d];
                NekDouble C          = verts[3][d];
                m_isoParameter[i][0] = 0.25 * (A + B + C + D);  // 1
                m_isoParameter[i][1] = 0.25 * (-A + B - C + D); // xi1
                m_isoParameter[i][2] = 0.25 * (-A - B + C + D); // xi2
                m_isoParameter[i][3] = 0.25 * (A - B - C + D);  // xi1*xi2
                NekDouble tmp =
                    fabs(m_isoParameter[i][1]) + fabs(m_isoParameter[i][2]);
                if (fabs(m_isoParameter[i][3]) >
                    tmp * NekConstants::kNekZeroTol)
                {
                    Gtype = eDeformed;
                }
            }
        }
 
        if (Gtype == eRegular)
        {
            v_CalculateInverseIsoParam();
        }
        else if (m_straightEdge)
        {
            PreSolveStraightEdge();
        }
 
        m_geomFactors = MemoryManager<GeomFactors>::AllocateSharedPtr(
            Gtype, m_coordim, m_xmap, m_coeffs);
        m_geomFactorsState = ePtsFilled;
    }
}

◆ v_GetCoord()

NekDouble Nektar::SpatialDomains::QuadGeom::v_GetCoord	(	const int	i,
		const Array< OneD, const NekDouble > &	Lcoord
	)

overrideprotectedvirtual

Given local collapsed coordinate Lcoord, return the value of physical coordinate in direction i.

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 118 of file QuadGeom.cpp.

{
    ASSERTL1(m_state == ePtsFilled, "Geometry is not in physical space");
 
    Array<OneD, NekDouble> tmp(m_xmap->GetTotPoints());
    m_xmap->BwdTrans(m_coeffs[i], tmp);
 
    return m_xmap->PhysEvaluate(Lcoord, tmp);
}

References ASSERTL1, Nektar::SpatialDomains::ePtsFilled, Nektar::SpatialDomains::Geometry::m_coeffs, Nektar::SpatialDomains::Geometry::m_state, and Nektar::SpatialDomains::Geometry::m_xmap.

◆ v_GetDir()

int Nektar::SpatialDomains::QuadGeom::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 507 of file QuadGeom.cpp.

{
    return i % 2;
}

◆ v_Reset()

void Nektar::SpatialDomains::QuadGeom::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 512 of file QuadGeom.cpp.

{
    Geometry::v_Reset(curvedEdges, curvedFaces);
    CurveMap::iterator it = curvedFaces.find(m_globalID);
 
    if (it != curvedFaces.end())
    {
        m_curve = it->second;
    }
 
    for (int i = 0; i < 4; ++i)
    {
        m_edges[i]->Reset(curvedEdges, curvedFaces);
    }
 
    SetUpXmap();
    SetUpCoeffs(m_xmap->GetNcoeffs());
}

References Nektar::SpatialDomains::Geometry2D::m_curve, Nektar::SpatialDomains::Geometry2D::m_edges, Nektar::SpatialDomains::Geometry::m_globalID, Nektar::SpatialDomains::Geometry::m_xmap, Nektar::SpatialDomains::Geometry::SetUpCoeffs(), SetUpXmap(), and Nektar::SpatialDomains::Geometry::v_Reset().

◆ v_Setup()

void Nektar::SpatialDomains::QuadGeom::v_Setup ( )

overrideprotectedvirtual

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 531 of file QuadGeom.cpp.

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

References Nektar::SpatialDomains::Geometry2D::m_edges, Nektar::SpatialDomains::Geometry::m_setupState, Nektar::SpatialDomains::Geometry::m_xmap, Nektar::SpatialDomains::Geometry::SetUpCoeffs(), and SetUpXmap().

Referenced by v_GenGeomFactors().

Member Data Documentation

◆ kNedges

const int Nektar::SpatialDomains::QuadGeom::kNedges = 4

static

Definition at line 75 of file QuadGeom.h.

Referenced by Nektar::HexCollectionTests::CreateHex(), Nektar::HexExpTests::CreateHex(), Nektar::Expansion3DTests::CreateHex(), Nektar::PrismCollectionTests::CreatePrism(), Nektar::PyrCollectionTests::CreatePyr(), Nektar::QuadCollectionTests::CreateQuad(), QuadGeom(), v_FillGeom(), Nektar::SpatialDomains::MeshGraphIOXml::v_ReadElements2D(), Nektar::SpatialDomains::MeshGraphIOXmlCompressed::v_ReadElements2D(), Nektar::SpatialDomains::MeshGraphIOXml::v_ReadFaces(), and Nektar::SpatialDomains::MeshGraphIOXmlCompressed::v_ReadFaces().

◆ kNverts

const int Nektar::SpatialDomains::QuadGeom::kNverts = 4

static

Definition at line 74 of file QuadGeom.h.

Referenced by Nektar::SpatialDomains::HexGeom::SetUpFaceOrientation(), and Nektar::SpatialDomains::PrismGeom::SetUpFaceOrientation().

◆ XMLElementType

const std::string Nektar::SpatialDomains::QuadGeom::XMLElementType

static

Definition at line 76 of file QuadGeom.h.

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Private Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ QuadGeom() [1/3]

◆ QuadGeom() [2/3]

◆ QuadGeom() [3/3]

◆ ~QuadGeom()

Member Function Documentation

◆ GetFaceOrientation() [1/2]

◆ GetFaceOrientation() [2/2]

◆ PreSolveStraightEdge()

◆ SetUpXmap()

◆ v_FillGeom()

◆ v_GenGeomFactors()

◆ v_GetCoord()

◆ v_GetDir()

◆ v_Reset()

◆ v_Setup()

Member Data Documentation

◆ kNedges

◆ kNverts

◆ XMLElementType