#include <SegGeom.h>

Inheritance diagram for Nektar::SpatialDomains::SegGeom:

Public Member Functions
	SegGeom ()

	SegGeom (int id, int coordim, std::array< PointGeom , kNverts > vertex, Curve curve=nullptr)

	SegGeom (const SegGeom &in)

SegGeomUniquePtr	GenerateOneSpaceDimGeom (EntityHolder1D &holder)
	Generate a one dimensional space segment geometry where the vert[0] has the same x value and vert[1] is set to vert[0] plus the length of the original segment.

	~SegGeom () override=default

Curve *	GetCurve ()

void	SetCurve (Curve *curvePtr)

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

	Geometry1D (const int coordim)

	~Geometry1D () override=default

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

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

virtual	~Geometry ()=default

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

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

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

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

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

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

int	GetVid (int i) const
	Returns global id of vertex `i` of this object.

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

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

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

PointGeom *	GetVertex (int i) const
	Returns vertex `i` of this object.

Geometry1D *	GetEdge (int i) const
	Returns edge `i` of this object.

Geometry2D *	GetFace (int i) const
	Returns face `i` of this object.

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

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

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

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

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

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

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

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

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

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

void	ClearBoundingBox ()

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

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

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

NekDouble	GetLocCoords (const Array< OneD, const NekDouble > &coords, Array< OneD, NekDouble > &Lcoords)
	Determine the local collapsed coordinates that correspond to a given Cartesian coordinate for this geometry object.

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

int	PreliminaryCheck (const Array< OneD, const NekDouble > &gloCoord)
	A fast and robust check if a given global coord is outside of a deformed element. For regular elements, this check is unnecessary.

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

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

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

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

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

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

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

int	GetDir (const int i, const int j=0) const
	Returns the element coordinate direction corresponding to a given face coordinate direction.

GeomType	CalcGeomType ()

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

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

void	Setup ()

Static Public Member Functions
static StdRegions::Orientation	GetEdgeOrientation (const SegGeom &edge1, const SegGeom &edge2)
	Get the orientation of `edge1`.

Static Public Attributes
static const int	kNverts = 2

static const int	kNfacets = kNverts

Static Public Attributes inherited from Nektar::SpatialDomains::Geometry1D
static const int	kDim = 1

Protected Member Functions
PointGeom *	v_GetVertex (const int i) const override
	Returns vertex `i` of this object.

virtual LibUtilities::ShapeType	v_GetShapeType () const

GeomType	v_CalcGeomType () override

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

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

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

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

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

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

Protected Member Functions inherited from Nektar::SpatialDomains::Geometry1D
int	v_GetShapeDim () const override
	Get the object's shape dimension.

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.

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 Geometry1D *	v_GetEdge (const int i) const
	Returns edge `i` of this object.

virtual Geometry2D *	v_GetFace (const int i) const
	Returns face `i` of this object.

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.

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_GetNumEdges () const
	Get the number of edges of this object.

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_AllLeftCheck (const Array< OneD, const NekDouble > &gloCoord)

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.

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

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

virtual void	v_CalculateInverseIsoParam ()

Protected Attributes
std::array< SpatialDomains::PointGeom *, kNverts >	m_verts

StdRegions::Orientation	m_porient [kNverts]

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

Private Attributes
Curve *	m_curve = nullptr
	Boolean indicating whether object owns the data.

Detailed Description

Definition at line 59 of file SegGeom.h.

Constructor & Destructor Documentation

◆ SegGeom() [1/3]

Nektar::SpatialDomains::SegGeom::SegGeom ( )

Definition at line 64 of file SegGeom.cpp.

{
    m_shapeType = LibUtilities::eSegment;
}

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

◆ SegGeom() [2/3]

Nektar::SpatialDomains::SegGeom::SegGeom	(	int	id,
		int	coordim,
		std::array< PointGeom *, kNverts >	vertex,
		Curve *	curve = `nullptr`
	)

Definition at line 69 of file SegGeom.cpp.

    : Geometry1D(coordim)
{
    m_shapeType = LibUtilities::eSegment;
    m_globalID  = id;
    m_state     = eNotFilled;
    m_curve     = curve;
    m_verts     = vertex;
}

References Nektar::SpatialDomains::eNotFilled, Nektar::LibUtilities::eSegment, m_curve, Nektar::SpatialDomains::Geometry::m_globalID, Nektar::SpatialDomains::Geometry::m_shapeType, Nektar::SpatialDomains::Geometry::m_state, and m_verts.

◆ SegGeom() [3/3]

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

Definition at line 80 of file SegGeom.cpp.

                                  : Geometry1D(in)
{
    // From Geometry class
    m_shapeType = in.m_shapeType;
 
    // info from EdgeComponent class
    m_globalID = in.m_globalID;
    m_xmap     = in.m_xmap;
    SetUpCoeffs(m_xmap->GetNcoeffs());
 
    // info from SegGeom class
    m_coordim  = in.m_coordim;
    m_verts[0] = in.m_verts[0];
    m_verts[1] = in.m_verts[1];
 
    m_state = in.m_state;
}

References Nektar::SpatialDomains::Geometry::m_coordim, Nektar::SpatialDomains::Geometry::m_globalID, Nektar::SpatialDomains::Geometry::m_shapeType, Nektar::SpatialDomains::Geometry::m_state, m_verts, Nektar::SpatialDomains::Geometry::m_xmap, and Nektar::SpatialDomains::Geometry::SetUpCoeffs().

◆ ~SegGeom()

Nektar::SpatialDomains::SegGeom::~SegGeom ( )

overridedefault

Member Function Documentation

◆ GenerateOneSpaceDimGeom()

SegGeomUniquePtr Nektar::SpatialDomains::SegGeom::GenerateOneSpaceDimGeom ( EntityHolder1D & holder )

Generate a one dimensional space segment geometry where the vert[0] has the same x value and vert[1] is set to vert[0] plus the length of the original segment.

Definition at line 122 of file SegGeom.cpp.

{
    SegGeomUniquePtr returnval = ObjPoolManager<SegGeom>::AllocateUniquePtr();
 
    // info about numbering
    returnval->m_globalID = m_globalID;
 
    // geometric information.
    returnval->m_coordim     = 1;
    NekDouble x0             = (*m_verts[0])[0];
    PointGeomUniquePtr vert0 = ObjPoolManager<PointGeom>::AllocateUniquePtr(
        1, m_verts[0]->GetGlobalID(), x0, 0.0, 0.0);
    vert0->SetGlobalID(vert0->GetGlobalID());
    returnval->m_verts[0] = vert0.get();
    holder.m_pointVec.push_back(std::move(vert0));
 
    // Get information to calculate length.
    const Array<OneD, const LibUtilities::BasisSharedPtr> base =
        m_xmap->GetBase();
    LibUtilities::PointsKeyVector v;
    v.push_back(base[0]->GetPointsKey());
 
    const Array<OneD, const NekDouble> jac = v_GenGeomFactors(v)->GetJac();
 
    NekDouble len = 0.0;
    if (jac.size() == 1)
    {
        len = jac[0] * 2.0;
    }
    else
    {
        Array<OneD, const NekDouble> w0 = base[0]->GetW();
        len                             = 0.0;
 
        for (int i = 0; i < jac.size(); ++i)
        {
            len += jac[i] * w0[i];
        }
    }
    // Set up second vertex.
    PointGeomUniquePtr vert1 = ObjPoolManager<PointGeom>::AllocateUniquePtr(
        1, m_verts[1]->GetGlobalID(), x0 + len, 0.0, 0.0);
    vert1->SetGlobalID(vert1->GetGlobalID());
 
    returnval->m_verts[1] = vert1.get();
    holder.m_pointVec.push_back(std::move(vert1));
 
    // at present just use previous m_xmap[0];
    returnval->m_xmap = m_xmap;
    returnval->SetUpCoeffs(m_xmap->GetNcoeffs());
    returnval->m_state = eNotFilled;
 
    return returnval;
}

References Nektar::ObjPoolManager< DataType >::AllocateUniquePtr(), Nektar::SpatialDomains::eNotFilled, Nektar::SpatialDomains::Geometry::GetGlobalID(), Nektar::SpatialDomains::Geometry::m_globalID, Nektar::SpatialDomains::EntityHolder1D::m_pointVec, m_verts, Nektar::SpatialDomains::Geometry::m_xmap, and v_GenGeomFactors().

◆ GetCurve()

Curve * Nektar::SpatialDomains::SegGeom::GetCurve ( )

inline

Definition at line 80 of file SegGeom.h.

    {
        return m_curve;
    }

References m_curve.

Referenced by export_GeomElements(), and Nektar::SpatialDomains::ZoneBase::ZoneBase().

◆ GetEdgeOrientation()

StdRegions::Orientation Nektar::SpatialDomains::SegGeom::GetEdgeOrientation	(	const SegGeom &	edge1,
		const SegGeom &	edge2
	)

static

Get the orientation of edge1.

If edge1 is connected to edge2 in the same direction as the points comprising edge1 then it is forward, otherwise it is backward.

For example, assume edge1 is comprised of points 1 and 2, and edge2 is comprised of points 2 and 3, then edge1 is forward.

If edge1 is comprised of points 2 and 1 and edge2 is comprised of points 3 and 2, then edge1 is backward.

Since both edges are passed, it does not need any information from the EdgeComponent instance.

Definition at line 211 of file SegGeom.cpp.

{
    StdRegions::Orientation returnval = StdRegions::eForwards;
 
    if ((*edge1.GetVertex(0) == *edge2.GetVertex(0)) ||
        (*edge1.GetVertex(0) == *edge2.GetVertex(1)))
    {
        // Backward direction.  Vertex 0 is connected to edge 2.
        returnval = StdRegions::eBackwards;
    }
    else if ((*edge1.GetVertex(1) != *edge2.GetVertex(0)) &&
             (*edge1.GetVertex(1) != *edge2.GetVertex(1)))
    {
        // Not forward either, then we have a problem.
        std::ostringstream errstrm;
        errstrm << "Connected edges do not share a vertex. Edges ";
        errstrm << edge1.GetGlobalID() << ", " << edge2.GetGlobalID();
        NEKERROR(ErrorUtil::efatal, errstrm.str());
    }
 
    return returnval;
}

References Nektar::StdRegions::eBackwards, Nektar::ErrorUtil::efatal, Nektar::StdRegions::eForwards, Nektar::SpatialDomains::Geometry::GetGlobalID(), Nektar::SpatialDomains::Geometry::GetVertex(), and NEKERROR.

Referenced by Nektar::SpatialDomains::TriGeom::TriGeom().

◆ SetCurve()

void Nektar::SpatialDomains::SegGeom::SetCurve ( Curve * curvePtr )

inline

Definition at line 84 of file SegGeom.h.

    {
        m_curve = curvePtr;
    }

References m_curve.

◆ SetUpXmap()

void Nektar::SpatialDomains::SegGeom::SetUpXmap ( )

private

Definition at line 98 of file SegGeom.cpp.

{
    if (m_curve)
    {
        int npts = m_curve->m_points.size();
        LibUtilities::PointsKey pkey(npts + 1,
                                     LibUtilities::eGaussLobattoLegendre);
        const LibUtilities::BasisKey B(LibUtilities::eModified_A, npts, pkey);
        m_xmap = MemoryManager<StdRegions::StdSegExp>::AllocateSharedPtr(B);
    }
    else
    {
        const LibUtilities::BasisKey B(
            LibUtilities::eModified_A, 2,
            LibUtilities::PointsKey(2, LibUtilities::eGaussLobattoLegendre));
        m_xmap = MemoryManager<StdRegions::StdSegExp>::AllocateSharedPtr(B);
    }
}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eModified_A, m_curve, Nektar::SpatialDomains::Curve::m_points, and Nektar::SpatialDomains::Geometry::m_xmap.

Referenced by v_Reset(), and v_Setup().

◆ v_CalcGeomType()

GeomType Nektar::SpatialDomains::SegGeom::v_CalcGeomType ( )

overrideprotectedvirtual

Calculates the GeomType (deformed, regular etc).

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 235 of file SegGeom.cpp.

{
    if (!m_setupState)
    {
        SegGeom::v_Setup();
    }
    SegGeom::v_FillGeom();
 
    SpatialDomains::GeomType gType = eRegular;
 
    if (m_xmap->GetBasisNumModes(0) != 2)
    {
        gType = eDeformed;
    }
 
    return gType;
}

References Nektar::SpatialDomains::eDeformed, Nektar::SpatialDomains::eRegular, Nektar::SpatialDomains::Geometry::m_setupState, Nektar::SpatialDomains::Geometry::m_xmap, v_FillGeom(), and v_Setup().

◆ v_FillGeom()

void Nektar::SpatialDomains::SegGeom::v_FillGeom ( )

overrideprotectedvirtual

Populate the coordinate mapping Geometry::m_coeffs information from any children geometry elements.

See also: v_FillGeom()

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 261 of file SegGeom.cpp.

{
    if (m_state != ePtsFilled)
    {
        int i;
 
        if (m_coordim > 0 && m_curve)
        {
            int npts = m_curve->m_points.size();
            LibUtilities::PointsKey pkey(npts + 1,
                                         LibUtilities::eGaussLobattoLegendre);
            Array<OneD, NekDouble> tmp(npts);
 
            if (m_verts[0]->dist(*(m_curve->m_points[0])) >
                NekConstants::kVertexTheSameDouble)
            {
                std::string err =
                    "Vertex 0 is separated from first point by more than ";
                std::stringstream strstrm;
                strstrm << NekConstants::kVertexTheSameDouble << " in edge "
                        << m_globalID;
                err += strstrm.str();
                NEKERROR(ErrorUtil::ewarning, err.c_str());
            }
 
            if (m_verts[1]->dist(*(m_curve->m_points[npts - 1])) >
                NekConstants::kVertexTheSameDouble)
            {
                std::string err =
                    "Vertex 1 is separated from last point by more than ";
                std::stringstream strstrm;
                strstrm << NekConstants::kVertexTheSameDouble << " in edge "
                        << m_globalID;
                err += strstrm.str();
                NEKERROR(ErrorUtil::ewarning, err.c_str());
            }
 
            LibUtilities::PointsKey fkey(npts, m_curve->m_ptype);
            DNekMatSharedPtr I0 =
                LibUtilities::PointsManager()[fkey]->GetI(pkey);
            NekVector<NekDouble> out(npts + 1);
 
            for (int i = 0; i < m_coordim; ++i)
            {
                // Load up coordinate values into tmp
                for (int j = 0; j < npts; ++j)
                {
                    tmp[j] = (m_curve->m_points[j]->GetPtr())[i];
                }
 
                // Interpolate to GLL points
                NekVector<NekDouble> in(npts, tmp, eWrapper);
                out = (*I0) * in;
 
                m_xmap->FwdTrans(out.GetPtr(), m_coeffs[i]);
            }
        }
 
        for (i = 0; i < m_coordim; ++i)
        {
            m_coeffs[i][0] = (*m_verts[0])[i];
            m_coeffs[i][1] = (*m_verts[1])[i];
        }
 
        m_state = ePtsFilled;
    }
}

Referenced by v_CalcGeomType().

◆ v_FindDistance()

NekDouble Nektar::SpatialDomains::SegGeom::v_FindDistance	(	const Array< OneD, const NekDouble > &	xs,
		Array< OneD, NekDouble > &	xi
	)

overrideprotectedvirtual

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 370 of file SegGeom.cpp.

{
    GeomType Gtype = CalcGeomType();
    if (Gtype == eRegular)
    {
        xiOut = Array<OneD, NekDouble>(1, 0.0);
 
        GetLocCoords(xs, xiOut);
        ClampLocCoords(xiOut);
 
        Array<OneD, NekDouble> gloCoord(m_coordim);
        NekDouble tmp = 0;
        for (int i = 0; i < m_coordim; ++i)
        {
            gloCoord[i] = GetCoord(i, xiOut);
            tmp += (xs[i] - gloCoord[i]) * (xs[i] - gloCoord[i]);
        }
 
        return sqrt(tmp);
    }
    // If deformed edge then the inverse mapping is non-linear so need to
    // numerically solve for the local coordinate
    else if (Gtype == eDeformed)
    {
        Array<OneD, NekDouble> xi(1, 0.0);
 
        // Armijo constants:
        // https://en.wikipedia.org/wiki/Backtracking_line_search
        const NekDouble c1 = 1e-4, c2 = 0.9;
 
        int dim = GetCoordim();
        int nq  = m_xmap->GetTotPoints();
 
        Array<OneD, Array<OneD, NekDouble>> x(dim), xder(dim), xder2(dim);
        // Get x,y,z phys values from coefficients
        for (int i = 0; i < dim; ++i)
        {
            x[i]     = Array<OneD, NekDouble>(nq);
            xder[i]  = Array<OneD, NekDouble>(nq);
            xder2[i] = Array<OneD, NekDouble>(nq);
 
            m_xmap->BwdTrans(m_coeffs[i], x[i]);
        }
 
        NekDouble fx_prev = std::numeric_limits<NekDouble>::max();
 
        // Minimisation loop (Quasi-newton method)
        for (int i = 0; i < NekConstants::kNewtonIterations; ++i)
        {
            // Compute the objective function, f(x_k) and its derivatives
            Array<OneD, NekDouble> xc(dim);
            Array<OneD, std::array<NekDouble, 3>> xc_der(dim);
            Array<OneD, std::array<NekDouble, 6>> xc_der2(dim);
            NekDouble fx = 0, fxp = 0, fxp2 = 0, xcDiff = 0;
            for (int j = 0; j < dim; ++j)
            {
                xc[j] = m_xmap->PhysEvaluate(xi, x[j], xc_der[j], xc_der2[j]);
 
                xcDiff = xc[j] - xs[j];
                // Objective function is the distance to the search point
                fx += xcDiff * xcDiff;
                fxp += xc_der[j][0] * xcDiff;
                fxp2 += xc_der2[j][0] * xcDiff + xc_der[j][0] * xc_der[j][0];
            }
 
            fxp *= 2;
            fxp2 *= 2;
 
            // Check for convergence
            if (std::abs(fx - fx_prev) < 1e-12)
            {
                fx_prev = fx;
                break;
            }
            else
            {
                fx_prev = fx;
            }
 
            NekDouble gamma = 1.0;
            bool conv       = false;
 
            // Search direction: Newton's method
            NekDouble pk = -fxp / fxp2;
 
            // Perform backtracking line search
            while (gamma > 1e-10)
            {
                Array<OneD, NekDouble> xi_pk(1);
                xi_pk[0] = xi[0] + pk * gamma;
 
                if (xi_pk[0] < -1.0 || xi_pk[0] > 1.0)
                {
                    gamma /= 2.0;
                    continue;
                }
 
                Array<OneD, NekDouble> xc_pk(dim);
                Array<OneD, std::array<NekDouble, 3>> xc_der_pk(dim);
                NekDouble fx_pk = 0, fxp_pk = 0, xc_pkDiff = 0;
                for (int j = 0; j < dim; ++j)
                {
                    xc_pk[j] = m_xmap->PhysEvaluate(xi_pk, x[j], xc_der_pk[j]);
 
                    xc_pkDiff = xc_pk[j] - xs[j];
                    fx_pk += xc_pkDiff * xc_pkDiff;
                    fxp_pk += xc_der_pk[j][0] * xc_pkDiff;
                }
 
                fxp_pk *= 2;
 
                // Check Wolfe conditions using Armijo constants
                // https://en.wikipedia.org/wiki/Wolfe_conditions
                if ((fx_pk - (fx + c1 * gamma * pk * fxp)) <
                        std::numeric_limits<NekDouble>::epsilon() &&
                    (-pk * fxp_pk + c2 * pk * fxp) <
                        std::numeric_limits<NekDouble>::epsilon())
                {
                    conv = true;
                    break;
                }
 
                gamma /= 2.0;
            }
 
            if (!conv)
            {
                break;
            }
 
            xi[0] += gamma * pk;
        }
 
        xiOut = xi;
        return sqrt(fx_prev);
    }
    else
    {
        NEKERROR(ErrorUtil::efatal, "Geometry type unknown");
    }
 
    return -1.0;
}

◆ v_GenGeomFactors()

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

overrideprotectedvirtual

Used by Expansion to generate associated GeomFactors.

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 253 of file SegGeom.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.

Referenced by GenerateOneSpaceDimGeom().

◆ v_GetCoord()

NekDouble Nektar::SpatialDomains::SegGeom::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 182 of file SegGeom.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_GetNumVerts()

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

overrideprotectedvirtual

Get the number of vertices of this object.

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 365 of file SegGeom.cpp.

{
    return kNverts;
}

References kNverts.

◆ v_GetShapeType()

LibUtilities::ShapeType Nektar::SpatialDomains::SegGeom::v_GetShapeType ( ) const

protectedvirtual

Definition at line 177 of file SegGeom.cpp.

{
    return LibUtilities::eSegment;
}

References Nektar::LibUtilities::eSegment.

◆ v_GetVertex()

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

overrideprotectedvirtual

Returns vertex i of this object.

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 353 of file SegGeom.cpp.

{
    PointGeom *returnval = nullptr;
 
    if (i >= 0 && i < kNverts)
    {
        returnval = m_verts[i];
    }
 
    return returnval;
}

References kNverts, and m_verts.

◆ v_Reset()

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

{
    Geometry::v_Reset(curvedEdges, curvedFaces);
    CurveMap::iterator it = curvedEdges.find(m_globalID);
 
    if (it != curvedEdges.end())
    {
        m_curve = it->second.get();
    }
 
    SetUpXmap();
    SetUpCoeffs(m_xmap->GetNcoeffs());
}

References m_curve, 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::SegGeom::v_Setup ( )

overrideprotectedvirtual

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 343 of file SegGeom.cpp.

{
    if (!m_setupState)
    {
        SetUpXmap();
        SetUpCoeffs(m_xmap->GetNcoeffs());
        m_setupState = true;
    }
}

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

Referenced by v_CalcGeomType().

Member Data Documentation

◆ kNfacets

const int Nektar::SpatialDomains::SegGeom::kNfacets = kNverts

static

Definition at line 63 of file SegGeom.h.

◆ kNverts

const int Nektar::SpatialDomains::SegGeom::kNverts = 2

static

Definition at line 62 of file SegGeom.h.

Referenced by v_GetNumVerts(), and v_GetVertex().

◆ m_curve

Curve* Nektar::SpatialDomains::SegGeom::m_curve = nullptr

private

Boolean indicating whether object owns the data.

Definition at line 109 of file SegGeom.h.

Referenced by GetCurve(), SegGeom(), SetCurve(), SetUpXmap(), v_FillGeom(), and v_Reset().

◆ m_porient

StdRegions::Orientation Nektar::SpatialDomains::SegGeom::m_porient[kNverts]

protected

Definition at line 91 of file SegGeom.h.

◆ m_verts

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

protected

Definition at line 90 of file SegGeom.h.

Referenced by GenerateOneSpaceDimGeom(), SegGeom(), SegGeom(), v_FillGeom(), and v_GetVertex().

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ SegGeom() [1/3]

◆ SegGeom() [2/3]

◆ SegGeom() [3/3]

◆ ~SegGeom()

Member Function Documentation

◆ GenerateOneSpaceDimGeom()

◆ GetCurve()

◆ GetEdgeOrientation()

◆ SetCurve()

◆ SetUpXmap()

◆ v_CalcGeomType()

◆ v_FillGeom()

◆ v_FindDistance()

◆ v_GenGeomFactors()

◆ v_GetCoord()

◆ v_GetNumVerts()

◆ v_GetShapeType()

◆ v_GetVertex()

◆ v_Reset()

◆ v_Setup()

Member Data Documentation

◆ kNfacets

◆ kNverts

◆ m_curve

◆ m_porient

◆ m_verts