Nektar++
Public Member Functions | Protected Member Functions | Private Member Functions | Private Attributes | List of all members
Nektar::LocalRegions::SegExp Class Reference

#include <SegExp.h>

Inheritance diagram for Nektar::LocalRegions::SegExp:
[legend]

Public Member Functions

 SegExp (const LibUtilities::BasisKey &Ba, const SpatialDomains::Geometry1DSharedPtr &geom)
 Constructor using BasisKey class for quadrature points and order definition. More...
 
 SegExp (const SegExp &S)
 Copy Constructor. More...
 
 ~SegExp ()
 
- Public Member Functions inherited from Nektar::StdRegions::StdSegExp
 StdSegExp ()
 Default constructor. More...
 
 StdSegExp (const LibUtilities::BasisKey &Ba)
 Constructor using BasisKey class for quadrature points and order definition. More...
 
 StdSegExp (const StdSegExp &T)
 Copy Constructor. More...
 
 ~StdSegExp ()
 
- Public Member Functions inherited from Nektar::StdRegions::StdExpansion1D
 StdExpansion1D ()
 
 StdExpansion1D (int numcoeffs, const LibUtilities::BasisKey &Ba)
 
 StdExpansion1D (const StdExpansion1D &T)
 
virtual ~StdExpansion1D ()
 
void PhysTensorDeriv (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 Evaluate the derivative \( d/d{\xi_1} \) at the physical quadrature points given by inarray and return in outarray. More...
 
- Public Member Functions inherited from Nektar::StdRegions::StdExpansion
 StdExpansion ()
 Default Constructor. More...
 
 StdExpansion (const int numcoeffs, const int numbases, const LibUtilities::BasisKey &Ba=LibUtilities::NullBasisKey, const LibUtilities::BasisKey &Bb=LibUtilities::NullBasisKey, const LibUtilities::BasisKey &Bc=LibUtilities::NullBasisKey)
 Constructor. More...
 
 StdExpansion (const StdExpansion &T)
 Copy Constructor. More...
 
virtual ~StdExpansion ()
 Destructor. More...
 
int GetNumBases () const
 This function returns the number of 1D bases used in the expansion. More...
 
const Array< OneD, const LibUtilities::BasisSharedPtr > & GetBase () const
 This function gets the shared point to basis. More...
 
const LibUtilities::BasisSharedPtr & GetBasis (int dir) const
 This function gets the shared point to basis in the dir direction. More...
 
int GetNcoeffs (void) const
 This function returns the total number of coefficients used in the expansion. More...
 
int GetTotPoints () const
 This function returns the total number of quadrature points used in the element. More...
 
LibUtilities::BasisType GetBasisType (const int dir) const
 This function returns the type of basis used in the dir direction. More...
 
int GetBasisNumModes (const int dir) const
 This function returns the number of expansion modes in the dir direction. More...
 
int EvalBasisNumModesMax (void) const
 This function returns the maximum number of expansion modes over all local directions. More...
 
LibUtilities::PointsType GetPointsType (const int dir) const
 This function returns the type of quadrature points used in the dir direction. More...
 
int GetNumPoints (const int dir) const
 This function returns the number of quadrature points in the dir direction. More...
 
const Array< OneD, const NekDouble > & GetPoints (const int dir) const
 This function returns a pointer to the array containing the quadrature points in dir direction. More...
 
int GetNverts () const
 This function returns the number of vertices of the expansion domain. More...
 
int GetTraceNcoeffs (const int i) const
 This function returns the number of expansion coefficients belonging to the i-th trace. More...
 
int GetTraceIntNcoeffs (const int i) const
 
int GetTraceNumPoints (const int i) const
 This function returns the number of quadrature points belonging to the i-th trace. More...
 
const LibUtilities::BasisKey GetTraceBasisKey (const int i, int k=-1) const
 This function returns the basis key belonging to the i-th trace. More...
 
LibUtilities::PointsKey GetTracePointsKey (const int i, int k=-1) const
 This function returns the basis key belonging to the i-th trace. More...
 
int NumBndryCoeffs (void) const
 
int NumDGBndryCoeffs (void) const
 
const LibUtilities::PointsKey GetNodalPointsKey () const
 This function returns the type of expansion Nodal point type if defined. More...
 
int GetNtraces () const
 Returns the number of trace elements connected to this element. More...
 
LibUtilities::ShapeType DetShapeType () const
 This function returns the shape of the expansion domain. More...
 
std::shared_ptr< StdExpansion > GetStdExp (void) const
 
std::shared_ptr< StdExpansion > GetLinStdExp (void) const
 
int GetShapeDimension () const
 
bool IsBoundaryInteriorExpansion ()
 
bool IsNodalNonTensorialExp ()
 
void BwdTrans (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 This function performs the Backward transformation from coefficient space to physical space. More...
 
void FwdTrans (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 This function performs the Forward transformation from physical space to coefficient space. More...
 
void FwdTrans_BndConstrained (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
NekDouble Integral (const Array< OneD, const NekDouble > &inarray)
 This function integrates the specified function over the domain. More...
 
void FillMode (const int mode, Array< OneD, NekDouble > &outarray)
 This function fills the array outarray with the mode-th mode of the expansion. More...
 
void IProductWRTBase (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 this function calculates the inner product of a given function f with the different modes of the expansion More...
 
void IProductWRTBase (const Array< OneD, const NekDouble > &base, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, int coll_check)
 
void IProductWRTDerivBase (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
void IProductWRTDirectionalDerivBase (const Array< OneD, const NekDouble > &direction, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
int GetElmtId ()
 Get the element id of this expansion when used in a list by returning value of m_elmt_id. More...
 
void SetElmtId (const int id)
 Set the element id of this expansion when used in a list by returning value of m_elmt_id. More...
 
void GetCoords (Array< OneD, NekDouble > &coords_1, Array< OneD, NekDouble > &coords_2=NullNekDouble1DArray, Array< OneD, NekDouble > &coords_3=NullNekDouble1DArray)
 this function returns the physical coordinates of the quadrature points of the expansion More...
 
void GetCoord (const Array< OneD, const NekDouble > &Lcoord, Array< OneD, NekDouble > &coord)
 given the coordinates of a point of the element in the local collapsed coordinate system, this function calculates the physical coordinates of the point More...
 
DNekMatSharedPtr GetStdMatrix (const StdMatrixKey &mkey)
 
DNekBlkMatSharedPtr GetStdStaticCondMatrix (const StdMatrixKey &mkey)
 
void NormVectorIProductWRTBase (const Array< OneD, const NekDouble > &Fx, Array< OneD, NekDouble > &outarray)
 
void NormVectorIProductWRTBase (const Array< OneD, const NekDouble > &Fx, const Array< OneD, NekDouble > &Fy, Array< OneD, NekDouble > &outarray)
 
void NormVectorIProductWRTBase (const Array< OneD, const NekDouble > &Fx, const Array< OneD, const NekDouble > &Fy, const Array< OneD, const NekDouble > &Fz, Array< OneD, NekDouble > &outarray)
 
void NormVectorIProductWRTBase (const Array< OneD, const Array< OneD, NekDouble > > &Fvec, Array< OneD, NekDouble > &outarray)
 
DNekScalBlkMatSharedPtr GetLocStaticCondMatrix (const LocalRegions::MatrixKey &mkey)
 
void DropLocStaticCondMatrix (const LocalRegions::MatrixKey &mkey)
 
int CalcNumberOfCoefficients (const std::vector< unsigned int > &nummodes, int &modes_offset)
 
NekDouble StdPhysEvaluate (const Array< OneD, const NekDouble > &Lcoord, const Array< OneD, const NekDouble > &physvals)
 
int GetCoordim ()
 
void GetBoundaryMap (Array< OneD, unsigned int > &outarray)
 
void GetInteriorMap (Array< OneD, unsigned int > &outarray)
 
int GetVertexMap (const int localVertexId, bool useCoeffPacking=false)
 
void GetTraceToElementMap (const int tid, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray, Orientation traceOrient=eForwards, int P=-1, int Q=-1)
 
void GetTraceInteriorToElementMap (const int tid, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray, const Orientation traceOrient=eForwards)
 
void GetTraceNumModes (const int tid, int &numModes0, int &numModes1, const Orientation traceOrient=eDir1FwdDir1_Dir2FwdDir2)
 
void MultiplyByQuadratureMetric (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
void MultiplyByStdQuadratureMetric (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
DNekMatSharedPtr CreateGeneralMatrix (const StdMatrixKey &mkey)
 this function generates the mass matrix \(\mathbf{M}[i][j] = \int \phi_i(\mathbf{x}) \phi_j(\mathbf{x}) d\mathbf{x}\) More...
 
void GeneralMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void MassMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void LaplacianMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void ReduceOrderCoeffs (int numMin, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
void SVVLaplacianFilter (Array< OneD, NekDouble > &array, const StdMatrixKey &mkey)
 
void ExponentialFilter (Array< OneD, NekDouble > &array, const NekDouble alpha, const NekDouble exponent, const NekDouble cutoff)
 
void LaplacianMatrixOp (const int k1, const int k2, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void WeakDerivMatrixOp (const int i, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void WeakDirectionalDerivMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void MassLevelCurvatureMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void LinearAdvectionDiffusionReactionMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey, bool addDiffusionTerm=true)
 
void HelmholtzMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
DNekMatSharedPtr GenMatrix (const StdMatrixKey &mkey)
 
void PhysDeriv (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_d0, Array< OneD, NekDouble > &out_d1=NullNekDouble1DArray, Array< OneD, NekDouble > &out_d2=NullNekDouble1DArray)
 
void PhysDeriv (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
void PhysDeriv_s (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_ds)
 
void PhysDeriv_n (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_dn)
 
void PhysDirectionalDeriv (const Array< OneD, const NekDouble > &inarray, const Array< OneD, const NekDouble > &direction, Array< OneD, NekDouble > &outarray)
 
void StdPhysDeriv (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_d0, Array< OneD, NekDouble > &out_d1=NullNekDouble1DArray, Array< OneD, NekDouble > &out_d2=NullNekDouble1DArray)
 
void StdPhysDeriv (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
NekDouble PhysEvaluate (const Array< OneD, const NekDouble > &coords, const Array< OneD, const NekDouble > &physvals)
 This function evaluates the expansion at a single (arbitrary) point of the domain. More...
 
NekDouble PhysEvaluate (const Array< OneD, DNekMatSharedPtr > &I, const Array< OneD, const NekDouble > &physvals)
 This function evaluates the expansion at a single (arbitrary) point of the domain. More...
 
NekDouble PhysEvaluateBasis (const Array< OneD, const NekDouble > &coords, int mode)
 This function evaluates the basis function mode mode at a point coords of the domain. More...
 
void LocCoordToLocCollapsed (const Array< OneD, const NekDouble > &xi, Array< OneD, NekDouble > &eta)
 Convert local cartesian coordinate xi into local collapsed coordinates eta. More...
 
void LocCollapsedToLocCoord (const Array< OneD, const NekDouble > &eta, Array< OneD, NekDouble > &xi)
 Convert local collapsed coordinates eta into local cartesian coordinate xi. More...
 
virtual void v_NormVectorIProductWRTBase (const Array< OneD, const NekDouble > &Fx, Array< OneD, NekDouble > &outarray)
 
virtual void v_NormVectorIProductWRTBase (const Array< OneD, const NekDouble > &Fx, const Array< OneD, const NekDouble > &Fy, const Array< OneD, const NekDouble > &Fz, Array< OneD, NekDouble > &outarray)
 
NekDouble Linf (const Array< OneD, const NekDouble > &phys, const Array< OneD, const NekDouble > &sol=NullNekDouble1DArray)
 Function to evaluate the discrete \( L_\infty\) error \( |\epsilon|_\infty = \max |u - u_{exact}|\) where \( u_{exact}\) is given by the array sol. More...
 
NekDouble L2 (const Array< OneD, const NekDouble > &phys, const Array< OneD, const NekDouble > &sol=NullNekDouble1DArray)
 Function to evaluate the discrete \( L_2\) error, \( | \epsilon |_{2} = \left [ \int^1_{-1} [u - u_{exact}]^2 dx \right]^{1/2} d\xi_1 \) where \( u_{exact}\) is given by the array sol. More...
 
NekDouble H1 (const Array< OneD, const NekDouble > &phys, const Array< OneD, const NekDouble > &sol=NullNekDouble1DArray)
 Function to evaluate the discrete \( H^1\) error, \( | \epsilon |^1_{2} = \left [ \int^1_{-1} [u - u_{exact}]^2 + \nabla(u - u_{exact})\cdot\nabla(u - u_{exact})\cdot dx \right]^{1/2} d\xi_1 \) where \( u_{exact}\) is given by the array sol. More...
 
const LibUtilities::PointsKeyVector GetPointsKeys () const
 
DNekMatSharedPtr BuildInverseTransformationMatrix (const DNekScalMatSharedPtr &m_transformationmatrix)
 
void PhysInterpToSimplexEquiSpaced (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, int npset=-1)
 This function performs an interpolation from the physical space points provided at input into an array of equispaced points which are not the collapsed coordinate. So for a tetrahedron you will only get a tetrahedral number of values. More...
 
void GetSimplexEquiSpacedConnectivity (Array< OneD, int > &conn, bool standard=true)
 This function provides the connectivity of local simplices (triangles or tets) to connect the equispaced data points provided by PhysInterpToSimplexEquiSpaced. More...
 
void EquiSpacedToCoeffs (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 This function performs a projection/interpolation from the equispaced points sometimes used in post-processing onto the coefficient space. More...
 
template<class T >
std::shared_ptr< T > as ()
 
void IProductWRTBase_SumFac (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, bool multiplybyweights=true)
 
void GenStdMatBwdDeriv (const int dir, DNekMatSharedPtr &mat)
 
- Public Member Functions inherited from Nektar::LocalRegions::Expansion1D
 Expansion1D (SpatialDomains::Geometry1DSharedPtr pGeom)
 
virtual ~Expansion1D ()
 
void AddNormTraceInt (const int dir, Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
void AddHDGHelmholtzTraceTerms (const NekDouble tau, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
SpatialDomains::Geometry1DSharedPtr GetGeom1D () const
 
- Public Member Functions inherited from Nektar::LocalRegions::Expansion
 Expansion (SpatialDomains::GeometrySharedPtr pGeom)
 
 Expansion (const Expansion &pSrc)
 
virtual ~Expansion ()
 
void SetTraceExp (const int traceid, ExpansionSharedPtr &f)
 
ExpansionSharedPtr GetTraceExp (const int traceid)
 
DNekScalMatSharedPtr GetLocMatrix (const LocalRegions::MatrixKey &mkey)
 
DNekScalMatSharedPtr GetLocMatrix (const StdRegions::MatrixType mtype, const StdRegions::ConstFactorMap &factors=StdRegions::NullConstFactorMap, const StdRegions::VarCoeffMap &varcoeffs=StdRegions::NullVarCoeffMap)
 
SpatialDomains::GeometrySharedPtr GetGeom () const
 
void Reset ()
 
IndexMapValuesSharedPtr CreateIndexMap (const IndexMapKey &ikey)
 
const SpatialDomains::GeomFactorsSharedPtr & GetMetricInfo () const
 
DNekMatSharedPtr BuildTransformationMatrix (const DNekScalMatSharedPtr &r_bnd, const StdRegions::MatrixType matrixType)
 
DNekMatSharedPtr BuildVertexMatrix (const DNekScalMatSharedPtr &r_bnd)
 
void ExtractDataToCoeffs (const NekDouble *data, const std::vector< unsigned int > &nummodes, const int nmodes_offset, NekDouble *coeffs, std::vector< LibUtilities::BasisType > &fromType)
 
void AddEdgeNormBoundaryInt (const int edge, const std::shared_ptr< Expansion > &EdgeExp, const Array< OneD, const NekDouble > &Fx, const Array< OneD, const NekDouble > &Fy, Array< OneD, NekDouble > &outarray)
 
void AddEdgeNormBoundaryInt (const int edge, const std::shared_ptr< Expansion > &EdgeExp, const Array< OneD, const NekDouble > &Fn, Array< OneD, NekDouble > &outarray)
 
void AddFaceNormBoundaryInt (const int face, const std::shared_ptr< Expansion > &FaceExp, const Array< OneD, const NekDouble > &Fn, Array< OneD, NekDouble > &outarray)
 
void DGDeriv (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, ExpansionSharedPtr > &EdgeExp, Array< OneD, Array< OneD, NekDouble > > &coeffs, Array< OneD, NekDouble > &outarray)
 
NekDouble VectorFlux (const Array< OneD, Array< OneD, NekDouble > > &vec)
 
IndexMapValuesSharedPtr GetIndexMap (const IndexMapKey &ikey)
 
void AlignVectorToCollapsedDir (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)
 
ExpansionSharedPtr GetLeftAdjacentElementExp () const
 
ExpansionSharedPtr GetRightAdjacentElementExp () const
 
int GetLeftAdjacentElementTrace () const
 
int GetRightAdjacentElementTrace () const
 
void SetAdjacentElementExp (int traceid, ExpansionSharedPtr &e)
 
StdRegions::Orientation GetTraceOrient (int trace)
 
void SetCoeffsToOrientation (StdRegions::Orientation dir, Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
void DivideByQuadratureMetric (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 Divided by the metric jacobi and quadrature weights. More...
 
void GetTraceQFactors (const int trace, Array< OneD, NekDouble > &outarray)
 Extract the metric factors to compute the contravariant fluxes along edge edge and stores them into outarray following the local edge orientation (i.e. anticlockwise convention). More...
 
void GetTracePhysVals (const int trace, const StdRegions::StdExpansionSharedPtr &TraceExp, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, StdRegions::Orientation orient=StdRegions::eNoOrientation)
 
void GetTracePhysMap (const int edge, Array< OneD, int > &outarray)
 
void ReOrientTracePhysMap (const StdRegions::Orientation orient, Array< OneD, int > &idmap, const int nq0, const int nq1)
 
const NormalVector & GetTraceNormal (const int id) const
 
void ComputeTraceNormal (const int id)
 
const Array< OneD, const NekDouble > & GetPhysNormals (void)
 
void SetPhysNormals (Array< OneD, const NekDouble > &normal)
 
void SetUpPhysNormals (const int trace)
 
void AddRobinMassMatrix (const int traceid, const Array< OneD, const NekDouble > &primCoeffs, DNekMatSharedPtr &inoutmat)
 
virtual void AddRobinTraceContribution (const int traceid, const Array< OneD, const NekDouble > &primCoeffs, const Array< OneD, NekDouble > &incoeffs, Array< OneD, NekDouble > &coeffs)
 
const Array< OneD, const NekDouble > & GetElmtBndNormDirElmtLen (const int nbnd) const
 

Protected Member Functions

virtual NekDouble v_Integral (const Array< OneD, const NekDouble > &inarray) override
 Integrate the physical point list inarray over region and return the value. More...
 
virtual void v_PhysDeriv (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_d0, Array< OneD, NekDouble > &out_d1=NullNekDouble1DArray, Array< OneD, NekDouble > &out_d2=NullNekDouble1DArray) override
 Evaluate the derivative \( d/d{\xi_1} \) at the physical quadrature points given by inarray and return in outarray. More...
 
virtual void v_PhysDeriv (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) override
 Calculate the derivative of the physical points in a given direction. More...
 
virtual void v_PhysDeriv_s (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_ds) override
 Evaluate the derivative along a line: \( d/ds=\frac{spacedim}{||tangent||}d/d{\xi} \). The derivative is calculated performing the product \( du/d{s}=\nabla u \cdot tangent \). More...
 
virtual void v_PhysDeriv_n (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_dn) override
 Evaluate the derivative normal to a line: \( d/dn=\frac{spacedim}{||normal||}d/d{\xi} \). The derivative is calculated performing the product \( du/d{s}=\nabla u \cdot normal \). More...
 
virtual void v_FwdTrans (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) override
 Forward transform from physical quadrature space stored in inarray and evaluate the expansion coefficients and store in outarray. More...
 
virtual void v_FwdTrans_BndConstrained (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) override
 
virtual void v_IProductWRTBase (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) override
 Inner product of inarray over region with respect to the expansion basis (this)->_Base[0] and return in outarray. More...
 
virtual void v_IProductWRTBase (const Array< OneD, const NekDouble > &base, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, int coll_check) override
 Inner product of inarray over region with respect to expansion basis base and return in outarray. More...
 
virtual void v_IProductWRTDerivBase (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) override
 
virtual void v_NormVectorIProductWRTBase (const Array< OneD, const NekDouble > &Fx, const Array< OneD, const NekDouble > &Fy, Array< OneD, NekDouble > &outarray) override
 
virtual void v_NormVectorIProductWRTBase (const Array< OneD, const Array< OneD, NekDouble > > &Fvec, Array< OneD, NekDouble > &outarray) override
 
virtual NekDouble v_StdPhysEvaluate (const Array< OneD, const NekDouble > &Lcoord, const Array< OneD, const NekDouble > &physvals) override
 
virtual NekDouble v_PhysEvaluate (const Array< OneD, const NekDouble > &coord, const Array< OneD, const NekDouble > &physvals) override
 
virtual void v_GetCoord (const Array< OneD, const NekDouble > &Lcoords, Array< OneD, NekDouble > &coords) override
 
virtual void v_GetCoords (Array< OneD, NekDouble > &coords_1, Array< OneD, NekDouble > &coords_2, Array< OneD, NekDouble > &coords_3) override
 
virtual void v_GetVertexPhysVals (const int vertex, const Array< OneD, const NekDouble > &inarray, NekDouble &outarray) override
 
virtual void v_AddVertexPhysVals (const int vertex, const NekDouble &inarray, Array< OneD, NekDouble > &outarray)
 
virtual void v_GetTracePhysVals (const int edge, const StdRegions::StdExpansionSharedPtr &EdgeExp, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, StdRegions::Orientation orient) override
 
virtual void v_GetTracePhysMap (const int vertex, Array< OneD, int > &map) override
 
virtual StdRegions::StdExpansionSharedPtr v_GetStdExp (void) const override
 
virtual StdRegions::StdExpansionSharedPtr v_GetLinStdExp (void) const override
 
virtual int v_GetCoordim () override
 
virtual void v_SetCoeffsToOrientation (StdRegions::Orientation dir, Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) override
 
virtual int v_GetNumPoints (const int dir) const
 
virtual int v_GetNcoeffs (void) const
 
virtual const LibUtilities::BasisSharedPtr & v_GetBasis (int dir) const
 
virtual int v_NumBndryCoeffs () const override
 
virtual int v_NumDGBndryCoeffs () const override
 
virtual void v_ComputeTraceNormal (const int vertex) override
 
virtual SpatialDomains::GeomType v_MetricInfoType ()
 
virtual void v_ExtractDataToCoeffs (const NekDouble *data, const std::vector< unsigned int > &nummodes, const int mode_offset, NekDouble *coeffs, std::vector< LibUtilities::BasisType > &fromType) override
 Unpack data from input file assuming it comes from. More...
 
virtual const Array< OneD, const NekDouble > & v_GetPhysNormals (void) override
 
virtual void v_LaplacianMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey) override
 
virtual void v_HelmholtzMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey) override
 
virtual DNekMatSharedPtr v_GenMatrix (const StdRegions::StdMatrixKey &mkey) override
 
DNekScalMatSharedPtr CreateMatrix (const MatrixKey &mkey)
 
virtual DNekMatSharedPtr v_CreateStdMatrix (const StdRegions::StdMatrixKey &mkey) override
 
DNekScalBlkMatSharedPtr CreateStaticCondMatrix (const MatrixKey &mkey)
 
virtual DNekScalMatSharedPtr v_GetLocMatrix (const MatrixKey &mkey) override
 
virtual DNekScalBlkMatSharedPtr v_GetLocStaticCondMatrix (const MatrixKey &mkey) override
 
void v_DropLocStaticCondMatrix (const MatrixKey &mkey) override
 
- Protected Member Functions inherited from Nektar::StdRegions::StdSegExp
virtual void v_StdPhysDeriv (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_d0, Array< OneD, NekDouble > &out_d1=NullNekDouble1DArray, Array< OneD, NekDouble > &out_d2=NullNekDouble1DArray)
 
virtual void v_StdPhysDeriv (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
virtual void v_BwdTrans (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 Backward transform from coefficient space given in inarray and evaluate at the physical quadrature points outarray. More...
 
virtual void v_BwdTrans_SumFac (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
virtual void v_IProductWRTBase_SumFac (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, bool multiplybyweights=true)
 
virtual void v_LocCoordToLocCollapsed (const Array< OneD, const NekDouble > &xi, Array< OneD, NekDouble > &eta)
 
virtual void v_LocCollapsedToLocCoord (const Array< OneD, const NekDouble > &eta, Array< OneD, NekDouble > &xi)
 
NekDouble v_PhysEvaluateBasis (const Array< OneD, const NekDouble > &coords, int mode) final
 
virtual void v_SVVLaplacianFilter (Array< OneD, NekDouble > &array, const StdMatrixKey &mkey)
 
virtual void v_ExponentialFilter (Array< OneD, NekDouble > &array, const NekDouble alpha, const NekDouble exponent, const NekDouble cutoff)
 
virtual void v_MultiplyByStdQuadratureMetric (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
virtual void v_FillMode (const int mode, Array< OneD, NekDouble > &outarray)
 
virtual void v_GetBoundaryMap (Array< OneD, unsigned int > &outarray)
 
virtual void v_GetInteriorMap (Array< OneD, unsigned int > &outarray)
 
virtual int v_GetVertexMap (int localVertexId, bool useCoeffPacking=false)
 
virtual int v_GetNverts () const
 
virtual int v_GetNtraces () const
 
virtual int v_GetTraceNcoeffs (const int i) const
 
virtual int v_GetTraceNumPoints (const int i) const
 
virtual bool v_IsBoundaryInteriorExpansion ()
 
virtual int v_CalcNumberOfCoefficients (const std::vector< unsigned int > &nummodes, int &modes_offset)
 
virtual LibUtilities::ShapeType v_DetShapeType () const
 Return Shape of region, using ShapeType enum list. i.e. Segment. More...
 
virtual void v_GetSimplexEquiSpacedConnectivity (Array< OneD, int > &conn, bool standard=true)
 
virtual void v_ReduceOrderCoeffs (int numMin, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
virtual void v_GetTraceToElementMap (const int tid, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray, Orientation edgeOrient, int P, int Q)
 
- Protected Member Functions inherited from Nektar::StdRegions::StdExpansion
DNekMatSharedPtr CreateStdMatrix (const StdMatrixKey &mkey)
 
DNekBlkMatSharedPtr CreateStdStaticCondMatrix (const StdMatrixKey &mkey)
 Create the static condensation of a matrix when using a boundary interior decomposition. More...
 
void BwdTrans_MatOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
void BwdTrans_SumFac (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
void IProductWRTDerivBase_SumFac (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
void IProductWRTDirectionalDerivBase_SumFac (const Array< OneD, const NekDouble > &direction, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
void GeneralMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void MassMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void LaplacianMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void LaplacianMatrixOp_MatFree_Kernel (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, Array< OneD, NekDouble > &wsp)
 
void LaplacianMatrixOp_MatFree_GenericImpl (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void LaplacianMatrixOp_MatFree (const int k1, const int k2, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void WeakDerivMatrixOp_MatFree (const int i, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void WeakDirectionalDerivMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void MassLevelCurvatureMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void LinearAdvectionDiffusionReactionMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey, bool addDiffusionTerm=true)
 
void HelmholtzMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void HelmholtzMatrixOp_MatFree_GenericImpl (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
virtual void v_SetCoeffsToOrientation (Array< OneD, NekDouble > &coeffs, StdRegions::Orientation dir)
 
virtual void v_GenStdMatBwdDeriv (const int dir, DNekMatSharedPtr &mat)
 
template<int DIR>
NekDouble BaryEvaluate (const NekDouble &coord, const NekDouble *physvals)
 This function performs the barycentric interpolation of the polynomial stored in coord at a point physvals using barycentric interpolation weights in direction. More...
 
template<int DIR>
NekDouble BaryEvaluateBasis (const NekDouble &coord, const int &mode)
 
- Protected Member Functions inherited from Nektar::LocalRegions::Expansion1D
virtual void v_AddRobinMassMatrix (const int vert, const Array< OneD, const NekDouble > &primCoeffs, DNekMatSharedPtr &inoutmat)
 
virtual void v_AddRobinEdgeContribution (const int vert, const Array< OneD, const NekDouble > &primCoeffs, const Array< OneD, NekDouble > &incoeffs, Array< OneD, NekDouble > &coeffs)
 
virtual NekDouble v_VectorFlux (const Array< OneD, Array< OneD, NekDouble > > &vec)
 
virtual const NormalVector & v_GetTraceNormal (const int edge) const final
 
virtual void v_ReOrientTracePhysMap (const StdRegions::Orientation orient, Array< OneD, int > &idmap, const int nq0, const int nq1)
 
- Protected Member Functions inherited from Nektar::LocalRegions::Expansion
void ComputeLaplacianMetric ()
 
void ComputeQuadratureMetric ()
 
void ComputeGmatcdotMF (const Array< TwoD, const NekDouble > &df, const Array< OneD, const NekDouble > &direction, Array< OneD, Array< OneD, NekDouble > > &dfdir)
 
virtual void v_MultiplyByQuadratureMetric (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
virtual void v_DivideByQuadratureMetric (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
virtual void v_ComputeLaplacianMetric ()
 
Array< OneD, NekDouble > v_GetMF (const int dir, const int shapedim, const StdRegions::VarCoeffMap &varcoeffs)
 
Array< OneD, NekDouble > v_GetMFDiv (const int dir, const StdRegions::VarCoeffMap &varcoeffs)
 
Array< OneD, NekDouble > v_GetMFMag (const int dir, const StdRegions::VarCoeffMap &varcoeffs)
 
virtual DNekMatSharedPtr v_BuildTransformationMatrix (const DNekScalMatSharedPtr &r_bnd, const StdRegions::MatrixType matrixType)
 
virtual DNekMatSharedPtr v_BuildVertexMatrix (const DNekScalMatSharedPtr &r_bnd)
 
virtual void v_AddEdgeNormBoundaryInt (const int edge, const std::shared_ptr< Expansion > &EdgeExp, const Array< OneD, const NekDouble > &Fx, const Array< OneD, const NekDouble > &Fy, Array< OneD, NekDouble > &outarray)
 
virtual void v_AddEdgeNormBoundaryInt (const int edge, const std::shared_ptr< Expansion > &EdgeExp, const Array< OneD, const NekDouble > &Fn, Array< OneD, NekDouble > &outarray)
 
virtual void v_AddFaceNormBoundaryInt (const int face, const std::shared_ptr< Expansion > &FaceExp, const Array< OneD, const NekDouble > &Fn, Array< OneD, NekDouble > &outarray)
 
virtual void v_DGDeriv (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, ExpansionSharedPtr > &EdgeExp, Array< OneD, Array< OneD, NekDouble > > &coeffs, Array< OneD, NekDouble > &outarray)
 
virtual void v_AlignVectorToCollapsedDir (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)
 
virtual StdRegions::Orientation v_GetTraceOrient (int trace)
 
virtual void v_GetTraceQFactors (const int trace, Array< OneD, NekDouble > &outarray)
 
virtual void v_SetPhysNormals (Array< OneD, const NekDouble > &normal)
 
virtual void v_SetUpPhysNormals (const int id)
 
virtual void v_AddRobinTraceContribution (const int traceid, const Array< OneD, const NekDouble > &primCoeffs, const Array< OneD, NekDouble > &incoeffs, Array< OneD, NekDouble > &coeffs)
 

Private Member Functions

 SegExp ()
 
void ReverseCoeffsAndSign (const Array< OneD, NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 Reverse the coefficients in a boundary interior expansion this routine is of use when we need the segment coefficients corresponding to a expansion in the reverse coordinate direction. More...
 
void MultiplyByElmtInvMass (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 

Private Attributes

LibUtilities::NekManager< MatrixKey, DNekScalMat, MatrixKey::opLess > m_matrixManager
 
LibUtilities::NekManager< MatrixKey, DNekScalBlkMat, MatrixKey::opLess > m_staticCondMatrixManager
 

Additional Inherited Members

- Protected Attributes inherited from Nektar::StdRegions::StdExpansion
Array< OneD, LibUtilities::BasisSharedPtr > m_base
 
int m_elmt_id
 
int m_ncoeffs
 
LibUtilities::NekManager< StdMatrixKey, DNekMat, StdMatrixKey::opLess > m_stdMatrixManager
 
LibUtilities::NekManager< StdMatrixKey, DNekBlkMat, StdMatrixKey::opLess > m_stdStaticCondMatrixManager
 
- Protected Attributes inherited from Nektar::LocalRegions::Expansion1D
std::map< int, NormalVector > m_vertexNormals
 
- Protected Attributes inherited from Nektar::LocalRegions::Expansion
LibUtilities::NekManager< IndexMapKey, IndexMapValues, IndexMapKey::opLess > m_indexMapManager
 
std::vector< ExpansionWeakPtr > m_traceExp
 
SpatialDomains::GeometrySharedPtr m_geom
 
SpatialDomains::GeomFactorsSharedPtr m_metricinfo
 
MetricMap m_metrics
 
ExpansionWeakPtr m_elementLeft
 
ExpansionWeakPtr m_elementRight
 
int m_elementTraceLeft = -1
 
int m_elementTraceRight = -1
 
std::map< int, Array< OneD, NekDouble > > m_elmtBndNormDirElmtLen
 the element length in each element boundary(Vertex, edge or face) normal direction calculated based on the local m_metricinfo times the standard element length (which is 2.0) More...
 

Detailed Description

Defines a Segment local expansion.

Definition at line 51 of file SegExp.h.

Constructor & Destructor Documentation

◆ SegExp() [1/3]

Nektar::LocalRegions::SegExp::SegExp ( const LibUtilities::BasisKey &  Ba,
const SpatialDomains::Geometry1DSharedPtr &  geom 
)

Constructor using BasisKey class for quadrature points and order definition.

Parameters
BaBasis key of segment expansion.
geomDescription of geometry.

Definition at line 59 of file SegExp.cpp.

60  :
61  StdExpansion(Ba.GetNumModes(), 1, Ba),
62  StdExpansion1D(Ba.GetNumModes(), Ba),
63  StdRegions::StdSegExp(Ba),
64  Expansion(geom),
65  Expansion1D(geom),
66  m_matrixManager(
67  std::bind(&SegExp::CreateMatrix, this, std::placeholders::_1),
68  std::string("SegExpMatrix")),
69  m_staticCondMatrixManager(
70  std::bind(&SegExp::CreateStaticCondMatrix, this, std::placeholders::_1),
71  std::string("SegExpStaticCondMatrix"))
72  {
73  }
Nektar::LocalRegions::Expansion1D::Expansion1D
Expansion1D(SpatialDomains::Geometry1DSharedPtr pGeom)
Definition: Expansion1D.h:60
Nektar::LocalRegions::Expansion::Expansion
Expansion(SpatialDomains::GeometrySharedPtr pGeom)
Definition: Expansion.cpp:47
Nektar::LocalRegions::SegExp::CreateStaticCondMatrix
DNekScalBlkMatSharedPtr CreateStaticCondMatrix(const MatrixKey &mkey)
Definition: SegExp.cpp:1503
Nektar::LocalRegions::SegExp::CreateMatrix
DNekScalMatSharedPtr CreateMatrix(const MatrixKey &mkey)
Definition: SegExp.cpp:1269
Nektar::LocalRegions::SegExp::m_staticCondMatrixManager
LibUtilities::NekManager< MatrixKey, DNekScalBlkMat, MatrixKey::opLess > m_staticCondMatrixManager
Definition: SegExp.h:255
Nektar::LocalRegions::SegExp::m_matrixManager
LibUtilities::NekManager< MatrixKey, DNekScalMat, MatrixKey::opLess > m_matrixManager
Definition: SegExp.h:253
Nektar::StdRegions::StdExpansion::StdExpansion
StdExpansion()
Default Constructor.
Definition: StdExpansion.cpp:45

◆ SegExp() [2/3]

Nektar::LocalRegions::SegExp::SegExp ( const SegExp &  S)

Copy Constructor.

Parameters
SExisting segment to duplicate.

Definition at line 80 of file SegExp.cpp.

80  :
81  StdExpansion(S),
82  StdExpansion1D(S),
83  StdRegions::StdSegExp(S),
84  Expansion(S),
85  Expansion1D(S),
86  m_matrixManager(S.m_matrixManager),
87  m_staticCondMatrixManager(S.m_staticCondMatrixManager)
88  {
89  }

◆ ~SegExp()

Nektar::LocalRegions::SegExp::~SegExp ( )

Definition at line 95 of file SegExp.cpp.

96  {
97  }

◆ SegExp() [3/3]

Nektar::LocalRegions::SegExp::SegExp ( )
private

Member Function Documentation

◆ CreateMatrix()

DNekScalMatSharedPtr Nektar::LocalRegions::SegExp::CreateMatrix ( const MatrixKey &  mkey)
protected

Definition at line 1269 of file SegExp.cpp.

1270  {
1271  DNekScalMatSharedPtr returnval;
1272  NekDouble fac;
1273  LibUtilities::PointsKeyVector ptsKeys = GetPointsKeys();
1274 
1275  ASSERTL2(m_metricinfo->GetGtype() !=
1276  SpatialDomains::eNoGeomType,
1277  "Geometric information is not set up");
1278 
1279  switch (mkey.GetMatrixType())
1280  {
1281  case StdRegions::eMass:
1282  {
1283  if ((m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
1284  || (mkey.GetNVarCoeff()))
1285  {
1286  fac = 1.0;
1287  goto UseLocRegionsMatrix;
1288  }
1289  else
1290  {
1291  fac = (m_metricinfo->GetJac(ptsKeys))[0];
1292  goto UseStdRegionsMatrix;
1293  }
1294  }
1295  break;
1296  case StdRegions::eInvMass:
1297  {
1298  if ((m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
1299  || (mkey.GetNVarCoeff()))
1300  {
1301  NekDouble one = 1.0;
1302  StdRegions::StdMatrixKey masskey(
1303  StdRegions::eMass,DetShapeType(), *this);
1304  DNekMatSharedPtr mat = GenMatrix(masskey);
1305  mat->Invert();
1306 
1307  returnval = MemoryManager<DNekScalMat>::
1308  AllocateSharedPtr(one,mat);
1309  }
1310  else
1311  {
1312  fac = 1.0/(m_metricinfo->GetJac(ptsKeys))[0];
1313  goto UseStdRegionsMatrix;
1314  }
1315  }
1316  break;
1317  case StdRegions::eWeakDeriv0:
1318  case StdRegions::eWeakDeriv1:
1319  case StdRegions::eWeakDeriv2:
1320  {
1321  if (m_metricinfo->GetGtype() == SpatialDomains::eDeformed ||
1322  mkey.GetNVarCoeff())
1323  {
1324  fac = 1.0;
1325  goto UseLocRegionsMatrix;
1326  }
1327  else
1328  {
1329  int dir = 0;
1330  switch(mkey.GetMatrixType())
1331  {
1332  case StdRegions::eWeakDeriv0:
1333  dir = 0;
1334  break;
1335  case StdRegions::eWeakDeriv1:
1336  ASSERTL1(m_geom->GetCoordim() >= 2,
1337  "Cannot call eWeakDeriv2 in a "
1338  "coordinate system which is not at "
1339  "least two-dimensional");
1340  dir = 1;
1341  break;
1342  case StdRegions::eWeakDeriv2:
1343  ASSERTL1(m_geom->GetCoordim() == 3,
1344  "Cannot call eWeakDeriv2 in a "
1345  "coordinate system which is not "
1346  "three-dimensional");
1347  dir = 2;
1348  break;
1349  default:
1350  break;
1351  }
1352 
1353  MatrixKey deriv0key(StdRegions::eWeakDeriv0,
1354  mkey.GetShapeType(), *this);
1355 
1356  DNekMatSharedPtr WeakDerivStd = GetStdMatrix(deriv0key);
1357  fac = m_metricinfo->GetDerivFactors(ptsKeys)[dir][0]*
1358  m_metricinfo->GetJac(ptsKeys)[0];
1359 
1360  returnval = MemoryManager<DNekScalMat>::
1361  AllocateSharedPtr(fac,WeakDerivStd);
1362  }
1363  }
1364  break;
1365  case StdRegions::eLaplacian:
1366  {
1367  if (m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
1368  {
1369  fac = 1.0;
1370  goto UseLocRegionsMatrix;
1371  }
1372  else
1373  {
1374  int coordim = m_geom->GetCoordim();
1375  fac = 0.0;
1376  for (int i = 0; i < coordim; ++i)
1377  {
1378  fac += m_metricinfo->GetDerivFactors(ptsKeys)[i][0]*
1379  m_metricinfo->GetDerivFactors(ptsKeys)[i][0];
1380  }
1381  fac *= m_metricinfo->GetJac(ptsKeys)[0];
1382  goto UseStdRegionsMatrix;
1383  }
1384  }
1385  break;
1386  case StdRegions::eHelmholtz:
1387  {
1388  NekDouble factor =
1389  mkey.GetConstFactor(StdRegions::eFactorLambda);
1390  MatrixKey masskey(StdRegions::eMass,
1391  mkey.GetShapeType(), *this);
1392  DNekScalMat &MassMat = *(this->m_matrixManager[masskey]);
1393  MatrixKey lapkey(StdRegions::eLaplacian, mkey.GetShapeType(),
1394  *this, mkey.GetConstFactors(),
1395  mkey.GetVarCoeffs());
1396  DNekScalMat &LapMat = *(this->m_matrixManager[lapkey]);
1397 
1398  int rows = LapMat.GetRows();
1399  int cols = LapMat.GetColumns();
1400 
1401  DNekMatSharedPtr helm =
1402  MemoryManager<DNekMat>::AllocateSharedPtr(rows,cols);
1403 
1404  NekDouble one = 1.0;
1405  (*helm) = LapMat + factor*MassMat;
1406 
1407  returnval =
1408  MemoryManager<DNekScalMat>::AllocateSharedPtr(one,helm);
1409  }
1410  break;
1411  case StdRegions::eHybridDGHelmholtz:
1412  case StdRegions::eHybridDGLamToU:
1413  case StdRegions::eHybridDGLamToQ0:
1414  case StdRegions::eHybridDGHelmBndLam:
1415  {
1416  NekDouble one = 1.0;
1417 
1418  DNekMatSharedPtr mat = GenMatrix(mkey);
1419  returnval =
1420  MemoryManager<DNekScalMat>::AllocateSharedPtr(one,mat);
1421  }
1422  break;
1423  case StdRegions::eInvHybridDGHelmholtz:
1424  {
1425  NekDouble one = 1.0;
1426 
1427 // StdRegions::StdMatrixKey hkey(StdRegions::eHybridDGHelmholtz,
1428 // DetShapeType(),*this,
1429 // mkey.GetConstant(0),
1430 // mkey.GetConstant(1));
1431  MatrixKey hkey(StdRegions::eHybridDGHelmholtz,
1432  DetShapeType(),
1433  *this, mkey.GetConstFactors(),
1434  mkey.GetVarCoeffs());
1435  DNekMatSharedPtr mat = GenMatrix(hkey);
1436 
1437  mat->Invert();
1438  returnval =
1439  MemoryManager<DNekScalMat>::AllocateSharedPtr(one,mat);
1440  }
1441  break;
1442  case StdRegions::eInterpGauss:
1443  {
1444  DNekMatSharedPtr m_Ix;
1445  Array<OneD, NekDouble> coords(1, 0.0);
1446  StdRegions::ConstFactorMap factors = mkey.GetConstFactors();
1447  int vertex = (int)factors[StdRegions::eFactorGaussVertex];
1448 
1449  coords[0] = (vertex == 0) ? -1.0 : 1.0;
1450 
1451  m_Ix = m_base[0]->GetI(coords);
1452  returnval =
1453  MemoryManager<DNekScalMat>::AllocateSharedPtr(1.0,m_Ix);
1454  }
1455  break;
1456 
1457  UseLocRegionsMatrix:
1458  {
1459  DNekMatSharedPtr mat = GenMatrix(mkey);
1460  returnval =
1461  MemoryManager<DNekScalMat>::AllocateSharedPtr(fac,mat);
1462  }
1463  break;
1464  UseStdRegionsMatrix:
1465  {
1466  DNekMatSharedPtr mat = GetStdMatrix(mkey);
1467  returnval =
1468  MemoryManager<DNekScalMat>::AllocateSharedPtr(fac,mat);
1469  }
1470  break;
1471  default:
1472  NEKERROR(ErrorUtil::efatal, "Matrix creation not defined");
1473  break;
1474  }
1475 
1476  return returnval;
1477  }
NEKERROR
#define NEKERROR(type, msg)
Assert Level 0 – Fundamental assert which is used whether in FULLDEBUG, DEBUG or OPT compilation mode...
Definition: ErrorUtil.hpp:209
ASSERTL1
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode....
Definition: ErrorUtil.hpp:250
ASSERTL2
#define ASSERTL2(condition, msg)
Assert Level 2 – Debugging which is used FULLDEBUG compilation mode. This level assert is designed to...
Definition: ErrorUtil.hpp:274
Nektar::LocalRegions::Expansion::m_geom
SpatialDomains::GeometrySharedPtr m_geom
Definition: Expansion.h:272
Nektar::LocalRegions::Expansion::m_metricinfo
SpatialDomains::GeomFactorsSharedPtr m_metricinfo
Definition: Expansion.h:273
Nektar::MemoryManager::AllocateSharedPtr
static std::shared_ptr< DataType > AllocateSharedPtr(const Args &...args)
Allocate a shared pointer from the memory pool.
Definition: NekMemoryManager.hpp:171
Nektar::StdRegions::StdExpansion::GetStdMatrix
DNekMatSharedPtr GetStdMatrix(const StdMatrixKey &mkey)
Definition: StdExpansion.h:617
Nektar::StdRegions::StdExpansion::GetPointsKeys
const LibUtilities::PointsKeyVector GetPointsKeys() const
Definition: StdExpansion.h:1078
Nektar::StdRegions::StdExpansion::DetShapeType
LibUtilities::ShapeType DetShapeType() const
This function returns the shape of the expansion domain.
Definition: StdExpansion.h:376
Nektar::StdRegions::StdExpansion::GenMatrix
DNekMatSharedPtr GenMatrix(const StdMatrixKey &mkey)
Definition: StdExpansion.h:850
Nektar::StdRegions::StdExpansion::m_base
Array< OneD, LibUtilities::BasisSharedPtr > m_base
Definition: StdExpansion.h:1162
Nektar::LibUtilities::PointsKeyVector
std::vector< PointsKey > PointsKeyVector
Definition: Points.h:246
Nektar::SpatialDomains::eNoGeomType
@ eNoGeomType
No type defined.
Definition: SpatialDomains.hpp:53
Nektar::SpatialDomains::eDeformed
@ eDeformed
Geometry is curved or has non-constant factors.
Definition: SpatialDomains.hpp:56
Nektar::StdRegions::ConstFactorMap
std::map< ConstFactorType, NekDouble > ConstFactorMap
Definition: StdRegions.hpp:314
Nektar::DNekScalMat
NekMatrix< NekMatrix< NekDouble, StandardMatrixTag >, ScaledMatrixTag > DNekScalMat
Definition: NekMatrixFwd.hpp:68
Nektar::DNekScalMatSharedPtr
std::shared_ptr< DNekScalMat > DNekScalMatSharedPtr
Definition: NekMatrixFwd.hpp:69
Nektar::DNekMatSharedPtr
std::shared_ptr< DNekMat > DNekMatSharedPtr
Definition: NekTypeDefs.hpp:69
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:43

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL1, ASSERTL2, Nektar::StdRegions::StdExpansion::DetShapeType(), Nektar::SpatialDomains::eDeformed, Nektar::StdRegions::eFactorGaussVertex, Nektar::StdRegions::eFactorLambda, Nektar::ErrorUtil::efatal, Nektar::StdRegions::eHelmholtz, Nektar::StdRegions::eHybridDGHelmBndLam, Nektar::StdRegions::eHybridDGHelmholtz, Nektar::StdRegions::eHybridDGLamToQ0, Nektar::StdRegions::eHybridDGLamToU, Nektar::StdRegions::eInterpGauss, Nektar::StdRegions::eInvHybridDGHelmholtz, Nektar::StdRegions::eInvMass, Nektar::StdRegions::eLaplacian, Nektar::StdRegions::eMass, Nektar::SpatialDomains::eNoGeomType, Nektar::StdRegions::eWeakDeriv0, Nektar::StdRegions::eWeakDeriv1, Nektar::StdRegions::eWeakDeriv2, Nektar::StdRegions::StdExpansion::GenMatrix(), Nektar::StdRegions::StdMatrixKey::GetConstFactor(), Nektar::StdRegions::StdMatrixKey::GetConstFactors(), Nektar::StdRegions::StdMatrixKey::GetMatrixType(), Nektar::StdRegions::StdMatrixKey::GetNVarCoeff(), Nektar::StdRegions::StdExpansion::GetPointsKeys(), Nektar::StdRegions::StdMatrixKey::GetShapeType(), Nektar::StdRegions::StdExpansion::GetStdMatrix(), Nektar::StdRegions::StdMatrixKey::GetVarCoeffs(), Nektar::StdRegions::StdExpansion::m_base, Nektar::LocalRegions::Expansion::m_geom, m_matrixManager, Nektar::LocalRegions::Expansion::m_metricinfo, and NEKERROR.

◆ CreateStaticCondMatrix()

DNekScalBlkMatSharedPtr Nektar::LocalRegions::SegExp::CreateStaticCondMatrix ( const MatrixKey &  mkey)
protected
Todo:
Really need a constructor which takes Arrays

Definition at line 1503 of file SegExp.cpp.

1505  {
1506  DNekScalBlkMatSharedPtr returnval;
1507 
1508  ASSERTL2(m_metricinfo->GetGtype() !=
1509  SpatialDomains::eNoGeomType,
1510  "Geometric information is not set up");
1511 
1512  // set up block matrix system
1513  int nbdry = NumBndryCoeffs();
1514  int nint = m_ncoeffs - nbdry;
1515  Array<OneD, unsigned int> exp_size(2);
1516  exp_size[0] = nbdry;
1517  exp_size[1] = nint;
1518 
1519  /// \todo Really need a constructor which takes Arrays
1520  returnval = MemoryManager<DNekScalBlkMat>::
1521  AllocateSharedPtr(exp_size,exp_size);
1522  NekDouble factor = 1.0;
1523 
1524  switch (mkey.GetMatrixType())
1525  {
1526  case StdRegions::eLaplacian:
1527  case StdRegions::eHelmholtz: // special case since Helmholtz
1528  // not defined in StdRegions
1529 
1530  // use Deformed case for both regular and deformed geometries
1531  factor = 1.0;
1532  goto UseLocRegionsMatrix;
1533  break;
1534  default:
1535  if(m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
1536  {
1537  factor = 1.0;
1538  goto UseLocRegionsMatrix;
1539  }
1540  else
1541  {
1542  DNekScalMatSharedPtr mat = GetLocMatrix(mkey);
1543  factor = mat->Scale();
1544  goto UseStdRegionsMatrix;
1545  }
1546  break;
1547  UseStdRegionsMatrix:
1548  {
1549  NekDouble invfactor = 1.0/factor;
1550  NekDouble one = 1.0;
1551  DNekBlkMatSharedPtr mat = GetStdStaticCondMatrix(mkey);
1552  DNekScalMatSharedPtr Atmp;
1553  DNekMatSharedPtr Asubmat;
1554 
1555  returnval->SetBlock(0,0,Atmp =
1556  MemoryManager<DNekScalMat>::AllocateSharedPtr(
1557  factor,Asubmat = mat->GetBlock(0,0)));
1558  returnval->SetBlock(0,1,Atmp =
1559  MemoryManager<DNekScalMat>::AllocateSharedPtr(
1560  one,Asubmat = mat->GetBlock(0,1)));
1561  returnval->SetBlock(1,0,Atmp =
1562  MemoryManager<DNekScalMat>::AllocateSharedPtr(
1563  factor,Asubmat = mat->GetBlock(1,0)));
1564  returnval->SetBlock(1,1,Atmp =
1565  MemoryManager<DNekScalMat>::AllocateSharedPtr(
1566  invfactor,Asubmat = mat->GetBlock(1,1)));
1567  }
1568  break;
1569  UseLocRegionsMatrix:
1570  {
1571  int i,j;
1572  NekDouble invfactor = 1.0/factor;
1573  NekDouble one = 1.0;
1574  DNekScalMat &mat = *GetLocMatrix(mkey);
1575  DNekMatSharedPtr A =
1576  MemoryManager<DNekMat>::AllocateSharedPtr(nbdry,nbdry);
1577  DNekMatSharedPtr B =
1578  MemoryManager<DNekMat>::AllocateSharedPtr(nbdry,nint);
1579  DNekMatSharedPtr C =
1580  MemoryManager<DNekMat>::AllocateSharedPtr(nint,nbdry);
1581  DNekMatSharedPtr D =
1582  MemoryManager<DNekMat>::AllocateSharedPtr(nint,nint);
1583 
1584  Array<OneD,unsigned int> bmap(nbdry);
1585  Array<OneD,unsigned int> imap(nint);
1586  GetBoundaryMap(bmap);
1587  GetInteriorMap(imap);
1588 
1589  for (i = 0; i < nbdry; ++i)
1590  {
1591  for (j = 0; j < nbdry; ++j)
1592  {
1593  (*A)(i,j) = mat(bmap[i],bmap[j]);
1594  }
1595 
1596  for (j = 0; j < nint; ++j)
1597  {
1598  (*B)(i,j) = mat(bmap[i],imap[j]);
1599  }
1600  }
1601 
1602  for (i = 0; i < nint; ++i)
1603  {
1604  for (j = 0; j < nbdry; ++j)
1605  {
1606  (*C)(i,j) = mat(imap[i],bmap[j]);
1607  }
1608 
1609  for (j = 0; j < nint; ++j)
1610  {
1611  (*D)(i,j) = mat(imap[i],imap[j]);
1612  }
1613  }
1614 
1615  // Calculate static condensed system
1616  if (nint)
1617  {
1618  D->Invert();
1619  (*B) = (*B)*(*D);
1620  (*A) = (*A) - (*B)*(*C);
1621  }
1622 
1623  DNekScalMatSharedPtr Atmp;
1624 
1625  returnval->SetBlock(0,0,Atmp = MemoryManager<DNekScalMat>::
1626  AllocateSharedPtr(factor,A));
1627  returnval->SetBlock(0,1,Atmp = MemoryManager<DNekScalMat>::
1628  AllocateSharedPtr(one,B));
1629  returnval->SetBlock(1,0,Atmp = MemoryManager<DNekScalMat>::
1630  AllocateSharedPtr(factor,C));
1631  returnval->SetBlock(1,1,Atmp = MemoryManager<DNekScalMat>::
1632  AllocateSharedPtr(invfactor,D));
1633  }
1634  }
1635 
1636 
1637  return returnval;
1638  }
Nektar::LocalRegions::Expansion::GetLocMatrix
DNekScalMatSharedPtr GetLocMatrix(const LocalRegions::MatrixKey &mkey)
Definition: Expansion.cpp:90
Nektar::StdRegions::StdExpansion::GetBoundaryMap
void GetBoundaryMap(Array< OneD, unsigned int > &outarray)
Definition: StdExpansion.h:687
Nektar::StdRegions::StdExpansion::GetStdStaticCondMatrix
DNekBlkMatSharedPtr GetStdStaticCondMatrix(const StdMatrixKey &mkey)
Definition: StdExpansion.h:622
Nektar::StdRegions::StdExpansion::GetInteriorMap
void GetInteriorMap(Array< OneD, unsigned int > &outarray)
Definition: StdExpansion.h:692
Nektar::DNekBlkMatSharedPtr
std::shared_ptr< DNekBlkMat > DNekBlkMatSharedPtr
Definition: NekTypeDefs.hpp:71
Nektar::DNekScalBlkMatSharedPtr
std::shared_ptr< DNekScalBlkMat > DNekScalBlkMatSharedPtr
Definition: NekTypeDefs.hpp:73

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL2, Nektar::SpatialDomains::eDeformed, Nektar::StdRegions::eHelmholtz, Nektar::StdRegions::eLaplacian, Nektar::SpatialDomains::eNoGeomType, Nektar::StdRegions::StdExpansion::GetBoundaryMap(), Nektar::StdRegions::StdExpansion::GetInteriorMap(), Nektar::LocalRegions::Expansion::GetLocMatrix(), Nektar::StdRegions::StdMatrixKey::GetMatrixType(), Nektar::StdRegions::StdExpansion::GetStdStaticCondMatrix(), Nektar::LocalRegions::Expansion::m_metricinfo, Nektar::StdRegions::StdExpansion::m_ncoeffs, and Nektar::StdRegions::StdExpansion::NumBndryCoeffs().

◆ MultiplyByElmtInvMass()

void Nektar::LocalRegions::SegExp::MultiplyByElmtInvMass ( const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray 
)
private
Todo:
Same method exists in ExpList and everyone references ExpList::MultiplyByElmtInvMass. Remove this one?

Definition at line 1692 of file SegExp.cpp.

1695  {
1696  // get Mass matrix inverse
1697  MatrixKey masskey(StdRegions::eInvMass,
1698  DetShapeType(),*this);
1699  DNekScalMatSharedPtr matsys = m_matrixManager[masskey];
1700 
1701  NekVector<NekDouble> in(m_ncoeffs,inarray,eCopy);
1702  NekVector<NekDouble> out(m_ncoeffs,outarray,eWrapper);
1703 
1704  out = (*matsys)*in;
1705  }

References Nektar::StdRegions::StdExpansion::DetShapeType(), Nektar::eCopy, Nektar::StdRegions::eInvMass, Nektar::eWrapper, m_matrixManager, and Nektar::StdRegions::StdExpansion::m_ncoeffs.

◆ ReverseCoeffsAndSign()

void Nektar::LocalRegions::SegExp::ReverseCoeffsAndSign ( const Array< OneD, NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray 
)
private

Reverse the coefficients in a boundary interior expansion this routine is of use when we need the segment coefficients corresponding to a expansion in the reverse coordinate direction.

Definition at line 1650 of file SegExp.cpp.

1653  {
1654 
1655  int m;
1656  NekDouble sgn = 1;
1657 
1658  ASSERTL1(&inarray[0] != &outarray[0],
1659  "inarray and outarray can not be the same");
1660  switch(GetBasisType(0))
1661  {
1662  case LibUtilities::eModified_A:
1663  //Swap vertices
1664  outarray[0] = inarray[1];
1665  outarray[1] = inarray[0];
1666  // negate odd modes
1667  for(m = 2; m < m_ncoeffs; ++m)
1668  {
1669  outarray[m] = sgn*inarray[m];
1670  sgn = -sgn;
1671  }
1672  break;
1673  case LibUtilities::eGLL_Lagrange:
1674  case LibUtilities::eGauss_Lagrange:
1675  for(m = 0; m < m_ncoeffs; ++m)
1676  {
1677  outarray[m_ncoeffs-1-m] = inarray[m];
1678  }
1679  break;
1680  default:
1681  ASSERTL0(false,"This basis is not allowed in this method");
1682  break;
1683  }
1684  }
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:216
Nektar::StdRegions::StdExpansion::GetBasisType
LibUtilities::BasisType GetBasisType(const int dir) const
This function returns the type of basis used in the dir direction.
Definition: StdExpansion.h:158
Nektar::LibUtilities::eGauss_Lagrange
@ eGauss_Lagrange
Lagrange Polynomials using the Gauss points .
Definition: BasisType.h:55
Nektar::LibUtilities::eGLL_Lagrange
@ eGLL_Lagrange
Lagrange for SEM basis .
Definition: BasisType.h:54
Nektar::LibUtilities::eModified_A
@ eModified_A
Principle Modified Functions .
Definition: BasisType.h:48

References ASSERTL0, ASSERTL1, Nektar::LibUtilities::eGauss_Lagrange, Nektar::LibUtilities::eGLL_Lagrange, Nektar::LibUtilities::eModified_A, Nektar::StdRegions::StdExpansion::GetBasisType(), and Nektar::StdRegions::StdExpansion::m_ncoeffs.

Referenced by v_SetCoeffsToOrientation().

◆ v_AddVertexPhysVals()

void Nektar::LocalRegions::SegExp::v_AddVertexPhysVals ( const int  vertex,
const NekDouble &  inarray,
Array< OneD, NekDouble > &  outarray 
)
protectedvirtual

Definition at line 742 of file SegExp.cpp.

746  {
747  size_t nquad = m_base[0]->GetNumPoints();
748 
749  if (m_base[0]->GetPointsType() != LibUtilities::eGaussGaussLegendre)
750  {
751  switch (vertex)
752  {
753  case 0:
754  outarray[0] += inarray;
755  break;
756  case 1:
757  outarray[nquad - 1] += inarray;
758  break;
759  }
760  }
761  else
762  {
763  StdRegions::ConstFactorMap factors;
764  factors[StdRegions::eFactorGaussVertex] = vertex;
765 
766  StdRegions::StdMatrixKey key(
767  StdRegions::eInterpGauss,
768  DetShapeType(),*this,factors);
769 
770  DNekScalMatSharedPtr mat_gauss = m_matrixManager[key];
771 
772  Vmath::Svtvp(nquad,inarray,
773  mat_gauss->GetOwnedMatrix()->GetPtr().get(), 1,
774  &outarray[0], 1, &outarray[0], 1);
775  }
776  }
Nektar::StdRegions::StdExpansion::GetPointsType
LibUtilities::PointsType GetPointsType(const int dir) const
This function returns the type of quadrature points used in the dir direction.
Definition: StdExpansion.h:208
Nektar::LibUtilities::eGaussGaussLegendre
@ eGaussGaussLegendre
1D Gauss-Gauss-Legendre quadrature points
Definition: PointsType.h:48
Vmath::Svtvp
void Svtvp(int n, const T alpha, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
svtvp (scalar times vector plus vector): z = alpha*x + y
Definition: Vmath.cpp:565

References Nektar::StdRegions::StdExpansion::DetShapeType(), Nektar::StdRegions::eFactorGaussVertex, Nektar::LibUtilities::eGaussGaussLegendre, Nektar::StdRegions::eInterpGauss, Nektar::StdRegions::StdExpansion::GetPointsType(), Nektar::StdRegions::StdExpansion::m_base, m_matrixManager, and Vmath::Svtvp().

◆ v_ComputeTraceNormal()

void Nektar::LocalRegions::SegExp::v_ComputeTraceNormal ( const int  vertex)
overrideprotectedvirtual

Reimplemented from Nektar::LocalRegions::Expansion.

Definition at line 945 of file SegExp.cpp.

946  {
947  int i;
948  const SpatialDomains::GeomFactorsSharedPtr &geomFactors =
949  GetGeom()->GetMetricInfo();
950  SpatialDomains::GeomType type = geomFactors->GetGtype();
951  const Array<TwoD, const NekDouble> &gmat =
952  geomFactors->GetDerivFactors(GetPointsKeys());
953  int nqe = 1;
954  int vCoordDim = GetCoordim();
955 
956  m_vertexNormals[vertex] =
957  Array<OneD, Array<OneD, NekDouble> >(vCoordDim);
958  Array<OneD, Array<OneD, NekDouble> > &normal =
959  m_vertexNormals[vertex];
960  for (i = 0; i < vCoordDim; ++i)
961  {
962  normal[i] = Array<OneD, NekDouble>(nqe);
963  }
964 
965 
966  size_t nqb = nqe;
967  size_t nbnd= vertex;
968  m_elmtBndNormDirElmtLen[nbnd] = Array<OneD, NekDouble> {nqb, 0.0};
969  Array<OneD, NekDouble> &length = m_elmtBndNormDirElmtLen[nbnd];
970 
971  // Regular geometry case
972  if ((type == SpatialDomains::eRegular) ||
973  (type == SpatialDomains::eMovingRegular))
974  {
975  NekDouble vert;
976  // Set up normals
977  switch (vertex)
978  {
979  case 0:
980  for(i = 0; i < vCoordDim; ++i)
981  {
982  Vmath::Fill(nqe, -gmat[i][0], normal[i], 1);
983  }
984  break;
985  case 1:
986  for(i = 0; i < vCoordDim; ++i)
987  {
988  Vmath::Fill(nqe, gmat[i][0], normal[i], 1);
989  }
990  break;
991  default:
992  ASSERTL0(false,
993  "point is out of range (point < 2)");
994  }
995 
996  // normalise
997  vert = 0.0;
998  for (i =0 ; i < vCoordDim; ++i)
999  {
1000  vert += normal[i][0]*normal[i][0];
1001  }
1002  vert = 1.0/sqrt(vert);
1003 
1004  Vmath::Fill(nqb, vert, length, 1);
1005 
1006  for (i = 0; i < vCoordDim; ++i)
1007  {
1008  Vmath::Smul(nqe, vert, normal[i], 1, normal[i], 1);
1009  }
1010  }
1011  }
Nektar::LocalRegions::Expansion1D::m_vertexNormals
std::map< int, NormalVector > m_vertexNormals
Definition: Expansion1D.h:83
Nektar::LocalRegions::Expansion::m_elmtBndNormDirElmtLen
std::map< int, Array< OneD, NekDouble > > m_elmtBndNormDirElmtLen
the element length in each element boundary(Vertex, edge or face) normal direction calculated based o...
Definition: Expansion.h:284
Nektar::LocalRegions::Expansion::GetGeom
SpatialDomains::GeometrySharedPtr GetGeom() const
Definition: Expansion.cpp:172
Nektar::SpatialDomains::GeomFactorsSharedPtr
std::shared_ptr< GeomFactors > GeomFactorsSharedPtr
Pointer to a GeomFactors object.
Definition: GeomFactors.h:62
Nektar::SpatialDomains::GeomType
GeomType
Indicates the type of element geometry.
Definition: SpatialDomains.hpp:52
Nektar::SpatialDomains::eRegular
@ eRegular
Geometry is straight-sided with constant geometric factors.
Definition: SpatialDomains.hpp:54
Nektar::SpatialDomains::eMovingRegular
@ eMovingRegular
Currently unused.
Definition: SpatialDomains.hpp:57
Vmath::Smul
void Smul(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Scalar multiply y = alpha*x.
Definition: Vmath.cpp:225
Vmath::Fill
void Fill(int n, const T alpha, T *x, const int incx)
Fill a vector with a constant value.
Definition: Vmath.cpp:45
tinysimd::sqrt
scalarT< T > sqrt(scalarT< T > in)
Definition: scalar.hpp:267

References ASSERTL0, Nektar::SpatialDomains::eMovingRegular, Nektar::SpatialDomains::eRegular, Vmath::Fill(), Nektar::StdRegions::StdExpansion::GetCoordim(), Nektar::LocalRegions::Expansion::GetGeom(), Nektar::StdRegions::StdExpansion::GetPointsKeys(), Nektar::LocalRegions::Expansion::m_elmtBndNormDirElmtLen, Nektar::LocalRegions::Expansion1D::m_vertexNormals, Vmath::Smul(), and tinysimd::sqrt().

◆ v_CreateStdMatrix()

DNekMatSharedPtr Nektar::LocalRegions::SegExp::v_CreateStdMatrix ( const StdRegions::StdMatrixKey &  mkey)
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdSegExp.

Definition at line 1258 of file SegExp.cpp.

1260  {
1261  LibUtilities::BasisKey bkey = m_base[0]->GetBasisKey();
1262  StdRegions::StdSegExpSharedPtr tmp =
1263  MemoryManager<StdSegExp>::AllocateSharedPtr(bkey);
1264 
1265  return tmp->GetStdMatrix(mkey);
1266  }
Nektar::StdRegions::StdSegExpSharedPtr
std::shared_ptr< StdSegExp > StdSegExpSharedPtr
Definition: StdSegExp.h:46

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), and Nektar::StdRegions::StdExpansion::m_base.

◆ v_DropLocStaticCondMatrix()

void Nektar::LocalRegions::SegExp::v_DropLocStaticCondMatrix ( const MatrixKey &  mkey)
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 1247 of file SegExp.cpp.

1248  {
1249  m_staticCondMatrixManager.DeleteObject(mkey);
1250  }

References m_staticCondMatrixManager.

◆ v_ExtractDataToCoeffs()

void Nektar::LocalRegions::SegExp::v_ExtractDataToCoeffs ( const NekDouble *  data,
const std::vector< unsigned int > &  nummodes,
const int  mode_offset,
NekDouble *  coeffs,
std::vector< LibUtilities::BasisType > &  fromType 
)
overrideprotectedvirtual

Unpack data from input file assuming it comes from.

Reimplemented from Nektar::LocalRegions::Expansion.

Definition at line 892 of file SegExp.cpp.

898  {
899  boost::ignore_unused(fromType);
900 
901  switch(m_base[0]->GetBasisType())
902  {
903  case LibUtilities::eModified_A:
904  {
905  int fillorder = min((int) nummodes[mode_offset],m_ncoeffs);
906 
907  Vmath::Zero(m_ncoeffs,coeffs,1);
908  Vmath::Vcopy(fillorder,&data[0],1,&coeffs[0],1);
909  }
910  break;
911  case LibUtilities::eGLL_Lagrange:
912  {
913  // Assume that input is also Gll_Lagrange
914  // but no way to check;
915  LibUtilities::PointsKey f0(
916  nummodes[mode_offset],
917  LibUtilities::eGaussLobattoLegendre);
918  LibUtilities::PointsKey t0(
919  m_base[0]->GetNumModes(),
920  LibUtilities::eGaussLobattoLegendre);
921  LibUtilities::Interp1D(
922  f0,data, t0, coeffs);
923  }
924  break;
925  case LibUtilities::eGauss_Lagrange:
926  {
927  // Assume that input is also Gauss_Lagrange
928  // but no way to check;
929  LibUtilities::PointsKey f0(
930  nummodes[mode_offset],
931  LibUtilities::eGaussGaussLegendre);
932  LibUtilities::PointsKey t0(
933  m_base[0]->GetNumModes(),
934  LibUtilities::eGaussGaussLegendre);
935  LibUtilities::Interp1D(
936  f0,data, t0, coeffs);
937  }
938  break;
939  default:
940  ASSERTL0(false,
941  "basis is either not set up or not hierarchicial");
942  }
943  }
Nektar::LibUtilities::Interp1D
void Interp1D(const BasisKey &fbasis0, const Array< OneD, const NekDouble > &from, const BasisKey &tbasis0, Array< OneD, NekDouble > &to)
this function interpolates a 1D function evaluated at the quadrature points of the basis fbasis0 to ...
Definition: Interp.cpp:53
Nektar::LibUtilities::eGaussLobattoLegendre
@ eGaussLobattoLegendre
1D Gauss-Lobatto-Legendre quadrature points
Definition: PointsType.h:51
Vmath::Zero
void Zero(int n, T *x, const int incx)
Zero vector.
Definition: Vmath.cpp:436
Vmath::Vcopy
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1199

References ASSERTL0, Nektar::LibUtilities::eGauss_Lagrange, Nektar::LibUtilities::eGaussGaussLegendre, Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eGLL_Lagrange, Nektar::LibUtilities::eModified_A, Nektar::StdRegions::StdExpansion::GetBasisType(), Nektar::LibUtilities::Interp1D(), Nektar::StdRegions::StdExpansion::m_base, Nektar::StdRegions::StdExpansion::m_ncoeffs, Vmath::Vcopy(), and Vmath::Zero().

◆ v_FwdTrans()

void Nektar::LocalRegions::SegExp::v_FwdTrans ( const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray 
)
overrideprotectedvirtual

Forward transform from physical quadrature space stored in inarray and evaluate the expansion coefficients and store in outarray.

Perform a forward transform using a Galerkin projection by taking the inner product of the physical points and multiplying by the inverse of the mass matrix using the Solve method of the standard matrix container holding the local mass matrix, i.e. \( {\bf \hat{u}} = {\bf M}^{-1} {\bf I} \) where \( {\bf I}[p] = \int^1_{-1} \phi_p(\xi_1) u(\xi_1) d\xi_1 \)

Inputs:

  • inarray: array of physical quadrature points to be transformed

Outputs:

  • outarray: updated array of expansion coefficients.

Reimplemented from Nektar::StdRegions::StdSegExp.

Definition at line 377 of file SegExp.cpp.

380  {
381  if (m_base[0]->Collocation())
382  {
383  Vmath::Vcopy(m_ncoeffs, inarray, 1, outarray, 1);
384  }
385  else
386  {
387  v_IProductWRTBase(inarray,outarray);
388 
389  // get Mass matrix inverse
390  MatrixKey masskey(StdRegions::eInvMass, DetShapeType(), *this);
391  DNekScalMatSharedPtr matsys = m_matrixManager[masskey];
392 
393  // copy inarray in case inarray == outarray
394  NekVector<NekDouble> in(m_ncoeffs,outarray,eCopy);
395  NekVector<NekDouble> out(m_ncoeffs,outarray,eWrapper);
396 
397  out = (*matsys)*in;
398  }
399  }
Nektar::LocalRegions::SegExp::v_IProductWRTBase
virtual void v_IProductWRTBase(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) override
Inner product of inarray over region with respect to the expansion basis (this)->_Base[0] and return ...
Definition: SegExp.cpp:506

References Nektar::StdRegions::StdExpansion::DetShapeType(), Nektar::eCopy, Nektar::StdRegions::eInvMass, Nektar::eWrapper, Nektar::StdRegions::StdExpansion::m_base, m_matrixManager, Nektar::StdRegions::StdExpansion::m_ncoeffs, v_IProductWRTBase(), and Vmath::Vcopy().

Referenced by v_FwdTrans_BndConstrained().

◆ v_FwdTrans_BndConstrained()

void Nektar::LocalRegions::SegExp::v_FwdTrans_BndConstrained ( const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray 
)
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdSegExp.

Definition at line 401 of file SegExp.cpp.

404  {
405  if(m_base[0]->Collocation())
406  {
407  Vmath::Vcopy(m_ncoeffs, inarray, 1, outarray, 1);
408  }
409  else
410  {
411  int nInteriorDofs = m_ncoeffs-2;
412  int offset = 0;
413 
414  switch (m_base[0]->GetBasisType())
415  {
416  case LibUtilities::eGLL_Lagrange:
417  {
418  offset = 1;
419  }
420  break;
421  case LibUtilities::eGauss_Lagrange:
422  {
423  nInteriorDofs = m_ncoeffs;
424  offset = 0;
425  }
426  break;
427  case LibUtilities::eModified_A:
428  case LibUtilities::eModified_B:
429  {
430  ASSERTL1(m_base[0]->GetPointsType() == LibUtilities::eGaussLobattoLegendre ||
431  m_base[0]->GetPointsType() == LibUtilities::ePolyEvenlySpaced,
432  "Cannot use FwdTrans_BndConstrained with these points.");
433  offset = 2;
434  }
435  break;
436  default:
437  ASSERTL0(false,"This type of FwdTrans is not defined"
438  "for this expansion type");
439  }
440 
441  fill(outarray.get(), outarray.get()+m_ncoeffs, 0.0 );
442 
443  if (m_base[0]->GetBasisType() != LibUtilities::eGauss_Lagrange)
444  {
445 
446  outarray[GetVertexMap(0)] = inarray[0];
447  outarray[GetVertexMap(1)] =
448  inarray[m_base[0]->GetNumPoints()-1];
449 
450  if (m_ncoeffs>2)
451  {
452  // ideally, we would like to have tmp0 to be replaced
453  // by outarray (currently MassMatrixOp does not allow
454  // aliasing)
455  Array<OneD, NekDouble> tmp0(m_ncoeffs);
456  Array<OneD, NekDouble> tmp1(m_ncoeffs);
457 
458  StdRegions::StdMatrixKey stdmasskey(
459  StdRegions::eMass,DetShapeType(),*this);
460  MassMatrixOp(outarray,tmp0,stdmasskey);
461  v_IProductWRTBase(inarray,tmp1);
462 
463  Vmath::Vsub(m_ncoeffs, tmp1, 1, tmp0, 1, tmp1, 1);
464 
465  // get Mass matrix inverse (only of interior DOF)
466  MatrixKey masskey(
467  StdRegions::eMass, DetShapeType(),*this);
468  DNekScalMatSharedPtr matsys =
469  (m_staticCondMatrixManager[masskey])->GetBlock(1,1);
470 
471  Blas::Dgemv('N',nInteriorDofs,nInteriorDofs,
472  matsys->Scale(),
473  &((matsys->GetOwnedMatrix())->GetPtr())[0],
474  nInteriorDofs,tmp1.get()+offset,1,0.0,
475  outarray.get()+offset,1);
476  }
477  }
478  else
479  {
480  SegExp::v_FwdTrans(inarray, outarray);
481 
482  }
483  }
484  }
Nektar::LocalRegions::SegExp::v_FwdTrans
virtual void v_FwdTrans(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) override
Forward transform from physical quadrature space stored in inarray and evaluate the expansion coeffic...
Definition: SegExp.cpp:377
Nektar::StdRegions::StdExpansion::MassMatrixOp
void MassMatrixOp(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
Definition: StdExpansion.h:762
Nektar::StdRegions::StdExpansion::GetVertexMap
int GetVertexMap(const int localVertexId, bool useCoeffPacking=false)
Definition: StdExpansion.h:697
Blas::Dgemv
static void Dgemv(const char &trans, const int &m, const int &n, const double &alpha, const double *a, const int &lda, const double *x, const int &incx, const double &beta, double *y, const int &incy)
BLAS level 2: Matrix vector multiply y = A x where A[m x n].
Definition: Blas.hpp:265
Nektar::LibUtilities::ePolyEvenlySpaced
@ ePolyEvenlySpaced
1D Evenly-spaced points using Lagrange polynomial
Definition: PointsType.h:64
Nektar::LibUtilities::eModified_B
@ eModified_B
Principle Modified Functions .
Definition: BasisType.h:49
Vmath::Vsub
void Vsub(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Subtract vector z = x-y.
Definition: Vmath.cpp:372

References ASSERTL0, ASSERTL1, Nektar::StdRegions::StdExpansion::DetShapeType(), Blas::Dgemv(), Nektar::LibUtilities::eGauss_Lagrange, Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eGLL_Lagrange, Nektar::StdRegions::eMass, Nektar::LibUtilities::eModified_A, Nektar::LibUtilities::eModified_B, Nektar::LibUtilities::ePolyEvenlySpaced, Nektar::StdRegions::StdExpansion::GetBasisType(), Nektar::StdRegions::StdExpansion::GetPointsType(), Nektar::StdRegions::StdExpansion::GetVertexMap(), Nektar::StdRegions::StdExpansion::m_base, Nektar::StdRegions::StdExpansion::m_ncoeffs, m_staticCondMatrixManager, Nektar::StdRegions::StdExpansion::MassMatrixOp(), v_FwdTrans(), v_IProductWRTBase(), Vmath::Vcopy(), and Vmath::Vsub().

◆ v_GenMatrix()

DNekMatSharedPtr Nektar::LocalRegions::SegExp::v_GenMatrix ( const StdRegions::StdMatrixKey &  mkey)
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdSegExp.

Definition at line 1479 of file SegExp.cpp.

1481  {
1482  DNekMatSharedPtr returnval;
1483 
1484  switch (mkey.GetMatrixType())
1485  {
1486  case StdRegions::eHybridDGHelmholtz:
1487  case StdRegions::eHybridDGLamToU:
1488  case StdRegions::eHybridDGLamToQ0:
1489  case StdRegions::eHybridDGLamToQ1:
1490  case StdRegions::eHybridDGLamToQ2:
1491  case StdRegions::eHybridDGHelmBndLam:
1492  returnval = Expansion1D::v_GenMatrix(mkey);
1493  break;
1494  default:
1495  returnval = StdSegExp::v_GenMatrix(mkey);
1496  break;
1497  }
1498 
1499  return returnval;
1500  }
Nektar::LocalRegions::Expansion1D::v_GenMatrix
virtual DNekMatSharedPtr v_GenMatrix(const StdRegions::StdMatrixKey &mkey)
Definition: Expansion1D.cpp:56

References Nektar::StdRegions::eHybridDGHelmBndLam, Nektar::StdRegions::eHybridDGHelmholtz, Nektar::StdRegions::eHybridDGLamToQ0, Nektar::StdRegions::eHybridDGLamToQ1, Nektar::StdRegions::eHybridDGLamToQ2, Nektar::StdRegions::eHybridDGLamToU, Nektar::StdRegions::StdMatrixKey::GetMatrixType(), and Nektar::LocalRegions::Expansion1D::v_GenMatrix().

◆ v_GetBasis()

const LibUtilities::BasisSharedPtr & Nektar::LocalRegions::SegExp::v_GetBasis ( int  dir) const
protectedvirtual

Definition at line 872 of file SegExp.cpp.

873  {
874  return GetBasis(dir);
875  }
Nektar::StdRegions::StdExpansion::GetBasis
const LibUtilities::BasisSharedPtr & GetBasis(int dir) const
This function gets the shared point to basis in the dir direction.
Definition: StdExpansion.h:111

References Nektar::StdRegions::StdExpansion::GetBasis().

◆ v_GetCoord()

void Nektar::LocalRegions::SegExp::v_GetCoord ( const Array< OneD, const NekDouble > &  Lcoords,
Array< OneD, NekDouble > &  coords 
)
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 681 of file SegExp.cpp.

684  {
685  int i;
686 
687  ASSERTL1(Lcoords[0] >= -1.0&& Lcoords[0] <= 1.0,
688  "Local coordinates are not in region [-1,1]");
689 
690  m_geom->FillGeom();
691  for(i = 0; i < m_geom->GetCoordim(); ++i)
692  {
693  coords[i] = m_geom->GetCoord(i,Lcoords);
694  }
695  }

References ASSERTL1, and Nektar::LocalRegions::Expansion::m_geom.

◆ v_GetCoordim()

int Nektar::LocalRegions::SegExp::v_GetCoordim ( void  )
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion1D.

Definition at line 846 of file SegExp.cpp.

847  {
848  return m_geom->GetCoordim();
849  }

References Nektar::LocalRegions::Expansion::m_geom.

◆ v_GetCoords()

void Nektar::LocalRegions::SegExp::v_GetCoords ( Array< OneD, NekDouble > &  coords_1,
Array< OneD, NekDouble > &  coords_2,
Array< OneD, NekDouble > &  coords_3 
)
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdSegExp.

Definition at line 697 of file SegExp.cpp.

701  {
702  Expansion::v_GetCoords(coords_0, coords_1, coords_2);
703  }
Nektar::LocalRegions::Expansion::v_GetCoords
virtual void v_GetCoords(Array< OneD, NekDouble > &coords_1, Array< OneD, NekDouble > &coords_2, Array< OneD, NekDouble > &coords_3)
Definition: Expansion.cpp:318

References Nektar::LocalRegions::Expansion::v_GetCoords().

◆ v_GetLinStdExp()

StdRegions::StdExpansionSharedPtr Nektar::LocalRegions::SegExp::v_GetLinStdExp ( void  ) const
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 837 of file SegExp.cpp.

838  {
839  LibUtilities::BasisKey bkey0(m_base[0]->GetBasisType(),
840  2, m_base[0]->GetPointsKey());
841 
842  return MemoryManager<StdRegions::StdSegExp>
843  ::AllocateSharedPtr( bkey0);
844  }

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::StdRegions::StdExpansion::GetBasisType(), and Nektar::StdRegions::StdExpansion::m_base.

◆ v_GetLocMatrix()

DNekScalMatSharedPtr Nektar::LocalRegions::SegExp::v_GetLocMatrix ( const MatrixKey &  mkey)
overrideprotectedvirtual

Reimplemented from Nektar::LocalRegions::Expansion.

Definition at line 1252 of file SegExp.cpp.

1253  {
1254  return m_matrixManager[mkey];
1255  }

References m_matrixManager.

◆ v_GetLocStaticCondMatrix()

DNekScalBlkMatSharedPtr Nektar::LocalRegions::SegExp::v_GetLocStaticCondMatrix ( const MatrixKey &  mkey)
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 1241 of file SegExp.cpp.

1243  {
1244  return m_staticCondMatrixManager[mkey];
1245  }

References m_staticCondMatrixManager.

◆ v_GetNcoeffs()

int Nektar::LocalRegions::SegExp::v_GetNcoeffs ( void  ) const
protectedvirtual

Definition at line 867 of file SegExp.cpp.

868  {
869  return m_ncoeffs;
870  }

References Nektar::StdRegions::StdExpansion::m_ncoeffs.

◆ v_GetNumPoints()

int Nektar::LocalRegions::SegExp::v_GetNumPoints ( const int  dir) const
protectedvirtual

Definition at line 862 of file SegExp.cpp.

863  {
864  return GetNumPoints(dir);
865  }
Nektar::StdRegions::StdExpansion::GetNumPoints
int GetNumPoints(const int dir) const
This function returns the number of quadrature points in the dir direction.
Definition: StdExpansion.h:221

References Nektar::StdRegions::StdExpansion::GetNumPoints().

◆ v_GetPhysNormals()

const Array< OneD, const NekDouble > & Nektar::LocalRegions::SegExp::v_GetPhysNormals ( void  )
overrideprotectedvirtual

Reimplemented from Nektar::LocalRegions::Expansion.

Definition at line 851 of file SegExp.cpp.

852  {
853  NEKERROR(ErrorUtil::efatal, "Got to SegExp");
854  return NullNekDouble1DArray;
855  }
Nektar::NullNekDouble1DArray
static Array< OneD, NekDouble > NullNekDouble1DArray
Definition: SharedArray.hpp:820

References Nektar::ErrorUtil::efatal, NEKERROR, and Nektar::NullNekDouble1DArray.

◆ v_GetStdExp()

StdRegions::StdExpansionSharedPtr Nektar::LocalRegions::SegExp::v_GetStdExp ( void  ) const
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 831 of file SegExp.cpp.

832  {
833  return MemoryManager<StdRegions::StdSegExp>
834  ::AllocateSharedPtr(m_base[0]->GetBasisKey());
835  }

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), and Nektar::StdRegions::StdExpansion::m_base.

◆ v_GetTracePhysMap()

void Nektar::LocalRegions::SegExp::v_GetTracePhysMap ( const int  vertex,
Array< OneD, int > &  map 
)
overrideprotectedvirtual

Reimplemented from Nektar::LocalRegions::Expansion.

Definition at line 793 of file SegExp.cpp.

796  {
797  int nquad = m_base[0]->GetNumPoints();
798 
799  ASSERTL1(vertex == 0 || vertex == 1,
800  "Vertex value should be 0 or 1");
801 
802  map = Array<OneD, int>(1);
803 
804  map[0] = vertex == 0 ? 0: nquad - 1;
805  }

References ASSERTL1, and Nektar::StdRegions::StdExpansion::m_base.

◆ v_GetTracePhysVals()

void Nektar::LocalRegions::SegExp::v_GetTracePhysVals ( const int  edge,
const StdRegions::StdExpansionSharedPtr &  EdgeExp,
const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray,
StdRegions::Orientation  orient 
)
overrideprotectedvirtual

Reimplemented from Nektar::LocalRegions::Expansion.

Definition at line 778 of file SegExp.cpp.

784  {
785  boost::ignore_unused(EdgeExp, orient);
786 
787  NekDouble result;
788  v_GetVertexPhysVals(edge, inarray, result);
789  outarray[0] = result;
790  }
Nektar::LocalRegions::SegExp::v_GetVertexPhysVals
virtual void v_GetVertexPhysVals(const int vertex, const Array< OneD, const NekDouble > &inarray, NekDouble &outarray) override
Definition: SegExp.cpp:706

References v_GetVertexPhysVals().

◆ v_GetVertexPhysVals()

void Nektar::LocalRegions::SegExp::v_GetVertexPhysVals ( const int  vertex,
const Array< OneD, const NekDouble > &  inarray,
NekDouble &  outarray 
)
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 706 of file SegExp.cpp.

710  {
711  int nquad = m_base[0]->GetNumPoints();
712 
713  if (m_base[0]->GetPointsType() != LibUtilities::eGaussGaussLegendre)
714  {
715  switch (vertex)
716  {
717  case 0:
718  outarray = inarray[0];
719  break;
720  case 1:
721  outarray = inarray[nquad - 1];
722  break;
723  }
724  }
725  else
726  {
727  StdRegions::ConstFactorMap factors;
728  factors[StdRegions::eFactorGaussVertex] = vertex;
729 
730  StdRegions::StdMatrixKey key(
731  StdRegions::eInterpGauss,
732  DetShapeType(),*this,factors);
733 
734  DNekScalMatSharedPtr mat_gauss = m_matrixManager[key];
735 
736  outarray = Blas::Ddot(nquad, mat_gauss->GetOwnedMatrix()
737  ->GetPtr().get(), 1, &inarray[0], 1);
738  }
739  }
Blas::Ddot
static double Ddot(const int &n, const double *x, const int &incx, const double *y, const int &incy)
BLAS level 1: output = .
Definition: Blas.hpp:197

References Blas::Ddot(), Nektar::StdRegions::StdExpansion::DetShapeType(), Nektar::StdRegions::eFactorGaussVertex, Nektar::LibUtilities::eGaussGaussLegendre, Nektar::StdRegions::eInterpGauss, Nektar::StdRegions::StdExpansion::GetPointsType(), Nektar::StdRegions::StdExpansion::m_base, and m_matrixManager.

Referenced by v_GetTracePhysVals().

◆ v_HelmholtzMatrixOp()

void Nektar::LocalRegions::SegExp::v_HelmholtzMatrixOp ( const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray,
const StdRegions::StdMatrixKey &  mkey 
)
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdSegExp.

Definition at line 1126 of file SegExp.cpp.

1130  {
1131  int nquad = m_base[0]->GetNumPoints();
1132  const Array<TwoD, const NekDouble>& gmat =
1133  m_metricinfo->GetDerivFactors(GetPointsKeys());
1134  const NekDouble lambda =
1135  mkey.GetConstFactor(StdRegions::eFactorLambda);
1136 
1137  Array<OneD,NekDouble> physValues(nquad);
1138  Array<OneD,NekDouble> dPhysValuesdx(nquad);
1139  Array<OneD,NekDouble> wsp(m_ncoeffs);
1140 
1141  BwdTrans(inarray, physValues);
1142 
1143  // mass matrix operation
1144  v_IProductWRTBase((m_base[0]->GetBdata()),physValues,wsp,1);
1145 
1146  // Laplacian matrix operation
1147  switch (m_geom->GetCoordim())
1148  {
1149  case 1:
1150  {
1151  PhysDeriv(physValues,dPhysValuesdx);
1152 
1153  // multiply with the proper geometric factors
1154  if (m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
1155  {
1156  Vmath::Vmul(nquad,
1157  &gmat[0][0],1,dPhysValuesdx.get(),1,
1158  dPhysValuesdx.get(),1);
1159  }
1160  else
1161  {
1162  Blas::Dscal(nquad, gmat[0][0], dPhysValuesdx.get(), 1);
1163  }
1164  }
1165  break;
1166  case 2:
1167  {
1168  Array<OneD,NekDouble> dPhysValuesdy(nquad);
1169 
1170  PhysDeriv(physValues, dPhysValuesdx, dPhysValuesdy);
1171 
1172  // multiply with the proper geometric factors
1173  if (m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
1174  {
1175  Vmath::Vmul (nquad,
1176  &gmat[0][0], 1, dPhysValuesdx.get(), 1,
1177  dPhysValuesdx.get(), 1);
1178  Vmath::Vvtvp(nquad,
1179  &gmat[1][0], 1, dPhysValuesdy.get(), 1,
1180  dPhysValuesdx.get(), 1,
1181  dPhysValuesdx.get(), 1);
1182  }
1183  else
1184  {
1185  Blas::Dscal(nquad, gmat[0][0], dPhysValuesdx.get(), 1);
1186  Blas::Daxpy(nquad,
1187  gmat[1][0], dPhysValuesdy.get(), 1,
1188  dPhysValuesdx.get(), 1);
1189  }
1190  }
1191  break;
1192  case 3:
1193  {
1194  Array<OneD,NekDouble> dPhysValuesdy(nquad);
1195  Array<OneD,NekDouble> dPhysValuesdz(nquad);
1196 
1197  PhysDeriv(physValues, dPhysValuesdx,
1198  dPhysValuesdy, dPhysValuesdz);
1199 
1200  // multiply with the proper geometric factors
1201  if (m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
1202  {
1203  Vmath::Vmul (nquad,
1204  &gmat[0][0], 1, dPhysValuesdx.get(), 1,
1205  dPhysValuesdx.get(), 1);
1206  Vmath::Vvtvp(nquad,
1207  &gmat[1][0], 1, dPhysValuesdy.get(), 1,
1208  dPhysValuesdx.get(), 1,
1209  dPhysValuesdx.get(), 1);
1210  Vmath::Vvtvp(nquad,
1211  &gmat[2][0], 1, dPhysValuesdz.get(), 1,
1212  dPhysValuesdx.get(), 1,
1213  dPhysValuesdx.get(), 1);
1214  }
1215  else
1216  {
1217  Blas::Dscal(nquad, gmat[0][0], dPhysValuesdx.get(), 1);
1218  Blas::Daxpy(nquad,
1219  gmat[1][0], dPhysValuesdy.get(), 1,
1220  dPhysValuesdx.get(), 1);
1221  Blas::Daxpy(nquad,
1222  gmat[2][0], dPhysValuesdz.get(),
1223  1, dPhysValuesdx.get(), 1);
1224  }
1225  }
1226  break;
1227  default:
1228  ASSERTL0(false,"Wrong number of dimensions");
1229  break;
1230  }
1231 
1232  v_IProductWRTBase(m_base[0]->GetDbdata(),dPhysValuesdx,outarray,1);
1233  Blas::Daxpy(m_ncoeffs, lambda, wsp.get(), 1, outarray.get(), 1);
1234  }
Nektar::StdRegions::StdExpansion::BwdTrans
void BwdTrans(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
This function performs the Backward transformation from coefficient space to physical space.
Definition: StdExpansion.h:433
Nektar::StdRegions::StdExpansion::PhysDeriv
void PhysDeriv(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_d0, Array< OneD, NekDouble > &out_d1=NullNekDouble1DArray, Array< OneD, NekDouble > &out_d2=NullNekDouble1DArray)
Definition: StdExpansion.h:855
Blas::Dscal
static void Dscal(const int &n, const double &alpha, double *x, const int &incx)
BLAS level 1: x = alpha x.
Definition: Blas.hpp:182
Blas::Daxpy
static void Daxpy(const int &n, const double &alpha, const double *x, const int &incx, const double *y, const int &incy)
BLAS level 1: y = alpha x plus y.
Definition: Blas.hpp:167
Vmath::Vmul
void Vmul(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Multiply vector z = x*y.
Definition: Vmath.cpp:192
Vmath::Vvtvp
void Vvtvp(int n, const T *w, const int incw, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
vvtvp (vector times vector plus vector): z = w*x + y
Definition: Vmath.cpp:513

References ASSERTL0, Nektar::StdRegions::StdExpansion::BwdTrans(), Blas::Daxpy(), Blas::Dscal(), Nektar::SpatialDomains::eDeformed, Nektar::StdRegions::eFactorLambda, Nektar::StdRegions::StdMatrixKey::GetConstFactor(), Nektar::StdRegions::StdExpansion::GetPointsKeys(), Nektar::StdRegions::StdExpansion::m_base, Nektar::LocalRegions::Expansion::m_geom, Nektar::LocalRegions::Expansion::m_metricinfo, Nektar::StdRegions::StdExpansion::m_ncoeffs, Nektar::StdRegions::StdExpansion::PhysDeriv(), v_IProductWRTBase(), Vmath::Vmul(), and Vmath::Vvtvp().

◆ v_Integral()

NekDouble Nektar::LocalRegions::SegExp::v_Integral ( const Array< OneD, const NekDouble > &  inarray)
overrideprotectedvirtual

Integrate the physical point list inarray over region and return the value.

Inputs:

  • inarray: definition of function to be returned at quadrature point of expansion.

Outputs:

  • returns \(\int^1_{-1} u(\xi_1)d \xi_1 \) where \(inarray[i] = u(\xi_{1i}) \)

Reimplemented from Nektar::StdRegions::StdSegExp.

Definition at line 118 of file SegExp.cpp.

120  {
121  int nquad0 = m_base[0]->GetNumPoints();
122  Array<OneD, const NekDouble> jac = m_metricinfo->GetJac(GetPointsKeys());
123  NekDouble ival;
124  Array<OneD,NekDouble> tmp(nquad0);
125 
126  // multiply inarray with Jacobian
127  if(m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
128  {
129  Vmath::Vmul(nquad0, jac, 1, inarray, 1, tmp,1);
130  }
131  else
132  {
133  Vmath::Smul(nquad0, jac[0], inarray, 1, tmp, 1);
134  }
135 
136  // call StdSegExp version;
137  ival = StdSegExp::v_Integral(tmp);
138  //ival = StdSegExp::Integral(tmp);
139  return ival;
140  }

References Nektar::SpatialDomains::eDeformed, Nektar::StdRegions::StdExpansion::GetPointsKeys(), Nektar::StdRegions::StdExpansion::m_base, Nektar::LocalRegions::Expansion::m_metricinfo, Vmath::Smul(), and Vmath::Vmul().

◆ v_IProductWRTBase() [1/2]

void Nektar::LocalRegions::SegExp::v_IProductWRTBase ( const Array< OneD, const NekDouble > &  base,
const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray,
int  coll_check 
)
overrideprotectedvirtual

Inner product of inarray over region with respect to expansion basis base and return in outarray.

Calculate \( I[p] = \int^{1}_{-1} \phi_p(\xi_1) u(\xi_1) d\xi_1 = \sum_{i=0}^{nq-1} \phi_p(\xi_{1i}) u(\xi_{1i}) w_i \) where \( outarray[p] = I[p], inarray[i] = u(\xi_{1i}), base[p*nq+i] = \phi_p(\xi_{1i}) \).

Inputs:

  • base: an array definiing the local basis for the inner product usually passed from Basis->get_bdata() or Basis->get_Dbdata()
  • inarray: physical point array of function to be integrated \( u(\xi_1) \)
  • coll_check: Flag to identify when a Basis->collocation() call should be performed to see if this is a GLL_Lagrange basis with a collocation property. (should be set to 0 if taking the inner product with respect to the derivative of basis)

Output:

  • outarray: array of coefficients representing the inner product of function with ever mode in the exapnsion

Reimplemented from Nektar::StdRegions::StdSegExp.

Definition at line 541 of file SegExp.cpp.

546  {
547  int nquad0 = m_base[0]->GetNumPoints();
548  Array<OneD, const NekDouble> jac = m_metricinfo->GetJac(GetPointsKeys());
549  Array<OneD,NekDouble> tmp(nquad0);
550 
551 
552  // multiply inarray with Jacobian
553  if(m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
554  {
555  Vmath::Vmul(nquad0, jac, 1, inarray, 1, tmp, 1);
556  }
557  else
558  {
559  Vmath::Smul(nquad0, jac[0], inarray, 1, tmp, 1);
560  }
561  StdSegExp::v_IProductWRTBase(base,tmp,outarray,coll_check);
562  }

References Nektar::SpatialDomains::eDeformed, Nektar::StdRegions::StdExpansion::GetPointsKeys(), Nektar::StdRegions::StdExpansion::m_base, Nektar::LocalRegions::Expansion::m_metricinfo, Vmath::Smul(), and Vmath::Vmul().

◆ v_IProductWRTBase() [2/2]

void Nektar::LocalRegions::SegExp::v_IProductWRTBase ( const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray 
)
overrideprotectedvirtual

Inner product of inarray over region with respect to the expansion basis (this)->_Base[0] and return in outarray.

Wrapper call to SegExp::IProduct_WRT_B

Input:

  • inarray: array of function evaluated at the physical collocation points

Output:

  • outarray: array of inner product with respect to each basis over region

Reimplemented from Nektar::StdRegions::StdSegExp.

Definition at line 506 of file SegExp.cpp.

509  {
510  v_IProductWRTBase(m_base[0]->GetBdata(),inarray,outarray,1);
511  }

References Nektar::StdRegions::StdExpansion::m_base.

Referenced by v_FwdTrans(), v_FwdTrans_BndConstrained(), v_HelmholtzMatrixOp(), v_IProductWRTDerivBase(), v_LaplacianMatrixOp(), and v_NormVectorIProductWRTBase().

◆ v_IProductWRTDerivBase()

void Nektar::LocalRegions::SegExp::v_IProductWRTDerivBase ( const int  dir,
const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray 
)
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdSegExp.

Definition at line 565 of file SegExp.cpp.

569  {
570  int nquad = m_base[0]->GetNumPoints();
571  const Array<TwoD, const NekDouble>& gmat =
572  m_metricinfo->GetDerivFactors(GetPointsKeys());
573 
574  Array<OneD, NekDouble> tmp1(nquad);
575 
576  switch(dir)
577  {
578  case 0:
579  {
580  if(m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
581  {
582  Vmath::Vmul(nquad,gmat[0],1,inarray,1,tmp1,1);
583  }
584  else
585  {
586  Vmath::Smul(nquad, gmat[0][0], inarray, 1, tmp1, 1);
587  }
588  }
589  break;
590  case 1:
591  {
592  if(m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
593  {
594  Vmath::Vmul(nquad,gmat[1],1,inarray,1,tmp1,1);
595  }
596  else
597  {
598  Vmath::Smul(nquad, gmat[1][0], inarray, 1, tmp1, 1);
599  }
600  }
601  break;
602  case 2:
603  {
604  ASSERTL1(m_geom->GetCoordim() == 3,"input dir is out of range");
605  if(m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
606  {
607  Vmath::Vmul(nquad,gmat[2],1,inarray,1,tmp1,1);
608  }
609  else
610  {
611  Vmath::Smul(nquad, gmat[2][0], inarray, 1, tmp1, 1);
612  }
613  }
614  break;
615  default:
616  {
617  ASSERTL1(false,"input dir is out of range");
618  }
619  break;
620  }
621  v_IProductWRTBase(m_base[0]->GetDbdata(),tmp1,outarray,1);
622  }

References ASSERTL1, Nektar::SpatialDomains::eDeformed, Nektar::StdRegions::StdExpansion::GetPointsKeys(), Nektar::StdRegions::StdExpansion::m_base, Nektar::LocalRegions::Expansion::m_geom, Nektar::LocalRegions::Expansion::m_metricinfo, Vmath::Smul(), v_IProductWRTBase(), and Vmath::Vmul().

◆ v_LaplacianMatrixOp()

void Nektar::LocalRegions::SegExp::v_LaplacianMatrixOp ( const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray,
const StdRegions::StdMatrixKey &  mkey 
)
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdSegExp.

Definition at line 1018 of file SegExp.cpp.

1022  {
1023  boost::ignore_unused(mkey);
1024 
1025  int nquad = m_base[0]->GetNumPoints();
1026  const Array<TwoD, const NekDouble>& gmat =
1027  m_metricinfo->GetDerivFactors(GetPointsKeys());
1028 
1029  Array<OneD,NekDouble> physValues(nquad);
1030  Array<OneD,NekDouble> dPhysValuesdx(nquad);
1031 
1032  BwdTrans(inarray,physValues);
1033 
1034  // Laplacian matrix operation
1035  switch (m_geom->GetCoordim())
1036  {
1037  case 1:
1038  {
1039  PhysDeriv(physValues,dPhysValuesdx);
1040 
1041  // multiply with the proper geometric factors
1042  if(m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
1043  {
1044  Vmath::Vmul(nquad,
1045  &gmat[0][0],1,dPhysValuesdx.get(),1,
1046  dPhysValuesdx.get(),1);
1047  }
1048  else
1049  {
1050  Blas::Dscal(nquad,
1051  gmat[0][0], dPhysValuesdx.get(), 1);
1052  }
1053  }
1054  break;
1055  case 2:
1056  {
1057  Array<OneD,NekDouble> dPhysValuesdy(nquad);
1058 
1059  PhysDeriv(physValues,dPhysValuesdx,dPhysValuesdy);
1060 
1061  // multiply with the proper geometric factors
1062  if (m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
1063  {
1064  Vmath::Vmul (nquad,
1065  &gmat[0][0],1,dPhysValuesdx.get(),1,
1066  dPhysValuesdx.get(),1);
1067  Vmath::Vvtvp(nquad,
1068  &gmat[1][0],1,dPhysValuesdy.get(),1,
1069  dPhysValuesdx.get(),1,
1070  dPhysValuesdx.get(),1);
1071  }
1072  else
1073  {
1074  Blas::Dscal(nquad,
1075  gmat[0][0], dPhysValuesdx.get(), 1);
1076  Blas::Daxpy(nquad,
1077  gmat[1][0], dPhysValuesdy.get(), 1,
1078  dPhysValuesdx.get(), 1);
1079  }
1080  }
1081  break;
1082  case 3:
1083  {
1084  Array<OneD,NekDouble> dPhysValuesdy(nquad);
1085  Array<OneD,NekDouble> dPhysValuesdz(nquad);
1086 
1087  PhysDeriv(physValues,dPhysValuesdx,
1088  dPhysValuesdy,dPhysValuesdz);
1089 
1090  // multiply with the proper geometric factors
1091  if(m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
1092  {
1093  Vmath::Vmul (nquad,
1094  &gmat[0][0], 1, dPhysValuesdx.get(), 1,
1095  dPhysValuesdx.get(),1);
1096  Vmath::Vvtvp(nquad,
1097  &gmat[1][0], 1, dPhysValuesdy.get(), 1,
1098  dPhysValuesdx.get(),1,
1099  dPhysValuesdx.get(),1);
1100  Vmath::Vvtvp(nquad,
1101  &gmat[2][0], 1, dPhysValuesdz.get(), 1,
1102  dPhysValuesdx.get(),1,
1103  dPhysValuesdx.get(),1);
1104  }
1105  else
1106  {
1107  Blas::Dscal(nquad, gmat[0][0], dPhysValuesdx.get(), 1);
1108  Blas::Daxpy(nquad,
1109  gmat[1][0], dPhysValuesdy.get(), 1,
1110  dPhysValuesdx.get(), 1);
1111  Blas::Daxpy(nquad,
1112  gmat[2][0], dPhysValuesdz.get(), 1,
1113  dPhysValuesdx.get(), 1);
1114  }
1115  }
1116  break;
1117  default:
1118  ASSERTL0(false,"Wrong number of dimensions");
1119  break;
1120  }
1121 
1122  v_IProductWRTBase(m_base[0]->GetDbdata(),dPhysValuesdx,outarray,1);
1123  }

References ASSERTL0, Nektar::StdRegions::StdExpansion::BwdTrans(), Blas::Daxpy(), Blas::Dscal(), Nektar::SpatialDomains::eDeformed, Nektar::StdRegions::StdExpansion::GetPointsKeys(), Nektar::StdRegions::StdExpansion::m_base, Nektar::LocalRegions::Expansion::m_geom, Nektar::LocalRegions::Expansion::m_metricinfo, Nektar::StdRegions::StdExpansion::PhysDeriv(), v_IProductWRTBase(), Vmath::Vmul(), and Vmath::Vvtvp().

◆ v_MetricInfoType()

SpatialDomains::GeomType Nektar::LocalRegions::SegExp::v_MetricInfoType ( )
protectedvirtual

Definition at line 857 of file SegExp.cpp.

858  {
859  return m_metricinfo->GetGtype();
860  }

References Nektar::LocalRegions::Expansion::m_metricinfo.

◆ v_NormVectorIProductWRTBase() [1/2]

void Nektar::LocalRegions::SegExp::v_NormVectorIProductWRTBase ( const Array< OneD, const Array< OneD, NekDouble > > &  Fvec,
Array< OneD, NekDouble > &  outarray 
)
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 643 of file SegExp.cpp.

646  {
647  NormVectorIProductWRTBase(Fvec[0], Fvec[1], outarray);
648  }
Nektar::StdRegions::StdExpansion::NormVectorIProductWRTBase
void NormVectorIProductWRTBase(const Array< OneD, const NekDouble > &Fx, Array< OneD, NekDouble > &outarray)
Definition: StdExpansion.h:628

References Nektar::StdRegions::StdExpansion::NormVectorIProductWRTBase().

◆ v_NormVectorIProductWRTBase() [2/2]

void Nektar::LocalRegions::SegExp::v_NormVectorIProductWRTBase ( const Array< OneD, const NekDouble > &  Fx,
const Array< OneD, const NekDouble > &  Fy,
Array< OneD, NekDouble > &  outarray 
)
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 624 of file SegExp.cpp.

628  {
629  int nq = m_base[0]->GetNumPoints();
630  Array<OneD, NekDouble > Fn(nq);
631 
632  // @TODO: This routine no longer makes sense as a normal is not unique to an edge
633  const Array<OneD, const Array<OneD, NekDouble> >
634  &normals =
635  GetLeftAdjacentElementExp()->
636  GetTraceNormal(GetLeftAdjacentElementTrace());
637  Vmath::Vmul (nq, &Fx[0], 1, &normals[0][0], 1, &Fn[0], 1);
638  Vmath::Vvtvp(nq, &Fy[0], 1, &normals[1][0], 1, &Fn[0], 1, &Fn[0], 1);
639 
640  v_IProductWRTBase(Fn,outarray);
641  }
Nektar::LocalRegions::Expansion::GetLeftAdjacentElementExp
ExpansionSharedPtr GetLeftAdjacentElementExp() const
Definition: Expansion.h:438
Nektar::LocalRegions::Expansion::GetTraceNormal
const NormalVector & GetTraceNormal(const int id) const
Definition: Expansion.h:222
Nektar::LocalRegions::Expansion::GetLeftAdjacentElementTrace
int GetLeftAdjacentElementTrace() const
Definition: Expansion.h:454

References Nektar::LocalRegions::Expansion::GetLeftAdjacentElementExp(), Nektar::LocalRegions::Expansion::GetLeftAdjacentElementTrace(), Nektar::LocalRegions::Expansion::GetTraceNormal(), Nektar::StdRegions::StdExpansion::m_base, v_IProductWRTBase(), Vmath::Vmul(), and Vmath::Vvtvp().

◆ v_NumBndryCoeffs()

int Nektar::LocalRegions::SegExp::v_NumBndryCoeffs ( ) const
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdSegExp.

Definition at line 878 of file SegExp.cpp.

879  {
880  return 2;
881  }

◆ v_NumDGBndryCoeffs()

int Nektar::LocalRegions::SegExp::v_NumDGBndryCoeffs ( ) const
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdSegExp.

Definition at line 884 of file SegExp.cpp.

885  {
886  return 2;
887  }

◆ v_PhysDeriv() [1/2]

void Nektar::LocalRegions::SegExp::v_PhysDeriv ( const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  out_d0,
Array< OneD, NekDouble > &  out_d1 = NullNekDouble1DArray,
Array< OneD, NekDouble > &  out_d2 = NullNekDouble1DArray 
)
overrideprotectedvirtual

Evaluate the derivative \( d/d{\xi_1} \) at the physical quadrature points given by inarray and return in outarray.

This is a wrapper around StdExpansion1D::Tensor_Deriv

Input:

  • n: number of derivatives to be evaluated where \( n \leq dim\)
  • inarray: array of function evaluated at the quadrature points

Output:

  • outarray: array of the derivatives \( du/d_{\xi_1}|_{\xi_{1i}} d\xi_1/dx, du/d_{\xi_1}|_{\xi_{1i}} d\xi_1/dy, du/d_{\xi_1}|_{\xi_{1i}} d\xi_1/dz, \) depending on value of dim

Reimplemented from Nektar::StdRegions::StdSegExp.

Definition at line 166 of file SegExp.cpp.

171  {
172  int nquad0 = m_base[0]->GetNumPoints();
173  Array<TwoD, const NekDouble> gmat =
174  m_metricinfo->GetDerivFactors(GetPointsKeys());
175  Array<OneD,NekDouble> diff(nquad0);
176 
177  //StdExpansion1D::PhysTensorDeriv(inarray,diff);
178  PhysTensorDeriv(inarray,diff);
179  if(m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
180  {
181  if(out_d0.size())
182  {
183  Vmath::Vmul(nquad0,&gmat[0][0],1,&diff[0],1,
184  &out_d0[0],1);
185  }
186 
187  if(out_d1.size())
188  {
189  Vmath::Vmul(nquad0,&gmat[1][0],1,&diff[0],1,
190  &out_d1[0],1);
191  }
192 
193  if(out_d2.size())
194  {
195  Vmath::Vmul(nquad0,&gmat[2][0],1,&diff[0],1,
196  &out_d2[0],1);
197  }
198  }
199  else
200  {
201  if(out_d0.size())
202  {
203  Vmath::Smul(nquad0, gmat[0][0], diff, 1,
204  out_d0, 1);
205  }
206 
207  if(out_d1.size())
208  {
209  Vmath::Smul(nquad0, gmat[1][0], diff, 1,
210  out_d1, 1);
211  }
212 
213  if(out_d2.size())
214  {
215  Vmath::Smul(nquad0, gmat[2][0], diff, 1,
216  out_d2, 1);
217  }
218  }
219  }
Nektar::StdRegions::StdExpansion1D::PhysTensorDeriv
void PhysTensorDeriv(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
Evaluate the derivative at the physical quadrature points given by inarray and return in outarray.
Definition: StdExpansion1D.cpp:66

References Nektar::SpatialDomains::eDeformed, Nektar::StdRegions::StdExpansion::GetPointsKeys(), Nektar::StdRegions::StdExpansion::m_base, Nektar::LocalRegions::Expansion::m_metricinfo, Nektar::StdRegions::StdExpansion1D::PhysTensorDeriv(), Vmath::Smul(), and Vmath::Vmul().

Referenced by v_PhysDeriv_n().

◆ v_PhysDeriv() [2/2]

void Nektar::LocalRegions::SegExp::v_PhysDeriv ( const int  dir,
const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  out_d0 
)
overrideprotectedvirtual

Calculate the derivative of the physical points in a given direction.

See also
StdRegions::StdExpansion::PhysDeriv

Reimplemented from Nektar::StdRegions::StdSegExp.

Definition at line 319 of file SegExp.cpp.

322  {
323  switch(dir)
324  {
325  case 0:
326  {
327  PhysDeriv(inarray, outarray, NullNekDouble1DArray,
328  NullNekDouble1DArray);
329  }
330  break;
331  case 1:
332  {
333  PhysDeriv(inarray, NullNekDouble1DArray, outarray,
334  NullNekDouble1DArray);
335  }
336  break;
337  case 2:
338  {
339  PhysDeriv(inarray, NullNekDouble1DArray,
340  NullNekDouble1DArray, outarray);
341  }
342  break;
343  default:
344  {
345  ASSERTL1(false,"input dir is out of range");
346  }
347  break;
348  }
349  }

References ASSERTL1, Nektar::NullNekDouble1DArray, and Nektar::StdRegions::StdExpansion::PhysDeriv().

◆ v_PhysDeriv_n()

void Nektar::LocalRegions::SegExp::v_PhysDeriv_n ( const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  out_dn 
)
overrideprotectedvirtual

Evaluate the derivative normal to a line: \( d/dn=\frac{spacedim}{||normal||}d/d{\xi} \). The derivative is calculated performing the product \( du/d{s}=\nabla u \cdot normal \).

Parameters
inarrayfunction to derive
out_dnresult of the derivative operation

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 269 of file SegExp.cpp.

272  {
273  int nquad0 = m_base[0]->GetNumPoints();
274  Array<TwoD, const NekDouble> gmat =
275  m_metricinfo->GetDerivFactors(GetPointsKeys());
276  int coordim = m_geom->GetCoordim();
277  Array<OneD, NekDouble> out_dn_tmp(nquad0,0.0);
278  switch(coordim)
279  {
280  case 2:
281 
282  Array<OneD, NekDouble> inarray_d0(nquad0);
283  Array<OneD, NekDouble> inarray_d1(nquad0);
284 
285  v_PhysDeriv(inarray,inarray_d0,inarray_d1);
286  Array<OneD, Array<OneD, NekDouble> > normals;
287  normals = Array<OneD, Array<OneD, NekDouble> >(coordim);
288  cout<<"der_n"<<endl;
289  for(int k=0; k<coordim; ++k)
290  {
291  normals[k]= Array<OneD, NekDouble>(nquad0);
292  }
293 // @TODO: this routine no longer makes sense, since normals are not unique on
294 // an edge
295 // normals = GetMetricInfo()->GetNormal();
296  for(int i=0; i<nquad0; i++)
297  {
298 cout<<"nx= "<<normals[0][i]<<" ny="<<normals[1][i]<<endl;
299  }
300  ASSERTL0(normals!=NullNekDoubleArrayOfArray,
301  "normal vectors do not exist: check if a"
302  "boundary region is defined as I ");
303  // \nabla u \cdot normal
304  Vmath::Vmul(nquad0,normals[0],1,inarray_d0,1,out_dn_tmp,1);
305  Vmath::Vadd(nquad0,out_dn_tmp,1,out_dn,1,out_dn,1);
306  Vmath::Zero(nquad0,out_dn_tmp,1);
307  Vmath::Vmul(nquad0,normals[1],1,inarray_d1,1,out_dn_tmp,1);
308  Vmath::Vadd(nquad0,out_dn_tmp,1,out_dn,1,out_dn,1);
309 
310  for(int i=0; i<nquad0; i++)
311  {
312 cout<<"deps/dx ="<<inarray_d0[i]<<" deps/dy="<<inarray_d1[i]<<endl;
313  }
314 
315 
316  }
317 
318  }
Nektar::LocalRegions::SegExp::v_PhysDeriv
virtual void v_PhysDeriv(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_d0, Array< OneD, NekDouble > &out_d1=NullNekDouble1DArray, Array< OneD, NekDouble > &out_d2=NullNekDouble1DArray) override
Evaluate the derivative at the physical quadrature points given by inarray and return in outarray.
Definition: SegExp.cpp:166
Nektar::NullNekDoubleArrayOfArray
static Array< OneD, Array< OneD, NekDouble > > NullNekDoubleArrayOfArray
Definition: SharedArray.hpp:821
Vmath::Vadd
void Vadd(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Add vector z = x+y.
Definition: Vmath.cpp:322

References ASSERTL0, Nektar::StdRegions::StdExpansion::GetPointsKeys(), Nektar::StdRegions::StdExpansion::m_base, Nektar::LocalRegions::Expansion::m_geom, Nektar::LocalRegions::Expansion::m_metricinfo, Nektar::NullNekDoubleArrayOfArray, v_PhysDeriv(), Vmath::Vadd(), Vmath::Vmul(), and Vmath::Zero().

◆ v_PhysDeriv_s()

void Nektar::LocalRegions::SegExp::v_PhysDeriv_s ( const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  out_ds 
)
overrideprotectedvirtual

Evaluate the derivative along a line: \( d/ds=\frac{spacedim}{||tangent||}d/d{\xi} \). The derivative is calculated performing the product \( du/d{s}=\nabla u \cdot tangent \).

Parameters
inarrayfunction to derive
out_dsresult of the derivative operation

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 229 of file SegExp.cpp.

232  {
233  int nquad0 = m_base[0]->GetNumPoints();
234  int coordim = m_geom->GetCoordim();
235  Array<OneD, NekDouble> diff (nquad0);
236  //this operation is needed if you put out_ds==inarray
237  Vmath::Zero(nquad0,out_ds,1);
238  switch(coordim)
239  {
240  case 2:
241  //diff= dU/de
242  Array<OneD,NekDouble> diff(nquad0);
243 
244  PhysTensorDeriv(inarray,diff);
245 
246  //get dS/de= (Jac)^-1
247  Array<OneD, NekDouble> Jac = m_metricinfo->GetJac(GetPointsKeys());
248  if(m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
249  {
250  //calculate the derivative as (dU/de)*(Jac)^-1
251  Vmath::Vdiv(nquad0,diff,1,Jac ,1,out_ds,1);
252  }
253  else
254  {
255  NekDouble invJac = 1/Jac[0];
256  Vmath::Smul(nquad0, invJac,diff,1,out_ds,1);
257  }
258  }
259  }
Vmath::Vdiv
void Vdiv(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Multiply vector z = x/y.
Definition: Vmath.cpp:257

References Nektar::SpatialDomains::eDeformed, Nektar::StdRegions::StdExpansion::GetPointsKeys(), Nektar::StdRegions::StdExpansion::m_base, Nektar::LocalRegions::Expansion::m_geom, Nektar::LocalRegions::Expansion::m_metricinfo, Nektar::StdRegions::StdExpansion1D::PhysTensorDeriv(), Vmath::Smul(), Vmath::Vdiv(), and Vmath::Zero().

◆ v_PhysEvaluate()

NekDouble Nektar::LocalRegions::SegExp::v_PhysEvaluate ( const Array< OneD, const NekDouble > &  coord,
const Array< OneD, const NekDouble > &  physvals 
)
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion1D.

Definition at line 668 of file SegExp.cpp.

671  {
672  Array<OneD,NekDouble> Lcoord = Array<OneD,NekDouble>(1);
673 
674  ASSERTL0(m_geom,"m_geom not defined");
675  m_geom->GetLocCoords(coord,Lcoord);
676 
677  return StdSegExp::v_PhysEvaluate(Lcoord, physvals);
678  }

References ASSERTL0, and Nektar::LocalRegions::Expansion::m_geom.

◆ v_SetCoeffsToOrientation()

void Nektar::LocalRegions::SegExp::v_SetCoeffsToOrientation ( StdRegions::Orientation  dir,
Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray 
)
overrideprotectedvirtual

Reimplemented from Nektar::LocalRegions::Expansion.

Definition at line 811 of file SegExp.cpp.

815  {
816 
817  if (dir == StdRegions::eBackwards)
818  {
819  if (&inarray[0] != &outarray[0])
820  {
821  Array<OneD,NekDouble> intmp (inarray);
822  ReverseCoeffsAndSign(intmp,outarray);
823  }
824  else
825  {
826  ReverseCoeffsAndSign(inarray,outarray);
827  }
828  }
829  }
Nektar::LocalRegions::SegExp::ReverseCoeffsAndSign
void ReverseCoeffsAndSign(const Array< OneD, NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
Reverse the coefficients in a boundary interior expansion this routine is of use when we need the seg...
Definition: SegExp.cpp:1650

References Nektar::StdRegions::eBackwards, and ReverseCoeffsAndSign().

◆ v_StdPhysEvaluate()

NekDouble Nektar::LocalRegions::SegExp::v_StdPhysEvaluate ( const Array< OneD, const NekDouble > &  Lcoord,
const Array< OneD, const NekDouble > &  physvals 
)
overrideprotectedvirtual

Given the local cartesian coordinate Lcoord evaluate the value of physvals at this point by calling through to the StdExpansion method

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 660 of file SegExp.cpp.

663  {
664  // Evaluate point in local (eta) coordinates.
665  return StdSegExp::v_PhysEvaluate(Lcoord,physvals);
666  }

Member Data Documentation

◆ m_matrixManager

LibUtilities::NekManager<MatrixKey, DNekScalMat, MatrixKey::opLess> Nektar::LocalRegions::SegExp::m_matrixManager
private

Definition at line 253 of file SegExp.h.

Referenced by CreateMatrix(), MultiplyByElmtInvMass(), v_AddVertexPhysVals(), v_FwdTrans(), v_GetLocMatrix(), and v_GetVertexPhysVals().

◆ m_staticCondMatrixManager

LibUtilities::NekManager<MatrixKey, DNekScalBlkMat, MatrixKey::opLess> Nektar::LocalRegions::SegExp::m_staticCondMatrixManager
private

Definition at line 255 of file SegExp.h.

Referenced by v_DropLocStaticCondMatrix(), v_FwdTrans_BndConstrained(), and v_GetLocStaticCondMatrix().

Generated on Wed Nov 24 2021 10:33:35 for Nektar++ by doxygen 1.9.1