#include <Expansion2D.h>
Inheritance diagram for Nektar::LocalRegions::Expansion2D:
Public Member Functions | |
| Expansion2D (SpatialDomains::Geometry2DSharedPtr pGeom) | |
| ~Expansion2D () override=default | |
| DNekScalMatSharedPtr | CreateMatrix (const MatrixKey &mkey) |
| void | SetTraceToGeomOrientation (Array< OneD, ExpansionSharedPtr > &EdgeExp, Array< OneD, NekDouble > &inout) |
| Array< OneD, unsigned int > | GetTraceInverseBoundaryMap (int eid) |
| void | AddNormTraceInt (const int dir, Array< OneD, ExpansionSharedPtr > &EdgeExp, Array< OneD, Array< OneD, NekDouble > > &edgeCoeffs, Array< OneD, NekDouble > &outarray) |
| void | AddNormTraceInt (const int dir, Array< OneD, const NekDouble > &inarray, Array< OneD, ExpansionSharedPtr > &EdgeExp, Array< OneD, NekDouble > &outarray, const StdRegions::VarCoeffMap &varcoeffs) |
| void | AddEdgeBoundaryInt (const int edge, ExpansionSharedPtr &EdgeExp, Array< OneD, NekDouble > &edgePhys, Array< OneD, NekDouble > &outarray, const StdRegions::VarCoeffMap &varcoeffs=StdRegions::NullVarCoeffMap) |
| void | AddHDGHelmholtzEdgeTerms (const NekDouble tau, const int edge, Array< OneD, ExpansionSharedPtr > &EdgeExp, Array< OneD, NekDouble > &edgePhys, const StdRegions::VarCoeffMap &dirForcing, Array< OneD, NekDouble > &outarray) |
| void | AddHDGHelmholtzTraceTerms (const NekDouble tau, const Array< OneD, const NekDouble > &inarray, Array< OneD, ExpansionSharedPtr > &EdgeExp, const StdRegions::VarCoeffMap &dirForcing, Array< OneD, NekDouble > &outarray) |
| SpatialDomains::Geometry2DSharedPtr | GetGeom2D () const |
| void | ReOrientEdgePhysMap (const int nvert, const StdRegions::Orientation orient, const int nq0, Array< OneD, int > &idmap) |
| DNekMatSharedPtr | v_GenMatrix (const StdRegions::StdMatrixKey &mkey) override |
| void | v_GenTraceExp (const int traceid, ExpansionSharedPtr &exp) override |
 Public Member Functions inherited from Nektar::LocalRegions::Expansion | |
| Expansion (SpatialDomains::GeometrySharedPtr pGeom) | |
| Expansion (const Expansion &pSrc) | |
| ~Expansion () override | |
| void | SetTraceExp (const int traceid, ExpansionSharedPtr &f) |
| ExpansionSharedPtr | GetTraceExp (const int traceid) |
| DNekScalMatSharedPtr | GetLocMatrix (const LocalRegions::MatrixKey &mkey) |
| void | DropLocMatrix (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) |
| DNekScalBlkMatSharedPtr | CreateStaticCondMatrix (const MatrixKey &mkey) |
| 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) |
| void | NormalTraceDerivFactors (Array< OneD, Array< OneD, NekDouble > > &factors, Array< OneD, Array< OneD, NekDouble > > &d0factors, Array< OneD, Array< OneD, NekDouble > > &d1factors) |
| 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) |
| 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) |
| void | TraceNormLen (const int traceid, NekDouble &h, NekDouble &p) |
| 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 |
| void | StdDerivBaseOnTraceMat (Array< OneD, DNekMatSharedPtr > &DerivMat) |
| 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 () const |
| std::shared_ptr< StdExpansion > | GetLinStdExp (void) const |
| int | GetShapeDimension () const |
| bool | IsBoundaryInteriorExpansion () const |
| 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 | FwdTransBndConstrained (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 | GetTraceCoeffMap (const unsigned int traceid, Array< OneD, unsigned int > &maparray) |
| void | GetElmtTraceToTraceMap (const unsigned 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 | LinearAdvectionMatrixOp (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, NekDouble > &coord, const Array< OneD, const NekDouble > &inarray, std::array< NekDouble, 3 > &firstOrderDerivs) |
| This function evaluates the first derivative of the expansion at a single (arbitrary) point of the domain. More... | |
| NekDouble | PhysEvaluate (const Array< OneD, NekDouble > &coord, const Array< OneD, const NekDouble > &inarray, std::array< NekDouble, 3 > &firstOrderDerivs, std::array< NekDouble, 6 > &secondOrderDerivs) |
| 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 int | v_CalcNumberOfCoefficients (const std::vector< unsigned int > &nummodes, int &modes_offset) |
| 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, 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) |
| virtual void | v_NormVectorIProductWRTBase (const Array< OneD, const Array< OneD, NekDouble > > &Fvec, Array< OneD, NekDouble > &outarray) |
| virtual DNekScalBlkMatSharedPtr | v_GetLocStaticCondMatrix (const LocalRegions::MatrixKey &mkey) |
| virtual void | v_DropLocStaticCondMatrix (const LocalRegions::MatrixKey &mkey) |
| 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::StdRegions::StdExpansion2D | |
| StdExpansion2D (int numcoeffs, const LibUtilities::BasisKey &Ba, const LibUtilities::BasisKey &Bb) | |
| StdExpansion2D ()=default | |
| StdExpansion2D (const StdExpansion2D &T)=default | |
| ~StdExpansion2D () override=default | |
| void | PhysTensorDeriv (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray_d0, Array< OneD, NekDouble > &outarray_d1) |
| Calculate the 2D derivative in the local tensor/collapsed coordinate at the physical points. More... | |
| NekDouble | Integral (const Array< OneD, const NekDouble > &inarray, const Array< OneD, const NekDouble > &w0, const Array< OneD, const NekDouble > &w1) |
| NekDouble | BaryTensorDeriv (const Array< OneD, NekDouble > &coord, const Array< OneD, const NekDouble > &inarray, std::array< NekDouble, 3 > &firstOrderDerivs) |
| void | BwdTrans_SumFacKernel (const Array< OneD, const NekDouble > &base0, const Array< OneD, const NekDouble > &base1, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, Array< OneD, NekDouble > &wsp, bool doCheckCollDir0=true, bool doCheckCollDir1=true) |
| void | IProductWRTBase_SumFacKernel (const Array< OneD, const NekDouble > &base0, const Array< OneD, const NekDouble > &base1, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, Array< OneD, NekDouble > &wsp, bool doCheckCollDir0=true, bool doCheckCollDir1=true) |
Protected Member Functions | |
| void | v_DGDeriv (const int dir, const Array< OneD, const NekDouble > &incoeffs, Array< OneD, ExpansionSharedPtr > &EdgeExp, Array< OneD, Array< OneD, NekDouble > > &edgeCoeffs, Array< OneD, NekDouble > &out_d) override |
| void | v_AddEdgeNormBoundaryInt (const int edge, const ExpansionSharedPtr &EdgeExp, const Array< OneD, const NekDouble > &Fx, const Array< OneD, const NekDouble > &Fy, Array< OneD, NekDouble > &outarray) override |
| void | v_AddEdgeNormBoundaryInt (const int edge, const ExpansionSharedPtr &EdgeExp, const Array< OneD, const NekDouble > &Fn, Array< OneD, NekDouble > &outarray) override |
| void | v_AddRobinMassMatrix (const int edgeid, const Array< OneD, const NekDouble > &primCoeffs, DNekMatSharedPtr &inoutmat) override |
| void | v_AddRobinTraceContribution (const int traceid, const Array< OneD, const NekDouble > &primCoeffs, const Array< OneD, NekDouble > &incoeffs, Array< OneD, NekDouble > &coeffs) override |
| DNekMatSharedPtr | v_BuildVertexMatrix (const DNekScalMatSharedPtr &r_bnd) override |
| void | v_ReOrientTracePhysMap (const StdRegions::Orientation orient, Array< OneD, int > &idmap, const int nq0, const int nq1) override |
| void | v_SetUpPhysNormals (const int edge) override |
| NekDouble | v_VectorFlux (const Array< OneD, Array< OneD, NekDouble > > &vec) override |
| void | v_TraceNormLen (const int traceid, NekDouble &h, NekDouble &p) override |
| 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) |
| Array< OneD, NekDouble > | GetMF (const int dir, const int shapedim, const StdRegions::VarCoeffMap &varcoeffs) |
| Array< OneD, NekDouble > | GetMFDiv (const int dir, const StdRegions::VarCoeffMap &varcoeffs) |
| Array< OneD, NekDouble > | GetMFMag (const int dir, const StdRegions::VarCoeffMap &varcoeffs) |
| void | v_MultiplyByQuadratureMetric (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) override |
| virtual void | v_DivideByQuadratureMetric (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) |
| virtual void | v_ComputeLaplacianMetric () |
| int | v_GetCoordim () const override |
| void | v_GetCoords (Array< OneD, NekDouble > &coords_1, Array< OneD, NekDouble > &coords_2, Array< OneD, NekDouble > &coords_3) override |
| virtual DNekScalMatSharedPtr | v_GetLocMatrix (const LocalRegions::MatrixKey &mkey) |
| virtual void | v_DropLocMatrix (const LocalRegions::MatrixKey &mkey) |
| virtual DNekMatSharedPtr | v_BuildTransformationMatrix (const DNekScalMatSharedPtr &r_bnd, const StdRegions::MatrixType matrixType) |
| virtual DNekMatSharedPtr | v_BuildVertexMatrix (const DNekScalMatSharedPtr &r_bnd) |
| virtual void | v_ExtractDataToCoeffs (const NekDouble *data, const std::vector< unsigned int > &nummodes, const int nmodes_offset, NekDouble *coeffs, std::vector< LibUtilities::BasisType > &fromType) |
| 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 NekDouble | v_VectorFlux (const Array< OneD, Array< OneD, NekDouble > > &vec) |
| virtual void | v_NormalTraceDerivFactors (Array< OneD, Array< OneD, NekDouble > > &factors, Array< OneD, Array< OneD, NekDouble > > &d0factors, Array< OneD, Array< OneD, NekDouble > > &d1factors) |
| 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) |
| void | v_SetCoeffsToOrientation (StdRegions::Orientation dir, Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) override |
| virtual void | v_GetTraceQFactors (const int trace, Array< OneD, NekDouble > &outarray) |
| virtual void | v_GetTracePhysVals (const int trace, const StdRegions::StdExpansionSharedPtr &TraceExp, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, StdRegions::Orientation orient) |
| virtual void | v_GetTracePhysMap (const int edge, Array< OneD, int > &outarray) |
| virtual void | v_ReOrientTracePhysMap (const StdRegions::Orientation orient, Array< OneD, int > &idmap, const int nq0, const int nq1=-1) |
| virtual void | v_ComputeTraceNormal (const int id) |
| virtual const Array< OneD, const NekDouble > & | v_GetPhysNormals () |
| virtual void | v_SetPhysNormals (Array< OneD, const NekDouble > &normal) |
| virtual void | v_SetUpPhysNormals (const int id) |
| virtual void | v_AddRobinMassMatrix (const int face, const Array< OneD, const NekDouble > &primCoeffs, DNekMatSharedPtr &inoutmat) |
| virtual void | v_AddRobinTraceContribution (const int traceid, const Array< OneD, const NekDouble > &primCoeffs, const Array< OneD, NekDouble > &incoeffs, Array< OneD, NekDouble > &coeffs) |
| virtual void | v_TraceNormLen (const int traceid, NekDouble &h, NekDouble &p) |
| virtual void | v_GenTraceExp (const int traceid, ExpansionSharedPtr &exp) |
| 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_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 | LinearAdvectionMatrixOp_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 (StdRegions::Orientation dir, Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) |
| virtual void | v_SetCoeffsToOrientation (Array< OneD, NekDouble > &coeffs, StdRegions::Orientation dir) |
| virtual NekDouble | v_StdPhysEvaluate (const Array< OneD, const NekDouble > &Lcoord, const Array< OneD, const NekDouble > &physvals) |
| virtual void | v_GenStdMatBwdDeriv (const int dir, DNekMatSharedPtr &mat) |
| virtual void | v_MultiplyByStdQuadratureMetric (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) |
| template<int DIR, bool DERIV = false, bool DERIV2 = false> | |
| NekDouble | BaryEvaluate (const NekDouble &coord, const NekDouble *physvals, NekDouble &deriv, NekDouble &deriv2) |
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) |
| template<int DIR, bool DERIV = false, bool DERIV2 = false> | |
| NekDouble | BaryEvaluate (const NekDouble &coord, const NekDouble *physvals) |
| Helper function to pass an unused value by reference into BaryEvaluate. More... | |
| template<int DIR, bool DERIV = false, bool DERIV2 = false> | |
| NekDouble | BaryEvaluate (const NekDouble &coord, const NekDouble *physvals, NekDouble &deriv) |
| Protected Member Functions inherited from Nektar::StdRegions::StdExpansion2D | |
| NekDouble | v_PhysEvaluate (const Array< OneD, const NekDouble > &coords, const Array< OneD, const NekDouble > &physvals) override |
| This function evaluates the expansion at a single (arbitrary) point of the domain. More... | |
| NekDouble | v_PhysEvaluate (const Array< OneD, DNekMatSharedPtr > &I, const Array< OneD, const NekDouble > &physvals) override |
| NekDouble | v_PhysEvaluate (const Array< OneD, NekDouble > &coord, const Array< OneD, const NekDouble > &inarray, std::array< NekDouble, 3 > &firstOrderDerivs) override |
| virtual void | v_BwdTrans_SumFacKernel (const Array< OneD, const NekDouble > &base0, const Array< OneD, const NekDouble > &base1, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, Array< OneD, NekDouble > &wsp, bool doCheckCollDir0, bool doCheckCollDir1)=0 |
| virtual void | v_IProductWRTBase_SumFacKernel (const Array< OneD, const NekDouble > &base0, const Array< OneD, const NekDouble > &base1, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, Array< OneD, NekDouble > &wsp, bool doCheckCollDir0, bool doCheckCollDir1)=0 |
| void | v_LaplacianMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey) override |
| void | v_HelmholtzMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey) override |
| void | v_GetTraceCoeffMap (const unsigned int traceid, Array< OneD, unsigned int > &maparray) override |
| void | v_GetElmtTraceToTraceMap (const unsigned int eid, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray, Orientation edgeOrient, int P, int Q) override |
| Determine the mapping to re-orientate the coefficients along the element trace (assumed to align with the standard element) into the orientation of the local trace given by edgeOrient. More... | |
| void | v_GetTraceToElementMap (const int eid, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray, Orientation edgeOrient=eForwards, int P=-1, int Q=-1) override |
| void | v_GenStdMatBwdDeriv (const int dir, DNekMatSharedPtr &mat) override |
Private Member Functions | |
| void | GetPhysEdgeVarCoeffsFromElement (const int edge, ExpansionSharedPtr &EdgeExp, const Array< OneD, const NekDouble > &varcoeff, Array< OneD, NekDouble > &outarray) |
| Array< OneD, NekDouble > | GetnEdgecdotMF (const int dir, const int edge, ExpansionSharedPtr &EdgeExp_e, const Array< OneD, const Array< OneD, NekDouble > > &normals, const StdRegions::VarCoeffMap &varcoeffs) |
Detailed Description
Definition at line 55 of file Expansion2D.h.
Constructor & Destructor Documentation
◆ Expansion2D()
| Nektar::LocalRegions::Expansion2D::Expansion2D | ( | SpatialDomains::Geometry2DSharedPtr | pGeom | ) |
Definition at line 50 of file Expansion2D.cpp.
52{
53}
Expansion(SpatialDomains::GeometrySharedPtr pGeom)
Definition: Expansion.cpp:43
StdExpansion2D()=default
◆ ~Expansion2D()
|
overridedefault |
Member Function Documentation
◆ AddEdgeBoundaryInt()
|
inline |
For a given edge add the \tilde{F}_1j contributions
@TODO Variable coeffs
Definition at line 1005 of file Expansion2D.cpp.
1010{
1011 int i;
1012 int order_e = EdgeExp->GetNcoeffs();
1013 int nquad_e = EdgeExp->GetNumPoints(0);
1014 Array<OneD, unsigned int> map;
1015 Array<OneD, int> sign;
1016 Array<OneD, NekDouble> coeff(order_e);
1017
1019
1021 StdRegions::eVarCoeffD11,
1022 StdRegions::eVarCoeffD22};
1023 StdRegions::VarCoeffMap::const_iterator x;
1024
1025 /// @TODO Variable coeffs
1026 if ((x = varcoeffs.find(VarCoeff[0])) != varcoeffs.end())
1027 {
1028 Array<OneD, NekDouble> work(nquad_e);
1029 GetPhysEdgeVarCoeffsFromElement(edge, EdgeExp, x->second.GetValue(),
1030 work);
1031 Vmath::Vmul(nquad_e, work, 1, edgePhys, 1, edgePhys, 1);
1032 }
1033
1034 EdgeExp->IProductWRTBase(edgePhys, coeff);
1035
1036 // add data to out array
1037 for (i = 0; i < order_e; ++i)
1038 {
1039 outarray[map[i]] += sign[i] * coeff[i];
1040 }
1041}
void GetPhysEdgeVarCoeffsFromElement(const int edge, ExpansionSharedPtr &EdgeExp, const Array< OneD, const NekDouble > &varcoeff, Array< OneD, NekDouble > &outarray)
Definition: Expansion2D.cpp:1223
virtual StdRegions::Orientation v_GetTraceOrient(int trace)
Definition: Expansion.cpp:813
void GetTraceToElementMap(const int tid, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray, Orientation traceOrient=eForwards, int P=-1, int Q=-1)
Definition: StdExpansion.h:684
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.hpp:72
References Nektar::StdRegions::eVarCoeffD00, Nektar::StdRegions::eVarCoeffD11, Nektar::StdRegions::eVarCoeffD22, GetPhysEdgeVarCoeffsFromElement(), Nektar::StdRegions::StdExpansion::GetTraceToElementMap(), sign, Nektar::LocalRegions::Expansion::v_GetTraceOrient(), and Vmath::Vmul().
Referenced by AddNormTraceInt().
◆ AddHDGHelmholtzEdgeTerms()
|
inline |
@TODO: What direction to use here??
@TODO: Document this (probably not needed)
Definition at line 1076 of file Expansion2D.cpp.
1080{
1082 int i, j, n;
1083 int nquad_e = EdgeExp[edge]->GetNumPoints(0);
1084 int order_e = EdgeExp[edge]->GetNcoeffs();
1087
1088 Array<OneD, NekDouble> inval(nquad_e);
1089 Array<OneD, NekDouble> outcoeff(order_e);
1090 Array<OneD, NekDouble> tmpcoeff(ncoeffs);
1091
1092 const Array<OneD, const Array<OneD, NekDouble>> &normals =
1093 GetTraceNormal(edge);
1094
1095 Array<OneD, unsigned int> emap;
1096 Array<OneD, int> sign;
1097
1099
1102
1104
1106 StdRegions::eWeakDeriv1,
1107 StdRegions::eWeakDeriv2};
1108
1110 StdRegions::eVarCoeffD11,
1111 StdRegions::eVarCoeffD22};
1112
1113 StdRegions::VarCoeffMap::const_iterator x;
1114 /// @TODO: What direction to use here??
1115 if ((x = varcoeffs.find(VarCoeff[0])) != varcoeffs.end())
1116 {
1117 Array<OneD, NekDouble> work(nquad_e);
1118 GetPhysEdgeVarCoeffsFromElement(edge, EdgeExp[edge],
1119 x->second.GetValue(), work);
1120 Vmath::Vmul(nquad_e, work, 1, edgePhys, 1, edgePhys, 1);
1121 }
1122
1123 //================================================================
1124 // Add F = \tau <phi_i,in_phys>
1125 // Fill edge and take inner product
1126 EdgeExp[edge]->IProductWRTBase(edgePhys, outcoeff);
1127 // add data to out array
1128 for (i = 0; i < order_e; ++i)
1129 {
1130 outarray[emap[i]] += sign[i] * tau * outcoeff[i];
1131 }
1132 //================================================================
1133
1134 //===============================================================
1135 // Add -\sum_i D_i^T M^{-1} G_i + E_i M^{-1} G_i =
1136 // \sum_i D_i M^{-1} G_i term
1137
1138 // Two independent direction
1139 DNekScalMatSharedPtr invMass;
1140 for (n = 0; n < coordim; ++n)
1141 {
1142 if (mmf)
1143 {
1144 StdRegions::VarCoeffMap Weight;
1146
1148 StdRegions::NullConstFactorMap, Weight);
1149
1150 invMass = GetLocMatrix(invMasskey);
1151
1152 Array<OneD, NekDouble> ncdotMF_e =
1153 GetnEdgecdotMF(n, edge, EdgeExp[edge], normals, varcoeffs);
1154
1155 Vmath::Vmul(nquad_e, ncdotMF_e, 1, edgePhys, 1, inval, 1);
1156 }
1157 else
1158 {
1159 Vmath::Vmul(nquad_e, normals[n], 1, edgePhys, 1, inval, 1);
1161 }
1162
1163 // Multiply by variable coefficient
1164 /// @TODO: Document this (probably not needed)
1165 // StdRegions::VarCoeffMap::const_iterator x;
1166 // if ((x = varcoeffs.find(VarCoeff[n])) !=
1167 // varcoeffs.end())
1168 // {
1169 // GetPhysEdgeVarCoeffsFromElement(edge,EdgeExp[edge],x->second,varcoeff_work);
1170 // Vmath::Vmul(nquad_e,varcoeff_work,1,EdgeExp[edge]->GetPhys(),1,EdgeExp[edge]->UpdatePhys(),1);
1171 // }
1172
1173 EdgeExp[edge]->IProductWRTBase(inval, outcoeff);
1174
1175 // M^{-1} G
1176 for (i = 0; i < ncoeffs; ++i)
1177 {
1178 tmpcoeff[i] = 0;
1179 for (j = 0; j < order_e; ++j)
1180 {
1181 tmpcoeff[i] += (*invMass)(i, emap[j]) * sign[j] * outcoeff[j];
1182 }
1183 }
1184
1185 if (mmf)
1186 {
1187 StdRegions::VarCoeffMap VarCoeffDirDeriv;
1188 VarCoeffDirDeriv[StdRegions::eVarCoeffMF] =
1189 GetMF(n, coordim, varcoeffs);
1190 VarCoeffDirDeriv[StdRegions::eVarCoeffMFDiv] =
1191 GetMFDiv(n, varcoeffs);
1192
1195 VarCoeffDirDeriv);
1196
1198
1199 Coeffs = Coeffs + Dmat * Tmpcoeff;
1200 }
1201 else
1202 {
1203 if (varcoeffs.find(VarCoeff[n]) != varcoeffs.end())
1204 {
1206 StdRegions::NullConstFactorMap, varcoeffs);
1207
1209 Coeffs = Coeffs + Dmat * Tmpcoeff;
1210 }
1211 else
1212 {
1214 Coeffs = Coeffs + Dmat * Tmpcoeff;
1215 }
1216 }
1217 }
1218}
Array< OneD, NekDouble > GetnEdgecdotMF(const int dir, const int edge, ExpansionSharedPtr &EdgeExp_e, const Array< OneD, const Array< OneD, NekDouble > > &normals, const StdRegions::VarCoeffMap &varcoeffs)
Definition: Expansion2D.cpp:2266
Array< OneD, NekDouble > GetMFMag(const int dir, const StdRegions::VarCoeffMap &varcoeffs)
Definition: Expansion.cpp:709
StdRegions::Orientation GetTraceOrient(int trace)
Definition: Expansion.h:168
DNekScalMatSharedPtr GetLocMatrix(const LocalRegions::MatrixKey &mkey)
Definition: Expansion.cpp:84
Array< OneD, NekDouble > GetMFDiv(const int dir, const StdRegions::VarCoeffMap &varcoeffs)
Definition: Expansion.cpp:686
const NormalVector & GetTraceNormal(const int id)
Definition: Expansion.cpp:251
Array< OneD, NekDouble > GetMF(const int dir, const int shapedim, const StdRegions::VarCoeffMap &varcoeffs)
Definition: Expansion.cpp:633
int GetNcoeffs(void) const
This function returns the total number of coefficients used in the expansion.
Definition: StdExpansion.h:124
LibUtilities::ShapeType DetShapeType() const
This function returns the shape of the expansion domain.
Definition: StdExpansion.h:367
static ConstFactorMap NullConstFactorMap
Definition: StdRegions.hpp:431
std::map< StdRegions::VarCoeffType, VarCoeffEntry > VarCoeffMap
Definition: StdRegions.hpp:375
NekMatrix< NekMatrix< NekDouble, StandardMatrixTag >, ScaledMatrixTag > DNekScalMat
Definition: NekMatrixFwd.hpp:65
std::shared_ptr< DNekScalMat > DNekScalMatSharedPtr
Definition: NekMatrixFwd.hpp:66
References Nektar::StdRegions::StdExpansion::DetShapeType(), Nektar::StdRegions::eInvMass, Nektar::StdRegions::eVarCoeffD00, Nektar::StdRegions::eVarCoeffD11, Nektar::StdRegions::eVarCoeffD22, Nektar::StdRegions::eVarCoeffMass, Nektar::StdRegions::eVarCoeffMF, Nektar::StdRegions::eVarCoeffMF1x, Nektar::StdRegions::eVarCoeffMFDiv, Nektar::StdRegions::eWeakDeriv0, Nektar::StdRegions::eWeakDeriv1, Nektar::StdRegions::eWeakDeriv2, Nektar::StdRegions::eWeakDirectionalDeriv, Nektar::eWrapper, Nektar::StdRegions::StdExpansion::GetCoordim(), Nektar::LocalRegions::Expansion::GetLocMatrix(), Nektar::LocalRegions::Expansion::GetMF(), Nektar::LocalRegions::Expansion::GetMFDiv(), Nektar::LocalRegions::Expansion::GetMFMag(), Nektar::StdRegions::StdExpansion::GetNcoeffs(), GetnEdgecdotMF(), GetPhysEdgeVarCoeffsFromElement(), Nektar::LocalRegions::Expansion::GetTraceNormal(), Nektar::LocalRegions::Expansion::GetTraceOrient(), Nektar::StdRegions::StdExpansion::GetTraceToElementMap(), Nektar::StdRegions::NullConstFactorMap, sign, and Vmath::Vmul().
Referenced by AddHDGHelmholtzTraceTerms().
◆ AddHDGHelmholtzTraceTerms()
|
inline |
Definition at line 1046 of file Expansion2D.cpp.
1050{
1051 ASSERTL0(&inarray[0] != &outarray[0],
1052 "Input and output arrays use the same memory");
1053
1055 Array<OneD, const NekDouble> tmp;
1056
1057 cnt = 0;
1058
1059 for (e = 0; e < nedges; ++e)
1060 {
1061 order_e = EdgeExp[e]->GetNcoeffs();
1062 Array<OneD, NekDouble> edgeCoeffs(order_e);
1063 Array<OneD, NekDouble> edgePhys(EdgeExp[e]->GetTotPoints());
1064
1065 Vmath::Vcopy(order_e, tmp = inarray + cnt, 1, edgeCoeffs, 1);
1066 EdgeExp[e]->BwdTrans(edgeCoeffs, edgePhys);
1067 AddHDGHelmholtzEdgeTerms(tau, e, EdgeExp, edgePhys, dirForcing,
1068 outarray);
1069
1070 cnt += order_e;
1071 }
1072}
void AddHDGHelmholtzEdgeTerms(const NekDouble tau, const int edge, Array< OneD, ExpansionSharedPtr > &EdgeExp, Array< OneD, NekDouble > &edgePhys, const StdRegions::VarCoeffMap &dirForcing, Array< OneD, NekDouble > &outarray)
Definition: Expansion2D.cpp:1076
int GetTotPoints() const
This function returns the total number of quadrature points used in the element.
Definition: StdExpansion.h:134
int GetNtraces() const
Returns the number of trace elements connected to this element.
Definition: StdExpansion.h:351
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.hpp:825
References AddHDGHelmholtzEdgeTerms(), ASSERTL0, Nektar::StdRegions::StdExpansion::GetNtraces(), Nektar::StdRegions::StdExpansion::GetTotPoints(), and Vmath::Vcopy().
Referenced by v_GenMatrix().
◆ AddNormTraceInt() [1/2]
|
inline |
Computes the C matrix entries due to the presence of the identity matrix in Eqn. 32.
@TODO: Document this
Definition at line 917 of file Expansion2D.cpp.
922{
923 int i, e, cnt;
924 int order_e, nquad_e;
926
927 cnt = 0;
928 for (e = 0; e < nedges; ++e)
929 {
930 order_e = EdgeExp[e]->GetNcoeffs();
931 nquad_e = EdgeExp[e]->GetNumPoints(0);
932
933 const Array<OneD, const Array<OneD, NekDouble>> &normals =
934 GetTraceNormal(e);
935 Array<OneD, NekDouble> edgeCoeffs(order_e);
936 Array<OneD, NekDouble> edgePhys(nquad_e);
937
938 for (i = 0; i < order_e; ++i)
939 {
940 edgeCoeffs[i] = inarray[i + cnt];
941 }
942 cnt += order_e;
943
944 EdgeExp[e]->BwdTrans(edgeCoeffs, edgePhys);
945
946 // Multiply by variable coefficient
947 /// @TODO: Document this
948 // StdRegions::VarCoeffType VarCoeff[3] = {StdRegions::eVarCoeffD00,
949 // StdRegions::eVarCoeffD11,
950 // StdRegions::eVarCoeffD22};
951 // StdRegions::VarCoeffMap::const_iterator x;
952 // Array<OneD, NekDouble> varcoeff_work(nquad_e);
953
954 // if ((x = varcoeffs.find(VarCoeff[dir])) != varcoeffs.end())
955 // {
956 // GetPhysEdgeVarCoeffsFromElement(e,EdgeExp[e],x->second,varcoeff_work);
957 // Vmath::Vmul(nquad_e,varcoeff_work,1,EdgeExp[e]->GetPhys(),1,EdgeExp[e]->UpdatePhys(),1);
958 // }
959
961 {
962 // MMF case
963 Array<OneD, NekDouble> ncdotMF_e =
964 GetnEdgecdotMF(dir, e, EdgeExp[e], normals, varcoeffs);
965
966 Vmath::Vmul(nquad_e, ncdotMF_e, 1, edgePhys, 1, edgePhys, 1);
967 }
968 else
969 {
970 Vmath::Vmul(nquad_e, normals[dir], 1, edgePhys, 1, edgePhys, 1);
971 }
972
973 AddEdgeBoundaryInt(e, EdgeExp[e], edgePhys, outarray, varcoeffs);
974 }
975}
void AddEdgeBoundaryInt(const int edge, ExpansionSharedPtr &EdgeExp, Array< OneD, NekDouble > &edgePhys, Array< OneD, NekDouble > &outarray, const StdRegions::VarCoeffMap &varcoeffs=StdRegions::NullVarCoeffMap)
Definition: Expansion2D.cpp:1005
References AddEdgeBoundaryInt(), Nektar::StdRegions::eVarCoeffMF1x, GetnEdgecdotMF(), Nektar::StdRegions::StdExpansion::GetNtraces(), Nektar::LocalRegions::Expansion::GetTraceNormal(), and Vmath::Vmul().
◆ AddNormTraceInt() [2/2]
|
inline |
Definition at line 977 of file Expansion2D.cpp.
981{
982 int e;
983 int nquad_e;
985
986 for (e = 0; e < nedges; ++e)
987 {
988 nquad_e = EdgeExp[e]->GetNumPoints(0);
989
990 Array<OneD, NekDouble> edgePhys(nquad_e);
991 const Array<OneD, const Array<OneD, NekDouble>> &normals =
992 GetTraceNormal(e);
993
994 EdgeExp[e]->BwdTrans(edgeCoeffs[e], edgePhys);
995
996 Vmath::Vmul(nquad_e, normals[dir], 1, edgePhys, 1, edgePhys, 1);
997
998 AddEdgeBoundaryInt(e, EdgeExp[e], edgePhys, outarray);
999 }
1000}
References AddEdgeBoundaryInt(), Nektar::StdRegions::StdExpansion::GetNtraces(), Nektar::LocalRegions::Expansion::GetTraceNormal(), and Vmath::Vmul().
Referenced by v_DGDeriv(), and v_GenMatrix().
◆ CreateMatrix()
| DNekScalMatSharedPtr Nektar::LocalRegions::Expansion2D::CreateMatrix | ( | const MatrixKey & | mkey | ) |
Definition at line 55 of file Expansion2D.cpp.
56{
57 DNekScalMatSharedPtr returnval;
59
61 "Geometric information is not set up");
62
63 switch (mkey.GetMatrixType())
64 {
66 {
68 (mkey.HasVarCoeff(StdRegions::eVarCoeffMass)))
69 {
70 NekDouble one = 1.0;
72
73 returnval =
74 MemoryManager<DNekScalMat>::AllocateSharedPtr(one, mat);
75 }
76 else
77 {
80
81 returnval =
82 MemoryManager<DNekScalMat>::AllocateSharedPtr(jac, mat);
83 }
84 }
85 break;
87 {
88 MatrixKey masskey(mkey, StdRegions::eMass);
90
91 // Generate a local copy of traceMat
92 MatrixKey key(mkey, StdRegions::eNormDerivOnTrace);
94
96 "Need to specify eFactorGJP to construct "
97 "a HelmholtzGJP matrix");
98
100
101 factor /= MassMat.Scale();
102
103 int ntot = MassMat.GetRows() * MassMat.GetColumns();
104
105 Vmath::Svtvp(ntot, factor, &NDTraceMat->GetPtr()[0], 1,
106 MassMat.GetRawPtr(), 1, &NDTraceMat->GetPtr()[0], 1);
107
108 returnval = MemoryManager<DNekScalMat>::AllocateSharedPtr(
109 MassMat.Scale(), NDTraceMat);
110 }
111 break;
113 {
115 {
116 NekDouble one = 1.0;
117 StdRegions::StdMatrixKey masskey(StdRegions::eMass,
120 mat->Invert();
121
122 returnval =
123 MemoryManager<DNekScalMat>::AllocateSharedPtr(one, mat);
124 }
125 else
126 {
129
130 returnval =
131 MemoryManager<DNekScalMat>::AllocateSharedPtr(fac, mat);
132 }
133 }
134 break;
138 {
140 (mkey.HasVarCoeff(StdRegions::eVarCoeffLaplacian)) ||
141 (mkey.HasVarCoeff(StdRegions::eVarCoeffD00)) ||
142 (mkey.HasVarCoeff(StdRegions::eVarCoeffD01)) ||
143 (mkey.HasVarCoeff(StdRegions::eVarCoeffD02)) ||
144 (mkey.HasVarCoeff(StdRegions::eVarCoeffD11)) ||
145 (mkey.HasVarCoeff(StdRegions::eVarCoeffD12)) ||
146 (mkey.HasVarCoeff(StdRegions::eVarCoeffD22)))
147 {
148 NekDouble one = 1.0;
150
151 returnval =
152 MemoryManager<DNekScalMat>::AllocateSharedPtr(one, mat);
153 }
154 else
155 {
157 Array<TwoD, const NekDouble> df =
158 m_metricinfo->GetDerivFactors(ptsKeys);
159 int dir = 0;
161 {
162 dir = 0;
163 }
165 {
166 dir = 1;
167 }
169 {
170 dir = 2;
171 }
172
173 MatrixKey deriv0key(StdRegions::eWeakDeriv0,
174 mkey.GetShapeType(), *this);
175 MatrixKey deriv1key(StdRegions::eWeakDeriv1,
176 mkey.GetShapeType(), *this);
177
180
181 int rows = deriv0.GetRows();
182 int cols = deriv1.GetColumns();
183
184 DNekMatSharedPtr WeakDeriv =
185 MemoryManager<DNekMat>::AllocateSharedPtr(rows, cols);
186 (*WeakDeriv) =
187 df[2 * dir][0] * deriv0 + df[2 * dir + 1][0] * deriv1;
188
189 returnval = MemoryManager<DNekScalMat>::AllocateSharedPtr(
190 jac, WeakDeriv);
191 }
192 }
193 break;
195 {
197 mkey.GetNVarCoeff())
198 {
199 NekDouble one = 1.0;
201
202 returnval =
203 MemoryManager<DNekScalMat>::AllocateSharedPtr(one, mat);
204 }
205 else
206 {
207 int shapedim = 2;
208
209 // dfdirxi = tan_{xi_x} * d \xi/dx
210 // + tan_{xi_y} * d \xi/dy
211 // + tan_{xi_z} * d \xi/dz
212 // dfdireta = tan_{eta_x} * d \eta/dx
213 // + tan_{xi_y} * d \xi/dy
214 // + tan_{xi_z} * d \xi/dz
216 Array<TwoD, const NekDouble> df =
217 m_metricinfo->GetDerivFactors(ptsKeys);
218
219 Array<OneD, NekDouble> direction =
220 mkey.GetVarCoeff(StdRegions::eVarCoeffMF);
221
222 // d / dx = df[0]*deriv0 + df[1]*deriv1
223 // d / dy = df[2]*deriv0 + df[3]*deriv1
224 // d / dz = df[4]*deriv0 + df[5]*deriv1
225
226 // dfdir[dir] = e \cdot (d/dx, d/dy, d/dz)
227 // = (e^0 * df[0] + e^1 * df[2]
228 // + e^2 * df[4]) * deriv0
229 // + (e^0 * df[1] + e^1 * df[3]
230 // + e^2 * df[5]) * deriv1
231 // dfdir[dir] = e^0 * df[2 * 0 + dir]
232 // + e^1 * df[2 * 1 + dir]
233 // + e^2 * df [ 2 * 2 + dir]
234 Array<OneD, Array<OneD, NekDouble>> dfdir(shapedim);
235 Expansion::ComputeGmatcdotMF(df, direction, dfdir);
236
237 StdRegions::VarCoeffMap dfdirxi;
238 StdRegions::VarCoeffMap dfdireta;
239
240 dfdirxi[StdRegions::eVarCoeffWeakDeriv] = dfdir[0];
241 dfdireta[StdRegions::eVarCoeffWeakDeriv] = dfdir[1];
242
243 MatrixKey derivxikey(StdRegions::eWeakDeriv0,
244 mkey.GetShapeType(), *this,
245 StdRegions::NullConstFactorMap, dfdirxi);
246 MatrixKey derivetakey(StdRegions::eWeakDeriv1,
247 mkey.GetShapeType(), *this,
248 StdRegions::NullConstFactorMap, dfdireta);
249
252
253 int rows = derivxi.GetRows();
254 int cols = deriveta.GetColumns();
255
256 DNekMatSharedPtr WeakDirDeriv =
257 MemoryManager<DNekMat>::AllocateSharedPtr(rows, cols);
258
259 (*WeakDirDeriv) = derivxi + deriveta;
260
261 // Add (\nabla \cdot e^k ) Mass
262 StdRegions::VarCoeffMap DiveMass;
263 DiveMass[StdRegions::eVarCoeffMass] =
264 mkey.GetVarCoeff(StdRegions::eVarCoeffMFDiv);
265 StdRegions::StdMatrixKey stdmasskey(
267 StdRegions::NullConstFactorMap, DiveMass);
268
270
271 (*WeakDirDeriv) = (*WeakDirDeriv) + (*DiveMassmat);
272
273 returnval = MemoryManager<DNekScalMat>::AllocateSharedPtr(
274 jac, WeakDirDeriv);
275 }
276 break;
277 }
279 {
281 (mkey.HasVarCoeff(StdRegions::eVarCoeffLaplacian)) ||
282 (mkey.HasVarCoeff(StdRegions::eVarCoeffD00)) ||
283 (mkey.HasVarCoeff(StdRegions::eVarCoeffD01)) ||
284 (mkey.HasVarCoeff(StdRegions::eVarCoeffD10)) ||
285 (mkey.HasVarCoeff(StdRegions::eVarCoeffD02)) ||
286 (mkey.HasVarCoeff(StdRegions::eVarCoeffD20)) ||
287 (mkey.HasVarCoeff(StdRegions::eVarCoeffD11)) ||
288 (mkey.HasVarCoeff(StdRegions::eVarCoeffD12)) ||
289 (mkey.HasVarCoeff(StdRegions::eVarCoeffD21)) ||
290 (mkey.HasVarCoeff(StdRegions::eVarCoeffD22)) ||
291 (mkey.ConstFactorExists(StdRegions::eFactorSVVCutoffRatio)))
292 {
293 NekDouble one = 1.0;
295
296 returnval =
297 MemoryManager<DNekScalMat>::AllocateSharedPtr(one, mat);
298 }
299 else
300 {
301 MatrixKey lap00key(StdRegions::eLaplacian00,
302 mkey.GetShapeType(), *this);
303 MatrixKey lap01key(StdRegions::eLaplacian01,
304 mkey.GetShapeType(), *this);
305 MatrixKey lap11key(StdRegions::eLaplacian11,
306 mkey.GetShapeType(), *this);
307
311
313 Array<TwoD, const NekDouble> gmat =
314 m_metricinfo->GetGmat(ptsKeys);
315
316 int rows = lap00.GetRows();
317 int cols = lap00.GetColumns();
318
319 DNekMatSharedPtr lap =
320 MemoryManager<DNekMat>::AllocateSharedPtr(rows, cols);
321
322 (*lap) = gmat[0][0] * lap00 +
323 gmat[1][0] * (lap01 + Transpose(lap01)) +
324 gmat[3][0] * lap11;
325
326 returnval =
327 MemoryManager<DNekScalMat>::AllocateSharedPtr(jac, lap);
328 }
329 }
330 break;
332 {
334
335 returnval = MemoryManager<DNekScalMat>::AllocateSharedPtr(1.0, mat);
336 }
337 break;
339 {
341
342 MatrixKey masskey(mkey, StdRegions::eMass);
344
345 MatrixKey lapkey(mkey, StdRegions::eLaplacian);
347
348 int rows = LapMat.GetRows();
349 int cols = LapMat.GetColumns();
350
351 DNekMatSharedPtr helm =
352 MemoryManager<DNekMat>::AllocateSharedPtr(rows, cols);
353
354 NekDouble one = 1.0;
355 (*helm) = LapMat + factor * MassMat;
356
357 returnval =
358 MemoryManager<DNekScalMat>::AllocateSharedPtr(one, helm);
359 }
360 break;
362 {
363 MatrixKey helmkey(mkey, StdRegions::eHelmholtz);
365
366 // Generate a local copy of traceMat
367 MatrixKey key(mkey, StdRegions::eNormDerivOnTrace);
369
371 "Need to specify eFactorGJP to construct "
372 "a HelmholtzGJP matrix");
373
375
376 factor /= HelmMat.Scale();
377
378 int ntot = HelmMat.GetRows() * HelmMat.GetColumns();
379
380 Vmath::Svtvp(ntot, factor, &NDTraceMat->GetPtr()[0], 1,
381 HelmMat.GetRawPtr(), 1, &NDTraceMat->GetPtr()[0], 1);
382
383 returnval = MemoryManager<DNekScalMat>::AllocateSharedPtr(
384 HelmMat.Scale(), NDTraceMat);
385 }
386 break;
388 {
390
391 // Construct mass matrix
392 // Check for mass-specific varcoeffs to avoid unncessary
393 // re-computation of the elemental matrix every time step
396 {
397 massVarcoeffs[StdRegions::eVarCoeffMass] =
398 mkey.GetVarCoeff(StdRegions::eVarCoeffMass);
399 }
401 mkey.GetConstFactors(), massVarcoeffs);
403
404 // Construct laplacian matrix (Check for varcoeffs)
405 // Take all varcoeffs if one or more are detected
406 // TODO We might want to have a map
407 // from MatrixType to Vector of Varcoeffs and vice-versa
410 (mkey.HasVarCoeff(StdRegions::eVarCoeffD00)) ||
411 (mkey.HasVarCoeff(StdRegions::eVarCoeffD01)) ||
412 (mkey.HasVarCoeff(StdRegions::eVarCoeffD10)) ||
413 (mkey.HasVarCoeff(StdRegions::eVarCoeffD02)) ||
414 (mkey.HasVarCoeff(StdRegions::eVarCoeffD20)) ||
415 (mkey.HasVarCoeff(StdRegions::eVarCoeffD11)) ||
416 (mkey.HasVarCoeff(StdRegions::eVarCoeffD12)) ||
417 (mkey.HasVarCoeff(StdRegions::eVarCoeffD21)) ||
418 (mkey.HasVarCoeff(StdRegions::eVarCoeffD22)))
419 {
420 lapVarcoeffs = mkey.GetVarCoeffs();
421 }
423 mkey.GetConstFactors(), lapVarcoeffs);
425
426 // Construct advection matrix
427 // Check for varcoeffs not required;
428 // assume advection velocity is always time-dependent
429 MatrixKey advkey(mkey, StdRegions::eLinearAdvection);
431
432 int rows = LapMat.GetRows();
433 int cols = LapMat.GetColumns();
434
435 DNekMatSharedPtr adr =
436 MemoryManager<DNekMat>::AllocateSharedPtr(rows, cols);
437
438 NekDouble one = 1.0;
439 (*adr) = LapMat - lambda * MassMat + AdvMat;
440
441 returnval = MemoryManager<DNekScalMat>::AllocateSharedPtr(one, adr);
442
443 // Clear memory for time-dependent matrices
444 DropLocMatrix(advkey);
445 if (!massVarcoeffs.empty())
446 {
447 DropLocMatrix(masskey);
448 }
449 if (!lapVarcoeffs.empty())
450 {
451 DropLocMatrix(lapkey);
452 }
453 }
454 break;
456 {
457 // Copied mostly from ADR solve to have fine-grain control
458 // over updating only advection matrix, relevant for performance!
460
461 // Construct mass matrix (Check for varcoeffs)
464 {
465 massVarcoeffs[StdRegions::eVarCoeffMass] =
466 mkey.GetVarCoeff(StdRegions::eVarCoeffMass);
467 }
469 mkey.GetConstFactors(), massVarcoeffs);
471
472 // Construct laplacian matrix (Check for varcoeffs)
475 (mkey.HasVarCoeff(StdRegions::eVarCoeffD00)) ||
476 (mkey.HasVarCoeff(StdRegions::eVarCoeffD01)) ||
477 (mkey.HasVarCoeff(StdRegions::eVarCoeffD10)) ||
478 (mkey.HasVarCoeff(StdRegions::eVarCoeffD02)) ||
479 (mkey.HasVarCoeff(StdRegions::eVarCoeffD20)) ||
480 (mkey.HasVarCoeff(StdRegions::eVarCoeffD11)) ||
481 (mkey.HasVarCoeff(StdRegions::eVarCoeffD12)) ||
482 (mkey.HasVarCoeff(StdRegions::eVarCoeffD21)) ||
483 (mkey.HasVarCoeff(StdRegions::eVarCoeffD22)))
484 {
485 lapVarcoeffs = mkey.GetVarCoeffs();
486 }
488 mkey.GetConstFactors(), lapVarcoeffs);
490
491 // Construct advection matrix
492 // (assume advection velocity defined and non-zero)
493 // Could check L2(AdvectionVelocity) or HasVarCoeff
494 MatrixKey advkey(mkey, StdRegions::eLinearAdvection);
496
497 // Generate a local copy of traceMat
498 MatrixKey gjpkey(StdRegions::eNormDerivOnTrace, mkey.GetShapeType(),
499 *this, mkey.GetConstFactors());
501
504 "Need to specify eFactorGJP to construct "
505 "a LinearAdvectionDiffusionReactionGJP matrix");
506
507 int rows = LapMat.GetRows();
508 int cols = LapMat.GetColumns();
509
510 DNekMatSharedPtr adr =
511 MemoryManager<DNekMat>::AllocateSharedPtr(rows, cols);
512
513 NekDouble one = 1.0;
514 (*adr) =
515 LapMat - lambda * MassMat + AdvMat + gjpfactor * NDTraceMat;
516
517 returnval = MemoryManager<DNekScalMat>::AllocateSharedPtr(one, adr);
518
519 // Clear memory
520 DropLocMatrix(advkey);
521 DropLocMatrix(masskey);
522 DropLocMatrix(lapkey);
523 }
524 break;
526 {
527 NekDouble one = 1.0;
529
530 returnval = MemoryManager<DNekScalMat>::AllocateSharedPtr(one, mat);
531 }
532 break;
534 {
536 {
537 NekDouble one = 1.0;
539
540 returnval =
541 MemoryManager<DNekScalMat>::AllocateSharedPtr(one, mat);
542 }
543 else
544 {
547
548 returnval =
549 MemoryManager<DNekScalMat>::AllocateSharedPtr(jac, mat);
550 }
551 }
552 break;
556 {
558 {
559 NekDouble one = 1.0;
561
562 returnval =
563 MemoryManager<DNekScalMat>::AllocateSharedPtr(one, mat);
564 }
565 else
566 {
568
569 const Array<TwoD, const NekDouble> &df =
570 m_metricinfo->GetDerivFactors(ptsKeys);
571 int dir = 0;
573 {
574 dir = 0;
575 }
577 {
578 dir = 1;
579 }
581 {
582 dir = 2;
583 }
584
585 MatrixKey iProdDeriv0Key(StdRegions::eIProductWRTDerivBase0,
586 mkey.GetShapeType(), *this);
587 MatrixKey iProdDeriv1Key(StdRegions::eIProductWRTDerivBase1,
588 mkey.GetShapeType(), *this);
589
592
593 int rows = stdiprod0.GetRows();
594 int cols = stdiprod1.GetColumns();
595
596 DNekMatSharedPtr mat =
597 MemoryManager<DNekMat>::AllocateSharedPtr(rows, cols);
598 (*mat) =
599 df[2 * dir][0] * stdiprod0 + df[2 * dir + 1][0] * stdiprod1;
600
601 returnval =
602 MemoryManager<DNekScalMat>::AllocateSharedPtr(jac, mat);
603 }
604 }
605 break;
606
608 {
609 NekDouble one = 1.0;
610
612 *this, mkey.GetConstFactors(), mkey.GetVarCoeffs());
613
615
616 mat->Invert();
617
618 returnval = MemoryManager<DNekScalMat>::AllocateSharedPtr(one, mat);
619 }
620 break;
622 {
624 "Matrix only setup for quad elements currently");
625 DNekMatSharedPtr m_Ix;
626 Array<OneD, NekDouble> coords(1, 0.0);
629
630 coords[0] = (edge == 0 || edge == 3) ? -1.0 : 1.0;
631
632 m_Ix = m_base[(edge + 1) % 2]->GetI(coords);
633
634 returnval =
635 MemoryManager<DNekScalMat>::AllocateSharedPtr(1.0, m_Ix);
636 }
637 break;
639 {
640 NekDouble one = 1.0;
641 MatrixKey helmkey(StdRegions::eHelmholtz, mkey.GetShapeType(),
642 *this, mkey.GetConstFactors(),
643 mkey.GetVarCoeffs());
644 DNekScalBlkMatSharedPtr helmStatCond =
645 GetLocStaticCondMatrix(helmkey);
648
649 returnval = MemoryManager<DNekScalMat>::AllocateSharedPtr(one, R);
650 }
651 break;
652 default:
653 {
654 NekDouble one = 1.0;
656
657 returnval = MemoryManager<DNekScalMat>::AllocateSharedPtr(one, mat);
658 }
659 break;
660 }
661
662 return returnval;
663}
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode....
Definition: ErrorUtil.hpp:242
#define ASSERTL2(condition, msg)
Assert Level 2 – Debugging which is used FULLDEBUG compilation mode. This level assert is designed to...
Definition: ErrorUtil.hpp:265
DNekMatSharedPtr v_GenMatrix(const StdRegions::StdMatrixKey &mkey) override
Definition: Expansion2D.cpp:1256
void DropLocMatrix(const LocalRegions::MatrixKey &mkey)
Definition: Expansion.cpp:90
DNekMatSharedPtr BuildVertexMatrix(const DNekScalMatSharedPtr &r_bnd)
Definition: Expansion.cpp:101
void ComputeGmatcdotMF(const Array< TwoD, const NekDouble > &df, const Array< OneD, const NekDouble > &direction, Array< OneD, Array< OneD, NekDouble > > &dfdir)
Definition: Expansion.cpp:603
SpatialDomains::GeomFactorsSharedPtr m_metricinfo
Definition: Expansion.h:274
static std::shared_ptr< DataType > AllocateSharedPtr(const Args &...args)
Allocate a shared pointer from the memory pool.
Definition: NekMemoryManager.hpp:166
DNekMatSharedPtr GetStdMatrix(const StdMatrixKey &mkey)
Definition: StdExpansion.h:603
const LibUtilities::PointsKeyVector GetPointsKeys() const
Definition: StdExpansion.h:1095
DNekScalBlkMatSharedPtr GetLocStaticCondMatrix(const LocalRegions::MatrixKey &mkey)
Definition: StdExpansion.h:641
DNekMatSharedPtr GenMatrix(const StdMatrixKey &mkey)
Definition: StdExpansion.h:844
Array< OneD, LibUtilities::BasisSharedPtr > m_base
Definition: StdExpansion.h:1173
std::vector< PointsKey > PointsKeyVector
Definition: Points.h:231
@ eLinearAdvectionDiffusionReaction
Definition: StdRegions.hpp:104
@ eLinearAdvectionDiffusionReactionGJP
Definition: StdRegions.hpp:105
@ eInvLaplacianWithUnityMean
Definition: StdRegions.hpp:96
std::map< ConstFactorType, NekDouble > ConstFactorMap
Definition: StdRegions.hpp:430
StdRegions::ConstFactorMap factors
Definition: TestVarcoeffHashing.cpp:52
std::shared_ptr< DNekScalBlkMat > DNekScalBlkMatSharedPtr
Definition: NekTypeDefs.hpp:79
NekMatrix< InnerMatrixType, BlockMatrixTag > Transpose(NekMatrix< InnerMatrixType, BlockMatrixTag > &rhs)
Definition: BlockMatrix.hpp:235
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.hpp:396
References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL1, ASSERTL2, Nektar::LocalRegions::Expansion::BuildVertexMatrix(), Nektar::LocalRegions::Expansion::ComputeGmatcdotMF(), Nektar::StdRegions::StdMatrixKey::ConstFactorExists(), Nektar::StdRegions::StdExpansion::DetShapeType(), Nektar::LocalRegions::Expansion::DropLocMatrix(), Nektar::SpatialDomains::eDeformed, Nektar::StdRegions::eFactorGaussEdge, Nektar::StdRegions::eFactorGJP, Nektar::StdRegions::eFactorLambda, Nektar::StdRegions::eFactorSVVCutoffRatio, Nektar::StdRegions::eHelmholtz, Nektar::StdRegions::eHelmholtzGJP, Nektar::StdRegions::eHybridDGHelmholtz, Nektar::StdRegions::eInterpGauss, Nektar::StdRegions::eInvHybridDGHelmholtz, Nektar::StdRegions::eInvLaplacianWithUnityMean, Nektar::StdRegions::eInvMass, Nektar::StdRegions::eIProductWRTBase, Nektar::StdRegions::eIProductWRTDerivBase0, Nektar::StdRegions::eIProductWRTDerivBase1, Nektar::StdRegions::eIProductWRTDerivBase2, Nektar::StdRegions::eLaplacian, Nektar::StdRegions::eLaplacian00, Nektar::StdRegions::eLaplacian01, Nektar::StdRegions::eLaplacian11, Nektar::StdRegions::eLinearAdvection, Nektar::StdRegions::eLinearAdvectionDiffusionReaction, Nektar::StdRegions::eLinearAdvectionDiffusionReactionGJP, Nektar::StdRegions::eMass, Nektar::StdRegions::eMassGJP, Nektar::SpatialDomains::eNoGeomType, Nektar::StdRegions::eNormDerivOnTrace, Nektar::StdRegions::ePreconLinearSpace, Nektar::LibUtilities::eQuadrilateral, Nektar::StdRegions::eVarCoeffD00, Nektar::StdRegions::eVarCoeffD01, Nektar::StdRegions::eVarCoeffD02, Nektar::StdRegions::eVarCoeffD10, Nektar::StdRegions::eVarCoeffD11, Nektar::StdRegions::eVarCoeffD12, Nektar::StdRegions::eVarCoeffD20, Nektar::StdRegions::eVarCoeffD21, Nektar::StdRegions::eVarCoeffD22, Nektar::StdRegions::eVarCoeffLaplacian, Nektar::StdRegions::eVarCoeffMass, Nektar::StdRegions::eVarCoeffMF, Nektar::StdRegions::eVarCoeffMFDiv, Nektar::StdRegions::eVarCoeffWeakDeriv, Nektar::StdRegions::eWeakDeriv0, Nektar::StdRegions::eWeakDeriv1, Nektar::StdRegions::eWeakDeriv2, Nektar::StdRegions::eWeakDirectionalDeriv, Nektar::VarcoeffHashingTest::factors, Nektar::StdRegions::StdExpansion::GenMatrix(), Nektar::StdRegions::StdMatrixKey::GetConstFactor(), Nektar::StdRegions::StdMatrixKey::GetConstFactors(), Nektar::LocalRegions::Expansion::GetLocMatrix(), Nektar::StdRegions::StdExpansion::GetLocStaticCondMatrix(), Nektar::StdRegions::StdMatrixKey::GetMatrixType(), Nektar::StdRegions::StdMatrixKey::GetNVarCoeff(), Nektar::StdRegions::StdExpansion::GetPointsKeys(), Nektar::StdRegions::StdMatrixKey::GetShapeType(), Nektar::StdRegions::StdExpansion::GetStdMatrix(), Nektar::StdRegions::StdMatrixKey::GetVarCoeff(), Nektar::StdRegions::StdMatrixKey::GetVarCoeffs(), Nektar::StdRegions::StdMatrixKey::HasVarCoeff(), Nektar::StdRegions::StdExpansion::m_base, Nektar::LocalRegions::Expansion::m_metricinfo, Nektar::StdRegions::NullConstFactorMap, Nektar::StdRegions::NullVarCoeffMap, Vmath::Svtvp(), Nektar::Transpose(), and v_GenMatrix().
◆ GetGeom2D()
|
inline |
Definition at line 164 of file Expansion2D.h.
References Nektar::LocalRegions::Expansion::m_geom.
Referenced by GetTraceInverseBoundaryMap(), Nektar::LocalRegions::QuadExp::v_FwdTransBndConstrained(), Nektar::LocalRegions::TriExp::v_FwdTransBndConstrained(), and Nektar::LocalRegions::TriExp::v_GetTraceOrient().
◆ GetnEdgecdotMF()
|
private |
Definition at line 2266 of file Expansion2D.cpp.
2270{
2271 int nquad_e = EdgeExp_e->GetNumPoints(0);
2275 int nqtot = nquad0 * nquad1;
2276
2277 StdRegions::VarCoeffType MMFCoeffs[15] = {
2285 StdRegions::eVarCoeffMF3Mag};
2286
2287 StdRegions::VarCoeffMap::const_iterator MFdir;
2288
2289 Array<OneD, NekDouble> ncdotMF(nqtot, 0.0);
2290 Array<OneD, NekDouble> tmp(nqtot);
2291 Array<OneD, NekDouble> tmp_e(nquad_e);
2292 for (int k = 0; k < coordim; k++)
2293 {
2294 MFdir = varcoeffs.find(MMFCoeffs[dir * 5 + k]);
2295 tmp = MFdir->second.GetValue();
2296
2297 GetPhysEdgeVarCoeffsFromElement(edge, EdgeExp_e, tmp, tmp_e);
2298
2299 Vmath::Vvtvp(nquad_e, &tmp_e[0], 1, &normals[k][0], 1, &ncdotMF[0], 1,
2300 &ncdotMF[0], 1);
2301 }
2302 return ncdotMF;
2303}
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.hpp:366
References Nektar::StdRegions::eVarCoeffMF1Div, Nektar::StdRegions::eVarCoeffMF1Mag, Nektar::StdRegions::eVarCoeffMF1x, Nektar::StdRegions::eVarCoeffMF1y, Nektar::StdRegions::eVarCoeffMF1z, Nektar::StdRegions::eVarCoeffMF2Div, Nektar::StdRegions::eVarCoeffMF2Mag, Nektar::StdRegions::eVarCoeffMF2x, Nektar::StdRegions::eVarCoeffMF2y, Nektar::StdRegions::eVarCoeffMF2z, Nektar::StdRegions::eVarCoeffMF3Div, Nektar::StdRegions::eVarCoeffMF3Mag, Nektar::StdRegions::eVarCoeffMF3x, Nektar::StdRegions::eVarCoeffMF3y, Nektar::StdRegions::eVarCoeffMF3z, Nektar::StdRegions::StdExpansion::GetCoordim(), GetPhysEdgeVarCoeffsFromElement(), Nektar::StdRegions::StdExpansion::m_base, and Vmath::Vvtvp().
Referenced by AddHDGHelmholtzEdgeTerms(), AddNormTraceInt(), and v_GenMatrix().
◆ GetPhysEdgeVarCoeffsFromElement()
|
private |
Extracts the variable coefficients along an edge
Definition at line 1223 of file Expansion2D.cpp.
1227{
1228 Array<OneD, NekDouble> tmp(GetNcoeffs());
1229 Array<OneD, NekDouble> edgetmp(EdgeExp->GetNcoeffs());
1230
1231 // FwdTrans varcoeffs
1232 FwdTrans(varcoeff, tmp);
1233
1234 // Map to edge
1235 Array<OneD, unsigned int> emap;
1236 Array<OneD, int> sign;
1239
1240 for (unsigned int i = 0; i < EdgeExp->GetNcoeffs(); ++i)
1241 {
1242 edgetmp[i] = tmp[emap[i]];
1243 }
1244
1245 // BwdTrans
1246 EdgeExp->BwdTrans(edgetmp, outarray);
1247}
void FwdTrans(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
This function performs the Forward transformation from physical space to coefficient space.
Definition: StdExpansion.h:1799
References Nektar::StdRegions::StdExpansion::FwdTrans(), Nektar::StdRegions::StdExpansion::GetNcoeffs(), Nektar::LocalRegions::Expansion::GetTraceOrient(), Nektar::StdRegions::StdExpansion::GetTraceToElementMap(), and sign.
Referenced by AddEdgeBoundaryInt(), AddHDGHelmholtzEdgeTerms(), GetnEdgecdotMF(), and v_GenMatrix().
◆ GetTraceInverseBoundaryMap()
| Array< OneD, unsigned int > Nektar::LocalRegions::Expansion2D::GetTraceInverseBoundaryMap | ( | int | eid | ) |
Definition at line 2190 of file Expansion2D.cpp.
2191{
2192 int n, j;
2193 int nEdgeCoeffs;
2195
2196 Array<OneD, unsigned int> bmap(nBndCoeffs);
2197 GetBoundaryMap(bmap);
2198
2199 // Map from full system to statically condensed system (i.e reverse
2200 // GetBoundaryMap)
2201 map<int, int> invmap;
2202 for (j = 0; j < nBndCoeffs; ++j)
2203 {
2204 invmap[bmap[j]] = j;
2205 }
2206
2207 // Number of interior edge coefficients
2208 nEdgeCoeffs = GetTraceNcoeffs(eid) - 2;
2209
2211
2212 Array<OneD, unsigned int> edgemaparray(nEdgeCoeffs);
2213 Array<OneD, unsigned int> maparray(nEdgeCoeffs);
2214 Array<OneD, int> signarray(nEdgeCoeffs, 1);
2215 StdRegions::Orientation eOrient = geom->GetEorient(eid);
2216
2217 // maparray is the location of the edge within the matrix
2218 GetTraceInteriorToElementMap(eid, maparray, signarray, eOrient);
2219
2220 for (n = 0; n < nEdgeCoeffs; ++n)
2221 {
2222 edgemaparray[n] = invmap[maparray[n]];
2223 }
2224
2225 return edgemaparray;
2226}
SpatialDomains::Geometry2DSharedPtr GetGeom2D() const
Definition: Expansion2D.h:164
void GetBoundaryMap(Array< OneD, unsigned int > &outarray)
Definition: StdExpansion.h:669
int NumBndryCoeffs(void) const
Definition: StdExpansion.h:322
void GetTraceInteriorToElementMap(const int tid, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray, const Orientation traceOrient=eForwards)
Definition: StdExpansion.h:708
int GetTraceNcoeffs(const int i) const
This function returns the number of expansion coefficients belonging to the i-th trace.
Definition: StdExpansion.h:261
std::shared_ptr< Geometry2D > Geometry2DSharedPtr
Definition: Geometry.h:62
References Nektar::StdRegions::StdExpansion::GetBoundaryMap(), GetGeom2D(), Nektar::StdRegions::StdExpansion::GetTraceInteriorToElementMap(), Nektar::StdRegions::StdExpansion::GetTraceNcoeffs(), and Nektar::StdRegions::StdExpansion::NumBndryCoeffs().
◆ ReOrientEdgePhysMap()
| void Nektar::LocalRegions::Expansion2D::ReOrientEdgePhysMap | ( | const int | nvert, |
| const StdRegions::Orientation | orient, | ||
| const int | nq0, | ||
| Array< OneD, int > & | idmap | ||
| ) |
◆ SetTraceToGeomOrientation()
| void Nektar::LocalRegions::Expansion2D::SetTraceToGeomOrientation | ( | Array< OneD, ExpansionSharedPtr > & | EdgeExp, |
| Array< OneD, NekDouble > & | inout | ||
| ) |
Definition at line 898 of file Expansion2D.cpp.
900{
901 int i, cnt = 0;
903 Array<OneD, NekDouble> e_tmp;
904
905 for (i = 0; i < nedges; ++i)
906 {
907 EdgeExp[i]->SetCoeffsToOrientation(
908 GetTraceOrient(i), e_tmp = inout + cnt, e_tmp = inout + cnt);
909 cnt += GetTraceNcoeffs(i);
910 }
911}
References Nektar::StdRegions::StdExpansion::GetNtraces(), Nektar::StdRegions::StdExpansion::GetTraceNcoeffs(), and Nektar::LocalRegions::Expansion::GetTraceOrient().
Referenced by v_GenMatrix().
◆ v_AddEdgeNormBoundaryInt() [1/2]
|
overrideprotected |
Definition at line 723 of file Expansion2D.cpp.
726{
727 int i;
728
730 {
732 m_requireNeg.resize(nedges);
733
734 for (i = 0; i < nedges; ++i)
735 {
737
739
740 if (edgeExp->GetRightAdjacentElementExp())
741 {
742 if (edgeExp->GetRightAdjacentElementExp()
743 ->GetGeom()
744 ->GetGlobalID() == GetGeom()->GetGlobalID())
745 {
747 }
748 }
749 }
750 }
751
754
756
757 // Order of the element
758 int order_e = map->size();
759 // Order of the trace
760 int n_coeffs = EdgeExp->GetNcoeffs();
761
762 Array<OneD, NekDouble> edgeCoeffs(n_coeffs);
763 if (n_coeffs != order_e) // Going to orthogonal space
764 {
765 EdgeExp->FwdTrans(Fn, edgeCoeffs);
766 Expansion1DSharedPtr locExp = EdgeExp->as<Expansion1D>();
767
769 {
770 Vmath::Neg(n_coeffs, edgeCoeffs, 1);
771 }
772
773 Array<OneD, NekDouble> coeff(n_coeffs, 0.0);
774 LibUtilities::BasisType btype =
776 LibUtilities::BasisKey bkey_ortho(btype,
777 EdgeExp->GetBasis(0)->GetNumModes(),
778 EdgeExp->GetBasis(0)->GetPointsKey());
779 LibUtilities::BasisKey bkey(EdgeExp->GetBasis(0)->GetBasisType(),
780 EdgeExp->GetBasis(0)->GetNumModes(),
781 EdgeExp->GetBasis(0)->GetPointsKey());
782 LibUtilities::InterpCoeff1D(bkey, edgeCoeffs, bkey_ortho, coeff);
783
784 // Cutting high frequencies
785 for (i = order_e; i < n_coeffs; i++)
786 {
787 coeff[i] = 0.0;
788 }
789
790 LibUtilities::InterpCoeff1D(bkey_ortho, coeff, bkey, edgeCoeffs);
791
792 StdRegions::StdMatrixKey masskey(StdRegions::eMass,
793 LibUtilities::eSegment, *EdgeExp);
794 EdgeExp->MassMatrixOp(edgeCoeffs, edgeCoeffs, masskey);
795 }
796 else
797 {
798 EdgeExp->IProductWRTBase(Fn, edgeCoeffs);
799
800 Expansion1DSharedPtr locExp = EdgeExp->as<Expansion1D>();
801
803 {
804 Vmath::Neg(n_coeffs, edgeCoeffs, 1);
805 }
806 }
807
808 // Implementation for all the basis except Gauss points
810 {
811 // add data to outarray if forward edge normal is outwards
812 for (i = 0; i < order_e; ++i)
813 {
814 outarray[(*map)[i].index] += (*map)[i].sign * edgeCoeffs[i];
815 }
816 }
817 else
818 {
819 int nCoeffs0, nCoeffs1;
820 int j;
821
826
828
829 switch (edge)
830 {
831 case 0:
832 {
833 nCoeffs1 = m_base[1]->GetNumModes();
834
835 for (i = 0; i < order_e; ++i)
836 {
837 for (j = 0; j < nCoeffs1; j++)
838 {
839 outarray[(*map)[i].index + j * order_e] +=
840 mat_gauss->GetPtr()[j] * (*map)[i].sign *
841 edgeCoeffs[i];
842 }
843 }
844 break;
845 }
846 case 1:
847 {
848 nCoeffs0 = m_base[0]->GetNumModes();
849
850 for (i = 0; i < order_e; ++i)
851 {
852 for (j = 0; j < nCoeffs0; j++)
853 {
854 outarray[(*map)[i].index - j] +=
855 mat_gauss->GetPtr()[order_e - 1 - j] *
856 (*map)[i].sign * edgeCoeffs[i];
857 }
858 }
859 break;
860 }
861 case 2:
862 {
863 nCoeffs1 = m_base[1]->GetNumModes();
864
865 for (i = 0; i < order_e; ++i)
866 {
867 for (j = 0; j < nCoeffs1; j++)
868 {
869 outarray[(*map)[i].index - j * order_e] +=
870 mat_gauss->GetPtr()[order_e - 1 - j] *
871 (*map)[i].sign * edgeCoeffs[i];
872 }
873 }
874 break;
875 }
876 case 3:
877 {
878 nCoeffs0 = m_base[0]->GetNumModes();
879
880 for (i = 0; i < order_e; ++i)
881 {
882 for (j = 0; j < nCoeffs0; j++)
883 {
884 outarray[(*map)[i].index + j] +=
885 mat_gauss->GetPtr()[j] * (*map)[i].sign *
886 edgeCoeffs[i];
887 }
888 }
889 break;
890 }
891 default:
893 break;
894 }
895 }
896}
std::vector< bool > m_requireNeg
Definition: Expansion2D.h:112
SpatialDomains::GeometrySharedPtr GetGeom() const
Definition: Expansion.cpp:167
std::map< int, ExpansionWeakPtr > m_traceExp
Definition: Expansion.h:272
IndexMapValuesSharedPtr GetIndexMap(const IndexMapKey &ikey)
Definition: Expansion.h:146
LibUtilities::NekManager< StdMatrixKey, DNekMat, StdMatrixKey::opLess > m_stdMatrixManager
Definition: StdExpansion.h:1178
int GetBasisNumModes(const int dir) const
This function returns the number of expansion modes in the dir direction.
Definition: StdExpansion.h:169
void InterpCoeff1D(const BasisKey &fbasis0, const Array< OneD, const NekDouble > &from, const BasisKey &tbasis0, Array< OneD, NekDouble > &to)
Definition: InterpCoeff.cpp:42
std::shared_ptr< Expansion > ExpansionSharedPtr
Definition: Expansion.h:66
std::shared_ptr< IndexMapValues > IndexMapValuesSharedPtr
Definition: IndexMapKey.h:126
std::shared_ptr< Expansion1D > Expansion1DSharedPtr
Definition: Expansion1D.h:50
References ASSERTL0, Nektar::StdRegions::StdExpansion::DetShapeType(), Nektar::LocalRegions::eEdgeToElement, Nektar::StdRegions::eFactorGaussEdge, Nektar::LibUtilities::eGauss_Lagrange, Nektar::StdRegions::eGaussDG, Nektar::StdRegions::eMass, Nektar::LibUtilities::eSegment, Nektar::VarcoeffHashingTest::factors, Nektar::StdRegions::StdExpansion::GetBasisNumModes(), Nektar::LocalRegions::Expansion::GetGeom(), Nektar::LocalRegions::Expansion::GetIndexMap(), Nektar::StdRegions::StdExpansion::GetNtraces(), Nektar::LocalRegions::Expansion::GetTraceOrient(), Nektar::LibUtilities::InterpCoeff1D(), Nektar::StdRegions::StdExpansion::m_base, m_requireNeg, Nektar::StdRegions::StdExpansion::m_stdMatrixManager, Nektar::LocalRegions::Expansion::m_traceExp, and Vmath::Neg().
◆ v_AddEdgeNormBoundaryInt() [2/2]
|
overrideprotected |
Definition at line 665 of file Expansion2D.cpp.
669{
671
672 const Array<OneD, const Array<OneD, NekDouble>> normals =
673 GetTraceNormal(edge);
674
676 {
678 m_requireNeg.resize(nedges);
679
680 for (int i = 0; i < nedges; ++i)
681 {
683
685
686 if (edgeExp->GetRightAdjacentElementExp())
687 {
688 if (edgeExp->GetRightAdjacentElementExp()
689 ->GetGeom()
690 ->GetGlobalID() == GetGeom()->GetGlobalID())
691 {
693 }
694 }
695 }
696 }
697
698 // We allow the case of mixed polynomial order by supporting only
699 // those modes on the edge common to both adjoining elements. This
700 // is enforced here by taking the minimum size and padding with
701 // zeros.
702 int nquad_e = min(EdgeExp->GetNumPoints(0), int(normals[0].size()));
703
704 int nEdgePts = EdgeExp->GetTotPoints();
705 Array<OneD, NekDouble> edgePhys(nEdgePts);
706 Vmath::Vmul(nquad_e, normals[0], 1, Fx, 1, edgePhys, 1);
707 Vmath::Vvtvp(nquad_e, normals[1], 1, Fy, 1, edgePhys, 1, edgePhys, 1);
708
709 Expansion1DSharedPtr locExp = EdgeExp->as<Expansion1D>();
710
712 {
713 if (locExp->GetRightAdjacentElementExp()->GetGeom()->GetGlobalID() ==
714 m_geom->GetGlobalID())
715 {
716 Vmath::Neg(nquad_e, edgePhys, 1);
717 }
718 }
719
720 AddEdgeNormBoundaryInt(edge, EdgeExp, edgePhys, outarray);
721}
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)
Definition: Expansion.cpp:114
References Nektar::LocalRegions::Expansion::AddEdgeNormBoundaryInt(), ASSERTL1, Nektar::StdRegions::StdExpansion::GetCoordim(), Nektar::LocalRegions::Expansion::GetGeom(), Nektar::StdRegions::StdExpansion::GetNtraces(), Nektar::LocalRegions::Expansion::GetTraceNormal(), Nektar::LocalRegions::Expansion::m_geom, m_requireNeg, Nektar::LocalRegions::Expansion::m_traceExp, Vmath::Neg(), Vmath::Vmul(), and Vmath::Vvtvp().
◆ v_AddRobinMassMatrix()
|
overrideprotectedvirtual |
Reimplemented from Nektar::LocalRegions::Expansion.
Definition at line 1986 of file Expansion2D.cpp.
1989{
1991 "Not set up for non boundary-interior expansions");
1992 ASSERTL1(inoutmat->GetRows() == inoutmat->GetColumns(),
1993 "Assuming that input matrix was square");
1994 int i, j;
1995 int id1, id2;
1997 int order_e = edgeExp->GetNcoeffs();
1998
1999 Array<OneD, unsigned int> map;
2000 Array<OneD, int> sign;
2001
2002 StdRegions::VarCoeffMap varcoeffs;
2003 varcoeffs[StdRegions::eVarCoeffMass] = primCoeffs;
2004
2006 *edgeExp, StdRegions::NullConstFactorMap,
2007 varcoeffs);
2008 DNekScalMat &edgemat = *edgeExp->GetLocMatrix(mkey);
2009
2010 // Now need to identify a map which takes the local edge
2011 // mass matrix to the matrix stored in inoutmat;
2012 // This can currently be deduced from the size of the matrix
2013
2014 // - if inoutmat.m_rows() == v_NCoeffs() it is a full
2015 // matrix system
2016
2017 // - if inoutmat.m_rows() == v_NumBndCoeffs() it is a
2018 // boundary CG system
2019
2020 // - if inoutmat.m_rows() == v_NumDGBndCoeffs() it is a
2021 // trace DG system
2022 int rows = inoutmat->GetRows();
2023
2025 {
2027 }
2029 {
2031 Array<OneD, unsigned int> bmap(nbndry);
2032
2034
2035 GetBoundaryMap(bmap);
2036
2037 for (i = 0; i < order_e; ++i)
2038 {
2039 for (j = 0; j < nbndry; ++j)
2040 {
2041 if (map[i] == bmap[j])
2042 {
2043 map[i] = j;
2044 break;
2045 }
2046 }
2048 }
2049 }
2051 {
2052 // possibly this should be a separate method
2053 int cnt = 0;
2054 map = Array<OneD, unsigned int>(order_e);
2055 sign = Array<OneD, int>(order_e, 1);
2056
2057 for (i = 0; i < edge; ++i)
2058 {
2059 cnt += GetTraceNcoeffs(i);
2060 }
2061
2062 for (i = 0; i < order_e; ++i)
2063 {
2064 map[i] = cnt++;
2065 }
2066 // check for mapping reversal
2068 {
2069 switch (edgeExp->GetBasis(0)->GetBasisType())
2070 {
2072 reverse(map.get(), map.get() + order_e);
2073 break;
2075 reverse(map.get(), map.get() + order_e);
2076 break;
2078 {
2079 swap(map[0], map[1]);
2080 for (i = 3; i < order_e; i += 2)
2081 {
2082 sign[i] = -1;
2083 }
2084 }
2085 break;
2086 default:
2088 "Edge boundary type not valid for this method");
2089 }
2090 }
2091 }
2092 else
2093 {
2095 }
2096
2097 for (i = 0; i < order_e; ++i)
2098 {
2099 id1 = map[i];
2100 for (j = 0; j < order_e; ++j)
2101 {
2102 id2 = map[j];
2104 }
2105 }
2106}
int NumDGBndryCoeffs(void) const
Definition: StdExpansion.h:327
bool IsBoundaryInteriorExpansion() const
Definition: StdExpansion.h:387
References ASSERTL0, ASSERTL1, Nektar::StdRegions::eBackwards, Nektar::LibUtilities::eGauss_Lagrange, Nektar::LibUtilities::eGLL_Lagrange, Nektar::StdRegions::eMass, Nektar::LibUtilities::eModified_A, Nektar::LibUtilities::eSegment, Nektar::StdRegions::eVarCoeffMass, Nektar::StdRegions::StdExpansion::GetBoundaryMap(), Nektar::StdRegions::StdExpansion::GetNcoeffs(), Nektar::StdRegions::StdExpansion::GetTraceNcoeffs(), Nektar::LocalRegions::Expansion::GetTraceOrient(), Nektar::StdRegions::StdExpansion::GetTraceToElementMap(), Nektar::StdRegions::StdExpansion::IsBoundaryInteriorExpansion(), Nektar::LocalRegions::Expansion::m_traceExp, Nektar::StdRegions::NullConstFactorMap, Nektar::StdRegions::StdExpansion::NumBndryCoeffs(), Nektar::StdRegions::StdExpansion::NumDGBndryCoeffs(), sign, and Nektar::LocalRegions::Expansion::v_GetTraceOrient().
◆ v_AddRobinTraceContribution()
|
overrideprotectedvirtual |
Given an edge and vector of element coefficients:
- maps those elemental coefficients corresponding to the edge into an edge-vector.
- resets the element coefficients
- multiplies the edge vector by the edge mass matrix
- maps the edge coefficients back onto the elemental coefficients
Reimplemented from Nektar::LocalRegions::Expansion.
Definition at line 2116 of file Expansion2D.cpp.
2119{
2121 "Not set up for non boundary-interior expansions");
2122 int i;
2124 int order_e = edgeExp->GetNcoeffs();
2125
2126 Array<OneD, unsigned int> map;
2127 Array<OneD, int> sign;
2128
2129 StdRegions::VarCoeffMap varcoeffs;
2130 varcoeffs[StdRegions::eVarCoeffMass] = primCoeffs;
2131
2133 *edgeExp, StdRegions::NullConstFactorMap,
2134 varcoeffs);
2135 DNekScalMat &edgemat = *edgeExp->GetLocMatrix(mkey);
2136
2137 NekVector<NekDouble> vEdgeCoeffs(order_e);
2138
2140
2141 for (i = 0; i < order_e; ++i)
2142 {
2143 vEdgeCoeffs[i] = incoeffs[map[i]] * sign[i];
2144 }
2145
2146 vEdgeCoeffs = edgemat * vEdgeCoeffs;
2147
2148 for (i = 0; i < order_e; ++i)
2149 {
2150 coeffs[map[i]] += vEdgeCoeffs[i] * sign[i];
2151 }
2152}
References ASSERTL1, Nektar::StdRegions::eMass, Nektar::LibUtilities::eSegment, Nektar::StdRegions::eVarCoeffMass, Nektar::StdRegions::StdExpansion::GetTraceToElementMap(), Nektar::StdRegions::StdExpansion::IsBoundaryInteriorExpansion(), Nektar::LocalRegions::Expansion::m_traceExp, Nektar::StdRegions::NullConstFactorMap, sign, and Nektar::LocalRegions::Expansion::v_GetTraceOrient().
◆ v_BuildVertexMatrix()
|
overrideprotectedvirtual |
Reimplemented from Nektar::LocalRegions::Expansion.
Definition at line 2154 of file Expansion2D.cpp.
2156{
2158 DNekMatSharedPtr m_vertexmatrix;
2159
2160 int nVerts, vid1, vid2, vMap1, vMap2;
2161 NekDouble VertexValue;
2162
2163 nVerts = GetNverts();
2164
2165 m_vertexmatrix =
2166 MemoryManager<DNekMat>::AllocateSharedPtr(nVerts, nVerts, 0.0, storage);
2167 DNekMat &VertexMat = (*m_vertexmatrix);
2168
2169 for (vid1 = 0; vid1 < nVerts; ++vid1)
2170 {
2171 vMap1 = GetVertexMap(vid1);
2172
2173 for (vid2 = 0; vid2 < nVerts; ++vid2)
2174 {
2175 vMap2 = GetVertexMap(vid2);
2176 VertexValue = (*r_bnd)(vMap1, vMap2);
2177 VertexMat.SetValue(vid1, vid2, VertexValue);
2178 }
2179 }
2180
2181 return m_vertexmatrix;
2182}
int GetVertexMap(const int localVertexId, bool useCoeffPacking=false)
Definition: StdExpansion.h:679
int GetNverts() const
This function returns the number of vertices of the expansion domain.
Definition: StdExpansion.h:246
References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::eFULL, Nektar::StdRegions::StdExpansion::GetNverts(), and Nektar::StdRegions::StdExpansion::GetVertexMap().
◆ v_DGDeriv()
|
overrideprotectedvirtual |
Reimplemented from Nektar::LocalRegions::Expansion.
Definition at line 1949 of file Expansion2D.cpp.
1954{
1956 StdRegions::eWeakDeriv1,
1957 StdRegions::eWeakDeriv2};
1958
1960
1963
1964 Array<OneD, NekDouble> coeffs = incoeffs;
1966
1967 Coeffs = Transpose(Dmat) * Coeffs;
1968 Vmath::Neg(ncoeffs, coeffs, 1);
1969
1970 // Add the boundary integral including the relevant part of
1971 // the normal
1972 AddNormTraceInt(dir, EdgeExp, edgeCoeffs, coeffs);
1973
1975
1976 Out_d = InvMass * Coeffs;
1977}
void AddNormTraceInt(const int dir, Array< OneD, ExpansionSharedPtr > &EdgeExp, Array< OneD, Array< OneD, NekDouble > > &edgeCoeffs, Array< OneD, NekDouble > &outarray)
Definition: Expansion2D.cpp:977
References AddNormTraceInt(), Nektar::StdRegions::eInvMass, Nektar::StdRegions::eWeakDeriv0, Nektar::StdRegions::eWeakDeriv1, Nektar::StdRegions::eWeakDeriv2, Nektar::eWrapper, Nektar::LocalRegions::Expansion::GetLocMatrix(), Nektar::StdRegions::StdExpansion::GetNcoeffs(), Vmath::Neg(), and Nektar::Transpose().
◆ v_GenMatrix()
|
overridevirtual |
Computes matrices needed for the HDG formulation. References to equations relate to the following paper: R. M. Kirby, S. J. Sherwin, B. Cockburn, To CG or to HDG: A Comparative Study, J. Sci. Comp P1-30 DOI 10.1007/s10915-011-9501-7
TODO: Add variable coeffs
Reimplemented from Nektar::StdRegions::StdExpansion.
Reimplemented in Nektar::LocalRegions::NodalTriExp, Nektar::LocalRegions::QuadExp, and Nektar::LocalRegions::TriExp.
Definition at line 1256 of file Expansion2D.cpp.
1257{
1258 DNekMatSharedPtr returnval;
1259
1260 switch (mkey.GetMatrixType())
1261 {
1262 // (Z^e)^{-1} (Eqn. 33, P22)
1264 {
1266 "HybridDGHelmholtz matrix not set up "
1267 "for non boundary-interior expansions");
1268
1269 int i, j, k;
1270 NekDouble lambdaval =
1271 mkey.GetConstFactor(StdRegions::eFactorLambda);
1275 int shapedim = 2;
1277 bool mmf =
1278 (varcoeffs.find(StdRegions::eVarCoeffMF1x) != varcoeffs.end());
1279
1280 Array<OneD, unsigned int> emap;
1281 Array<OneD, int> sign;
1283 ExpansionSharedPtr EdgeExp;
1284
1288 StdRegions::eWeakDeriv1,
1289 StdRegions::eWeakDeriv2};
1290 DNekMat LocMat(ncoeffs, ncoeffs);
1291
1292 returnval =
1293 MemoryManager<DNekMat>::AllocateSharedPtr(ncoeffs, ncoeffs);
1294 DNekMat &Mat = *returnval;
1295 Vmath::Zero(ncoeffs * ncoeffs, Mat.GetPtr(), 1);
1296
1298 StdRegions::eVarCoeffD11,
1299 StdRegions::eVarCoeffD22};
1300
1301 StdRegions::VarCoeffMap::const_iterator x;
1302
1303 for (i = 0; i < coordim; ++i)
1304 {
1305 if (mmf)
1306 {
1307 if (i < shapedim)
1308 {
1309 StdRegions::VarCoeffMap VarCoeffDirDeriv;
1310 VarCoeffDirDeriv[StdRegions::eVarCoeffMF] =
1311 GetMF(i, shapedim, varcoeffs);
1312 VarCoeffDirDeriv[StdRegions::eVarCoeffMFDiv] =
1313 GetMFDiv(i, varcoeffs);
1314
1315 MatrixKey Dmatkey(StdRegions::eWeakDirectionalDeriv,
1318 VarCoeffDirDeriv);
1319
1321
1322 StdRegions::VarCoeffMap Weight;
1323 Weight[StdRegions::eVarCoeffMass] =
1324 GetMFMag(i, mkey.GetVarCoeffs());
1325
1326 MatrixKey invMasskey(
1328 StdRegions::NullConstFactorMap, Weight);
1329
1331
1332 Mat = Mat + Dmat * invMass * Transpose(Dmat);
1333 }
1334 }
1335 else if (mkey.HasVarCoeff(Coeffs[i]))
1336 {
1339 mkey.GetVarCoeffAsMap(Coeffs[i]));
1340
1342
1345 Mat = Mat + DmatL * invMass * Transpose(DmatR);
1346 }
1347 else
1348 {
1350 Mat = Mat + Dmat * invMass * Transpose(Dmat);
1351 }
1352 }
1353
1354 // Add Mass Matrix Contribution for Helmholtz problem
1356 Mat = Mat + lambdaval * Mass;
1357
1358 // Add tau*E_l using elemental mass matrices on each edge
1359 for (i = 0; i < nedges; ++i)
1360 {
1361 EdgeExp = GetTraceExp(i);
1362 order_e = EdgeExp->GetNcoeffs();
1363
1364 int nq = EdgeExp->GetNumPoints(0);
1366
1367 // @TODO: Document
1368 StdRegions::VarCoeffMap edgeVarCoeffs;
1370 {
1371 Array<OneD, NekDouble> mu(nq);
1373 i, EdgeExp, mkey.GetVarCoeff(StdRegions::eVarCoeffD00),
1374 mu);
1375 edgeVarCoeffs[StdRegions::eVarCoeffMass] = mu;
1376 }
1379 edgeVarCoeffs);
1380 // DNekScalMat &eMass =
1381 // *EdgeExp->GetLocMatrix(StdRegions::eMass);
1382
1383 for (j = 0; j < order_e; ++j)
1384 {
1385 for (k = 0; k < order_e; ++k)
1386 {
1387 Mat(emap[j], emap[k]) =
1388 Mat(emap[j], emap[k]) +
1390 }
1391 }
1392 }
1393 }
1394 break;
1395 // U^e (P22)
1397 {
1398 int i, j, k;
1403
1404 Array<OneD, NekDouble> lambda(nbndry);
1406 Array<OneD, NekDouble> ulam(ncoeffs);
1408 Array<OneD, NekDouble> f(ncoeffs);
1410
1411 Array<OneD, ExpansionSharedPtr> EdgeExp(nedges);
1412 // declare matrix space
1413 returnval =
1414 MemoryManager<DNekMat>::AllocateSharedPtr(ncoeffs, nbndry);
1415 DNekMat &Umat = *returnval;
1416
1417 // Z^e matrix
1419 *this, mkey.GetConstFactors(),
1420 mkey.GetVarCoeffs());
1422
1423 Array<OneD, unsigned int> emap;
1424 Array<OneD, int> sign;
1425
1426 for (i = 0; i < nedges; ++i)
1427 {
1428 EdgeExp[i] = GetTraceExp(i);
1429 }
1430
1431 // for each degree of freedom of the lambda space
1432 // calculate Umat entry
1433 // Generate Lambda to U_lambda matrix
1434 for (j = 0; j < nbndry; ++j)
1435 {
1436 // standard basis vectors e_j
1437 Vmath::Zero(nbndry, &lambda[0], 1);
1438 Vmath::Zero(ncoeffs, &f[0], 1);
1439 lambda[j] = 1.0;
1440
1441 SetTraceToGeomOrientation(EdgeExp, lambda);
1442
1443 // Compute F = [I D_1 M^{-1} D_2 M^{-1}] C e_j
1444 AddHDGHelmholtzTraceTerms(tau, lambda, EdgeExp,
1445 mkey.GetVarCoeffs(), f);
1446
1447 // Compute U^e_j
1448 Ulam = invHmat * F; // generate Ulam from lambda
1449
1450 // fill column of matrix
1451 for (k = 0; k < ncoeffs; ++k)
1452 {
1453 Umat(k, j) = Ulam[k];
1454 }
1455 }
1456 }
1457 break;
1458 // Q_0, Q_1, Q_2 matrices (P23)
1459 // Each are a product of a row of Eqn 32 with the C matrix.
1460 // Rather than explicitly computing all of Eqn 32, we note each
1461 // row is almost a multiple of U^e, so use that as our starting
1462 // point.
1466 {
1467 int i = 0;
1468 int j = 0;
1469 int k = 0;
1470 int dir = 0;
1474 int shapedim = 2;
1475
1476 Array<OneD, NekDouble> lambda(nbndry);
1478 Array<OneD, ExpansionSharedPtr> EdgeExp(nedges);
1479
1480 Array<OneD, NekDouble> ulam(ncoeffs);
1482 Array<OneD, NekDouble> f(ncoeffs);
1484
1485 // declare matrix space
1486 returnval =
1487 MemoryManager<DNekMat>::AllocateSharedPtr(ncoeffs, nbndry);
1488 DNekMat &Qmat = *returnval;
1489
1490 // Lambda to U matrix
1492 *this, mkey.GetConstFactors(),
1493 mkey.GetVarCoeffs());
1495
1496 // Inverse mass matrix
1498
1499 for (i = 0; i < nedges; ++i)
1500 {
1501 EdgeExp[i] = GetTraceExp(i);
1502 }
1503
1504 // Weak Derivative matrix
1505 DNekScalMatSharedPtr Dmat;
1506 switch (mkey.GetMatrixType())
1507 {
1509 dir = 0;
1511 break;
1513 dir = 1;
1515 break;
1517 dir = 2;
1519 break;
1520 default:
1522 break;
1523 }
1524
1527 {
1528 StdRegions::VarCoeffMap VarCoeffDirDeriv;
1529 VarCoeffDirDeriv[StdRegions::eVarCoeffMF] =
1530 GetMF(dir, shapedim, varcoeffs);
1531 VarCoeffDirDeriv[StdRegions::eVarCoeffMFDiv] =
1532 GetMFDiv(dir, varcoeffs);
1533
1534 MatrixKey Dmatkey(
1536 StdRegions::NullConstFactorMap, VarCoeffDirDeriv);
1537
1538 Dmat = GetLocMatrix(Dmatkey);
1539
1540 StdRegions::VarCoeffMap Weight;
1541 Weight[StdRegions::eVarCoeffMass] =
1542 GetMFMag(dir, mkey.GetVarCoeffs());
1543
1546 Weight);
1547
1548 invMass = *GetLocMatrix(invMasskey);
1549 }
1550 else
1551 {
1553 StdRegions::eWeakDeriv1,
1554 StdRegions::eWeakDeriv2};
1555
1556 Dmat = GetLocMatrix(DerivType[dir]);
1557
1559 *this);
1560 invMass = *GetLocMatrix(invMasskey);
1561 }
1562
1563 // for each degree of freedom of the lambda space
1564 // calculate Qmat entry
1565 // Generate Lambda to Q_lambda matrix
1566 for (j = 0; j < nbndry; ++j)
1567 {
1568 Vmath::Zero(nbndry, &lambda[0], 1);
1569 lambda[j] = 1.0;
1570
1571 // for lambda[j] = 1 this is the solution to ulam
1572 for (k = 0; k < ncoeffs; ++k)
1573 {
1574 Ulam[k] = lamToU(k, j);
1575 }
1576
1577 // -D^T ulam
1578 Vmath::Neg(ncoeffs, &ulam[0], 1);
1579 F = Transpose(*Dmat) * Ulam;
1580
1581 SetTraceToGeomOrientation(EdgeExp, lambda);
1582
1583 // Add the C terms resulting from the I's on the
1584 // diagonals of Eqn 32
1585 AddNormTraceInt(dir, lambda, EdgeExp, f, mkey.GetVarCoeffs());
1586
1587 // finally multiply by inverse mass matrix
1588 Ulam = invMass * F;
1589
1590 // fill column of matrix (Qmat is in column major format)
1591 Vmath::Vcopy(ncoeffs, &ulam[0], 1,
1592 &(Qmat.GetPtr())[0] + j * ncoeffs, 1);
1593 }
1594 }
1595 break;
1596 // Matrix K (P23)
1598 {
1599 int i, j, e, cnt;
1600 int order_e, nquad_e;
1605 StdRegions::VarCoeffMap::const_iterator x;
1607 bool mmf =
1608 (varcoeffs.find(StdRegions::eVarCoeffMF1x) != varcoeffs.end());
1609
1610 Array<OneD, NekDouble> work, varcoeff_work;
1611 Array<OneD, const Array<OneD, NekDouble>> normals;
1612 Array<OneD, ExpansionSharedPtr> EdgeExp(nedges);
1613 Array<OneD, NekDouble> lam(nbndry);
1614
1615 Array<OneD, unsigned int> emap;
1616 Array<OneD, int> sign;
1617 StdRegions::Orientation edgedir;
1618
1619 // declare matrix space
1620 returnval =
1621 MemoryManager<DNekMat>::AllocateSharedPtr(nbndry, nbndry);
1622 DNekMat &BndMat = *returnval;
1623
1624 DNekScalMatSharedPtr LamToQ[3];
1625
1626 // Matrix to map Lambda to U
1628 *this, mkey.GetConstFactors(),
1629 mkey.GetVarCoeffs());
1631
1632 // Matrix to map Lambda to Q0
1634 *this, mkey.GetConstFactors(),
1635 mkey.GetVarCoeffs());
1636 LamToQ[0] = GetLocMatrix(LamToQ0key);
1637
1638 // Matrix to map Lambda to Q1
1640 *this, mkey.GetConstFactors(),
1641 mkey.GetVarCoeffs());
1642 LamToQ[1] = GetLocMatrix(LamToQ1key);
1643
1644 // Matrix to map Lambda to Q2 for 3D coordinates
1645 if (coordim == 3)
1646 {
1647 MatrixKey LamToQ2key(
1649 mkey.GetConstFactors(), mkey.GetVarCoeffs());
1650 LamToQ[2] = GetLocMatrix(LamToQ2key);
1651 }
1652
1653 // Set up edge segment expansions from local geom info
1654 for (i = 0; i < nedges; ++i)
1655 {
1656 EdgeExp[i] = GetTraceExp(i);
1657 }
1658
1659 // Set up matrix derived from <mu, Q_lam.n - \tau (U_lam - Lam) >
1660 for (i = 0; i < nbndry; ++i)
1661 {
1662 cnt = 0;
1663
1664 Vmath::Zero(nbndry, lam, 1);
1665 lam[i] = 1.0;
1666 SetTraceToGeomOrientation(EdgeExp, lam);
1667
1668 for (e = 0; e < nedges; ++e)
1669 {
1670 order_e = EdgeExp[e]->GetNcoeffs();
1671 nquad_e = EdgeExp[e]->GetNumPoints(0);
1672
1673 normals = GetTraceNormal(e);
1674 edgedir = GetTraceOrient(e);
1675
1676 work = Array<OneD, NekDouble>(nquad_e);
1677 varcoeff_work = Array<OneD, NekDouble>(nquad_e);
1678
1680
1681 StdRegions::VarCoeffType VarCoeff[3] = {
1683 StdRegions::eVarCoeffD22};
1684
1685 // Q0 * n0 (BQ_0 terms)
1686 Array<OneD, NekDouble> edgeCoeffs(order_e);
1687 Array<OneD, NekDouble> edgePhys(nquad_e);
1688 for (j = 0; j < order_e; ++j)
1689 {
1690 edgeCoeffs[j] = sign[j] * (*LamToQ[0])(emap[j], i);
1691 }
1692
1693 EdgeExp[e]->BwdTrans(edgeCoeffs, edgePhys);
1694 // @TODO Var coeffs
1695 // Multiply by variable coefficient
1696 // if ((x =
1697 // varcoeffs.find(VarCoeff[0]))
1698 // != varcoeffs.end())
1699 // {
1700 // GetPhysEdgeVarCoeffsFromElement(e,EdgeExp[e],x->second,varcoeff_work);
1701 // Vmath::Vmul(nquad_e,varcoeff_work,1,EdgeExp[e]->GetPhys(),1,EdgeExp[e]->UpdatePhys(),1);
1702 // }
1703 if (mmf)
1704 {
1705 Array<OneD, NekDouble> ncdotMF = GetnEdgecdotMF(
1706 0, e, EdgeExp[e], normals, varcoeffs);
1707 Vmath::Vmul(nquad_e, ncdotMF, 1, edgePhys, 1, work, 1);
1708 }
1709 else
1710 {
1711 Vmath::Vmul(nquad_e, normals[0], 1, edgePhys, 1, work,
1712 1);
1713 }
1714
1715 // Q1 * n1 (BQ_1 terms)
1716 for (j = 0; j < order_e; ++j)
1717 {
1718 edgeCoeffs[j] = sign[j] * (*LamToQ[1])(emap[j], i);
1719 }
1720
1721 EdgeExp[e]->BwdTrans(edgeCoeffs, edgePhys);
1722
1723 // @TODO var coeffs
1724 // Multiply by variable coefficients
1725 // if ((x =
1726 // varcoeffs.find(VarCoeff[1]))
1727 // != varcoeffs.end())
1728 // {
1729 // GetPhysEdgeVarCoeffsFromElement(e,EdgeExp[e],x->second,varcoeff_work);
1730 // Vmath::Vmul(nquad_e,varcoeff_work,1,EdgeExp[e]->GetPhys(),1,EdgeExp[e]->UpdatePhys(),1);
1731 // }
1732
1733 if (mmf)
1734 {
1735 Array<OneD, NekDouble> ncdotMF = GetnEdgecdotMF(
1736 1, e, EdgeExp[e], normals, varcoeffs);
1737 Vmath::Vvtvp(nquad_e, ncdotMF, 1, edgePhys, 1, work, 1,
1738 work, 1);
1739 }
1740 else
1741 {
1742 Vmath::Vvtvp(nquad_e, normals[1], 1, edgePhys, 1, work,
1743 1, work, 1);
1744 }
1745
1746 // Q2 * n2 (BQ_2 terms)
1747 if (coordim == 3)
1748 {
1749 for (j = 0; j < order_e; ++j)
1750 {
1751 edgeCoeffs[j] = sign[j] * (*LamToQ[2])(emap[j], i);
1752 }
1753
1754 EdgeExp[e]->BwdTrans(edgeCoeffs, edgePhys);
1755 // @TODO var coeffs
1756 // Multiply by variable coefficients
1757 // if ((x =
1758 // varcoeffs.find(VarCoeff[2]))
1759 // != varcoeffs.end())
1760 // {
1761 // GetPhysEdgeVarCoeffsFromElement(e,EdgeExp[e],x->second,varcoeff_work);
1762 // Vmath::Vmul(nquad_e,varcoeff_work,1,EdgeExp[e]->GetPhys(),1,EdgeExp[e]->UpdatePhys(),1);
1763 // }
1764
1765 Vmath::Vvtvp(nquad_e, normals[2], 1, edgePhys, 1, work,
1766 1, work, 1);
1767 }
1768
1769 // - tau (ulam - lam)
1770 // Corresponds to the G and BU terms.
1771 for (j = 0; j < order_e; ++j)
1772 {
1773 edgeCoeffs[j] =
1774 sign[j] * LamToU(emap[j], i) - lam[cnt + j];
1775 }
1776
1777 EdgeExp[e]->BwdTrans(edgeCoeffs, edgePhys);
1778
1779 // Multiply by variable coefficients
1780 if ((x = varcoeffs.find(VarCoeff[0])) != varcoeffs.end())
1781 {
1783 e, EdgeExp[e], x->second.GetValue(), varcoeff_work);
1784 Vmath::Vmul(nquad_e, varcoeff_work, 1, edgePhys, 1,
1785 edgePhys, 1);
1786 }
1787
1788 Vmath::Svtvp(nquad_e, -tau, edgePhys, 1, work, 1, work, 1);
1789 /// TODO: Add variable coeffs
1790 EdgeExp[e]->IProductWRTBase(work, edgeCoeffs);
1791
1792 EdgeExp[e]->SetCoeffsToOrientation(edgedir, edgeCoeffs,
1793 edgeCoeffs);
1794
1795 for (j = 0; j < order_e; ++j)
1796 {
1797 BndMat(cnt + j, i) = edgeCoeffs[j];
1798 }
1799
1800 cnt += order_e;
1801 }
1802 }
1803 }
1804 break;
1805 // HDG postprocessing
1807 {
1809 mkey.GetConstFactors(), mkey.GetVarCoeffs());
1811
1812 returnval = MemoryManager<DNekMat>::AllocateSharedPtr(
1813 LapMat.GetRows(), LapMat.GetColumns());
1814 DNekMatSharedPtr lmat = returnval;
1815
1816 (*lmat) = LapMat;
1817
1818 // replace first column with inner product wrt 1
1820 Array<OneD, NekDouble> tmp(nq);
1821 Array<OneD, NekDouble> outarray(m_ncoeffs);
1822 Vmath::Fill(nq, 1.0, tmp, 1);
1823 IProductWRTBase(tmp, outarray);
1824
1826 lmat->Invert();
1827 }
1828 break;
1830 {
1834 Array<OneD, const Array<OneD, NekDouble>> normals;
1835 Array<OneD, NekDouble> phys(nphys);
1836 returnval =
1838 DNekMat &Mat = *returnval;
1840
1841 Array<OneD, Array<OneD, NekDouble>> Deriv(3, NullNekDouble1DArray);
1842
1844 {
1845 Deriv[d] = Array<OneD, NekDouble>(nphys);
1846 }
1847
1848 Array<OneD, int> tracepts(ntraces);
1849 Array<OneD, ExpansionSharedPtr> traceExp(ntraces);
1850 int maxtpts = 0;
1851 for (int t = 0; t < ntraces; ++t)
1852 {
1853 traceExp[t] = GetTraceExp(t);
1854 tracepts[t] = traceExp[t]->GetTotPoints();
1855 maxtpts = (maxtpts > tracepts[t]) ? maxtpts : tracepts[t];
1856 }
1857
1858 Array<OneD, NekDouble> val(maxtpts), tmp, tmp1;
1859
1860 Array<OneD, Array<OneD, NekDouble>> dphidn(ntraces);
1861 for (int t = 0; t < ntraces; ++t)
1862 {
1863 dphidn[t] =
1864 Array<OneD, NekDouble>(m_ncoeffs * tracepts[t], 0.0);
1865 }
1866
1868 {
1869 FillMode(i, phys);
1870 PhysDeriv(phys, Deriv[0], Deriv[1], Deriv[2]);
1871
1872 for (int t = 0; t < ntraces; ++t)
1873 {
1875
1876 LibUtilities::BasisKey fromkey = GetTraceBasisKey(t);
1877 LibUtilities::BasisKey tokey =
1878 traceExp[t]->GetBasis(0)->GetBasisKey();
1879 bool DoInterp = (fromkey != tokey);
1880
1881 Array<OneD, NekDouble> n(tracepts[t]);
1882 ;
1884 {
1885 // if variable p may need to interpolate
1886 if (DoInterp)
1887 {
1889 }
1890 else
1891 {
1892 n = norm[d];
1893 }
1894
1896 v_GetTraceOrient(t));
1897
1898 Vmath::Vvtvp(tracepts[t], n, 1, val, 1,
1899 tmp = dphidn[t] + i * tracepts[t], 1,
1900 tmp1 = dphidn[t] + i * tracepts[t], 1);
1901 }
1902 }
1903 }
1904
1905 for (int t = 0; t < ntraces; ++t)
1906 {
1907 int nt = tracepts[t];
1910
1911 // scaling from GJP paper
1912 NekDouble scale =
1914
1916 {
1918 {
1919 Vmath::Vmul(nt, dphidn[t] + i * nt, 1,
1920 dphidn[t] + j * nt, 1, val, 1);
1921 Mat(i, j) =
1922 Mat(i, j) + scale * traceExp[t]->Integral(val);
1923 }
1924 }
1925 }
1926
1927 // fill in symmetric components.
1929 {
1930 for (int j = 0; j < i; ++j)
1931 {
1932 Mat(i, j) = Mat(j, i);
1933 }
1934 }
1935 }
1936 break;
1937 default:
1939 "This matrix type cannot be generated from this class");
1940 break;
1941 }
1942
1943 return returnval;
1944}
void SetTraceToGeomOrientation(Array< OneD, ExpansionSharedPtr > &EdgeExp, Array< OneD, NekDouble > &inout)
Definition: Expansion2D.cpp:898
void AddHDGHelmholtzTraceTerms(const NekDouble tau, const Array< OneD, const NekDouble > &inarray, Array< OneD, ExpansionSharedPtr > &EdgeExp, const StdRegions::VarCoeffMap &dirForcing, Array< OneD, NekDouble > &outarray)
Definition: Expansion2D.cpp:1046
void GetTracePhysVals(const int trace, const StdRegions::StdExpansionSharedPtr &TraceExp, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, StdRegions::Orientation orient=StdRegions::eNoOrientation)
Definition: Expansion.h:200
ExpansionSharedPtr GetTraceExp(const int traceid)
Definition: Expansion.h:414
void TraceNormLen(const int traceid, NekDouble &h, NekDouble &p)
Definition: Expansion.h:250
void FillMode(const int mode, Array< OneD, NekDouble > &outarray)
This function fills the array outarray with the mode-th mode of the expansion.
Definition: StdExpansion.h:491
const LibUtilities::BasisKey GetTraceBasisKey(const int i, int k=-1) const
This function returns the basis key belonging to the i-th trace.
Definition: StdExpansion.h:299
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 expa...
Definition: StdExpansion.h:528
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:849
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:47
Array< OneD, Array< OneD, NekDouble > > NormalVector
Definition: Expansion.h:53
std::vector< double > d(NPUPPER *NPUPPER)
static Array< OneD, NekDouble > NullNekDouble1DArray
Definition: BasicUtils/SharedArray.hpp:927
void Fill(int n, const T alpha, T *x, const int incx)
Fill a vector with a constant value.
Definition: Vmath.hpp:54
References AddHDGHelmholtzTraceTerms(), AddNormTraceInt(), Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, ASSERTL1, Nektar::UnitTests::d(), Nektar::StdRegions::StdExpansion::DetShapeType(), Nektar::StdRegions::eFactorLambda, Nektar::StdRegions::eFactorTau, Nektar::StdRegions::eForwards, Nektar::StdRegions::eHybridDGHelmBndLam, Nektar::StdRegions::eHybridDGHelmholtz, Nektar::StdRegions::eHybridDGLamToQ0, Nektar::StdRegions::eHybridDGLamToQ1, Nektar::StdRegions::eHybridDGLamToQ2, Nektar::StdRegions::eHybridDGLamToU, Nektar::StdRegions::eInvHybridDGHelmholtz, Nektar::StdRegions::eInvLaplacianWithUnityMean, Nektar::StdRegions::eInvMass, Nektar::StdRegions::eLaplacian, Nektar::StdRegions::eMass, Nektar::StdRegions::eNormDerivOnTrace, Nektar::StdRegions::eVarCoeffD00, Nektar::StdRegions::eVarCoeffD11, Nektar::StdRegions::eVarCoeffD22, Nektar::StdRegions::eVarCoeffMass, Nektar::StdRegions::eVarCoeffMF, Nektar::StdRegions::eVarCoeffMF1x, Nektar::StdRegions::eVarCoeffMFDiv, Nektar::StdRegions::eWeakDeriv0, Nektar::StdRegions::eWeakDeriv1, Nektar::StdRegions::eWeakDeriv2, Nektar::StdRegions::eWeakDirectionalDeriv, Nektar::eWrapper, Vmath::Fill(), Nektar::StdRegions::StdExpansion::FillMode(), Nektar::StdRegions::StdMatrixKey::GetConstFactor(), Nektar::StdRegions::StdMatrixKey::GetConstFactors(), Nektar::StdRegions::StdExpansion::GetCoordim(), Nektar::LocalRegions::Expansion::GetLocMatrix(), Nektar::StdRegions::StdMatrixKey::GetMatrixType(), Nektar::LocalRegions::Expansion::GetMF(), Nektar::LocalRegions::Expansion::GetMFDiv(), Nektar::LocalRegions::Expansion::GetMFMag(), Nektar::StdRegions::StdExpansion::GetNcoeffs(), GetnEdgecdotMF(), Nektar::StdRegions::StdExpansion::GetNtraces(), GetPhysEdgeVarCoeffsFromElement(), Nektar::StdRegions::StdExpansion::GetTotPoints(), Nektar::StdRegions::StdExpansion::GetTraceBasisKey(), Nektar::LocalRegions::Expansion::GetTraceExp(), Nektar::LocalRegions::Expansion::GetTraceNormal(), Nektar::LocalRegions::Expansion::GetTraceOrient(), Nektar::LocalRegions::Expansion::GetTracePhysVals(), Nektar::StdRegions::StdExpansion::GetTraceToElementMap(), Nektar::StdRegions::StdMatrixKey::GetVarCoeff(), Nektar::StdRegions::StdMatrixKey::GetVarCoeffAsMap(), Nektar::StdRegions::StdMatrixKey::GetVarCoeffs(), Nektar::StdRegions::StdMatrixKey::HasVarCoeff(), Nektar::LibUtilities::Interp1D(), Nektar::StdRegions::StdExpansion::IProductWRTBase(), Nektar::StdRegions::StdExpansion::IsBoundaryInteriorExpansion(), Nektar::StdRegions::StdExpansion::m_ncoeffs, Vmath::Neg(), Nektar::StdRegions::NullConstFactorMap, Nektar::NullNekDouble1DArray, Nektar::StdRegions::StdExpansion::NumDGBndryCoeffs(), CellMLToNektar.cellml_metadata::p, Nektar::StdRegions::StdExpansion::PhysDeriv(), SetTraceToGeomOrientation(), sign, Vmath::Svtvp(), Nektar::LocalRegions::Expansion::TraceNormLen(), Nektar::Transpose(), Nektar::LocalRegions::Expansion::v_GetTraceOrient(), Vmath::Vcopy(), Vmath::Vmul(), Vmath::Vvtvp(), and Vmath::Zero().
Referenced by CreateMatrix(), Nektar::LocalRegions::NodalTriExp::v_GenMatrix(), Nektar::LocalRegions::QuadExp::v_GenMatrix(), and Nektar::LocalRegions::TriExp::v_GenMatrix().
◆ v_GenTraceExp()
|
overridevirtual |
Reimplemented from Nektar::LocalRegions::Expansion.
Definition at line 2184 of file Expansion2D.cpp.
2185{
2188}
References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::StdRegions::StdExpansion::GetTraceBasisKey(), and Nektar::LocalRegions::Expansion::m_geom.
◆ v_ReOrientTracePhysMap()
|
overrideprotectedvirtual |
Reimplemented from Nektar::LocalRegions::Expansion.
Definition at line 2233 of file Expansion2D.cpp.
2236{
2237 if (idmap.size() != nq0)
2238 {
2239 idmap = Array<OneD, int>(nq0);
2240 }
2241 switch (orient)
2242 {
2244 // Fwd
2245 for (int i = 0; i < nq0; ++i)
2246 {
2247 idmap[i] = i;
2248 }
2249 break;
2251 {
2252 // Bwd
2253 for (int i = 0; i < nq0; ++i)
2254 {
2255 idmap[i] = nq0 - 1 - i;
2256 }
2257 }
2258 break;
2259 default:
2261 break;
2262 }
2263}
References ASSERTL0, Nektar::StdRegions::eBackwards, and Nektar::StdRegions::eForwards.
◆ v_SetUpPhysNormals()
|
overrideprotectedvirtual |
Reimplemented from Nektar::LocalRegions::Expansion.
Definition at line 2228 of file Expansion2D.cpp.
2229{
2230 v_ComputeTraceNormal(edge);
2231}
virtual void v_ComputeTraceNormal(const int id)
Definition: Expansion.cpp:868
References Nektar::LocalRegions::Expansion::v_ComputeTraceNormal().
◆ v_TraceNormLen()
|
overrideprotectedvirtual |
Reimplemented from Nektar::LocalRegions::Expansion.
Definition at line 2321 of file Expansion2D.cpp.
2322{
2324
2325 int nverts = geom->GetNumVerts();
2326
2327 // vertices on edges
2328 SpatialDomains::PointGeom ev0 = *geom->GetVertex(traceid);
2329 SpatialDomains::PointGeom ev1 = *geom->GetVertex((traceid + 1) % nverts);
2330
2331 // vertex on adjacent edge to ev0
2332 SpatialDomains::PointGeom vadj =
2333 *geom->GetVertex((traceid + (nverts - 1)) % nverts);
2334
2335 // calculate perpendicular distance of normal length
2336 // from first vertex
2337 NekDouble h1 = ev0.dist(vadj);
2338 SpatialDomains::PointGeom Dx, Dx1;
2339
2340 Dx.Sub(ev1, ev0);
2341 Dx1.Sub(vadj, ev0);
2342
2343 NekDouble d1 = Dx.dot(Dx1);
2344 NekDouble lenDx = Dx.dot(Dx);
2345 h = sqrt(h1 * h1 - d1 * d1 / lenDx);
2346
2347 // perpendicular distanace from second vertex
2348 SpatialDomains::PointGeom vadj1 = *geom->GetVertex((traceid + 2) % nverts);
2349
2350 h1 = ev1.dist(vadj1);
2351 Dx1.Sub(vadj1, ev1);
2352 d1 = Dx.dot(Dx1);
2353
2354 h = (h + sqrt(h1 * h1 - d1 * d1 / lenDx)) * 0.5;
2355
2356 int dirn = (geom->GetDir(traceid) == 0) ? 1 : 0;
2357
2359}
std::shared_ptr< Geometry > GeometrySharedPtr
Definition: Geometry.h:51
References Nektar::SpatialDomains::PointGeom::dist(), Nektar::SpatialDomains::PointGeom::dot(), Nektar::StdRegions::StdExpansion::GetBasisNumModes(), Nektar::LocalRegions::Expansion::GetGeom(), Nektar::SpatialDomains::Geometry::GetVertex(), CellMLToNektar.cellml_metadata::p, tinysimd::sqrt(), and Nektar::SpatialDomains::PointGeom::Sub().
◆ v_VectorFlux()
|
overrideprotectedvirtual |
Reimplemented from Nektar::LocalRegions::Expansion.
Definition at line 2305 of file Expansion2D.cpp.
2307{
2308 const Array<OneD, const Array<OneD, NekDouble>> &normals =
2309 GetLeftAdjacentElementExp()->GetTraceNormal(
2310 GetLeftAdjacentElementTrace());
2311
2313 Array<OneD, NekDouble> Fn(nq);
2314 Vmath::Vmul(nq, &vec[0][0], 1, &normals[0][0], 1, &Fn[0], 1);
2315 Vmath::Vvtvp(nq, &vec[1][0], 1, &normals[1][0], 1, &Fn[0], 1, &Fn[0], 1);
2316 Vmath::Vvtvp(nq, &vec[2][0], 1, &normals[2][0], 1, &Fn[0], 1, &Fn[0], 1);
2317
2318 return StdExpansion::Integral(Fn);
2319}
ExpansionSharedPtr GetLeftAdjacentElementExp() const
Definition: Expansion.h:441
int GetLeftAdjacentElementTrace() const
Definition: Expansion.h:454
References Nektar::LocalRegions::Expansion::GetLeftAdjacentElementExp(), Nektar::LocalRegions::Expansion::GetLeftAdjacentElementTrace(), Nektar::StdRegions::StdExpansion::GetTotPoints(), Vmath::Vmul(), and Vmath::Vvtvp().
Member Data Documentation
◆ m_requireNeg
|
protected |
Definition at line 112 of file Expansion2D.h.
Referenced by v_AddEdgeNormBoundaryInt().
