#include <TriGeom.h>

Inheritance diagram for Nektar::SpatialDomains::TriGeom:

Public Member Functions
	TriGeom ()

	TriGeom (const TriGeom &in)

	TriGeom (const int id, std::array< SegGeom , kNedges > edges, Curve curve=nullptr)

	~TriGeom () override=default

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

	Geometry2D (const int coordim, Curve *curve)

	~Geometry2D () override=default

Curve *	GetCurve ()

void	SetCurve (Curve *curvePtr)

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 Member Functions
static StdRegions::Orientation	GetFaceOrientation (const TriGeom &face1, const TriGeom &face2, bool doRot, int dir, NekDouble angle, NekDouble tol)
	Get the orientation of face1.

static StdRegions::Orientation	GetFaceOrientation (std::array< PointGeom , kNedges > face1, std::array< PointGeom , kNedges > face2, bool doRot, int dir, NekDouble angle, NekDouble tol)

Static Public Attributes
static const int	kNedges = 3

static const int	kNverts = 3

static const int	kNfacets = kNedges

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

GeomType	v_CalcGeomType () override

GeomFactorsUniquePtr	v_GenGeomFactors (LibUtilities::PointsKeyVector &keyTgt) override
	Used by Expansion to generate associated GeomFactors.

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.

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

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

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.

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.

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.

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.

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

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

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 Geometry2D *	v_GetFace (const int i) const
	Returns face `i` of this object.

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.

virtual int	v_GetNumFaces () const
	Get the number of faces 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 int	v_GetVertexEdgeMap (int i, int j) const
	Returns the standard element edge IDs that are connected to a given vertex.

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

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

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.

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< StdRegions::Orientation, kNedges >	m_eorient

Protected Attributes inherited from Nektar::SpatialDomains::Geometry2D
Curve *	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.

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

Detailed Description

Definition at line 54 of file TriGeom.h.

Constructor & Destructor Documentation

◆ TriGeom() [1/3]

Nektar::SpatialDomains::TriGeom::TriGeom ( )

Definition at line 54 of file TriGeom.cpp.

{
    m_shapeType = LibUtilities::eTriangle;
}

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

◆ TriGeom() [2/3]

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

Definition at line 90 of file TriGeom.cpp.

                                  : Geometry2D(in)
{
    // From Geometry
    m_shapeType = in.m_shapeType;
 
    // From TriFaceComponent
    m_globalID = in.m_globalID;
 
    // From TriGeom
    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, m_edges, m_eorient, Nektar::SpatialDomains::Geometry::m_globalID, Nektar::SpatialDomains::Geometry::m_shapeType, and m_verts.

◆ TriGeom() [3/3]

Nektar::SpatialDomains::TriGeom::TriGeom	(	const int	id,
		std::array< SegGeom *, kNedges >	edges,
		Curve *	curve = `nullptr`
	)

Copy the edge pointers

Definition at line 59 of file TriGeom.cpp.

    : Geometry2D(edges[0]->GetVertex(0)->GetCoordim(), curve)
{
    int j;
 
    m_shapeType = LibUtilities::eTriangle;
    m_globalID  = id;
 
    /// Copy the edge pointers
    m_edges = edges;
 
    for (j = 0; j < kNedges; ++j)
    {
        m_eorient[j] =
            SegGeom::GetEdgeOrientation(*edges[j], *edges[(j + 1) % kNedges]);
        m_verts[j] =
            edges[j]->GetVertex(m_eorient[j] == StdRegions::eForwards ? 0 : 1);
    }
 
    m_eorient[2] = m_eorient[2] == StdRegions::eBackwards
                       ? StdRegions::eForwards
                       : StdRegions::eBackwards;
 
    m_coordim = edges[0]->GetVertex(0)->GetCoordim();
    if (m_coordim <= 1)
    {
        NEKERROR(ErrorUtil::efatal, "Cannot call function with dim == 1");
    }
}

References Nektar::StdRegions::eBackwards, Nektar::ErrorUtil::efatal, Nektar::StdRegions::eForwards, Nektar::LibUtilities::eTriangle, Nektar::SpatialDomains::SegGeom::GetEdgeOrientation(), kNedges, Nektar::SpatialDomains::Geometry::m_coordim, m_edges, m_eorient, Nektar::SpatialDomains::Geometry::m_globalID, Nektar::SpatialDomains::Geometry::m_shapeType, m_verts, and NEKERROR.

◆ ~TriGeom()

Nektar::SpatialDomains::TriGeom::~TriGeom ( )

overridedefault

Member Function Documentation

◆ GetFaceOrientation() [1/2]

StdRegions::Orientation Nektar::SpatialDomains::TriGeom::GetFaceOrientation	(	const TriGeom &	face1,
		const TriGeom &	face2,
		bool	doRot,
		int	dir,
		NekDouble	angle,
		NekDouble	tol
	)

static

Get the orientation of face1.

Definition at line 207 of file TriGeom.cpp.

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

References GetFaceOrientation(), and m_verts.

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

◆ GetFaceOrientation() [2/2]

static StdRegions::Orientation Nektar::SpatialDomains::TriGeom::GetFaceOrientation	(	std::array< PointGeom *, kNedges >	face1,
		std::array< PointGeom *, kNedges >	face2,
		bool	doRot,
		int	dir,
		NekDouble	angle,
		NekDouble	tol
	)

static

◆ SetUpXmap()

void Nektar::SpatialDomains::TriGeom::SetUpXmap ( )

private

Definition at line 659 of file TriGeom.cpp.

{
    int order0 = m_edges[0]->GetXmap()->GetBasis(0)->GetNumModes();
    int order1 = std::max(
        order0, std::max(m_edges[1]->GetXmap()->GetBasis(0)->GetNumModes(),
                         m_edges[2]->GetXmap()->GetBasis(0)->GetNumModes()));
 
    std::array<LibUtilities::BasisKey, 2> basis = {
        LibUtilities::BasisKey(
            LibUtilities::eModified_A, order0,
            LibUtilities::PointsKey(order0 + 1,
                                    LibUtilities::eGaussLobattoLegendre)),
        LibUtilities::BasisKey(
            LibUtilities::eModified_B, order1,
            LibUtilities::PointsKey(order1,
                                    LibUtilities::eGaussRadauMAlpha1Beta0))};
 
    m_xmap = GetStdTriFactory().CreateInstance(basis);
}

References Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eModified_A, Nektar::LibUtilities::eModified_B, Nektar::SpatialDomains::GetStdTriFactory(), Nektar::SpatialDomains::Geometry::GetXmap(), m_edges, and Nektar::SpatialDomains::Geometry::m_xmap.

Referenced by v_Reset(), and v_Setup().

◆ v_AllLeftCheck()

int Nektar::SpatialDomains::TriGeom::v_AllLeftCheck ( const Array< OneD, const NekDouble > & gloCoord )

overrideprotectedvirtual

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 107 of file TriGeom.cpp.

{
    int nc = 1, d0 = m_manifold[0], d1 = m_manifold[1];
    if (0 == m_edgeNormal.size())
    {
        m_edgeNormal = Array<OneD, Array<OneD, NekDouble>>(m_verts.size());
        Array<OneD, Array<OneD, NekDouble>> x(2);
        x[0] = Array<OneD, NekDouble>(3);
        x[1] = Array<OneD, NekDouble>(3);
        m_verts[0]->GetCoords(x[0]);
        int i0 = 1, i1 = 0, direction = 1;
        for (size_t i = 0; i < m_verts.size(); ++i)
        {
            i0 ^= 1;
            i1 ^= 1;
            m_verts[(i + 1) % m_verts.size()]->GetCoords(x[i1]);
            if (m_edges[i]->GetXmap()->GetBasis(0)->GetNumModes() > 2)
            {
                continue;
            }
            m_edgeNormal[i]    = Array<OneD, NekDouble>(2);
            m_edgeNormal[i][0] = x[i0][d1] - x[i1][d1];
            m_edgeNormal[i][1] = x[i1][d0] - x[i0][d0];
        }
        if (m_coordim == 3)
        {
            for (size_t i = 0; i < m_verts.size(); ++i)
            {
                if (m_edgeNormal[i].size() == 2)
                {
                    m_verts[i]->GetCoords(x[0]);
                    m_verts[(i + 2) % m_verts.size()]->GetCoords(x[1]);
                    if (m_edgeNormal[i][0] * (x[1][d0] - x[0][d0]) <
                        m_edgeNormal[i][1] * (x[0][d1] - x[1][d1]))
                    {
                        direction = -1;
                    }
                    break;
                }
            }
        }
        if (direction == -1)
        {
            for (size_t i = 0; i < m_verts.size(); ++i)
            {
                if (m_edgeNormal[i].size() == 2)
                {
                    m_edgeNormal[i][0] = -m_edgeNormal[i][0];
                    m_edgeNormal[i][1] = -m_edgeNormal[i][1];
                }
            }
        }
    }
 
    Array<OneD, NekDouble> vertex(3);
    for (size_t i = 0; i < m_verts.size(); ++i)
    {
        int i1 = (i + 1) % m_verts.size();
        if (m_verts[i]->GetGlobalID() < m_verts[i1]->GetGlobalID())
        {
            m_verts[i]->GetCoords(vertex);
        }
        else
        {
            m_verts[i1]->GetCoords(vertex);
        }
        if (m_edgeNormal[i].size() == 0)
        {
            nc = 0; // not sure
            continue;
        }
        if (m_edgeNormal[i][0] * (gloCoord[d0] - vertex[d0]) <
            m_edgeNormal[i][1] * (vertex[d1] - gloCoord[d1]))
        {
            return -1; // outside
        }
    }
    // 3D manifold needs to check the distance
    if (m_coordim == 3)
    {
        nc = 0;
    }
    // nc: 1 (side element), 0 (maybe inside), -1 (outside)
    return nc;
}

References Nektar::SpatialDomains::Geometry::GetGlobalID(), Nektar::SpatialDomains::Geometry::GetXmap(), Nektar::SpatialDomains::Geometry::m_coordim, Nektar::SpatialDomains::Geometry2D::m_edgeNormal, m_edges, Nektar::SpatialDomains::Geometry2D::m_manifold, and m_verts.

◆ v_CalcGeomType()

GeomType Nektar::SpatialDomains::TriGeom::v_CalcGeomType ( )

overrideprotectedvirtual

Calculates the GeomType (deformed, regular etc).

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 316 of file TriGeom.cpp.

{
    if (!m_setupState)
    {
        TriGeom::v_Setup();
    }
    TriGeom::v_FillGeom();
 
    GeomType Gtype = eRegular;
 
    // check to see if expansions are linear
    if (m_xmap->GetBasisNumModes(0) != 2 || m_xmap->GetBasisNumModes(1) != 2)
    {
        Gtype = eDeformed;
    }
 
    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[2], *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
        // a10 + a11 xi1 + a12 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>(3, 0.);
            NekDouble A          = verts[0][d];
            NekDouble B          = verts[1][d];
            NekDouble C          = verts[2][d];
            m_isoParameter[i][0] = 0.5 * (B + C);  // 1
            m_isoParameter[i][1] = 0.5 * (-A + B); // xi1
            m_isoParameter[i][2] = 0.5 * (-A + C); // xi2
        }
    }
 
    if (Gtype == eRegular)
    {
        v_CalculateInverseIsoParam();
    }
 
    return Gtype;
}

◆ v_FillGeom()

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

{
    // check to see if geometry structure is already filled
    if (m_state == ePtsFilled)
    {
        return;
    }
 
    int i, j, k;
    int nEdgeCoeffs = m_xmap->GetTraceNcoeffs(0);
 
    if (m_curve)
    {
        int pdim = LibUtilities::PointsManager()[LibUtilities::PointsKey(
                                                     2, m_curve->m_ptype)]
                       ->GetPointsDim();
 
        // Deal with 2D points type separately
        // (e.g. electrostatic or Fekete points) to 1D tensor
        // product.
        if (pdim == 2)
        {
            int N = m_curve->m_points.size();
            int nEdgePts =
                (-1 + (int)sqrt(static_cast<NekDouble>(8 * N + 1))) / 2;
 
            ASSERTL0(nEdgePts * (nEdgePts + 1) / 2 == N,
                     "NUMPOINTS should be a triangle number for"
                     " triangle curved face " +
                         std::to_string(m_globalID));
 
            // Sanity check 1: are curved vertices consistent with
            // triangle vertices?
            for (i = 0; i < 3; ++i)
            {
                NekDouble dist = m_verts[i]->dist(*(m_curve->m_points[i]));
                if (dist > NekConstants::kVertexTheSameDouble)
                {
                    std::stringstream ss;
                    ss << "Curved vertex " << i << " of triangle " << m_globalID
                       << " is separated from expansion vertex by"
                       << " more than " << NekConstants::kVertexTheSameDouble
                       << " (dist = " << dist << ")";
                    NEKERROR(ErrorUtil::ewarning, ss.str().c_str());
                }
            }
 
            // Sanity check 2: are curved edges from the face curvature
            // consistent with curved edges?
            for (i = 0; i < kNedges; ++i)
            {
                Curve *edgeCurve = m_edges[i]->GetCurve();
 
                ASSERTL0(edgeCurve->m_points.size() == nEdgePts,
                         "Number of edge points does not correspond "
                         "to number of face points in triangle " +
                             std::to_string(m_globalID));
 
                const int offset  = 3 + i * (nEdgePts - 2);
                NekDouble maxDist = 0.0;
 
                // Account for different ordering of nodal coordinates
                // vs. Cartesian ordering of element.
                StdRegions::Orientation orient = m_eorient[i];
 
                if (i == 2)
                {
                    orient = orient == StdRegions::eForwards
                                 ? StdRegions::eBackwards
                                 : StdRegions::eForwards;
                }
 
                if (orient == StdRegions::eForwards)
                {
                    for (j = 0; j < nEdgePts - 2; ++j)
                    {
                        NekDouble dist = m_curve->m_points[offset + j]->dist(
                            *(edgeCurve->m_points[j + 1]));
                        maxDist = dist > maxDist ? dist : maxDist;
                    }
                }
                else
                {
                    for (j = 0; j < nEdgePts - 2; ++j)
                    {
                        NekDouble dist = m_curve->m_points[offset + j]->dist(
                            *(edgeCurve->m_points[nEdgePts - 2 - j]));
                        maxDist = dist > maxDist ? dist : maxDist;
                    }
                }
 
                if (maxDist > NekConstants::kVertexTheSameDouble)
                {
                    std::stringstream ss;
                    ss << "Curved edge " << i << " of triangle " << m_globalID
                       << " has a point separated from edge interior"
                       << " points by more than "
                       << NekConstants::kVertexTheSameDouble
                       << " (maxdist = " << maxDist << ")";
                    NEKERROR(ErrorUtil::ewarning, ss.str().c_str());
                }
            }
 
            const LibUtilities::PointsKey P0(
                nEdgePts, LibUtilities::eGaussLobattoLegendre);
            const LibUtilities::PointsKey P1(
                nEdgePts, LibUtilities::eGaussRadauMAlpha1Beta0);
            const LibUtilities::BasisKey T0(LibUtilities::eOrtho_A, nEdgePts,
                                            P0);
            const LibUtilities::BasisKey T1(LibUtilities::eOrtho_B, nEdgePts,
                                            P1);
            Array<OneD, NekDouble> phys(
                std::max(nEdgePts * nEdgePts, m_xmap->GetTotPoints()));
            Array<OneD, NekDouble> tmp(nEdgePts * nEdgePts);
 
            for (i = 0; i < m_coordim; ++i)
            {
                // Create a StdNodalTriExp.
                StdRegions::StdNodalTriExpSharedPtr t =
                    MemoryManager<StdRegions::StdNodalTriExp>::
                        AllocateSharedPtr(T0, T1, m_curve->m_ptype);
 
                for (j = 0; j < N; ++j)
                {
                    phys[j] = (m_curve->m_points[j]->GetPtr())[i];
                }
 
                t->BwdTrans(phys, tmp);
 
                // Interpolate points to standard region.
                LibUtilities::Interp2D(
                    P0, P1, tmp, m_xmap->GetBasis(0)->GetPointsKey(),
                    m_xmap->GetBasis(1)->GetPointsKey(), phys);
 
                // Forwards transform to get coefficient space.
                m_xmap->FwdTrans(phys, m_coeffs[i]);
            }
        }
        else if (pdim == 1)
        {
            int npts     = m_curve->m_points.size();
            int nEdgePts = (int)sqrt(static_cast<NekDouble>(npts));
            Array<OneD, NekDouble> tmp(npts);
            Array<OneD, NekDouble> phys(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 for"
                     " triangle " +
                         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 triangle " +
                             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 curve points to standard triangle
                // points.
                LibUtilities::Interp2D(curveKey, curveKey, tmp,
                                       m_xmap->GetBasis(0)->GetPointsKey(),
                                       m_xmap->GetBasis(1)->GetPointsKey(),
                                       phys);
 
                // Forwards transform to get coefficient space.
                m_xmap->FwdTrans(phys, m_coeffs[i]);
            }
        }
        else
        {
            NEKERROR(ErrorUtil::efatal, "Only 1D/2D points distributions "
                                        "supported.");
        }
    }
 
    Array<OneD, unsigned int> mapArray(nEdgeCoeffs);
    Array<OneD, int> signArray(nEdgeCoeffs);
 
    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_CalcGeomType().

◆ v_GenGeomFactors()

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

overrideprotectedvirtual

Used by Expansion to generate associated GeomFactors.

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 388 of file TriGeom.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_GetCoord()

NekDouble Nektar::SpatialDomains::TriGeom::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 193 of file TriGeom.cpp.

{
    if (m_state != ePtsFilled)
    {
        NEKERROR(ErrorUtil::ewarning, "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 Nektar::SpatialDomains::ePtsFilled, Nektar::ErrorUtil::ewarning, Nektar::SpatialDomains::Geometry::m_coeffs, Nektar::SpatialDomains::Geometry::m_state, Nektar::SpatialDomains::Geometry::m_xmap, and NEKERROR.

◆ v_GetDir()

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

{
    return i == 0 ? 0 : 1;
}

◆ v_GetEdge()

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

inlinefinalprotectedvirtual

Returns edge i of this object.

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 109 of file TriGeom.h.

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

References m_edges.

◆ v_GetEorient()

StdRegions::Orientation Nektar::SpatialDomains::TriGeom::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 114 of file TriGeom.h.

    {
        return m_eorient[i];
    }

References m_eorient.

◆ v_GetNumEdges()

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

inlinefinalprotectedvirtual

Get the number of edges of this object.

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 99 of file TriGeom.h.

    {
        return kNedges;
    }

References kNedges.

◆ v_GetNumVerts()

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

inlinefinalprotectedvirtual

Get the number of vertices of this object.

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 94 of file TriGeom.h.

    {
        return kNverts;
    }

References kNverts.

◆ v_GetVertex()

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

inlinefinalprotectedvirtual

Returns vertex i of this object.

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 104 of file TriGeom.h.

    {
        return m_verts[i];
    }

References m_verts.

◆ v_Reset()

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

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

References Nektar::SpatialDomains::Geometry2D::m_curve, 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::TriGeom::v_Setup ( )

overrideprotectedvirtual

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 636 of file TriGeom.cpp.

{
    if (!m_setupState)
    {
        for (int i = 0; i < 3; ++i)
        {
            m_edges[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_straightEdge = 0;
        }
 
        m_setupState = true;
    }
}

References m_edges, 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

◆ kNedges

const int Nektar::SpatialDomains::TriGeom::kNedges = 3

static

Definition at line 57 of file TriGeom.h.

Referenced by TriGeom(), TriGeom(), v_FillGeom(), and v_GetNumEdges().

◆ kNfacets

const int Nektar::SpatialDomains::TriGeom::kNfacets = kNedges

static

Definition at line 59 of file TriGeom.h.

◆ kNverts

const int Nektar::SpatialDomains::TriGeom::kNverts = 3

static

Definition at line 58 of file TriGeom.h.

Referenced by Nektar::SpatialDomains::TetGeom::SetUpFaceOrientation(), and v_GetNumVerts().

◆ m_edges

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

protected

Definition at line 120 of file TriGeom.h.

Referenced by SetUpXmap(), TriGeom(), TriGeom(), v_AllLeftCheck(), v_FillGeom(), v_GetEdge(), v_Reset(), and v_Setup().

◆ m_eorient

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

protected

Definition at line 121 of file TriGeom.h.

Referenced by TriGeom(), TriGeom(), v_FillGeom(), and v_GetEorient().

◆ m_verts

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

protected

Definition at line 119 of file TriGeom.h.

Referenced by GetFaceOrientation(), TriGeom(), TriGeom(), v_AllLeftCheck(), v_CalcGeomType(), v_FillGeom(), and v_GetVertex().

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Private Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ TriGeom() [1/3]

◆ TriGeom() [2/3]

◆ TriGeom() [3/3]

◆ ~TriGeom()

Member Function Documentation

◆ GetFaceOrientation() [1/2]

◆ GetFaceOrientation() [2/2]

◆ SetUpXmap()

◆ v_AllLeftCheck()

◆ v_CalcGeomType()

◆ v_FillGeom()

◆ v_GenGeomFactors()

◆ v_GetCoord()

◆ v_GetDir()

◆ v_GetEdge()

◆ v_GetEorient()

◆ v_GetNumEdges()

◆ v_GetNumVerts()

◆ v_GetVertex()

◆ v_Reset()

◆ v_Setup()

Member Data Documentation

◆ kNedges

◆ kNfacets

◆ kNverts

◆ m_edges

◆ m_eorient

◆ m_verts