Base class for all multi-elemental spectral/hp expansions. More...

#include <ExpList.h>

Inheritance diagram for Nektar::MultiRegions::ExpList:

Public Member Functions
	ExpList (const ExpansionType Type=eNoType)
	The default constructor using a type. More...

	ExpList (const ExpList &in, const bool DeclareCoeffPhysArrays=true)
	The copy constructor. More...

	ExpList (const ExpList &in, const std::vector< unsigned int > &eIDs, const bool DeclareCoeffPhysArrays=true, const Collections::ImplementationType ImpType=Collections::eNoImpType)
	Constructor copying only elements defined in eIds. More...

	ExpList (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &graph, const bool DeclareCoeffPhysArrays=true, const std::string &var="DefaultVar", const Collections::ImplementationType ImpType=Collections::eNoImpType)
	Generate an ExpList from a meshgraph graph and session file. More...

	ExpList (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::ExpansionInfoMap &expansions, const bool DeclareCoeffPhysArrays=true, const Collections::ImplementationType ImpType=Collections::eNoImpType)
	Sets up a list of local expansions based on an expansion Map. More...

	ExpList (const SpatialDomains::PointGeomSharedPtr &geom)
	Specialised constructors for 0D Expansions Wrapper around LocalRegion::PointExp - used in PrePacing.cpp. More...

	ExpList (const LibUtilities::SessionReaderSharedPtr &pSession, const Array< OneD, const ExpListSharedPtr > &bndConstraint, const Array< OneD, const SpatialDomains ::BoundaryConditionShPtr > &bndCond, const LocalRegions::ExpansionVector &locexp, const SpatialDomains::MeshGraphSharedPtr &graph, const LibUtilities::CommSharedPtr &comm, const bool DeclareCoeffPhysArrays=true, const std::string variable="DefaultVar", const Collections::ImplementationType ImpType=Collections::eNoImpType)
	Generate expansions for the trace space expansions used in DisContField. More...

	ExpList (const LibUtilities::SessionReaderSharedPtr &pSession, const LocalRegions::ExpansionVector &locexp, const SpatialDomains::MeshGraphSharedPtr &graph, const bool DeclareCoeffPhysArrays, const std::string variable, const Collections::ImplementationType ImpType=Collections::eNoImpType)
	Generate an trace ExpList from a meshgraph graph and session file. More...

	ExpList (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::CompositeMap &domain, const SpatialDomains::MeshGraphSharedPtr &graph, const bool DeclareCoeffPhysArrays=true, const std::string variable="DefaultVar", bool SetToOneSpaceDimension=false, const LibUtilities::CommSharedPtr comm=LibUtilities::CommSharedPtr(), const Collections::ImplementationType ImpType=Collections::eNoImpType)
	Constructor based on domain information only for 1D & 2D boundary conditions. More...

virtual	~ExpList ()
	The default destructor. More...

int	GetNcoeffs (void) const
	Returns the total number of local degrees of freedom $N_{\mathrm{eof}}=\sum_{e=1}^{{N_{\mathrm{el}}}}N^{e}_m$. More...

int	GetNcoeffs (const int eid) const
	Returns the total number of local degrees of freedom for element eid. More...

ExpansionType	GetExpType (void)
	Returns the type of the expansion. More...

void	SetExpType (ExpansionType Type)
	Returns the type of the expansion. More...

int	EvalBasisNumModesMax (void) const
	Evaulates the maximum number of modes in the elemental basis order over all elements. More...

const Array< OneD, int >	EvalBasisNumModesMaxPerExp (void) const
	Returns the vector of the number of modes in the elemental basis order over all elements. More...

int	GetTotPoints (void) const
	Returns the total number of quadrature points m_npoints $=Q_{\mathrm{tot}}$. More...

int	GetTotPoints (const int eid) const
	Returns the total number of quadrature points for eid's element $=Q_{\mathrm{tot}}$. More...

int	GetNpoints (void) const
	Returns the total number of quadrature points m_npoints $=Q_{\mathrm{tot}}$. More...

int	Get1DScaledTotPoints (const NekDouble scale) const
	Returns the total number of qudature points scaled by the factor scale on each 1D direction. More...

void	SetWaveSpace (const bool wavespace)
	Sets the wave space to the one of the possible configuration true or false. More...

void	SetModifiedBasis (const bool modbasis)
	Set Modified Basis for the stability analysis. More...

bool	GetWaveSpace (void) const
	This function returns the third direction expansion condition, which can be in wave space (coefficient) or not It is stored in the variable m_WaveSpace. More...

void	SetPhys (int i, NekDouble val)
	Set the i th value of m_phys to value val. More...

void	SetPhys (const Array< OneD, const NekDouble > &inarray)
	Fills the array m_phys. More...

void	SetPhysArray (Array< OneD, NekDouble > &inarray)
	Sets the array m_phys. More...

void	SetPhysState (const bool physState)
	This function manually sets whether the array of physical values $\boldsymbol{u}_l$ (implemented as m_phys) is filled or not. More...

bool	GetPhysState (void) const
	This function indicates whether the array of physical values $\boldsymbol{u}_l$ (implemented as m_phys) is filled or not. More...

void	MultiplyByQuadratureMetric (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
	multiply the metric jacobi and quadrature weights More...

void	DivideByQuadratureMetric (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
	Divided by the metric jacobi and quadrature weights. More...

void	IProductWRTBase (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
	This function calculates the inner product of a function $f(\boldsymbol{x})$ with respect to all local expansion modes $\phi_n^e(\boldsymbol{x})$. More...

void	IProductWRTDerivBase (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
	This function calculates the inner product of a function $f(\boldsymbol{x})$ with respect to the derivative (in direction. More...

void	IProductWRTDirectionalDerivBase (const Array< OneD, const NekDouble > &direction, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
	Directional derivative along a given direction. More...

void	IProductWRTDerivBase (const Array< OneD, const Array< OneD, NekDouble >> &inarray, Array< OneD, NekDouble > &outarray)
	This function calculates the inner product of a function $f(\boldsymbol{x})$ with respect to the derivative of all local expansion modes $\phi_n^e(\boldsymbol{x})$. More...

void	FwdTransLocalElmt (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
	This function elementally evaluates the forward transformation of a function $u(\boldsymbol{x})$ onto the global spectral/hp expansion. More...

void	FwdTrans (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)

void	ExponentialFilter (Array< OneD, NekDouble > &array, const NekDouble alpha, const NekDouble exponent, const NekDouble cutoff)

void	MultiplyByElmtInvMass (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
	This function elementally mulplies the coefficient space of Sin my the elemental inverse of the mass matrix. More...

void	MultiplyByInvMassMatrix (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)

void	MultiplyByMassMatrix (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)

void	SmoothField (Array< OneD, NekDouble > &field)
	Smooth a field across elements. More...

GlobalLinSysKey	HelmSolve (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::ConstFactorMap &factors, const StdRegions::VarCoeffMap &varcoeff=StdRegions::NullVarCoeffMap, const MultiRegions::VarFactorsMap &varfactors=MultiRegions::NullVarFactorsMap, const Array< OneD, const NekDouble > &dirForcing=NullNekDouble1DArray, const bool PhysSpaceForcing=true)
	Solve helmholtz problem. More...

GlobalLinSysKey	LinearAdvectionDiffusionReactionSolve (const Array< OneD, Array< OneD, NekDouble >> &velocity, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const NekDouble lambda, const Array< OneD, const NekDouble > &dirForcing=NullNekDouble1DArray)
	Solve Advection Diffusion Reaction. More...

void	LinearAdvectionReactionSolve (const Array< OneD, Array< OneD, NekDouble >> &velocity, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const NekDouble lambda, const Array< OneD, const NekDouble > &dirForcing=NullNekDouble1DArray)
	Solve Advection Diffusion Reaction. More...

void	FwdTransBndConstrained (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)

void	BwdTrans (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
	This function elementally evaluates the backward transformation of the global spectral/hp element expansion. More...

void	GetCoords (Array< OneD, NekDouble > &coord_0, Array< OneD, NekDouble > &coord_1=NullNekDouble1DArray, Array< OneD, NekDouble > &coord_2=NullNekDouble1DArray)
	This function calculates the coordinates of all the elemental quadrature points $\boldsymbol{x}_i$. More...

void	GetCoords (const int eid, Array< OneD, NekDouble > &coord_0, Array< OneD, NekDouble > &coord_1=NullNekDouble1DArray, Array< OneD, NekDouble > &coord_2=NullNekDouble1DArray)

void	HomogeneousFwdTrans (const int npts, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, bool Shuff=true, bool UnShuff=true)

void	HomogeneousBwdTrans (const int npts, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, bool Shuff=true, bool UnShuff=true)

void	DealiasedProd (const int num_dofs, const Array< OneD, NekDouble > &inarray1, const Array< OneD, NekDouble > &inarray2, Array< OneD, NekDouble > &outarray)

void	DealiasedDotProd (const int num_dofs, const Array< OneD, Array< OneD, NekDouble >> &inarray1, const Array< OneD, Array< OneD, NekDouble >> &inarray2, Array< OneD, Array< OneD, NekDouble >> &outarray)

void	GetBCValues (Array< OneD, NekDouble > &BndVals, const Array< OneD, NekDouble > &TotField, int BndID)

void	NormVectorIProductWRTBase (Array< OneD, const NekDouble > &V1, Array< OneD, const NekDouble > &V2, Array< OneD, NekDouble > &outarray, int BndID)

void	NormVectorIProductWRTBase (Array< OneD, Array< OneD, NekDouble >> &V, Array< OneD, NekDouble > &outarray)

void	ApplyGeomInfo ()
	Apply geometry information to each expansion. More...

void	Reset ()
	Reset geometry information and reset matrices. More...

void	WriteTecplotHeader (std::ostream &outfile, std::string var="")

void	WriteTecplotZone (std::ostream &outfile, int expansion=-1)

void	WriteTecplotField (std::ostream &outfile, int expansion=-1)

void	WriteTecplotConnectivity (std::ostream &outfile, int expansion=-1)

void	WriteVtkHeader (std::ostream &outfile)

void	WriteVtkFooter (std::ostream &outfile)

void	WriteVtkPieceHeader (std::ostream &outfile, int expansion, int istrip=0)

void	WriteVtkPieceFooter (std::ostream &outfile, int expansion)

void	WriteVtkPieceData (std::ostream &outfile, int expansion, std::string var="v")

int	GetCoordim (int eid)
	This function returns the dimension of the coordinates of the element eid. More...

void	SetCoeff (int i, NekDouble val)
	Set the i th coefficiient in m_coeffs to value val. More...

void	SetCoeffs (int i, NekDouble val)
	Set the i th coefficiient in m_coeffs to value val. More...

void	SetCoeffsArray (Array< OneD, NekDouble > &inarray)
	Set the m_coeffs array to inarray. More...

int	GetShapeDimension ()
	This function returns the dimension of the shape of the element eid. More...

const Array< OneD, const NekDouble > &	GetCoeffs () const
	This function returns (a reference to) the array $\boldsymbol{\hat{u}}_l$ (implemented as m_coeffs) containing all local expansion coefficients. More...

void	ImposeDirichletConditions (Array< OneD, NekDouble > &outarray)
	Impose Dirichlet Boundary Conditions onto Array. More...

void	FillBndCondFromField (const Array< OneD, NekDouble > coeffs)
	Fill Bnd Condition expansion from the values stored in expansion. More...

void	FillBndCondFromField (const int nreg, const Array< OneD, NekDouble > coeffs)
	Fill Bnd Condition expansion in nreg from the values stored in expansion. More...

void	LocalToGlobal (bool useComm=true)
	Gathers the global coefficients $\boldsymbol{\hat{u}}_g$ from the local coefficients $\boldsymbol{\hat{u}}_l$. More...

void	LocalToGlobal (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, bool useComm=true)

void	GlobalToLocal (void)
	Scatters from the global coefficients $\boldsymbol{\hat{u}}_g$ to the local coefficients $\boldsymbol{\hat{u}}_l$. More...

void	GlobalToLocal (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)

NekDouble	GetCoeff (int i)
	Get the i th value (coefficient) of m_coeffs. More...

NekDouble	GetCoeffs (int i)
	Get the i th value (coefficient) of m_coeffs. More...

const Array< OneD, const NekDouble > &	GetPhys () const
	This function returns (a reference to) the array $\boldsymbol{u}_l$ (implemented as m_phys) containing the function $u^{\delta}(\boldsymbol{x})$ evaluated at the quadrature points. More...

NekDouble	Linf (const Array< OneD, const NekDouble > &inarray, const Array< OneD, const NekDouble > &soln=NullNekDouble1DArray)
	This function calculates the $L_\infty$ error of the global spectral/hp element approximation. More...

NekDouble	L2 (const Array< OneD, const NekDouble > &inarray, const Array< OneD, const NekDouble > &soln=NullNekDouble1DArray)
	This function calculates the $L_\infty$ error of the global This function calculates the $L_2$ error with respect to soln of the global spectral/hp element approximation. More...

NekDouble	H1 (const Array< OneD, const NekDouble > &inarray, const Array< OneD, const NekDouble > &soln=NullNekDouble1DArray)
	Calculates the $H^1$ error of the global spectral/hp element approximation. More...

NekDouble	Integral ()
	Calculates the $H^1$ error of the global spectral/hp element approximation. More...

NekDouble	Integral (const Array< OneD, const NekDouble > &inarray)

NekDouble	VectorFlux (const Array< OneD, Array< OneD, NekDouble >> &inarray)

Array< OneD, const NekDouble >	HomogeneousEnergy (void)
	This function calculates the energy associated with each one of the modesof a 3D homogeneous nD expansion. More...

void	SetHomo1DSpecVanVisc (Array< OneD, NekDouble > visc)
	This function sets the Spectral Vanishing Viscosity in homogeneous1D expansion. More...

Array< OneD, const unsigned int >	GetZIDs (void)
	This function returns a vector containing the wave numbers in z-direction associated with the 3D homogenous expansion. Required if a parellelisation is applied in the Fourier direction. More...

LibUtilities::TranspositionSharedPtr	GetTransposition (void)
	This function returns the transposition class associated with the homogeneous expansion. More...

NekDouble	GetHomoLen (void)
	This function returns the Width of homogeneous direction associated with the homogeneous expansion. More...

void	SetHomoLen (const NekDouble lhom)
	This function sets the Width of homogeneous direction associated with the homogeneous expansion. More...

Array< OneD, const unsigned int >	GetYIDs (void)
	This function returns a vector containing the wave numbers in y-direction associated with the 3D homogenous expansion. Required if a parellelisation is applied in the Fourier direction. More...

void	PhysInterp1DScaled (const NekDouble scale, const Array< OneD, NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
	This function interpolates the physical space points in inarray to outarray using the same points defined in the expansion but where the number of points are rescaled by 1DScale. More...

void	PhysGalerkinProjection1DScaled (const NekDouble scale, const Array< OneD, NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
	This function Galerkin projects the physical space points in inarray to outarray where inarray is assumed to be defined in the expansion but where the number of points are rescaled by 1DScale. More...

int	GetExpSize (void)
	This function returns the number of elements in the expansion. More...

size_t	GetNumElmts (void)
	This function returns the number of elements in the expansion which may be different for a homogeoenous extended expansionp. More...

const std::shared_ptr< LocalRegions::ExpansionVector >	GetExp () const
	This function returns the vector of elements in the expansion. More...

LocalRegions::ExpansionSharedPtr &	GetExp (int n) const
	This function returns (a shared pointer to) the local elemental expansion of the $n^{\mathrm{th}}$ element. More...

LocalRegions::ExpansionSharedPtr &	GetExpFromGeomId (int n)
	This function returns (a shared pointer to) the local elemental expansion of the $n^{\mathrm{th}}$ element given a global geometry ID. More...

LocalRegions::ExpansionSharedPtr &	GetExp (const Array< OneD, const NekDouble > &gloCoord)
	This function returns (a shared pointer to) the local elemental expansion containing the arbitrary point given by gloCoord. More...

int	GetExpIndex (const Array< OneD, const NekDouble > &gloCoord, NekDouble tol=0.0, bool returnNearestElmt=false, int cachedId=-1, NekDouble maxDistance=1e6)
	This function returns the index of the local elemental expansion containing the arbitrary point given by gloCoord, within a distance tolerance of tol. More...

int	GetExpIndex (const Array< OneD, const NekDouble > &gloCoords, Array< OneD, NekDouble > &locCoords, NekDouble tol=0.0, bool returnNearestElmt=false, int cachedId=-1, NekDouble maxDistance=1e6)

NekDouble	PhysEvaluate (const Array< OneD, const NekDouble > &coords, const Array< OneD, const NekDouble > &phys)

int	GetCoeff_Offset (int n) const
	Get the start offset position for a local contiguous list of coeffs correspoinding to element n. More...

int	GetPhys_Offset (int n) const
	Get the start offset position for a local contiguous list of quadrature points in a full array correspoinding to element n. More...

Array< OneD, NekDouble > &	UpdateCoeffs ()
	This function returns (a reference to) the array $\boldsymbol{\hat{u}}_l$ (implemented as m_coeffs) containing all local expansion coefficients. More...

Array< OneD, NekDouble > &	UpdatePhys ()
	This function returns (a reference to) the array $\boldsymbol{u}_l$ (implemented as m_phys) containing the function $u^{\delta}(\boldsymbol{x})$ evaluated at the quadrature points. More...

void	PhysDeriv (Direction edir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_d)

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)
	This function discretely evaluates the derivative of a function $f(\boldsymbol{x})$ on the domain consisting of all elements of the expansion. More...

void	PhysDeriv (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_d)

void	CurlCurl (Array< OneD, Array< OneD, NekDouble >> &Vel, Array< OneD, Array< OneD, NekDouble >> &Q)

void	PhysDirectionalDeriv (const Array< OneD, const NekDouble > &direction, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)

void	GetMovingFrames (const SpatialDomains::GeomMMF MMFdir, const Array< OneD, const NekDouble > &CircCentre, Array< OneD, Array< OneD, NekDouble >> &outarray)

const Array< OneD, const std::shared_ptr< ExpList > > &	GetBndCondExpansions ()

const Array< OneD, const NekDouble > &	GetBndCondBwdWeight ()
	Get the weight value for boundary conditions. More...

void	SetBndCondBwdWeight (const int index, const NekDouble value)
	Set the weight value for boundary conditions. More...

std::shared_ptr< ExpList > &	UpdateBndCondExpansion (int i)

void	Upwind (const Array< OneD, const NekDouble > &Vn, const Array< OneD, const NekDouble > &Fwd, const Array< OneD, const NekDouble > &Bwd, Array< OneD, NekDouble > &Upwind)

void	Upwind (const Array< OneD, const Array< OneD, NekDouble >> &Vec, const Array< OneD, const NekDouble > &Fwd, const Array< OneD, const NekDouble > &Bwd, Array< OneD, NekDouble > &Upwind)

std::shared_ptr< ExpList > &	GetTrace ()

std::shared_ptr< AssemblyMapDG > &	GetTraceMap (void)

const Array< OneD, const int > &	GetTraceBndMap (void)

void	GetNormals (Array< OneD, Array< OneD, NekDouble >> &normals)

void	GetElmtNormalLength (Array< OneD, NekDouble > &lengthsFwd, Array< OneD, NekDouble > &lengthsBwd)
	Get the length of elements in boundary normal direction. More...

void	GetBwdWeight (Array< OneD, NekDouble > &weightAver, Array< OneD, NekDouble > &weightJump)
	Get the weight value for boundary conditions for boundary average and jump calculations. More...

void	AddTraceIntegral (const Array< OneD, const NekDouble > &Fx, const Array< OneD, const NekDouble > &Fy, Array< OneD, NekDouble > &outarray)

void	AddTraceIntegral (const Array< OneD, const NekDouble > &Fn, Array< OneD, NekDouble > &outarray)

void	AddFwdBwdTraceIntegral (const Array< OneD, const NekDouble > &Fwd, const Array< OneD, const NekDouble > &Bwd, Array< OneD, NekDouble > &outarray)

void	GetFwdBwdTracePhys (Array< OneD, NekDouble > &Fwd, Array< OneD, NekDouble > &Bwd)

void	GetFwdBwdTracePhys (const Array< OneD, const NekDouble > &field, Array< OneD, NekDouble > &Fwd, Array< OneD, NekDouble > &Bwd, bool FillBnd=true, bool PutFwdInBwdOnBCs=false, bool DoExchange=true)

void	FillBwdWithBoundCond (const Array< OneD, NekDouble > &Fwd, Array< OneD, NekDouble > &Bwd, bool PutFwdInBwdOnBCs=false)

void	AddTraceQuadPhysToField (const Array< OneD, const NekDouble > &Fwd, const Array< OneD, const NekDouble > &Bwd, Array< OneD, NekDouble > &field)
	Add Fwd and Bwd value to field, a reverse procedure of GetFwdBwdTracePhys. More...

void	AddTraceQuadPhysToOffDiag (const Array< OneD, const NekDouble > &Fwd, const Array< OneD, const NekDouble > &Bwd, Array< OneD, NekDouble > &field)

void	GetLocTraceFromTracePts (const Array< OneD, const NekDouble > &Fwd, const Array< OneD, const NekDouble > &Bwd, Array< OneD, NekDouble > &locTraceFwd, Array< OneD, NekDouble > &locTraceBwd)

void	FillBwdWithBwdWeight (Array< OneD, NekDouble > &weightave, Array< OneD, NekDouble > &weightjmp)
	Fill Bwd with boundary conditions. More...

void	PeriodicBwdCopy (const Array< OneD, const NekDouble > &Fwd, Array< OneD, NekDouble > &Bwd)
	Copy and fill the Periodic boundaries. More...

const std::vector< bool > &	GetLeftAdjacentFaces (void) const

void	ExtractTracePhys (Array< OneD, NekDouble > &outarray)

void	ExtractTracePhys (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)

const Array< OneD, const SpatialDomains::BoundaryConditionShPtr > &	GetBndConditions ()

Array< OneD, SpatialDomains::BoundaryConditionShPtr > &	UpdateBndConditions ()

void	EvaluateBoundaryConditions (const NekDouble time=0.0, const std::string varName="", const NekDouble=NekConstants::kNekUnsetDouble, const NekDouble=NekConstants::kNekUnsetDouble)

void	GeneralMatrixOp (const GlobalMatrixKey &gkey, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
	This function calculates the result of the multiplication of a matrix of type specified by mkey with a vector given by inarray. More...

void	SetUpPhysNormals ()

void	GetBoundaryToElmtMap (Array< OneD, int > &ElmtID, Array< OneD, int > &EdgeID)

virtual void	GetBndElmtExpansion (int i, std::shared_ptr< ExpList > &result, const bool DeclareCoeffPhysArrays=true)

void	ExtractElmtToBndPhys (int i, const Array< OneD, NekDouble > &elmt, Array< OneD, NekDouble > &boundary)

void	ExtractPhysToBndElmt (int i, const Array< OneD, const NekDouble > &phys, Array< OneD, NekDouble > &bndElmt)

void	ExtractPhysToBnd (int i, const Array< OneD, const NekDouble > &phys, Array< OneD, NekDouble > &bnd)

void	GetBoundaryNormals (int i, Array< OneD, Array< OneD, NekDouble >> &normals)

void	GeneralGetFieldDefinitions (std::vector< LibUtilities::FieldDefinitionsSharedPtr > &fielddef, int NumHomoDir=0, Array< OneD, LibUtilities::BasisSharedPtr > &HomoBasis=LibUtilities::NullBasisSharedPtr1DArray, std::vector< NekDouble > &HomoLen=LibUtilities::NullNekDoubleVector, bool homoStrips=false, std::vector< unsigned int > &HomoSIDs=LibUtilities::NullUnsignedIntVector, std::vector< unsigned int > &HomoZIDs=LibUtilities::NullUnsignedIntVector, std::vector< unsigned int > &HomoYIDs=LibUtilities::NullUnsignedIntVector)

std::map< int, RobinBCInfoSharedPtr >	GetRobinBCInfo ()

void	GetPeriodicEntities (PeriodicMap &periodicVerts, PeriodicMap &periodicEdges, PeriodicMap &periodicFaces=NullPeriodicMap)

std::vector< LibUtilities::FieldDefinitionsSharedPtr >	GetFieldDefinitions ()

void	GetFieldDefinitions (std::vector< LibUtilities::FieldDefinitionsSharedPtr > &fielddef)

void	AppendFieldData (LibUtilities::FieldDefinitionsSharedPtr &fielddef, std::vector< NekDouble > &fielddata)
	Append the element data listed in elements fielddef->m_ElementIDs onto fielddata. More...

void	AppendFieldData (LibUtilities::FieldDefinitionsSharedPtr &fielddef, std::vector< NekDouble > &fielddata, Array< OneD, NekDouble > &coeffs)
	Append the data in coeffs listed in elements fielddef->m_ElementIDs onto fielddata. More...

void	ExtractElmtDataToCoeffs (LibUtilities::FieldDefinitionsSharedPtr &fielddef, std::vector< NekDouble > &fielddata, std::string &field, Array< OneD, NekDouble > &coeffs)
	Extract the data in fielddata into the coeffs using the basic ExpList Elemental expansions rather than planes in homogeneous case. More...

void	ExtractCoeffsToCoeffs (const std::shared_ptr< ExpList > &fromExpList, const Array< OneD, const NekDouble > &fromCoeffs, Array< OneD, NekDouble > &toCoeffs)
	Extract the data from fromField using fromExpList the coeffs using the basic ExpList Elemental expansions rather than planes in homogeneous case. More...

void	ExtractDataToCoeffs (LibUtilities::FieldDefinitionsSharedPtr &fielddef, std::vector< NekDouble > &fielddata, std::string &field, Array< OneD, NekDouble > &coeffs, std::unordered_map< int, int > zIdToPlane=std::unordered_map< int, int >())
	Extract the data in fielddata into the coeffs. More...

void	ExtractCoeffsFromFile (const std::string &fileName, LibUtilities::CommSharedPtr comm, const std::string &varName, Array< OneD, NekDouble > &coeffs)

void	GenerateElementVector (const int ElementID, const NekDouble scalar1, const NekDouble scalar2, Array< OneD, NekDouble > &outarray)
	Generate vector v such that v[i] = scalar1 if i is in the element < ElementID. Otherwise, v[i] = scalar2. More...

std::shared_ptr< ExpList >	GetSharedThisPtr ()
	Returns a shared pointer to the current object. More...

std::shared_ptr< LibUtilities::SessionReader >	GetSession () const
	Returns the session object. More...

std::shared_ptr< LibUtilities::Comm >	GetComm () const
	Returns the comm object. More...

SpatialDomains::MeshGraphSharedPtr	GetGraph ()

LibUtilities::BasisSharedPtr	GetHomogeneousBasis (void)

std::shared_ptr< ExpList > &	GetPlane (int n)

void	CreateCollections (Collections::ImplementationType ImpType=Collections::eNoImpType)
	Construct collections of elements containing a single element type and polynomial order from the list of expansions. More...

void	ClearGlobalLinSysManager (void)

int	GetPoolCount (std::string)

void	UnsetGlobalLinSys (GlobalLinSysKey, bool)

LibUtilities::NekManager< GlobalLinSysKey, GlobalLinSys > &	GetGlobalLinSysManager (void)

const Array< OneD, const std::pair< int, int > > &	GetCoeffsToElmt () const
	Get m_coeffs to elemental value map. More...

void	AddTraceJacToElmtJac (const Array< OneD, const DNekMatSharedPtr > &FwdMat, const Array< OneD, const DNekMatSharedPtr > &BwdMat, Array< OneD, DNekMatSharedPtr > &fieldMat)
	inverse process of v_GetFwdBwdTracePhys. Given Trace integration of Fwd and Bwd Jacobian, with dimension NtotalTraceTraceCoefTracePhys. return Elemental Jacobian matrix with dimension NtotalElementElementCoefElementPhys. More...

void	GetMatIpwrtDeriveBase (const Array< OneD, const Array< OneD, NekDouble >> &inarray, const int nDirctn, Array< OneD, DNekMatSharedPtr > &mtxPerVar)

void	GetMatIpwrtDeriveBase (const TensorOfArray3D< NekDouble > &inarray, Array< OneD, DNekMatSharedPtr > &mtxPerVar)

void	GetDiagMatIpwrtBase (const Array< OneD, const Array< OneD, NekDouble >> &inarray, Array< OneD, DNekMatSharedPtr > &mtxPerVar)

void	AddTraceIntegralToOffDiag (const Array< OneD, const NekDouble > &FwdFlux, const Array< OneD, const NekDouble > &BwdFlux, Array< OneD, NekDouble > &outarray)

void	AddRightIPTPhysDerivBase (const int dir, const Array< OneD, const DNekMatSharedPtr > ElmtJacQuad, Array< OneD, DNekMatSharedPtr > ElmtJacCoef)

void	AddRightIPTBaseMatrix (const Array< OneD, const DNekMatSharedPtr > ElmtJacQuad, Array< OneD, DNekMatSharedPtr > ElmtJacCoef)

const LocTraceToTraceMapSharedPtr &	GetLocTraceToTraceMap () const

std::vector< bool > &	GetLeftAdjacentTraces (void)

const std::unordered_map< int, int > &	GetElmtToExpId (void)
	This function returns the map of index inside m_exp to geom id. More...

int	GetElmtToExpId (int elmtId)
	This function returns the index inside m_exp for a given geom id. More...

Protected Member Functions
std::shared_ptr< DNekMat >	GenGlobalMatrixFull (const GlobalLinSysKey &mkey, const std::shared_ptr< AssemblyMapCG > &locToGloMap)

const DNekScalBlkMatSharedPtr	GenBlockMatrix (const GlobalMatrixKey &gkey)
	This function assembles the block diagonal matrix of local matrices of the type mtype. More...

const DNekScalBlkMatSharedPtr &	GetBlockMatrix (const GlobalMatrixKey &gkey)

void	MultiplyByBlockMatrix (const GlobalMatrixKey &gkey, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)

std::shared_ptr< GlobalMatrix >	GenGlobalMatrix (const GlobalMatrixKey &mkey, const std::shared_ptr< AssemblyMapCG > &locToGloMap)
	Generates a global matrix from the given key and map. More...

void	GlobalEigenSystem (const std::shared_ptr< DNekMat > &Gmat, Array< OneD, NekDouble > &EigValsReal, Array< OneD, NekDouble > &EigValsImag, Array< OneD, NekDouble > &EigVecs=NullNekDouble1DArray)

std::shared_ptr< GlobalLinSys >	GenGlobalLinSys (const GlobalLinSysKey &mkey, const std::shared_ptr< AssemblyMapCG > &locToGloMap)
	This operation constructs the global linear system of type mkey. More...

std::shared_ptr< GlobalLinSys >	GenGlobalBndLinSys (const GlobalLinSysKey &mkey, const AssemblyMapSharedPtr &locToGloMap)
	Generate a GlobalLinSys from information provided by the key "mkey" and the mapping provided in LocToGloBaseMap. More...

virtual size_t	v_GetNumElmts (void)

virtual const Array< OneD, const std::shared_ptr< ExpList > > &	v_GetBndCondExpansions (void)

virtual const Array< OneD, const NekDouble > &	v_GetBndCondBwdWeight ()

virtual void	v_SetBndCondBwdWeight (const int index, const NekDouble value)

virtual std::shared_ptr< ExpList > &	v_UpdateBndCondExpansion (int i)

virtual void	v_Upwind (const Array< OneD, const Array< OneD, NekDouble >> &Vec, const Array< OneD, const NekDouble > &Fwd, const Array< OneD, const NekDouble > &Bwd, Array< OneD, NekDouble > &Upwind)

virtual void	v_Upwind (const Array< OneD, const NekDouble > &Vn, const Array< OneD, const NekDouble > &Fwd, const Array< OneD, const NekDouble > &Bwd, Array< OneD, NekDouble > &Upwind)

virtual std::shared_ptr< ExpList > &	v_GetTrace ()

virtual std::shared_ptr< AssemblyMapDG > &	v_GetTraceMap ()

virtual const Array< OneD, const int > &	v_GetTraceBndMap ()

virtual const std::shared_ptr< LocTraceToTraceMap > &	v_GetLocTraceToTraceMap (void) const

virtual std::vector< bool > &	v_GetLeftAdjacentTraces (void)

virtual void	v_GetNormals (Array< OneD, Array< OneD, NekDouble >> &normals)
	Populate normals with the normals of all expansions. More...

virtual void	v_AddTraceIntegral (const Array< OneD, const NekDouble > &Fx, const Array< OneD, const NekDouble > &Fy, Array< OneD, NekDouble > &outarray)

virtual void	v_AddTraceIntegral (const Array< OneD, const NekDouble > &Fn, Array< OneD, NekDouble > &outarray)

virtual void	v_AddFwdBwdTraceIntegral (const Array< OneD, const NekDouble > &Fwd, const Array< OneD, const NekDouble > &Bwd, Array< OneD, NekDouble > &outarray)

virtual void	v_GetFwdBwdTracePhys (Array< OneD, NekDouble > &Fwd, Array< OneD, NekDouble > &Bwd)

virtual void	v_GetFwdBwdTracePhys (const Array< OneD, const NekDouble > &field, Array< OneD, NekDouble > &Fwd, Array< OneD, NekDouble > &Bwd, bool FillBnd=true, bool PutFwdInBwdOnBCs=false, bool DoExchange=true)

virtual void	v_FillBwdWithBoundCond (const Array< OneD, NekDouble > &Fwd, Array< OneD, NekDouble > &Bwd, bool PutFwdInBwdOnBCs)

virtual void	v_AddTraceQuadPhysToField (const Array< OneD, const NekDouble > &Fwd, const Array< OneD, const NekDouble > &Bwd, Array< OneD, NekDouble > &field)

virtual void	v_AddTraceQuadPhysToOffDiag (const Array< OneD, const NekDouble > &Fwd, const Array< OneD, const NekDouble > &Bwd, Array< OneD, NekDouble > &field)

virtual void	v_GetLocTraceFromTracePts (const Array< OneD, const NekDouble > &Fwd, const Array< OneD, const NekDouble > &Bwd, Array< OneD, NekDouble > &locTraceFwd, Array< OneD, NekDouble > &locTraceBwd)

virtual void	v_FillBwdWithBwdWeight (Array< OneD, NekDouble > &weightave, Array< OneD, NekDouble > &weightjmp)

virtual void	v_PeriodicBwdCopy (const Array< OneD, const NekDouble > &Fwd, Array< OneD, NekDouble > &Bwd)

virtual const std::vector< bool > &	v_GetLeftAdjacentFaces (void) const

virtual void	v_ExtractTracePhys (Array< OneD, NekDouble > &outarray)

virtual void	v_ExtractTracePhys (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)

virtual void	v_MultiplyByInvMassMatrix (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)

virtual GlobalLinSysKey	v_HelmSolve (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::ConstFactorMap &factors, const StdRegions::VarCoeffMap &varcoeff, const MultiRegions::VarFactorsMap &varfactors, const Array< OneD, const NekDouble > &dirForcing, const bool PhysSpaceForcing)

virtual GlobalLinSysKey	v_LinearAdvectionDiffusionReactionSolve (const Array< OneD, Array< OneD, NekDouble >> &velocity, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const NekDouble lambda, const Array< OneD, const NekDouble > &dirForcing=NullNekDouble1DArray)

virtual void	v_LinearAdvectionReactionSolve (const Array< OneD, Array< OneD, NekDouble >> &velocity, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const NekDouble lambda, const Array< OneD, const NekDouble > &dirForcing=NullNekDouble1DArray)

virtual void	v_ImposeDirichletConditions (Array< OneD, NekDouble > &outarray)

virtual void	v_FillBndCondFromField (const Array< OneD, NekDouble > coeffs)

virtual void	v_FillBndCondFromField (const int nreg, const Array< OneD, NekDouble > coeffs)

virtual void	v_Reset ()
	Reset geometry information, metrics, matrix managers and geometry information. More...

virtual void	v_LocalToGlobal (bool UseComm)

virtual void	v_LocalToGlobal (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, bool UseComm)

virtual void	v_GlobalToLocal (void)

virtual void	v_GlobalToLocal (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)

virtual void	v_BwdTrans (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)

virtual void	v_FwdTrans (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)

virtual void	v_FwdTransLocalElmt (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)

virtual void	v_FwdTransBndConstrained (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)

virtual void	v_SmoothField (Array< OneD, NekDouble > &field)

virtual void	v_IProductWRTBase (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)

virtual void	v_GetCoords (Array< OneD, NekDouble > &coord_0, Array< OneD, NekDouble > &coord_1=NullNekDouble1DArray, Array< OneD, NekDouble > &coord_2=NullNekDouble1DArray)

virtual void	v_GetCoords (const int eid, Array< OneD, NekDouble > &xc0, Array< OneD, NekDouble > &xc1, Array< OneD, NekDouble > &xc2)

virtual void	v_PhysDeriv (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_d0, Array< OneD, NekDouble > &out_d1, Array< OneD, NekDouble > &out_d2)

virtual void	v_PhysDeriv (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_d)

virtual void	v_PhysDeriv (Direction edir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_d)

virtual void	v_CurlCurl (Array< OneD, Array< OneD, NekDouble >> &Vel, Array< OneD, Array< OneD, NekDouble >> &Q)

virtual void	v_PhysDirectionalDeriv (const Array< OneD, const NekDouble > &direction, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)

virtual void	v_GetMovingFrames (const SpatialDomains::GeomMMF MMFdir, const Array< OneD, const NekDouble > &CircCentre, Array< OneD, Array< OneD, NekDouble >> &outarray)

virtual void	v_HomogeneousFwdTrans (const int npts, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, bool Shuff=true, bool UnShuff=true)

virtual void	v_HomogeneousBwdTrans (const int npts, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, bool Shuff=true, bool UnShuff=true)

virtual void	v_DealiasedProd (const int num_dofs, const Array< OneD, NekDouble > &inarray1, const Array< OneD, NekDouble > &inarray2, Array< OneD, NekDouble > &outarray)

virtual void	v_DealiasedDotProd (const int num_dofs, const Array< OneD, Array< OneD, NekDouble >> &inarray1, const Array< OneD, Array< OneD, NekDouble >> &inarray2, Array< OneD, Array< OneD, NekDouble >> &outarray)

virtual void	v_GetBCValues (Array< OneD, NekDouble > &BndVals, const Array< OneD, NekDouble > &TotField, int BndID)

virtual void	v_NormVectorIProductWRTBase (Array< OneD, const NekDouble > &V1, Array< OneD, const NekDouble > &V2, Array< OneD, NekDouble > &outarray, int BndID)

virtual void	v_NormVectorIProductWRTBase (Array< OneD, Array< OneD, NekDouble >> &V, Array< OneD, NekDouble > &outarray)

virtual void	v_SetUpPhysNormals ()
	: Set up a normal along the trace elements between two elements at elemental level More...

virtual void	v_GetBoundaryToElmtMap (Array< OneD, int > &ElmtID, Array< OneD, int > &EdgeID)

virtual void	v_GetBndElmtExpansion (int i, std::shared_ptr< ExpList > &result, const bool DeclareCoeffPhysArrays)

virtual void	v_ExtractElmtToBndPhys (const int i, const Array< OneD, NekDouble > &elmt, Array< OneD, NekDouble > &boundary)

virtual void	v_ExtractPhysToBndElmt (const int i, const Array< OneD, const NekDouble > &phys, Array< OneD, NekDouble > &bndElmt)

virtual void	v_ExtractPhysToBnd (const int i, const Array< OneD, const NekDouble > &phys, Array< OneD, NekDouble > &bnd)

virtual void	v_GetBoundaryNormals (int i, Array< OneD, Array< OneD, NekDouble >> &normals)

virtual std::vector< LibUtilities::FieldDefinitionsSharedPtr >	v_GetFieldDefinitions (void)

virtual void	v_GetFieldDefinitions (std::vector< LibUtilities::FieldDefinitionsSharedPtr > &fielddef)

virtual void	v_AppendFieldData (LibUtilities::FieldDefinitionsSharedPtr &fielddef, std::vector< NekDouble > &fielddata)

virtual void	v_AppendFieldData (LibUtilities::FieldDefinitionsSharedPtr &fielddef, std::vector< NekDouble > &fielddata, Array< OneD, NekDouble > &coeffs)

virtual void	v_ExtractDataToCoeffs (LibUtilities::FieldDefinitionsSharedPtr &fielddef, std::vector< NekDouble > &fielddata, std::string &field, Array< OneD, NekDouble > &coeffs, std::unordered_map< int, int > zIdToPlane)
	Extract data from raw field data into expansion list. More...

virtual void	v_ExtractCoeffsToCoeffs (const std::shared_ptr< ExpList > &fromExpList, const Array< OneD, const NekDouble > &fromCoeffs, Array< OneD, NekDouble > &toCoeffs)

virtual void	v_WriteTecplotHeader (std::ostream &outfile, std::string var="")

virtual void	v_WriteTecplotZone (std::ostream &outfile, int expansion)

virtual void	v_WriteTecplotField (std::ostream &outfile, int expansion)

virtual void	v_WriteTecplotConnectivity (std::ostream &outfile, int expansion)

virtual void	v_WriteVtkPieceData (std::ostream &outfile, int expansion, std::string var)

virtual void	v_WriteVtkPieceHeader (std::ostream &outfile, int expansion, int istrip)

virtual NekDouble	v_L2 (const Array< OneD, const NekDouble > &phys, const Array< OneD, const NekDouble > &soln=NullNekDouble1DArray)

virtual NekDouble	v_Integral (const Array< OneD, const NekDouble > &inarray)

virtual NekDouble	v_VectorFlux (const Array< OneD, Array< OneD, NekDouble >> &inarray)

virtual Array< OneD, const NekDouble >	v_HomogeneousEnergy (void)

virtual LibUtilities::TranspositionSharedPtr	v_GetTransposition (void)

virtual NekDouble	v_GetHomoLen (void)

virtual void	v_SetHomoLen (const NekDouble lhom)

virtual Array< OneD, const unsigned int >	v_GetZIDs (void)

virtual Array< OneD, const unsigned int >	v_GetYIDs (void)

virtual void	v_PhysInterp1DScaled (const NekDouble scale, const Array< OneD, NekDouble > &inarray, Array< OneD, NekDouble > &outarray)

virtual void	v_PhysGalerkinProjection1DScaled (const NekDouble scale, const Array< OneD, NekDouble > &inarray, Array< OneD, NekDouble > &outarray)

virtual void	v_ClearGlobalLinSysManager (void)

virtual int	v_GetPoolCount (std::string)

virtual void	v_UnsetGlobalLinSys (GlobalLinSysKey, bool)

virtual LibUtilities::NekManager< GlobalLinSysKey, GlobalLinSys > &	v_GetGlobalLinSysManager (void)

void	ExtractFileBCs (const std::string &fileName, LibUtilities::CommSharedPtr comm, const std::string &varName, const std::shared_ptr< ExpList > locExpList)

virtual const Array< OneD, const SpatialDomains::BoundaryConditionShPtr > &	v_GetBndConditions ()

virtual Array< OneD, SpatialDomains::BoundaryConditionShPtr > &	v_UpdateBndConditions ()

virtual void	v_EvaluateBoundaryConditions (const NekDouble time=0.0, const std::string varName="", const NekDouble x2_in=NekConstants::kNekUnsetDouble, const NekDouble x3_in=NekConstants::kNekUnsetDouble)

virtual std::map< int, RobinBCInfoSharedPtr >	v_GetRobinBCInfo (void)

virtual void	v_GetPeriodicEntities (PeriodicMap &periodicVerts, PeriodicMap &periodicEdges, PeriodicMap &periodicFaces)

virtual LibUtilities::BasisSharedPtr	v_GetHomogeneousBasis (void)

virtual void	v_SetHomo1DSpecVanVisc (Array< OneD, NekDouble > visc)

virtual std::shared_ptr< ExpList > &	v_GetPlane (int n)

virtual void	v_AddTraceIntegralToOffDiag (const Array< OneD, const NekDouble > &FwdFlux, const Array< OneD, const NekDouble > &BwdFlux, Array< OneD, NekDouble > &outarray)

Static Protected Member Functions
static SpatialDomains::BoundaryConditionShPtr	GetBoundaryCondition (const SpatialDomains::BoundaryConditionCollection &collection, unsigned int index, const std::string &variable)

Protected Attributes
ExpansionType	m_expType
	Exapnsion type. More...

LibUtilities::CommSharedPtr	m_comm
	Communicator. More...

LibUtilities::SessionReaderSharedPtr	m_session
	Session. More...

SpatialDomains::MeshGraphSharedPtr	m_graph
	Mesh associated with this expansion list. More...

int	m_ncoeffs
	The total number of local degrees of freedom. m_ncoeffs $=N_{\mathrm{eof}}=\sum_{e=1}^{{N_{\mathrm{el}}}}N^{e}_l$. More...

int	m_npoints

Array< OneD, NekDouble >	m_coeffs
	Concatenation of all local expansion coefficients. More...

Array< OneD, NekDouble >	m_phys
	The global expansion evaluated at the quadrature points. More...

bool	m_physState
	The state of the array m_phys. More...

std::shared_ptr< LocalRegions::ExpansionVector >	m_exp
	The list of local expansions. More...

Collections::CollectionVector	m_collections

std::vector< bool >	m_collectionsDoInit
	Vector of bools to act as an initialise on first call flag. More...

std::vector< int >	m_coll_coeff_offset
	Offset of elemental data into the array m_coeffs. More...

std::vector< int >	m_coll_phys_offset
	Offset of elemental data into the array m_phys. More...

Array< OneD, int >	m_coeff_offset
	Offset of elemental data into the array m_coeffs. More...

Array< OneD, int >	m_phys_offset
	Offset of elemental data into the array m_phys. More...

Array< OneD, std::pair< int, int > >	m_coeffsToElmt
	m_coeffs to elemental value map More...

BlockMatrixMapShPtr	m_blockMat

bool	m_WaveSpace

std::unordered_map< int, int >	m_elmtToExpId
	Mapping from geometry ID of element to index inside m_exp. More...

Private Member Functions
void	SetupCoeffPhys (bool DeclareCoeffPhysArrays=true, bool SetupOffsets=true)
	Definition of the total number of degrees of freedom and quadrature points and offsets to access data. More...

void	InitialiseExpVector (const SpatialDomains::ExpansionInfoMap &expmap)
	Define a list of elements using the geometry and basis key information in expmap;. More...

Detailed Description

Base class for all multi-elemental spectral/hp expansions.

All multi-elemental expansions $u^{\delta}(\boldsymbol{x})$ can be considered as the assembly of the various elemental contributions. On a discrete level, this yields,

\[u^{\delta}(\boldsymbol{x}_i)=\sum_{e=1}^{{N_{\mathrm{el}}}} \sum_{n=0}^{N^{e}_m-1}\hat{u}_n^e\phi_n^e(\boldsymbol{x}_i).\]

where ${N_{\mathrm{el}}}$ is the number of elements and $N^{e}_m$ is the local elemental number of expansion modes. As it is the lowest level class, it contains the definition of the common data and common routines to all multi-elemental expansions.

The class stores a vector of expansions, m_exp, (each derived from StdRegions::StdExpansion) which define the constituent components of the domain.

Definition at line 102 of file ExpList.h.

Constructor & Destructor Documentation

◆ ExpList() [1/9]

Nektar::MultiRegions::ExpList::ExpList ( const ExpansionType type = eNoType )

The default constructor using a type.

Creates an empty expansion list.

Definition at line 102 of file ExpList.cpp.

     : m_expType(type), m_ncoeffs(0), m_npoints(0), m_physState(false),
       m_exp(MemoryManager<LocalRegions::ExpansionVector>::AllocateSharedPtr()),
       m_blockMat(MemoryManager<BlockMatrixMap>::AllocateSharedPtr()),
       m_WaveSpace(false)
 {
 }

◆ ExpList() [2/9]

Nektar::MultiRegions::ExpList::ExpList	(	const ExpList &	in,
		const bool	DeclareCoeffPhysArrays = `true`
	)

The copy constructor.

Copies an existing expansion list.

Parameters

in	Source expansion list.

Definition at line 118 of file ExpList.cpp.

     : std::enable_shared_from_this<ExpList>(in), m_expType(in.m_expType),
  
       m_comm(in.m_comm), m_session(in.m_session), m_graph(in.m_graph),
       m_ncoeffs(in.m_ncoeffs), m_npoints(in.m_npoints), m_physState(false),
       m_exp(in.m_exp), m_collections(in.m_collections),
       m_collectionsDoInit(in.m_collectionsDoInit),
       m_coll_coeff_offset(in.m_coll_coeff_offset),
       m_coll_phys_offset(in.m_coll_phys_offset),
       m_coeff_offset(in.m_coeff_offset), m_phys_offset(in.m_phys_offset),
       m_blockMat(in.m_blockMat), m_WaveSpace(false),
       m_elmtToExpId(in.m_elmtToExpId)
 {
  
     // Set up m_coeffs, m_phys and offset arrays.
     // use this to keep memory declaration in one place
     SetupCoeffPhys(DeclareCoeffPhysArrays, false);
 }

References SetupCoeffPhys().

◆ ExpList() [3/9]

Nektar::MultiRegions::ExpList::ExpList	(	const ExpList &	in,
		const std::vector< unsigned int > &	eIDs,
		const bool	DeclareCoeffPhysArrays = `true`,
		const Collections::ImplementationType	ImpType = `Collections::eNoImpType`
	)

Constructor copying only elements defined in eIds.

Copies the eIds elements from an existing expansion list.

Parameters

in	Source expansion list.
in	elements that will be in the new exp list.

Definition at line 142 of file ExpList.cpp.

     : m_expType(in.m_expType), m_comm(in.m_comm), m_session(in.m_session),
       m_graph(in.m_graph), m_physState(false),
       m_exp(MemoryManager<LocalRegions::ExpansionVector>::AllocateSharedPtr()),
       m_blockMat(MemoryManager<BlockMatrixMap>::AllocateSharedPtr()),
       m_WaveSpace(false)
 {
     for (int i = 0; i < eIDs.size(); ++i)
     {
         (*m_exp).push_back((*(in.m_exp))[eIDs[i]]);
     }
  
     // Set up m_coeffs, m_phys and offset arrays.
     SetupCoeffPhys(DeclareCoeffPhysArrays);
  
     // set up collections
     CreateCollections(ImpType);
 }

References CreateCollections(), m_exp, and SetupCoeffPhys().

◆ ExpList() [4/9]

Nektar::MultiRegions::ExpList::ExpList	(	const LibUtilities::SessionReaderSharedPtr &	pSession,
		const SpatialDomains::MeshGraphSharedPtr &	graph,
		const bool	DeclareCoeffPhysArrays = `true`,
		const std::string &	var = `"DefaultVar"`,
		const Collections::ImplementationType	ImpType = `Collections::eNoImpType`
	)

Generate an ExpList from a meshgraph graph and session file.

Given a meshgraph graph, containing information about the domain and the spectral/hp element expansion, this constructor fills the list of local expansions \texttt{m_exp} with the proper expansions, calculates the total number of quadrature points $x_i$ and local expansion coefficients $\hat{u}^e_n$ and

Parameters

pSession	A session within information about expansion
graph	A meshgraph, containing information about the domain and the spectral/hp element expansion.
DeclareCoeffPhysArrays	Declare the coefficient and phys space arrays
ImpType	Detail about the implementation type to use in operators

Definition at line 182 of file ExpList.cpp.

     : m_comm(pSession->GetComm()), m_session(pSession), m_graph(graph),
       m_physState(false),
       m_exp(MemoryManager<LocalRegions::ExpansionVector>::AllocateSharedPtr()),
       m_blockMat(MemoryManager<BlockMatrixMap>::AllocateSharedPtr()),
       m_WaveSpace(false)
 {
     // Retrieve the list of expansions
     const SpatialDomains::ExpansionInfoMap &expansions =
         graph->GetExpansionInfo(var);
  
     // Initialise Expansionn Vector
     InitialiseExpVector(expansions);
  
     // Setup phys coeff space
     SetupCoeffPhys(DeclareCoeffPhysArrays);
  
     // Initialise collection
     CreateCollections(ImpType);
 }

References CreateCollections(), InitialiseExpVector(), and SetupCoeffPhys().

◆ ExpList() [5/9]

Nektar::MultiRegions::ExpList::ExpList	(	const LibUtilities::SessionReaderSharedPtr &	pSession,
		const SpatialDomains::ExpansionInfoMap &	expansions,
		const bool	DeclareCoeffPhysArrays = `true`,
		const Collections::ImplementationType	ImpType = `Collections::eNoImpType`
	)

Sets up a list of local expansions based on an expansion Map.

Given an expansion vector expansions, containing information about the domain and the spectral/hp element expansion, this constructor fills the list of local expansions \texttt{m_exp} with the proper expansions, calculates the total number of quadrature points $\boldsymbol{x}_i$ and local expansion coefficients $\hat{u}^e_n$.

Parameters

pSession	A session within information about expansion
expansions	A vector containing information about the domain and the spectral/hp element expansion.
DeclareCoeffPhysArrays	Declare the coefficient and phys space arrays
ImpType	Detail about the implementation type to use in operators

Definition at line 224 of file ExpList.cpp.

     : m_comm(pSession->GetComm()), m_session(pSession), m_physState(false),
       m_exp(MemoryManager<LocalRegions::ExpansionVector>::AllocateSharedPtr()),
       m_blockMat(MemoryManager<BlockMatrixMap>::AllocateSharedPtr()),
       m_WaveSpace(false)
 {
  
     // Initialise expansion vector
     InitialiseExpVector(expansions);
  
     // Set up m_coeffs, m_phys and offset arrays.
     SetupCoeffPhys(DeclareCoeffPhysArrays);
  
     // Setup Collection
     CreateCollections(ImpType);
 }

References CreateCollections(), InitialiseExpVector(), and SetupCoeffPhys().

◆ ExpList() [6/9]

Nektar::MultiRegions::ExpList::ExpList ( const SpatialDomains::PointGeomSharedPtr & geom )

Specialised constructors for 0D Expansions Wrapper around LocalRegion::PointExp - used in PrePacing.cpp.

Definition at line 247 of file ExpList.cpp.

     : m_expType(e0D), m_ncoeffs(1), m_npoints(1), m_physState(false),
       m_exp(MemoryManager<LocalRegions::ExpansionVector>::AllocateSharedPtr()),
       m_blockMat(MemoryManager<BlockMatrixMap>::AllocateSharedPtr()),
       m_WaveSpace(false)
 {
     LocalRegions::PointExpSharedPtr Point =
         MemoryManager<LocalRegions::PointExp>::AllocateSharedPtr(geom);
     (*m_exp).push_back(Point);
  
     SetupCoeffPhys();
 }

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::LibUtilities::Point, and SetupCoeffPhys().

◆ ExpList() [7/9]

Nektar::MultiRegions::ExpList::ExpList	(	const LibUtilities::SessionReaderSharedPtr &	pSession,
		const Array< OneD, const ExpListSharedPtr > &	bndConstraint,
		const Array< OneD, const SpatialDomains ::BoundaryConditionShPtr > &	bndCond,
		const LocalRegions::ExpansionVector &	locexp,
		const SpatialDomains::MeshGraphSharedPtr &	graph,
		const LibUtilities::CommSharedPtr &	comm,
		const bool	DeclareCoeffPhysArrays = `true`,
		const std::string	variable = `"DefaultVar"`,
		const Collections::ImplementationType	ImpType = `Collections::eNoImpType`
	)

Generate expansions for the trace space expansions used in DisContField.

◆ ExpList() [8/9]

Nektar::MultiRegions::ExpList::ExpList	(	const LibUtilities::SessionReaderSharedPtr &	pSession,
		const LocalRegions::ExpansionVector &	locexp,
		const SpatialDomains::MeshGraphSharedPtr &	graph,
		const bool	DeclareCoeffPhysArrays,
		const std::string	variable,
		const Collections::ImplementationType	ImpType = `Collections::eNoImpType`
	)

Generate an trace ExpList from a meshgraph graph and session file.

Set expansions for localtrace space expansions used in DisContField as part of Gradient Jump Penalisation

Parameters

pSession	A session within information about expansion
locexp	Complete domain expansion list.
graph	mesh corresponding to the expansion list.
DeclareCoeffPhysArrays	Declare the coefficient and phys space arrays
variable	The variable name associated with the expansion
ImpType	Detail about the implementation type to use in operators

Definition at line 779 of file ExpList.cpp.

     : m_comm(pSession->GetComm()), m_session(pSession), m_graph(graph),
       m_physState(false),
       m_exp(MemoryManager<LocalRegions::ExpansionVector>::AllocateSharedPtr()),
       m_blockMat(MemoryManager<BlockMatrixMap>::AllocateSharedPtr()),
       m_WaveSpace(false)
 {
     boost::ignore_unused(variable, ImpType);
     int i, j, elmtid = 0;
  
     SpatialDomains::PointGeomSharedPtr PointGeom;
     SpatialDomains::Geometry1DSharedPtr segGeom;
     SpatialDomains::Geometry2DSharedPtr ElGeom;
     SpatialDomains::Geometry2DSharedPtr FaceGeom;
     SpatialDomains::QuadGeomSharedPtr QuadGeom;
     SpatialDomains::TriGeomSharedPtr TriGeom;
  
     LocalRegions::ExpansionSharedPtr exp;
     LocalRegions::Expansion0DSharedPtr exp0D;
     LocalRegions::Expansion1DSharedPtr exp1D;
     LocalRegions::Expansion2DSharedPtr exp2D;
     LocalRegions::Expansion3DSharedPtr exp3D;
  
     for (i = 0; i < locexp.size(); ++i)
     {
         if ((exp1D = std::dynamic_pointer_cast<LocalRegions::Expansion1D>(
                  locexp[i])))
         {
             m_expType = e0D;
  
             for (j = 0; j < 2; ++j)
             {
                 PointGeom = (exp1D->GetGeom1D())->GetVertex(j);
  
                 exp = MemoryManager<LocalRegions::PointExp>::AllocateSharedPtr(
                     PointGeom);
                 exp->SetElmtId(elmtid++);
                 (*m_exp).push_back(exp);
             }
         }
         else if ((exp2D = std::dynamic_pointer_cast<LocalRegions::Expansion2D>(
                       locexp[i])))
         {
             m_expType = e1D;
             LibUtilities::BasisKey edgeKey0 =
                 locexp[i]->GetBasis(0)->GetBasisKey();
  
             for (j = 0; j < locexp[i]->GetNtraces(); ++j)
             {
                 segGeom = exp2D->GetGeom2D()->GetEdge(j);
  
                 int dir = exp2D->GetGeom2D()->GetDir(j);
  
                 if (locexp[i]->GetNtraces() == 3)
                 {
                     LibUtilities::BasisKey edgeKey =
                         locexp[i]->GetBasis(dir)->GetBasisKey();
  
                     LibUtilities::BasisKey nEdgeKey(edgeKey0.GetBasisType(),
                                                     edgeKey.GetNumModes(),
                                                     edgeKey.GetPointsKey());
  
                     exp =
                         MemoryManager<LocalRegions::SegExp>::AllocateSharedPtr(
                             nEdgeKey, segGeom);
                 }
                 else
                 {
                     exp =
                         MemoryManager<LocalRegions::SegExp>::AllocateSharedPtr(
                             locexp[i]->GetBasis(dir)->GetBasisKey(), segGeom);
                 }
  
                 exp->SetElmtId(elmtid++);
                 (*m_exp).push_back(exp);
             }
         }
         else if ((exp3D = dynamic_pointer_cast<LocalRegions::Expansion3D>(
                       locexp[i])))
         {
             m_expType = e2D;
  
             LibUtilities::BasisKey face0_dir0 =
                 locexp[i]->GetBasis(0)->GetBasisKey();
             LibUtilities::BasisKey face0_dir1 =
                 locexp[i]->GetBasis(1)->GetBasisKey();
  
             for (j = 0; j < exp3D->GetNtraces(); ++j)
             {
                 FaceGeom = exp3D->GetGeom3D()->GetFace(j);
  
                 int dir0 = exp3D->GetGeom3D()->GetDir(j, 0);
                 int dir1 = exp3D->GetGeom3D()->GetDir(j, 1);
  
                 LibUtilities::BasisKey face_dir0 =
                     locexp[i]->GetBasis(dir0)->GetBasisKey();
                 LibUtilities::BasisKey face_dir1 =
                     locexp[i]->GetBasis(dir1)->GetBasisKey();
  
                 if ((QuadGeom =
                          std::dynamic_pointer_cast<SpatialDomains::QuadGeom>(
                              FaceGeom)))
                 {
                     exp =
                         MemoryManager<LocalRegions::QuadExp>::AllocateSharedPtr(
                             face_dir0, face_dir1, QuadGeom);
                 }
                 else if ((TriGeom = std::dynamic_pointer_cast<
                               SpatialDomains::TriGeom>(FaceGeom)))
                 {
  
                     LibUtilities::BasisKey nface_dir0(face0_dir0.GetBasisType(),
                                                       face_dir0.GetNumModes(),
                                                       face_dir0.GetPointsKey());
                     LibUtilities::BasisKey nface_dir1(face0_dir1.GetBasisType(),
                                                       face_dir1.GetNumModes(),
                                                       face_dir1.GetPointsKey());
                     exp =
                         MemoryManager<LocalRegions::TriExp>::AllocateSharedPtr(
                             nface_dir0, nface_dir1, TriGeom);
                 }
                 exp->SetElmtId(elmtid++);
                 (*m_exp).push_back(exp);
             }
         }
     }
  
     // Set up m_coeffs, m_phys and offset arrays.
     SetupCoeffPhys(DeclareCoeffPhysArrays);
  
     // Set up collections
     if (m_expType != e0D)
     {
         CreateCollections(ImpType);
     }
 }

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), CreateCollections(), Nektar::MultiRegions::e0D, Nektar::MultiRegions::e1D, Nektar::MultiRegions::e2D, Nektar::LibUtilities::BasisKey::GetBasisType(), Nektar::LibUtilities::BasisKey::GetNumModes(), Nektar::LibUtilities::BasisKey::GetPointsKey(), m_expType, and SetupCoeffPhys().

◆ ExpList() [9/9]

Nektar::MultiRegions::ExpList::ExpList	(	const LibUtilities::SessionReaderSharedPtr &	pSession,
		const SpatialDomains::CompositeMap &	domain,
		const SpatialDomains::MeshGraphSharedPtr &	graph,
		const bool	DeclareCoeffPhysArrays = `true`,
		const std::string	variable = `"DefaultVar"`,
		bool	SetToOneSpaceDimension = `false`,
		const LibUtilities::CommSharedPtr	comm = `LibUtilities::CommSharedPtr()`,
		const Collections::ImplementationType	ImpType = `Collections::eNoImpType`
	)

Constructor based on domain information only for 1D & 2D boundary conditions.

Fills the list of local expansions with the trace from the mesh specified by domain. This CompositeMap contains a list of Composites which define the boundary. It is also used to set up expansion domains in the 1D Pulse Wave solver.

Parameters

pSession	A session within information about expansion
domain	A domain, comprising of one or more composite regions,
graph	A mesh, containing information about the domain and the spectral/hp element expansion.
DeclareCoeffPhysArrays	Declare the coefficient and phys space arrays. Default is true.
variable	The variable name associated with the expansion
SetToOneSpaceDimension	Reduce to one space dimension expansion
comm	An optional communicator that can be used with the boundary expansion in case of more global parallel operations. Default to a Null Communicator
ImpType	Detail about the implementation type to use in operators. Default is eNoImpType.

Definition at line 942 of file ExpList.cpp.

     : m_comm(comm), m_session(pSession), m_graph(graph), m_physState(false),
       m_exp(MemoryManager<LocalRegions::ExpansionVector>::AllocateSharedPtr()),
       m_blockMat(MemoryManager<BlockMatrixMap>::AllocateSharedPtr()),
       m_WaveSpace(false)
 {
     int j, elmtid = 0;
     SpatialDomains::PointGeomSharedPtr PtGeom;
     SpatialDomains::SegGeomSharedPtr SegGeom;
     SpatialDomains::TriGeomSharedPtr TriGeom;
     SpatialDomains::QuadGeomSharedPtr QuadGeom;
  
     LocalRegions::ExpansionSharedPtr exp;
  
     LibUtilities::PointsType TriNb;
  
     int meshdim = graph->GetMeshDimension();
  
     // Retrieve the list of expansions (needed of meshdim == 1
     const SpatialDomains::ExpansionInfoMap &expansions =
         graph->GetExpansionInfo(variable);
  
     // Retrieve the list of expansions
     // Process each composite region.
     for (auto &compIt : domain)
     {
         // Process each expansion in the region.
         for (j = 0; j < compIt.second->m_geomVec.size(); ++j)
         {
             if ((PtGeom = std::dynamic_pointer_cast<SpatialDomains::PointGeom>(
                      compIt.second->m_geomVec[j])))
             {
                 m_expType = e0D;
  
                 exp = MemoryManager<LocalRegions::PointExp>::AllocateSharedPtr(
                     PtGeom);
             }
             else if ((SegGeom =
                           std::dynamic_pointer_cast<SpatialDomains::SegGeom>(
                               compIt.second->m_geomVec[j])))
             {
                 m_expType = e1D;
  
                 // Retrieve the basis key from the expansion.
                 LibUtilities::BasisKey bkey = LibUtilities::NullBasisKey;
  
                 if (meshdim == 1)
                 {
                     auto expIt = expansions.find(SegGeom->GetGlobalID());
                     ASSERTL0(expIt != expansions.end(),
                              "Failed to find basis key");
                     bkey = expIt->second->m_basisKeyVector[0];
                 }
                 else
                 {
                     bkey = graph->GetEdgeBasisKey(SegGeom, variable);
                 }
  
                 if (SetToOneSpaceDimension)
                 {
                     SpatialDomains::SegGeomSharedPtr OneDSegmentGeom =
                         SegGeom->GenerateOneSpaceDimGeom();
  
                     exp =
                         MemoryManager<LocalRegions::SegExp>::AllocateSharedPtr(
                             bkey, OneDSegmentGeom);
                 }
                 else
                 {
  
                     exp =
                         MemoryManager<LocalRegions::SegExp>::AllocateSharedPtr(
                             bkey, SegGeom);
                 }
             }
             else if ((TriGeom =
                           std::dynamic_pointer_cast<SpatialDomains::TriGeom>(
                               compIt.second->m_geomVec[j])))
             {
                 m_expType = e2D;
  
                 LibUtilities::BasisKey TriBa =
                     graph->GetFaceBasisKey(TriGeom, 0, variable);
                 LibUtilities::BasisKey TriBb =
                     graph->GetFaceBasisKey(TriGeom, 1, variable);
  
                 if (graph->GetExpansionInfo()
                         .begin()
                         ->second->m_basisKeyVector[0]
                         .GetBasisType() == LibUtilities::eGLL_Lagrange)
                 {
                     NEKERROR(ErrorUtil::efatal, "This method needs sorting");
                     TriNb = LibUtilities::eNodalTriElec;
  
                     exp = MemoryManager<
                         LocalRegions::NodalTriExp>::AllocateSharedPtr(TriBa,
                                                                       TriBb,
                                                                       TriNb,
                                                                       TriGeom);
                 }
                 else
                 {
                     exp =
                         MemoryManager<LocalRegions::TriExp>::AllocateSharedPtr(
                             TriBa, TriBb, TriGeom);
                 }
             }
             else if ((QuadGeom =
                           std::dynamic_pointer_cast<SpatialDomains::QuadGeom>(
                               compIt.second->m_geomVec[j])))
             {
                 m_expType = e2D;
  
                 LibUtilities::BasisKey QuadBa =
                     graph->GetFaceBasisKey(QuadGeom, 0, variable);
                 LibUtilities::BasisKey QuadBb =
                     graph->GetFaceBasisKey(QuadGeom, 1, variable);
  
                 exp = MemoryManager<LocalRegions::QuadExp>::AllocateSharedPtr(
                     QuadBa, QuadBb, QuadGeom);
             }
             else
             {
                 NEKERROR(ErrorUtil::efatal,
                          "dynamic cast to a Geom (possibly 3D) failed");
             }
  
             exp->SetElmtId(elmtid++);
             (*m_exp).push_back(exp);
         }
     }
  
     // Set up m_coeffs, m_phys and offset arrays.
     SetupCoeffPhys(DeclareCoeffPhysArrays);
  
     if (m_expType != e0D)
     {
         CreateCollections(ImpType);
     }
 }

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, CreateCollections(), Nektar::MultiRegions::e0D, Nektar::MultiRegions::e1D, Nektar::MultiRegions::e2D, Nektar::ErrorUtil::efatal, Nektar::LibUtilities::eGLL_Lagrange, Nektar::LibUtilities::eNodalTriElec, m_expType, NEKERROR, Nektar::LibUtilities::NullBasisKey(), and SetupCoeffPhys().

◆ ~ExpList()

Nektar::MultiRegions::ExpList::~ExpList ( )

virtual

The default destructor.

Definition at line 1315 of file ExpList.cpp.

1316 {

1317 }

Member Function Documentation

◆ AddFwdBwdTraceIntegral()

void Nektar::MultiRegions::ExpList::AddFwdBwdTraceIntegral	(	const Array< OneD, const NekDouble > &	Fwd,
		const Array< OneD, const NekDouble > &	Bwd,
		Array< OneD, NekDouble > &	outarray
	)

inline

Definition at line 2139 of file ExpList.h.

 {
     v_AddFwdBwdTraceIntegral(Fwd, Bwd, outarray);
 }

References v_AddFwdBwdTraceIntegral().

◆ AddRightIPTBaseMatrix()

void Nektar::MultiRegions::ExpList::AddRightIPTBaseMatrix	(	const Array< OneD, const DNekMatSharedPtr >	ElmtJacQuad,
		Array< OneD, DNekMatSharedPtr >	ElmtJacCoef
	)

Definition at line 5913 of file ExpList.cpp.

 {
     int nelmt;
     int nelmtcoef, nelmtpnts, nelmtcoef0, nelmtpnts0;
  
     nelmtcoef = GetNcoeffs(0);
     nelmtpnts = GetTotPoints(0);
  
     Array<OneD, NekDouble> innarray(nelmtpnts, 0.0);
     Array<OneD, NekDouble> outarray(nelmtcoef, 0.0);
  
     Array<OneD, NekDouble> MatQ_data;
     Array<OneD, NekDouble> MatC_data;
  
     DNekMatSharedPtr tmpMatQ, tmpMatC;
  
     nelmtcoef0 = nelmtcoef;
     nelmtpnts0 = nelmtpnts;
  
     for (nelmt = 0; nelmt < (*m_exp).size(); ++nelmt)
     {
         nelmtcoef = GetNcoeffs(nelmt);
         nelmtpnts = GetTotPoints(nelmt);
  
         tmpMatQ = ElmtJacQuad[nelmt];
         tmpMatC = ElmtJacCoef[nelmt];
  
         MatQ_data = tmpMatQ->GetPtr();
         MatC_data = tmpMatC->GetPtr();
  
         if (nelmtcoef != nelmtcoef0)
         {
             outarray   = Array<OneD, NekDouble>(nelmtcoef, 0.0);
             nelmtcoef0 = nelmtcoef;
         }
  
         if (nelmtpnts != nelmtpnts0)
         {
             innarray   = Array<OneD, NekDouble>(nelmtpnts, 0.0);
             nelmtpnts0 = nelmtpnts;
         }
  
         for (int np = 0; np < nelmtcoef; np++)
         {
             Vmath::Vcopy(nelmtpnts, &MatQ_data[0] + np, nelmtcoef, &innarray[0],
                          1);
             (*m_exp)[nelmt]->DivideByQuadratureMetric(innarray, innarray);
             (*m_exp)[nelmt]->IProductWRTBase(innarray, outarray);
  
             Vmath::Vadd(nelmtcoef, &outarray[0], 1, &MatC_data[0] + np,
                         nelmtcoef, &MatC_data[0] + np, nelmtcoef);
         }
     }
 }

References GetNcoeffs(), GetTotPoints(), Vmath::Vadd(), and Vmath::Vcopy().

◆ AddRightIPTPhysDerivBase()

void Nektar::MultiRegions::ExpList::AddRightIPTPhysDerivBase	(	const int	dir,
		const Array< OneD, const DNekMatSharedPtr >	ElmtJacQuad,
		Array< OneD, DNekMatSharedPtr >	ElmtJacCoef
	)

Definition at line 5856 of file ExpList.cpp.

 {
     int nelmt;
     int nelmtcoef, nelmtpnts, nelmtcoef0, nelmtpnts0;
  
     nelmtcoef = GetNcoeffs(0);
     nelmtpnts = GetTotPoints(0);
  
     Array<OneD, NekDouble> innarray(nelmtpnts, 0.0);
     Array<OneD, NekDouble> outarray(nelmtcoef, 0.0);
  
     Array<OneD, NekDouble> MatQ_data;
     Array<OneD, NekDouble> MatC_data;
  
     DNekMatSharedPtr tmpMatQ, tmpMatC;
  
     nelmtcoef0 = nelmtcoef;
     nelmtpnts0 = nelmtpnts;
  
     for (nelmt = 0; nelmt < (*m_exp).size(); ++nelmt)
     {
         nelmtcoef = GetNcoeffs(nelmt);
         nelmtpnts = GetTotPoints(nelmt);
  
         tmpMatQ = ElmtJacQuad[nelmt];
         tmpMatC = ElmtJacCoef[nelmt];
  
         MatQ_data = tmpMatQ->GetPtr();
         MatC_data = tmpMatC->GetPtr();
  
         if (nelmtcoef != nelmtcoef0)
         {
             outarray   = Array<OneD, NekDouble>(nelmtcoef, 0.0);
             nelmtcoef0 = nelmtcoef;
         }
  
         if (nelmtpnts != nelmtpnts0)
         {
             innarray   = Array<OneD, NekDouble>(nelmtpnts, 0.0);
             nelmtpnts0 = nelmtpnts;
         }
  
         for (int np = 0; np < nelmtcoef; np++)
         {
             Vmath::Vcopy(nelmtpnts, &MatQ_data[0] + np, nelmtcoef, &innarray[0],
                          1);
             (*m_exp)[nelmt]->DivideByQuadratureMetric(innarray, innarray);
             (*m_exp)[nelmt]->IProductWRTDerivBase(dir, innarray, outarray);
  
             Vmath::Vadd(nelmtcoef, &outarray[0], 1, &MatC_data[0] + np,
                         nelmtcoef, &MatC_data[0] + np, nelmtcoef);
         }
     }
 }

References GetNcoeffs(), GetTotPoints(), Vmath::Vadd(), and Vmath::Vcopy().

◆ AddTraceIntegral() [1/2]

void Nektar::MultiRegions::ExpList::AddTraceIntegral	(	const Array< OneD, const NekDouble > &	Fn,
		Array< OneD, NekDouble > &	outarray
	)

inline

Definition at line 2134 of file ExpList.h.

 {
     v_AddTraceIntegral(Fn, outarray);
 }

References v_AddTraceIntegral().

◆ AddTraceIntegral() [2/2]

void Nektar::MultiRegions::ExpList::AddTraceIntegral	(	const Array< OneD, const NekDouble > &	Fx,
		const Array< OneD, const NekDouble > &	Fy,
		Array< OneD, NekDouble > &	outarray
	)

inline

Definition at line 2128 of file ExpList.h.

 {
     v_AddTraceIntegral(Fx, Fy, outarray);
 }

References v_AddTraceIntegral().

◆ AddTraceIntegralToOffDiag()

void Nektar::MultiRegions::ExpList::AddTraceIntegralToOffDiag	(	const Array< OneD, const NekDouble > &	FwdFlux,
		const Array< OneD, const NekDouble > &	BwdFlux,
		Array< OneD, NekDouble > &	outarray
	)

inline

Definition at line 1004 of file ExpList.h.

     {
         v_AddTraceIntegralToOffDiag(FwdFlux, BwdFlux, outarray);
     }

References v_AddTraceIntegralToOffDiag().

◆ AddTraceJacToElmtJac()

void Nektar::MultiRegions::ExpList::AddTraceJacToElmtJac	(	const Array< OneD, const DNekMatSharedPtr > &	FwdMat,
		const Array< OneD, const DNekMatSharedPtr > &	BwdMat,
		Array< OneD, DNekMatSharedPtr > &	fieldMat
	)

inverse process of v_GetFwdBwdTracePhys. Given Trace integration of Fwd and Bwd Jacobian, with dimension NtotalTrace*TraceCoef*TracePhys. return Elemental Jacobian matrix with dimension NtotalElement*ElementCoef*ElementPhys.

Parameters

field	is a NekDouble array which contains the 2D data from which we wish to extract the backward and forward orientated trace/edge arrays.
Fwd	The resulting forwards space.
Bwd	The resulting backwards space.

Definition at line 5620 of file ExpList.cpp.

 {
     MultiRegions::ExpListSharedPtr tracelist = GetTrace();
     std::shared_ptr<LocalRegions::ExpansionVector> traceExp =
         tracelist->GetExp();
     int ntotTrace = (*traceExp).size();
     int nTracePnt, nTraceCoef;
  
     std::shared_ptr<LocalRegions::ExpansionVector> fieldExp = GetExp();
     int nElmtCoef;
  
     const MultiRegions::LocTraceToTraceMapSharedPtr locTraceToTraceMap =
         GetLocTraceToTraceMap();
     const Array<OneD, const Array<OneD, int>> LRAdjExpid =
         locTraceToTraceMap->GetLeftRightAdjacentExpId();
     const Array<OneD, const Array<OneD, bool>> LRAdjflag =
         locTraceToTraceMap->GetLeftRightAdjacentExpFlag();
  
     const Array<OneD, const Array<OneD, Array<OneD, int>>> elmtLRMap =
         locTraceToTraceMap->GetTraceCoeffToLeftRightExpCoeffMap();
     const Array<OneD, const Array<OneD, Array<OneD, int>>> elmtLRSign =
         locTraceToTraceMap->GetTraceCoeffToLeftRightExpCoeffSign();
     DNekMatSharedPtr ElmtMat;
     Array<OneD, NekDouble> ElmtMat_data;
     // int nclAdjExp;
     int nrwAdjExp;
     int MatIndex, nPnts;
     NekDouble sign = 1.0;
  
     int nTracePntsTtl   = tracelist->GetTotPoints();
     int nlocTracePts    = locTraceToTraceMap->GetNLocTracePts();
     int nlocTracePtsFwd = locTraceToTraceMap->GetNFwdLocTracePts();
     int nlocTracePtsBwd = nlocTracePts - nlocTracePtsFwd;
  
     Array<OneD, int> nlocTracePtsLR(2);
     nlocTracePtsLR[0] = nlocTracePtsFwd;
     nlocTracePtsLR[1] = nlocTracePtsBwd;
  
     size_t nFwdBwdNonZero = 0;
     Array<OneD, int> tmpIndex{2, -1};
     for (int i = 0; i < 2; ++i)
     {
         if (nlocTracePtsLR[i] > 0)
         {
             tmpIndex[nFwdBwdNonZero] = i;
             nFwdBwdNonZero++;
         }
     }
  
     Array<OneD, int> nlocTracePtsNonZeroIndex{nFwdBwdNonZero};
     for (int i = 0; i < nFwdBwdNonZero; ++i)
     {
         nlocTracePtsNonZeroIndex[i] = tmpIndex[i];
     }
  
     Array<OneD, NekDouble> TraceFwdPhy(nTracePntsTtl);
     Array<OneD, NekDouble> TraceBwdPhy(nTracePntsTtl);
     Array<OneD, Array<OneD, NekDouble>> tmplocTrace(2);
     for (int k = 0; k < 2; ++k)
     {
         tmplocTrace[k] = NullNekDouble1DArray;
     }
  
     for (int k = 0; k < nFwdBwdNonZero; ++k)
     {
         size_t i       = nlocTracePtsNonZeroIndex[k];
         tmplocTrace[i] = Array<OneD, NekDouble>(nlocTracePtsLR[i]);
     }
  
     int nNumbElmt = fieldMat.size();
     Array<OneD, Array<OneD, NekDouble>> ElmtMatDataArray(nNumbElmt);
     Array<OneD, int> ElmtCoefArray(nNumbElmt);
     for (int i = 0; i < nNumbElmt; i++)
     {
         ElmtMatDataArray[i] = fieldMat[i]->GetPtr();
         ElmtCoefArray[i]    = GetNcoeffs(i);
     }
  
     int nTraceCoefMax = 0;
     int nTraceCoefMin = std::numeric_limits<int>::max();
     Array<OneD, int> TraceCoefArray(ntotTrace);
     Array<OneD, int> TracePntArray(ntotTrace);
     Array<OneD, int> TraceOffArray(ntotTrace);
     Array<OneD, Array<OneD, NekDouble>> FwdMatData(ntotTrace);
     Array<OneD, Array<OneD, NekDouble>> BwdMatData(ntotTrace);
     for (int nt = 0; nt < ntotTrace; nt++)
     {
         nTraceCoef         = (*traceExp)[nt]->GetNcoeffs();
         nTracePnt          = tracelist->GetTotPoints(nt);
         int noffset        = tracelist->GetPhys_Offset(nt);
         TraceCoefArray[nt] = nTraceCoef;
         TracePntArray[nt]  = nTracePnt;
         TraceOffArray[nt]  = noffset;
         FwdMatData[nt]     = FwdMat[nt]->GetPtr();
         BwdMatData[nt]     = BwdMat[nt]->GetPtr();
         if (nTraceCoef > nTraceCoefMax)
         {
             nTraceCoefMax = nTraceCoef;
         }
         if (nTraceCoef < nTraceCoefMin)
         {
             nTraceCoefMin = nTraceCoef;
         }
     }
     WARNINGL1(nTraceCoefMax == nTraceCoefMin,
               "nTraceCoefMax!=nTraceCoefMin: Effeciency may be low ");
  
     int traceID, nfieldPnts, ElmtId, noffset;
     const Array<OneD, const Array<OneD, int>> LocTracephysToTraceIDMap =
         locTraceToTraceMap->GetLocTracephysToTraceIDMap();
     const Array<OneD, const int> fieldToLocTraceMap =
         locTraceToTraceMap->GetLocTraceToFieldMap();
     Array<OneD, Array<OneD, int>> fieldToLocTraceMapLR(2);
     noffset = 0;
     for (int k = 0; k < nFwdBwdNonZero; ++k)
     {
         size_t i                = nlocTracePtsNonZeroIndex[k];
         fieldToLocTraceMapLR[i] = Array<OneD, int>(nlocTracePtsLR[i]);
         Vmath::Vcopy(nlocTracePtsLR[i], &fieldToLocTraceMap[0] + noffset, 1,
                      &fieldToLocTraceMapLR[i][0], 1);
         noffset += nlocTracePtsLR[i];
     }
  
     Array<OneD, Array<OneD, int>> MatIndexArray(2);
     for (int k = 0; k < nFwdBwdNonZero; ++k)
     {
         size_t nlr         = nlocTracePtsNonZeroIndex[k];
         MatIndexArray[nlr] = Array<OneD, int>(nlocTracePtsLR[nlr]);
         for (int nloc = 0; nloc < nlocTracePtsLR[nlr]; nloc++)
         {
             traceID    = LocTracephysToTraceIDMap[nlr][nloc];
             nTraceCoef = TraceCoefArray[traceID];
             ElmtId     = LRAdjExpid[nlr][traceID];
             noffset    = GetPhys_Offset(ElmtId);
             nElmtCoef  = ElmtCoefArray[ElmtId];
             nfieldPnts = fieldToLocTraceMapLR[nlr][nloc];
             nPnts      = nfieldPnts - noffset;
  
             MatIndexArray[nlr][nloc] = nPnts * nElmtCoef;
         }
     }
  
     for (int nc = 0; nc < nTraceCoefMin; nc++)
     {
         for (int nt = 0; nt < ntotTrace; nt++)
         {
             nTraceCoef = TraceCoefArray[nt];
             nTracePnt  = TracePntArray[nt];
             noffset    = TraceOffArray[nt];
             Vmath::Vcopy(nTracePnt, &FwdMatData[nt][nc], nTraceCoef,
                          &TraceFwdPhy[noffset], 1);
             Vmath::Vcopy(nTracePnt, &BwdMatData[nt][nc], nTraceCoef,
                          &TraceBwdPhy[noffset], 1);
         }
  
         for (int k = 0; k < nFwdBwdNonZero; ++k)
         {
             size_t i = nlocTracePtsNonZeroIndex[k];
             Vmath::Zero(nlocTracePtsLR[i], tmplocTrace[i], 1);
         }
  
         GetLocTraceFromTracePts(TraceFwdPhy, TraceBwdPhy, tmplocTrace[0],
                                 tmplocTrace[1]);
  
         for (int k = 0; k < nFwdBwdNonZero; ++k)
         {
             size_t nlr = nlocTracePtsNonZeroIndex[k];
             for (int nloc = 0; nloc < nlocTracePtsLR[nlr]; nloc++)
             {
                 traceID    = LocTracephysToTraceIDMap[nlr][nloc];
                 nTraceCoef = TraceCoefArray[traceID];
                 ElmtId     = LRAdjExpid[nlr][traceID];
                 nrwAdjExp  = elmtLRMap[nlr][traceID][nc];
                 sign       = elmtLRSign[nlr][traceID][nc];
                 MatIndex   = MatIndexArray[nlr][nloc] + nrwAdjExp;
  
                 ElmtMatDataArray[ElmtId][MatIndex] -=
                     sign * tmplocTrace[nlr][nloc];
             }
         }
     }
  
     for (int nc = nTraceCoefMin; nc < nTraceCoefMax; nc++)
     {
         for (int nt = 0; nt < ntotTrace; nt++)
         {
             nTraceCoef = TraceCoefArray[nt];
             nTracePnt  = TracePntArray[nt];
             noffset    = TraceOffArray[nt];
             if (nc < nTraceCoef)
             {
                 Vmath::Vcopy(nTracePnt, &FwdMatData[nt][nc], nTraceCoef,
                              &TraceFwdPhy[noffset], 1);
                 Vmath::Vcopy(nTracePnt, &BwdMatData[nt][nc], nTraceCoef,
                              &TraceBwdPhy[noffset], 1);
             }
             else
             {
                 Vmath::Zero(nTracePnt, &TraceFwdPhy[noffset], 1);
                 Vmath::Zero(nTracePnt, &TraceBwdPhy[noffset], 1);
             }
         }
  
         for (int k = 0; k < nFwdBwdNonZero; ++k)
         {
             size_t i = nlocTracePtsNonZeroIndex[k];
             Vmath::Zero(nlocTracePtsLR[i], tmplocTrace[i], 1);
         }
         GetLocTraceFromTracePts(TraceFwdPhy, TraceBwdPhy, tmplocTrace[0],
                                 tmplocTrace[1]);
  
         for (int k = 0; k < nFwdBwdNonZero; ++k)
         {
             size_t nlr = nlocTracePtsNonZeroIndex[k];
             for (int nloc = 0; nloc < nlocTracePtsLR[nlr]; nloc++)
             {
                 traceID    = LocTracephysToTraceIDMap[nlr][nloc];
                 nTraceCoef = TraceCoefArray[traceID];
                 if (nc < nTraceCoef)
                 {
                     ElmtId    = LRAdjExpid[nlr][traceID];
                     nrwAdjExp = elmtLRMap[nlr][traceID][nc];
                     sign      = -elmtLRSign[nlr][traceID][nc];
                     MatIndex  = MatIndexArray[nlr][nloc] + nrwAdjExp;
  
                     ElmtMatDataArray[ElmtId][MatIndex] +=
                         sign * tmplocTrace[nlr][nloc];
                 }
             }
         }
     }
 }

References GetExp(), GetLocTraceFromTracePts(), GetLocTraceToTraceMap(), GetNcoeffs(), GetPhys_Offset(), GetTrace(), Nektar::NullNekDouble1DArray, sign, Vmath::Vcopy(), WARNINGL1, and Vmath::Zero().

◆ AddTraceQuadPhysToField()

void Nektar::MultiRegions::ExpList::AddTraceQuadPhysToField	(	const Array< OneD, const NekDouble > &	Fwd,
		const Array< OneD, const NekDouble > &	Bwd,
		Array< OneD, NekDouble > &	field
	)

inline

Add Fwd and Bwd value to field, a reverse procedure of GetFwdBwdTracePhys.

Definition at line 2164 of file ExpList.h.

 {
     v_AddTraceQuadPhysToField(Fwd, Bwd, field);
 }

References v_AddTraceQuadPhysToField().

◆ AddTraceQuadPhysToOffDiag()

void Nektar::MultiRegions::ExpList::AddTraceQuadPhysToOffDiag	(	const Array< OneD, const NekDouble > &	Fwd,
		const Array< OneD, const NekDouble > &	Bwd,
		Array< OneD, NekDouble > &	field
	)

inline

Definition at line 809 of file ExpList.h.

     {
         v_AddTraceQuadPhysToOffDiag(Fwd, Bwd, field);
     }

References v_AddTraceQuadPhysToOffDiag().

◆ AppendFieldData() [1/2]

void Nektar::MultiRegions::ExpList::AppendFieldData	(	LibUtilities::FieldDefinitionsSharedPtr &	fielddef,
		std::vector< NekDouble > &	fielddata
	)

inline

Append the element data listed in elements fielddef->m_ElementIDs onto fielddata.

Definition at line 904 of file ExpList.h.

     {
         v_AppendFieldData(fielddef, fielddata);
     }

References v_AppendFieldData().

◆ AppendFieldData() [2/2]

void Nektar::MultiRegions::ExpList::AppendFieldData	(	LibUtilities::FieldDefinitionsSharedPtr &	fielddef,
		std::vector< NekDouble > &	fielddata,
		Array< OneD, NekDouble > &	coeffs
	)

inline

Append the data in coeffs listed in elements fielddef->m_ElementIDs onto fielddata.

Definition at line 911 of file ExpList.h.

     {
         v_AppendFieldData(fielddef, fielddata, coeffs);
     }

References v_AppendFieldData().

◆ ApplyGeomInfo()

void Nektar::MultiRegions::ExpList::ApplyGeomInfo ( )

Apply geometry information to each expansion.

Configures geometric info, such as tangent direction, on each expansion.

Parameters

graph2D Mesh

Definition at line 2661 of file ExpList.cpp.

2662 {

2663 }

Referenced by Nektar::MultiRegions::DisContField::DisContField().

◆ BwdTrans()

void Nektar::MultiRegions::ExpList::BwdTrans	(	const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray
	)

inline

This function elementally evaluates the backward transformation of the global spectral/hp element expansion.

Given the coefficients of an expansion, this function evaluates the spectral/hp expansion $u^{\delta}(\boldsymbol{x})$ at the quadrature points $\boldsymbol{x}_i$.

Definition at line 1677 of file ExpList.h.

 {
     v_BwdTrans(inarray, outarray);
 }

References v_BwdTrans().

Referenced by Nektar::MultiRegions::DisContField::L2_DGDeriv(), MultiplyByMassMatrix(), Nektar::MultiRegions::ContField::v_HelmSolve(), Nektar::MultiRegions::ContField::v_SmoothField(), and v_WriteTecplotField().

◆ ClearGlobalLinSysManager()

void Nektar::MultiRegions::ExpList::ClearGlobalLinSysManager ( void )

Definition at line 5295 of file ExpList.cpp.

 {
     v_ClearGlobalLinSysManager();
 }

References v_ClearGlobalLinSysManager().

◆ CreateCollections()

void Nektar::MultiRegions::ExpList::CreateCollections ( Collections::ImplementationType ImpType = Collections::eNoImpType )

Construct collections of elements containing a single element type and polynomial order from the list of expansions.

Definition at line 5103 of file ExpList.cpp.

 {
     map<LibUtilities::ShapeType,
         vector<std::pair<LocalRegions::ExpansionSharedPtr, int>>>
         collections;
  
     // Set up initialisation flags
     m_collectionsDoInit =
         std::vector<bool>(Collections::SIZE_OperatorType, true);
  
     // Figure out optimisation parameters if provided in
     // session file or default given
     Collections::CollectionOptimisation colOpt(
         m_session, (*m_exp)[0]->GetShapeDimension(), ImpType);
     // ImpType = colOpt.GetDefaultImplementationType();
  
     // turn on autotuning if explicitly specified in xml file
     // or command line option is set but only do optimisation
     // for volumetric elements (not boundary condition)
     bool autotuning = colOpt.IsUsingAutotuning();
     if ((autotuning == false) && (ImpType == Collections::eNoImpType))
     {
         // turn on autotuning if writeoptfile specified
         // if m_graph available
         if (m_session->GetUpdateOptFile() && m_graph)
         {
             // only turn on autotuning for volumetric elements
             // where Mesh Dimension is equal to the Shape
             // Dimension of element.
             if (m_graph->GetMeshDimension() == (*m_exp)[0]->GetShapeDimension())
             {
                 autotuning = true;
             }
         }
     }
     bool verbose = (m_session->DefinesCmdLineArgument("verbose")) &&
                    (m_session->GetComm()->GetRank() == 0);
     int collmax =
         (colOpt.GetMaxCollectionSize() > 0 ? colOpt.GetMaxCollectionSize()
                                            : 2 * m_exp->size());
  
     // clear vectors in case previously called
     m_collections.clear();
     m_coll_coeff_offset.clear();
     m_coll_phys_offset.clear();
  
     // Loop over expansions, and create collections for each element type
     for (int i = 0; i < m_exp->size(); ++i)
     {
         collections[(*m_exp)[i]->DetShapeType()].push_back(
             std::pair<LocalRegions::ExpansionSharedPtr, int>((*m_exp)[i], i));
     }
  
     for (auto &it : collections)
     {
         LocalRegions::ExpansionSharedPtr exp = it.second[0].first;
  
         Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(exp);
  
         vector<StdRegions::StdExpansionSharedPtr> collExp;
  
         int prevCoeffOffset = m_coeff_offset[it.second[0].second];
         int prevPhysOffset  = m_phys_offset[it.second[0].second];
         int collcnt;
  
         m_coll_coeff_offset.push_back(prevCoeffOffset);
         m_coll_phys_offset.push_back(prevPhysOffset);
  
         int collsize = 0;
  
         if (it.second.size() == 1) // single element case
         {
             collExp.push_back(it.second[0].first);
  
             // if no Imp Type provided and No
             // setting in xml file. reset
             // impTypes using timings
             if (autotuning)
             {
                 if (collExp.size() > collsize)
                 {
                     impTypes =
                         colOpt.SetWithTimings(collExp, impTypes, verbose);
                     collsize = collExp.size();
                 }
             }
  
             Collections::Collection tmp(collExp, impTypes);
             m_collections.push_back(tmp);
         }
         else
         {
             // set up first geometry
             collExp.push_back(it.second[0].first);
             int prevnCoeff = it.second[0].first->GetNcoeffs();
             int prevnPhys  = it.second[0].first->GetTotPoints();
             bool prevDeformed =
                 it.second[0].first->GetMetricInfo()->GetGtype() ==
                 SpatialDomains::eDeformed;
             collcnt = 1;
  
             for (int i = 1; i < it.second.size(); ++i)
             {
                 int nCoeffs = it.second[i].first->GetNcoeffs();
                 int nPhys   = it.second[i].first->GetTotPoints();
                 bool Deformed =
                     it.second[i].first->GetMetricInfo()->GetGtype() ==
                     SpatialDomains::eDeformed;
                 int coeffOffset = m_coeff_offset[it.second[i].second];
                 int physOffset  = m_phys_offset[it.second[i].second];
  
                 // check to see if next elmt is different or
                 // collmax reached and if so end collection
                 // and start new one
                 if (prevCoeffOffset + nCoeffs != coeffOffset ||
                     prevnCoeff != nCoeffs ||
                     prevPhysOffset + nPhys != physOffset ||
                     prevDeformed != Deformed || prevnPhys != nPhys ||
                     collcnt >= collmax)
                 {
  
                     // if no Imp Type provided and No
                     // settign in xml file. reset
                     // impTypes using timings
                     if (autotuning)
                     {
                         if (collExp.size() > collsize)
                         {
                             impTypes = colOpt.SetWithTimings(collExp, impTypes,
                                                              verbose);
                             collsize = collExp.size();
                         }
                     }
  
                     Collections::Collection tmp(collExp, impTypes);
                     m_collections.push_back(tmp);
  
                     // start new geom list
                     collExp.clear();
  
                     m_coll_coeff_offset.push_back(coeffOffset);
                     m_coll_phys_offset.push_back(physOffset);
                     collExp.push_back(it.second[i].first);
                     collcnt = 1;
                 }
                 else // add to list of collections
                 {
                     collExp.push_back(it.second[i].first);
                     collcnt++;
                 }
  
                 // if end of list finish up collection
                 if (i == it.second.size() - 1)
                 {
                     // if no Imp Type provided and No
                     // settign in xml file.
                     if (autotuning)
                     {
                         if (collExp.size() > collsize)
                         {
                             impTypes = colOpt.SetWithTimings(collExp, impTypes,
                                                              verbose);
                             collsize = collExp.size();
                         }
                     }
  
                     Collections::Collection tmp(collExp, impTypes);
                     m_collections.push_back(tmp);
  
                     collExp.clear();
                     collcnt = 0;
                 }
  
                 prevCoeffOffset = coeffOffset;
                 prevPhysOffset  = physOffset;
                 prevDeformed    = Deformed;
                 prevnCoeff      = nCoeffs;
                 prevnPhys       = nPhys;
             }
         }
     }
  
     // update optimisation file
     if ((m_session->GetUpdateOptFile()) && (ImpType == Collections::eNoImpType))
     {
         colOpt.UpdateOptFile(m_session->GetSessionName(), m_comm);
         // turn off writeoptfile option so only first
         // instance is timed
         m_session->SetUpdateOptFile(false);
     }
 }

References Nektar::SpatialDomains::eDeformed, Nektar::Collections::eNoImpType, Nektar::Collections::CollectionOptimisation::GetMaxCollectionSize(), Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), GetShapeDimension(), Nektar::Collections::CollectionOptimisation::IsUsingAutotuning(), m_coeff_offset, m_coll_coeff_offset, m_coll_phys_offset, m_collections, m_collectionsDoInit, m_comm, m_exp, m_graph, m_phys_offset, m_session, Nektar::Collections::CollectionOptimisation::SetWithTimings(), Nektar::Collections::SIZE_OperatorType, and Nektar::Collections::CollectionOptimisation::UpdateOptFile().

Referenced by ExpList().

◆ CurlCurl()

void Nektar::MultiRegions::ExpList::CurlCurl	(	Array< OneD, Array< OneD, NekDouble >> &	Vel,
		Array< OneD, Array< OneD, NekDouble >> &	Q
	)

inline

Definition at line 1790 of file ExpList.h.

 {
     v_CurlCurl(Vel, Q);
 }

References v_CurlCurl().

◆ DealiasedDotProd()

void Nektar::MultiRegions::ExpList::DealiasedDotProd	(	const int	num_dofs,
		const Array< OneD, Array< OneD, NekDouble >> &	inarray1,
		const Array< OneD, Array< OneD, NekDouble >> &	inarray2,
		Array< OneD, Array< OneD, NekDouble >> &	outarray
	)

inline

Definition at line 1826 of file ExpList.h.

 {
     v_DealiasedDotProd(num_dofs, inarray1, inarray2, outarray);
 }

References v_DealiasedDotProd().

◆ DealiasedProd()

void Nektar::MultiRegions::ExpList::DealiasedProd	(	const int	num_dofs,
		const Array< OneD, NekDouble > &	inarray1,
		const Array< OneD, NekDouble > &	inarray2,
		Array< OneD, NekDouble > &	outarray
	)

inline

Definition at line 1816 of file ExpList.h.

 {
     v_DealiasedProd(num_dofs, inarray1, inarray2, outarray);
 }

References v_DealiasedProd().

Referenced by Nektar::MultiRegions::ExpListHomogeneous2D::v_DealiasedDotProd().

◆ DivideByQuadratureMetric()

void Nektar::MultiRegions::ExpList::DivideByQuadratureMetric	(	const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray
	)

Divided by the metric jacobi and quadrature weights.

Divided by the metric jacobi and quadrature weights

Definition at line 1364 of file ExpList.cpp.

 {
     Array<OneD, NekDouble> e_outarray;
  
     for (int i = 0; i < (*m_exp).size(); ++i)
     {
         (*m_exp)[i]->DivideByQuadratureMetric(inarray + m_phys_offset[i],
                                               e_outarray =
                                                   outarray + m_phys_offset[i]);
     }
 }

References m_phys_offset.

◆ EvalBasisNumModesMax()

int Nektar::MultiRegions::ExpList::EvalBasisNumModesMax ( void ) const

inline

Evaulates the maximum number of modes in the elemental basis order over all elements.

Evaulates the maximum number of modes in the elemental basis order over all elements

Definition at line 1506 of file ExpList.h.

 {
     int returnval = 0;
  
     for (size_t i = 0; i < (*m_exp).size(); ++i)
     {
         returnval = (std::max)(returnval, (*m_exp)[i]->EvalBasisNumModesMax());
     }
  
     return returnval;
 }

References m_exp.

◆ EvalBasisNumModesMaxPerExp()

const Array< OneD, int > Nektar::MultiRegions::ExpList::EvalBasisNumModesMaxPerExp ( void ) const

inline

Returns the vector of the number of modes in the elemental basis order over all elements.

Definition at line 1521 of file ExpList.h.

 {
     Array<OneD, int> returnval((*m_exp).size(), 0);
  
     for (size_t i = 0; i < (*m_exp).size(); ++i)
     {
         returnval[i] =
             (std::max)(returnval[i], (*m_exp)[i]->EvalBasisNumModesMax());
     }
  
     return returnval;
 }

References m_exp.

◆ EvaluateBoundaryConditions()

void Nektar::MultiRegions::ExpList::EvaluateBoundaryConditions	(	const NekDouble	time = `0.0`,
		const std::string	varName = `""`,
		const NekDouble	x2_in = `NekConstants::kNekUnsetDouble`,
		const NekDouble	x3_in = `NekConstants::kNekUnsetDouble`
	)

inline

Definition at line 2211 of file ExpList.h.

 {
     v_EvaluateBoundaryConditions(time, varName, x2_in, x3_in);
 }

References v_EvaluateBoundaryConditions().

Referenced by Nektar::MultiRegions::DisContField::DisContField(), and Nektar::MultiRegions::DisContField3DHomogeneous2D::v_EvaluateBoundaryConditions().

◆ ExponentialFilter()

void Nektar::MultiRegions::ExpList::ExponentialFilter	(	Array< OneD, NekDouble > &	array,
		const NekDouble	alpha,
		const NekDouble	exponent,
		const NekDouble	cutoff
	)

Definition at line 1750 of file ExpList.cpp.

 {
     Array<OneD, NekDouble> e_array;
  
     for (int i = 0; i < (*m_exp).size(); ++i)
     {
         (*m_exp)[i]->ExponentialFilter(e_array = array + m_phys_offset[i],
                                        alpha, exponent, cutoff);
     }
 }

References m_phys_offset.

◆ ExtractCoeffsFromFile()

void Nektar::MultiRegions::ExpList::ExtractCoeffsFromFile	(	const std::string &	fileName,
		LibUtilities::CommSharedPtr	comm,
		const std::string &	varName,
		Array< OneD, NekDouble > &	coeffs
	)

Definition at line 3331 of file ExpList.cpp.

 {
     string varString = fileName.substr(0, fileName.find_last_of("."));
     int j, k, len = varString.length();
     varString = varString.substr(len - 1, len);
  
     std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef;
     std::vector<std::vector<NekDouble>> FieldData;
  
     std::string ft = LibUtilities::FieldIO::GetFileType(fileName, comm);
     LibUtilities::FieldIOSharedPtr f =
         LibUtilities::GetFieldIOFactory().CreateInstance(
             ft, comm, m_session->GetSharedFilesystem());
  
     f->Import(fileName, FieldDef, FieldData);
  
     bool found = false;
     for (j = 0; j < FieldDef.size(); ++j)
     {
         for (k = 0; k < FieldDef[j]->m_fields.size(); ++k)
         {
             if (FieldDef[j]->m_fields[k] == varName)
             {
                 // Copy FieldData into locExpList
                 ExtractDataToCoeffs(FieldDef[j], FieldData[j],
                                     FieldDef[j]->m_fields[k], coeffs);
                 found = true;
             }
         }
     }
  
     ASSERTL0(found, "Could not find variable '" + varName +
                         "' in file boundary condition " + fileName);
 }

References ASSERTL0, Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::CreateInstance(), ExtractDataToCoeffs(), Nektar::LibUtilities::GetFieldIOFactory(), Nektar::LibUtilities::FieldIO::GetFileType(), and m_session.

◆ ExtractCoeffsToCoeffs()

void Nektar::MultiRegions::ExpList::ExtractCoeffsToCoeffs	(	const std::shared_ptr< ExpList > &	fromExpList,
		const Array< OneD, const NekDouble > &	fromCoeffs,
		Array< OneD, NekDouble > &	toCoeffs
	)

Extract the data from fromField using fromExpList the coeffs using the basic ExpList Elemental expansions rather than planes in homogeneous case.

Definition at line 3571 of file ExpList.cpp.

 {
     v_ExtractCoeffsToCoeffs(fromExpList, fromCoeffs, toCoeffs);
 }

References v_ExtractCoeffsToCoeffs().

◆ ExtractDataToCoeffs()

void Nektar::MultiRegions::ExpList::ExtractDataToCoeffs	(	LibUtilities::FieldDefinitionsSharedPtr &	fielddef,
		std::vector< NekDouble > &	fielddata,
		std::string &	field,
		Array< OneD, NekDouble > &	coeffs,
		std::unordered_map< int, int >	zIdToPlane = `std::unordered_map<int, int>()`
	)

Extract the data in fielddata into the coeffs.

Definition at line 3563 of file ExpList.cpp.

 {
     v_ExtractDataToCoeffs(fielddef, fielddata, field, coeffs, zIdToPlane);
 }

References v_ExtractDataToCoeffs().

Referenced by ExtractCoeffsFromFile().

◆ ExtractElmtDataToCoeffs()

void Nektar::MultiRegions::ExpList::ExtractElmtDataToCoeffs	(	LibUtilities::FieldDefinitionsSharedPtr &	fielddef,
		std::vector< NekDouble > &	fielddata,
		std::string &	field,
		Array< OneD, NekDouble > &	coeffs
	)

Extract the data in fielddata into the coeffs using the basic ExpList Elemental expansions rather than planes in homogeneous case.

◆ ExtractElmtToBndPhys()

void Nektar::MultiRegions::ExpList::ExtractElmtToBndPhys	(	int	i,
		const Array< OneD, NekDouble > &	elmt,
		Array< OneD, NekDouble > &	boundary
	)

inline

Definition at line 2234 of file ExpList.h.

 {
     v_ExtractElmtToBndPhys(i, elmt, boundary);
 }

References v_ExtractElmtToBndPhys().

◆ ExtractFileBCs()

void Nektar::MultiRegions::ExpList::ExtractFileBCs	(	const std::string &	fileName,
		LibUtilities::CommSharedPtr	comm,
		const std::string &	varName,
		const std::shared_ptr< ExpList >	locExpList
	)

protected

◆ ExtractPhysToBnd()

void Nektar::MultiRegions::ExpList::ExtractPhysToBnd	(	int	i,
		const Array< OneD, const NekDouble > &	phys,
		Array< OneD, NekDouble > &	bnd
	)

inline

Definition at line 2248 of file ExpList.h.

 {
     v_ExtractPhysToBnd(i, phys, bnd);
 }

References v_ExtractPhysToBnd().

◆ ExtractPhysToBndElmt()

void Nektar::MultiRegions::ExpList::ExtractPhysToBndElmt	(	int	i,
		const Array< OneD, const NekDouble > &	phys,
		Array< OneD, NekDouble > &	bndElmt
	)

inline

Definition at line 2241 of file ExpList.h.

 {
     v_ExtractPhysToBndElmt(i, phys, bndElmt);
 }

References v_ExtractPhysToBndElmt().

◆ ExtractTracePhys() [1/2]

void Nektar::MultiRegions::ExpList::ExtractTracePhys ( Array< OneD, NekDouble > & outarray )

inline

Definition at line 2191 of file ExpList.h.

 {
     v_ExtractTracePhys(outarray);
 }

References v_ExtractTracePhys().

◆ ExtractTracePhys() [2/2]

void Nektar::MultiRegions::ExpList::ExtractTracePhys	(	const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray
	)

inline

Definition at line 2195 of file ExpList.h.

 {
     v_ExtractTracePhys(inarray, outarray);
 }

References v_ExtractTracePhys().

◆ FillBndCondFromField() [1/2]

void Nektar::MultiRegions::ExpList::FillBndCondFromField ( const Array< OneD, NekDouble > coeffs )

inline

Fill Bnd Condition expansion from the values stored in expansion.

Definition at line 1910 of file ExpList.h.

 {
     v_FillBndCondFromField(coeffs);
 }

References v_FillBndCondFromField().

◆ FillBndCondFromField() [2/2]

void Nektar::MultiRegions::ExpList::FillBndCondFromField	(	const int	nreg,
		const Array< OneD, NekDouble >	coeffs
	)

inline

Fill Bnd Condition expansion in nreg from the values stored in expansion.

Definition at line 1914 of file ExpList.h.

 {
     v_FillBndCondFromField(nreg, coeffs);
 }

References v_FillBndCondFromField().

◆ FillBwdWithBoundCond()

void Nektar::MultiRegions::ExpList::FillBwdWithBoundCond	(	const Array< OneD, NekDouble > &	Fwd,
		Array< OneD, NekDouble > &	Bwd,
		bool	PutFwdInBwdOnBCs = `false`
	)

inline

Definition at line 2158 of file ExpList.h.

 {
     v_FillBwdWithBoundCond(Fwd, Bwd, PutFwdInBwdOnBCs);
 }

References v_FillBwdWithBoundCond().

◆ FillBwdWithBwdWeight()

void Nektar::MultiRegions::ExpList::FillBwdWithBwdWeight	(	Array< OneD, NekDouble > &	weightave,
		Array< OneD, NekDouble > &	weightjmp
	)

inline

Fill Bwd with boundary conditions.

Definition at line 2177 of file ExpList.h.

 {
     v_FillBwdWithBwdWeight(weightave, weightjmp);
 }

References v_FillBwdWithBwdWeight().

Referenced by GetBwdWeight().

◆ FwdTrans()

void Nektar::MultiRegions::ExpList::FwdTrans	(	const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray
	)

inline

Definition at line 1639 of file ExpList.h.

 {
     v_FwdTrans(inarray, outarray);
 }

References v_FwdTrans().

◆ FwdTransBndConstrained()

void Nektar::MultiRegions::ExpList::FwdTransBndConstrained	(	const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray
	)

inline

Definition at line 1656 of file ExpList.h.

 {
     v_FwdTransBndConstrained(inarray, outarray);
 }

References v_FwdTransBndConstrained().

◆ FwdTransLocalElmt()

void Nektar::MultiRegions::ExpList::FwdTransLocalElmt	(	const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray
	)

inline

This function elementally evaluates the forward transformation of a function $u(\boldsymbol{x})$ onto the global spectral/hp expansion.

Definition at line 1647 of file ExpList.h.

 {
     v_FwdTransLocalElmt(inarray, outarray);
 }

References v_FwdTransLocalElmt().

◆ GenBlockMatrix()

const DNekScalBlkMatSharedPtr Nektar::MultiRegions::ExpList::GenBlockMatrix ( const GlobalMatrixKey & gkey )

protected

This function assembles the block diagonal matrix of local matrices of the type mtype.

This function assembles the block diagonal matrix $\underline{\boldsymbol{M}}^e$, which is the concatenation of the local matrices $\boldsymbol{M}^e$ of the type mtype, that is

\[ \underline{\boldsymbol{M}}^e = \left[ \begin{array}{cccc} \boldsymbol{M}^1 & 0 & \hspace{3mm}0 \hspace{3mm}& 0 \\ 0 & \boldsymbol{M}^2 & 0 & 0 \\ 0 & 0 & \ddots & 0 \\ 0 & 0 & 0 & \boldsymbol{M}^{N_{\mathrm{el}}} \end{array}\right].\]

Parameters

mtype	the type of matrix to be assembled
scalar	an optional parameter
constant	an optional parameter

Definition at line 1881 of file ExpList.cpp.

 {
     int i, cnt1;
     int n_exp = 0;
     DNekScalMatSharedPtr loc_mat;
     DNekScalBlkMatSharedPtr BlkMatrix;
     map<int, int> elmt_id;
     LibUtilities::ShapeType ShapeType = gkey.GetShapeType();
  
     if (ShapeType != LibUtilities::eNoShapeType)
     {
         for (i = 0; i < (*m_exp).size(); ++i)
         {
             if ((*m_exp)[i]->DetShapeType() == ShapeType)
             {
                 elmt_id[n_exp++] = i;
             }
         }
     }
     else
     {
         n_exp = (*m_exp).size();
         for (i = 0; i < n_exp; ++i)
         {
             elmt_id[i] = i;
         }
     }
  
     Array<OneD, unsigned int> nrows(n_exp);
     Array<OneD, unsigned int> ncols(n_exp);
  
     switch (gkey.GetMatrixType())
     {
         case StdRegions::eBwdTrans:
         {
             // set up an array of integers for block matrix construction
             for (i = 0; i < n_exp; ++i)
             {
                 nrows[i] = (*m_exp)[elmt_id.find(i)->second]->GetTotPoints();
                 ncols[i] = (*m_exp)[elmt_id.find(i)->second]->GetNcoeffs();
             }
         }
         break;
         case StdRegions::eIProductWRTBase:
         {
             // set up an array of integers for block matrix construction
             for (i = 0; i < n_exp; ++i)
             {
                 nrows[i] = (*m_exp)[elmt_id.find(i)->second]->GetNcoeffs();
                 ncols[i] = (*m_exp)[elmt_id.find(i)->second]->GetTotPoints();
             }
         }
         break;
         case StdRegions::eMass:
         case StdRegions::eInvMass:
         case StdRegions::eHelmholtz:
         case StdRegions::eLaplacian:
         case StdRegions::eInvHybridDGHelmholtz:
         {
             // set up an array of integers for block matrix construction
             for (i = 0; i < n_exp; ++i)
             {
                 nrows[i] = (*m_exp)[elmt_id.find(i)->second]->GetNcoeffs();
                 ncols[i] = (*m_exp)[elmt_id.find(i)->second]->GetNcoeffs();
             }
         }
         break;
  
         case StdRegions::eHybridDGLamToU:
         {
             // set up an array of integers for block matrix construction
             for (i = 0; i < n_exp; ++i)
             {
                 nrows[i] = (*m_exp)[elmt_id.find(i)->second]->GetNcoeffs();
                 ncols[i] =
                     (*m_exp)[elmt_id.find(i)->second]->NumDGBndryCoeffs();
             }
         }
         break;
         case StdRegions::eHybridDGHelmBndLam:
         {
             // set up an array of integers for block matrix construction
             for (i = 0; i < n_exp; ++i)
             {
                 nrows[i] =
                     (*m_exp)[elmt_id.find(i)->second]->NumDGBndryCoeffs();
                 ncols[i] =
                     (*m_exp)[elmt_id.find(i)->second]->NumDGBndryCoeffs();
             }
         }
         break;
         default:
         {
             NEKERROR(ErrorUtil::efatal,
                      "Global Matrix creation not defined for this "
                      "type of matrix");
         }
     }
  
     MatrixStorage blkmatStorage = eDIAGONAL;
     BlkMatrix = MemoryManager<DNekScalBlkMat>::AllocateSharedPtr(nrows, ncols,
                                                                  blkmatStorage);
  
     int nvarcoeffs = gkey.GetNVarCoeffs();
     int eid;
     Array<OneD, NekDouble> varcoeffs_wk;
  
     for (i = cnt1 = 0; i < n_exp; ++i)
     {
         // need to be initialised with zero size for non
         // variable coefficient case
         StdRegions::VarCoeffMap varcoeffs;
  
         eid = elmt_id[i];
         if (nvarcoeffs > 0)
         {
             varcoeffs = StdRegions::RestrictCoeffMap(
                 gkey.GetVarCoeffs(), m_phys_offset[i],
                 (*m_exp)[i]->GetTotPoints());
         }
  
         LocalRegions::MatrixKey matkey(
             gkey.GetMatrixType(), (*m_exp)[eid]->DetShapeType(), *(*m_exp)[eid],
             gkey.GetConstFactors(), varcoeffs);
  
         loc_mat = std::dynamic_pointer_cast<LocalRegions::Expansion>(
                       (*m_exp)[elmt_id.find(i)->second])
                       ->GetLocMatrix(matkey);
         BlkMatrix->SetBlock(i, i, loc_mat);
     }
  
     return BlkMatrix;
 }

Referenced by GetBlockMatrix().

◆ GeneralGetFieldDefinitions()

void Nektar::MultiRegions::ExpList::GeneralGetFieldDefinitions	(	std::vector< LibUtilities::FieldDefinitionsSharedPtr > &	fielddef,
		int	NumHomoDir = `0`,
		Array< OneD, LibUtilities::BasisSharedPtr > &	HomoBasis = `LibUtilities::NullBasisSharedPtr1DArray`,
		std::vector< NekDouble > &	HomoLen = `LibUtilities::NullNekDoubleVector`,
		bool	homoStrips = `false`,
		std::vector< unsigned int > &	HomoSIDs = `LibUtilities::NullUnsignedIntVector`,
		std::vector< unsigned int > &	HomoZIDs = `LibUtilities::NullUnsignedIntVector`,
		std::vector< unsigned int > &	HomoYIDs = `LibUtilities::NullUnsignedIntVector`
	)

Definition at line 3404 of file ExpList.cpp.

 {
     int startenum = (int)LibUtilities::eSegment;
     int endenum   = (int)LibUtilities::eHexahedron;
     int s         = 0;
     LibUtilities::ShapeType shape;
  
     ASSERTL1(NumHomoDir == HomoBasis.size(),
              "Homogeneous basis is not the same length as NumHomoDir");
     ASSERTL1(NumHomoDir == HomoLen.size(),
              "Homogeneous length vector is not the same length as NumHomDir");
  
     // count number of shapes
     switch ((*m_exp)[0]->GetShapeDimension())
     {
         case 1:
             startenum = (int)LibUtilities::eSegment;
             endenum   = (int)LibUtilities::eSegment;
             break;
         case 2:
             startenum = (int)LibUtilities::eTriangle;
             endenum   = (int)LibUtilities::eQuadrilateral;
             break;
         case 3:
             startenum = (int)LibUtilities::eTetrahedron;
             endenum   = (int)LibUtilities::eHexahedron;
             break;
     }
  
     for (s = startenum; s <= endenum; ++s)
     {
         std::vector<unsigned int> elementIDs;
         std::vector<LibUtilities::BasisType> basis;
         std::vector<unsigned int> numModes;
         std::vector<std::string> fields;
  
         bool first    = true;
         bool UniOrder = true;
         int n;
  
         shape = (LibUtilities::ShapeType)s;
  
         for (int i = 0; i < (*m_exp).size(); ++i)
         {
             if ((*m_exp)[i]->GetGeom()->GetShapeType() == shape)
             {
                 elementIDs.push_back((*m_exp)[i]->GetGeom()->GetGlobalID());
                 if (first)
                 {
                     for (int j = 0; j < (*m_exp)[i]->GetNumBases(); ++j)
                     {
                         basis.push_back(
                             (*m_exp)[i]->GetBasis(j)->GetBasisType());
                         numModes.push_back(
                             (*m_exp)[i]->GetBasis(j)->GetNumModes());
                     }
  
                     // add homogeneous direction details if defined
                     for (n = 0; n < NumHomoDir; ++n)
                     {
                         basis.push_back(HomoBasis[n]->GetBasisType());
                         numModes.push_back(HomoBasis[n]->GetNumModes());
                     }
  
                     first = false;
                 }
                 else
                 {
                     ASSERTL0(
                         (*m_exp)[i]->GetBasis(0)->GetBasisType() == basis[0],
                         "Routine is not set up for multiple bases definitions");
  
                     for (int j = 0; j < (*m_exp)[i]->GetNumBases(); ++j)
                     {
                         numModes.push_back(
                             (*m_exp)[i]->GetBasis(j)->GetNumModes());
                         if (numModes[j] !=
                             (*m_exp)[i]->GetBasis(j)->GetNumModes())
                         {
                             UniOrder = false;
                         }
                     }
                     // add homogeneous direction details if defined
                     for (n = 0; n < NumHomoDir; ++n)
                     {
                         numModes.push_back(HomoBasis[n]->GetNumModes());
                     }
                 }
             }
         }
  
         if (elementIDs.size() > 0)
         {
             LibUtilities::FieldDefinitionsSharedPtr fdef =
                 MemoryManager<LibUtilities::FieldDefinitions>::
                     AllocateSharedPtr(shape, elementIDs, basis, UniOrder,
                                       numModes, fields, NumHomoDir, HomoLen,
                                       homoStrips, HomoSIDs, HomoZIDs, HomoYIDs);
             fielddef.push_back(fdef);
         }
     }
 }

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, ASSERTL1, Nektar::LibUtilities::eHexahedron, Nektar::LibUtilities::eQuadrilateral, Nektar::LibUtilities::eSegment, Nektar::LibUtilities::eTetrahedron, Nektar::LibUtilities::eTriangle, GetShapeDimension(), and m_exp.

Referenced by v_GetFieldDefinitions().

◆ GeneralMatrixOp()

void Nektar::MultiRegions::ExpList::GeneralMatrixOp	(	const GlobalMatrixKey &	gkey,
		const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray
	)

This function calculates the result of the multiplication of a matrix of type specified by mkey with a vector given by inarray.

This operation is equivalent to the evaluation of $\underline{\boldsymbol{M}}^e\boldsymbol{\hat{u}}_l$, that is,

\[ \left[ \begin{array}{cccc} \boldsymbol{M}^1 & 0 & \hspace{3mm}0 \hspace{3mm}& 0 \\ 0 & \boldsymbol{M}^2 & 0 & 0 \\ 0 & 0 & \ddots & 0 \\ 0 & 0 & 0 & \boldsymbol{M}^{N_{\mathrm{el}}} \end{array} \right] *\left [ \begin{array}{c} \boldsymbol{\hat{u}}^{1} \\ \boldsymbol{\hat{u}}^{2} \\ \vdots \\ \boldsymbol{\hat{u}}^{{{N_{\mathrm{el}}}}} \end{array} \right ]\]

where $\boldsymbol{M}^e$ are the local matrices of type specified by the key mkey. The decoupling of the local matrices allows for a local evaluation of the operation. However, rather than a local matrix-vector multiplication, the local operations are evaluated as implemented in the function StdRegions::StdExpansion::GeneralMatrixOp.

Parameters

mkey	This key uniquely defines the type matrix required for the operation.
inarray	The vector $\boldsymbol{\hat{u}}_l$ of size $N_{\mathrm{eof}}$.
outarray	The resulting vector of size $N_{\mathrm{eof}}$.

Definition at line 2060 of file ExpList.cpp.

 {
     int nvarcoeffs = gkey.GetNVarCoeffs();
  
     if ((nvarcoeffs == 0) && (gkey.GetMatrixType() == StdRegions::eHelmholtz))
     {
         // initialise if required
         if (m_collections.size() &&
             m_collectionsDoInit[Collections::eHelmholtz])
         {
             for (int i = 0; i < m_collections.size(); ++i)
             {
                 m_collections[i].Initialise(Collections::eHelmholtz,
                                             gkey.GetConstFactors());
             }
             m_collectionsDoInit[Collections::eHelmholtz] = false;
         }
         else
         {
             for (int i = 0; i < m_collections.size(); ++i)
             {
                 m_collections[i].CheckFactors(Collections::eHelmholtz,
                                               gkey.GetConstFactors(),
                                               m_coll_phys_offset[i]);
             }
         }
  
         Array<OneD, NekDouble> tmp;
         for (int i = 0; i < m_collections.size(); ++i)
         {
             m_collections[i].ApplyOperator(
                 Collections::eHelmholtz, inarray + m_coll_coeff_offset[i],
                 tmp = outarray + m_coll_coeff_offset[i]);
         }
     }
     else
     {
         Array<OneD, NekDouble> tmp_outarray;
         for (int i = 0; i < (*m_exp).size(); ++i)
         {
             // need to be initialised with zero size for non
             // variable coefficient case
             StdRegions::VarCoeffMap varcoeffs;
  
             if (nvarcoeffs > 0)
             {
                 varcoeffs = StdRegions::RestrictCoeffMap(
                     gkey.GetVarCoeffs(), m_phys_offset[i],
                     (*m_exp)[i]->GetTotPoints());
             }
  
             StdRegions::StdMatrixKey mkey(
                 gkey.GetMatrixType(), (*m_exp)[i]->DetShapeType(),
                 *((*m_exp)[i]), gkey.GetConstFactors(), varcoeffs);
  
             (*m_exp)[i]->GeneralMatrixOp(
                 inarray + m_coeff_offset[i],
                 tmp_outarray = outarray + m_coeff_offset[i], mkey);
         }
     }
 }

References Nektar::Collections::eHelmholtz, Nektar::StdRegions::eHelmholtz, Nektar::MultiRegions::GlobalMatrixKey::GetConstFactors(), Nektar::MultiRegions::GlobalMatrixKey::GetMatrixType(), Nektar::MultiRegions::GlobalMatrixKey::GetNVarCoeffs(), Nektar::MultiRegions::GlobalMatrixKey::GetVarCoeffs(), m_coeff_offset, m_coll_coeff_offset, m_coll_phys_offset, m_collections, m_collectionsDoInit, m_exp, m_phys_offset, and Nektar::StdRegions::RestrictCoeffMap().

◆ GenerateElementVector()

void Nektar::MultiRegions::ExpList::GenerateElementVector	(	const int	ElementID,
		const NekDouble	scalar1,
		const NekDouble	scalar2,
		Array< OneD, NekDouble > &	outarray
	)

Generate vector v such that v[i] = scalar1 if i is in the element < ElementID. Otherwise, v[i] = scalar2.

Definition at line 3761 of file ExpList.cpp.

 {
     int npoints_e;
     NekDouble coeff;
  
     Array<OneD, NekDouble> outarray_e;
  
     for (int i = 0; i < (*m_exp).size(); ++i)
     {
         npoints_e = (*m_exp)[i]->GetTotPoints();
  
         if (i <= ElementID)
         {
             coeff = scalar1;
         }
         else
         {
             coeff = scalar2;
         }
  
         outarray_e = Array<OneD, NekDouble>(npoints_e, coeff);
         Vmath::Vcopy(npoints_e, &outarray_e[0], 1, &outarray[m_phys_offset[i]],
                      1);
     }
 }

References m_phys_offset, and Vmath::Vcopy().

◆ GenGlobalBndLinSys()

GlobalLinSysSharedPtr Nektar::MultiRegions::ExpList::GenGlobalBndLinSys	(	const GlobalLinSysKey &	mkey,
		const AssemblyMapSharedPtr &	locToGloMap
	)

protected

Generate a GlobalLinSys from information provided by the key "mkey" and the mapping provided in LocToGloBaseMap.

Definition at line 2434 of file ExpList.cpp.

 {
     std::shared_ptr<ExpList> vExpList                 = GetSharedThisPtr();
     const map<int, RobinBCInfoSharedPtr> vRobinBCInfo = GetRobinBCInfo();
  
     MultiRegions::GlobalSysSolnType vType = mkey.GetGlobalSysSolnType();
  
     if (vType >= eSIZE_GlobalSysSolnType)
     {
         NEKERROR(ErrorUtil::efatal, "Matrix solution type not defined");
     }
     std::string vSolnType = MultiRegions::GlobalSysSolnTypeMap[vType];
  
     return GetGlobalLinSysFactory().CreateInstance(vSolnType, mkey, vExpList,
                                                    locToGloMap);
 }

References Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::CreateInstance(), Nektar::ErrorUtil::efatal, Nektar::MultiRegions::eSIZE_GlobalSysSolnType, Nektar::MultiRegions::GetGlobalLinSysFactory(), Nektar::MultiRegions::GlobalLinSysKey::GetGlobalSysSolnType(), GetRobinBCInfo(), GetSharedThisPtr(), Nektar::MultiRegions::GlobalSysSolnTypeMap, and NEKERROR.

Referenced by Nektar::MultiRegions::DisContField::GetGlobalBndLinSys().

◆ GenGlobalLinSys()

GlobalLinSysSharedPtr Nektar::MultiRegions::ExpList::GenGlobalLinSys	(	const GlobalLinSysKey &	mkey,
		const std::shared_ptr< AssemblyMapCG > &	locToGloMap
	)

protected

This operation constructs the global linear system of type mkey.

Consider a linear system $\boldsymbol{M\hat{u}}_g=\boldsymbol{f}$ to be solved. Dependent on the solution method, this function constructs

The full linear system
A call to the function #GenGlobalLinSysFullDirect
The statically condensed linear system
A call to the function #GenGlobalLinSysStaticCond

Parameters

mkey	A key which uniquely defines the global matrix to be constructed.
locToGloMap	Contains the mapping array and required information for the transformation from local to global degrees of freedom.

Returns: (A shared pointer to) the global linear system in required format.

Definition at line 2416 of file ExpList.cpp.

 {
     GlobalLinSysSharedPtr returnlinsys;
     std::shared_ptr<ExpList> vExpList = GetSharedThisPtr();
  
     MultiRegions::GlobalSysSolnType vType = mkey.GetGlobalSysSolnType();
  
     if (vType >= eSIZE_GlobalSysSolnType)
     {
         NEKERROR(ErrorUtil::efatal, "Matrix solution type not defined");
     }
     std::string vSolnType = MultiRegions::GlobalSysSolnTypeMap[vType];
  
     return GetGlobalLinSysFactory().CreateInstance(vSolnType, mkey, vExpList,
                                                    locToGloMap);
 }

References Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::CreateInstance(), Nektar::ErrorUtil::efatal, Nektar::MultiRegions::eSIZE_GlobalSysSolnType, Nektar::MultiRegions::GetGlobalLinSysFactory(), Nektar::MultiRegions::GlobalLinSysKey::GetGlobalSysSolnType(), GetSharedThisPtr(), Nektar::MultiRegions::GlobalSysSolnTypeMap, and NEKERROR.

Referenced by Nektar::MultiRegions::ContField::GenGlobalLinSys().

◆ GenGlobalMatrix()

GlobalMatrixSharedPtr Nektar::MultiRegions::ExpList::GenGlobalMatrix	(	const GlobalMatrixKey &	mkey,
		const std::shared_ptr< AssemblyMapCG > &	locToGloMap
	)

protected

Generates a global matrix from the given key and map.

Retrieves local matrices from each expansion in the expansion list and combines them together to generate a global matrix system.

Parameters

mkey	Matrix key for the matrix to be generated.
locToGloMap	Local to global mapping.

Returns: Shared pointer to the generated global matrix.

Definition at line 2131 of file ExpList.cpp.

 {
     int i, j, n, gid1, gid2, cntdim1, cntdim2;
     NekDouble sign1, sign2;
     DNekScalMatSharedPtr loc_mat;
  
     unsigned int glob_rows = 0;
     unsigned int glob_cols = 0;
     unsigned int loc_rows  = 0;
     unsigned int loc_cols  = 0;
  
     bool assembleFirstDim  = false;
     bool assembleSecondDim = false;
  
     switch (mkey.GetMatrixType())
     {
         case StdRegions::eBwdTrans:
         {
             glob_rows = m_npoints;
             glob_cols = locToGloMap->GetNumGlobalCoeffs();
  
             assembleFirstDim  = false;
             assembleSecondDim = true;
         }
         break;
         case StdRegions::eIProductWRTBase:
         {
             glob_rows = locToGloMap->GetNumGlobalCoeffs();
             glob_cols = m_npoints;
  
             assembleFirstDim  = true;
             assembleSecondDim = false;
         }
         break;
         case StdRegions::eMass:
         case StdRegions::eHelmholtz:
         case StdRegions::eLaplacian:
         case StdRegions::eHybridDGHelmBndLam:
         {
             glob_rows = locToGloMap->GetNumGlobalCoeffs();
             glob_cols = locToGloMap->GetNumGlobalCoeffs();
  
             assembleFirstDim  = true;
             assembleSecondDim = true;
         }
         break;
         default:
         {
             NEKERROR(ErrorUtil::efatal,
                      "Global Matrix creation not defined for this "
                      "type of matrix");
         }
     }
  
     COOMatType spcoomat;
     CoordType coord;
  
     int nvarcoeffs = mkey.GetNVarCoeffs();
     int eid;
  
     // fill global matrix
     for (n = cntdim1 = cntdim2 = 0; n < (*m_exp).size(); ++n)
     {
         // need to be initialised with zero size for non
         // variable coefficient case
         StdRegions::VarCoeffMap varcoeffs;
  
         eid = n;
         if (nvarcoeffs > 0)
         {
             varcoeffs = StdRegions::RestrictCoeffMap(
                 mkey.GetVarCoeffs(), m_phys_offset[eid],
                 (*m_exp)[eid]->GetTotPoints());
         }
  
         LocalRegions::MatrixKey matkey(
             mkey.GetMatrixType(), (*m_exp)[eid]->DetShapeType(),
             *((*m_exp)[eid]), mkey.GetConstFactors(), varcoeffs);
  
         loc_mat =
             std::dynamic_pointer_cast<LocalRegions::Expansion>((*m_exp)[n])
                 ->GetLocMatrix(matkey);
  
         loc_rows = loc_mat->GetRows();
         loc_cols = loc_mat->GetColumns();
  
         for (i = 0; i < loc_rows; ++i)
         {
             if (assembleFirstDim)
             {
                 gid1  = locToGloMap->GetLocalToGlobalMap(cntdim1 + i);
                 sign1 = locToGloMap->GetLocalToGlobalSign(cntdim1 + i);
             }
             else
             {
                 gid1  = cntdim1 + i;
                 sign1 = 1.0;
             }
  
             for (j = 0; j < loc_cols; ++j)
             {
                 if (assembleSecondDim)
                 {
                     gid2  = locToGloMap->GetLocalToGlobalMap(cntdim2 + j);
                     sign2 = locToGloMap->GetLocalToGlobalSign(cntdim2 + j);
                 }
                 else
                 {
                     gid2  = cntdim2 + j;
                     sign2 = 1.0;
                 }
  
                 // sparse matrix fill
                 coord = make_pair(gid1, gid2);
                 if (spcoomat.count(coord) == 0)
                 {
                     spcoomat[coord] = sign1 * sign2 * (*loc_mat)(i, j);
                 }
                 else
                 {
                     spcoomat[coord] += sign1 * sign2 * (*loc_mat)(i, j);
                 }
             }
         }
         cntdim1 += loc_rows;
         cntdim2 += loc_cols;
     }
  
     return MemoryManager<GlobalMatrix>::AllocateSharedPtr(m_session, glob_rows,
                                                           glob_cols, spcoomat);
 }

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::StdRegions::eBwdTrans, Nektar::ErrorUtil::efatal, Nektar::StdRegions::eHelmholtz, Nektar::StdRegions::eHybridDGHelmBndLam, Nektar::StdRegions::eIProductWRTBase, Nektar::StdRegions::eLaplacian, Nektar::StdRegions::eMass, Nektar::MultiRegions::GlobalMatrixKey::GetConstFactors(), Nektar::MultiRegions::GlobalMatrixKey::GetMatrixType(), Nektar::MultiRegions::GlobalMatrixKey::GetNVarCoeffs(), Nektar::MultiRegions::GlobalMatrixKey::GetVarCoeffs(), m_exp, m_npoints, m_phys_offset, m_session, NEKERROR, and Nektar::StdRegions::RestrictCoeffMap().

Referenced by Nektar::MultiRegions::ContField::GetGlobalMatrix().

◆ GenGlobalMatrixFull()

DNekMatSharedPtr Nektar::MultiRegions::ExpList::GenGlobalMatrixFull	(	const GlobalLinSysKey &	mkey,
		const std::shared_ptr< AssemblyMapCG > &	locToGloMap
	)

protected

Definition at line 2264 of file ExpList.cpp.

 {
     int i, j, n, gid1, gid2, loc_lda, eid;
     NekDouble sign1, sign2, value;
     DNekScalMatSharedPtr loc_mat;
  
     int totDofs   = locToGloMap->GetNumGlobalCoeffs();
     int NumDirBCs = locToGloMap->GetNumGlobalDirBndCoeffs();
  
     unsigned int rows = totDofs - NumDirBCs;
     unsigned int cols = totDofs - NumDirBCs;
     NekDouble zero    = 0.0;
  
     DNekMatSharedPtr Gmat;
     int bwidth = locToGloMap->GetFullSystemBandWidth();
  
     int nvarcoeffs = mkey.GetNVarCoeffs();
     MatrixStorage matStorage;
  
     map<int, RobinBCInfoSharedPtr> RobinBCInfo = GetRobinBCInfo();
  
     switch (mkey.GetMatrixType())
     {
             // case for all symmetric matices
         case StdRegions::eHelmholtz:
         case StdRegions::eLaplacian:
             if ((2 * (bwidth + 1)) < rows)
             {
                 matStorage = ePOSITIVE_DEFINITE_SYMMETRIC_BANDED;
                 Gmat       = MemoryManager<DNekMat>::AllocateSharedPtr(
                     rows, cols, zero, matStorage, bwidth, bwidth);
             }
             else
             {
                 matStorage = ePOSITIVE_DEFINITE_SYMMETRIC;
                 Gmat       = MemoryManager<DNekMat>::AllocateSharedPtr(
                     rows, cols, zero, matStorage);
             }
  
             break;
         default: // Assume general matrix - currently only set up
             // for full invert
             {
                 matStorage = eFULL;
                 Gmat       = MemoryManager<DNekMat>::AllocateSharedPtr(
                     rows, cols, zero, matStorage);
             }
     }
  
     // fill global symmetric matrix
     for (n = 0; n < (*m_exp).size(); ++n)
     {
         // need to be initialised with zero size for non
         // variable coefficient case
         StdRegions::VarCoeffMap varcoeffs;
  
         eid = n;
         if (nvarcoeffs > 0)
         {
             varcoeffs = StdRegions::RestrictCoeffMap(
                 mkey.GetVarCoeffs(), m_phys_offset[eid],
                 (*m_exp)[eid]->GetTotPoints());
         }
  
         LocalRegions::MatrixKey matkey(
             mkey.GetMatrixType(), (*m_exp)[eid]->DetShapeType(),
             *((*m_exp)[eid]), mkey.GetConstFactors(), varcoeffs);
  
         loc_mat =
             std::dynamic_pointer_cast<LocalRegions::Expansion>((*m_exp)[n])
                 ->GetLocMatrix(matkey);
  
         if (RobinBCInfo.count(n) != 0) // add robin mass matrix
         {
             RobinBCInfoSharedPtr rBC;
  
             // declare local matrix from scaled matrix.
             int rows             = loc_mat->GetRows();
             int cols             = loc_mat->GetColumns();
             const NekDouble *dat = loc_mat->GetRawPtr();
             DNekMatSharedPtr new_mat =
                 MemoryManager<DNekMat>::AllocateSharedPtr(rows, cols, dat);
             Blas::Dscal(rows * cols, loc_mat->Scale(), new_mat->GetRawPtr(), 1);
  
             // add local matrix contribution
             for (rBC = RobinBCInfo.find(n)->second; rBC; rBC = rBC->next)
             {
                 (*m_exp)[n]->AddRobinMassMatrix(
                     rBC->m_robinID, rBC->m_robinPrimitiveCoeffs, new_mat);
             }
  
             NekDouble one = 1.0;
             // redeclare loc_mat to point to new_mat plus the scalar.
             loc_mat =
                 MemoryManager<DNekScalMat>::AllocateSharedPtr(one, new_mat);
         }
  
         loc_lda = loc_mat->GetColumns();
  
         for (i = 0; i < loc_lda; ++i)
         {
             gid1 = locToGloMap->GetLocalToGlobalMap(m_coeff_offset[n] + i) -
                    NumDirBCs;
             sign1 = locToGloMap->GetLocalToGlobalSign(m_coeff_offset[n] + i);
             if (gid1 >= 0)
             {
                 for (j = 0; j < loc_lda; ++j)
                 {
                     gid2 = locToGloMap->GetLocalToGlobalMap(m_coeff_offset[n] +
                                                             j) -
                            NumDirBCs;
                     sign2 = locToGloMap->GetLocalToGlobalSign(
                         m_coeff_offset[n] + j);
                     if (gid2 >= 0)
                     {
                         // When global matrix is symmetric,
                         // only add the value for the upper
                         // triangular part in order to avoid
                         // entries to be entered twice
                         if ((matStorage == eFULL) || (gid2 >= gid1))
                         {
                             value = Gmat->GetValue(gid1, gid2) +
                                     sign1 * sign2 * (*loc_mat)(i, j);
                             Gmat->SetValue(gid1, gid2, value);
                         }
                     }
                 }
             }
         }
     }
  
     return Gmat;
 }

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Blas::Dscal(), Nektar::eFULL, Nektar::StdRegions::eHelmholtz, Nektar::StdRegions::eLaplacian, Nektar::ePOSITIVE_DEFINITE_SYMMETRIC, Nektar::ePOSITIVE_DEFINITE_SYMMETRIC_BANDED, Nektar::MultiRegions::GlobalMatrixKey::GetConstFactors(), Nektar::MultiRegions::GlobalMatrixKey::GetMatrixType(), Nektar::MultiRegions::GlobalMatrixKey::GetNVarCoeffs(), GetRobinBCInfo(), Nektar::MultiRegions::GlobalMatrixKey::GetVarCoeffs(), m_coeff_offset, m_exp, m_phys_offset, Nektar::MultiRegions::RobinBCInfo::next, and Nektar::StdRegions::RestrictCoeffMap().

Referenced by Nektar::MultiRegions::ContField::LinearAdvectionEigs().

◆ Get1DScaledTotPoints()

int Nektar::MultiRegions::ExpList::Get1DScaledTotPoints ( const NekDouble scale ) const

inline

Returns the total number of qudature points scaled by the factor scale on each 1D direction.

Definition at line 1547 of file ExpList.h.

 {
     int returnval = 0;
     size_t cnt;
     size_t nbase = (*m_exp)[0]->GetNumBases();
  
     for (size_t i = 0; i < (*m_exp).size(); ++i)
     {
         cnt = 1;
         for (size_t j = 0; j < nbase; ++j)
         {
             cnt *= scale * ((*m_exp)[i]->GetNumPoints(j));
         }
         returnval += cnt;
     }
     return returnval;
 }

◆ GetBCValues()

void Nektar::MultiRegions::ExpList::GetBCValues	(	Array< OneD, NekDouble > &	BndVals,
		const Array< OneD, NekDouble > &	TotField,
		int	BndID
	)

inline

Definition at line 1836 of file ExpList.h.

 {
     v_GetBCValues(BndVals, TotField, BndID);
 }

References v_GetBCValues().

◆ GetBlockMatrix()

const DNekScalBlkMatSharedPtr & Nektar::MultiRegions::ExpList::GetBlockMatrix ( const GlobalMatrixKey & gkey )

protected

Definition at line 2016 of file ExpList.cpp.

 {
     auto matrixIter = m_blockMat->find(gkey);
  
     if (matrixIter == m_blockMat->end())
     {
         return ((*m_blockMat)[gkey] = GenBlockMatrix(gkey));
     }
     else
     {
         return matrixIter->second;
     }
 }

References GenBlockMatrix(), and m_blockMat.

Referenced by MultiplyByBlockMatrix(), MultiplyByElmtInvMass(), and Nektar::MultiRegions::DisContField::v_HelmSolve().

◆ GetBndCondBwdWeight()

const Array< OneD, const NekDouble > & Nektar::MultiRegions::ExpList::GetBndCondBwdWeight ( )

inline

Get the weight value for boundary conditions.

Definition at line 2086 of file ExpList.h.

 {
     return v_GetBndCondBwdWeight();
 }

References v_GetBndCondBwdWeight().

◆ GetBndCondExpansions()

const Array< OneD, const std::shared_ptr< ExpList > > & Nektar::MultiRegions::ExpList::GetBndCondExpansions ( )

inline

Definition at line 2071 of file ExpList.h.

 {
     return v_GetBndCondExpansions();
 }

References v_GetBndCondExpansions().

Referenced by v_ExtractElmtToBndPhys(), v_ExtractPhysToBnd(), v_ExtractPhysToBndElmt(), v_GetBoundaryNormals(), and Nektar::MultiRegions::DisContField3DHomogeneous1D::v_GetBoundaryNormals().

◆ GetBndConditions()

const Array< OneD, const SpatialDomains::BoundaryConditionShPtr > & Nektar::MultiRegions::ExpList::GetBndConditions ( )

inline

Definition at line 2202 of file ExpList.h.

 {
     return v_GetBndConditions();
 }

References v_GetBndConditions().

◆ GetBndElmtExpansion()

void Nektar::MultiRegions::ExpList::GetBndElmtExpansion	(	int	i,
		std::shared_ptr< ExpList > &	result,
		const bool	DeclareCoeffPhysArrays = `true`
	)

inlinevirtual

Definition at line 2227 of file ExpList.h.

 {
     v_GetBndElmtExpansion(i, result, DeclareCoeffPhysArrays);
 }

References v_GetBndElmtExpansion().

◆ GetBoundaryCondition()

SpatialDomains::BoundaryConditionShPtr Nektar::MultiRegions::ExpList::GetBoundaryCondition	(	const SpatialDomains::BoundaryConditionCollection &	collection,
		unsigned int	index,
		const std::string &	variable
	)

staticprotected

Definition at line 5070 of file ExpList.cpp.

 {
     auto collectionIter = collection.find(regionId);
     ASSERTL1(collectionIter != collection.end(),
              "Unable to locate collection " +
                  boost::lexical_cast<string>(regionId));
  
     const SpatialDomains::BoundaryConditionMapShPtr bndCondMap =
         (*collectionIter).second;
     auto conditionMapIter = bndCondMap->find(variable);
     ASSERTL1(conditionMapIter != bndCondMap->end(),
              "Unable to locate condition map.");
  
     const SpatialDomains::BoundaryConditionShPtr boundaryCondition =
         (*conditionMapIter).second;
  
     return boundaryCondition;
 }

References ASSERTL1.

Referenced by Nektar::MultiRegions::DisContField::FindPeriodicTraces(), Nektar::MultiRegions::DisContField::GenerateBoundaryConditionExpansion(), and Nektar::MultiRegions::DisContField3DHomogeneous1D::SetupBoundaryConditions().

◆ GetBoundaryNormals()

void Nektar::MultiRegions::ExpList::GetBoundaryNormals	(	int	i,
		Array< OneD, Array< OneD, NekDouble >> &	normals
	)

inline

Definition at line 2255 of file ExpList.h.

 {
     v_GetBoundaryNormals(i, normals);
 }

References v_GetBoundaryNormals().

◆ GetBoundaryToElmtMap()

void Nektar::MultiRegions::ExpList::GetBoundaryToElmtMap	(	Array< OneD, int > &	ElmtID,
		Array< OneD, int > &	EdgeID
	)

inline

Definition at line 2222 of file ExpList.h.

 {
     v_GetBoundaryToElmtMap(ElmtID, EdgeID);
 }

References v_GetBoundaryToElmtMap().

Referenced by Nektar::MultiRegions::DisContField::DisContField(), v_ExtractElmtToBndPhys(), v_ExtractPhysToBnd(), v_ExtractPhysToBndElmt(), Nektar::MultiRegions::DisContField::v_GetBndElmtExpansion(), Nektar::MultiRegions::DisContField3DHomogeneous1D::v_GetBndElmtExpansion(), Nektar::MultiRegions::DisContField3DHomogeneous2D::v_GetBndElmtExpansion(), v_GetBoundaryNormals(), Nektar::MultiRegions::DisContField3DHomogeneous1D::v_GetBoundaryNormals(), and Nektar::MultiRegions::DisContField::v_GetRobinBCInfo().

◆ GetBwdWeight()

void Nektar::MultiRegions::ExpList::GetBwdWeight	(	Array< OneD, NekDouble > &	weightAver,
		Array< OneD, NekDouble > &	weightJump
	)

Get the weight value for boundary conditions for boundary average and jump calculations.

Get the weight value on boundaries

Definition at line 3704 of file ExpList.cpp.

 {
     size_t nTracePts = weightAver.size();
     // average for interior traces
     for (int i = 0; i < nTracePts; ++i)
     {
         weightAver[i] = 0.5;
         weightJump[i] = 1.0;
     }
     FillBwdWithBwdWeight(weightAver, weightJump);
 }

References FillBwdWithBwdWeight().

◆ GetCoeff()

NekDouble Nektar::MultiRegions::ExpList::GetCoeff ( int i )

inline

Get the i th value (coefficient) of m_coeffs.

Parameters

i	The index of m_coeffs to be returned

Returns: The NekDouble held in m_coeffs[i].

Definition at line 1968 of file ExpList.h.

 {
     return m_coeffs[i];
 }

References m_coeffs.

Referenced by Nektar::MultiRegions::DisContField::v_EvaluateBoundaryConditions().

◆ GetCoeff_Offset()

int Nektar::MultiRegions::ExpList::GetCoeff_Offset ( int n ) const

inline

Get the start offset position for a local contiguous list of coeffs correspoinding to element n.

Definition at line 2037 of file ExpList.h.

 {
     return m_coeff_offset[n];
 }

References m_coeff_offset.

◆ GetCoeffs() [1/2]

const Array< OneD, const NekDouble > & Nektar::MultiRegions::ExpList::GetCoeffs ( void ) const

inline

This function returns (a reference to) the array $\boldsymbol{\hat{u}}_l$ (implemented as m_coeffs) containing all local expansion coefficients.

As the function returns a constant reference to a const Array, it is not possible to modify the underlying data of the array m_coeffs. In order to do so, use the function UpdateCoeffs instead.

Returns: (A constant reference to) the array m_coeffs.

Definition at line 1902 of file ExpList.h.

 {
     return m_coeffs;
 }

References m_coeffs.

Referenced by Nektar::MultiRegions::ContField::LaplaceSolve(), Nektar::MultiRegions::DisContField3DHomogeneous2D::v_EvaluateBoundaryConditions(), Nektar::MultiRegions::DisContField::v_GetBndElmtExpansion(), Nektar::MultiRegions::DisContField3DHomogeneous1D::v_GetBndElmtExpansion(), Nektar::MultiRegions::DisContField3DHomogeneous2D::v_GetBndElmtExpansion(), Nektar::MultiRegions::ContField::v_HelmSolve(), Nektar::MultiRegions::ExpList3DHomogeneous1D::v_HomogeneousEnergy(), Nektar::MultiRegions::ContField::v_ImposeDirichletConditions(), and Nektar::MultiRegions::ContField::v_LinearAdvectionDiffusionReactionSolve().

◆ GetCoeffs() [2/2]

NekDouble Nektar::MultiRegions::ExpList::GetCoeffs ( int i )

inline

Get the i th value (coefficient) of m_coeffs.

Parameters

i	The index of m_coeffs to be returned

Returns: The NekDouble held in m_coeffs[i].

Definition at line 1976 of file ExpList.h.

 {
     return m_coeffs[i];
 }

References m_coeffs.

◆ GetCoeffsToElmt()

const Array< OneD, const std::pair< int, int > > & Nektar::MultiRegions::ExpList::GetCoeffsToElmt ( ) const

inline

Get m_coeffs to elemental value map.

Definition at line 2077 of file ExpList.h.

 {
     return m_coeffsToElmt;
 }

References m_coeffsToElmt.

Referenced by Nektar::MultiRegions::LocTraceToTraceMap::TraceLocToElmtLocCoeffMap().

◆ GetComm()

std::shared_ptr<LibUtilities::Comm> Nektar::MultiRegions::ExpList::GetComm ( ) const

inline

Returns the comm object.

Definition at line 960 of file ExpList.h.

     {
         return m_comm;
     }

References m_comm.

Referenced by Nektar::MultiRegions::AssemblyCommDG::AssemblyCommDG(), and Nektar::MultiRegions::AssemblyMapCG::v_LinearSpaceMap().

◆ GetCoordim()

int Nektar::MultiRegions::ExpList::GetCoordim ( int eid )

inline

This function returns the dimension of the coordinates of the element eid.

Parameters

eid	The index of the element to be checked.

Returns: The dimension of the coordinates of the specific element.

Definition at line 1861 of file ExpList.h.

 {
     ASSERTL2(eid <= (*m_exp).size(), "eid is larger than number of elements");
     return (*m_exp)[eid]->GetCoordim();
 }

References ASSERTL2, and m_exp.

Referenced by GetExpIndex(), IProductWRTDerivBase(), PhysEvaluate(), v_GetBoundaryNormals(), Nektar::MultiRegions::DisContField3DHomogeneous1D::v_GetBoundaryNormals(), v_GetCoords(), Nektar::MultiRegions::ExpList2DHomogeneous1D::v_GetCoords(), v_GetNormals(), Nektar::MultiRegions::ExpList2DHomogeneous1D::v_GetNormals(), v_NormVectorIProductWRTBase(), v_Upwind(), v_WriteTecplotZone(), Nektar::MultiRegions::ExpList2DHomogeneous1D::v_WriteTecplotZone(), and Nektar::MultiRegions::ExpList2DHomogeneous2D::v_WriteTecplotZone().

◆ GetCoords() [1/2]

void Nektar::MultiRegions::ExpList::GetCoords	(	Array< OneD, NekDouble > &	coord_0,
		Array< OneD, NekDouble > &	coord_1 = `NullNekDouble1DArray`,
		Array< OneD, NekDouble > &	coord_2 = `NullNekDouble1DArray`
	)

inline

This function calculates the coordinates of all the elemental quadrature points $\boldsymbol{x}_i$.

Definition at line 1728 of file ExpList.h.

 {
     v_GetCoords(coord_0, coord_1, coord_2);
 }

References v_GetCoords().

Referenced by v_WriteTecplotZone(), Nektar::MultiRegions::ExpList2DHomogeneous1D::v_WriteTecplotZone(), Nektar::MultiRegions::ExpList2DHomogeneous2D::v_WriteTecplotZone(), Nektar::MultiRegions::ExpList3DHomogeneous2D::v_WriteTecplotZone(), Nektar::MultiRegions::ExpList2DHomogeneous1D::v_WriteVtkPieceHeader(), Nektar::MultiRegions::ExpList2DHomogeneous2D::v_WriteVtkPieceHeader(), and Nektar::MultiRegions::ExpList3DHomogeneous2D::v_WriteVtkPieceHeader().

◆ GetCoords() [2/2]

void Nektar::MultiRegions::ExpList::GetCoords	(	const int	eid,
		Array< OneD, NekDouble > &	coord_0,
		Array< OneD, NekDouble > &	coord_1 = `NullNekDouble1DArray`,
		Array< OneD, NekDouble > &	coord_2 = `NullNekDouble1DArray`
	)

inline

Definition at line 1735 of file ExpList.h.

 {
     v_GetCoords(eid, xc0, xc1, xc2);
 }

References v_GetCoords().

◆ GetDiagMatIpwrtBase()

void Nektar::MultiRegions::ExpList::GetDiagMatIpwrtBase	(	const Array< OneD, const Array< OneD, NekDouble >> &	inarray,
		Array< OneD, DNekMatSharedPtr > &	mtxPerVar
	)

Definition at line 5549 of file ExpList.cpp.

 {
     LibUtilities::ShapeType ElmtTypePrevious = LibUtilities::eNoShapeType;
     int nElmtPntPrevious                     = 0;
     int nElmtCoefPrevious                    = 0;
     int nTotElmt                             = (*m_exp).size();
     int nElmtPnt                             = (*m_exp)[0]->GetTotPoints();
     int nElmtCoef                            = (*m_exp)[0]->GetNcoeffs();
  
     Array<OneD, NekDouble> tmpPhys;
     Array<OneD, NekDouble> clmnArray, clmnStdMatArray;
     Array<OneD, NekDouble> stdMat_data;
  
     for (int nelmt = 0; nelmt < nTotElmt; nelmt++)
     {
         nElmtCoef                           = (*m_exp)[nelmt]->GetNcoeffs();
         nElmtPnt                            = (*m_exp)[nelmt]->GetTotPoints();
         LibUtilities::ShapeType ElmtTypeNow = (*m_exp)[nelmt]->DetShapeType();
  
         if (nElmtPntPrevious != nElmtPnt || nElmtCoefPrevious != nElmtCoef ||
             (ElmtTypeNow != ElmtTypePrevious))
         {
             StdRegions::StdExpansionSharedPtr stdExp;
             stdExp = (*m_exp)[nelmt]->GetStdExp();
             StdRegions::StdMatrixKey matkey(StdRegions::eBwdMat,
                                             stdExp->DetShapeType(), *stdExp);
  
             DNekMatSharedPtr BwdMat = stdExp->GetStdMatrix(matkey);
             stdMat_data             = BwdMat->GetPtr();
  
             if (nElmtPntPrevious != nElmtPnt)
             {
                 tmpPhys = Array<OneD, NekDouble>(nElmtPnt, 0.0);
             }
  
             ElmtTypePrevious  = ElmtTypeNow;
             nElmtPntPrevious  = nElmtPnt;
             nElmtCoefPrevious = nElmtCoef;
         }
  
         (*m_exp)[nelmt]->MultiplyByQuadratureMetric(
             inarray[nelmt],
             tmpPhys); // weight with metric
  
         Array<OneD, NekDouble> MatDataArray = mtxPerVar[nelmt]->GetPtr();
  
         for (int np = 0; np < nElmtPnt; np++)
         {
             NekDouble factor = tmpPhys[np];
             clmnArray        = MatDataArray + np * nElmtCoef;
             clmnStdMatArray  = stdMat_data + np * nElmtCoef;
             Vmath::Smul(nElmtCoef, factor, clmnStdMatArray, 1, clmnArray, 1);
         }
     }
 }

References Nektar::StdRegions::eBwdMat, Nektar::LibUtilities::eNoShapeType, and Vmath::Smul().

◆ GetElmtNormalLength()

void Nektar::MultiRegions::ExpList::GetElmtNormalLength	(	Array< OneD, NekDouble > &	lengthsFwd,
		Array< OneD, NekDouble > &	lengthsBwd
	)

Get the length of elements in boundary normal direction.

Definition at line 4232 of file ExpList.cpp.

 {
     int e_npoints;
  
     Array<OneD, NekDouble> locLeng;
     Array<OneD, Array<OneD, NekDouble>> lengintp(2);
     Array<OneD, Array<OneD, NekDouble>> lengAdd(2);
     Array<OneD, int> LRbndnumbs(2);
     Array<OneD, Array<OneD, NekDouble>> lengLR(2);
     lengLR[0] = lengthsFwd;
     lengLR[1] = lengthsBwd;
     Array<OneD, LocalRegions::ExpansionSharedPtr> LRelmts(2);
     LocalRegions::ExpansionSharedPtr loc_elmt;
     LocalRegions::ExpansionSharedPtr loc_exp;
     int e_npoints0 = -1;
     if (m_expType == e1D)
     {
         for (int i = 0; i < m_exp->size(); ++i)
         {
             loc_exp    = (*m_exp)[i];
             int offset = m_phys_offset[i];
  
             int e_nmodes = loc_exp->GetBasis(0)->GetNumModes();
             e_npoints    = (*m_exp)[i]->GetNumPoints(0);
             if (e_npoints0 < e_npoints)
             {
                 for (int nlr = 0; nlr < 2; nlr++)
                 {
                     lengintp[nlr] = Array<OneD, NekDouble>(e_npoints, 0.0);
                 }
                 e_npoints0 = e_npoints;
             }
  
             LRelmts[0] = loc_exp->GetLeftAdjacentElementExp();
             LRelmts[1] = loc_exp->GetRightAdjacentElementExp();
  
             LRbndnumbs[0] = loc_exp->GetLeftAdjacentElementTrace();
             LRbndnumbs[1] = loc_exp->GetRightAdjacentElementTrace();
             for (int nlr = 0; nlr < 2; ++nlr)
             {
                 Vmath::Zero(e_npoints0, lengintp[nlr], 1);
                 lengAdd[nlr]  = lengintp[nlr];
                 int bndNumber = LRbndnumbs[nlr];
                 loc_elmt      = LRelmts[nlr];
                 if (bndNumber >= 0)
                 {
                     locLeng = loc_elmt->GetElmtBndNormDirElmtLen(bndNumber);
                     lengAdd[nlr] = locLeng;
  
                     int loc_nmodes = loc_elmt->GetBasis(0)->GetNumModes();
                     if (e_nmodes != loc_nmodes)
                     {
                         // Parallel case: need to interpolate.
                         LibUtilities::PointsKey to_key =
                             loc_exp->GetBasis(0)->GetPointsKey();
                         LibUtilities::PointsKey from_key =
                             loc_elmt->GetBasis(0)->GetPointsKey();
                         LibUtilities::Interp1D(from_key, locLeng, to_key,
                                                lengintp[nlr]);
                         lengAdd[nlr] = lengintp[nlr];
                     }
                 }
  
                 for (int j = 0; j < e_npoints; ++j)
                 {
                     lengLR[nlr][offset + j] = lengAdd[nlr][j];
                 }
             }
         }
     }
     else if (m_expType == e2D)
     {
         for (int i = 0; i < m_exp->size(); ++i)
         {
             loc_exp    = (*m_exp)[i];
             int offset = m_phys_offset[i];
  
             LibUtilities::BasisKey traceBasis0 =
                 loc_exp->GetBasis(0)->GetBasisKey();
             LibUtilities::BasisKey traceBasis1 =
                 loc_exp->GetBasis(1)->GetBasisKey();
             const int TraceNq0 = traceBasis0.GetNumPoints();
             const int TraceNq1 = traceBasis1.GetNumPoints();
             e_npoints          = TraceNq0 * TraceNq1;
             if (e_npoints0 < e_npoints)
             {
                 for (int nlr = 0; nlr < 2; nlr++)
                 {
                     lengintp[nlr] = Array<OneD, NekDouble>(e_npoints, 0.0);
                 }
                 e_npoints0 = e_npoints;
             }
  
             LRelmts[0] = loc_exp->GetLeftAdjacentElementExp();
             LRelmts[1] = loc_exp->GetRightAdjacentElementExp();
  
             LRbndnumbs[0] = loc_exp->GetLeftAdjacentElementTrace();
             LRbndnumbs[1] = loc_exp->GetRightAdjacentElementTrace();
             for (int nlr = 0; nlr < 2; ++nlr)
             {
                 Vmath::Zero(e_npoints0, lengintp[nlr], 1);
                 int bndNumber = LRbndnumbs[nlr];
                 loc_elmt      = LRelmts[nlr];
                 if (bndNumber >= 0)
                 {
                     locLeng = loc_elmt->GetElmtBndNormDirElmtLen(bndNumber);
                     // Project normals from 3D element onto the
                     // same orientation as the trace expansion.
                     StdRegions::Orientation orient =
                         loc_elmt->GetTraceOrient(bndNumber);
  
                     int fromid0, fromid1;
                     if (orient < StdRegions::eDir1FwdDir2_Dir2FwdDir1)
                     {
                         fromid0 = 0;
                         fromid1 = 1;
                     }
                     else
                     {
                         fromid0 = 1;
                         fromid1 = 0;
                     }
  
                     LibUtilities::BasisKey faceBasis0 =
                         loc_elmt->GetTraceBasisKey(bndNumber, fromid0);
                     LibUtilities::BasisKey faceBasis1 =
                         loc_elmt->GetTraceBasisKey(bndNumber, fromid1);
                     const int faceNq0 = faceBasis0.GetNumPoints();
                     const int faceNq1 = faceBasis1.GetNumPoints();
                     Array<OneD, NekDouble> alignedLeng(faceNq0 * faceNq1);
  
                     AlignFace(orient, faceNq0, faceNq1, locLeng, alignedLeng);
                     LibUtilities::Interp2D(
                         faceBasis0.GetPointsKey(), faceBasis1.GetPointsKey(),
                         alignedLeng, traceBasis0.GetPointsKey(),
                         traceBasis1.GetPointsKey(), lengintp[nlr]);
                 }
  
                 for (int j = 0; j < e_npoints; ++j)
                 {
                     lengLR[nlr][offset + j] = lengintp[nlr][j];
                 }
             }
         }
     }
 }

References Nektar::MultiRegions::AlignFace(), Nektar::MultiRegions::e1D, Nektar::MultiRegions::e2D, Nektar::StdRegions::eDir1FwdDir2_Dir2FwdDir1, Nektar::LibUtilities::BasisKey::GetNumPoints(), Nektar::LibUtilities::BasisKey::GetPointsKey(), Nektar::LibUtilities::Interp1D(), Nektar::LibUtilities::Interp2D(), m_exp, m_expType, m_phys_offset, and Vmath::Zero().

◆ GetElmtToExpId() [1/2]

int Nektar::MultiRegions::ExpList::GetElmtToExpId ( int elmtId )

inline

This function returns the index inside m_exp for a given geom id.

Definition at line 1032 of file ExpList.h.

     {
         auto it = m_elmtToExpId.find(elmtId);
         ASSERTL0(it != m_elmtToExpId.end(), "Global geometry ID " +
                                                 std::to_string(elmtId) +
                                                 " not found in element ID to "
                                                 "expansion ID map.")
         return it->second;
     }

References ASSERTL0, and m_elmtToExpId.

◆ GetElmtToExpId() [2/2]

const std::unordered_map<int, int>& Nektar::MultiRegions::ExpList::GetElmtToExpId ( void )

inline

This function returns the map of index inside m_exp to geom id.

Definition at line 1026 of file ExpList.h.

     {
         return m_elmtToExpId;
     }

References m_elmtToExpId.

◆ GetExp() [1/3]

const std::shared_ptr< LocalRegions::ExpansionVector > Nektar::MultiRegions::ExpList::GetExp ( void ) const

inline

This function returns the vector of elements in the expansion.

Returns: (A const shared pointer to) the local expansion vector m_exp

Definition at line 2029 of file ExpList.h.

 {
     return m_exp;
 }

References m_exp.

◆ GetExp() [2/3]

LocalRegions::ExpansionSharedPtr & Nektar::MultiRegions::ExpList::GetExp ( const Array< OneD, const NekDouble > & gloCoord )

This function returns (a shared pointer to) the local elemental expansion containing the arbitrary point given by gloCoord.

Definition at line 2510 of file ExpList.cpp.

 {
     return GetExp(GetExpIndex(gloCoord));
 }

References GetExp(), and GetExpIndex().

◆ GetExp() [3/3]

LocalRegions::ExpansionSharedPtr & Nektar::MultiRegions::ExpList::GetExp ( int n ) const

inline

This function returns (a shared pointer to) the local elemental expansion of the $n^{\mathrm{th}}$ element.

Parameters

n	The index of the element concerned.

Returns: (A shared pointer to) the local expansion of the $n^{\mathrm{th}}$ element.

Definition at line 2006 of file ExpList.h.

 {
     return (*m_exp)[n];
 }

References m_exp.

◆ GetExpFromGeomId()

LocalRegions::ExpansionSharedPtr & Nektar::MultiRegions::ExpList::GetExpFromGeomId ( int n )

inline

This function returns (a shared pointer to) the local elemental expansion of the $n^{\mathrm{th}}$ element given a global geometry ID.

Parameters

n	The global id of the element concerned.

Returns: (A shared pointer to) the local expansion of the $n^{\mathrm{th}}$ element.

Definition at line 2016 of file ExpList.h.

 {
     auto it = m_elmtToExpId.find(n);
     ASSERTL0(it != m_elmtToExpId.end(), "Global geometry ID " +
                                             std::to_string(n) +
                                             " not found in element ID to "
                                             "expansion ID map.")
     return (*m_exp)[it->second];
 }

References ASSERTL0, m_elmtToExpId, and m_exp.

◆ GetExpIndex() [1/2]

int Nektar::MultiRegions::ExpList::GetExpIndex	(	const Array< OneD, const NekDouble > &	gloCoord,
		NekDouble	tol = `0.0`,
		bool	returnNearestElmt = `false`,
		int	cachedId = `-1`,
		NekDouble	maxDistance = `1e6`
	)

This function returns the index of the local elemental expansion containing the arbitrary point given by gloCoord, within a distance tolerance of tol.

If returnNearestElmt is true and no element contains the point, this function returns the nearest element whose bounding box contains the point. The bounding box has a 10% margin in each direction.

Parameters

gloCoord	(input) coordinate in physics space
locCoords	(output) local coordinate xi in the returned element
tol	distance tolerance to judge if a point lies in an element
returnNearestElmt	if true and no element contains this point, the nearest element whose bounding box contains this point is returned
cachedId	an initial guess of the most possible element index
maxDistance	if returnNearestElmt is set as true, the nearest element will be returned. But the distance of the nearest element and this point should be <= maxDistance.

Returns: element index; if no element is found, -1 is returned.

Todo:: need a smarter search here that first just looks at bounding vertices - suggest first seeing if point is within 10% of region defined by vertices. The do point search.

Definition at line 2521 of file ExpList.cpp.

 {
     Array<OneD, NekDouble> Lcoords(gloCoord.size());
  
     return GetExpIndex(gloCoord, Lcoords, tol, returnNearestElmt, cachedId,
                        maxDistance);
 }

Referenced by GetExp(), and PhysEvaluate().

◆ GetExpIndex() [2/2]

int Nektar::MultiRegions::ExpList::GetExpIndex	(	const Array< OneD, const NekDouble > &	gloCoords,
		Array< OneD, NekDouble > &	locCoords,
		NekDouble	tol = `0.0`,
		bool	returnNearestElmt = `false`,
		int	cachedId = `-1`,
		NekDouble	maxDistance = `1e6`
	)

This function returns the index and the Local Cartesian Coordinates locCoords of the local elemental expansion containing the arbitrary point given by gloCoords.

Definition at line 2531 of file ExpList.cpp.

 {
     if (GetNumElmts() == 0)
     {
         return -1;
     }
  
     if (m_elmtToExpId.size() == 0)
     {
         // Loop in reverse order so that in case where using a
         // Homogeneous expansion it sets geometry ids to first part of
         // m_exp list. Otherwise will set to second (complex) expansion
         for (int i = (*m_exp).size() - 1; i >= 0; --i)
         {
             m_elmtToExpId[(*m_exp)[i]->GetGeom()->GetGlobalID()] = i;
         }
     }
  
     NekDouble nearpt     = 1e6;
     NekDouble nearpt_min = 1e6;
     int min_id           = -1;
     Array<OneD, NekDouble> savLocCoords(locCoords.size());
  
     if (cachedId >= 0 && cachedId < (*m_exp).size())
     {
         nearpt = 1e12;
         if ((*m_exp)[cachedId]->GetGeom()->MinMaxCheck(gloCoords) &&
             (*m_exp)[cachedId]->GetGeom()->ContainsPoint(gloCoords, locCoords,
                                                          tol, nearpt))
         {
             return cachedId;
         }
         else if (returnNearestElmt && (nearpt < nearpt_min))
         {
             // If it does not lie within, keep track of which element
             // is nearest.
             min_id     = cachedId;
             nearpt_min = nearpt;
             Vmath::Vcopy(locCoords.size(), locCoords, 1, savLocCoords, 1);
         }
     }
  
     NekDouble x = (gloCoords.size() > 0 ? gloCoords[0] : 0.0);
     NekDouble y = (gloCoords.size() > 1 ? gloCoords[1] : 0.0);
     NekDouble z = (gloCoords.size() > 2 ? gloCoords[2] : 0.0);
     SpatialDomains::PointGeomSharedPtr p =
         MemoryManager<SpatialDomains::PointGeom>::AllocateSharedPtr(
             GetExp(0)->GetCoordim(), -1, x, y, z);
  
     // Get the list of elements whose bounding box contains the desired
     // point.
     std::vector<int> elmts = m_graph->GetElementsContainingPoint(p);
  
     // Check each element in turn to see if point lies within it.
     for (int i = 0; i < elmts.size(); ++i)
     {
         int id = m_elmtToExpId[elmts[i]];
         if (id == cachedId)
         {
             continue;
         }
         if ((*m_exp)[id]->GetGeom()->ContainsPoint(gloCoords, locCoords, tol,
                                                    nearpt))
         {
             return id;
         }
         else if (returnNearestElmt && (nearpt < nearpt_min))
         {
             // If it does not lie within, keep track of which element
             // is nearest.
             min_id     = id;
             nearpt_min = nearpt;
             Vmath::Vcopy(locCoords.size(), locCoords, 1, savLocCoords, 1);
         }
     }
  
     // If the calling function is with just the nearest element, return
     // that. Otherwise return -1 to indicate no matching elemenet found.
     if (returnNearestElmt && nearpt_min <= maxDistance)
     {
  
         std::string msg =
             "Failed to find point within element to "
             "tolerance of " +
             boost::lexical_cast<std::string>(tol) + " using local point (" +
             boost::lexical_cast<std::string>(locCoords[0]) + "," +
             boost::lexical_cast<std::string>(locCoords[1]) + "," +
             boost::lexical_cast<std::string>(locCoords[1]) +
             ") in element: " + boost::lexical_cast<std::string>(min_id);
         WARNINGL1(false, msg.c_str());
  
         Vmath::Vcopy(locCoords.size(), savLocCoords, 1, locCoords, 1);
         return min_id;
     }
     else
     {
         return -1;
     }
 }

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), GetCoordim(), GetExp(), GetNumElmts(), m_elmtToExpId, m_exp, m_graph, CellMLToNektar.pycml::msg, CellMLToNektar.cellml_metadata::p, Vmath::Vcopy(), and WARNINGL1.

◆ GetExpSize()

int Nektar::MultiRegions::ExpList::GetExpSize ( void )

inline

This function returns the number of elements in the expansion.

Returns: $N_{\mathrm{el}}$, the number of elements in the expansion.

Definition at line 1996 of file ExpList.h.

 {
     return (*m_exp).size();
 }

◆ GetExpType()

ExpansionType Nektar::MultiRegions::ExpList::GetExpType ( void )

Returns the type of the expansion.

Definition at line 1310 of file ExpList.cpp.

 {
     return m_expType;
 }

References m_expType.

Referenced by v_CurlCurl().

◆ GetFieldDefinitions() [1/2]

std::vector<LibUtilities::FieldDefinitionsSharedPtr> Nektar::MultiRegions::ExpList::GetFieldDefinitions ( )

inline

Definition at line 891 of file ExpList.h.

     {
         return v_GetFieldDefinitions();
     }

References v_GetFieldDefinitions().

◆ GetFieldDefinitions() [2/2]

void Nektar::MultiRegions::ExpList::GetFieldDefinitions ( std::vector< LibUtilities::FieldDefinitionsSharedPtr > & fielddef )

inline

Definition at line 896 of file ExpList.h.

     {
         v_GetFieldDefinitions(fielddef);
     }

References v_GetFieldDefinitions().

◆ GetFwdBwdTracePhys() [1/2]

void Nektar::MultiRegions::ExpList::GetFwdBwdTracePhys	(	Array< OneD, NekDouble > &	Fwd,
		Array< OneD, NekDouble > &	Bwd
	)

inline

Definition at line 2145 of file ExpList.h.

 {
     v_GetFwdBwdTracePhys(Fwd, Bwd);
 }

References v_GetFwdBwdTracePhys().

◆ GetFwdBwdTracePhys() [2/2]

void Nektar::MultiRegions::ExpList::GetFwdBwdTracePhys	(	const Array< OneD, const NekDouble > &	field,
		Array< OneD, NekDouble > &	Fwd,
		Array< OneD, NekDouble > &	Bwd,
		bool	FillBnd = `true`,
		bool	PutFwdInBwdOnBCs = `false`,
		bool	DoExchange = `true`
	)

inline

Definition at line 2150 of file ExpList.h.

 {
     v_GetFwdBwdTracePhys(field, Fwd, Bwd, FillBnd, PutFwdInBwdOnBCs,
                          DoExchange);
 }

References v_GetFwdBwdTracePhys().

◆ GetGlobalLinSysManager()

LibUtilities::NekManager< GlobalLinSysKey, GlobalLinSys > & Nektar::MultiRegions::ExpList::GetGlobalLinSysManager ( void )

Definition at line 5316 of file ExpList.cpp.

 {
     return v_GetGlobalLinSysManager();
 }

References v_GetGlobalLinSysManager().

◆ GetGraph()

SpatialDomains::MeshGraphSharedPtr Nektar::MultiRegions::ExpList::GetGraph ( )

inline

Definition at line 964 of file ExpList.h.

     {
         return m_graph;
     }

References m_graph.

◆ GetHomogeneousBasis()

LibUtilities::BasisSharedPtr Nektar::MultiRegions::ExpList::GetHomogeneousBasis ( void )

inline

Definition at line 969 of file ExpList.h.

     {
         return v_GetHomogeneousBasis();
     }

References v_GetHomogeneousBasis().

◆ GetHomoLen()

NekDouble Nektar::MultiRegions::ExpList::GetHomoLen ( void )

inline

This function returns the Width of homogeneous direction associated with the homogeneous expansion.

Definition at line 596 of file ExpList.h.

     {
         return v_GetHomoLen();
     }

References v_GetHomoLen().

◆ GetLeftAdjacentFaces()

const std::vector< bool > & Nektar::MultiRegions::ExpList::GetLeftAdjacentFaces ( void ) const

inline

Definition at line 2187 of file ExpList.h.

 {
     return v_GetLeftAdjacentFaces();
 }

References v_GetLeftAdjacentFaces().

◆ GetLeftAdjacentTraces()

std::vector< bool > & Nektar::MultiRegions::ExpList::GetLeftAdjacentTraces ( void )

inline

Definition at line 2261 of file ExpList.h.

 {
     return v_GetLeftAdjacentTraces();
 }

References v_GetLeftAdjacentTraces().

◆ GetLocTraceFromTracePts()

void Nektar::MultiRegions::ExpList::GetLocTraceFromTracePts	(	const Array< OneD, const NekDouble > &	Fwd,
		const Array< OneD, const NekDouble > &	Bwd,
		Array< OneD, NekDouble > &	locTraceFwd,
		Array< OneD, NekDouble > &	locTraceBwd
	)

inline

Definition at line 2170 of file ExpList.h.

 {
     v_GetLocTraceFromTracePts(Fwd, Bwd, locTraceFwd, locTraceBwd);
 }

References v_GetLocTraceFromTracePts().

Referenced by AddTraceJacToElmtJac().

◆ GetLocTraceToTraceMap()

const LocTraceToTraceMapSharedPtr & Nektar::MultiRegions::ExpList::GetLocTraceToTraceMap ( ) const

inline

Definition at line 2081 of file ExpList.h.

 {
     return v_GetLocTraceToTraceMap();
 }

References v_GetLocTraceToTraceMap().

Referenced by AddTraceJacToElmtJac().

◆ GetMatIpwrtDeriveBase() [1/2]

void Nektar::MultiRegions::ExpList::GetMatIpwrtDeriveBase	(	const Array< OneD, const Array< OneD, NekDouble >> &	inarray,
		const int	nDirctn,
		Array< OneD, DNekMatSharedPtr > &	mtxPerVar
	)

Definition at line 5406 of file ExpList.cpp.

 {
     int nTotElmt  = (*m_exp).size();
     int nElmtPnt  = (*m_exp)[0]->GetTotPoints();
     int nElmtCoef = (*m_exp)[0]->GetNcoeffs();
  
     Array<OneD, NekDouble> tmpCoef(nElmtCoef, 0.0);
     Array<OneD, NekDouble> tmpPhys(nElmtPnt, 0.0);
  
     for (int nelmt = 0; nelmt < nTotElmt; nelmt++)
     {
         nElmtCoef = (*m_exp)[nelmt]->GetNcoeffs();
         nElmtPnt  = (*m_exp)[nelmt]->GetTotPoints();
  
         if (tmpPhys.size() != nElmtPnt || tmpCoef.size() != nElmtCoef)
         {
             tmpPhys = Array<OneD, NekDouble>(nElmtPnt, 0.0);
             tmpCoef = Array<OneD, NekDouble>(nElmtCoef, 0.0);
         }
  
         for (int ncl = 0; ncl < nElmtPnt; ncl++)
         {
             tmpPhys[ncl] = inarray[nelmt][ncl];
  
             (*m_exp)[nelmt]->IProductWRTDerivBase(nDirctn, tmpPhys, tmpCoef);
  
             for (int nrw = 0; nrw < nElmtCoef; nrw++)
             {
                 (*mtxPerVar[nelmt])(nrw, ncl) = tmpCoef[nrw];
             }
             // to maintain all the other columes are zero.
             tmpPhys[ncl] = 0.0;
         }
     }
 }

◆ GetMatIpwrtDeriveBase() [2/2]

void Nektar::MultiRegions::ExpList::GetMatIpwrtDeriveBase	(	const TensorOfArray3D< NekDouble > &	inarray,
		Array< OneD, DNekMatSharedPtr > &	mtxPerVar
	)

Definition at line 5444 of file ExpList.cpp.

 {
     int nTotElmt = (*m_exp).size();
  
     int nspacedim = m_graph->GetSpaceDimension();
     Array<OneD, Array<OneD, NekDouble>> projectedpnts(nspacedim);
     Array<OneD, Array<OneD, NekDouble>> tmppnts(nspacedim);
     Array<OneD, DNekMatSharedPtr> ArrayStdMat(nspacedim);
     Array<OneD, Array<OneD, NekDouble>> ArrayStdMat_data(nspacedim);
  
     Array<OneD, NekDouble> clmnArray, clmnStdMatArray;
  
     LibUtilities::ShapeType ElmtTypePrevious = LibUtilities::eNoShapeType;
     int nElmtPntPrevious                     = 0;
     int nElmtCoefPrevious                    = 0;
  
     int nElmtPnt, nElmtCoef;
     for (int nelmt = 0; nelmt < nTotElmt; nelmt++)
     {
         nElmtCoef                           = (*m_exp)[nelmt]->GetNcoeffs();
         nElmtPnt                            = (*m_exp)[nelmt]->GetTotPoints();
         LibUtilities::ShapeType ElmtTypeNow = (*m_exp)[nelmt]->DetShapeType();
  
         if (nElmtPntPrevious != nElmtPnt || nElmtCoefPrevious != nElmtCoef ||
             (ElmtTypeNow != ElmtTypePrevious))
         {
             if (nElmtPntPrevious != nElmtPnt)
             {
                 for (int ndir = 0; ndir < nspacedim; ndir++)
                 {
                     projectedpnts[ndir] = Array<OneD, NekDouble>(nElmtPnt, 0.0);
                     tmppnts[ndir]       = Array<OneD, NekDouble>(nElmtPnt, 0.0);
                 }
             }
             StdRegions::StdExpansionSharedPtr stdExp;
             stdExp = (*m_exp)[nelmt]->GetStdExp();
             StdRegions::StdMatrixKey matkey(StdRegions::eDerivBase0,
                                             stdExp->DetShapeType(), *stdExp);
  
             ArrayStdMat[0]      = stdExp->GetStdMatrix(matkey);
             ArrayStdMat_data[0] = ArrayStdMat[0]->GetPtr();
  
             if (nspacedim > 1)
             {
                 StdRegions::StdMatrixKey matkey(
                     StdRegions::eDerivBase1, stdExp->DetShapeType(), *stdExp);
  
                 ArrayStdMat[1]      = stdExp->GetStdMatrix(matkey);
                 ArrayStdMat_data[1] = ArrayStdMat[1]->GetPtr();
  
                 if (nspacedim > 2)
                 {
                     StdRegions::StdMatrixKey matkey(StdRegions::eDerivBase2,
                                                     stdExp->DetShapeType(),
                                                     *stdExp);
  
                     ArrayStdMat[2]      = stdExp->GetStdMatrix(matkey);
                     ArrayStdMat_data[2] = ArrayStdMat[2]->GetPtr();
                 }
             }
  
             ElmtTypePrevious  = ElmtTypeNow;
             nElmtPntPrevious  = nElmtPnt;
             nElmtCoefPrevious = nElmtCoef;
         }
         else
         {
             for (int ndir = 0; ndir < nspacedim; ndir++)
             {
                 Vmath::Zero(nElmtPnt, projectedpnts[ndir], 1);
             }
         }
  
         for (int ndir = 0; ndir < nspacedim; ndir++)
         {
             (*m_exp)[nelmt]->AlignVectorToCollapsedDir(
                 ndir, inarray[ndir][nelmt], tmppnts);
             for (int n = 0; n < nspacedim; n++)
             {
                 Vmath::Vadd(nElmtPnt, tmppnts[n], 1, projectedpnts[n], 1,
                             projectedpnts[n], 1);
             }
         }
  
         for (int ndir = 0; ndir < nspacedim; ndir++)
         {
             // weight with metric
             (*m_exp)[nelmt]->MultiplyByQuadratureMetric(projectedpnts[ndir],
                                                         projectedpnts[ndir]);
             Array<OneD, NekDouble> MatDataArray = mtxPerVar[nelmt]->GetPtr();
  
             for (int np = 0; np < nElmtPnt; np++)
             {
                 NekDouble factor = projectedpnts[ndir][np];
                 clmnArray        = MatDataArray + np * nElmtCoef;
                 clmnStdMatArray  = ArrayStdMat_data[ndir] + np * nElmtCoef;
                 Vmath::Svtvp(nElmtCoef, factor, clmnStdMatArray, 1, clmnArray,
                              1, clmnArray, 1);
             }
         }
     }
 }

References Nektar::StdRegions::eDerivBase0, Nektar::StdRegions::eDerivBase1, Nektar::StdRegions::eDerivBase2, Nektar::LibUtilities::eNoShapeType, m_graph, Vmath::Svtvp(), Vmath::Vadd(), and Vmath::Zero().

◆ GetMovingFrames()

void Nektar::MultiRegions::ExpList::GetMovingFrames	(	const SpatialDomains::GeomMMF	MMFdir,
		const Array< OneD, const NekDouble > &	CircCentre,
		Array< OneD, Array< OneD, NekDouble >> &	outarray
	)

inline

Definition at line 1745 of file ExpList.h.

 {
     v_GetMovingFrames(MMFdir, CircCentre, outarray);
 }

References v_GetMovingFrames().

◆ GetNcoeffs() [1/2]

int Nektar::MultiRegions::ExpList::GetNcoeffs ( const int eid ) const

inline

Returns the total number of local degrees of freedom for element eid.

Definition at line 1497 of file ExpList.h.

 {
     return (*m_exp)[eid]->GetNcoeffs();
 }

References m_exp.

◆ GetNcoeffs() [2/2]

int Nektar::MultiRegions::ExpList::GetNcoeffs ( void ) const

inline

Returns the total number of local degrees of freedom $N_{\mathrm{eof}}=\sum_{e=1}^{{N_{\mathrm{el}}}}N^{e}_m$.

Definition at line 1492 of file ExpList.h.

 {
     return m_ncoeffs;
 }

References m_ncoeffs.

◆ GetNormals()

void Nektar::MultiRegions::ExpList::GetNormals ( Array< OneD, Array< OneD, NekDouble >> & normals )

inline

Definition at line 2124 of file ExpList.h.

 {
     v_GetNormals(normals);
 }

References v_GetNormals().

◆ GetNpoints()

int Nektar::MultiRegions::ExpList::GetNpoints ( void ) const

inline

Returns the total number of quadrature points m_npoints $=Q_{\mathrm{tot}}$.

Definition at line 1568 of file ExpList.h.

 {
     return m_npoints;
 }

References m_npoints.

Referenced by export_ExpList(), and MultiplyByMassMatrix().

◆ GetNumElmts()

size_t Nektar::MultiRegions::ExpList::GetNumElmts ( void )

inline

This function returns the number of elements in the expansion which may be different for a homogeoenous extended expansionp.

Definition at line 645 of file ExpList.h.

     {
         return v_GetNumElmts();
     }

References v_GetNumElmts().

Referenced by GetExpIndex(), v_GetCoords(), and v_WriteTecplotHeader().

◆ GetPeriodicEntities()

void Nektar::MultiRegions::ExpList::GetPeriodicEntities	(	PeriodicMap &	periodicVerts,
		PeriodicMap &	periodicEdges,
		PeriodicMap &	periodicFaces = `NullPeriodicMap`
	)

inline

Definition at line 884 of file ExpList.h.

     {
         v_GetPeriodicEntities(periodicVerts, periodicEdges, periodicFaces);
     }

References v_GetPeriodicEntities().

◆ GetPhys()

const Array< OneD, const NekDouble > & Nektar::MultiRegions::ExpList::GetPhys ( void ) const

inline

This function returns (a reference to) the array $\boldsymbol{u}_l$ (implemented as m_phys) containing the function $u^{\delta}(\boldsymbol{x})$ evaluated at the quadrature points.

As the function returns a constant reference to a const Array it is not possible to modify the underlying data of the array m_phys. In order to do so, use the function UpdatePhys instead.

Returns: (A constant reference to) the array m_phys.

Definition at line 1988 of file ExpList.h.

 {
     return m_phys;
 }

References m_phys.

Referenced by Nektar::MultiRegions::DisContField::v_FillBwdWithBoundCond(), Nektar::MultiRegions::DisContField::v_GetBndElmtExpansion(), Nektar::MultiRegions::DisContField3DHomogeneous1D::v_GetBndElmtExpansion(), and Nektar::MultiRegions::DisContField3DHomogeneous2D::v_GetBndElmtExpansion().

◆ GetPhys_Offset()

int Nektar::MultiRegions::ExpList::GetPhys_Offset ( int n ) const

inline

Get the start offset position for a local contiguous list of quadrature points in a full array correspoinding to element n.

Definition at line 2044 of file ExpList.h.

 {
     return m_phys_offset[n];
 }

References m_phys_offset.

Referenced by AddTraceJacToElmtJac(), export_ExpList(), Nektar::MultiRegions::LocTraceToTraceMap::Setup(), v_ExtractPhysToBnd(), v_ExtractPhysToBndElmt(), Nektar::MultiRegions::DisContField::v_ExtractTracePhys(), Nektar::MultiRegions::DisContField3DHomogeneous1D::v_GetBCValues(), Nektar::MultiRegions::DisContField::v_GetBndElmtExpansion(), Nektar::MultiRegions::DisContField3DHomogeneous1D::v_GetBndElmtExpansion(), Nektar::MultiRegions::DisContField3DHomogeneous2D::v_GetBndElmtExpansion(), Nektar::MultiRegions::DisContField::v_GetFwdBwdTracePhys(), and v_NormVectorIProductWRTBase().

◆ GetPhysState()

bool Nektar::MultiRegions::ExpList::GetPhysState ( void ) const

inline

This function indicates whether the array of physical values $\boldsymbol{u}_l$ (implemented as m_phys) is filled or not.

Returns: physState true (=filled) or false (=not filled).

Definition at line 1623 of file ExpList.h.

 {
     return m_physState;
 }

References m_physState.

Referenced by export_ExpList().

◆ GetPlane()

std::shared_ptr<ExpList>& Nektar::MultiRegions::ExpList::GetPlane ( int n )

inline

Definition at line 973 of file ExpList.h.

     {
         return v_GetPlane(n);
     }

References v_GetPlane().

◆ GetPoolCount()

int Nektar::MultiRegions::ExpList::GetPoolCount ( std::string poolName )

Added for access to the pool count by external code (e.g. UnitTests) which can't access the static pool across compilation units on Windows builds.

Definition at line 5305 of file ExpList.cpp.

 {
     return v_GetPoolCount(poolName);
 }

References v_GetPoolCount().

◆ GetRobinBCInfo()

std::map<int, RobinBCInfoSharedPtr> Nektar::MultiRegions::ExpList::GetRobinBCInfo ( )

inline

Definition at line 879 of file ExpList.h.

     {
         return v_GetRobinBCInfo();
     }

References v_GetRobinBCInfo().

Referenced by GenGlobalBndLinSys(), and GenGlobalMatrixFull().

◆ GetSession()

std::shared_ptr<LibUtilities::SessionReader> Nektar::MultiRegions::ExpList::GetSession ( ) const

inline

Returns the session object.

Definition at line 955 of file ExpList.h.

     {
         return m_session;
     }

References m_session.

Referenced by Nektar::MultiRegions::AssemblyCommDG::AssemblyCommDG(), Nektar::MultiRegions::AssemblyMapCG::SetUpUniversalC0ContMap(), and Nektar::MultiRegions::AssemblyMapCG::v_LinearSpaceMap().

◆ GetShapeDimension()

int Nektar::MultiRegions::ExpList::GetShapeDimension ( )

inline

This function returns the dimension of the shape of the element eid.

Parameters

eid	The index of the element to be checked.

Returns: The dimension of the shape of the specific element.

Definition at line 1870 of file ExpList.h.

 {
     return (*m_exp)[0]->GetShapeDimension();
 }

References m_exp.

Referenced by CreateCollections(), and GeneralGetFieldDefinitions().

◆ GetSharedThisPtr()

std::shared_ptr<ExpList> Nektar::MultiRegions::ExpList::GetSharedThisPtr ( )

inline

Returns a shared pointer to the current object.

Definition at line 950 of file ExpList.h.

     {
         return shared_from_this();
     }

Referenced by GenGlobalBndLinSys(), GenGlobalLinSys(), Nektar::MultiRegions::ContField::GetGJPForcing(), and Nektar::MultiRegions::ContField::v_HelmSolve().

◆ GetTotPoints() [1/2]

int Nektar::MultiRegions::ExpList::GetTotPoints ( const int eid ) const

inline

Returns the total number of quadrature points for eid's element $=Q_{\mathrm{tot}}$.

Definition at line 1542 of file ExpList.h.

 {
     return (*m_exp)[eid]->GetTotPoints();
 }

References m_exp.

◆ GetTotPoints() [2/2]

int Nektar::MultiRegions::ExpList::GetTotPoints ( void ) const

inline

Returns the total number of quadrature points m_npoints $=Q_{\mathrm{tot}}$.

Definition at line 1537 of file ExpList.h.

 {
     return m_npoints;
 }

References m_npoints.

Referenced by AddRightIPTBaseMatrix(), AddRightIPTPhysDerivBase(), v_CurlCurl(), v_ExtractElmtToBndPhys(), v_ExtractPhysToBnd(), v_GetBoundaryNormals(), Nektar::MultiRegions::DisContField3DHomogeneous1D::v_GetBoundaryNormals(), Nektar::MultiRegions::ExpList2DHomogeneous1D::v_GetCoords(), Nektar::MultiRegions::ExpList3DHomogeneous1D::v_GetCoords(), Nektar::MultiRegions::ExpList3DHomogeneous2D::v_GetCoords(), Nektar::MultiRegions::ExpList3DHomogeneous1D::v_HomogeneousEnergy(), Nektar::MultiRegions::ExpList3DHomogeneous2D::v_L2(), v_WriteTecplotField(), and v_WriteTecplotZone().

◆ GetTrace()

std::shared_ptr< ExpList > & Nektar::MultiRegions::ExpList::GetTrace ( )

inline

Return a reference to the trace space associated with this expansion list.

Definition at line 2112 of file ExpList.h.

 {
     return v_GetTrace();
 }

References v_GetTrace().

Referenced by AddTraceJacToElmtJac(), and Nektar::MultiRegions::DisContField::v_AddTraceIntegral().

◆ GetTraceBndMap()

const Array< OneD, const int > & Nektar::MultiRegions::ExpList::GetTraceBndMap ( void )

inline

Definition at line 2120 of file ExpList.h.

 {
     return v_GetTraceBndMap();
 }

References v_GetTraceBndMap().

◆ GetTraceMap()

std::shared_ptr< AssemblyMapDG > & Nektar::MultiRegions::ExpList::GetTraceMap ( void )

inline

Definition at line 2116 of file ExpList.h.

 {
     return v_GetTraceMap();
 }

References v_GetTraceMap().

Referenced by v_GetTraceBndMap().

◆ GetTransposition()

LibUtilities::TranspositionSharedPtr Nektar::MultiRegions::ExpList::GetTransposition ( void )

inline

This function returns the transposition class associated with the homogeneous expansion.

Definition at line 589 of file ExpList.h.

     {
         return v_GetTransposition();
     }

References v_GetTransposition().

◆ GetWaveSpace()

bool Nektar::MultiRegions::ExpList::GetWaveSpace ( void ) const

inline

This function returns the third direction expansion condition, which can be in wave space (coefficient) or not It is stored in the variable m_WaveSpace.

Definition at line 1584 of file ExpList.h.

 {
     return m_WaveSpace;
 }

References m_WaveSpace.

Referenced by Nektar::MultiRegions::DisContField3DHomogeneous1D::v_GetBndElmtExpansion(), and Nektar::MultiRegions::DisContField3DHomogeneous2D::v_GetBndElmtExpansion().

◆ GetYIDs()

Array<OneD, const unsigned int> Nektar::MultiRegions::ExpList::GetYIDs ( void )

inline

This function returns a vector containing the wave numbers in y-direction associated with the 3D homogenous expansion. Required if a parellelisation is applied in the Fourier direction.

Definition at line 612 of file ExpList.h.

     {
         return v_GetYIDs();
     }

References v_GetYIDs().

◆ GetZIDs()

Array<OneD, const unsigned int> Nektar::MultiRegions::ExpList::GetZIDs ( void )

inline

This function returns a vector containing the wave numbers in z-direction associated with the 3D homogenous expansion. Required if a parellelisation is applied in the Fourier direction.

Definition at line 582 of file ExpList.h.

     {
         return v_GetZIDs();
     }

References v_GetZIDs().

Referenced by v_WriteTecplotZone().

◆ GlobalEigenSystem()

void Nektar::MultiRegions::ExpList::GlobalEigenSystem	(	const std::shared_ptr< DNekMat > &	Gmat,
		Array< OneD, NekDouble > &	EigValsReal,
		Array< OneD, NekDouble > &	EigValsImag,
		Array< OneD, NekDouble > &	EigVecs = `NullNekDouble1DArray`
	)

protected

◆ GlobalToLocal() [1/2]

void Nektar::MultiRegions::ExpList::GlobalToLocal	(	const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray
	)

inline

This operation is evaluated as:

\begin{tabbing} \hspace{1cm} \= Do \= $e=$ $1, N_{\mathrm{el}}$ \\ \> \> Do \= $i=$ $0,N_m^e-1$ \\ \> \> \> $\boldsymbol{\hat{u}}^{e}[i] = \mbox{sign}[e][i] \cdot \boldsymbol{\hat{u}}_g[\mbox{map}[e][i]]$ \\ \> \> continue \\ \> continue \end{tabbing}

where map $[e][i]$ is the mapping array and sign $[e][i]$ is an array of similar dimensions ensuring the correct modal connectivity between the different elements (both these arrays are contained in the data member #m_locToGloMap). This operation is equivalent to the scatter operation $\boldsymbol{\hat{u}}_l=\mathcal{A}\boldsymbol{\hat{u}}_g$, where $\mathcal{A}$ is the $N_{\mathrm{eof}}\times N_{\mathrm{dof}}$ permutation matrix.

Parameters

inarray	An array of size $N_\mathrm{dof}$ containing the global degrees of freedom $\boldsymbol{x}_g$.
outarray	The resulting local degrees of freedom $\boldsymbol{x}_l$ will be stored in this array of size $N_\mathrm{eof}$.

Definition at line 1959 of file ExpList.h.

 {
     v_GlobalToLocal(inarray, outarray);
 }

References v_GlobalToLocal().

◆ GlobalToLocal() [2/2]

void Nektar::MultiRegions::ExpList::GlobalToLocal ( void )

inline

Scatters from the global coefficients $\boldsymbol{\hat{u}}_g$ to the local coefficients $\boldsymbol{\hat{u}}_l$.

Definition at line 1929 of file ExpList.h.

 {
     v_GlobalToLocal();
 }

References v_GlobalToLocal().

◆ H1()

NekDouble Nektar::MultiRegions::ExpList::H1	(	const Array< OneD, const NekDouble > &	inarray,
		const Array< OneD, const NekDouble > &	soln = `NullNekDouble1DArray`
	)

Calculates the $H^1$ error of the global spectral/hp element approximation.

Given a spectral/hp approximation $u^{\delta}(\boldsymbol{x})$ evaluated at the quadrature points (which should be contained in m_phys), this function calculates the $H^1_2$ error of this approximation with respect to an exact solution. The local distribution of the quadrature points allows an elemental evaluation of this operation through the functions StdRegions::StdExpansion::H1.

The exact solution, also evaluated at the quadrature points, should be contained in the variable m_phys of the ExpList object Sol.

Parameters

soln	An 1D array, containing the discrete evaluation of the exact solution at the quadrature points.

Returns: The $H^1_2$ error of the approximation.

Definition at line 3386 of file ExpList.cpp.

 {
     NekDouble err = 0.0, errh1;
     int i;
  
     for (i = 0; i < (*m_exp).size(); ++i)
     {
         errh1 = (*m_exp)[i]->H1(inarray + m_phys_offset[i],
                                 soln + m_phys_offset[i]);
         err += errh1 * errh1;
     }
  
     m_comm->GetRowComm()->AllReduce(err, LibUtilities::ReduceSum);
  
     return sqrt(err);
 }

References m_comm, m_phys_offset, Nektar::LibUtilities::ReduceSum, and tinysimd::sqrt().

◆ HelmSolve()

GlobalLinSysKey Nektar::MultiRegions::ExpList::HelmSolve	(	const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray,
		const StdRegions::ConstFactorMap &	factors,
		const StdRegions::VarCoeffMap &	varcoeff = `StdRegions::NullVarCoeffMap`,
		const MultiRegions::VarFactorsMap &	varfactors = `MultiRegions::NullVarFactorsMap`,
		const Array< OneD, const NekDouble > &	dirForcing = `NullNekDouble1DArray`,
		const bool	PhysSpaceForcing = `true`
	)

inline

Solve helmholtz problem.

Definition at line 1694 of file ExpList.h.

 {
     return v_HelmSolve(inarray, outarray, factors, varcoeff, varfactors,
                        dirForcing, PhysSpaceForcing);
 }

References v_HelmSolve().

◆ HomogeneousBwdTrans()

void Nektar::MultiRegions::ExpList::HomogeneousBwdTrans	(	const int	npts,
		const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray,
		bool	Shuff = `true`,
		bool	UnShuff = `true`
	)

inline

Definition at line 1807 of file ExpList.h.

 {
     v_HomogeneousBwdTrans(npts, inarray, outarray, Shuff, UnShuff);
 }

References v_HomogeneousBwdTrans().

Referenced by Nektar::MultiRegions::ExpListHomogeneous1D::v_BwdTrans(), Nektar::MultiRegions::ExpListHomogeneous2D::v_BwdTrans(), Nektar::MultiRegions::ExpListHomogeneous1D::v_DealiasedDotProd(), Nektar::MultiRegions::ExpListHomogeneous1D::v_DealiasedProd(), Nektar::MultiRegions::ExpListHomogeneous2D::v_DealiasedProd(), Nektar::MultiRegions::ExpListHomogeneous1D::v_PhysDeriv(), and Nektar::MultiRegions::ExpListHomogeneous2D::v_PhysDeriv().

◆ HomogeneousEnergy()

Array<OneD, const NekDouble> Nektar::MultiRegions::ExpList::HomogeneousEnergy ( void )

inline

This function calculates the energy associated with each one of the modesof a 3D homogeneous nD expansion.

Definition at line 566 of file ExpList.h.

     {
         return v_HomogeneousEnergy();
     }

References v_HomogeneousEnergy().

◆ HomogeneousFwdTrans()

void Nektar::MultiRegions::ExpList::HomogeneousFwdTrans	(	const int	npts,
		const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray,
		bool	Shuff = `true`,
		bool	UnShuff = `true`
	)

inline

Definition at line 1798 of file ExpList.h.

 {
     v_HomogeneousFwdTrans(npts, inarray, outarray, Shuff, UnShuff);
 }

References v_HomogeneousFwdTrans().

◆ ImposeDirichletConditions()

void Nektar::MultiRegions::ExpList::ImposeDirichletConditions ( Array< OneD, NekDouble > & outarray )

inline

Impose Dirichlet Boundary Conditions onto Array.

Definition at line 1906 of file ExpList.h.

 {
     v_ImposeDirichletConditions(outarray);
 }

References v_ImposeDirichletConditions().

◆ InitialiseExpVector()

void Nektar::MultiRegions::ExpList::InitialiseExpVector ( const SpatialDomains::ExpansionInfoMap & expmap )

private

Define a list of elements using the geometry and basis key information in expmap;.

Definition at line 1142 of file ExpList.cpp.

 {
  
     SpatialDomains::SegGeomSharedPtr SegmentGeom;
     SpatialDomains::TriGeomSharedPtr TriangleGeom;
     SpatialDomains::QuadGeomSharedPtr QuadrilateralGeom;
     SpatialDomains::TetGeomSharedPtr TetGeom;
     SpatialDomains::HexGeomSharedPtr HexGeom;
     SpatialDomains::PrismGeomSharedPtr PrismGeom;
     SpatialDomains::PyrGeomSharedPtr PyrGeom;
  
     int id = 0;
     LocalRegions::ExpansionSharedPtr exp;
  
     m_expType = eNoType;
     // Process each expansion in the graph
     for (auto &expIt : expmap)
     {
         const SpatialDomains::ExpansionInfoShPtr expInfo = expIt.second;
  
         switch (expInfo->m_basisKeyVector.size())
         {
             case 1: // Segment Expansions
             {
                 ASSERTL1(m_expType == e1D || m_expType == eNoType,
                          "Cannot mix expansion dimensions in one vector");
                 m_expType = e1D;
  
                 if ((SegmentGeom =
                          std::dynamic_pointer_cast<SpatialDomains::SegGeom>(
                              expInfo->m_geomShPtr)))
                 {
                     // Retrieve basis key from expansion
                     LibUtilities::BasisKey bkey = expInfo->m_basisKeyVector[0];
  
                     exp =
                         MemoryManager<LocalRegions::SegExp>::AllocateSharedPtr(
                             bkey, SegmentGeom);
                 }
                 else
                 {
                     NEKERROR(ErrorUtil::efatal,
                              "dynamic cast to a 1D Geom failed");
                 }
             }
             break;
             case 2:
             {
                 ASSERTL1(m_expType == e2D || m_expType == eNoType,
                          "Cannot mix expansion dimensions in one vector");
                 m_expType = e2D;
  
                 LibUtilities::BasisKey Ba = expInfo->m_basisKeyVector[0];
                 LibUtilities::BasisKey Bb = expInfo->m_basisKeyVector[1];
  
                 if ((TriangleGeom =
                          std::dynamic_pointer_cast<SpatialDomains ::TriGeom>(
                              expInfo->m_geomShPtr)))
                 {
  
                     // This is not elegantly implemented needs re-thinking.
                     if (Ba.GetBasisType() == LibUtilities::eGLL_Lagrange)
                     {
                         LibUtilities::BasisKey newBa(LibUtilities::eOrtho_A,
                                                      Ba.GetNumModes(),
                                                      Ba.GetPointsKey());
  
                         LibUtilities::PointsType TriNb =
                             LibUtilities::eNodalTriElec;
                         exp = MemoryManager<LocalRegions::NodalTriExp>::
                             AllocateSharedPtr(newBa, Bb, TriNb, TriangleGeom);
                     }
                     else
                     {
                         exp = MemoryManager<LocalRegions::TriExp>::
                             AllocateSharedPtr(Ba, Bb, TriangleGeom);
                     }
                 }
                 else if ((QuadrilateralGeom = std::dynamic_pointer_cast<
                               SpatialDomains::QuadGeom>(expInfo->m_geomShPtr)))
                 {
                     exp =
                         MemoryManager<LocalRegions::QuadExp>::AllocateSharedPtr(
                             Ba, Bb, QuadrilateralGeom);
                 }
                 else
                 {
                     NEKERROR(ErrorUtil::efatal,
                              "dynamic cast to a 2D Geom failed");
                 }
             }
             break;
             case 3:
             {
                 ASSERTL1(m_expType == e3D || m_expType == eNoType,
                          "Cannot mix expansion dimensions in one vector");
                 m_expType = e3D;
  
                 LibUtilities::BasisKey Ba = expInfo->m_basisKeyVector[0];
                 LibUtilities::BasisKey Bb = expInfo->m_basisKeyVector[1];
                 LibUtilities::BasisKey Bc = expInfo->m_basisKeyVector[2];
  
                 if ((TetGeom =
                          std::dynamic_pointer_cast<SpatialDomains::TetGeom>(
                              expInfo->m_geomShPtr)))
                 {
  
                     if (Ba.GetBasisType() == LibUtilities::eGLL_Lagrange ||
                         Ba.GetBasisType() == LibUtilities::eGauss_Lagrange)
                     {
                         NEKERROR(ErrorUtil::efatal,
                                  "LocalRegions::NodalTetExp is not implemented "
                                  "yet");
                     }
                     else
                     {
                         exp = MemoryManager<
                             LocalRegions::TetExp>::AllocateSharedPtr(Ba, Bb, Bc,
                                                                      TetGeom);
                     }
                 }
                 else if ((PrismGeom = std::dynamic_pointer_cast<
                               SpatialDomains ::PrismGeom>(
                               expInfo->m_geomShPtr)))
                 {
                     exp = MemoryManager<
                         LocalRegions::PrismExp>::AllocateSharedPtr(Ba, Bb, Bc,
                                                                    PrismGeom);
                 }
                 else if ((PyrGeom = std::dynamic_pointer_cast<
                               SpatialDomains::PyrGeom>(expInfo->m_geomShPtr)))
                 {
  
                     exp =
                         MemoryManager<LocalRegions::PyrExp>::AllocateSharedPtr(
                             Ba, Bb, Bc, PyrGeom);
                 }
                 else if ((HexGeom = std::dynamic_pointer_cast<
                               SpatialDomains::HexGeom>(expInfo->m_geomShPtr)))
                 {
                     exp =
                         MemoryManager<LocalRegions::HexExp>::AllocateSharedPtr(
                             Ba, Bb, Bc, HexGeom);
                 }
                 else
                 {
                     NEKERROR(ErrorUtil::efatal,
                              "dynamic cast to a Geom failed");
                 }
             }
             break;
             default:
                 NEKERROR(ErrorUtil::efatal,
                          "Dimension of basis key is greater than 3");
         }
  
         // Assign next id
         exp->SetElmtId(id++);
  
         // Add the expansion
         (*m_exp).push_back(exp);
     }
 }

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL1, Nektar::MultiRegions::e1D, Nektar::MultiRegions::e2D, Nektar::MultiRegions::e3D, Nektar::ErrorUtil::efatal, Nektar::LibUtilities::eGauss_Lagrange, Nektar::LibUtilities::eGLL_Lagrange, Nektar::LibUtilities::eNodalTriElec, Nektar::MultiRegions::eNoType, Nektar::LibUtilities::eOrtho_A, Nektar::LibUtilities::BasisKey::GetBasisType(), Nektar::LibUtilities::BasisKey::GetNumModes(), Nektar::LibUtilities::BasisKey::GetPointsKey(), m_expType, and NEKERROR.

Referenced by ExpList().

◆ Integral() [1/2]

NekDouble Nektar::MultiRegions::ExpList::Integral ( )

inline

Calculates the $H^1$ error of the global spectral/hp element approximation.

The integration is evaluated locally, that is

\[\int f(\boldsymbol{x})d\boldsymbol{x}=\sum_{e=1}^{{N_{\mathrm{el}}}} \left\{\int_{\Omega_e}f(\boldsymbol{x})d\boldsymbol{x}\right\}, \]

where the integration over the separate elements is done by the function StdRegions::StdExpansion::Integral, which discretely evaluates the integral using Gaussian quadrature.

Note that the array m_phys should be filled with the values of the function $f(\boldsymbol{x})$ at the quadrature points $\boldsymbol{x}_i$.

Returns: The value of the discretely evaluated integral $\int f(\boldsymbol{x})d\boldsymbol{x}$.

Definition at line 535 of file ExpList.h.

     {
         ASSERTL1(m_physState == true, "local physical space is not true ");
         return Integral(m_phys);
     }

References ASSERTL1, m_phys, and m_physState.

◆ Integral() [2/2]

NekDouble Nektar::MultiRegions::ExpList::Integral ( const Array< OneD, const NekDouble > & inarray )

inline

The integration is evaluated locally, that is

\[\int f(\boldsymbol{x})d\boldsymbol{x}=\sum_{e=1}^{{N_{\mathrm{el}}}} \left\{\int_{\Omega_e}f(\boldsymbol{x})d\boldsymbol{x}\right\}, \]

where the integration over the separate elements is done by the function StdRegions::StdExpansion::Integral, which discretely evaluates the integral using Gaussian quadrature.

Parameters

inarray An array of size $Q_{\mathrm{tot}}$ containing the values of the function $f(\boldsymbol{x})$ at the quadrature points $\boldsymbol{x}_i$.

Returns: The value of the discretely evaluated integral $\int f(\boldsymbol{x})d\boldsymbol{x}$.

Definition at line 556 of file ExpList.h.

     {
         return v_Integral(inarray);
     }

References v_Integral().

◆ IProductWRTBase()

void Nektar::MultiRegions::ExpList::IProductWRTBase	(	const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray
	)

inline

This function calculates the inner product of a function $f(\boldsymbol{x})$ with respect to all local expansion modes $\phi_n^e(\boldsymbol{x})$.

Definition at line 1630 of file ExpList.h.

 {
     v_IProductWRTBase(inarray, outarray);
 }

References v_IProductWRTBase().

Referenced by Nektar::MultiRegions::ContField::FwdTrans(), Nektar::MultiRegions::ContField::LaplaceSolve(), MultiplyByMassMatrix(), v_FwdTransLocalElmt(), Nektar::MultiRegions::ContField::v_HelmSolve(), Nektar::MultiRegions::DisContField::v_HelmSolve(), Nektar::MultiRegions::ContField::v_LinearAdvectionDiffusionReactionSolve(), Nektar::MultiRegions::ContField::v_LinearAdvectionReactionSolve(), and Nektar::MultiRegions::ContField::v_SmoothField().

◆ IProductWRTDerivBase() [1/2]

void Nektar::MultiRegions::ExpList::IProductWRTDerivBase	(	const Array< OneD, const Array< OneD, NekDouble >> &	inarray,
		Array< OneD, NekDouble > &	outarray
	)

This function calculates the inner product of a function $f(\boldsymbol{x})$ with respect to the derivative of all local expansion modes $\phi_n^e(\boldsymbol{x})$.

The operation is evaluated locally for every element by the function StdRegions::StdExpansion::IProductWRTDerivBase.

Parameters

inarray	An array of arrays of size $Q_{\mathrm{tot}}$ containing the values of the function $f(\boldsymbol{x})$ at the quadrature points $\boldsymbol{x}_i$ in dir directions.
outarray	An array of size $N_{\mathrm{eof}}$ used to store the result.

Definition at line 1453 of file ExpList.cpp.

 {
     Array<OneD, NekDouble> tmp0, tmp1, tmp2;
     // assume coord dimension defines the size of Deriv Base
     int dim = GetCoordim(0);
  
     ASSERTL1(inarray.size() >= dim, "inarray is not of sufficient dimension");
  
     // initialise if required
     if (m_collectionsDoInit[Collections::eIProductWRTDerivBase])
     {
         for (int i = 0; i < m_collections.size(); ++i)
         {
             m_collections[i].Initialise(Collections::eIProductWRTDerivBase);
         }
         m_collectionsDoInit[Collections::eIProductWRTDerivBase] = false;
     }
  
     LibUtilities::Timer timer;
  
     LIKWID_MARKER_START("IProductWRTDerivBase_coll");
     timer.Start();
  
     switch (dim)
     {
         case 1:
             for (int i = 0; i < m_collections.size(); ++i)
             {
                 m_collections[i].ApplyOperator(
                     Collections::eIProductWRTDerivBase,
                     inarray[0] + m_coll_phys_offset[i],
                     tmp0 = outarray + m_coll_coeff_offset[i]);
             }
             break;
         case 2:
             for (int i = 0; i < m_collections.size(); ++i)
             {
                 m_collections[i].ApplyOperator(
                     Collections::eIProductWRTDerivBase,
                     inarray[0] + m_coll_phys_offset[i],
                     tmp0 = inarray[1] + m_coll_phys_offset[i],
                     tmp1 = outarray + m_coll_coeff_offset[i]);
             }
             break;
         case 3:
             for (int i = 0; i < m_collections.size(); ++i)
             {
                 m_collections[i].ApplyOperator(
                     Collections::eIProductWRTDerivBase,
                     inarray[0] + m_coll_phys_offset[i],
                     tmp0 = inarray[1] + m_coll_phys_offset[i],
                     tmp1 = inarray[2] + m_coll_phys_offset[i],
                     tmp2 = outarray + m_coll_coeff_offset[i]);
             }
             break;
         default:
             NEKERROR(ErrorUtil::efatal, "Dimension of inarray not correct");
             break;
     }
  
     timer.Stop();
     LIKWID_MARKER_STOP("IProductWRTDerivBase_coll");
  
     // Elapsed time
     timer.AccumulateRegion("Collections:IProductWRTDerivBase", 10);
 }

References Nektar::LibUtilities::Timer::AccumulateRegion(), ASSERTL1, Nektar::ErrorUtil::efatal, Nektar::Collections::eIProductWRTDerivBase, GetCoordim(), LIKWID_MARKER_START, LIKWID_MARKER_STOP, m_coll_coeff_offset, m_coll_phys_offset, m_collections, m_collectionsDoInit, NEKERROR, Nektar::LibUtilities::Timer::Start(), and Nektar::LibUtilities::Timer::Stop().

◆ IProductWRTDerivBase() [2/2]

void Nektar::MultiRegions::ExpList::IProductWRTDerivBase	(	const int	dir,
		const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray
	)

This function calculates the inner product of a function $f(\boldsymbol{x})$ with respect to the derivative (in direction.

Parameters

dir)	of all local expansion modes $\phi_n^e(\boldsymbol{x})$.

The operation is evaluated locally for every element by the function StdRegions::Expansion::IProductWRTDerivBase.

Parameters

dir	{0,1} is the direction in which the derivative of the basis should be taken
inarray	An array of size $Q_{\mathrm{tot}}$ containing the values of the function $f(\boldsymbol{x})$ at the quadrature points $\boldsymbol{x}_i$.
outarray	An array of size $N_{\mathrm{eof}}$ used to store the result.

Definition at line 1391 of file ExpList.cpp.

 {
     int i;
  
     Array<OneD, NekDouble> e_outarray;
  
     for (i = 0; i < (*m_exp).size(); ++i)
     {
         (*m_exp)[i]->IProductWRTDerivBase(dir, inarray + m_phys_offset[i],
                                           e_outarray =
                                               outarray + m_coeff_offset[i]);
     }
 }

References m_coeff_offset, and m_phys_offset.

◆ IProductWRTDirectionalDerivBase()

void Nektar::MultiRegions::ExpList::IProductWRTDirectionalDerivBase	(	const Array< OneD, const NekDouble > &	direction,
		const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray
	)

Directional derivative along a given direction.

Definition at line 1411 of file ExpList.cpp.

 {
     int npts_e;
     int coordim = (*m_exp)[0]->GetGeom()->GetCoordim();
     int nq      = direction.size() / coordim;
  
     Array<OneD, NekDouble> e_outarray;
     Array<OneD, NekDouble> e_MFdiv;
  
     Array<OneD, NekDouble> locdir;
  
     for (int i = 0; i < (*m_exp).size(); ++i)
     {
         npts_e = (*m_exp)[i]->GetTotPoints();
         locdir = Array<OneD, NekDouble>(npts_e * coordim);
  
         for (int k = 0; k < coordim; ++k)
         {
             Vmath::Vcopy(npts_e, &direction[k * nq + m_phys_offset[i]], 1,
                          &locdir[k * npts_e], 1);
         }
  
         (*m_exp)[i]->IProductWRTDirectionalDerivBase(
             locdir, inarray + m_phys_offset[i],
             e_outarray = outarray + m_coeff_offset[i]);
     }
 }

References m_coeff_offset, m_phys_offset, and Vmath::Vcopy().

◆ L2()

NekDouble Nektar::MultiRegions::ExpList::L2	(	const Array< OneD, const NekDouble > &	inarray,
		const Array< OneD, const NekDouble > &	soln = `NullNekDouble1DArray`
	)

inline

This function calculates the $L_\infty$ error of the global This function calculates the $L_2$ error with respect to soln of the global spectral/hp element approximation.

Definition at line 506 of file ExpList.h.

     {
         return v_L2(inarray, soln);
     }

References v_L2().

Referenced by Nektar::MultiRegions::DisContField::L2_DGDeriv(), and Nektar::MultiRegions::ExpList3DHomogeneous2D::v_L2().

◆ LinearAdvectionDiffusionReactionSolve()

GlobalLinSysKey Nektar::MultiRegions::ExpList::LinearAdvectionDiffusionReactionSolve	(	const Array< OneD, Array< OneD, NekDouble >> &	velocity,
		const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray,
		const NekDouble	lambda,
		const Array< OneD, const NekDouble > &	dirForcing = `NullNekDouble1DArray`
	)

inline

Solve Advection Diffusion Reaction.

Definition at line 1707 of file ExpList.h.

 {
     return v_LinearAdvectionDiffusionReactionSolve(velocity, inarray, outarray,
                                                    lambda, dirForcing);
 }

References v_LinearAdvectionDiffusionReactionSolve().

◆ LinearAdvectionReactionSolve()

void Nektar::MultiRegions::ExpList::LinearAdvectionReactionSolve	(	const Array< OneD, Array< OneD, NekDouble >> &	velocity,
		const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray,
		const NekDouble	lambda,
		const Array< OneD, const NekDouble > &	dirForcing = `NullNekDouble1DArray`
	)

inline

Solve Advection Diffusion Reaction.

Definition at line 1716 of file ExpList.h.

 {
     v_LinearAdvectionReactionSolve(velocity, inarray, outarray, lambda,
                                    dirForcing);
 }

References v_LinearAdvectionReactionSolve().

◆ Linf()

NekDouble Nektar::MultiRegions::ExpList::Linf	(	const Array< OneD, const NekDouble > &	inarray,
		const Array< OneD, const NekDouble > &	soln = `NullNekDouble1DArray`
	)

This function calculates the $L_\infty$ error of the global spectral/hp element approximation.

Given a spectral/hp approximation $u^{\delta}(\boldsymbol{x})$ evaluated at the quadrature points (which should be contained in m_phys), this function calculates the $L_\infty$ error of this approximation with respect to an exact solution. The local distribution of the quadrature points allows an elemental evaluation of this operation through the functions StdRegions::StdExpansion::Linf.

The exact solution, also evaluated at the quadrature points, should be contained in the variable m_phys of the ExpList object Sol.

Parameters

soln	A 1D array, containing the discrete evaluation of the exact solution at the quadrature points in its array m_phys.

Returns: The $L_\infty$ error of the approximation.

Definition at line 3139 of file ExpList.cpp.

 {
     NekDouble err = 0.0;
  
     if (soln == NullNekDouble1DArray)
     {
         err = Vmath::Vmax(m_npoints, inarray, 1);
     }
     else
     {
         for (int i = 0; i < m_npoints; ++i)
         {
             err = max(err, abs(inarray[i] - soln[i]));
         }
     }
  
     m_comm->GetRowComm()->AllReduce(err, LibUtilities::ReduceMax);
  
     return err;
 }

References tinysimd::abs(), m_comm, m_npoints, Nektar::NullNekDouble1DArray, Nektar::LibUtilities::ReduceMax, and Vmath::Vmax().

◆ LocalToGlobal() [1/2]

void Nektar::MultiRegions::ExpList::LocalToGlobal ( bool useComm = true )

inline

Gathers the global coefficients $\boldsymbol{\hat{u}}_g$ from the local coefficients $\boldsymbol{\hat{u}}_l$.

Definition at line 1919 of file ExpList.h.

 {
     v_LocalToGlobal(useComm);
 }

References v_LocalToGlobal().

◆ LocalToGlobal() [2/2]

void Nektar::MultiRegions::ExpList::LocalToGlobal	(	const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray,
		bool	useComm = `true`
	)

inline

Definition at line 1923 of file ExpList.h.

 {
     v_LocalToGlobal(inarray, outarray, useComm);
 }

References v_LocalToGlobal().

◆ MultiplyByBlockMatrix()

void Nektar::MultiRegions::ExpList::MultiplyByBlockMatrix	(	const GlobalMatrixKey &	gkey,
		const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray
	)

protected

Retrieves the block matrix specified by bkey, and computes $ y=Mx $.

Parameters

gkey	GlobalMatrixKey specifying the block matrix to use in the matrix-vector multiply.
inarray	Input vector $ x $.
outarray	Output vector $ y $.

Definition at line 1327 of file ExpList.cpp.

 {
     // Retrieve the block matrix using the given key.
     const DNekScalBlkMatSharedPtr &blockmat = GetBlockMatrix(gkey);
     int nrows                               = blockmat->GetRows();
     int ncols                               = blockmat->GetColumns();
  
     // Create NekVectors from the given data arrays
     NekVector<NekDouble> in(ncols, inarray, eWrapper);
     NekVector<NekDouble> out(nrows, outarray, eWrapper);
  
     // Perform matrix-vector multiply.
     out = (*blockmat) * in;
 }

References Nektar::eWrapper, and GetBlockMatrix().

◆ MultiplyByElmtInvMass()

void Nektar::MultiRegions::ExpList::MultiplyByElmtInvMass	(	const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray
	)

This function elementally mulplies the coefficient space of Sin my the elemental inverse of the mass matrix.

The coefficients of the function to be acted upon should be contained in the

Parameters

inarray.	The resulting coefficients are stored in
outarray
inarray	An array of size $N_{\mathrm{eof}}$ containing the inner product.

Definition at line 1771 of file ExpList.cpp.

 {
     GlobalMatrixKey mkey(StdRegions::eInvMass);
     const DNekScalBlkMatSharedPtr &InvMass = GetBlockMatrix(mkey);
  
     // Inverse mass matrix
     NekVector<NekDouble> out(m_ncoeffs, outarray, eWrapper);
     if (inarray.get() == outarray.get())
     {
         NekVector<NekDouble> in(m_ncoeffs, inarray); // copy data
         out = (*InvMass) * in;
     }
     else
     {
         NekVector<NekDouble> in(m_ncoeffs, inarray, eWrapper);
         out = (*InvMass) * in;
     }
 }

References Nektar::StdRegions::eInvMass, Nektar::eWrapper, GetBlockMatrix(), and m_ncoeffs.

Referenced by v_FwdTransLocalElmt().

◆ MultiplyByInvMassMatrix()

void Nektar::MultiRegions::ExpList::MultiplyByInvMassMatrix	(	const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray
	)

inline

Definition at line 1685 of file ExpList.h.

 {
     v_MultiplyByInvMassMatrix(inarray, outarray);
 }

References v_MultiplyByInvMassMatrix().

◆ MultiplyByMassMatrix()

void Nektar::MultiRegions::ExpList::MultiplyByMassMatrix	(	const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray
	)

inline

Definition at line 301 of file ExpList.h.

     {
         Array<OneD, NekDouble> tmp(GetNpoints(), 0.0);
         BwdTrans(inarray, tmp);
         IProductWRTBase(tmp, outarray);
     }

References BwdTrans(), GetNpoints(), and IProductWRTBase().

◆ MultiplyByQuadratureMetric()

void Nektar::MultiRegions::ExpList::MultiplyByQuadratureMetric	(	const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray
	)

multiply the metric jacobi and quadrature weights

Definition at line 1347 of file ExpList.cpp.

 {
     Array<OneD, NekDouble> e_outarray;
  
     for (int i = 0; i < (*m_exp).size(); ++i)
     {
         (*m_exp)[i]->MultiplyByQuadratureMetric(inarray + m_phys_offset[i],
                                                 e_outarray = outarray +
                                                              m_phys_offset[i]);
     }
 }

References m_phys_offset.

◆ NormVectorIProductWRTBase() [1/2]

void Nektar::MultiRegions::ExpList::NormVectorIProductWRTBase	(	Array< OneD, Array< OneD, NekDouble >> &	V,
		Array< OneD, NekDouble > &	outarray
	)

inline

Definition at line 1852 of file ExpList.h.

 {
     v_NormVectorIProductWRTBase(V, outarray);
 }

References v_NormVectorIProductWRTBase().

◆ NormVectorIProductWRTBase() [2/2]

void Nektar::MultiRegions::ExpList::NormVectorIProductWRTBase	(	Array< OneD, const NekDouble > &	V1,
		Array< OneD, const NekDouble > &	V2,
		Array< OneD, NekDouble > &	outarray,
		int	BndID
	)

inline

Definition at line 1845 of file ExpList.h.

 {
     v_NormVectorIProductWRTBase(V1, V2, outarray, BndID);
 }

References v_NormVectorIProductWRTBase().

◆ PeriodicBwdCopy()

void Nektar::MultiRegions::ExpList::PeriodicBwdCopy	(	const Array< OneD, const NekDouble > &	Fwd,
		Array< OneD, NekDouble > &	Bwd
	)

inline

Copy and fill the Periodic boundaries.

Definition at line 2182 of file ExpList.h.

 {
     v_PeriodicBwdCopy(Fwd, Bwd);
 }

References v_PeriodicBwdCopy().

◆ PhysDeriv() [1/3]

void Nektar::MultiRegions::ExpList::PhysDeriv	(	const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	out_d0,
		Array< OneD, NekDouble > &	out_d1 = `NullNekDouble1DArray`,
		Array< OneD, NekDouble > &	out_d2 = `NullNekDouble1DArray`
	)

inline

This function discretely evaluates the derivative of a function $f(\boldsymbol{x})$ on the domain consisting of all elements of the expansion.

Definition at line 1755 of file ExpList.h.

 {
     v_PhysDeriv(inarray, out_d0, out_d1, out_d2);
 }

References v_PhysDeriv().

◆ PhysDeriv() [2/3]

void Nektar::MultiRegions::ExpList::PhysDeriv	(	const int	dir,
		const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	out_d
	)

inline

Definition at line 1765 of file ExpList.h.

 {
     v_PhysDeriv(dir, inarray, out_d);
 }

References v_PhysDeriv().

◆ PhysDeriv() [3/3]

void Nektar::MultiRegions::ExpList::PhysDeriv	(	Direction	edir,
		const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	out_d
	)

inline

Definition at line 1771 of file ExpList.h.

 {
     v_PhysDeriv(edir, inarray, out_d);
 }

References v_PhysDeriv().

Referenced by v_CurlCurl().

◆ PhysDirectionalDeriv()

void Nektar::MultiRegions::ExpList::PhysDirectionalDeriv	(	const Array< OneD, const NekDouble > &	direction,
		const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray
	)

inline

Definition at line 1780 of file ExpList.h.

 {
     v_PhysDirectionalDeriv(direction, inarray, outarray);
 }

References v_PhysDirectionalDeriv().

◆ PhysEvaluate()

NekDouble Nektar::MultiRegions::ExpList::PhysEvaluate	(	const Array< OneD, const NekDouble > &	coords,
		const Array< OneD, const NekDouble > &	phys
	)

This function return the expansion field value at the coordinates given as input.

Given some coordinates, output the expansion field value at that point

Definition at line 2638 of file ExpList.cpp.

 {
     int dim = GetCoordim(0);
     ASSERTL0(dim == coords.size(), "Invalid coordinate dimension.");
  
     // Grab the element index corresponding to coords.
     Array<OneD, NekDouble> xi(dim);
     int elmtIdx = GetExpIndex(coords, xi);
     ASSERTL0(elmtIdx > 0, "Unable to find element containing point.");
  
     // Grab that element's physical storage.
     Array<OneD, NekDouble> elmtPhys = phys + m_phys_offset[elmtIdx];
  
     // Evaluate the element at the appropriate point.
     return (*m_exp)[elmtIdx]->StdPhysEvaluate(xi, elmtPhys);
 }

References ASSERTL0, GetCoordim(), GetExpIndex(), m_exp, and m_phys_offset.

Referenced by export_ExpList().

◆ PhysGalerkinProjection1DScaled()

void Nektar::MultiRegions::ExpList::PhysGalerkinProjection1DScaled	(	const NekDouble	scale,
		const Array< OneD, NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray
	)

inline

This function Galerkin projects the physical space points in inarray to outarray where inarray is assumed to be defined in the expansion but where the number of points are rescaled by 1DScale.

Definition at line 632 of file ExpList.h.

     {
         v_PhysGalerkinProjection1DScaled(scale, inarray, outarray);
     }

References v_PhysGalerkinProjection1DScaled().

◆ PhysInterp1DScaled()

void Nektar::MultiRegions::ExpList::PhysInterp1DScaled	(	const NekDouble	scale,
		const Array< OneD, NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray
	)

inline

This function interpolates the physical space points in inarray to outarray using the same points defined in the expansion but where the number of points are rescaled by 1DScale.

Definition at line 621 of file ExpList.h.

     {
         v_PhysInterp1DScaled(scale, inarray, outarray);
     }

References v_PhysInterp1DScaled().

◆ Reset()

void Nektar::MultiRegions::ExpList::Reset ( )

inline

Reset geometry information and reset matrices.

Definition at line 383 of file ExpList.h.

     {
         v_Reset();
     }

References v_Reset().

◆ SetBndCondBwdWeight()

void Nektar::MultiRegions::ExpList::SetBndCondBwdWeight	(	const int	index,
		const NekDouble	value
	)

inline

Set the weight value for boundary conditions.

Definition at line 2090 of file ExpList.h.

 {
     v_SetBndCondBwdWeight(index, value);
 }

References v_SetBndCondBwdWeight().

◆ SetCoeff()

void Nektar::MultiRegions::ExpList::SetCoeff	(	int	i,
		NekDouble	val
	)

inline

Set the i th coefficiient in m_coeffs to value val.

Parameters

i	The index of m_coeffs to be set
val	The value which m_coeffs[i] is to be set to.

Definition at line 1878 of file ExpList.h.

 {
     m_coeffs[i] = val;
 }

References m_coeffs.

◆ SetCoeffs()

void Nektar::MultiRegions::ExpList::SetCoeffs	(	int	i,
		NekDouble	val
	)

inline

Set the i th coefficiient in m_coeffs to value val.

Parameters

i	The index of m_coeffs to be set.
val	The value which m_coeffs[i] is to be set to.

Definition at line 1886 of file ExpList.h.

 {
     m_coeffs[i] = val;
 }

References m_coeffs.

◆ SetCoeffsArray()

void Nektar::MultiRegions::ExpList::SetCoeffsArray ( Array< OneD, NekDouble > & inarray )

inline

Set the m_coeffs array to inarray.

Definition at line 1890 of file ExpList.h.

 {
     m_coeffs = inarray;
 }

References m_coeffs.

◆ SetExpType()

void Nektar::MultiRegions::ExpList::SetExpType ( ExpansionType Type )

Returns the type of the expansion.

◆ SetHomo1DSpecVanVisc()

void Nektar::MultiRegions::ExpList::SetHomo1DSpecVanVisc ( Array< OneD, NekDouble > visc )

inline

This function sets the Spectral Vanishing Viscosity in homogeneous1D expansion.

Definition at line 573 of file ExpList.h.

     {
         v_SetHomo1DSpecVanVisc(visc);
     }

References v_SetHomo1DSpecVanVisc().

◆ SetHomoLen()

void Nektar::MultiRegions::ExpList::SetHomoLen ( const NekDouble lhom )

inline

This function sets the Width of homogeneous direction associated with the homogeneous expansion.

Definition at line 603 of file ExpList.h.

     {
         return v_SetHomoLen(lhom);
     }

References v_SetHomoLen().

◆ SetModifiedBasis()

void Nektar::MultiRegions::ExpList::SetModifiedBasis ( const bool modbasis )

inline

Set Modified Basis for the stability analysis.

◆ SetPhys() [1/2]

void Nektar::MultiRegions::ExpList::SetPhys ( const Array< OneD, const NekDouble > & inarray )

inline

Fills the array m_phys.

This function fills the array $\boldsymbol{u}_l$, the evaluation of the expansion at the quadrature points (implemented as m_phys), with the values of the array inarray.

Parameters

inarray The array containing the values where m_phys should be filled with.

Definition at line 1602 of file ExpList.h.

 {
     ASSERTL0((int)inarray.size() == m_npoints,
              "Input array does not have correct number of elements.");
     Vmath::Vcopy(m_npoints, &inarray[0], 1, &m_phys[0], 1);
     m_physState = true;
 }

References ASSERTL0, m_npoints, m_phys, m_physState, and Vmath::Vcopy().

◆ SetPhys() [2/2]

void Nektar::MultiRegions::ExpList::SetPhys	(	int	i,
		NekDouble	val
	)

inline

Set the i th value of m_phys to value val.

Set the i th value ofm_phys to value val.

Definition at line 1590 of file ExpList.h.

 {
     m_phys[i] = val;
 }

References m_phys.

◆ SetPhysArray()

void Nektar::MultiRegions::ExpList::SetPhysArray ( Array< OneD, NekDouble > & inarray )

inline

Sets the array m_phys.

Definition at line 1609 of file ExpList.h.

 {
     m_phys = inarray;
 }

References m_phys.

◆ SetPhysState()

void Nektar::MultiRegions::ExpList::SetPhysState ( const bool physState )

inline

This function manually sets whether the array of physical values $\boldsymbol{u}_l$ (implemented as m_phys) is filled or not.

Parameters

physState true (=filled) or false (=not filled).

Definition at line 1616 of file ExpList.h.

 {
     m_physState = physState;
 }

References m_physState.

Referenced by export_ExpList().

◆ SetupCoeffPhys()

void Nektar::MultiRegions::ExpList::SetupCoeffPhys	(	bool	DeclareCoeffPhysArrays = `true`,
		bool	SetupOffsets = `true`
	)

private

Definition of the total number of degrees of freedom and quadrature points and offsets to access data.

Each expansion (local element) is processed in turn to determine the number of coefficients and physical data points it contributes to the domain. Two arrays, m_coeff_offset are m_phys_offset are also initialised and updated to store the data offsets of each element in the m_coeffs and m_phys arrays, and the element id that each consecutive block is associated respectively. Finally we initialise m_coeffs and m_phys

Definition at line 1099 of file ExpList.cpp.

 {
     if (SetupOffsets)
     {
         int i;
  
         // Set up offset information and array sizes
         m_coeff_offset = Array<OneD, int>(m_exp->size());
         m_phys_offset  = Array<OneD, int>(m_exp->size());
  
         m_ncoeffs = m_npoints = 0;
  
         for (i = 0; i < m_exp->size(); ++i)
         {
             m_coeff_offset[i] = m_ncoeffs;
             m_phys_offset[i]  = m_npoints;
             m_ncoeffs += (*m_exp)[i]->GetNcoeffs();
             m_npoints += (*m_exp)[i]->GetTotPoints();
         }
     }
  
     if (DeclareCoeffPhysArrays)
     {
         m_coeffs = Array<OneD, NekDouble>(m_ncoeffs, 0.0);
         m_phys   = Array<OneD, NekDouble>(m_npoints, 0.0);
     }
  
     m_coeffsToElmt = Array<OneD, pair<int, int>>{size_t(m_ncoeffs)};
  
     for (int i = 0; i < m_exp->size(); ++i)
     {
         int coeffs_offset = m_coeff_offset[i];
  
         int loccoeffs = (*m_exp)[i]->GetNcoeffs();
  
         for (int j = 0; j < loccoeffs; ++j)
         {
             m_coeffsToElmt[coeffs_offset + j].first  = i;
             m_coeffsToElmt[coeffs_offset + j].second = j;
         }
     }
 }

References m_coeff_offset, m_coeffs, m_coeffsToElmt, m_exp, m_ncoeffs, m_npoints, m_phys, and m_phys_offset.

Referenced by ExpList().

◆ SetUpPhysNormals()

void Nektar::MultiRegions::ExpList::SetUpPhysNormals ( )

inline

Definition at line 2218 of file ExpList.h.

 {
     v_SetUpPhysNormals();
 }

References v_SetUpPhysNormals().

Referenced by Nektar::MultiRegions::DisContField::DisContField(), Nektar::MultiRegions::DisContField::GenerateBoundaryConditionExpansion(), and Nektar::MultiRegions::DisContField::SetUpDG().

◆ SetWaveSpace()

void Nektar::MultiRegions::ExpList::SetWaveSpace ( const bool wavespace )

inline

Sets the wave space to the one of the possible configuration true or false.

Definition at line 1576 of file ExpList.h.

 {
     m_WaveSpace = wavespace;
 }

References m_WaveSpace.

◆ SmoothField()

void Nektar::MultiRegions::ExpList::SmoothField ( Array< OneD, NekDouble > & field )

inline

Smooth a field across elements.

Definition at line 1665 of file ExpList.h.

 {
     v_SmoothField(field);
 }

References v_SmoothField().

◆ UnsetGlobalLinSys()

void Nektar::MultiRegions::ExpList::UnsetGlobalLinSys	(	GlobalLinSysKey	key,
		bool	clearLocalMatrices
	)

Definition at line 5310 of file ExpList.cpp.

 {
     v_UnsetGlobalLinSys(key, clearLocalMatrices);
 }

References v_UnsetGlobalLinSys().

◆ UpdateBndCondExpansion()

std::shared_ptr< ExpList > & Nektar::MultiRegions::ExpList::UpdateBndCondExpansion ( int i )

inline

Definition at line 2094 of file ExpList.h.

 {
     return v_UpdateBndCondExpansion(i);
 }

References v_UpdateBndCondExpansion().

◆ UpdateBndConditions()

Array< OneD, SpatialDomains::BoundaryConditionShPtr > & Nektar::MultiRegions::ExpList::UpdateBndConditions ( )

inline

Definition at line 2207 of file ExpList.h.

 {
     return v_UpdateBndConditions();
 }

References v_UpdateBndConditions().

◆ UpdateCoeffs()

Array< OneD, NekDouble > & Nektar::MultiRegions::ExpList::UpdateCoeffs ( void )

inline

This function returns (a reference to) the array $\boldsymbol{\hat{u}}_l$ (implemented as m_coeffs) containing all local expansion coefficients.

If one wants to get hold of the underlying data without modifying them, rather use the function GetCoeffs instead.

Returns: (A reference to) the array m_coeffs.

Definition at line 2054 of file ExpList.h.

 {
     return m_coeffs;
 }

References m_coeffs.

Referenced by Nektar::MultiRegions::DisContField3DHomogeneous2D::v_EvaluateBoundaryConditions().

◆ UpdatePhys()

Array< OneD, NekDouble > & Nektar::MultiRegions::ExpList::UpdatePhys ( void )

inline

This function returns (a reference to) the array $\boldsymbol{u}_l$ (implemented as m_phys) containing the function $u^{\delta}(\boldsymbol{x})$ evaluated at the quadrature points.

If one wants to get hold of the underlying data without modifying them, rather use the function GetPhys instead.

Returns: (A reference to) the array m_phys.

Definition at line 2064 of file ExpList.h.

 {
     m_physState = true;
     return m_phys;
 }

References m_phys, and m_physState.

◆ Upwind() [1/2]

void Nektar::MultiRegions::ExpList::Upwind	(	const Array< OneD, const Array< OneD, NekDouble >> &	Vec,
		const Array< OneD, const NekDouble > &	Fwd,
		const Array< OneD, const NekDouble > &	Bwd,
		Array< OneD, NekDouble > &	Upwind
	)

inline

Definition at line 2098 of file ExpList.h.

 {
     v_Upwind(Vec, Fwd, Bwd, Upwind);
 }

References Upwind(), and v_Upwind().

◆ Upwind() [2/2]

void Nektar::MultiRegions::ExpList::Upwind	(	const Array< OneD, const NekDouble > &	Vn,
		const Array< OneD, const NekDouble > &	Fwd,
		const Array< OneD, const NekDouble > &	Bwd,
		Array< OneD, NekDouble > &	Upwind
	)

inline

Definition at line 2105 of file ExpList.h.

 {
     v_Upwind(Vn, Fwd, Bwd, Upwind);
 }

References v_Upwind().

Referenced by Upwind(), and v_Upwind().

◆ v_AddFwdBwdTraceIntegral()

void Nektar::MultiRegions::ExpList::v_AddFwdBwdTraceIntegral	(	const Array< OneD, const NekDouble > &	Fwd,
		const Array< OneD, const NekDouble > &	Bwd,
		Array< OneD, NekDouble > &	outarray
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::DisContField.

Definition at line 4397 of file ExpList.cpp.

 {
     boost::ignore_unused(Fwd, Bwd, outarray);
     NEKERROR(ErrorUtil::efatal,
              "This method is not defined or valid for this class type");
 }

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

Referenced by AddFwdBwdTraceIntegral().

◆ v_AddTraceIntegral() [1/2]

void Nektar::MultiRegions::ExpList::v_AddTraceIntegral	(	const Array< OneD, const NekDouble > &	Fn,
		Array< OneD, NekDouble > &	outarray
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::DisContField.

Definition at line 4389 of file ExpList.cpp.

 {
     boost::ignore_unused(Fn, outarray);
     NEKERROR(ErrorUtil::efatal,
              "This method is not defined or valid for this class type");
 }

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

◆ v_AddTraceIntegral() [2/2]

void Nektar::MultiRegions::ExpList::v_AddTraceIntegral	(	const Array< OneD, const NekDouble > &	Fx,
		const Array< OneD, const NekDouble > &	Fy,
		Array< OneD, NekDouble > &	outarray
	)

protectedvirtual

Definition at line 4380 of file ExpList.cpp.

 {
     boost::ignore_unused(Fx, Fy, outarray);
     NEKERROR(ErrorUtil::efatal,
              "This method is not defined or valid for this class type");
 }

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

Referenced by AddTraceIntegral().

◆ v_AddTraceIntegralToOffDiag()

void Nektar::MultiRegions::ExpList::v_AddTraceIntegralToOffDiag	(	const Array< OneD, const NekDouble > &	FwdFlux,
		const Array< OneD, const NekDouble > &	BwdFlux,
		Array< OneD, NekDouble > &	outarray
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::DisContField.

Definition at line 5397 of file ExpList.cpp.

 {
     boost::ignore_unused(FwdFlux, BwdFlux, outarray);
     NEKERROR(ErrorUtil::efatal, "AddTraceIntegralToOffDiag not defined");
 }

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

Referenced by AddTraceIntegralToOffDiag().

◆ v_AddTraceQuadPhysToField()

void Nektar::MultiRegions::ExpList::v_AddTraceQuadPhysToField	(	const Array< OneD, const NekDouble > &	Fwd,
		const Array< OneD, const NekDouble > &	Bwd,
		Array< OneD, NekDouble > &	field
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::DisContField.

Definition at line 4434 of file ExpList.cpp.

 {
     boost::ignore_unused(field, Fwd, Bwd);
     NEKERROR(ErrorUtil::efatal,
              "v_AddTraceQuadPhysToField is not defined for this class type");
 }

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

Referenced by AddTraceQuadPhysToField().

◆ v_AddTraceQuadPhysToOffDiag()

void Nektar::MultiRegions::ExpList::v_AddTraceQuadPhysToOffDiag	(	const Array< OneD, const NekDouble > &	Fwd,
		const Array< OneD, const NekDouble > &	Bwd,
		Array< OneD, NekDouble > &	field
	)

protectedvirtual

Definition at line 4443 of file ExpList.cpp.

 {
     boost::ignore_unused(field, Fwd, Bwd);
     NEKERROR(ErrorUtil::efatal,
              "v_AddTraceQuadPhysToOffDiag is not defined for this class");
 }

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

Referenced by AddTraceQuadPhysToOffDiag().

◆ v_AppendFieldData() [1/2]

void Nektar::MultiRegions::ExpList::v_AppendFieldData	(	LibUtilities::FieldDefinitionsSharedPtr &	fielddef,
		std::vector< NekDouble > &	fielddata
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::ExpListHomogeneous2D, and Nektar::MultiRegions::ExpListHomogeneous1D.

Definition at line 3531 of file ExpList.cpp.

 {
     v_AppendFieldData(fielddef, fielddata, m_coeffs);
 }

References m_coeffs.

Referenced by AppendFieldData().

◆ v_AppendFieldData() [2/2]

void Nektar::MultiRegions::ExpList::v_AppendFieldData	(	LibUtilities::FieldDefinitionsSharedPtr &	fielddef,
		std::vector< NekDouble > &	fielddata,
		Array< OneD, NekDouble > &	coeffs
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::ExpListHomogeneous2D, and Nektar::MultiRegions::ExpListHomogeneous1D.

Definition at line 3538 of file ExpList.cpp.

 {
     int i;
     // Determine mapping from element ids to location in
     // expansion list
     // Determine mapping from element ids to location in
     // expansion list
     map<int, int> ElmtID_to_ExpID;
     for (i = 0; i < (*m_exp).size(); ++i)
     {
         ElmtID_to_ExpID[(*m_exp)[i]->GetGeom()->GetGlobalID()] = i;
     }
  
     for (i = 0; i < fielddef->m_elementIDs.size(); ++i)
     {
         int eid     = ElmtID_to_ExpID[fielddef->m_elementIDs[i]];
         int datalen = (*m_exp)[eid]->GetNcoeffs();
         fielddata.insert(fielddata.end(), &coeffs[m_coeff_offset[eid]],
                          &coeffs[m_coeff_offset[eid]] + datalen);
     }
 }

References m_coeff_offset.

◆ v_BwdTrans()

void Nektar::MultiRegions::ExpList::v_BwdTrans	(	const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray
	)

protectedvirtual

Given the elemental coefficients $\hat{u}_n^e$ of an expansion, this function evaluates the spectral/hp expansion $u^{\delta}(\boldsymbol{x})$ at the quadrature points $\boldsymbol{x}_i$. The operation is evaluated locally by the elemental function StdRegions::StdExpansion::BwdTrans.

Parameters

inarray	An array of size $N_{\mathrm{eof}}$ containing the local coefficients $\hat{u}_n^e$.
outarray	The resulting physical values at the quadrature points $u^{\delta}(\boldsymbol{x}_i)$ will be stored in this array of size $Q_{\mathrm{tot}}$.

Reimplemented in Nektar::MultiRegions::ExpListHomogeneous2D, and Nektar::MultiRegions::ExpListHomogeneous1D.

Definition at line 2470 of file ExpList.cpp.

 {
     LibUtilities::Timer timer;
  
     if (m_expType == e0D)
     {
         Vmath::Vcopy(m_ncoeffs, inarray, 1, outarray, 1);
     }
     else
     {
         // initialise if required
         if (m_collections.size() && m_collectionsDoInit[Collections::eBwdTrans])
         {
             for (int i = 0; i < m_collections.size(); ++i)
             {
                 m_collections[i].Initialise(Collections::eBwdTrans);
             }
             m_collectionsDoInit[Collections::eBwdTrans] = false;
         }
  
         LIKWID_MARKER_START("v_BwdTrans");
         timer.Start();
  
         Array<OneD, NekDouble> tmp;
         for (int i = 0; i < m_collections.size(); ++i)
         {
             m_collections[i].ApplyOperator(
                 Collections::eBwdTrans, inarray + m_coll_coeff_offset[i],
                 tmp = outarray + m_coll_phys_offset[i]);
         }
  
         timer.Stop();
         LIKWID_MARKER_STOP("v_BwdTrans");
     }
  
     // Elapsed time
     timer.AccumulateRegion("Collections:BwdTrans", 10);
 }

References Nektar::LibUtilities::Timer::AccumulateRegion(), Nektar::MultiRegions::e0D, Nektar::Collections::eBwdTrans, LIKWID_MARKER_START, LIKWID_MARKER_STOP, m_coll_coeff_offset, m_coll_phys_offset, m_collections, m_collectionsDoInit, m_expType, m_ncoeffs, Nektar::LibUtilities::Timer::Start(), Nektar::LibUtilities::Timer::Stop(), and Vmath::Vcopy().

Referenced by BwdTrans().

◆ v_ClearGlobalLinSysManager()

void Nektar::MultiRegions::ExpList::v_ClearGlobalLinSysManager ( void )

protectedvirtual

Reimplemented in Nektar::MultiRegions::ContField3DHomogeneous2D, Nektar::MultiRegions::ContField3DHomogeneous1D, and Nektar::MultiRegions::ContField.

Definition at line 3303 of file ExpList.cpp.

 {
     NEKERROR(ErrorUtil::efatal,
              "ClearGlobalLinSysManager not implemented for ExpList.");
 }

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

Referenced by ClearGlobalLinSysManager().

◆ v_CurlCurl()

void Nektar::MultiRegions::ExpList::v_CurlCurl	(	Array< OneD, Array< OneD, NekDouble >> &	Vel,
		Array< OneD, Array< OneD, NekDouble >> &	Q
	)

protectedvirtual

Definition at line 1652 of file ExpList.cpp.

 {
     int nq = GetTotPoints();
     Array<OneD, NekDouble> Vx(nq);
     Array<OneD, NekDouble> Uy(nq);
     Array<OneD, NekDouble> Dummy(nq);
  
     bool halfMode = false;
     if (GetExpType() == e3DH1D)
     {
         m_session->MatchSolverInfo("ModeType", "HalfMode", halfMode, false);
     }
  
     switch (m_expType)
     {
         case e2D:
         {
             PhysDeriv(xDir, Vel[yDir], Vx);
             PhysDeriv(yDir, Vel[xDir], Uy);
  
             Vmath::Vsub(nq, Vx, 1, Uy, 1, Dummy, 1);
  
             PhysDeriv(Dummy, Q[1], Q[0]);
  
             Vmath::Smul(nq, -1.0, Q[1], 1, Q[1], 1);
         }
         break;
  
         case e3D:
         case e3DH1D:
         case e3DH2D:
         {
             Array<OneD, NekDouble> Vz(nq);
             Array<OneD, NekDouble> Uz(nq);
             Array<OneD, NekDouble> Wx(nq);
             Array<OneD, NekDouble> Wy(nq);
  
             PhysDeriv(Vel[xDir], Dummy, Uy, Uz);
             PhysDeriv(Vel[yDir], Vx, Dummy, Vz);
             PhysDeriv(Vel[zDir], Wx, Wy, Dummy);
  
             Vmath::Vsub(nq, Wy, 1, Vz, 1, Q[0], 1);
             Vmath::Vsub(nq, Uz, 1, Wx, 1, Q[1], 1);
             Vmath::Vsub(nq, Vx, 1, Uy, 1, Q[2], 1);
  
             PhysDeriv(Q[0], Dummy, Uy, Uz);
             PhysDeriv(Q[1], Vx, Dummy, Vz);
             PhysDeriv(Q[2], Wx, Wy, Dummy);
  
             // For halfmode, need to change the sign of z derivatives
             if (halfMode)
             {
                 Vmath::Neg(nq, Uz, 1);
                 Vmath::Neg(nq, Vz, 1);
             }
  
             Vmath::Vsub(nq, Wy, 1, Vz, 1, Q[0], 1);
             Vmath::Vsub(nq, Uz, 1, Wx, 1, Q[1], 1);
             Vmath::Vsub(nq, Vx, 1, Uy, 1, Q[2], 1);
         }
         break;
         default:
             ASSERTL0(0, "Dimension not supported");
             break;
     }
 }

References ASSERTL0, Nektar::MultiRegions::e2D, Nektar::MultiRegions::e3D, Nektar::MultiRegions::e3DH1D, Nektar::MultiRegions::e3DH2D, GetExpType(), GetTotPoints(), m_expType, m_session, Vmath::Neg(), PhysDeriv(), Vmath::Smul(), Vmath::Vsub(), Nektar::xDir, Nektar::yDir, and Nektar::zDir.

Referenced by CurlCurl().

◆ v_DealiasedDotProd()

void Nektar::MultiRegions::ExpList::v_DealiasedDotProd	(	const int	num_dofs,
		const Array< OneD, Array< OneD, NekDouble >> &	inarray1,
		const Array< OneD, Array< OneD, NekDouble >> &	inarray2,
		Array< OneD, Array< OneD, NekDouble >> &	outarray
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::ExpListHomogeneous2D, and Nektar::MultiRegions::ExpListHomogeneous1D.

Definition at line 4575 of file ExpList.cpp.

 {
     boost::ignore_unused(npts, inarray1, inarray2, outarray);
     NEKERROR(ErrorUtil::efatal,
              "This method is not defined or valid for this class type");
 }

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

Referenced by DealiasedDotProd().

◆ v_DealiasedProd()

void Nektar::MultiRegions::ExpList::v_DealiasedProd	(	const int	num_dofs,
		const Array< OneD, NekDouble > &	inarray1,
		const Array< OneD, NekDouble > &	inarray2,
		Array< OneD, NekDouble > &	outarray
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::ExpListHomogeneous2D, and Nektar::MultiRegions::ExpListHomogeneous1D.

Definition at line 4565 of file ExpList.cpp.

 {
     boost::ignore_unused(npts, inarray1, inarray2, outarray);
     NEKERROR(ErrorUtil::efatal,
              "This method is not defined or valid for this class type");
 }

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

Referenced by DealiasedProd().

◆ v_EvaluateBoundaryConditions()

void Nektar::MultiRegions::ExpList::v_EvaluateBoundaryConditions	(	const NekDouble	time = `0.0`,
		const std::string	varName = `""`,
		const NekDouble	x2_in = `NekConstants::kNekUnsetDouble`,
		const NekDouble	x3_in = `NekConstants::kNekUnsetDouble`
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::DisContField3DHomogeneous2D, Nektar::MultiRegions::DisContField3DHomogeneous1D, and Nektar::MultiRegions::DisContField.

Definition at line 5039 of file ExpList.cpp.

 {
     boost::ignore_unused(time, varName, x2_in, x3_in);
     NEKERROR(ErrorUtil::efatal,
              "This method is not defined or valid for this class type");
 }

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

Referenced by EvaluateBoundaryConditions().

◆ v_ExtractCoeffsToCoeffs()

void Nektar::MultiRegions::ExpList::v_ExtractCoeffsToCoeffs	(	const std::shared_ptr< ExpList > &	fromExpList,
		const Array< OneD, const NekDouble > &	fromCoeffs,
		Array< OneD, NekDouble > &	toCoeffs
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::ExpListHomogeneous1D.

Definition at line 3675 of file ExpList.cpp.

 {
     int i;
     int offset = 0;
  
     for (i = 0; i < (*m_exp).size(); ++i)
     {
         std::vector<unsigned int> nummodes;
         vector<LibUtilities::BasisType> basisTypes;
         for (int j = 0; j < fromExpList->GetExp(i)->GetNumBases(); ++j)
         {
             nummodes.push_back(fromExpList->GetExp(i)->GetBasisNumModes(j));
             basisTypes.push_back(fromExpList->GetExp(i)->GetBasisType(j));
         }
  
         (*m_exp)[i]->ExtractDataToCoeffs(&fromCoeffs[offset], nummodes, 0,
                                          &toCoeffs[m_coeff_offset[i]],
                                          basisTypes);
  
         offset += fromExpList->GetExp(i)->GetNcoeffs();
     }
 }

References m_coeff_offset.

Referenced by ExtractCoeffsToCoeffs().

◆ v_ExtractDataToCoeffs()

void Nektar::MultiRegions::ExpList::v_ExtractDataToCoeffs	(	LibUtilities::FieldDefinitionsSharedPtr &	fielddef,
		std::vector< NekDouble > &	fielddata,
		std::string &	field,
		Array< OneD, NekDouble > &	coeffs,
		std::unordered_map< int, int >	zIdToPlane
	)

protectedvirtual

Extract data from raw field data into expansion list.

Parameters

fielddef	Field definitions.
fielddata	Data for associated field.
field	Field variable name.
coeffs	Resulting coefficient array.

Reimplemented in Nektar::MultiRegions::ExpListHomogeneous2D, and Nektar::MultiRegions::ExpListHomogeneous1D.

Definition at line 3587 of file ExpList.cpp.

 {
     boost::ignore_unused(zIdToPlane);
     int i, expId;
     int offset       = 0;
     int modes_offset = 0;
     int datalen      = fielddata.size() / fielddef->m_fields.size();
  
     // Find data location according to field definition
     for (i = 0; i < fielddef->m_fields.size(); ++i)
     {
         if (fielddef->m_fields[i] == field)
         {
             break;
         }
         offset += datalen;
     }
  
     ASSERTL0(i != fielddef->m_fields.size(),
              "Field (" + field + ") not found in file.");
  
     if (m_elmtToExpId.size() == 0)
     {
         // Loop in reverse order so that in case where using a
         // Homogeneous expansion it sets geometry ids to first part of
         // m_exp list. Otherwise will set to second (complex) expansion
         for (i = (*m_exp).size() - 1; i >= 0; --i)
         {
             m_elmtToExpId[(*m_exp)[i]->GetGeom()->GetGlobalID()] = i;
         }
     }
  
     for (i = 0; i < fielddef->m_elementIDs.size(); ++i)
     {
         // Reset modes_offset in the case where all expansions of
         // the same order.
         if (fielddef->m_uniOrder == true)
         {
             modes_offset = 0;
         }
  
         datalen = LibUtilities::GetNumberOfCoefficients(
             fielddef->m_shapeType, fielddef->m_numModes, modes_offset);
  
         const int elmtId = fielddef->m_elementIDs[i];
         auto eIt         = m_elmtToExpId.find(elmtId);
  
         if (eIt == m_elmtToExpId.end())
         {
             offset += datalen;
             modes_offset += (*m_exp)[0]->GetNumBases();
             continue;
         }
  
         expId = eIt->second;
  
         bool sameBasis = true;
         for (int j = 0; j < fielddef->m_basis.size(); ++j)
         {
             if (fielddef->m_basis[j] != (*m_exp)[expId]->GetBasisType(j))
             {
                 sameBasis = false;
                 break;
             }
         }
  
         if (datalen == (*m_exp)[expId]->GetNcoeffs() && sameBasis)
         {
             Vmath::Vcopy(datalen, &fielddata[offset], 1,
                          &coeffs[m_coeff_offset[expId]], 1);
         }
         else
         {
             (*m_exp)[expId]->ExtractDataToCoeffs(
                 &fielddata[offset], fielddef->m_numModes, modes_offset,
                 &coeffs[m_coeff_offset[expId]], fielddef->m_basis);
         }
  
         offset += datalen;
         modes_offset += (*m_exp)[0]->GetNumBases();
     }
  
     return;
 }

References ASSERTL0, GetNcoeffs(), Nektar::LibUtilities::GetNumberOfCoefficients(), m_coeff_offset, m_elmtToExpId, m_exp, and Vmath::Vcopy().

Referenced by ExtractDataToCoeffs().

◆ v_ExtractElmtToBndPhys()

void Nektar::MultiRegions::ExpList::v_ExtractElmtToBndPhys	(	const int	i,
		const Array< OneD, NekDouble > &	elmt,
		Array< OneD, NekDouble > &	boundary
	)

protectedvirtual

Definition at line 4835 of file ExpList.cpp.

 {
     int n, cnt;
     Array<OneD, NekDouble> tmp1, tmp2;
     LocalRegions::ExpansionSharedPtr elmt;
  
     Array<OneD, int> ElmtID, EdgeID;
     GetBoundaryToElmtMap(ElmtID, EdgeID);
  
     // Initialise result
     boundary =
         Array<OneD, NekDouble>(GetBndCondExpansions()[i]->GetTotPoints(), 0.0);
  
     // Skip other boundary regions
     for (cnt = n = 0; n < i; ++n)
     {
         cnt += GetBndCondExpansions()[n]->GetExpSize();
     }
  
     int offsetBnd;
     int offsetElmt = 0;
     for (n = 0; n < GetBndCondExpansions()[i]->GetExpSize(); ++n)
     {
         offsetBnd = GetBndCondExpansions()[i]->GetPhys_Offset(n);
  
         elmt = GetExp(ElmtID[cnt + n]);
         elmt->GetTracePhysVals(
             EdgeID[cnt + n], GetBndCondExpansions()[i]->GetExp(n),
             tmp1 = element + offsetElmt, tmp2 = boundary + offsetBnd);
  
         offsetElmt += elmt->GetTotPoints();
     }
 }

References GetBndCondExpansions(), GetBoundaryToElmtMap(), GetExp(), and GetTotPoints().

Referenced by ExtractElmtToBndPhys().

◆ v_ExtractPhysToBnd()

void Nektar::MultiRegions::ExpList::v_ExtractPhysToBnd	(	const int	i,
		const Array< OneD, const NekDouble > &	phys,
		Array< OneD, NekDouble > &	bnd
	)

protectedvirtual

Definition at line 4912 of file ExpList.cpp.

 {
     int n, cnt;
     Array<OneD, NekDouble> tmp1;
     LocalRegions::ExpansionSharedPtr elmt;
  
     Array<OneD, int> ElmtID, EdgeID;
     GetBoundaryToElmtMap(ElmtID, EdgeID);
  
     // Initialise result
     bnd =
         Array<OneD, NekDouble>(GetBndCondExpansions()[i]->GetTotPoints(), 0.0);
  
     // Skip other boundary regions
     for (cnt = n = 0; n < i; ++n)
     {
         cnt += GetBndCondExpansions()[n]->GetExpSize();
     }
  
     int offsetBnd;
     int offsetPhys;
     for (n = 0; n < GetBndCondExpansions()[i]->GetExpSize(); ++n)
     {
         offsetPhys = GetPhys_Offset(ElmtID[cnt + n]);
         offsetBnd  = GetBndCondExpansions()[i]->GetPhys_Offset(n);
  
         elmt = GetExp(ElmtID[cnt + n]);
         elmt->GetTracePhysVals(EdgeID[cnt + n],
                                GetBndCondExpansions()[i]->GetExp(n),
                                phys + offsetPhys, tmp1 = bnd + offsetBnd);
     }
 }

References GetBndCondExpansions(), GetBoundaryToElmtMap(), GetExp(), GetPhys_Offset(), and GetTotPoints().

Referenced by ExtractPhysToBnd().

◆ v_ExtractPhysToBndElmt()

void Nektar::MultiRegions::ExpList::v_ExtractPhysToBndElmt	(	const int	i,
		const Array< OneD, const NekDouble > &	phys,
		Array< OneD, NekDouble > &	bndElmt
	)

protectedvirtual

Definition at line 4873 of file ExpList.cpp.

 {
     int n, cnt, nq;
  
     Array<OneD, int> ElmtID, EdgeID;
     GetBoundaryToElmtMap(ElmtID, EdgeID);
  
     // Skip other boundary regions
     for (cnt = n = 0; n < i; ++n)
     {
         cnt += GetBndCondExpansions()[n]->GetExpSize();
     }
  
     // Count number of points
     int npoints = 0;
     for (n = 0; n < GetBndCondExpansions()[i]->GetExpSize(); ++n)
     {
         npoints += GetExp(ElmtID[cnt + n])->GetTotPoints();
     }
  
     // Initialise result
     bndElmt = Array<OneD, NekDouble>(npoints, 0.0);
  
     // Extract data
     int offsetPhys;
     int offsetElmt = 0;
     for (n = 0; n < GetBndCondExpansions()[i]->GetExpSize(); ++n)
     {
         nq         = GetExp(ElmtID[cnt + n])->GetTotPoints();
         offsetPhys = GetPhys_Offset(ElmtID[cnt + n]);
         Vmath::Vcopy(nq, &phys[offsetPhys], 1, &bndElmt[offsetElmt], 1);
         offsetElmt += nq;
     }
 }

References GetBndCondExpansions(), GetBoundaryToElmtMap(), GetExp(), GetPhys_Offset(), and Vmath::Vcopy().

Referenced by ExtractPhysToBndElmt().

◆ v_ExtractTracePhys() [1/2]

void Nektar::MultiRegions::ExpList::v_ExtractTracePhys ( Array< OneD, NekDouble > & outarray )

protectedvirtual

Reimplemented in Nektar::MultiRegions::DisContField3DHomogeneous1D, and Nektar::MultiRegions::DisContField.

Definition at line 4485 of file ExpList.cpp.

 {
     boost::ignore_unused(outarray);
     NEKERROR(ErrorUtil::efatal,
              "This method is not defined or valid for this class type");
 }

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

Referenced by ExtractTracePhys().

◆ v_ExtractTracePhys() [2/2]

void Nektar::MultiRegions::ExpList::v_ExtractTracePhys	(	const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::DisContField3DHomogeneous1D, and Nektar::MultiRegions::DisContField.

Definition at line 4492 of file ExpList.cpp.

 {
     boost::ignore_unused(inarray, outarray);
     NEKERROR(ErrorUtil::efatal,
              "This method is not defined or valid for this class type");
 }

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

◆ v_FillBndCondFromField() [1/2]

void Nektar::MultiRegions::ExpList::v_FillBndCondFromField ( const Array< OneD, NekDouble > coeffs )

protectedvirtual

Reimplemented in Nektar::MultiRegions::ContField3DHomogeneous1D, and Nektar::MultiRegions::ContField.

Definition at line 4655 of file ExpList.cpp.

 {
     boost::ignore_unused(coeffs);
     NEKERROR(ErrorUtil::efatal,
              "This method is not defined or valid for this class type");
 }

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

Referenced by FillBndCondFromField().

◆ v_FillBndCondFromField() [2/2]

void Nektar::MultiRegions::ExpList::v_FillBndCondFromField	(	const int	nreg,
		const Array< OneD, NekDouble >	coeffs
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::ContField3DHomogeneous1D, and Nektar::MultiRegions::ContField.

Definition at line 4664 of file ExpList.cpp.

 {
     boost::ignore_unused(nreg, coeffs);
     NEKERROR(ErrorUtil::efatal,
              "This method is not defined or valid for this class type");
 }

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

◆ v_FillBwdWithBoundCond()

void Nektar::MultiRegions::ExpList::v_FillBwdWithBoundCond	(	const Array< OneD, NekDouble > &	Fwd,
		Array< OneD, NekDouble > &	Bwd,
		bool	PutFwdInBwdOnBCs
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::DisContField.

Definition at line 4425 of file ExpList.cpp.

 {
     boost::ignore_unused(Fwd, Bwd, PutFwdInBwdOnBCs);
     NEKERROR(ErrorUtil::efatal,
              "This method is not defined or valid for this class type");
 }

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

Referenced by FillBwdWithBoundCond().

◆ v_FillBwdWithBwdWeight()

void Nektar::MultiRegions::ExpList::v_FillBwdWithBwdWeight	(	Array< OneD, NekDouble > &	weightave,
		Array< OneD, NekDouble > &	weightjmp
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::DisContField.

Definition at line 5001 of file ExpList.cpp.

 {
     boost::ignore_unused(weightave, weightjmp);
     NEKERROR(ErrorUtil::efatal, "v_FillBwdWithBwdWeight not defined");
 }

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

Referenced by FillBwdWithBwdWeight().

◆ v_FwdTrans()

void Nektar::MultiRegions::ExpList::v_FwdTrans	(	const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::ExpListHomogeneous2D, Nektar::MultiRegions::ExpListHomogeneous1D, Nektar::MultiRegions::ExpList2DHomogeneous2D, and Nektar::MultiRegions::ContField.

Definition at line 4701 of file ExpList.cpp.

 {
     v_FwdTransLocalElmt(inarray, outarray);
 }

References v_FwdTransLocalElmt().

Referenced by FwdTrans().

◆ v_FwdTransBndConstrained()

void Nektar::MultiRegions::ExpList::v_FwdTransBndConstrained	(	const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::ExpListHomogeneous2D, Nektar::MultiRegions::ExpListHomogeneous1D, and Nektar::MultiRegions::ExpList2DHomogeneous2D.

Definition at line 1818 of file ExpList.cpp.

 {
     int i;
  
     Array<OneD, NekDouble> e_outarray;
  
     for (i = 0; i < (*m_exp).size(); ++i)
     {
         (*m_exp)[i]->FwdTransBndConstrained(inarray + m_phys_offset[i],
                                             e_outarray =
                                                 outarray + m_coeff_offset[i]);
     }
 }

References m_coeff_offset, and m_phys_offset.

Referenced by FwdTransBndConstrained().

◆ v_FwdTransLocalElmt()

void Nektar::MultiRegions::ExpList::v_FwdTransLocalElmt	(	const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray
	)

protectedvirtual

Given a function $u(\boldsymbol{x})$ defined at the quadrature points, this function determines the transformed elemental coefficients $\hat{u}_n^e$ employing a discrete elemental Galerkin projection from physical space to coefficient space. For each element, the operation is evaluated locally by the function StdRegions::StdExpansion::IproductWRTBase followed by a call to #MultiRegions#MultiplyByElmtInvMass.

Parameters

inarray	An array of size $Q_{\mathrm{tot}}$ containing the values of the function $f(\boldsymbol{x})$ at the quadrature points $\boldsymbol{x}_i$.
outarray	The resulting coefficients $\hat{u}_n^e$ will be stored in this array of size $N_{\mathrm{eof}}$.

Reimplemented in Nektar::MultiRegions::ExpListHomogeneous2D, Nektar::MultiRegions::ExpListHomogeneous1D, and Nektar::MultiRegions::ExpList2DHomogeneous2D.

Definition at line 1809 of file ExpList.cpp.

 {
     Array<OneD, NekDouble> f(m_ncoeffs);
  
     IProductWRTBase(inarray, f);
     MultiplyByElmtInvMass(f, outarray);
 }

References IProductWRTBase(), m_ncoeffs, and MultiplyByElmtInvMass().

Referenced by FwdTransLocalElmt(), and v_FwdTrans().

◆ v_GetBCValues()

void Nektar::MultiRegions::ExpList::v_GetBCValues	(	Array< OneD, NekDouble > &	BndVals,
		const Array< OneD, NekDouble > &	TotField,
		int	BndID
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::DisContField3DHomogeneous1D.

Definition at line 4585 of file ExpList.cpp.

 {
     boost::ignore_unused(BndVals, TotField, BndID);
     NEKERROR(ErrorUtil::efatal,
              "This method is not defined or valid for this class type");
 }

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

Referenced by GetBCValues().

◆ v_GetBndCondBwdWeight()

const Array< OneD, const NekDouble > & Nektar::MultiRegions::ExpList::v_GetBndCondBwdWeight ( )

protectedvirtual

Reimplemented in Nektar::MultiRegions::DisContField.

Definition at line 4462 of file ExpList.cpp.

 {
     NEKERROR(ErrorUtil::efatal,
              "v_GetBndCondBwdWeight is not defined for this class type");
     static Array<OneD, NekDouble> tmp;
     return tmp;
 }

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

Referenced by GetBndCondBwdWeight().

◆ v_GetBndCondExpansions()

const Array< OneD, const std::shared_ptr< ExpList > > & Nektar::MultiRegions::ExpList::v_GetBndCondExpansions ( void )

protectedvirtual

Reimplemented in Nektar::MultiRegions::DisContField3DHomogeneous2D, Nektar::MultiRegions::DisContField3DHomogeneous1D, and Nektar::MultiRegions::DisContField.

Definition at line 3791 of file ExpList.cpp.

 {
     NEKERROR(ErrorUtil::efatal,
              "This method is not defined or valid for this class type");
     static Array<OneD, const std::shared_ptr<ExpList>> result;
     return result;
 }

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

Referenced by GetBndCondExpansions().

◆ v_GetBndConditions()

const Array< OneD, const SpatialDomains::BoundaryConditionShPtr > & Nektar::MultiRegions::ExpList::v_GetBndConditions ( void )

protectedvirtual

Reimplemented in Nektar::MultiRegions::DisContField3DHomogeneous2D, Nektar::MultiRegions::DisContField3DHomogeneous1D, Nektar::MultiRegions::DisContField, and Nektar::MultiRegions::ContField.

Definition at line 5018 of file ExpList.cpp.

 {
     NEKERROR(ErrorUtil::efatal,
              "This method is not defined or valid for this class type");
     static Array<OneD, const SpatialDomains::BoundaryConditionShPtr> result;
     return result;
 }

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

Referenced by GetBndConditions().

◆ v_GetBndElmtExpansion()

void Nektar::MultiRegions::ExpList::v_GetBndElmtExpansion	(	int	i,
		std::shared_ptr< ExpList > &	result,
		const bool	DeclareCoeffPhysArrays
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::DisContField3DHomogeneous2D, Nektar::MultiRegions::DisContField3DHomogeneous1D, and Nektar::MultiRegions::DisContField.

Definition at line 4825 of file ExpList.cpp.

 {
     boost::ignore_unused(i, result, DeclareCoeffPhysArrays);
     NEKERROR(ErrorUtil::efatal,
              "This method is not defined or valid for this class type");
 }

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

Referenced by GetBndElmtExpansion().

◆ v_GetBoundaryNormals()

void Nektar::MultiRegions::ExpList::v_GetBoundaryNormals	(	int	i,
		Array< OneD, Array< OneD, NekDouble >> &	normals
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::DisContField3DHomogeneous1D.

Definition at line 4949 of file ExpList.cpp.

 {
     int j, n, cnt, nq;
     int coordim = GetCoordim(0);
     Array<OneD, NekDouble> tmp;
     LocalRegions::ExpansionSharedPtr elmt;
  
     Array<OneD, int> ElmtID, EdgeID;
     GetBoundaryToElmtMap(ElmtID, EdgeID);
  
     // Initialise result
     normals = Array<OneD, Array<OneD, NekDouble>>(coordim);
     for (j = 0; j < coordim; ++j)
     {
         normals[j] = Array<OneD, NekDouble>(
             GetBndCondExpansions()[i]->GetTotPoints(), 0.0);
     }
  
     // Skip other boundary regions
     for (cnt = n = 0; n < i; ++n)
     {
         cnt += GetBndCondExpansions()[n]->GetExpSize();
     }
  
     int offset;
     for (n = 0; n < GetBndCondExpansions()[i]->GetExpSize(); ++n)
     {
         offset = GetBndCondExpansions()[i]->GetPhys_Offset(n);
         nq     = GetBndCondExpansions()[i]->GetExp(n)->GetTotPoints();
  
         elmt = GetExp(ElmtID[cnt + n]);
         const Array<OneD, const Array<OneD, NekDouble>> normalsElmt =
             elmt->GetTraceNormal(EdgeID[cnt + n]);
         // Copy to result
         for (j = 0; j < coordim; ++j)
         {
             Vmath::Vcopy(nq, normalsElmt[j], 1, tmp = normals[j] + offset, 1);
         }
     }
 }

References GetBndCondExpansions(), GetBoundaryToElmtMap(), GetCoordim(), GetExp(), GetTotPoints(), and Vmath::Vcopy().

Referenced by GetBoundaryNormals().

◆ v_GetBoundaryToElmtMap()

void Nektar::MultiRegions::ExpList::v_GetBoundaryToElmtMap	(	Array< OneD, int > &	ElmtID,
		Array< OneD, int > &	EdgeID
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::DisContField, Nektar::MultiRegions::DisContField3DHomogeneous2D, and Nektar::MultiRegions::DisContField3DHomogeneous1D.

Definition at line 4993 of file ExpList.cpp.

 {
     boost::ignore_unused(ElmtID, EdgeID);
     NEKERROR(ErrorUtil::efatal,
              "This method is not defined or valid for this class type");
 }

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

Referenced by GetBoundaryToElmtMap().

◆ v_GetCoords() [1/2]

void Nektar::MultiRegions::ExpList::v_GetCoords	(	Array< OneD, NekDouble > &	coord_0,
		Array< OneD, NekDouble > &	coord_1 = `NullNekDouble1DArray`,
		Array< OneD, NekDouble > &	coord_2 = `NullNekDouble1DArray`
	)

protectedvirtual

The operation is evaluated locally by the elemental function StdRegions::StdExpansion::GetCoords.

Parameters

coord_0	After calculation, the $x_1$ coordinate will be stored in this array.
coord_1	After calculation, the $x_2$ coordinate will be stored in this array.
coord_2	After calculation, the $x_3$ coordinate will be stored in this array.

Reimplemented in Nektar::MultiRegions::ExpList3DHomogeneous2D, Nektar::MultiRegions::ExpList3DHomogeneous1D, Nektar::MultiRegions::ExpList2DHomogeneous2D, and Nektar::MultiRegions::ExpList2DHomogeneous1D.

Definition at line 4752 of file ExpList.cpp.

 {
     if (GetNumElmts() == 0)
     {
         return;
     }
  
     int i;
     Array<OneD, NekDouble> e_coord_0;
     Array<OneD, NekDouble> e_coord_1;
     Array<OneD, NekDouble> e_coord_2;
  
     switch (GetExp(0)->GetCoordim())
     {
         case 1:
             for (i = 0; i < (*m_exp).size(); ++i)
             {
                 e_coord_0 = coord_0 + m_phys_offset[i];
                 (*m_exp)[i]->GetCoords(e_coord_0);
             }
             break;
         case 2:
             ASSERTL0(coord_1.size() != 0, "output coord_1 is not defined");
  
             for (i = 0; i < (*m_exp).size(); ++i)
             {
                 e_coord_0 = coord_0 + m_phys_offset[i];
                 e_coord_1 = coord_1 + m_phys_offset[i];
                 (*m_exp)[i]->GetCoords(e_coord_0, e_coord_1);
             }
             break;
         case 3:
             ASSERTL0(coord_1.size() != 0, "output coord_1 is not defined");
             ASSERTL0(coord_2.size() != 0, "output coord_2 is not defined");
  
             for (i = 0; i < (*m_exp).size(); ++i)
             {
                 e_coord_0 = coord_0 + m_phys_offset[i];
                 e_coord_1 = coord_1 + m_phys_offset[i];
                 e_coord_2 = coord_2 + m_phys_offset[i];
                 (*m_exp)[i]->GetCoords(e_coord_0, e_coord_1, e_coord_2);
             }
             break;
     }
 }

References ASSERTL0, GetCoordim(), GetExp(), GetNumElmts(), and m_phys_offset.

Referenced by GetCoords().

◆ v_GetCoords() [2/2]

void Nektar::MultiRegions::ExpList::v_GetCoords	(	const int	eid,
		Array< OneD, NekDouble > &	xc0,
		Array< OneD, NekDouble > &	xc1,
		Array< OneD, NekDouble > &	xc2
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::ExpList3DHomogeneous2D, Nektar::MultiRegions::ExpList3DHomogeneous1D, Nektar::MultiRegions::ExpList2DHomogeneous2D, and Nektar::MultiRegions::ExpList2DHomogeneous1D.

Definition at line 4800 of file ExpList.cpp.

 {
     (*m_exp)[eid]->GetCoords(xc0, xc1, xc2);
 }

◆ v_GetFieldDefinitions() [1/2]

void Nektar::MultiRegions::ExpList::v_GetFieldDefinitions ( std::vector< LibUtilities::FieldDefinitionsSharedPtr > & fielddef )

protectedvirtual

Reimplemented in Nektar::MultiRegions::ExpListHomogeneous2D, and Nektar::MultiRegions::ExpListHomogeneous1D.

Definition at line 3523 of file ExpList.cpp.

 {
     GeneralGetFieldDefinitions(fielddef);
 }

References GeneralGetFieldDefinitions().

◆ v_GetFieldDefinitions() [2/2]

std::vector< LibUtilities::FieldDefinitionsSharedPtr > Nektar::MultiRegions::ExpList::v_GetFieldDefinitions ( void )

protectedvirtual

Reimplemented in Nektar::MultiRegions::ExpListHomogeneous2D, and Nektar::MultiRegions::ExpListHomogeneous1D.

Definition at line 3515 of file ExpList.cpp.

 {
     std::vector<LibUtilities::FieldDefinitionsSharedPtr> returnval;
     v_GetFieldDefinitions(returnval);
     return returnval;
 }

Referenced by GetFieldDefinitions().

◆ v_GetFwdBwdTracePhys() [1/2]

void Nektar::MultiRegions::ExpList::v_GetFwdBwdTracePhys	(	Array< OneD, NekDouble > &	Fwd,
		Array< OneD, NekDouble > &	Bwd
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::DisContField.

Definition at line 4406 of file ExpList.cpp.

 {
     boost::ignore_unused(Fwd, Bwd);
     NEKERROR(ErrorUtil::efatal,
              "This method is not defined or valid for this class type");
 }

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

Referenced by GetFwdBwdTracePhys().

◆ v_GetFwdBwdTracePhys() [2/2]

void Nektar::MultiRegions::ExpList::v_GetFwdBwdTracePhys	(	const Array< OneD, const NekDouble > &	field,
		Array< OneD, NekDouble > &	Fwd,
		Array< OneD, NekDouble > &	Bwd,
		bool	FillBnd = `true`,
		bool	PutFwdInBwdOnBCs = `false`,
		bool	DoExchange = `true`
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::DisContField.

Definition at line 4414 of file ExpList.cpp.

 {
     boost::ignore_unused(field, Fwd, Bwd, FillBnd, PutFwdInBwdOnBCs,
                          DoExchange);
     NEKERROR(ErrorUtil::efatal,
              "This method is not defined or valid for this class type");
 }

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

◆ v_GetGlobalLinSysManager()

LibUtilities::NekManager< GlobalLinSysKey, GlobalLinSys > & Nektar::MultiRegions::ExpList::v_GetGlobalLinSysManager ( void )

protectedvirtual

Definition at line 3324 of file ExpList.cpp.

 {
     NEKERROR(ErrorUtil::efatal,
              "GetGlobalLinSysManager not implemented for ExpList.");
     return NullGlobalLinSysManager;
 }

References Nektar::ErrorUtil::efatal, NEKERROR, and Nektar::MultiRegions::NullGlobalLinSysManager.

Referenced by GetGlobalLinSysManager().

◆ v_GetHomogeneousBasis()

virtual LibUtilities::BasisSharedPtr Nektar::MultiRegions::ExpList::v_GetHomogeneousBasis ( void )

inlineprotectedvirtual

Reimplemented in Nektar::MultiRegions::ExpListHomogeneous1D.

Definition at line 1444 of file ExpList.h.

     {
         NEKERROR(ErrorUtil::efatal,
                  "This method is not defined or valid for this class type");
         return LibUtilities::NullBasisSharedPtr;
     }

References Nektar::ErrorUtil::efatal, NEKERROR, and Nektar::LibUtilities::NullBasisSharedPtr.

Referenced by GetHomogeneousBasis().

◆ v_GetHomoLen()

NekDouble Nektar::MultiRegions::ExpList::v_GetHomoLen ( void )

protectedvirtual

Reimplemented in Nektar::MultiRegions::ExpListHomogeneous1D.

Definition at line 3272 of file ExpList.cpp.

 {
     NEKERROR(ErrorUtil::efatal,
              "This method is not defined or valid for this class type");
     NekDouble len = 0.0;
     return len;
 }

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

Referenced by GetHomoLen().

◆ v_GetLeftAdjacentFaces()

const vector< bool > & Nektar::MultiRegions::ExpList::v_GetLeftAdjacentFaces ( void ) const

protectedvirtual

Definition at line 4477 of file ExpList.cpp.

 {
     NEKERROR(ErrorUtil::efatal,
              "This method is not defined or valid for this class type");
     static vector<bool> tmp;
     return tmp;
 }

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

Referenced by GetLeftAdjacentFaces().

◆ v_GetLeftAdjacentTraces()

std::vector< bool > & Nektar::MultiRegions::ExpList::v_GetLeftAdjacentTraces ( void )

protectedvirtual

Reimplemented in Nektar::MultiRegions::DisContField.

Definition at line 3937 of file ExpList.cpp.

 {
     NEKERROR(ErrorUtil::efatal,
              "This method is not defined or valid for this class type");
     static std::vector<bool> result;
     return result;
 }

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

Referenced by GetLeftAdjacentTraces().

◆ v_GetLocTraceFromTracePts()

void Nektar::MultiRegions::ExpList::v_GetLocTraceFromTracePts	(	const Array< OneD, const NekDouble > &	Fwd,
		const Array< OneD, const NekDouble > &	Bwd,
		Array< OneD, NekDouble > &	locTraceFwd,
		Array< OneD, NekDouble > &	locTraceBwd
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::DisContField.

Definition at line 4452 of file ExpList.cpp.

 {
     boost::ignore_unused(Fwd, Bwd, locTraceFwd, locTraceBwd);
     NEKERROR(ErrorUtil::efatal,
              "v_GetLocTraceFromTracePts is not defined for this class");
 }

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

Referenced by GetLocTraceFromTracePts().

◆ v_GetLocTraceToTraceMap()

const LocTraceToTraceMapSharedPtr & Nektar::MultiRegions::ExpList::v_GetLocTraceToTraceMap ( void ) const

protectedvirtual

Reimplemented in Nektar::MultiRegions::DisContField.

Definition at line 6045 of file ExpList.cpp.

 {
     NEKERROR(ErrorUtil::efatal, "v_GetLocTraceToTraceMap not coded");
     return NullLocTraceToTraceMapSharedPtr;
 }

References Nektar::ErrorUtil::efatal, NEKERROR, and Nektar::MultiRegions::NullLocTraceToTraceMapSharedPtr.

Referenced by GetLocTraceToTraceMap().

◆ v_GetMovingFrames()

void Nektar::MultiRegions::ExpList::v_GetMovingFrames	(	const SpatialDomains::GeomMMF	MMFdir,
		const Array< OneD, const NekDouble > &	CircCentre,
		Array< OneD, Array< OneD, NekDouble >> &	outarray
	)

protectedvirtual

Definition at line 3717 of file ExpList.cpp.

 {
     int npts;
  
     int MFdim = 3;
     int nq    = outarray[0].size() / MFdim;
  
     // Assume whole array is of same coordinate dimension
     int coordim = (*m_exp)[0]->GetGeom()->GetCoordim();
  
     Array<OneD, Array<OneD, NekDouble>> MFloc(MFdim * coordim);
     // Process each expansion.
     for (int i = 0; i < m_exp->size(); ++i)
     {
         npts = (*m_exp)[i]->GetTotPoints();
  
         for (int j = 0; j < MFdim * coordim; ++j)
         {
             MFloc[j] = Array<OneD, NekDouble>(npts, 0.0);
         }
  
         // MF from LOCALREGIONS
         (*m_exp)[i]->GetMetricInfo()->GetMovingFrames(
             (*m_exp)[i]->GetPointsKeys(), MMFdir, CircCentre, MFloc);
  
         // Get the physical data offset for this expansion.
         for (int j = 0; j < MFdim; ++j)
         {
             for (int k = 0; k < coordim; ++k)
             {
                 Vmath::Vcopy(npts, &MFloc[j * coordim + k][0], 1,
                              &outarray[j][k * nq + m_phys_offset[i]], 1);
             }
         }
     }
 }

References m_exp, m_phys_offset, and Vmath::Vcopy().

Referenced by GetMovingFrames().

◆ v_GetNormals()

void Nektar::MultiRegions::ExpList::v_GetNormals ( Array< OneD, Array< OneD, NekDouble >> & normals )

protectedvirtual

Populate normals with the normals of all expansions.

For each local element, copy the normals stored in the element list into the array normals.

Parameters

normals Multidimensional array in which to copy normals to. Must have dimension equal to or larger than the spatial dimension of the elements.

Reimplemented in Nektar::MultiRegions::ExpList2DHomogeneous1D.

Definition at line 4015 of file ExpList.cpp.

 {
     int i, j, k, e_npoints, offset;
     Array<OneD, Array<OneD, NekDouble>> locnormals;
  
     // Assume whole array is of same coordinate dimension
     int coordim = GetCoordim(0);
  
     ASSERTL1(normals.size() >= coordim,
              "Output vector does not have sufficient dimensions to "
              "match coordim");
  
     switch (m_expType)
     {
         case e0D:
         {
             // Process each expansion.
             for (i = 0; i < m_exp->size(); ++i)
             {
                 LocalRegions::ExpansionSharedPtr loc_exp = (*m_exp)[i];
  
                 LocalRegions::ExpansionSharedPtr loc_elmt =
                     loc_exp->GetLeftAdjacentElementExp();
  
                 // Get the number of points and normals for this expansion.
                 e_npoints  = 1;
                 locnormals = loc_elmt->GetTraceNormal(
                     loc_exp->GetLeftAdjacentElementTrace());
  
                 // Get the physical data offset for this expansion.
                 offset = m_phys_offset[i];
  
                 // Process each point in the expansion.
                 for (j = 0; j < e_npoints; ++j)
                 {
                     // Process each spatial dimension and copy the
                     // values into the output array.
                     for (k = 0; k < coordim; ++k)
                     {
                         normals[k][offset] = locnormals[k][0];
                     }
                 }
             }
         }
         break;
         case e1D:
         {
             SpatialDomains::Geometry1DSharedPtr segGeom;
             Array<OneD, Array<OneD, NekDouble>> locnormals2;
             Array<OneD, Array<OneD, NekDouble>> Norms;
  
             for (i = 0; i < m_exp->size(); ++i)
             {
                 LocalRegions::ExpansionSharedPtr loc_exp = (*m_exp)[i];
  
                 LocalRegions::ExpansionSharedPtr loc_elmt =
                     loc_exp->GetLeftAdjacentElementExp();
  
                 int edgeNumber = loc_exp->GetLeftAdjacentElementTrace();
  
                 // Get the number of points and normals for this expansion.
                 e_npoints = (*m_exp)[i]->GetNumPoints(0);
  
                 locnormals     = loc_elmt->GetTraceNormal(edgeNumber);
                 int e_nmodes   = loc_exp->GetBasis(0)->GetNumModes();
                 int loc_nmodes = loc_elmt->GetBasis(0)->GetNumModes();
  
                 if (e_nmodes != loc_nmodes)
                 {
                     if (loc_exp->GetRightAdjacentElementTrace() >= 0)
                     {
                         LocalRegions::ExpansionSharedPtr loc_elmt =
                             loc_exp->GetRightAdjacentElementExp();
  
                         int EdgeNumber =
                             loc_exp->GetRightAdjacentElementTrace();
  
                         // Serial case: right element is connected so we can
                         // just grab that normal.
                         locnormals = loc_elmt->GetTraceNormal(EdgeNumber);
  
                         offset = m_phys_offset[i];
  
                         // Process each point in the expansion.
                         for (j = 0; j < e_npoints; ++j)
                         {
                             // Process each spatial dimension and
                             // copy the values into the output
                             // array.
                             for (k = 0; k < coordim; ++k)
                             {
                                 normals[k][offset + j] = -locnormals[k][j];
                             }
                         }
                     }
                     else
                     {
                         // Parallel case: need to interpolate normal.
                         Array<OneD, Array<OneD, NekDouble>> normal(coordim);
  
                         for (int p = 0; p < coordim; ++p)
                         {
                             normal[p] = Array<OneD, NekDouble>(e_npoints, 0.0);
                             LibUtilities::PointsKey to_key =
                                 loc_exp->GetBasis(0)->GetPointsKey();
                             LibUtilities::PointsKey from_key =
                                 loc_elmt->GetBasis(0)->GetPointsKey();
                             LibUtilities::Interp1D(from_key, locnormals[p],
                                                    to_key, normal[p]);
                         }
  
                         offset = m_phys_offset[i];
  
                         // Process each point in the expansion.
                         for (j = 0; j < e_npoints; ++j)
                         {
                             // Process each spatial dimension and copy the
                             // values into the output array.
                             for (k = 0; k < coordim; ++k)
                             {
                                 normals[k][offset + j] = normal[k][j];
                             }
                         }
                     }
                 }
                 else
                 {
                     // Get the physical data offset for this expansion.
                     offset = m_phys_offset[i];
  
                     // Process each point in the expansion.
                     for (j = 0; j < e_npoints; ++j)
                     {
                         // Process each spatial dimension and copy the values
                         // into the output array.
                         for (k = 0; k < coordim; ++k)
                         {
                             normals[k][offset + j] = locnormals[k][j];
                         }
                     }
                 }
             }
         }
         break;
         case e2D:
         {
             Array<OneD, NekDouble> tmp;
  
             // Process each expansion.
             for (i = 0; i < m_exp->size(); ++i)
             {
                 LocalRegions::ExpansionSharedPtr traceExp = (*m_exp)[i];
                 LocalRegions::ExpansionSharedPtr exp3D =
                     traceExp->GetLeftAdjacentElementExp();
  
                 // Get the number of points and normals for this expansion.
                 int faceNum = traceExp->GetLeftAdjacentElementTrace();
                 int offset  = m_phys_offset[i];
  
                 const Array<OneD, const Array<OneD, NekDouble>> &locNormals =
                     exp3D->GetTraceNormal(faceNum);
  
                 // Project normals from 3D element onto the same
                 // orientation as the trace expansion.
                 StdRegions::Orientation orient = exp3D->GetTraceOrient(faceNum);
  
                 int fromid0, fromid1;
  
                 if (orient < StdRegions::eDir1FwdDir2_Dir2FwdDir1)
                 {
                     fromid0 = 0;
                     fromid1 = 1;
                 }
                 else
                 {
                     fromid0 = 1;
                     fromid1 = 0;
                 }
  
                 LibUtilities::BasisKey faceBasis0 =
                     exp3D->GetTraceBasisKey(faceNum, fromid0);
                 LibUtilities::BasisKey faceBasis1 =
                     exp3D->GetTraceBasisKey(faceNum, fromid1);
                 LibUtilities::BasisKey traceBasis0 =
                     traceExp->GetBasis(0)->GetBasisKey();
                 LibUtilities::BasisKey traceBasis1 =
                     traceExp->GetBasis(1)->GetBasisKey();
  
                 const int faceNq0 = faceBasis0.GetNumPoints();
                 const int faceNq1 = faceBasis1.GetNumPoints();
  
                 Array<OneD, int> faceids;
                 exp3D->ReOrientTracePhysMap(orient, faceids, faceNq0, faceNq1);
  
                 Array<OneD, NekDouble> traceNormals(faceNq0 * faceNq1);
  
                 for (j = 0; j < coordim; ++j)
                 {
                     Vmath::Scatr(faceNq0 * faceNq1, locNormals[j], faceids,
                                  traceNormals);
  
                     LibUtilities::Interp2D(
                         faceBasis0.GetPointsKey(), faceBasis1.GetPointsKey(),
                         traceNormals, traceBasis0.GetPointsKey(),
                         traceBasis1.GetPointsKey(), tmp = normals[j] + offset);
                 }
             }
         }
         break;
         default:
         {
             NEKERROR(ErrorUtil::efatal,
                      "This method is not defined or valid for this class type");
         }
     }
 }

References ASSERTL1, Nektar::MultiRegions::e0D, Nektar::MultiRegions::e1D, Nektar::MultiRegions::e2D, Nektar::StdRegions::eDir1FwdDir2_Dir2FwdDir1, Nektar::ErrorUtil::efatal, GetCoordim(), Nektar::LibUtilities::BasisKey::GetNumPoints(), Nektar::LibUtilities::BasisKey::GetPointsKey(), Nektar::LibUtilities::Interp1D(), Nektar::LibUtilities::Interp2D(), m_exp, m_expType, m_phys_offset, NEKERROR, CellMLToNektar.cellml_metadata::p, and Vmath::Scatr().

Referenced by GetNormals().

◆ v_GetNumElmts()

virtual size_t Nektar::MultiRegions::ExpList::v_GetNumElmts ( void )

inlineprotectedvirtual

Reimplemented in Nektar::MultiRegions::ExpListHomogeneous2D, and Nektar::MultiRegions::ExpListHomogeneous1D.

Definition at line 1159 of file ExpList.h.

     {
         return (*m_exp).size();
     }

Referenced by GetNumElmts().

◆ v_GetPeriodicEntities()

void Nektar::MultiRegions::ExpList::v_GetPeriodicEntities	(	PeriodicMap &	periodicVerts,
		PeriodicMap &	periodicEdges,
		PeriodicMap &	periodicFaces
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::ExpList3DHomogeneous1D, and Nektar::MultiRegions::DisContField.

Definition at line 5061 of file ExpList.cpp.

 {
     boost::ignore_unused(periodicVerts, periodicEdges, periodicFaces);
     NEKERROR(ErrorUtil::efatal,
              "This method is not defined or valid for this class type");
 }

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

Referenced by GetPeriodicEntities().

◆ v_GetPlane()

ExpListSharedPtr & Nektar::MultiRegions::ExpList::v_GetPlane ( int n )

protectedvirtual

Reimplemented in Nektar::MultiRegions::ExpListHomogeneous1D.

Definition at line 5091 of file ExpList.cpp.

 {
     boost::ignore_unused(n);
     NEKERROR(ErrorUtil::efatal,
              "This method is not defined or valid for this class type");
     return NullExpListSharedPtr;
 }

References Nektar::ErrorUtil::efatal, NEKERROR, and Nektar::MultiRegions::NullExpListSharedPtr.

Referenced by GetPlane().

◆ v_GetPoolCount()

int Nektar::MultiRegions::ExpList::v_GetPoolCount ( std::string poolName )

protectedvirtual

Reimplemented in Nektar::MultiRegions::ContField.

Definition at line 3309 of file ExpList.cpp.

 {
     boost::ignore_unused(poolName);
     NEKERROR(ErrorUtil::efatal, "GetPoolCount not implemented for ExpList.");
     return -1;
 }

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

Referenced by GetPoolCount().

◆ v_GetRobinBCInfo()

map< int, RobinBCInfoSharedPtr > Nektar::MultiRegions::ExpList::v_GetRobinBCInfo ( void )

protectedvirtual

Reimplemented in Nektar::MultiRegions::DisContField3DHomogeneous2D, Nektar::MultiRegions::DisContField3DHomogeneous1D, and Nektar::MultiRegions::DisContField.

Definition at line 5051 of file ExpList.cpp.

 {
     NEKERROR(ErrorUtil::efatal,
              "This method is not defined or valid for this class type");
     static map<int, RobinBCInfoSharedPtr> result;
     return result;
 }

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

Referenced by GetRobinBCInfo().

◆ v_GetTrace()

std::shared_ptr< ExpList > & Nektar::MultiRegions::ExpList::v_GetTrace ( )

protectedvirtual

Reimplemented in Nektar::MultiRegions::DisContField3DHomogeneous1D, and Nektar::MultiRegions::DisContField.

Definition at line 3916 of file ExpList.cpp.

 {
     NEKERROR(ErrorUtil::efatal,
              "This method is not defined or valid for this class type");
     static std::shared_ptr<ExpList> returnVal;
     return returnVal;
 }

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

Referenced by GetTrace().

◆ v_GetTraceBndMap()

const Array< OneD, const int > & Nektar::MultiRegions::ExpList::v_GetTraceBndMap ( )

protectedvirtual

Reimplemented in Nektar::MultiRegions::DisContField3DHomogeneous1D.

Definition at line 3932 of file ExpList.cpp.

 {
     return GetTraceMap()->GetBndCondIDToGlobalTraceID();
 }

References GetTraceMap().

Referenced by GetTraceBndMap().

◆ v_GetTraceMap()

std::shared_ptr< AssemblyMapDG > & Nektar::MultiRegions::ExpList::v_GetTraceMap ( void )

protectedvirtual

Reimplemented in Nektar::MultiRegions::DisContField, and Nektar::MultiRegions::DisContField3DHomogeneous1D.

Definition at line 3924 of file ExpList.cpp.

 {
     NEKERROR(ErrorUtil::efatal,
              "This method is not defined or valid for this class type");
     static std::shared_ptr<AssemblyMapDG> result;
     return result;
 }

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

Referenced by GetTraceMap().

◆ v_GetTransposition()

LibUtilities::TranspositionSharedPtr Nektar::MultiRegions::ExpList::v_GetTransposition ( void )

protectedvirtual

Reimplemented in Nektar::MultiRegions::ExpListHomogeneous1D.

Definition at line 3264 of file ExpList.cpp.

 {
     NEKERROR(ErrorUtil::efatal,
              "This method is not defined or valid for this class type");
     LibUtilities::TranspositionSharedPtr trans;
     return trans;
 }

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

Referenced by GetTransposition().

◆ v_GetYIDs()

Array< OneD, const unsigned int > Nektar::MultiRegions::ExpList::v_GetYIDs ( void )

protectedvirtual

Definition at line 3295 of file ExpList.cpp.

 {
     NEKERROR(ErrorUtil::efatal,
              "This method is not defined or valid for this class type");
     Array<OneD, unsigned int> NoModes(1);
     return NoModes;
 }

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

Referenced by GetYIDs().

◆ v_GetZIDs()

Array< OneD, const unsigned int > Nektar::MultiRegions::ExpList::v_GetZIDs ( void )

protectedvirtual

Reimplemented in Nektar::MultiRegions::ExpListHomogeneous1D.

Definition at line 3287 of file ExpList.cpp.

 {
     NEKERROR(ErrorUtil::efatal,
              "This method is not defined or valid for this class type");
     Array<OneD, unsigned int> NoModes(1);
     return NoModes;
 }

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

Referenced by GetZIDs().

◆ v_GlobalToLocal() [1/2]

void Nektar::MultiRegions::ExpList::v_GlobalToLocal	(	const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::ContField.

Definition at line 4693 of file ExpList.cpp.

 {
     boost::ignore_unused(inarray, outarray);
     NEKERROR(ErrorUtil::efatal,
              "This method is not defined or valid for this class type");
 }

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

◆ v_GlobalToLocal() [2/2]

void Nektar::MultiRegions::ExpList::v_GlobalToLocal ( void )

protectedvirtual

Reimplemented in Nektar::MultiRegions::ContField3DHomogeneous2D, Nektar::MultiRegions::ContField3DHomogeneous1D, and Nektar::MultiRegions::ContField.

Definition at line 4687 of file ExpList.cpp.

 {
     NEKERROR(ErrorUtil::efatal,
              "This method is not defined or valid for this class type");
 }

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

Referenced by GlobalToLocal().

◆ v_HelmSolve()

GlobalLinSysKey Nektar::MultiRegions::ExpList::v_HelmSolve	(	const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray,
		const StdRegions::ConstFactorMap &	factors,
		const StdRegions::VarCoeffMap &	varcoeff,
		const MultiRegions::VarFactorsMap &	varfactors,
		const Array< OneD, const NekDouble > &	dirForcing,
		const bool	PhysSpaceForcing
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::DisContField3DHomogeneous2D, Nektar::MultiRegions::DisContField3DHomogeneous1D, Nektar::MultiRegions::DisContField, Nektar::MultiRegions::ContField3DHomogeneous2D, Nektar::MultiRegions::ContField3DHomogeneous1D, and Nektar::MultiRegions::ContField.

Definition at line 4509 of file ExpList.cpp.

 {
     boost::ignore_unused(inarray, outarray, factors, varcoeff, varfactors,
                          dirForcing, PhysSpaceForcing);
     NEKERROR(ErrorUtil::efatal, "HelmSolve not implemented.");
     return NullGlobalLinSysKey;
 }

References Nektar::ErrorUtil::efatal, NEKERROR, and Nektar::MultiRegions::NullGlobalLinSysKey().

Referenced by HelmSolve().

◆ v_HomogeneousBwdTrans()

void Nektar::MultiRegions::ExpList::v_HomogeneousBwdTrans	(	const int	npts,
		const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray,
		bool	Shuff = `true`,
		bool	UnShuff = `true`
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::ExpListHomogeneous2D, and Nektar::MultiRegions::ExpListHomogeneous1D.

Definition at line 4555 of file ExpList.cpp.

 {
     boost::ignore_unused(npts, inarray, outarray, Shuff, UnShuff);
     NEKERROR(ErrorUtil::efatal,
              "This method is not defined or valid for this class type");
 }

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

Referenced by HomogeneousBwdTrans().

◆ v_HomogeneousEnergy()

Array< OneD, const NekDouble > Nektar::MultiRegions::ExpList::v_HomogeneousEnergy ( void )

protectedvirtual

Reimplemented in Nektar::MultiRegions::ExpList3DHomogeneous1D.

Definition at line 3256 of file ExpList.cpp.

 {
     NEKERROR(ErrorUtil::efatal,
              "This method is not defined or valid for this class type");
     Array<OneD, NekDouble> NoEnergy(1, 0.0);
     return NoEnergy;
 }

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

Referenced by HomogeneousEnergy().

◆ v_HomogeneousFwdTrans()

void Nektar::MultiRegions::ExpList::v_HomogeneousFwdTrans	(	const int	npts,
		const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray,
		bool	Shuff = `true`,
		bool	UnShuff = `true`
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::ExpListHomogeneous2D, and Nektar::MultiRegions::ExpListHomogeneous1D.

Definition at line 4545 of file ExpList.cpp.

 {
     boost::ignore_unused(npts, inarray, outarray, Shuff, UnShuff);
     NEKERROR(ErrorUtil::efatal,
              "This method is not defined or valid for this class type");
 }

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

Referenced by HomogeneousFwdTrans().

◆ v_ImposeDirichletConditions()

void Nektar::MultiRegions::ExpList::v_ImposeDirichletConditions ( Array< OneD, NekDouble > & outarray )

protectedvirtual

Reimplemented in Nektar::MultiRegions::ContField3DHomogeneous2D, Nektar::MultiRegions::ContField3DHomogeneous1D, and Nektar::MultiRegions::ContField.

Definition at line 4646 of file ExpList.cpp.

 {
     boost::ignore_unused(outarray);
     NEKERROR(ErrorUtil::efatal,
              "This method is not defined or valid for this class type");
 }

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

Referenced by ImposeDirichletConditions().

◆ v_Integral()

NekDouble Nektar::MultiRegions::ExpList::v_Integral ( const Array< OneD, const NekDouble > & inarray )

protectedvirtual

The integration is evaluated locally, that is

\[\int f(\boldsymbol{x})d\boldsymbol{x}=\sum_{e=1}^{{N_{\mathrm{el}}}} \left\{\int_{\Omega_e}f(\boldsymbol{x})d\boldsymbol{x}\right\}, \]

where the integration over the separate elements is done by the function StdRegions::StdExpansion::Integral, which discretely evaluates the integral using Gaussian quadrature.

Parameters

inarray An array of size $Q_{\mathrm{tot}}$ containing the values of the function $f(\boldsymbol{x})$ at the quadrature points $\boldsymbol{x}_i$.

Returns: The value of the discretely evaluated integral $\int f(\boldsymbol{x})d\boldsymbol{x}$.

Reimplemented in Nektar::MultiRegions::ExpListHomogeneous1D.

Definition at line 3222 of file ExpList.cpp.

 {
     NekDouble sum = 0.0;
     int i         = 0;
  
     for (i = 0; i < (*m_exp).size(); ++i)
     {
         sum += (*m_exp)[i]->Integral(inarray + m_phys_offset[i]);
     }
     m_comm->GetRowComm()->AllReduce(sum, LibUtilities::ReduceSum);
  
     return sum;
 }

References m_comm, m_phys_offset, and Nektar::LibUtilities::ReduceSum.

Referenced by Integral().

◆ v_IProductWRTBase()

void Nektar::MultiRegions::ExpList::v_IProductWRTBase	(	const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray
	)

protectedvirtual

The operation is evaluated locally for every element by the function StdRegions::StdExpansion::IProductWRTBase.

Parameters

inarray	An array of size $Q_{\mathrm{tot}}$ containing the values of the function $f(\boldsymbol{x})$ at the quadrature points $\boldsymbol{x}_i$.
outarray	An array of size $N_{\mathrm{eof}}$ used to store the result.

Reimplemented in Nektar::MultiRegions::ExpListHomogeneous2D, and Nektar::MultiRegions::ExpListHomogeneous1D.

Definition at line 4718 of file ExpList.cpp.

 {
     // initialise if required
     if (m_collectionsDoInit[Collections::eIProductWRTBase])
     {
         for (int i = 0; i < m_collections.size(); ++i)
         {
             m_collections[i].Initialise(Collections::eIProductWRTBase);
         }
         m_collectionsDoInit[Collections::eIProductWRTBase] = false;
     }
  
     Array<OneD, NekDouble> tmp;
     for (int i = 0; i < m_collections.size(); ++i)
     {
  
         m_collections[i].ApplyOperator(Collections::eIProductWRTBase,
                                        inarray + m_coll_phys_offset[i],
                                        tmp = outarray + m_coll_coeff_offset[i]);
     }
 }

References Nektar::Collections::eIProductWRTBase, m_coll_coeff_offset, m_coll_phys_offset, m_collections, and m_collectionsDoInit.

Referenced by IProductWRTBase().

◆ v_L2()

NekDouble Nektar::MultiRegions::ExpList::v_L2	(	const Array< OneD, const NekDouble > &	inarray,
		const Array< OneD, const NekDouble > &	soln = `NullNekDouble1DArray`
	)

protectedvirtual

Given a spectral/hp approximation $u^{\delta}(\boldsymbol{x})$ evaluated at the quadrature points (which should be contained in m_phys), this function calculates the $L_2$ error of this approximation with respect to an exact solution. The local distribution of the quadrature points allows an elemental evaluation of this operation through the functions StdRegions::StdExpansion::L2.

The exact solution, also evaluated at the quadrature points, should be contained in the variable m_phys of the ExpList object Sol.

Parameters

Sol	An ExpList, containing the discrete evaluation of the exact solution at the quadrature points in its array m_phys.

Returns: The $L_2$ error of the approximation.

Reimplemented in Nektar::MultiRegions::ExpList3DHomogeneous2D, and Nektar::MultiRegions::ExpList3DHomogeneous1D.

Definition at line 3177 of file ExpList.cpp.

 {
     NekDouble err = 0.0, errl2;
     int i;
  
     if (soln == NullNekDouble1DArray)
     {
         for (i = 0; i < (*m_exp).size(); ++i)
         {
             errl2 = (*m_exp)[i]->L2(inarray + m_phys_offset[i]);
             err += errl2 * errl2;
         }
     }
     else
     {
         for (i = 0; i < (*m_exp).size(); ++i)
         {
             errl2 = (*m_exp)[i]->L2(inarray + m_phys_offset[i],
                                     soln + m_phys_offset[i]);
             err += errl2 * errl2;
         }
     }
  
     m_comm->GetRowComm()->AllReduce(err, LibUtilities::ReduceSum);
  
     return sqrt(err);
 }

References m_comm, m_phys_offset, Nektar::NullNekDouble1DArray, Nektar::LibUtilities::ReduceSum, and tinysimd::sqrt().

Referenced by L2().

◆ v_LinearAdvectionDiffusionReactionSolve()

GlobalLinSysKey Nektar::MultiRegions::ExpList::v_LinearAdvectionDiffusionReactionSolve	(	const Array< OneD, Array< OneD, NekDouble >> &	velocity,
		const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray,
		const NekDouble	lambda,
		const Array< OneD, const NekDouble > &	dirForcing = `NullNekDouble1DArray`
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::ContField.

Definition at line 4522 of file ExpList.cpp.

 {
     boost::ignore_unused(velocity, inarray, outarray, lambda, dirForcing);
     NEKERROR(ErrorUtil::efatal,
              "LinearAdvectionDiffusionReactionSolve not implemented.");
     return NullGlobalLinSysKey;
 }

References Nektar::ErrorUtil::efatal, NEKERROR, and Nektar::MultiRegions::NullGlobalLinSysKey().

Referenced by LinearAdvectionDiffusionReactionSolve().

◆ v_LinearAdvectionReactionSolve()

void Nektar::MultiRegions::ExpList::v_LinearAdvectionReactionSolve	(	const Array< OneD, Array< OneD, NekDouble >> &	velocity,
		const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray,
		const NekDouble	lambda,
		const Array< OneD, const NekDouble > &	dirForcing = `NullNekDouble1DArray`
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::ContField.

Definition at line 4534 of file ExpList.cpp.

 {
     boost::ignore_unused(velocity, inarray, outarray, lambda, dirForcing);
     NEKERROR(ErrorUtil::efatal,
              "This method is not defined or valid for this class type");
 }

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

Referenced by LinearAdvectionReactionSolve().

◆ v_LocalToGlobal() [1/2]

void Nektar::MultiRegions::ExpList::v_LocalToGlobal ( bool UseComm )

protectedvirtual

Reimplemented in Nektar::MultiRegions::ContField3DHomogeneous2D, Nektar::MultiRegions::ContField3DHomogeneous1D, and Nektar::MultiRegions::ContField.

Definition at line 4672 of file ExpList.cpp.

 {
     boost::ignore_unused(useComm);
     NEKERROR(ErrorUtil::efatal,
              "This method is not defined or valid for this class type");
 }

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

Referenced by LocalToGlobal().

◆ v_LocalToGlobal() [2/2]

void Nektar::MultiRegions::ExpList::v_LocalToGlobal	(	const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray,
		bool	UseComm
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::ContField.

Definition at line 4679 of file ExpList.cpp.

 {
     boost::ignore_unused(inarray, outarray, useComm);
     NEKERROR(ErrorUtil::efatal,
              "This method is not defined or valid for this class type");
 }

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

◆ v_MultiplyByInvMassMatrix()

void Nektar::MultiRegions::ExpList::v_MultiplyByInvMassMatrix	(	const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::ContField.

Definition at line 4500 of file ExpList.cpp.

 {
     boost::ignore_unused(inarray, outarray);
     NEKERROR(ErrorUtil::efatal,
              "This method is not defined or valid for this class type");
 }

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

Referenced by MultiplyByInvMassMatrix().

◆ v_NormVectorIProductWRTBase() [1/2]

void Nektar::MultiRegions::ExpList::v_NormVectorIProductWRTBase	(	Array< OneD, Array< OneD, NekDouble >> &	V,
		Array< OneD, NekDouble > &	outarray
	)

protectedvirtual

Definition at line 4603 of file ExpList.cpp.

 {
     Array<OneD, NekDouble> tmp;
     switch (GetCoordim(0))
     {
         case 1:
         {
             for (int i = 0; i < GetExpSize(); ++i)
             {
                 (*m_exp)[i]->NormVectorIProductWRTBase(
                     V[0] + GetPhys_Offset(i),
                     tmp = outarray + GetCoeff_Offset(i));
             }
         }
         break;
         case 2:
         {
             for (int i = 0; i < GetExpSize(); ++i)
             {
                 (*m_exp)[i]->NormVectorIProductWRTBase(
                     V[0] + GetPhys_Offset(i), V[1] + GetPhys_Offset(i),
                     tmp = outarray + GetCoeff_Offset(i));
             }
         }
         break;
         case 3:
         {
             for (int i = 0; i < GetExpSize(); ++i)
             {
                 (*m_exp)[i]->NormVectorIProductWRTBase(
                     V[0] + GetPhys_Offset(i), V[1] + GetPhys_Offset(i),
                     V[2] + GetPhys_Offset(i),
                     tmp = outarray + GetCoeff_Offset(i));
             }
         }
         break;
         default:
             NEKERROR(ErrorUtil::efatal, "Dimension not supported");
             break;
     }
 }

References Nektar::ErrorUtil::efatal, GetCoeff_Offset(), GetCoordim(), GetExpSize(), GetPhys_Offset(), and NEKERROR.

◆ v_NormVectorIProductWRTBase() [2/2]

void Nektar::MultiRegions::ExpList::v_NormVectorIProductWRTBase	(	Array< OneD, const NekDouble > &	V1,
		Array< OneD, const NekDouble > &	V2,
		Array< OneD, NekDouble > &	outarray,
		int	BndID
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::DisContField3DHomogeneous1D.

Definition at line 4593 of file ExpList.cpp.

 {
     boost::ignore_unused(V1, V2, outarray, BndID);
     NEKERROR(ErrorUtil::efatal,
              "This method is not defined or valid for this class type");
 }

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

Referenced by NormVectorIProductWRTBase().

◆ v_PeriodicBwdCopy()

void Nektar::MultiRegions::ExpList::v_PeriodicBwdCopy	(	const Array< OneD, const NekDouble > &	Fwd,
		Array< OneD, NekDouble > &	Bwd
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::DisContField.

Definition at line 5008 of file ExpList.cpp.

 {
     boost::ignore_unused(Fwd, Bwd);
     NEKERROR(ErrorUtil::efatal, "v_PeriodicBwdCopy not defined");
 }

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

Referenced by PeriodicBwdCopy().

◆ v_PhysDeriv() [1/3]

void Nektar::MultiRegions::ExpList::v_PhysDeriv	(	const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	out_d0,
		Array< OneD, NekDouble > &	out_d1,
		Array< OneD, NekDouble > &	out_d2
	)

protectedvirtual

Given a function $f(\boldsymbol{x})$ evaluated at the quadrature points, this function calculates the derivatives $\frac{d}{dx_1}$, $\frac{d}{dx_2}$ and $\frac{d}{dx_3}$ of the function $f(\boldsymbol{x})$ at the same quadrature points. The local distribution of the quadrature points allows an elemental evaluation of the derivative. This is done by a call to the function StdRegions::StdExpansion::PhysDeriv.

Parameters

inarray	An array of size $Q_{\mathrm{tot}}$ containing the values of the function $f(\boldsymbol{x})$ at the quadrature points $\boldsymbol{x}_i$.
out_d0	The discrete evaluation of the derivative $\frac{d}{dx_1}$ will be stored in this array of size $Q_{\mathrm{tot}}$.
out_d1	The discrete evaluation of the derivative $\frac{d}{dx_2}$ will be stored in this array of size $Q_{\mathrm{tot}}$. Note that if no memory is allocated for out_d1, the derivative $\frac{d}{dx_2}$ will not be calculated.
out_d2	The discrete evaluation of the derivative $\frac{d}{dx_3}$ will be stored in this array of size $Q_{\mathrm{tot}}$. Note that if no memory is allocated for out_d2, the derivative $\frac{d}{dx_3}$ will not be calculated.

Reimplemented in Nektar::MultiRegions::ExpListHomogeneous2D, and Nektar::MultiRegions::ExpListHomogeneous1D.

Definition at line 1555 of file ExpList.cpp.

 {
     Array<OneD, NekDouble> e_out_d0;
     Array<OneD, NekDouble> e_out_d1;
     Array<OneD, NekDouble> e_out_d2;
     int offset;
  
     // initialise if required
     if (m_collectionsDoInit[Collections::ePhysDeriv])
     {
         for (int i = 0; i < m_collections.size(); ++i)
         {
             m_collections[i].Initialise(Collections::ePhysDeriv);
         }
         m_collectionsDoInit[Collections::ePhysDeriv] = false;
     }
  
     LibUtilities::Timer timer;
     timer.Start();
     for (int i = 0; i < m_collections.size(); ++i)
     {
         offset   = m_coll_phys_offset[i];
         e_out_d0 = out_d0 + offset;
         e_out_d1 = out_d1 + offset;
         e_out_d2 = out_d2 + offset;
  
         m_collections[i].ApplyOperator(Collections::ePhysDeriv,
                                        inarray + offset, e_out_d0, e_out_d1,
                                        e_out_d2);
     }
     timer.Stop();
     // Elapsed time
     timer.AccumulateRegion("Collections:PhysDeriv", 10);
 }

References Nektar::LibUtilities::Timer::AccumulateRegion(), Nektar::Collections::ePhysDeriv, m_coll_phys_offset, m_collections, m_collectionsDoInit, Nektar::LibUtilities::Timer::Start(), and Nektar::LibUtilities::Timer::Stop().

Referenced by PhysDeriv(), and v_PhysDeriv().

◆ v_PhysDeriv() [2/3]

void Nektar::MultiRegions::ExpList::v_PhysDeriv	(	const int	dir,
		const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	out_d
	)

protectedvirtual

Definition at line 1593 of file ExpList.cpp.

 {
     Direction edir = DirCartesianMap[dir];
     v_PhysDeriv(edir, inarray, out_d);
 }

References Nektar::MultiRegions::DirCartesianMap, and v_PhysDeriv().

◆ v_PhysDeriv() [3/3]

void Nektar::MultiRegions::ExpList::v_PhysDeriv	(	Direction	edir,
		const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	out_d
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::ExpListHomogeneous2D, and Nektar::MultiRegions::ExpListHomogeneous1D.

Definition at line 1601 of file ExpList.cpp.

 {
     int i;
     if (edir == MultiRegions::eS)
     {
         Array<OneD, NekDouble> e_out_ds;
         for (i = 0; i < (*m_exp).size(); ++i)
         {
             e_out_ds = out_d + m_phys_offset[i];
             (*m_exp)[i]->PhysDeriv_s(inarray + m_phys_offset[i], e_out_ds);
         }
     }
     else if (edir == MultiRegions::eN)
     {
         Array<OneD, NekDouble> e_out_dn;
         for (i = 0; i < (*m_exp).size(); i++)
         {
             e_out_dn = out_d + m_phys_offset[i];
             (*m_exp)[i]->PhysDeriv_n(inarray + m_phys_offset[i], e_out_dn);
         }
     }
     else
     {
  
         // initialise if required
         if (m_collectionsDoInit[Collections::ePhysDeriv])
         {
             for (int i = 0; i < m_collections.size(); ++i)
             {
                 m_collections[i].Initialise(Collections::ePhysDeriv);
             }
             m_collectionsDoInit[Collections::ePhysDeriv] = false;
         }
  
         // convert enum into int
         int intdir = (int)edir;
         Array<OneD, NekDouble> e_out_d;
         int offset;
         for (int i = 0; i < m_collections.size(); ++i)
         {
             offset  = m_coll_phys_offset[i];
             e_out_d = out_d + offset;
  
             m_collections[i].ApplyOperator(Collections::ePhysDeriv, intdir,
                                            inarray + offset, e_out_d);
         }
     }
 }

References Nektar::MultiRegions::eN, Nektar::Collections::ePhysDeriv, Nektar::MultiRegions::eS, m_coll_phys_offset, m_collections, m_collectionsDoInit, and m_phys_offset.

◆ v_PhysDirectionalDeriv()

void Nektar::MultiRegions::ExpList::v_PhysDirectionalDeriv	(	const Array< OneD, const NekDouble > &	direction,
		const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray
	)

protectedvirtual

Definition at line 1720 of file ExpList.cpp.

 {
     int npts_e;
     int coordim = (*m_exp)[0]->GetGeom()->GetCoordim();
     int nq      = direction.size() / coordim;
  
     Array<OneD, NekDouble> e_outarray;
     Array<OneD, NekDouble> e_MFdiv;
     Array<OneD, NekDouble> locdir;
  
     for (int i = 0; i < (*m_exp).size(); ++i)
     {
         npts_e = (*m_exp)[i]->GetTotPoints();
         locdir = Array<OneD, NekDouble>(npts_e * coordim);
  
         for (int k = 0; k < coordim; ++k)
         {
             Vmath::Vcopy(npts_e, &direction[k * nq + m_phys_offset[i]], 1,
                          &locdir[k * npts_e], 1);
         }
  
         (*m_exp)[i]->PhysDirectionalDeriv(inarray + m_phys_offset[i], locdir,
                                           e_outarray =
                                               outarray + m_phys_offset[i]);
     }
 }

References m_phys_offset, and Vmath::Vcopy().

Referenced by PhysDirectionalDeriv().

◆ v_PhysGalerkinProjection1DScaled()

void Nektar::MultiRegions::ExpList::v_PhysGalerkinProjection1DScaled	(	const NekDouble	scale,
		const Array< OneD, NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::ExpListHomogeneous1D.

Definition at line 5970 of file ExpList.cpp.

 {
     int cnt, cnt1;
  
     cnt = cnt1 = 0;
  
     switch (m_expType)
     {
         case e2D:
         {
             for (int i = 0; i < GetExpSize(); ++i)
             {
                 // get new points key
                 int pt0  = (*m_exp)[i]->GetNumPoints(0);
                 int pt1  = (*m_exp)[i]->GetNumPoints(1);
                 int npt0 = (int)pt0 * scale;
                 int npt1 = (int)pt1 * scale;
  
                 LibUtilities::PointsKey newPointsKey0(
                     npt0, (*m_exp)[i]->GetPointsType(0));
                 LibUtilities::PointsKey newPointsKey1(
                     npt1, (*m_exp)[i]->GetPointsType(1));
  
                 // Project points;
                 LibUtilities::PhysGalerkinProject2D(
                     newPointsKey0, newPointsKey1, &inarray[cnt],
                     (*m_exp)[i]->GetBasis(0)->GetPointsKey(),
                     (*m_exp)[i]->GetBasis(1)->GetPointsKey(), &outarray[cnt1]);
  
                 cnt += npt0 * npt1;
                 cnt1 += pt0 * pt1;
             }
         }
         break;
         case e3D:
         {
             for (int i = 0; i < GetExpSize(); ++i)
             {
                 // get new points key
                 int pt0  = (*m_exp)[i]->GetNumPoints(0);
                 int pt1  = (*m_exp)[i]->GetNumPoints(1);
                 int pt2  = (*m_exp)[i]->GetNumPoints(2);
                 int npt0 = (int)pt0 * scale;
                 int npt1 = (int)pt1 * scale;
                 int npt2 = (int)pt2 * scale;
  
                 LibUtilities::PointsKey newPointsKey0(
                     npt0, (*m_exp)[i]->GetPointsType(0));
                 LibUtilities::PointsKey newPointsKey1(
                     npt1, (*m_exp)[i]->GetPointsType(1));
                 LibUtilities::PointsKey newPointsKey2(
                     npt2, (*m_exp)[i]->GetPointsType(2));
  
                 // Project points;
                 LibUtilities::PhysGalerkinProject3D(
                     newPointsKey0, newPointsKey1, newPointsKey2, &inarray[cnt],
                     (*m_exp)[i]->GetBasis(0)->GetPointsKey(),
                     (*m_exp)[i]->GetBasis(1)->GetPointsKey(),
                     (*m_exp)[i]->GetBasis(2)->GetPointsKey(), &outarray[cnt1]);
  
                 cnt += npt0 * npt1 * npt2;
                 cnt1 += pt0 * pt1 * pt2;
             }
         }
         break;
         default:
         {
             NEKERROR(ErrorUtil::efatal, "not setup for this expansion");
         }
         break;
     }
 }

References Nektar::MultiRegions::e2D, Nektar::MultiRegions::e3D, Nektar::ErrorUtil::efatal, GetExpSize(), m_exp, m_expType, NEKERROR, Nektar::LibUtilities::PhysGalerkinProject2D(), and Nektar::LibUtilities::PhysGalerkinProject3D().

Referenced by PhysGalerkinProjection1DScaled().

◆ v_PhysInterp1DScaled()

void Nektar::MultiRegions::ExpList::v_PhysInterp1DScaled	(	const NekDouble	scale,
		const Array< OneD, NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::ExpListHomogeneous1D.

Definition at line 5321 of file ExpList.cpp.

 {
     int cnt, cnt1;
  
     cnt = cnt1 = 0;
  
     switch (m_expType)
     {
         case e2D:
         {
             for (int i = 0; i < GetExpSize(); ++i)
             {
                 // get new points key
                 int pt0  = (*m_exp)[i]->GetNumPoints(0);
                 int pt1  = (*m_exp)[i]->GetNumPoints(1);
                 int npt0 = (int)pt0 * scale;
                 int npt1 = (int)pt1 * scale;
  
                 LibUtilities::PointsKey newPointsKey0(
                     npt0, (*m_exp)[i]->GetPointsType(0));
                 LibUtilities::PointsKey newPointsKey1(
                     npt1, (*m_exp)[i]->GetPointsType(1));
  
                 // Interpolate points;
                 LibUtilities::Interp2D((*m_exp)[i]->GetBasis(0)->GetPointsKey(),
                                        (*m_exp)[i]->GetBasis(1)->GetPointsKey(),
                                        &inarray[cnt], newPointsKey0,
                                        newPointsKey1, &outarray[cnt1]);
  
                 cnt += pt0 * pt1;
                 cnt1 += npt0 * npt1;
             }
         }
         break;
         case e3D:
         {
             for (int i = 0; i < GetExpSize(); ++i)
             {
                 // get new points key
                 int pt0  = (*m_exp)[i]->GetNumPoints(0);
                 int pt1  = (*m_exp)[i]->GetNumPoints(1);
                 int pt2  = (*m_exp)[i]->GetNumPoints(2);
                 int npt0 = (int)pt0 * scale;
                 int npt1 = (int)pt1 * scale;
                 int npt2 = (int)pt2 * scale;
  
                 LibUtilities::PointsKey newPointsKey0(
                     npt0, (*m_exp)[i]->GetPointsType(0));
                 LibUtilities::PointsKey newPointsKey1(
                     npt1, (*m_exp)[i]->GetPointsType(1));
                 LibUtilities::PointsKey newPointsKey2(
                     npt2, (*m_exp)[i]->GetPointsType(2));
  
                 // Interpolate points;
                 LibUtilities::Interp3D((*m_exp)[i]->GetBasis(0)->GetPointsKey(),
                                        (*m_exp)[i]->GetBasis(1)->GetPointsKey(),
                                        (*m_exp)[i]->GetBasis(2)->GetPointsKey(),
                                        &inarray[cnt], newPointsKey0,
                                        newPointsKey1, newPointsKey2,
                                        &outarray[cnt1]);
  
                 cnt += pt0 * pt1 * pt2;
                 cnt1 += npt0 * npt1 * npt2;
             }
         }
         break;
         default:
         {
             NEKERROR(ErrorUtil::efatal, "This expansion is not set");
         }
         break;
     }
 }

References Nektar::MultiRegions::e2D, Nektar::MultiRegions::e3D, Nektar::ErrorUtil::efatal, GetExpSize(), Nektar::LibUtilities::Interp2D(), Nektar::LibUtilities::Interp3D(), m_exp, m_expType, and NEKERROR.

Referenced by PhysInterp1DScaled().

◆ v_Reset()

void Nektar::MultiRegions::ExpList::v_Reset ( )

protectedvirtual

Reset geometry information, metrics, matrix managers and geometry information.

This routine clears all matrix managers and resets all geometry information, which allows the geometry information to be dynamically updated as the solver is run.

Reimplemented in Nektar::MultiRegions::DisContField.

Definition at line 2673 of file ExpList.cpp.

 {
     // Reset matrix managers.
     LibUtilities::NekManager<LocalRegions::MatrixKey, DNekScalMat,
                              LocalRegions::MatrixKey::opLess>::ClearManager();
     LibUtilities::NekManager<LocalRegions::MatrixKey, DNekScalBlkMat,
                              LocalRegions::MatrixKey::opLess>::ClearManager();
  
     // Loop over all elements and reset geometry information.
     for (int i = 0; i < m_exp->size(); ++i)
     {
         (*m_exp)[i]->GetGeom()->Reset(m_graph->GetCurvedEdges(),
                                       m_graph->GetCurvedFaces());
     }
  
     // Loop over all elements and rebuild geometric factors.
     for (int i = 0; i < m_exp->size(); ++i)
     {
         (*m_exp)[i]->Reset();
     }
 }

References m_exp, and m_graph.

Referenced by Reset(), and Nektar::MultiRegions::DisContField::v_Reset().

◆ v_SetBndCondBwdWeight()

void Nektar::MultiRegions::ExpList::v_SetBndCondBwdWeight	(	const int	index,
		const NekDouble	value
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::DisContField3DHomogeneous2D, Nektar::MultiRegions::DisContField3DHomogeneous1D, and Nektar::MultiRegions::DisContField.

Definition at line 4470 of file ExpList.cpp.

 {
     boost::ignore_unused(index, value);
     NEKERROR(ErrorUtil::efatal,
              "v_setBndCondBwdWeight is not defined for this class type");
 }

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

Referenced by SetBndCondBwdWeight().

◆ v_SetHomo1DSpecVanVisc()

virtual void Nektar::MultiRegions::ExpList::v_SetHomo1DSpecVanVisc ( Array< OneD, NekDouble > visc )

inlineprotectedvirtual

Reimplemented in Nektar::MultiRegions::ExpListHomogeneous1D.

Definition at line 1452 of file ExpList.h.

     {
         boost::ignore_unused(visc);
         NEKERROR(ErrorUtil::efatal,
                  "This method is not defined or valid for this class type");
     }

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

Referenced by SetHomo1DSpecVanVisc().

◆ v_SetHomoLen()

void Nektar::MultiRegions::ExpList::v_SetHomoLen ( const NekDouble lhom )

protectedvirtual

Reimplemented in Nektar::MultiRegions::ExpListHomogeneous1D.

Definition at line 3280 of file ExpList.cpp.

 {
     boost::ignore_unused(lhom);
     NEKERROR(ErrorUtil::efatal,
              "This method is not defined or valid for this class type");
 }

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

Referenced by SetHomoLen().

◆ v_SetUpPhysNormals()

void Nektar::MultiRegions::ExpList::v_SetUpPhysNormals ( )

protectedvirtual

: Set up a normal along the trace elements between two elements at elemental level

Definition at line 4812 of file ExpList.cpp.

 {
     for (int i = 0; i < m_exp->size(); ++i)
     {
         for (int j = 0; j < (*m_exp)[i]->GetNtraces(); ++j)
         {
             (*m_exp)[i]->ComputeTraceNormal(j);
         }
     }
 }

References m_exp.

Referenced by SetUpPhysNormals().

◆ v_SmoothField()

void Nektar::MultiRegions::ExpList::v_SmoothField ( Array< OneD, NekDouble > & field )

protectedvirtual

This function smooth a field after some calculaitons which have been done elementally.

Parameters

field An array containing the field in physical space

Reimplemented in Nektar::MultiRegions::ContField3DHomogeneous1D, and Nektar::MultiRegions::ContField.

Definition at line 1841 of file ExpList.cpp.

 {
     boost::ignore_unused(field);
     // Do nothing unless the method is implemented in the appropriate
     // class, i.e. ContField1D,ContField2D, etc.
  
     // So far it has been implemented just for ContField2D and
     // ContField3DHomogeneous1D
  
     // Block in case users try the smoothing with a modal expansion.
     // Maybe a different techique for the smoothing require
     // implementation for modal basis.
  
     ASSERTL0((*m_exp)[0]->GetBasisType(0) == LibUtilities::eGLL_Lagrange ||
                  (*m_exp)[0]->GetBasisType(0) == LibUtilities::eGauss_Lagrange,
              "Smoothing is currently not allowed unless you are using "
              "a nodal base for efficiency reasons. The implemented "
              "smoothing technique requires the mass matrix inversion "
              "which is trivial just for GLL_LAGRANGE_SEM and "
              "GAUSS_LAGRANGE_SEMexpansions.");
 }

References ASSERTL0, Nektar::LibUtilities::eGauss_Lagrange, Nektar::LibUtilities::eGLL_Lagrange, and m_exp.

Referenced by SmoothField().

◆ v_UnsetGlobalLinSys()

void Nektar::MultiRegions::ExpList::v_UnsetGlobalLinSys	(	GlobalLinSysKey	key,
		bool	clearLocalMatrices
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::ContField.

Definition at line 3316 of file ExpList.cpp.

 {
     boost::ignore_unused(key, clearLocalMatrices);
     NEKERROR(ErrorUtil::efatal,
              "UnsetGlobalLinSys not implemented for ExpList.");
 }

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

Referenced by UnsetGlobalLinSys().

◆ v_UpdateBndCondExpansion()

std::shared_ptr< ExpList > & Nektar::MultiRegions::ExpList::v_UpdateBndCondExpansion ( int i )

protectedvirtual

Reimplemented in Nektar::MultiRegions::DisContField3DHomogeneous2D, Nektar::MultiRegions::DisContField3DHomogeneous1D, and Nektar::MultiRegions::DisContField.

Definition at line 3799 of file ExpList.cpp.

 {
     boost::ignore_unused(i);
     NEKERROR(ErrorUtil::efatal,
              "This method is not defined or valid for this class type");
     static std::shared_ptr<ExpList> result;
     return result;
 }

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

Referenced by UpdateBndCondExpansion().

◆ v_UpdateBndConditions()

Array< OneD, SpatialDomains::BoundaryConditionShPtr > & Nektar::MultiRegions::ExpList::v_UpdateBndConditions ( )

protectedvirtual

Reimplemented in Nektar::MultiRegions::DisContField3DHomogeneous2D, Nektar::MultiRegions::DisContField3DHomogeneous1D, and Nektar::MultiRegions::DisContField.

Definition at line 5029 of file ExpList.cpp.

 {
     NEKERROR(ErrorUtil::efatal,
              "This method is not defined or valid for this class type");
     static Array<OneD, SpatialDomains::BoundaryConditionShPtr> result;
     return result;
 }

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

Referenced by UpdateBndConditions().

◆ v_Upwind() [1/2]

void Nektar::MultiRegions::ExpList::v_Upwind	(	const Array< OneD, const Array< OneD, NekDouble >> &	Vec,
		const Array< OneD, const NekDouble > &	Fwd,
		const Array< OneD, const NekDouble > &	Bwd,
		Array< OneD, NekDouble > &	Upwind
	)

protectedvirtual

Upwind the left and right states given by the Arrays Fwd and Bwd using the vector quantity Vec and ouput the upwinded value in the array upwind.

Parameters

Vec	Velocity field.
Fwd	Left state.
Bwd	Right state.
Upwind	Output vector.

Definition at line 3818 of file ExpList.cpp.

 {
     switch (m_expType)
     {
         case e1D:
         {
             int i, j, k, e_npoints, offset;
             Array<OneD, NekDouble> normals;
             NekDouble Vn;
  
             // Assume whole array is of same coordimate dimension
             int coordim = GetCoordim(0);
  
             ASSERTL1(Vec.size() >= coordim,
                      "Input vector does not have sufficient dimensions to "
                      "match coordim");
  
             // Process each expansion
             for (i = 0; i < m_exp->size(); ++i)
             {
                 // Get the number of points in the expansion and the normals.
                 e_npoints = (*m_exp)[i]->GetNumPoints(0);
                 normals   = (*m_exp)[i]->GetPhysNormals();
  
                 // Get the physical data offset of the expansion in m_phys.
                 offset = m_phys_offset[i];
  
                 // Compute each data point.
                 for (j = 0; j < e_npoints; ++j)
                 {
                     // Calculate normal velocity.
                     Vn = 0.0;
                     for (k = 0; k < coordim; ++k)
                     {
                         Vn += Vec[k][offset + j] * normals[k * e_npoints + j];
                     }
  
                     // Upwind based on direction of normal velocity.
                     if (Vn > 0.0)
                     {
                         Upwind[offset + j] = Fwd[offset + j];
                     }
                     else
                     {
                         Upwind[offset + j] = Bwd[offset + j];
                     }
                 }
             }
         }
         break;
         default:
             NEKERROR(ErrorUtil::efatal,
                      "This method is not defined or valid for this class type");
             break;
     }
 }

References ASSERTL1, Nektar::MultiRegions::e1D, Nektar::ErrorUtil::efatal, GetCoordim(), m_exp, m_expType, m_phys_offset, NEKERROR, and Upwind().

Referenced by Upwind().

◆ v_Upwind() [2/2]

void Nektar::MultiRegions::ExpList::v_Upwind	(	const Array< OneD, const NekDouble > &	Vn,
		const Array< OneD, const NekDouble > &	Fwd,
		const Array< OneD, const NekDouble > &	Bwd,
		Array< OneD, NekDouble > &	Upwind
	)

protectedvirtual

One-dimensional upwind.

See also: ExpList::Upwind( const Array<OneD, const Array<OneD, NekDouble> >, const Array<OneD, const NekDouble>, const Array<OneD, const NekDouble>, Array<OneD, NekDouble>, int)

Parameters

Vn	Velocity field.
Fwd	Left state.
Bwd	Right state.
Upwind	Output vector.

Definition at line 3891 of file ExpList.cpp.

 {
     ASSERTL1(Vn.size() >= m_npoints, "Vn is not of sufficient length");
     ASSERTL1(Fwd.size() >= m_npoints, "Fwd is not of sufficient length");
     ASSERTL1(Bwd.size() >= m_npoints, "Bwd is not of sufficient length");
     ASSERTL1(Upwind.size() >= m_npoints, "Upwind is not of sufficient length");
  
     // Process each point in the expansion.
     for (int j = 0; j < m_npoints; ++j)
     {
         // Upwind based on one-dimensional velocity.
         if (Vn[j] > 0.0)
         {
             Upwind[j] = Fwd[j];
         }
         else
         {
             Upwind[j] = Bwd[j];
         }
     }
 }

References ASSERTL1, m_npoints, and Upwind().

◆ v_VectorFlux()

NekDouble Nektar::MultiRegions::ExpList::v_VectorFlux ( const Array< OneD, Array< OneD, NekDouble >> & inarray )

protectedvirtual

Definition at line 3236 of file ExpList.cpp.

 {
     NekDouble flux = 0.0;
     int i          = 0;
     int j;
  
     for (i = 0; i < (*m_exp).size(); ++i)
     {
         Array<OneD, Array<OneD, NekDouble>> tmp(inarray.size());
         for (j = 0; j < inarray.size(); ++j)
         {
             tmp[j] = Array<OneD, NekDouble>(inarray[j] + m_phys_offset[i]);
         }
         flux += (*m_exp)[i]->VectorFlux(tmp);
     }
  
     return flux;
 }

References m_phys_offset.

Referenced by VectorFlux().

◆ v_WriteTecplotConnectivity()

void Nektar::MultiRegions::ExpList::v_WriteTecplotConnectivity	(	std::ostream &	outfile,
		int	expansion
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::ExpList3DHomogeneous1D.

Definition at line 2831 of file ExpList.cpp.

 {
     int i, j, k, l;
     int nbase = (*m_exp)[0]->GetNumBases();
     int cnt   = 0;
  
     std::shared_ptr<LocalRegions::ExpansionVector> exp = m_exp;
  
     if (expansion != -1)
     {
         exp = std::shared_ptr<LocalRegions::ExpansionVector>(
             new LocalRegions::ExpansionVector(1));
         (*exp)[0] = (*m_exp)[expansion];
     }
  
     if (nbase == 2)
     {
         for (i = 0; i < (*exp).size(); ++i)
         {
             const int np0 = (*exp)[i]->GetNumPoints(0);
             const int np1 = (*exp)[i]->GetNumPoints(1);
  
             for (j = 1; j < np1; ++j)
             {
                 for (k = 1; k < np0; ++k)
                 {
                     outfile << cnt + (j - 1) * np0 + k << " ";
                     outfile << cnt + (j - 1) * np0 + k + 1 << " ";
                     outfile << cnt + j * np0 + k + 1 << " ";
                     outfile << cnt + j * np0 + k << endl;
                 }
             }
  
             cnt += np0 * np1;
         }
     }
     else if (nbase == 3)
     {
         for (i = 0; i < (*exp).size(); ++i)
         {
             const int np0  = (*exp)[i]->GetNumPoints(0);
             const int np1  = (*exp)[i]->GetNumPoints(1);
             const int np2  = (*exp)[i]->GetNumPoints(2);
             const int np01 = np0 * np1;
  
             for (j = 1; j < np2; ++j)
             {
                 for (k = 1; k < np1; ++k)
                 {
                     for (l = 1; l < np0; ++l)
                     {
                         outfile << cnt + (j - 1) * np01 + (k - 1) * np0 + l
                                 << " ";
                         outfile << cnt + (j - 1) * np01 + (k - 1) * np0 + l + 1
                                 << " ";
                         outfile << cnt + (j - 1) * np01 + k * np0 + l + 1
                                 << " ";
                         outfile << cnt + (j - 1) * np01 + k * np0 + l << " ";
                         outfile << cnt + j * np01 + (k - 1) * np0 + l << " ";
                         outfile << cnt + j * np01 + (k - 1) * np0 + l + 1
                                 << " ";
                         outfile << cnt + j * np01 + k * np0 + l + 1 << " ";
                         outfile << cnt + j * np01 + k * np0 + l << endl;
                     }
                 }
             }
             cnt += np0 * np1 * np2;
         }
     }
     else
     {
         NEKERROR(ErrorUtil::efatal, "Not set up for this dimension");
     }
 }

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

Referenced by WriteTecplotConnectivity().

◆ v_WriteTecplotField()

void Nektar::MultiRegions::ExpList::v_WriteTecplotField	(	std::ostream &	outfile,
		int	expansion
	)

protectedvirtual

Write Tecplot Files Field

Parameters

outfile	Output file name.
expansion	Expansion that is considered

Definition at line 2911 of file ExpList.cpp.

 {
     if (expansion == -1)
     {
         int totpoints = GetTotPoints();
         if (m_physState == false)
         {
             BwdTrans(m_coeffs, m_phys);
         }
  
         for (int i = 0; i < totpoints; ++i)
         {
             outfile << m_phys[i] << " ";
             if (i % 1000 == 0 && i)
             {
                 outfile << std::endl;
             }
         }
         outfile << std::endl;
     }
     else
     {
         int nPoints = (*m_exp)[expansion]->GetTotPoints();
  
         for (int i = 0; i < nPoints; ++i)
         {
             outfile << m_phys[i + m_phys_offset[expansion]] << " ";
         }
  
         outfile << std::endl;
     }
 }

References BwdTrans(), GetTotPoints(), m_coeffs, m_phys, m_phys_offset, and m_physState.

Referenced by WriteTecplotField().

◆ v_WriteTecplotHeader()

void Nektar::MultiRegions::ExpList::v_WriteTecplotHeader	(	std::ostream &	outfile,
		std::string	var = `""`
	)

protectedvirtual

Write Tecplot Files Header

Parameters

outfile	Output file name.
var	variables names

Definition at line 2700 of file ExpList.cpp.

 {
     if (GetNumElmts() == 0)
     {
         return;
     }
  
     int coordim  = GetExp(0)->GetCoordim();
     char vars[3] = {'x', 'y', 'z'};
  
     if (m_expType == e3DH1D)
     {
         coordim += 1;
     }
     else if (m_expType == e3DH2D)
     {
         coordim += 2;
     }
  
     outfile << "Variables = x";
     for (int i = 1; i < coordim; ++i)
     {
         outfile << ", " << vars[i];
     }
  
     if (var.size() > 0)
     {
         outfile << ", " << var;
     }
  
     outfile << std::endl << std::endl;
 }

References Nektar::MultiRegions::e3DH1D, Nektar::MultiRegions::e3DH2D, GetExp(), GetNumElmts(), and m_expType.

Referenced by WriteTecplotHeader().

◆ v_WriteTecplotZone()

void Nektar::MultiRegions::ExpList::v_WriteTecplotZone	(	std::ostream &	outfile,
		int	expansion
	)

protectedvirtual

Write Tecplot Files Zone

Parameters

outfile	Output file name.
expansion	Expansion that is considered

Reimplemented in Nektar::MultiRegions::ExpList3DHomogeneous2D, Nektar::MultiRegions::ExpList2DHomogeneous2D, and Nektar::MultiRegions::ExpList2DHomogeneous1D.

Definition at line 2738 of file ExpList.cpp.

 {
     int i, j;
     int coordim   = GetCoordim(0);
     int nPoints   = GetTotPoints();
     int nBases    = (*m_exp)[0]->GetNumBases();
     int numBlocks = 0;
  
     Array<OneD, Array<OneD, NekDouble>> coords(3);
  
     if (expansion == -1)
     {
         nPoints = GetTotPoints();
  
         coords[0] = Array<OneD, NekDouble>(nPoints);
         coords[1] = Array<OneD, NekDouble>(nPoints);
         coords[2] = Array<OneD, NekDouble>(nPoints);
  
         GetCoords(coords[0], coords[1], coords[2]);
  
         for (i = 0; i < m_exp->size(); ++i)
         {
             int numInt = 1;
  
             for (j = 0; j < nBases; ++j)
             {
                 numInt *= (*m_exp)[i]->GetNumPoints(j) - 1;
             }
  
             numBlocks += numInt;
         }
     }
     else
     {
         nPoints = (*m_exp)[expansion]->GetTotPoints();
  
         coords[0] = Array<OneD, NekDouble>(nPoints);
         coords[1] = Array<OneD, NekDouble>(nPoints);
         coords[2] = Array<OneD, NekDouble>(nPoints);
  
         (*m_exp)[expansion]->GetCoords(coords[0], coords[1], coords[2]);
  
         numBlocks = 1;
         for (j = 0; j < nBases; ++j)
         {
             numBlocks *= (*m_exp)[expansion]->GetNumPoints(j) - 1;
         }
     }
  
     if (m_expType == e3DH1D)
     {
         nBases += 1;
         coordim += 1;
         int nPlanes   = GetZIDs().size();
         NekDouble tmp = numBlocks * (nPlanes - 1.0) / nPlanes;
         numBlocks     = (int)tmp;
     }
     else if (m_expType == e3DH2D)
     {
         nBases += 2;
         coordim += 1;
     }
  
     outfile << "Zone, N=" << nPoints << ", E=" << numBlocks << ", F=FEBlock";
  
     switch (nBases)
     {
         case 2:
             outfile << ", ET=QUADRILATERAL" << std::endl;
             break;
         case 3:
             outfile << ", ET=BRICK" << std::endl;
             break;
         default:
             NEKERROR(ErrorUtil::efatal, "Not set up for this type of output");
             break;
     }
  
     // Write out coordinates
     for (j = 0; j < coordim; ++j)
     {
         for (i = 0; i < nPoints; ++i)
         {
             outfile << coords[j][i] << " ";
             if (i % 1000 == 0 && i)
             {
                 outfile << std::endl;
             }
         }
         outfile << std::endl;
     }
 }

References Nektar::MultiRegions::e3DH1D, Nektar::MultiRegions::e3DH2D, Nektar::ErrorUtil::efatal, GetCoordim(), GetCoords(), GetTotPoints(), GetZIDs(), m_exp, m_expType, and NEKERROR.

Referenced by WriteTecplotZone().

◆ v_WriteVtkPieceData()

void Nektar::MultiRegions::ExpList::v_WriteVtkPieceData	(	std::ostream &	outfile,
		int	expansion,
		std::string	var
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::ExpListHomogeneous2D, and Nektar::MultiRegions::ExpListHomogeneous1D.

Definition at line 3099 of file ExpList.cpp.

 {
     int i;
     int nq = (*m_exp)[expansion]->GetTotPoints();
  
     // printing the fields of that zone
     outfile << "        <DataArray type=\"Float64\" Name=\"" << var << "\">"
             << endl;
     outfile << "          ";
  
     const Array<OneD, NekDouble> phys = m_phys + m_phys_offset[expansion];
  
     for (i = 0; i < nq; ++i)
     {
         outfile << (fabs(phys[i]) < NekConstants::kNekZeroTol ? 0 : phys[i])
                 << " ";
     }
     outfile << endl;
     outfile << "        </DataArray>" << endl;
 }

References Nektar::NekConstants::kNekZeroTol, m_phys, and m_phys_offset.

Referenced by WriteVtkPieceData().

◆ v_WriteVtkPieceHeader()

void Nektar::MultiRegions::ExpList::v_WriteVtkPieceHeader	(	std::ostream &	outfile,
		int	expansion,
		int	istrip
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::ExpList3DHomogeneous2D, Nektar::MultiRegions::ExpList3DHomogeneous1D, Nektar::MultiRegions::ExpList2DHomogeneous2D, and Nektar::MultiRegions::ExpList2DHomogeneous1D.

Definition at line 2958 of file ExpList.cpp.

 {
     boost::ignore_unused(istrip);
     int i, j, k;
     int nbase = (*m_exp)[expansion]->GetNumBases();
     int ntot  = (*m_exp)[expansion]->GetTotPoints();
     int nquad[3];
  
     int ntotminus = 1;
     for (i = 0; i < nbase; ++i)
     {
         nquad[i] = (*m_exp)[expansion]->GetNumPoints(i);
         ntotminus *= (nquad[i] - 1);
     }
  
     Array<OneD, NekDouble> coords[3];
     coords[0] = Array<OneD, NekDouble>(ntot, 0.0);
     coords[1] = Array<OneD, NekDouble>(ntot, 0.0);
     coords[2] = Array<OneD, NekDouble>(ntot, 0.0);
     (*m_exp)[expansion]->GetCoords(coords[0], coords[1], coords[2]);
  
     outfile << "    <Piece NumberOfPoints=\"" << ntot << "\" NumberOfCells=\""
             << ntotminus << "\">" << endl;
     outfile << "      <Points>" << endl;
     outfile << "        <DataArray type=\"Float64\" "
             << "NumberOfComponents=\"3\" format=\"ascii\">" << endl;
     outfile << "          ";
     for (i = 0; i < ntot; ++i)
     {
         for (j = 0; j < 3; ++j)
         {
             outfile << setprecision(8) << scientific << (float)coords[j][i]
                     << " ";
         }
         outfile << endl;
     }
     outfile << endl;
     outfile << "        </DataArray>" << endl;
     outfile << "      </Points>" << endl;
     outfile << "      <Cells>" << endl;
     outfile << "        <DataArray type=\"Int32\" "
             << "Name=\"connectivity\" format=\"ascii\">" << endl;
  
     int ns = 0; // pow(2,dim) for later usage
     string ostr;
     switch (m_expType)
     {
         case e1D:
         {
             ns   = 2;
             ostr = "3 ";
             for (i = 0; i < nquad[0] - 1; ++i)
             {
                 outfile << i << " " << i + 1 << endl;
             }
         }
         break;
         case e2D:
         {
             ns   = 4;
             ostr = "9 ";
             for (i = 0; i < nquad[0] - 1; ++i)
             {
                 for (j = 0; j < nquad[1] - 1; ++j)
                 {
                     outfile << j * nquad[0] + i << " " << j * nquad[0] + i + 1
                             << " " << (j + 1) * nquad[0] + i + 1 << " "
                             << (j + 1) * nquad[0] + i << endl;
                 }
             }
         }
         break;
         case e3D:
         {
             ns   = 8;
             ostr = "12 ";
             for (i = 0; i < nquad[0] - 1; ++i)
             {
                 for (j = 0; j < nquad[1] - 1; ++j)
                 {
                     for (k = 0; k < nquad[2] - 1; ++k)
                     {
                         outfile
                             << k * nquad[0] * nquad[1] + j * nquad[0] + i << " "
                             << k * nquad[0] * nquad[1] + j * nquad[0] + i + 1
                             << " "
                             << k * nquad[0] * nquad[1] + (j + 1) * nquad[0] +
                                    i + 1
                             << " "
                             << k * nquad[0] * nquad[1] + (j + 1) * nquad[0] + i
                             << " "
                             << (k + 1) * nquad[0] * nquad[1] + j * nquad[0] + i
                             << " "
                             << (k + 1) * nquad[0] * nquad[1] + j * nquad[0] +
                                    i + 1
                             << " "
                             << (k + 1) * nquad[0] * nquad[1] +
                                    (j + 1) * nquad[0] + i + 1
                             << " "
                             << (k + 1) * nquad[0] * nquad[1] +
                                    (j + 1) * nquad[0] + i
                             << " " << endl;
                     }
                 }
             }
         }
         break;
         default:
             break;
     }
  
     outfile << endl;
     outfile << "        </DataArray>" << endl;
     outfile << "        <DataArray type=\"Int32\" "
             << "Name=\"offsets\" format=\"ascii\">" << endl;
     for (i = 0; i < ntotminus; ++i)
     {
         outfile << i * ns + ns << " ";
     }
     outfile << endl;
     outfile << "        </DataArray>" << endl;
     outfile << "        <DataArray type=\"UInt8\" "
             << "Name=\"types\" format=\"ascii\">" << endl;
     for (i = 0; i < ntotminus; ++i)
     {
         outfile << ostr;
     }
     outfile << endl;
     outfile << "        </DataArray>" << endl;
     outfile << "      </Cells>" << endl;
     outfile << "      <PointData>" << endl;
 }

References Nektar::MultiRegions::e1D, Nektar::MultiRegions::e2D, Nektar::MultiRegions::e3D, and m_expType.

Referenced by WriteVtkPieceHeader().

◆ VectorFlux()

NekDouble Nektar::MultiRegions::ExpList::VectorFlux ( const Array< OneD, Array< OneD, NekDouble >> & inarray )

inline

Definition at line 560 of file ExpList.h.

     {
         return v_VectorFlux(inarray);
     }

References v_VectorFlux().

◆ WriteTecplotConnectivity()

void Nektar::MultiRegions::ExpList::WriteTecplotConnectivity	(	std::ostream &	outfile,
		int	expansion = `-1`
	)

inline

Definition at line 400 of file ExpList.h.

     {
         v_WriteTecplotConnectivity(outfile, expansion);
     }

References v_WriteTecplotConnectivity().

◆ WriteTecplotField()

void Nektar::MultiRegions::ExpList::WriteTecplotField	(	std::ostream &	outfile,
		int	expansion = `-1`
	)

inline

Definition at line 396 of file ExpList.h.

     {
         v_WriteTecplotField(outfile, expansion);
     }

References v_WriteTecplotField().

◆ WriteTecplotHeader()

void Nektar::MultiRegions::ExpList::WriteTecplotHeader	(	std::ostream &	outfile,
		std::string	var = `""`
	)

inline

Definition at line 388 of file ExpList.h.

     {
         v_WriteTecplotHeader(outfile, var);
     }

References v_WriteTecplotHeader().

◆ WriteTecplotZone()

void Nektar::MultiRegions::ExpList::WriteTecplotZone	(	std::ostream &	outfile,
		int	expansion = `-1`
	)

inline

Definition at line 392 of file ExpList.h.

     {
         v_WriteTecplotZone(outfile, expansion);
     }

References v_WriteTecplotZone().

◆ WriteVtkFooter()

void Nektar::MultiRegions::ExpList::WriteVtkFooter ( std::ostream & outfile )

Definition at line 2952 of file ExpList.cpp.

 {
     outfile << "  </UnstructuredGrid>" << endl;
     outfile << "</VTKFile>" << endl;
 }

◆ WriteVtkHeader()

void Nektar::MultiRegions::ExpList::WriteVtkHeader ( std::ostream & outfile )

Definition at line 2944 of file ExpList.cpp.

 {
     outfile << "<?xml version=\"1.0\"?>" << endl;
     outfile << "<VTKFile type=\"UnstructuredGrid\" version=\"0.1\" "
             << "byte_order=\"LittleEndian\">" << endl;
     outfile << "  <UnstructuredGrid>" << endl;
 }

◆ WriteVtkPieceData()

void Nektar::MultiRegions::ExpList::WriteVtkPieceData	(	std::ostream &	outfile,
		int	expansion,
		std::string	var = `"v"`
	)

inline

Definition at line 413 of file ExpList.h.

     {
         v_WriteVtkPieceData(outfile, expansion, var);
     }

References v_WriteVtkPieceData().

◆ WriteVtkPieceFooter()

void Nektar::MultiRegions::ExpList::WriteVtkPieceFooter	(	std::ostream &	outfile,
		int	expansion
	)

Definition at line 3092 of file ExpList.cpp.

 {
     boost::ignore_unused(expansion);
     outfile << "      </PointData>" << endl;
     outfile << "    </Piece>" << endl;
 }

◆ WriteVtkPieceHeader()

void Nektar::MultiRegions::ExpList::WriteVtkPieceHeader	(	std::ostream &	outfile,
		int	expansion,
		int	istrip = `0`
	)

inline

Definition at line 406 of file ExpList.h.

     {
         v_WriteVtkPieceHeader(outfile, expansion, istrip);
     }

References v_WriteVtkPieceHeader().

Member Data Documentation

◆ m_blockMat

BlockMatrixMapShPtr Nektar::MultiRegions::ExpList::m_blockMat

protected

Definition at line 1125 of file ExpList.h.

Referenced by GetBlockMatrix().

◆ m_coeff_offset

Array<OneD, int> Nektar::MultiRegions::ExpList::m_coeff_offset

protected

Offset of elemental data into the array m_coeffs.

Definition at line 1120 of file ExpList.h.

◆ m_coeffs

Array<OneD, NekDouble> Nektar::MultiRegions::ExpList::m_coeffs

protected

Concatenation of all local expansion coefficients.

The array of length m_ncoeffs $=N_{\mathrm{eof}}$ which is the concatenation of the local expansion coefficients $\hat{u}_n^e$ over all $N_{\mathrm{el}}$ elements

\[\mathrm{\texttt{m\_coeffs}}=\boldsymbol{\hat{u}}_{l} = \underline{\boldsymbol{\hat{u}}}^e = \left [ \begin{array}{c} \boldsymbol{\hat{u}}^{1} \ \ \boldsymbol{\hat{u}}^{2} \ \ \vdots \ \ \boldsymbol{\hat{u}}^{{{N_{\mathrm{el}}}}} \end{array} \right ], \quad \mathrm{where}\quad \boldsymbol{\hat{u}}^{e}[n]=\hat{u}_n^{e}\]

Definition at line 1076 of file ExpList.h.

◆ m_coeffsToElmt

Array<OneD, std::pair<int, int> > Nektar::MultiRegions::ExpList::m_coeffsToElmt

protected

m_coeffs to elemental value map

Definition at line 1124 of file ExpList.h.

Referenced by GetCoeffsToElmt(), and SetupCoeffPhys().

◆ m_coll_coeff_offset

std::vector<int> Nektar::MultiRegions::ExpList::m_coll_coeff_offset

protected

Offset of elemental data into the array m_coeffs.

Definition at line 1116 of file ExpList.h.

Referenced by CreateCollections(), GeneralMatrixOp(), IProductWRTDerivBase(), v_BwdTrans(), and v_IProductWRTBase().

◆ m_coll_phys_offset

std::vector<int> Nektar::MultiRegions::ExpList::m_coll_phys_offset

protected

Offset of elemental data into the array m_phys.

Definition at line 1118 of file ExpList.h.

Referenced by CreateCollections(), GeneralMatrixOp(), IProductWRTDerivBase(), v_BwdTrans(), v_IProductWRTBase(), and v_PhysDeriv().

◆ m_collections

Collections::CollectionVector Nektar::MultiRegions::ExpList::m_collections

protected

Definition at line 1112 of file ExpList.h.

Referenced by CreateCollections(), GeneralMatrixOp(), IProductWRTDerivBase(), v_BwdTrans(), v_IProductWRTBase(), and v_PhysDeriv().

◆ m_collectionsDoInit

std::vector<bool> Nektar::MultiRegions::ExpList::m_collectionsDoInit

protected

Vector of bools to act as an initialise on first call flag.

Definition at line 1114 of file ExpList.h.

Referenced by CreateCollections(), GeneralMatrixOp(), IProductWRTDerivBase(), v_BwdTrans(), v_IProductWRTBase(), and v_PhysDeriv().

◆ m_comm

LibUtilities::CommSharedPtr Nektar::MultiRegions::ExpList::m_comm

protected

Communicator.

Definition at line 1049 of file ExpList.h.

◆ m_elmtToExpId

std::unordered_map<int, int> Nektar::MultiRegions::ExpList::m_elmtToExpId

protected

Mapping from geometry ID of element to index inside m_exp.

Definition at line 1132 of file ExpList.h.

Referenced by GetElmtToExpId(), GetExpFromGeomId(), GetExpIndex(), Nektar::MultiRegions::ExpListHomogeneous1D::v_AppendFieldData(), v_ExtractDataToCoeffs(), and Nektar::MultiRegions::ExpListHomogeneous1D::v_ExtractDataToCoeffs().

◆ m_exp

std::shared_ptr<LocalRegions::ExpansionVector> Nektar::MultiRegions::ExpList::m_exp

protected

The list of local expansions.

The (shared pointer to the) vector containing (shared pointers to) all local expansions. The fact that the local expansions are all stored as a (pointer to a) #StdExpansion, the abstract base class for all local expansions, allows a general implementation where most of the routines for the derived classes are defined in the ExpList base class.

Definition at line 1111 of file ExpList.h.

◆ m_expType

ExpansionType Nektar::MultiRegions::ExpList::m_expType

protected

Exapnsion type.

Definition at line 1044 of file ExpList.h.

◆ m_graph

SpatialDomains::MeshGraphSharedPtr Nektar::MultiRegions::ExpList::m_graph

protected

Mesh associated with this expansion list.

Definition at line 1053 of file ExpList.h.

Referenced by Nektar::MultiRegions::ContField3DHomogeneous1D::ContField3DHomogeneous1D(), CreateCollections(), Nektar::MultiRegions::DisContField::DisContField(), Nektar::MultiRegions::ExpList3DHomogeneous1D::ExpList3DHomogeneous1D(), Nektar::MultiRegions::DisContField::FindPeriodicTraces(), GetExpIndex(), GetGraph(), GetMatIpwrtDeriveBase(), Nektar::MultiRegions::DisContField::SetUpDG(), Nektar::MultiRegions::DisContField::v_GetBoundaryToElmtMap(), and v_Reset().

◆ m_ncoeffs

int Nektar::MultiRegions::ExpList::m_ncoeffs

protected

The total number of local degrees of freedom. m_ncoeffs $=N_{\mathrm{eof}}=\sum_{e=1}^{{N_{\mathrm{el}}}}N^{e}_l$.

Definition at line 1056 of file ExpList.h.

◆ m_npoints

int Nektar::MultiRegions::ExpList::m_npoints

protected

The total number of quadrature points. m_npoints $=Q_{\mathrm{tot}}=\sum_{e=1}^{{N_{\mathrm{el}}}}N^{e}_Q$

Definition at line 1060 of file ExpList.h.

◆ m_phys

Array<OneD, NekDouble> Nektar::MultiRegions::ExpList::m_phys

protected

The global expansion evaluated at the quadrature points.

The array of length m_npoints $=Q_{\mathrm{tot}}$ containing the evaluation of $u^{\delta}(\boldsymbol{x})$ at the quadrature points $\boldsymbol{x}_i$.

\[\mathrm{\texttt{m\_phys}}=\boldsymbol{u}_{l} = \underline{\boldsymbol{u}}^e = \left [ \begin{array}{c} \boldsymbol{u}^{1} \ \ \boldsymbol{u}^{2} \ \ \vdots \ \ \boldsymbol{u}^{{{N_{\mathrm{el}}}}} \end{array} \right ],\quad \mathrm{where}\quad \boldsymbol{u}^{e}[i]=u^{\delta}(\boldsymbol{x}_i)\]

Definition at line 1092 of file ExpList.h.

◆ m_phys_offset

Array<OneD, int> Nektar::MultiRegions::ExpList::m_phys_offset

protected

Offset of elemental data into the array m_phys.

Definition at line 1122 of file ExpList.h.

Referenced by CreateCollections(), DivideByQuadratureMetric(), ExponentialFilter(), GenBlockMatrix(), GeneralMatrixOp(), GenerateElementVector(), GenGlobalMatrix(), GenGlobalMatrixFull(), GetElmtNormalLength(), GetPhys_Offset(), H1(), IProductWRTDerivBase(), IProductWRTDirectionalDerivBase(), MultiplyByQuadratureMetric(), PhysEvaluate(), Nektar::MultiRegions::ExpList2DHomogeneous1D::SetCoeffPhys(), Nektar::MultiRegions::ExpList2DHomogeneous2D::SetCoeffPhys(), Nektar::MultiRegions::ExpList3DHomogeneous1D::SetCoeffPhys(), Nektar::MultiRegions::ExpList3DHomogeneous2D::SetCoeffPhys(), SetupCoeffPhys(), v_FwdTransBndConstrained(), v_GetCoords(), v_GetMovingFrames(), v_GetNormals(), v_Integral(), Nektar::MultiRegions::ExpListHomogeneous1D::v_Integral(), v_L2(), v_PhysDeriv(), v_PhysDirectionalDeriv(), v_Upwind(), v_VectorFlux(), v_WriteTecplotField(), v_WriteVtkPieceData(), Nektar::MultiRegions::ExpListHomogeneous1D::v_WriteVtkPieceData(), and Nektar::MultiRegions::ExpListHomogeneous2D::v_WriteVtkPieceData().

◆ m_physState

bool Nektar::MultiRegions::ExpList::m_physState

protected

The state of the array m_phys.

Indicates whether the array m_phys, created to contain the evaluation of $u^{\delta}(\boldsymbol{x})$ at the quadrature points $\boldsymbol{x}_i$, is filled with these values.

Definition at line 1100 of file ExpList.h.

Referenced by GetPhysState(), Integral(), SetPhys(), SetPhysState(), UpdatePhys(), Nektar::MultiRegions::DisContField::v_ExtractTracePhys(), Nektar::MultiRegions::DisContField3DHomogeneous1D::v_ExtractTracePhys(), and v_WriteTecplotField().

◆ m_session

LibUtilities::SessionReaderSharedPtr Nektar::MultiRegions::ExpList::m_session

protected

Session.

Definition at line 1051 of file ExpList.h.

◆ m_WaveSpace

bool Nektar::MultiRegions::ExpList::m_WaveSpace

protected

Definition at line 1130 of file ExpList.h.

inarray	An array of size \(N_\mathrm{dof}\) containing the global degrees of freedom \(\boldsymbol{x}_g\).
outarray	The resulting local degrees of freedom \(\boldsymbol{x}_l\) will be stored in this array of size \(N_\mathrm{eof}\).

inarray	An array of arrays of size \(Q_{\mathrm{tot}}\) containing the values of the function \(f(\boldsymbol{x})\) at the quadrature points \(\boldsymbol{x}_i\) in dir directions.
outarray	An array of size \(N_{\mathrm{eof}}\) used to store the result.

dir	{0,1} is the direction in which the derivative of the basis should be taken
inarray	An array of size \(Q_{\mathrm{tot}}\) containing the values of the function \(f(\boldsymbol{x})\) at the quadrature points \(\boldsymbol{x}_i\).
outarray	An array of size \(N_{\mathrm{eof}}\) used to store the result.

inarray	An array of size \(N_{\mathrm{eof}}\) containing the local coefficients \(\hat{u}_n^e\).
outarray	The resulting physical values at the quadrature points \(u^{\delta}(\boldsymbol{x}_i)\) will be stored in this array of size \(Q_{\mathrm{tot}}\).

coord_0	After calculation, the \(x_1\) coordinate will be stored in this array.
coord_1	After calculation, the \(x_2\) coordinate will be stored in this array.
coord_2	After calculation, the \(x_3\) coordinate will be stored in this array.

Public Member Functions

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Private Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ ExpList() [1/9]

◆ ExpList() [2/9]

◆ ExpList() [3/9]

◆ ExpList() [4/9]

◆ ExpList() [5/9]

◆ ExpList() [6/9]

◆ ExpList() [7/9]

◆ ExpList() [8/9]

◆ ExpList() [9/9]

◆ ~ExpList()

Member Function Documentation

◆ AddFwdBwdTraceIntegral()

◆ AddRightIPTBaseMatrix()

◆ AddRightIPTPhysDerivBase()

◆ AddTraceIntegral() [1/2]

◆ AddTraceIntegral() [2/2]

◆ AddTraceIntegralToOffDiag()

◆ AddTraceJacToElmtJac()

◆ AddTraceQuadPhysToField()

◆ AddTraceQuadPhysToOffDiag()

◆ AppendFieldData() [1/2]

◆ AppendFieldData() [2/2]

◆ ApplyGeomInfo()

◆ BwdTrans()

◆ ClearGlobalLinSysManager()

◆ CreateCollections()

◆ CurlCurl()

◆ DealiasedDotProd()

◆ DealiasedProd()

◆ DivideByQuadratureMetric()

◆ EvalBasisNumModesMax()

◆ EvalBasisNumModesMaxPerExp()

◆ EvaluateBoundaryConditions()

◆ ExponentialFilter()

◆ ExtractCoeffsFromFile()

◆ ExtractCoeffsToCoeffs()

◆ ExtractDataToCoeffs()

◆ ExtractElmtDataToCoeffs()

◆ ExtractElmtToBndPhys()

◆ ExtractFileBCs()

◆ ExtractPhysToBnd()

◆ ExtractPhysToBndElmt()

◆ ExtractTracePhys() [1/2]

◆ ExtractTracePhys() [2/2]

◆ FillBndCondFromField() [1/2]

◆ FillBndCondFromField() [2/2]

◆ FillBwdWithBoundCond()

◆ FillBwdWithBwdWeight()

◆ FwdTrans()

◆ FwdTransBndConstrained()

◆ FwdTransLocalElmt()

◆ GenBlockMatrix()

◆ GeneralGetFieldDefinitions()

◆ GeneralMatrixOp()

◆ GenerateElementVector()

◆ GenGlobalBndLinSys()

◆ GenGlobalLinSys()

◆ GenGlobalMatrix()

◆ GenGlobalMatrixFull()

◆ Get1DScaledTotPoints()

◆ GetBCValues()

◆ GetBlockMatrix()

◆ GetBndCondBwdWeight()

◆ GetBndCondExpansions()

◆ GetBndConditions()

◆ GetBndElmtExpansion()

◆ GetBoundaryCondition()

◆ GetBoundaryNormals()

◆ GetBoundaryToElmtMap()

◆ GetBwdWeight()

◆ GetCoeff()

◆ GetCoeff_Offset()

◆ GetCoeffs() [1/2]