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

#include <ExpList.h>

Inheritance diagram for Nektar::MultiRegions::ExpList:

Public Member Functions
	ExpList ()
	The default constructor. More...

	ExpList (const LibUtilities::SessionReaderSharedPtr &pSession)
	The default constructor. More...

	ExpList (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
	The default constructor. More...

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

	ExpList (const ExpList &in, const bool DeclareCoeffPhysArrays=true)
	The copy constructor. 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...

void	SetPhys (int i, NekDouble val)
	Set the i th value of m_phys to value val. 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 (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...

NekDouble	PhysIntegral (void)
	This function integrates a function $f(\boldsymbol{x})$ over the domain consisting of all the elements of the expansion. More...

NekDouble	PhysIntegral (const Array< OneD, const NekDouble > &inarray)
	This function integrates a function $f(\boldsymbol{x})$ over the domain consisting of all the elements of the expansion. More...

void	IProductWRTBase_IterPerExp (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	IProductWRTBase (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, CoeffState coeffstate=eLocal)

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 (in direction. More...

void	FwdTrans_IterPerExp (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, CoeffState coeffstate=eLocal)

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, CoeffState coeffstate=eLocal)

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

void	HelmSolve (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const FlagList &flags, 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...

void	LinearAdvectionDiffusionReactionSolve (const Array< OneD, Array< OneD, NekDouble > > &velocity, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const NekDouble lambda, CoeffState coeffstate=eLocal, 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, CoeffState coeffstate=eLocal, const Array< OneD, const NekDouble > &dirForcing=NullNekDouble1DArray)
	Solve Advection Diffusion Reaction. More...

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

void	BwdTrans_IterPerExp (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	BwdTrans (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, CoeffState coeffstate=eLocal)

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	HomogeneousFwdTrans (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, CoeffState coeffstate=eLocal, bool Shuff=true, bool UnShuff=true)

void	HomogeneousBwdTrans (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, CoeffState coeffstate=eLocal, bool Shuff=true, bool UnShuff=true)

void	DealiasedProd (const Array< OneD, NekDouble > &inarray1, const Array< OneD, NekDouble > &inarray2, Array< OneD, NekDouble > &outarray, CoeffState coeffstate=eLocal)

void	DealiasedDotProd (const Array< OneD, Array< OneD, NekDouble > > &inarray1, const Array< OneD, Array< OneD, NekDouble > > &inarray2, Array< OneD, Array< OneD, NekDouble > > &outarray, CoeffState coeffstate=eLocal)

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 (void)
	Fill Bnd Condition expansion from the values stored in expansion. More...

void	FillBndCondFromField (const int nreg)
	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_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 (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 associaed with the homogeneous expansion. More...

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

void	SetHomoLen (const NekDouble lhom)
	This function sets the Width of homogeneous direction associaed 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...

int	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 &	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	GetExpIndex (const Array< OneD, const NekDouble > &gloCoords, Array< OneD, NekDouble > &locCoords, NekDouble tol=0.0, bool returnNearestElmt=false)

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 global list of m_coeffs correspoinding to element n. More...

int	GetPhys_Offset (int n) const
	Get the start offset position for a global list of m_phys 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 ()

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

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)

void	Upwind (const Array< OneD, const NekDouble > &Vn, 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	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)

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, CoeffState coeffstate=eLocal)
	This function calculates the result of the multiplication of a matrix of type specified by mkey with a vector given by inarray. More...

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

void	SetUpPhysNormals ()

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

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)

const NekOptimize::GlobalOptParamSharedPtr &	GetGlobalOptParam (void)

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)
	Extract the data in fielddata into the coeffs. More...

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

Public Attributes
ExpansionType	m_expType

Protected Member Functions
void	SetCoeffPhysOffsets ()
	Definition of the total number of degrees of freedom and quadrature points and offsets to access data. More...

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

void	ReadGlobalOptimizationParameters ()

virtual int	v_GetNumElmts (void)

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

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 void	v_GetNormals (Array< OneD, Array< OneD, NekDouble > > &normals)

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)

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, CoeffState coeffstate)

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

virtual void	v_LinearAdvectionDiffusionReactionSolve (const Array< OneD, Array< OneD, NekDouble > > &velocity, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const NekDouble lambda, CoeffState coeffstate=eLocal, 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, CoeffState coeffstate=eLocal, const Array< OneD, const NekDouble > &dirForcing=NullNekDouble1DArray)

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

virtual void	v_FillBndCondFromField ()

virtual void	v_FillBndCondFromField (const int nreg)

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, CoeffState coeffstate)

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

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

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

virtual void	v_FwdTrans_BndConstrained (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, CoeffState coeffstate)

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

virtual void	v_GeneralMatrixOp (const GlobalMatrixKey &gkey, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, CoeffState coeffstate)

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

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 Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, CoeffState coeffstate=eLocal, bool Shuff=true, bool UnShuff=true)

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

virtual void	v_DealiasedProd (const Array< OneD, NekDouble > &inarray1, const Array< OneD, NekDouble > &inarray2, Array< OneD, NekDouble > &outarray, CoeffState coeffstate=eLocal)

virtual void	v_DealiasedDotProd (const Array< OneD, Array< OneD, NekDouble > > &inarray1, const Array< OneD, Array< OneD, NekDouble > > &inarray2, Array< OneD, Array< OneD, NekDouble > > &outarray, CoeffState coeffstate=eLocal)

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

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

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)
	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_WriteVtkPieceHeader (std::ostream &outfile, int expansion, int istrip)

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

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)

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

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

Protected Attributes
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< 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...

NekOptimize::GlobalOptParamSharedPtr	m_globalOptParam

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

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. The coefficients from these expansions are concatenated in m_coeffs, while the expansion evaluated at the quadrature points is stored in m_phys.

Definition at line 103 of file ExpList.h.

Constructor & Destructor Documentation

◆ ExpList() [1/5]

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

The default constructor.

Creates an empty expansion list. The expansion list will typically be populated by a derived class (namely one of MultiRegions::ExpList1D, MultiRegions::ExpList2D or MultiRegions::ExpList3D).

Definition at line 96 of file ExpList.cpp.

References Nektar::MultiRegions::eNoType, and SetExpType().

Referenced by Nektar::MultiRegions::ExpList0D::ExpList0D(), and Nektar::MultiRegions::ExpList1D::ExpList1D().

                         :
             m_comm(),
             m_session(),
             m_graph(),
             m_ncoeffs(0),
             m_npoints(0),
             m_coeffs(),
             m_phys(),
             m_physState(false),
             m_exp(MemoryManager<LocalRegions::ExpansionVector>
                       ::AllocateSharedPtr()),
             m_coeff_offset(),
             m_phys_offset(),
             m_blockMat(MemoryManager<BlockMatrixMap>::AllocateSharedPtr()),
             m_WaveSpace(false)
         {
             SetExpType(eNoType);
         }

◆ ExpList() [2/5]

Nektar::MultiRegions::ExpList::ExpList ( const LibUtilities::SessionReaderSharedPtr & pSession )

The default constructor.

Creates an empty expansion list. The expansion list will typically be populated by a derived class (namely one of MultiRegions::ExpList1D, MultiRegions::ExpList2D or MultiRegions::ExpList3D).

Definition at line 121 of file ExpList.cpp.

References Nektar::MultiRegions::eNoType, and SetExpType().

                                                                    :
             m_comm(pSession->GetComm()),
             m_session(pSession),
             m_graph(),
             m_ncoeffs(0),
             m_npoints(0),
             m_coeffs(),
             m_phys(),
             m_physState(false),
             m_exp(MemoryManager<LocalRegions::ExpansionVector>
                       ::AllocateSharedPtr()),
             m_coeff_offset(),
             m_phys_offset(),
             m_blockMat(MemoryManager<BlockMatrixMap>::AllocateSharedPtr()),
             m_WaveSpace(false)
         {
             SetExpType(eNoType);
         }

◆ ExpList() [3/5]

Nektar::MultiRegions::ExpList::ExpList	(	const LibUtilities::SessionReaderSharedPtr &	pSession,
		const SpatialDomains::MeshGraphSharedPtr &	pGraph
	)

The default constructor.

Creates an empty expansion list. The expansion list will typically be populated by a derived class (namely one of MultiRegions::ExpList1D, MultiRegions::ExpList2D or MultiRegions::ExpList3D).

Definition at line 147 of file ExpList.cpp.

References Nektar::MultiRegions::eNoType, and SetExpType().

                                                                :
             m_comm(pSession->GetComm()),
             m_session(pSession),
             m_graph(pGraph),
             m_ncoeffs(0),
             m_npoints(0),
             m_coeffs(),
             m_phys(),
             m_physState(false),
             m_exp(MemoryManager<LocalRegions::ExpansionVector>
                       ::AllocateSharedPtr()),
             m_coeff_offset(),
             m_phys_offset(),
             m_blockMat(MemoryManager<BlockMatrixMap>::AllocateSharedPtr()),
             m_WaveSpace(false)
         {
             SetExpType(eNoType);
         }

◆ ExpList() [4/5]

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

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 173 of file ExpList.cpp.

References Nektar::MultiRegions::eNoType, m_coeffs, m_exp, m_ncoeffs, m_npoints, m_phys, and SetExpType().

                                                            :
             m_comm(in.m_comm),
             m_session(in.m_session),
             m_graph(in.m_graph),
             m_ncoeffs(0),
             m_npoints(0),
             m_coeffs(),
             m_phys(),
             m_physState(false),
             m_exp(MemoryManager<LocalRegions::ExpansionVector>
                       ::AllocateSharedPtr()),
             m_coeff_offset(),
             m_phys_offset(),
             m_blockMat(MemoryManager<BlockMatrixMap>::AllocateSharedPtr()),
             m_WaveSpace(false)
         {
             SetExpType(eNoType);
 
             for (int i=0; i < eIDs.size(); ++i)
             {
                 (*m_exp).push_back( (*(in.m_exp))[eIDs[i]]);
                 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);
             }
         }

◆ ExpList() [5/5]

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 212 of file ExpList.cpp.

References Nektar::MultiRegions::eNoType, m_coeffs, m_ncoeffs, m_npoints, m_phys, and SetExpType().

                                                                             :
             std::enable_shared_from_this<ExpList>(in),
             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_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_globalOptParam(in.m_globalOptParam),
             m_blockMat(in.m_blockMat),
             m_WaveSpace(false)
         {
             SetExpType(eNoType);
 
             if(DeclareCoeffPhysArrays)
             {
                 m_coeffs = Array<OneD, NekDouble>(m_ncoeffs, 0.0);
                 m_phys   = Array<OneD, NekDouble>(m_npoints, 0.0);
             }
         }

◆ ~ExpList()

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

virtual

The default destructor.

Definition at line 284 of file ExpList.cpp.

285 {

286 }

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 2303 of file ExpList.h.

References v_AddFwdBwdTraceIntegral().

Referenced by GetNumElmts().

         {
             v_AddFwdBwdTraceIntegral(Fwd,Bwd,outarray);
         }

◆ AddTraceIntegral() [1/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 2288 of file ExpList.h.

References v_AddTraceIntegral().

Referenced by GetNumElmts().

         {
             v_AddTraceIntegral(Fx,Fy,outarray);
         }

◆ AddTraceIntegral() [2/2]

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

inline

Definition at line 2296 of file ExpList.h.

References v_AddTraceIntegral().

         {
             v_AddTraceIntegral(Fn,outarray);
         }

◆ 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 913 of file ExpList.h.

References v_AppendFieldData().

             {
                 v_AppendFieldData(fielddef,fielddata);
             }

◆ 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 923 of file ExpList.h.

References ExtractCoeffsToCoeffs(), ExtractDataToCoeffs(), ExtractElmtDataToCoeffs(), GenerateElementVector(), MULTI_REGIONS_EXPORT, and v_AppendFieldData().

             {
                 v_AppendFieldData(fielddef,fielddata,coeffs);
             }

◆ 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 1579 of file ExpList.cpp.

Referenced by Nektar::MultiRegions::DisContField1D::DisContField1D(), and Nektar::MultiRegions::DisContField3D::DisContField3D().

         {
 
         }

◆ BwdTrans()

void Nektar::MultiRegions::ExpList::BwdTrans	(	const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray,
		CoeffState	coeffstate = `eLocal`
	)

inline

Definition at line 1775 of file ExpList.h.

References v_BwdTrans().

Referenced by Nektar::MultiRegions::DisContField2D::L2_DGDeriv(), and v_WriteTecplotField().

         {
             v_BwdTrans(inarray,outarray,coeffstate);
         }

◆ BwdTrans_IterPerExp()

void Nektar::MultiRegions::ExpList::BwdTrans_IterPerExp	(	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.

Definition at line 1786 of file ExpList.h.

References v_BwdTrans_IterPerExp().

Referenced by Nektar::MultiRegions::ContField1D::BwdTrans(), Nektar::MultiRegions::ContField2D::BwdTrans(), and Nektar::MultiRegions::ContField3D::v_BwdTrans().

         {
             v_BwdTrans_IterPerExp(inarray,outarray);
         }

◆ ClearGlobalLinSysManager()

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

Definition at line 3441 of file ExpList.cpp.

References v_ClearGlobalLinSysManager().

         {
             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 3304 of file ExpList.cpp.

References Nektar::Collections::CollectionOptimisation::GetDefaultImplementationType(), Nektar::Collections::CollectionOptimisation::GetMaxCollectionSize(), Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), Nektar::Collections::CollectionOptimisation::IsUsingAutotuning(), m_coeff_offset, m_coll_coeff_offset, m_coll_phys_offset, m_collections, m_comm, m_exp, m_phys_offset, m_session, and Nektar::Collections::CollectionOptimisation::SetWithTimings().

Referenced by Nektar::MultiRegions::ExpList1D::ExpList1D(), Nektar::MultiRegions::ExpList2D::ExpList2D(), and Nektar::MultiRegions::ExpList3D::ExpList3D().

         {
             map<LibUtilities::ShapeType,
                 vector<std::pair<LocalRegions::ExpansionSharedPtr,int> > > collections;
 
             // Figure out optimisation parameters if provided in
             // session file or default given
             Collections::CollectionOptimisation colOpt(m_session, ImpType);
             ImpType = colOpt.GetDefaultImplementationType();
 
             bool autotuning = colOpt.IsUsingAutotuning();
             bool verbose    = (m_session->DefinesCmdLineArgument("verbose")) &&
                               (m_comm->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);
 
                 if(it.second.size() == 1) // single element case
                 {
                     collExp.push_back(it.second[0].first);
 
                     // if no Imp Type provided and No settign in xml file.
                     // reset impTypes using timings
                     if(autotuning)
                     {
                         impTypes = colOpt.SetWithTimings(collExp,
                                                          impTypes, verbose);
                     }
 
                     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();
                     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();
                         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 ||
                            prevnPhys != nPhys || collcnt >= collmax)
                         {
 
                             // if no Imp Type provided and No
                             // settign in xml file. reset
                             // impTypes using timings
                             if(autotuning)
                             {
                                 impTypes = colOpt.SetWithTimings(collExp,
                                                                  impTypes,
                                                                  verbose);
                             }
 
                             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)
                             {
                                 impTypes = colOpt.SetWithTimings(collExp,
                                                                  impTypes,verbose);
                             }
 
                             Collections::Collection tmp(collExp, impTypes);
                             m_collections.push_back(tmp);
                             collExp.clear();
                             collcnt = 0;
 
                         }
 
                         prevCoeffOffset = coeffOffset;
                         prevPhysOffset  = physOffset;
                         prevnCoeff      = nCoeffs;
                         prevnPhys       = nPhys;
                     }
                 }
             }
         }

◆ CurlCurl()

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

inline

Definition at line 1922 of file ExpList.h.

References v_CurlCurl().

Referenced by GetNumElmts().

         {
             v_CurlCurl(Vel, Q);
         }

◆ DealiasedDotProd()

void Nektar::MultiRegions::ExpList::DealiasedDotProd	(	const Array< OneD, Array< OneD, NekDouble > > &	inarray1,
		const Array< OneD, Array< OneD, NekDouble > > &	inarray2,
		Array< OneD, Array< OneD, NekDouble > > &	outarray,
		CoeffState	coeffstate = `eLocal`
	)

inline

Definition at line 1970 of file ExpList.h.

References v_DealiasedDotProd().

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

◆ DealiasedProd()

void Nektar::MultiRegions::ExpList::DealiasedProd	(	const Array< OneD, NekDouble > &	inarray1,
		const Array< OneD, NekDouble > &	inarray2,
		Array< OneD, NekDouble > &	outarray,
		CoeffState	coeffstate = `eLocal`
	)

inline

Definition at line 1958 of file ExpList.h.

References v_DealiasedProd().

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

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

◆ 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 1572 of file ExpList.h.

References m_exp.

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

◆ 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 1589 of file ExpList.h.

References m_exp.

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

◆ 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 2356 of file ExpList.h.

References v_EvaluateBoundaryConditions().

Referenced by Nektar::MultiRegions::DisContField1D::DisContField1D(), Nektar::MultiRegions::DisContField2D::DisContField2D(), Nektar::MultiRegions::DisContField3D::DisContField3D(), and GetNumElmts().

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

◆ ExponentialFilter()

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

Definition at line 729 of file ExpList.cpp.

References m_phys_offset.

         {
             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);
             }
         }

◆ 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 2342 of file ExpList.cpp.

References v_ExtractCoeffsToCoeffs().

Referenced by AppendFieldData().

         {
             v_ExtractCoeffsToCoeffs(fromExpList,fromCoeffs,toCoeffs);
         }

◆ ExtractDataToCoeffs()

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

Extract the data in fielddata into the coeffs.

Definition at line 2333 of file ExpList.cpp.

References v_ExtractDataToCoeffs().

Referenced by AppendFieldData().

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

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

Referenced by AppendFieldData().

◆ ExtractElmtToBndPhys()

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

inline

Definition at line 2422 of file ExpList.h.

References v_ExtractElmtToBndPhys().

Referenced by GetNumElmts().

         {
             v_ExtractElmtToBndPhys(i, elmt, boundary);
         }

◆ ExtractFileBCs()

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

protected

Definition at line 2104 of file ExpList.cpp.

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

Referenced by Nektar::MultiRegions::DisContField3D::v_EvaluateBoundaryConditions(), Nektar::MultiRegions::DisContField3DHomogeneous1D::v_EvaluateBoundaryConditions(), Nektar::MultiRegions::DisContField2D::v_EvaluateBoundaryConditions(), and v_GetNumElmts().

         {
             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
                         locExpList->ExtractDataToCoeffs(
                             FieldDef[j], FieldData[j],
                             FieldDef[j]->m_fields[k],
                             locExpList->UpdateCoeffs());
                         found = true;
                     }
                 }
             }
 
             ASSERTL0(found, "Could not find variable '"+varName+
                             "' in file boundary condition "+fileName);
             locExpList->BwdTrans_IterPerExp(
                 locExpList->GetCoeffs(),
                 locExpList->UpdatePhys());
         }

◆ ExtractPhysToBnd()

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

inline

Definition at line 2436 of file ExpList.h.

References v_ExtractPhysToBnd().

Referenced by GetNumElmts().

         {
             v_ExtractPhysToBnd(i, phys, bnd);
         }

◆ ExtractPhysToBndElmt()

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

inline

Definition at line 2429 of file ExpList.h.

References v_ExtractPhysToBndElmt().

Referenced by GetNumElmts().

         {
             v_ExtractPhysToBndElmt(i, phys, bndElmt);
         }

◆ ExtractTracePhys() [1/2]

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

inline

Definition at line 2331 of file ExpList.h.

References v_ExtractTracePhys().

Referenced by GetNumElmts().

         {
             v_ExtractTracePhys(outarray);
         }

◆ ExtractTracePhys() [2/2]

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

inline

Definition at line 2337 of file ExpList.h.

References v_ExtractTracePhys().

         {
             v_ExtractTracePhys(inarray,outarray);
         }

◆ FillBndCondFromField() [1/2]

void Nektar::MultiRegions::ExpList::FillBndCondFromField ( void )

inline

Fill Bnd Condition expansion from the values stored in expansion.

Definition at line 2073 of file ExpList.h.

References v_FillBndCondFromField().

Referenced by WriteVtkPieceData().

         {
             v_FillBndCondFromField();
         }

◆ FillBndCondFromField() [2/2]

void Nektar::MultiRegions::ExpList::FillBndCondFromField ( const int nreg )

inline

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

Definition at line 2078 of file ExpList.h.

References v_FillBndCondFromField().

         {
             v_FillBndCondFromField(nreg);
         }

◆ FwdTrans()

void Nektar::MultiRegions::ExpList::FwdTrans	(	const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray,
		CoeffState	coeffstate = `eLocal`
	)

inline

Definition at line 1735 of file ExpList.h.

References v_FwdTrans().

         {
             v_FwdTrans(inarray,outarray,coeffstate);
         }

◆ FwdTrans_BndConstrained()

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

inline

Definition at line 1756 of file ExpList.h.

References v_FwdTrans_BndConstrained().

         {
             v_FwdTrans_BndConstrained(inarray,outarray);
         }

◆ FwdTrans_IterPerExp()

void Nektar::MultiRegions::ExpList::FwdTrans_IterPerExp	(	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 1746 of file ExpList.h.

References v_FwdTrans_IterPerExp().

         {
             v_FwdTrans_IterPerExp(inarray,outarray);
         }

◆ 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 869 of file ExpList.cpp.

Referenced by GetBlockMatrix().

         {
             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)
                 {
                     for (auto &x : gkey.GetVarCoeffs())
                     {
                         varcoeffs[x.first] = x.second + m_phys_offset[eid];
                     }
                 }
 
                 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;
         }

◆ 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 2183 of file ExpList.cpp.

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

Referenced by GetNumElmts(), and v_GetFieldDefinitions().

         {
             int startenum = (int) LibUtilities::eSegment;
             int endenum   = (int) LibUtilities::eHexahedron;
             int s         = 0;
             LibUtilities::ShapeType shape;
 
             ASSERTL1(NumHomoDir == HomoBasis.num_elements(),"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);
                 }
             }
         }

◆ GeneralMatrixOp()

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

inline

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 2394 of file ExpList.h.

References v_GeneralMatrixOp().

Referenced by Nektar::MultiRegions::ContField3D::GenerateDirBndCondForcing(), and GetNumElmts().

         {
             v_GeneralMatrixOp(gkey,inarray,outarray,coeffstate);
         }

◆ GeneralMatrixOp_IterPerExp()

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

Definition at line 1019 of file ExpList.cpp.

References Nektar::MultiRegions::GlobalMatrixKey::GetConstFactors(), Nektar::MultiRegions::GlobalMatrixKey::GetMatrixType(), Nektar::MultiRegions::GlobalMatrixKey::GetNVarCoeffs(), Nektar::MultiRegions::GlobalMatrixKey::GetVarCoeffs(), m_coeff_offset, m_globalOptParam, m_phys_offset, and MultiplyByBlockMatrix().

Referenced by GetNumElmts(), Nektar::MultiRegions::ContField3D::v_GeneralMatrixOp(), Nektar::MultiRegions::ContField1D::v_GeneralMatrixOp(), Nektar::MultiRegions::ContField2D::v_GeneralMatrixOp(), and v_GeneralMatrixOp().

         {
             const Array<OneD, const bool>  doBlockMatOp
                         = m_globalOptParam->DoBlockMatOp(gkey.GetMatrixType());
             const Array<OneD, const int> num_elmts
                         = m_globalOptParam->GetShapeNumElements();
 
             Array<OneD,NekDouble> tmp_outarray;
             int cnt = 0;
             int eid;
             for(int n = 0; n < num_elmts.num_elements(); ++n)
             {
                 if(doBlockMatOp[n])
                 {
                     const LibUtilities::ShapeType vType
                                     = m_globalOptParam->GetShapeList()[n];
                     const MultiRegions::GlobalMatrixKey vKey(gkey, vType);
                     if (cnt < m_coeff_offset.num_elements())
                     {
                         eid = cnt;
                         MultiplyByBlockMatrix(vKey,inarray + m_coeff_offset[eid],
                                               tmp_outarray = outarray + m_coeff_offset[eid]);
                         cnt += num_elmts[n];
                     }
                 }
                 else
                 {
                     int i;
                     int nvarcoeffs = gkey.GetNVarCoeffs();
 
                     for(i= 0; i < num_elmts[n]; ++i)
                     {
                         // need to be initialised with zero size for non variable coefficient case
                         StdRegions::VarCoeffMap varcoeffs;
 
                         eid = cnt++;
                         if(nvarcoeffs>0)
                         {
                             for (auto &x : gkey.GetVarCoeffs())
                             {
                                 varcoeffs[x.first] = x.second + m_phys_offset[eid];
                             }
                         }
 
                         StdRegions::StdMatrixKey mkey(gkey.GetMatrixType(),
                                                       (*m_exp)[eid]->DetShapeType(),
                                                       *((*m_exp)[eid]),
                                                       gkey.GetConstFactors(),varcoeffs);
 
                         (*m_exp)[eid]->GeneralMatrixOp(inarray + m_coeff_offset[eid],
                                                        tmp_outarray = outarray+m_coeff_offset[eid],
                                                        mkey);
                     }
                 }
             }
         }

◆ 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 2520 of file ExpList.cpp.

References m_phys_offset, and Vmath::Vcopy().

Referenced by AppendFieldData().

         {
             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);
             }
         }

◆ 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 1381 of file ExpList.cpp.

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

Referenced by Nektar::MultiRegions::DisContField2D::GetGlobalBndLinSys(), Nektar::MultiRegions::DisContField3D::GetGlobalBndLinSys(), and Nektar::MultiRegions::DisContField1D::GetGlobalBndLinSys().

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

◆ 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 1362 of file ExpList.cpp.

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

Referenced by Nektar::MultiRegions::ContField3D::GenGlobalLinSys(), Nektar::MultiRegions::ContField1D::GenGlobalLinSys(), and Nektar::MultiRegions::ContField2D::GenGlobalLinSys().

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

◆ 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 1086 of file ExpList.cpp.

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_npoints, m_phys_offset, m_session, and NEKERROR.

Referenced by Nektar::MultiRegions::ContField3D::GetGlobalMatrix(), and Nektar::MultiRegions::ContField2D::GetGlobalMatrix().

         {
             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)
                 {
                     for (auto &x : mkey.GetVarCoeffs())
                     {
                         varcoeffs[x.first] = x.second + m_phys_offset[eid];
                     }
                 }
 
                 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);
         }

◆ GenGlobalMatrixFull()

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

protected

Definition at line 1222 of file ExpList.cpp.

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, and m_phys_offset.

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

         {
             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)
                 {
                     for (auto &x : mkey.GetVarCoeffs())
                     {
                         varcoeffs[x.first] = x.second + m_phys_offset[eid];
                     }
                 }
 
                 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;
         }

◆ 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 1619 of file ExpList.h.

References m_exp.

         {
             int returnval = 0;
             int cnt;
             int nbase = (*m_exp)[0]->GetNumBases();
             
             for(int i = 0; i < (*m_exp).size(); ++i)
             {
                 cnt = 1;
                 for(int j = 0; j < nbase; ++j)
                 {
                     cnt *= (int)(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 1982 of file ExpList.h.

References v_GetBCValues().

         {
             v_GetBCValues(BndVals,TotField,BndID);
         }

◆ GetBlockMatrix()

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

protected

Definition at line 1004 of file ExpList.cpp.

References GenBlockMatrix(), and m_blockMat.

Referenced by MultiplyByBlockMatrix(), MultiplyByElmtInvMass(), Nektar::MultiRegions::DisContField3D::v_GeneralMatrixOp(), Nektar::MultiRegions::DisContField2D::v_GeneralMatrixOp(), Nektar::MultiRegions::DisContField3D::v_HelmSolve(), Nektar::MultiRegions::DisContField2D::v_HelmSolve(), and Nektar::MultiRegions::DisContField1D::v_HelmSolve().

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

◆ GetBndCondExpansions()

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

inline

Definition at line 2239 of file ExpList.h.

References v_GetBndCondExpansions().

Referenced by GetNumElmts(), v_ExtractElmtToBndPhys(), v_ExtractPhysToBnd(), v_ExtractPhysToBndElmt(), and v_GetBoundaryNormals().

         {
             return v_GetBndCondExpansions();
         }

◆ GetBndConditions()

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

inline

Definition at line 2345 of file ExpList.h.

References v_GetBndConditions().

Referenced by GetNumElmts().

         {
             return v_GetBndConditions();
         }

◆ GetBndElmtExpansion()

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

inline

Definition at line 2415 of file ExpList.h.

References v_GetBndElmtExpansion().

Referenced by GetNumElmts().

         {
             v_GetBndElmtExpansion(i, result, DeclareCoeffPhysArrays);
         }

◆ GetBoundaryCondition()

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

staticprotected

Definition at line 3270 of file ExpList.cpp.

References ASSERTL1.

Referenced by Nektar::MultiRegions::DisContField2D::FindPeriodicEdges(), Nektar::MultiRegions::DisContField3D::FindPeriodicFaces(), Nektar::MultiRegions::DisContField1D::FindPeriodicVertices(), Nektar::MultiRegions::DisContField1D::GenerateBoundaryConditionExpansion(), Nektar::MultiRegions::DisContField3D::GenerateBoundaryConditionExpansion(), Nektar::MultiRegions::DisContField2D::GenerateBoundaryConditionExpansion(), Nektar::MultiRegions::DisContField1D::SetBoundaryConditionExpansion(), Nektar::MultiRegions::DisContField3DHomogeneous1D::SetupBoundaryConditions(), and v_GetNumElmts().

         {
             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;
         }

◆ GetBoundaryNormals()

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

inline

Definition at line 2443 of file ExpList.h.

References v_GetBoundaryNormals().

Referenced by GetNumElmts().

         {
             v_GetBoundaryNormals(i, normals);
         }

◆ GetBoundaryToElmtMap()

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

inline

Definition at line 2409 of file ExpList.h.

References v_GetBoundaryToElmtMap().

         {
             v_GetBoundaryToElmtMap(ElmtID,EdgeID);
         }

◆ 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 2139 of file ExpList.h.

References m_coeffs.

Referenced by Nektar::MultiRegions::DisContField1D::v_EvaluateBoundaryConditions(), and WriteVtkPieceData().

         {
             return m_coeffs[i];
         }

◆ GetCoeff_Offset()

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

inline

Get the start offset position for a global list of m_coeffs correspoinding to element n.

Definition at line 2200 of file ExpList.h.

References m_coeff_offset.

         {
             return m_coeff_offset[n];
         }

◆ 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 2062 of file ExpList.h.

References m_coeffs.

         {
             return m_coeffs;
         }

◆ 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 2148 of file ExpList.h.

References m_coeffs.

         {
             return m_coeffs[i];
         }

◆ GetComm()

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

inline

Returns the comm object.

Definition at line 980 of file ExpList.h.

References m_comm.

             {
                 return m_comm;
             }

◆ 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 2013 of file ExpList.h.

References ASSERTL2, and m_exp.

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

◆ GetCoords()

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 1854 of file ExpList.h.

References v_GetCoords().

Referenced by v_WriteTecplotZone().

         {
             v_GetCoords(coord_0,coord_1,coord_2);
         }

◆ 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 2191 of file ExpList.h.

References m_exp.

         {
             return m_exp;
         }

◆ GetExp() [2/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 2182 of file ExpList.h.

References m_exp.

         {
             return (*m_exp)[n];
         }

◆ GetExp() [3/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 1430 of file ExpList.cpp.

References ASSERTL0, GetCoordim(), and m_exp.

         {
             Array<OneD, NekDouble> stdCoord(GetCoordim(0),0.0);
             for (int i = 0; i < (*m_exp).size(); ++i)
             {
                 if ((*m_exp)[i]->GetGeom()->ContainsPoint(gloCoord))
                 {
                     return (*m_exp)[i];
                 }
             }
             ASSERTL0(false, "Cannot find element for this point.");
             return (*m_exp)[0]; // avoid warnings
         }

◆ GetExpIndex() [1/2]

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

This function returns the index of the local elemental expansion containing the arbitrary point given by gloCoord.

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 1451 of file ExpList.cpp.

Referenced by GetNumElmts(), and PhysEvaluate().

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

◆ 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`
	)

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 1462 of file ExpList.cpp.

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.

         {
             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 x = (gloCoords.num_elements() > 0 ? gloCoords[0] : 0.0);
             NekDouble y = (gloCoords.num_elements() > 1 ? gloCoords[1] : 0.0);
             NekDouble z = (gloCoords.num_elements() > 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);
 
             NekDouble nearpt     = 1e6;
             NekDouble nearpt_min = 1e6;
             int       min_id     = 0;
             Array<OneD, NekDouble> savLocCoords(locCoords.num_elements());
 
             // Check each element in turn to see if point lies within it.
             for (int i = 0; i < elmts.size(); ++i)
             {
                 if ((*m_exp)[m_elmtToExpId[elmts[i]]]->
                             GetGeom()->ContainsPoint(gloCoords,
                                                      locCoords,
                                                      tol, nearpt))
                 {
                     return m_elmtToExpId[elmts[i]];
                 }
                 else
                 {
                     // If it does not lie within, keep track of which element
                     // is nearest.
                     if(nearpt < nearpt_min)
                     {
                         min_id     = m_elmtToExpId[elmts[i]];
                         nearpt_min = nearpt;
                         Vmath::Vcopy(locCoords.num_elements(),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)
             {
 
                 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.num_elements(),savLocCoords, 1,
                                                       locCoords,    1);
                 return min_id;
             }
             else
             {
                 return -1;
             }
         }

◆ 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 2170 of file ExpList.h.

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

◆ GetExpType()

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

Returns the type of the expansion.

Definition at line 271 of file ExpList.cpp.

References m_expType.

Referenced by v_CurlCurl().

         {
             return m_expType;
         }

◆ GetFieldDefinitions() [1/2]

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

inline

Definition at line 898 of file ExpList.h.

References v_GetFieldDefinitions().

             {
                 return v_GetFieldDefinitions();
             }

◆ GetFieldDefinitions() [2/2]

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

inline

Definition at line 904 of file ExpList.h.

References v_GetFieldDefinitions().

             {
                 v_GetFieldDefinitions(fielddef);
             }

◆ GetFwdBwdTracePhys() [1/2]

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

inline

Definition at line 2311 of file ExpList.h.

References v_GetFwdBwdTracePhys().

Referenced by GetNumElmts().

         {
             v_GetFwdBwdTracePhys(Fwd,Bwd);
         }

◆ GetFwdBwdTracePhys() [2/2]

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

inline

Definition at line 2318 of file ExpList.h.

References v_GetFwdBwdTracePhys().

         {
             v_GetFwdBwdTracePhys(field,Fwd,Bwd);
         }

◆ GetGlobalOptParam()

const NekOptimize::GlobalOptParamSharedPtr& Nektar::MultiRegions::ExpList::GetGlobalOptParam ( void )

inline

Definition at line 879 of file ExpList.h.

References m_globalOptParam.

             {
                 return m_globalOptParam;
             }

◆ GetGraph()

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

inline

Definition at line 985 of file ExpList.h.

References m_graph.

             {
                 return m_graph;
             }

◆ GetHomogeneousBasis()

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

inline

Definition at line 991 of file ExpList.h.

References v_GetHomogeneousBasis().

             {
                 return v_GetHomogeneousBasis();
             }

◆ GetHomoLen()

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

inline

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

Definition at line 603 of file ExpList.h.

References v_GetHomoLen().

             {
                 return v_GetHomoLen();
             }

◆ GetLeftAdjacentFaces()

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

inline

Definition at line 2326 of file ExpList.h.

References v_GetLeftAdjacentFaces().

Referenced by GetNumElmts().

         {
             return v_GetLeftAdjacentFaces();
         }

◆ 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 1866 of file ExpList.h.

References v_GetMovingFrames().

Referenced by GetNumElmts().

         {
              v_GetMovingFrames(MMFdir,CircCentre,outarray);
         }

◆ GetNcoeffs() [1/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 1558 of file ExpList.h.

References m_ncoeffs.

         {
             return m_ncoeffs;
         }

◆ GetNcoeffs() [2/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 1563 of file ExpList.h.

References m_exp.

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

◆ GetNormals()

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

inline

Definition at line 2282 of file ExpList.h.

References v_GetNormals().

Referenced by GetNumElmts().

         {
             v_GetNormals(normals);
         }

◆ GetNpoints()

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

inline

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

Definition at line 1640 of file ExpList.h.

References m_npoints.

Referenced by export_ExpList().

         {
             return m_npoints;
         }

◆ GetNumElmts()

int 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 655 of file ExpList.h.

References AddFwdBwdTraceIntegral(), AddTraceIntegral(), CurlCurl(), Nektar::MultiRegions::eLocal, EvaluateBoundaryConditions(), ExtractElmtToBndPhys(), ExtractPhysToBnd(), ExtractPhysToBndElmt(), ExtractTracePhys(), GeneralGetFieldDefinitions(), GeneralMatrixOp(), GeneralMatrixOp_IterPerExp(), GetBndCondExpansions(), GetBndConditions(), GetBndElmtExpansion(), GetBoundaryNormals(), GetBoundaryToElmtMap(), GetCoeff_Offset(), GetExp(), GetExpIndex(), GetFwdBwdTracePhys(), GetLeftAdjacentFaces(), GetMovingFrames(), GetNormals(), GetPhys_Offset(), GetTrace(), GetTraceBndMap(), GetTraceMap(), Nektar::NekConstants::kNekUnsetDouble, MULTI_REGIONS_EXPORT, Nektar::LibUtilities::NullBasisSharedPtr1DArray, Nektar::NullNekDouble1DArray, Nektar::LibUtilities::NullNekDoubleVector, Nektar::LibUtilities::NullUnsignedIntVector, PhysDeriv(), PhysDirectionalDeriv(), PhysEvaluate(), SetUpPhysNormals(), UpdateBndCondExpansion(), UpdateBndConditions(), UpdateCoeffs(), UpdatePhys(), Upwind(), and v_GetNumElmts().

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

             {
                 return v_GetNumElmts();
             }

◆ GetPeriodicEntities()

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

inline

Definition at line 889 of file ExpList.h.

References v_GetPeriodicEntities().

             {
                 v_GetPeriodicEntities(periodicVerts, periodicEdges, periodicFaces);
             }

◆ 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 2161 of file ExpList.h.

References m_phys.

         {
             return m_phys;
         }

◆ GetPhys_Offset()

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

inline

Get the start offset position for a global list of m_phys correspoinding to element n.

Definition at line 2208 of file ExpList.h.

References m_phys_offset.

         {
             return m_phys_offset[n];
         }

◆ 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 1706 of file ExpList.h.

References m_physState.

Referenced by export_ExpList().

         {
             return m_physState;
         }

◆ GetPlane()

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

inline

Definition at line 996 of file ExpList.h.

References v_GetPlane().

             {
                 return v_GetPlane(n);
             }

◆ GetRobinBCInfo()

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

inline

Definition at line 884 of file ExpList.h.

References v_GetRobinBCInfo().

Referenced by GenGlobalBndLinSys(), and GenGlobalMatrixFull().

             {
                 return v_GetRobinBCInfo();
             }

◆ GetSession()

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

inline

Returns the session object.

Definition at line 974 of file ExpList.h.

References m_session.

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

             {
                 return m_session;
             }

◆ 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 2024 of file ExpList.h.

References m_exp.

Referenced by WriteVtkPieceData().

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

◆ GetSharedThisPtr()

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

inline

Returns a shared pointer to the current object.

Definition at line 968 of file ExpList.h.

Referenced by GenGlobalBndLinSys(), and GenGlobalLinSys().

             {
                 return shared_from_this();
             }

◆ GetTotPoints() [1/2]

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

inline

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

Definition at line 1608 of file ExpList.h.

References m_npoints.

Referenced by Nektar::MultiRegions::ExpList2DHomogeneous1D::GetCoords(), Nektar::MultiRegions::ExpList3DHomogeneous2D::GetCoords(), Nektar::MultiRegions::ExpList3DHomogeneous1D::GetCoords(), v_CurlCurl(), Nektar::MultiRegions::ExpList3DHomogeneous1D::v_HomogeneousEnergy(), Nektar::MultiRegions::ExpList3DHomogeneous2D::v_L2(), v_WriteTecplotField(), and v_WriteTecplotZone().

         {
             return m_npoints;
         }

◆ GetTotPoints() [2/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 1613 of file ExpList.h.

References m_exp.

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

◆ 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 2267 of file ExpList.h.

References v_GetTrace().

Referenced by GetNumElmts(), Nektar::MultiRegions::DisContField2D::v_AddFwdBwdTraceIntegral(), Nektar::MultiRegions::DisContField1D::v_AddTraceIntegral(), and Nektar::MultiRegions::DisContField2D::v_AddTraceIntegral().

         {
             return v_GetTrace();
         }

◆ GetTraceBndMap()

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

inline

Definition at line 2277 of file ExpList.h.

References v_GetTraceBndMap().

Referenced by GetNumElmts().

         {
             return v_GetTraceBndMap();
         }

◆ GetTraceMap()

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

inline

Definition at line 2272 of file ExpList.h.

References v_GetTraceMap().

Referenced by GetNumElmts(), and v_GetTraceBndMap().

         {
             return v_GetTraceMap();
         }

◆ GetTransposition()

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

inline

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

Definition at line 596 of file ExpList.h.

References v_GetTransposition().

             {
                 return 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 1657 of file ExpList.h.

References m_WaveSpace.

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

         {
             return m_WaveSpace;
         }

◆ 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 619 of file ExpList.h.

References v_GetYIDs().

             {
                 return 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 589 of file ExpList.h.

References v_GetZIDs().

Referenced by v_WriteTecplotZone().

             {
                 return v_GetZIDs();
             }

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

inline

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

Definition at line 2096 of file ExpList.h.

References v_GlobalToLocal().

         {
             v_GlobalToLocal();
         }

◆ GlobalToLocal() [2/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 2127 of file ExpList.h.

References v_GlobalToLocal().

         {
             v_GlobalToLocal(inarray, outarray);
         }

◆ 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 2164 of file ExpList.cpp.

References m_comm, m_phys_offset, and Nektar::LibUtilities::ReduceSum.

Referenced by L2().

         {
             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);
         }

◆ HelmSolve()

void Nektar::MultiRegions::ExpList::HelmSolve	(	const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray,
		const FlagList &	flags,
		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 1808 of file ExpList.h.

References v_HelmSolve().

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

◆ HomogeneousBwdTrans()

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

inline

Definition at line 1945 of file ExpList.h.

References v_HomogeneousBwdTrans().

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

◆ 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 573 of file ExpList.h.

References v_HomogeneousEnergy().

             {
                 return v_HomogeneousEnergy();
             }

◆ HomogeneousFwdTrans()

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

inline

Definition at line 1932 of file ExpList.h.

References v_HomogeneousFwdTrans().

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

◆ ImposeDirichletConditions()

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

inline

Impose Dirichlet Boundary Conditions onto Array.

Definition at line 2067 of file ExpList.h.

References v_ImposeDirichletConditions().

Referenced by WriteVtkPieceData().

         {
             v_ImposeDirichletConditions(outarray);
         }

◆ Integral()

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

inline

Definition at line 561 of file ExpList.h.

References v_Integral().

             {
                 return v_Integral(inarray);
             }

◆ IProductWRTBase()

void Nektar::MultiRegions::ExpList::IProductWRTBase	(	const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray,
		CoeffState	coeffstate = `eLocal`
	)

inline

Definition at line 1714 of file ExpList.h.

References v_IProductWRTBase().

Referenced by Nektar::MultiRegions::ContField3D::v_FwdTrans(), Nektar::MultiRegions::ContField3D::v_HelmSolve(), Nektar::MultiRegions::DisContField3D::v_HelmSolve(), Nektar::MultiRegions::DisContField2D::v_HelmSolve(), Nektar::MultiRegions::DisContField1D::v_HelmSolve(), and Nektar::MultiRegions::ContField3D::v_LinearAdvectionDiffusionReactionSolve().

         {
             v_IProductWRTBase(inarray,outarray, coeffstate);
         }

◆ IProductWRTBase_IterPerExp()

void Nektar::MultiRegions::ExpList::IProductWRTBase_IterPerExp	(	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 1725 of file ExpList.h.

References v_IProductWRTBase_IterPerExp().

Referenced by Nektar::MultiRegions::ContField2D::IProductWRTBase(), Nektar::MultiRegions::ContField1D::IProductWRTBase(), v_FwdTrans_IterPerExp(), and Nektar::MultiRegions::ContField3D::v_IProductWRTBase().

         {
             v_IProductWRTBase_IterPerExp(inarray,outarray);
         }

◆ IProductWRTDerivBase() [1/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::StdExpansion::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 409 of file ExpList.cpp.

References m_coeff_offset, and m_phys_offset.

         {
             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]);
             }
         }

◆ IProductWRTDerivBase() [2/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 (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::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 473 of file ExpList.cpp.

References ASSERTL0, ASSERTL1, Nektar::Collections::eIProductWRTDerivBase, GetCoordim(), m_coll_coeff_offset, m_coll_phys_offset, and m_collections.

         {
             Array<OneD, NekDouble> tmp0,tmp1,tmp2;
             // assume coord dimension defines the size of Deriv Base
             int dim = GetCoordim(0);
 
             ASSERTL1(inarray.num_elements() >= dim,"inarray is not of sufficient dimension");
 
             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:
                 ASSERTL0(false,"Dimension of inarray not correct");
                 break;
             }
         }

◆ 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 429 of file ExpList.cpp.

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

         {
             int npts_e;
             int coordim = (*m_exp)[0]->GetGeom()->GetCoordim();
             int nq      = direction.num_elements()/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] );
             }
         }

◆ 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_2$ error with respect to soln of the global spectral/hp element approximation.

Definition at line 548 of file ExpList.h.

References H1(), MULTI_REGIONS_EXPORT, Nektar::NullNekDouble1DArray, and v_L2().

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

             {
                 return v_L2(inarray, soln);
             }

◆ LinearAdvectionDiffusionReactionSolve()

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

inline

Solve Advection Diffusion Reaction.

Definition at line 1827 of file ExpList.h.

References v_LinearAdvectionDiffusionReactionSolve().

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

◆ 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,
		CoeffState	coeffstate = `eLocal`,
		const Array< OneD, const NekDouble > &	dirForcing = `NullNekDouble1DArray`
	)

inline

Solve Advection Diffusion Reaction.

Definition at line 1839 of file ExpList.h.

References v_LinearAdvectionReactionSolve().

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

◆ 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 1928 of file ExpList.cpp.

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

Referenced by WriteVtkPieceData().

         {
             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;
         }

◆ 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 2083 of file ExpList.h.

References v_LocalToGlobal().

Referenced by Nektar::MultiRegions::ContField3D::v_FillBndCondFromField(), Nektar::MultiRegions::ContField2D::v_FillBndCondFromField(), Nektar::MultiRegions::ContField3D::v_HelmSolve(), Nektar::MultiRegions::ContField2D::v_HelmSolve(), and WriteVtkPieceData().

         {
             v_LocalToGlobal(useComm);
         }

◆ 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 2088 of file ExpList.h.

References v_LocalToGlobal().

         {
             v_LocalToGlobal(inarray, outarray,useComm);
         }

◆ 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 352 of file ExpList.cpp.

References Nektar::eWrapper, and GetBlockMatrix().

Referenced by GeneralMatrixOp_IterPerExp().

         {
             // 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;
         }

◆ 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 755 of file ExpList.cpp.

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

Referenced by v_FwdTrans_IterPerExp().

         {
             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;
             }
         }

◆ MultiplyByInvMassMatrix()

void Nektar::MultiRegions::ExpList::MultiplyByInvMassMatrix	(	const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray,
		CoeffState	coeffstate = `eLocal`
	)

inline

Definition at line 1797 of file ExpList.h.

References v_MultiplyByInvMassMatrix().

         {
             v_MultiplyByInvMassMatrix(inarray,outarray,coeffstate);
         }

◆ NormVectorIProductWRTBase() [1/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 1993 of file ExpList.h.

References v_NormVectorIProductWRTBase().

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

◆ NormVectorIProductWRTBase() [2/2]

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

inline

Definition at line 2002 of file ExpList.h.

References v_NormVectorIProductWRTBase().

         {
             v_NormVectorIProductWRTBase(V, outarray);
         }

◆ PhysDeriv() [1/3]

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

inline

Definition at line 1897 of file ExpList.h.

References v_PhysDeriv().

Referenced by GetNumElmts(), and v_CurlCurl().

         {
             v_PhysDeriv(edir, inarray,out_d);
         }        

◆ PhysDeriv() [2/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 1878 of file ExpList.h.

References v_PhysDeriv().

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

◆ PhysDeriv() [3/3]

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

inline

Definition at line 1889 of file ExpList.h.

References v_PhysDeriv().

         {
             v_PhysDeriv(dir,inarray,out_d);
         }

◆ 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 1909 of file ExpList.h.

References v_PhysDirectionalDeriv().

Referenced by GetNumElmts().

         {
             v_PhysDirectionalDeriv(direction, inarray, outarray);
         }

◆ 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 1554 of file ExpList.cpp.

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

Referenced by export_ExpList(), and GetNumElmts().

         {
             int dim = GetCoordim(0);
             ASSERTL0(dim == coords.num_elements(),
                      "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);
         }

◆ 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 640 of file ExpList.h.

References GetExpSize(), and v_PhysGalerkinProjection1DScaled().

             {
                 v_PhysGalerkinProjection1DScaled(scale, inarray, outarray);
             } 

◆ PhysIntegral() [1/2]

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

This function integrates a function $f(\boldsymbol{x})$ over the domain consisting of all the elements of the expansion.

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 304 of file ExpList.cpp.

References ASSERTL1, m_phys, and m_physState.

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

◆ PhysIntegral() [2/2]

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

This function integrates a function $f(\boldsymbol{x})$ over the domain consisting of all the elements of the expansion.

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 329 of file ExpList.cpp.

References m_phys_offset.

         {
             int       i;
             NekDouble sum = 0.0;
 
             for(i = 0; i < (*m_exp).size(); ++i)
             {
                 sum += (*m_exp)[i]->Integral(inarray + m_phys_offset[i]);
             }
 
             return sum;
         }

◆ 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 628 of file ExpList.h.

References v_PhysInterp1DScaled().

             {
                 v_PhysInterp1DScaled(scale, inarray,outarray);                
             }

◆ ReadGlobalOptimizationParameters()

void Nektar::MultiRegions::ExpList::ReadGlobalOptimizationParameters ( )

inlineprotected

Definition at line 1157 of file ExpList.h.

References v_ReadGlobalOptimizationParameters().

Referenced by Nektar::MultiRegions::ExpList1D::ExpList1D(), Nektar::MultiRegions::ExpList2D::ExpList2D(), and Nektar::MultiRegions::ExpList3D::ExpList3D().

             {
                 v_ReadGlobalOptimizationParameters();
             }

◆ Reset()

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

inline

Reset geometry information and reset matrices.

Definition at line 393 of file ExpList.h.

References v_Reset().

             {
                 v_Reset();
             }

◆ 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 2033 of file ExpList.h.

References m_coeffs.

Referenced by WriteVtkPieceData().

         {
             m_coeffs[i] = val;
         }

◆ SetCoeffPhysOffsets()

void Nektar::MultiRegions::ExpList::SetCoeffPhysOffsets ( )

protected

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

Definition at line 249 of file ExpList.cpp.

References m_coeff_offset, m_exp, m_ncoeffs, m_npoints, and m_phys_offset.

Referenced by Nektar::MultiRegions::ExpList0D::ExpList0D(), Nektar::MultiRegions::ExpList1D::ExpList1D(), Nektar::MultiRegions::ExpList2D::ExpList2D(), and Nektar::MultiRegions::ExpList3D::ExpList3D().

         {
             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();
             }
         }

◆ 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 2043 of file ExpList.h.

References m_coeffs.

Referenced by WriteVtkPieceData().

         {
             m_coeffs[i] = val;
         }

◆ SetCoeffsArray()

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

inline

Set the m_coeffs array to inarray.

Definition at line 2049 of file ExpList.h.

References m_coeffs.

Referenced by WriteVtkPieceData().

         {
             m_coeffs = inarray;
         }

◆ SetExpType()

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

Returns the type of the expansion.

Definition at line 279 of file ExpList.cpp.

References m_expType.

Referenced by ExpList(), Nektar::MultiRegions::ExpList0D::ExpList0D(), Nektar::MultiRegions::ExpList1D::ExpList1D(), Nektar::MultiRegions::ExpList2D::ExpList2D(), Nektar::MultiRegions::ExpList2DHomogeneous1D::ExpList2DHomogeneous1D(), Nektar::MultiRegions::ExpList3D::ExpList3D(), Nektar::MultiRegions::ExpList3DHomogeneous1D::ExpList3DHomogeneous1D(), and Nektar::MultiRegions::ExpList3DHomogeneous2D::ExpList3DHomogeneous2D().

         {
             m_expType = Type;
         }

◆ SetHomo1DSpecVanVisc()

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

inline

This function sets the Spectral Vanishing Viscosity in homogeneous1D expansion.

Definition at line 580 of file ExpList.h.

References v_SetHomo1DSpecVanVisc().

             {
                 v_SetHomo1DSpecVanVisc(visc);
             }

◆ SetHomoLen()

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

inline

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

Definition at line 610 of file ExpList.h.

References v_SetHomoLen().

             {
                 return v_SetHomoLen(lhom);
             }

◆ 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	(	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 1663 of file ExpList.h.

References m_phys.

         {
             m_phys[i] = val;
         }

◆ SetPhys() [2/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 1677 of file ExpList.h.

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

         {
             ASSERTL0(inarray.num_elements() == 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;
         }

◆ SetPhysArray()

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

inline

Sets the array m_phys.

Definition at line 1688 of file ExpList.h.

References m_phys.

         {
             m_phys = inarray;
         }

◆ 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 1697 of file ExpList.h.

References m_physState.

Referenced by export_ExpList().

         {
             m_physState = physState;
         }

◆ SetUpPhysNormals()

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

inline

Definition at line 2404 of file ExpList.h.

References v_SetUpPhysNormals().

Referenced by Nektar::MultiRegions::DisContField1D::DisContField1D(), Nektar::MultiRegions::DisContField2D::DisContField2D(), Nektar::MultiRegions::DisContField3D::DisContField3D(), Nektar::MultiRegions::DisContField3D::GenerateBoundaryConditionExpansion(), Nektar::MultiRegions::DisContField2D::GenerateBoundaryConditionExpansion(), GetNumElmts(), Nektar::MultiRegions::DisContField3D::SetUpDG(), Nektar::MultiRegions::DisContField2D::SetUpDG(), and Nektar::MultiRegions::DisContField1D::SetUpDG().

         {
             v_SetUpPhysNormals();
         }

◆ 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 1649 of file ExpList.h.

References m_WaveSpace.

         {
             m_WaveSpace = wavespace;
         }

◆ SmoothField()

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

inline

Smooth a field across elements.

Definition at line 1767 of file ExpList.h.

References v_SmoothField().

         {
             v_SmoothField(field);
         }

◆ UpdateBndCondExpansion()

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

inline

Definition at line 2244 of file ExpList.h.

References v_UpdateBndCondExpansion().

Referenced by GetNumElmts().

         {
             return v_UpdateBndCondExpansion(i);
         }

◆ UpdateBndConditions()

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

inline

Definition at line 2351 of file ExpList.h.

References v_UpdateBndConditions().

Referenced by GetNumElmts().

         {
             return 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 2219 of file ExpList.h.

References m_coeffs.

Referenced by Nektar::MultiRegions::DisContField3DHomogeneous2D::EvaluateBoundaryConditions(), and GetNumElmts().

         {
             return m_coeffs;
         }

◆ 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 2230 of file ExpList.h.

References m_phys, and m_physState.

Referenced by GetNumElmts().

         {
             m_physState = true;
             return m_phys;
         }

◆ 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 2249 of file ExpList.h.

References v_Upwind().

Referenced by GetNumElmts().

         {
             v_Upwind(Vec, Fwd, Bwd, 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 2258 of file ExpList.h.

References v_Upwind().

         {
             v_Upwind(Vn, Fwd, Bwd, 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::DisContField2D, and Nektar::MultiRegions::DisContField3D.

Definition at line 2638 of file ExpList.cpp.

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

Referenced by AddFwdBwdTraceIntegral(), and v_GetNumElmts().

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

◆ v_AddTraceIntegral() [1/2]

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

protectedvirtual

Reimplemented in Nektar::MultiRegions::DisContField2D.

Definition at line 2619 of file ExpList.cpp.

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

Referenced by AddTraceIntegral(), and v_GetNumElmts().

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

◆ v_AddTraceIntegral() [2/2]

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

protectedvirtual

Reimplemented in Nektar::MultiRegions::DisContField2D, Nektar::MultiRegions::DisContField3D, and Nektar::MultiRegions::DisContField1D.

Definition at line 2629 of file ExpList.cpp.

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

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

◆ v_AppendFieldData() [1/2]

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

protectedvirtual

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

Definition at line 2305 of file ExpList.cpp.

References m_coeffs.

Referenced by AppendFieldData(), and v_GetNumElmts().

         {
             v_AppendFieldData(fielddef,fielddata,m_coeffs);
         }

◆ 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::ExpListHomogeneous1D, and Nektar::MultiRegions::ExpListHomogeneous2D.

Definition at line 2310 of file ExpList.cpp.

References m_coeff_offset.

         {
             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);
             }
 
         }

◆ v_BwdTrans()

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

protectedvirtual

Reimplemented in Nektar::MultiRegions::ContField2D, Nektar::MultiRegions::ContField1D, Nektar::MultiRegions::ExpListHomogeneous1D, Nektar::MultiRegions::ExpListHomogeneous2D, and Nektar::MultiRegions::ContField3D.

Definition at line 2910 of file ExpList.cpp.

References v_BwdTrans_IterPerExp().

Referenced by BwdTrans(), and v_GetNumElmts().

         {
             boost::ignore_unused(coeffstate);
             v_BwdTrans_IterPerExp(inarray,outarray);
         }

◆ v_BwdTrans_IterPerExp()

void Nektar::MultiRegions::ExpList::v_BwdTrans_IterPerExp	(	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::ExpListHomogeneous1D, and Nektar::MultiRegions::ExpListHomogeneous2D.

Definition at line 1418 of file ExpList.cpp.

References Nektar::Collections::eBwdTrans, m_coll_coeff_offset, m_coll_phys_offset, and m_collections.

Referenced by BwdTrans_IterPerExp(), v_BwdTrans(), and v_GetNumElmts().

         {
             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]);
             }
         }

◆ v_ClearGlobalLinSysManager()

void Nektar::MultiRegions::ExpList::v_ClearGlobalLinSysManager ( void )

protectedvirtual

Reimplemented in Nektar::MultiRegions::ContField2D, Nektar::MultiRegions::ContField1D, Nektar::MultiRegions::ContField3D, Nektar::MultiRegions::ContField3DHomogeneous1D, and Nektar::MultiRegions::ContField3DHomogeneous2D.

Definition at line 2098 of file ExpList.cpp.

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

Referenced by ClearGlobalLinSysManager(), and v_GetNumElmts().

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

◆ v_CurlCurl()

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

protectedvirtual

Definition at line 625 of file ExpList.cpp.

References ASSERTL0, Nektar::MultiRegions::e2D, Nektar::MultiRegions::e3D, Nektar::MultiRegions::e3DH1D, Nektar::MultiRegions::e3DH2D, GetExpType(), GetTotPoints(), m_session, Vmath::Neg(), PhysDeriv(), Vmath::Smul(), Vmath::Vsub(), Nektar::xDir, Nektar::yDir, and Nektar::zDir.

Referenced by CurlCurl(), and v_GetNumElmts().

         {
             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(GetExpType())
             {
             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;
             }
         }

◆ v_DealiasedDotProd()

void Nektar::MultiRegions::ExpList::v_DealiasedDotProd	(	const Array< OneD, Array< OneD, NekDouble > > &	inarray1,
		const Array< OneD, Array< OneD, NekDouble > > &	inarray2,
		Array< OneD, Array< OneD, NekDouble > > &	outarray,
		CoeffState	coeffstate = `eLocal`
	)

protectedvirtual

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

Definition at line 2776 of file ExpList.cpp.

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

Referenced by DealiasedDotProd(), and v_GetNumElmts().

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

◆ v_DealiasedProd()

void Nektar::MultiRegions::ExpList::v_DealiasedProd	(	const Array< OneD, NekDouble > &	inarray1,
		const Array< OneD, NekDouble > &	inarray2,
		Array< OneD, NekDouble > &	outarray,
		CoeffState	coeffstate = `eLocal`
	)

protectedvirtual

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

Definition at line 2766 of file ExpList.cpp.

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

Referenced by DealiasedProd(), and v_GetNumElmts().

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

◆ 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`
	)

privatevirtual

Reimplemented in Nektar::MultiRegions::DisContField2D, Nektar::MultiRegions::DisContField3DHomogeneous1D, Nektar::MultiRegions::DisContField3D, Nektar::MultiRegions::DisContField1D, and Nektar::MultiRegions::DisContField3DHomogeneous2D.

Definition at line 3237 of file ExpList.cpp.

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

Referenced by EvaluateBoundaryConditions(), and v_GetNumElmts().

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

◆ 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 2444 of file ExpList.cpp.

References m_coeff_offset.

Referenced by ExtractCoeffsToCoeffs(), and v_GetNumElmts().

         {
             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();
             }
         }

◆ v_ExtractDataToCoeffs()

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

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::ExpListHomogeneous1D, and Nektar::MultiRegions::ExpListHomogeneous2D.

Definition at line 2355 of file ExpList.cpp.

References ASSERTL0, Nektar::LibUtilities::GetNumberOfCoefficients(), m_coeff_offset, m_elmtToExpId, m_exp, and Vmath::Vcopy().

Referenced by ExtractDataToCoeffs(), and v_GetNumElmts().

         {
             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;
         }

◆ v_ExtractElmtToBndPhys()

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

protectedvirtual

Definition at line 3035 of file ExpList.cpp.

References GetBndCondExpansions(), GetBoundaryToElmtMap(), and GetExp().

Referenced by ExtractElmtToBndPhys(), and v_GetNumElmts().

         {
             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();
             }
         }

◆ 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 3114 of file ExpList.cpp.

References GetBndCondExpansions(), GetBoundaryToElmtMap(), GetExp(), and GetPhys_Offset().

Referenced by ExtractPhysToBnd(), and v_GetNumElmts().

         {
             int n, cnt;
             Array<OneD, NekDouble> tmp1;
             StdRegions::StdExpansionSharedPtr 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);
             }
         }

◆ 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 3074 of file ExpList.cpp.

References GetBndCondExpansions(), GetBoundaryToElmtMap(), GetExp(), GetPhys_Offset(), and Vmath::Vcopy().

Referenced by ExtractPhysToBndElmt(), and v_GetNumElmts().

         {
             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;
             }
         }

◆ v_ExtractTracePhys() [1/2]

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

protectedvirtual

Reimplemented in Nektar::MultiRegions::DisContField3DHomogeneous1D, Nektar::MultiRegions::DisContField2D, Nektar::MultiRegions::DisContField1D, and Nektar::MultiRegions::DisContField3D.

Definition at line 2675 of file ExpList.cpp.

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

Referenced by ExtractTracePhys(), and v_GetNumElmts().

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

◆ 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, Nektar::MultiRegions::DisContField2D, Nektar::MultiRegions::DisContField1D, and Nektar::MultiRegions::DisContField3D.

Definition at line 2682 of file ExpList.cpp.

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

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

◆ v_FillBndCondFromField() [1/2]

void Nektar::MultiRegions::ExpList::v_FillBndCondFromField ( void )

protectedvirtual

Reimplemented in Nektar::MultiRegions::ContField2D, Nektar::MultiRegions::ContField3D, and Nektar::MultiRegions::ContField3DHomogeneous1D.

Definition at line 2861 of file ExpList.cpp.

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

Referenced by FillBndCondFromField(), and v_GetNumElmts().

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

◆ v_FillBndCondFromField() [2/2]

void Nektar::MultiRegions::ExpList::v_FillBndCondFromField ( const int nreg )

protectedvirtual

Reimplemented in Nektar::MultiRegions::ContField2D, Nektar::MultiRegions::ContField3D, and Nektar::MultiRegions::ContField3DHomogeneous1D.

Definition at line 2869 of file ExpList.cpp.

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

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

◆ v_FwdTrans()

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

protectedvirtual

Reimplemented in Nektar::MultiRegions::ContField2D, Nektar::MultiRegions::ExpListHomogeneous1D, Nektar::MultiRegions::ContField1D, Nektar::MultiRegions::ExpListHomogeneous2D, and Nektar::MultiRegions::ContField3D.

Definition at line 2918 of file ExpList.cpp.

References v_FwdTrans_IterPerExp().

Referenced by FwdTrans(), and v_GetNumElmts().

         {
             boost::ignore_unused(coeffstate);
             v_FwdTrans_IterPerExp(inarray,outarray);
         }

◆ v_FwdTrans_BndConstrained()

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

protectedvirtual

Reimplemented in Nektar::MultiRegions::ExpListHomogeneous1D.

Definition at line 804 of file ExpList.cpp.

References m_coeff_offset, and m_phys_offset.

Referenced by FwdTrans_BndConstrained(), and v_GetNumElmts().

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

◆ v_FwdTrans_IterPerExp()

void Nektar::MultiRegions::ExpList::v_FwdTrans_IterPerExp	(	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::ExpListHomogeneous1D, and Nektar::MultiRegions::ExpListHomogeneous2D.

Definition at line 794 of file ExpList.cpp.

References IProductWRTBase_IterPerExp(), m_ncoeffs, and MultiplyByElmtInvMass().

Referenced by FwdTrans_IterPerExp(), v_FwdTrans(), and v_GetNumElmts().

         {
             Array<OneD,NekDouble> f(m_ncoeffs);
 
             IProductWRTBase_IterPerExp(inarray,f);
             MultiplyByElmtInvMass(f,outarray);
 
         }

◆ v_GeneralMatrixOp()

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

protectedvirtual

Reimplemented in Nektar::MultiRegions::ContField2D, Nektar::MultiRegions::DisContField2D, Nektar::MultiRegions::ContField1D, Nektar::MultiRegions::DisContField3D, and Nektar::MultiRegions::ContField3D.

Definition at line 2942 of file ExpList.cpp.

References GeneralMatrixOp_IterPerExp().

Referenced by GeneralMatrixOp(), and v_GetNumElmts().

         {
             boost::ignore_unused(coeffstate);
             GeneralMatrixOp_IterPerExp(gkey,inarray,outarray);
         }

◆ 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 2787 of file ExpList.cpp.

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

Referenced by GetBCValues(), and v_GetNumElmts().

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

◆ v_GetBndCondExpansions()

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

protectedvirtual

Reimplemented in Nektar::MultiRegions::DisContField2D, Nektar::MultiRegions::DisContField3DHomogeneous1D, Nektar::MultiRegions::DisContField3D, Nektar::MultiRegions::DisContField1D, and Nektar::MultiRegions::DisContField3DHomogeneous2D.

Definition at line 2551 of file ExpList.cpp.

References ASSERTL0.

Referenced by GetBndCondExpansions(), and v_GetNumElmts().

         {
             ASSERTL0(false,
                      "This method is not defined or valid for this class type");
             static Array<OneD,const std::shared_ptr<ExpList> > result;
             return result;
         }

◆ v_GetBndConditions()

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

privatevirtual

Reimplemented in Nektar::MultiRegions::ContField2D, Nektar::MultiRegions::DisContField2D, Nektar::MultiRegions::DisContField3DHomogeneous1D, Nektar::MultiRegions::DisContField3D, Nektar::MultiRegions::DisContField1D, Nektar::MultiRegions::ContField1D, and Nektar::MultiRegions::DisContField3DHomogeneous2D.

Definition at line 3216 of file ExpList.cpp.

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

Referenced by GetBndConditions(), and v_GetNumElmts().

         {
             NEKERROR(ErrorUtil::efatal,
                      "This method is not defined or valid for this class type");
             static Array<OneD, const SpatialDomains::BoundaryConditionShPtr>
                                                                         result;
             return result;
         }

◆ v_GetBndElmtExpansion()

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

protectedvirtual

Reimplemented in Nektar::MultiRegions::DisContField2D, Nektar::MultiRegions::DisContField1D, Nektar::MultiRegions::DisContField3D, Nektar::MultiRegions::DisContField3DHomogeneous1D, and Nektar::MultiRegions::DisContField3DHomogeneous2D.

Definition at line 3024 of file ExpList.cpp.

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

Referenced by GetBndElmtExpansion(), and v_GetNumElmts().

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

◆ 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 3152 of file ExpList.cpp.

References GetBndCondExpansions(), GetBoundaryToElmtMap(), GetCoordim(), GetExp(), and Vmath::Vcopy().

Referenced by GetBoundaryNormals(), and v_GetNumElmts().

         {
             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->GetSurfaceNormal(EdgeID[cnt+n]);
                 // Copy to result
                 for (j = 0; j < coordim; ++j)
                 {
                     Vmath::Vcopy(nq, normalsElmt[j], 1,
                                      tmp = normals[j] + offset, 1);
                 }
             }
         }

◆ v_GetBoundaryToElmtMap()

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

protectedvirtual

Reimplemented in Nektar::MultiRegions::DisContField1D, Nektar::MultiRegions::DisContField2D, Nektar::MultiRegions::DisContField3DHomogeneous1D, Nektar::MultiRegions::DisContField3D, and Nektar::MultiRegions::DisContField3DHomogeneous2D.

Definition at line 3197 of file ExpList.cpp.

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

Referenced by GetBoundaryToElmtMap(), and v_GetNumElmts().

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

◆ v_GetCoords()

void Nektar::MultiRegions::ExpList::v_GetCoords	(	Array< OneD, NekDouble > &	coord_0,
		Array< OneD, NekDouble > &	coord_1,
		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::ExpList3DHomogeneous1D, Nektar::MultiRegions::ExpList3DHomogeneous2D, Nektar::MultiRegions::ExpList2DHomogeneous1D, and Nektar::MultiRegions::ExpList1DHomogeneous2D.

Definition at line 2963 of file ExpList.cpp.

References ASSERTL0, GetCoordim(), GetExp(), GetNumElmts(), and m_phys_offset.

Referenced by GetCoords(), and v_GetNumElmts().

         {
             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.num_elements() != 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.num_elements() != 0,
                          "output coord_1 is not defined");
                 ASSERTL0(coord_2.num_elements() != 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;
             }
         }

◆ v_GetFieldDefinitions() [1/2]

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

protectedvirtual

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

Definition at line 2291 of file ExpList.cpp.

Referenced by GetFieldDefinitions(), and v_GetNumElmts().

         {
             std::vector<LibUtilities::FieldDefinitionsSharedPtr> returnval;
             v_GetFieldDefinitions(returnval);
             return returnval;
         }

◆ v_GetFieldDefinitions() [2/2]

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

protectedvirtual

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

Definition at line 2298 of file ExpList.cpp.

References GeneralGetFieldDefinitions().

         {
             GeneralGetFieldDefinitions(fielddef);
         }

◆ v_GetFwdBwdTracePhys() [1/2]

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

protectedvirtual

Reimplemented in Nektar::MultiRegions::DisContField2D, Nektar::MultiRegions::DisContField1D, and Nektar::MultiRegions::DisContField3D.

Definition at line 2648 of file ExpList.cpp.

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

Referenced by GetFwdBwdTracePhys(), and v_GetNumElmts().

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

◆ v_GetFwdBwdTracePhys() [2/2]

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

protectedvirtual

Reimplemented in Nektar::MultiRegions::DisContField2D, Nektar::MultiRegions::DisContField1D, and Nektar::MultiRegions::DisContField3D.

Definition at line 2656 of file ExpList.cpp.

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

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

◆ v_GetHomogeneousBasis()

virtual LibUtilities::BasisSharedPtr Nektar::MultiRegions::ExpList::v_GetHomogeneousBasis ( void )

inlineprivatevirtual

Reimplemented in Nektar::MultiRegions::ExpListHomogeneous1D.

Definition at line 1526 of file ExpList.h.

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

Referenced by GetHomogeneousBasis().

             {
                 NEKERROR(ErrorUtil::efatal,
                     "This method is not defined or valid for this class type");
                 return LibUtilities::NullBasisSharedPtr; 
             }

◆ v_GetHomoLen()

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

protectedvirtual

Reimplemented in Nektar::MultiRegions::ExpListHomogeneous1D.

Definition at line 2046 of file ExpList.cpp.

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

Referenced by GetHomoLen(), and v_GetNumElmts().

         {
             NEKERROR(ErrorUtil::efatal,
                      "This method is not defined or valid for this class type");
             NekDouble len = 0.0;
             return len;
         }

◆ v_GetLeftAdjacentFaces()

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

protectedvirtual

Reimplemented in Nektar::MultiRegions::DisContField3D.

Definition at line 2666 of file ExpList.cpp.

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

Referenced by GetLeftAdjacentFaces(), and v_GetNumElmts().

         {
             NEKERROR(ErrorUtil::efatal,
                      "This method is not defined or valid for this class type");
             static vector<bool> tmp;
             return tmp;
         }

◆ 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 2468 of file ExpList.cpp.

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

Referenced by GetMovingFrames(), and v_GetNumElmts().

         {
             int npts;
 
             int MFdim = 3;
             int nq = outarray[0].num_elements()/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);
                     }
                 }
             }
 
         }

◆ v_GetNormals()

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

protectedvirtual

Reimplemented in Nektar::MultiRegions::ExpList1D, Nektar::MultiRegions::ExpList2D, Nektar::MultiRegions::ExpList2DHomogeneous1D, and Nektar::MultiRegions::ExpList0D.

Definition at line 2611 of file ExpList.cpp.

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

Referenced by GetNormals(), and v_GetNumElmts().

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

◆ v_GetNumElmts()

virtual int Nektar::MultiRegions::ExpList::v_GetNumElmts ( void )

inlineprotectedvirtual

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

Definition at line 1164 of file ExpList.h.

References Nektar::MultiRegions::eLocal, ExtractFileBCs(), GetBoundaryCondition(), Nektar::NekConstants::kNekUnsetDouble, MULTI_REGIONS_EXPORT, Nektar::NullNekDouble1DArray, v_AddFwdBwdTraceIntegral(), v_AddTraceIntegral(), v_AppendFieldData(), v_BwdTrans(), v_BwdTrans_IterPerExp(), v_ClearGlobalLinSysManager(), v_CurlCurl(), v_DealiasedDotProd(), v_DealiasedProd(), v_EvaluateBoundaryConditions(), v_ExtractCoeffsToCoeffs(), v_ExtractDataToCoeffs(), v_ExtractElmtToBndPhys(), v_ExtractPhysToBnd(), v_ExtractPhysToBndElmt(), v_ExtractTracePhys(), v_FillBndCondFromField(), v_FwdTrans(), v_FwdTrans_BndConstrained(), v_FwdTrans_IterPerExp(), v_GeneralMatrixOp(), v_GetBCValues(), v_GetBndCondExpansions(), v_GetBndConditions(), v_GetBndElmtExpansion(), v_GetBoundaryNormals(), v_GetBoundaryToElmtMap(), v_GetCoords(), v_GetFieldDefinitions(), v_GetFwdBwdTracePhys(), v_GetHomoLen(), v_GetLeftAdjacentFaces(), v_GetMovingFrames(), v_GetNormals(), v_GetPeriodicEntities(), v_GetRobinBCInfo(), v_GetTrace(), v_GetTraceBndMap(), v_GetTraceMap(), v_GetTransposition(), v_GetYIDs(), v_GetZIDs(), v_GlobalToLocal(), v_HelmSolve(), v_HomogeneousBwdTrans(), v_HomogeneousEnergy(), v_HomogeneousFwdTrans(), v_ImposeDirichletConditions(), v_Integral(), v_IProductWRTBase(), v_IProductWRTBase_IterPerExp(), v_L2(), v_LinearAdvectionDiffusionReactionSolve(), v_LinearAdvectionReactionSolve(), v_LocalToGlobal(), v_MultiplyByInvMassMatrix(), v_NormVectorIProductWRTBase(), v_PhysDeriv(), v_PhysDirectionalDeriv(), v_PhysGalerkinProjection1DScaled(), v_PhysInterp1DScaled(), v_ReadGlobalOptimizationParameters(), v_Reset(), v_SetHomoLen(), v_SetUpPhysNormals(), v_SmoothField(), v_UpdateBndCondExpansion(), v_UpdateBndConditions(), v_Upwind(), v_VectorFlux(), v_WriteTecplotConnectivity(), v_WriteTecplotField(), v_WriteTecplotHeader(), v_WriteTecplotZone(), v_WriteVtkPieceData(), and v_WriteVtkPieceHeader().

Referenced by GetNumElmts().

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

◆ v_GetPeriodicEntities()

void Nektar::MultiRegions::ExpList::v_GetPeriodicEntities	(	PeriodicMap &	periodicVerts,
		PeriodicMap &	periodicEdges,
		PeriodicMap &	periodicFaces
	)

privatevirtual

Reimplemented in Nektar::MultiRegions::DisContField2D, Nektar::MultiRegions::DisContField3D, and Nektar::MultiRegions::ExpList3DHomogeneous1D.

Definition at line 3260 of file ExpList.cpp.

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

Referenced by GetPeriodicEntities(), and v_GetNumElmts().

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

◆ v_GetPlane()

ExpListSharedPtr & Nektar::MultiRegions::ExpList::v_GetPlane ( int n )

privatevirtual

Reimplemented in Nektar::MultiRegions::ExpListHomogeneous1D.

Definition at line 3292 of file ExpList.cpp.

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

Referenced by GetPlane(), and v_SetHomo1DSpecVanVisc().

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

◆ v_GetRobinBCInfo()

map< int, RobinBCInfoSharedPtr > Nektar::MultiRegions::ExpList::v_GetRobinBCInfo ( void )

privatevirtual

Reimplemented in Nektar::MultiRegions::DisContField2D, Nektar::MultiRegions::DisContField3D, Nektar::MultiRegions::DisContField3DHomogeneous1D, Nektar::MultiRegions::DisContField1D, and Nektar::MultiRegions::DisContField3DHomogeneous2D.

Definition at line 3250 of file ExpList.cpp.

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

Referenced by GetRobinBCInfo(), and v_GetNumElmts().

         {
             NEKERROR(ErrorUtil::efatal,
                      "This method is not defined or valid for this class type");
             static map<int,RobinBCInfoSharedPtr> result;
             return result;
         }

◆ v_GetTrace()

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

protectedvirtual

Reimplemented in Nektar::MultiRegions::DisContField3DHomogeneous1D, Nektar::MultiRegions::DisContField3D, Nektar::MultiRegions::DisContField1D, and Nektar::MultiRegions::DisContField2D.

Definition at line 2590 of file ExpList.cpp.

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

Referenced by GetTrace(), and v_GetNumElmts().

         {
             NEKERROR(ErrorUtil::efatal,
                      "This method is not defined or valid for this class type");
             static std::shared_ptr<ExpList> returnVal;
             return returnVal;
         }

◆ v_GetTraceBndMap()

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

protectedvirtual

Reimplemented in Nektar::MultiRegions::DisContField3DHomogeneous1D.

Definition at line 2606 of file ExpList.cpp.

References GetTraceMap().

Referenced by GetTraceBndMap(), and v_GetNumElmts().

         {
             return GetTraceMap()->GetBndCondTraceToGlobalTraceMap();
         }

◆ v_GetTraceMap()

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

protectedvirtual

Reimplemented in Nektar::MultiRegions::DisContField2D, Nektar::MultiRegions::DisContField3DHomogeneous1D, Nektar::MultiRegions::DisContField3D, and Nektar::MultiRegions::DisContField1D.

Definition at line 2598 of file ExpList.cpp.

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

Referenced by GetTraceMap(), and v_GetNumElmts().

         {
             NEKERROR(ErrorUtil::efatal,
                      "This method is not defined or valid for this class type");
             static std::shared_ptr<AssemblyMapDG> result;
             return result;
         }

◆ v_GetTransposition()

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

protectedvirtual

Reimplemented in Nektar::MultiRegions::ExpListHomogeneous1D.

Definition at line 2038 of file ExpList.cpp.

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

Referenced by GetTransposition(), and v_GetNumElmts().

         {
             NEKERROR(ErrorUtil::efatal,
                      "This method is not defined or valid for this class type");
             LibUtilities::TranspositionSharedPtr trans;
             return trans;
         }

◆ v_GetYIDs()

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

protectedvirtual

Definition at line 2069 of file ExpList.cpp.

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

Referenced by GetYIDs(), and v_GetNumElmts().

         {
             NEKERROR(ErrorUtil::efatal,
                      "This method is not defined or valid for this class type");
             Array<OneD, unsigned int> NoModes(1);
             return NoModes;
         }

◆ v_GetZIDs()

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

protectedvirtual

Reimplemented in Nektar::MultiRegions::ExpListHomogeneous1D.

Definition at line 2061 of file ExpList.cpp.

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

Referenced by GetZIDs(), and v_GetNumElmts().

         {
             NEKERROR(ErrorUtil::efatal,
                      "This method is not defined or valid for this class type");
             Array<OneD, unsigned int> NoModes(1);
             return NoModes;
         }

◆ v_GlobalToLocal() [1/2]

void Nektar::MultiRegions::ExpList::v_GlobalToLocal ( void )

protectedvirtual

Reimplemented in Nektar::MultiRegions::ContField2D, Nektar::MultiRegions::ContField1D, Nektar::MultiRegions::ContField3D, Nektar::MultiRegions::ContField3DHomogeneous1D, and Nektar::MultiRegions::ContField3DHomogeneous2D.

Definition at line 2894 of file ExpList.cpp.

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

Referenced by GlobalToLocal(), and v_GetNumElmts().

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

◆ v_GlobalToLocal() [2/2]

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

protectedvirtual

Reimplemented in Nektar::MultiRegions::ContField2D, Nektar::MultiRegions::ContField1D, and Nektar::MultiRegions::ContField3D.

Definition at line 2901 of file ExpList.cpp.

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

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

◆ v_HelmSolve()

void Nektar::MultiRegions::ExpList::v_HelmSolve	(	const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray,
		const FlagList &	flags,
		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::DisContField3DHomogeneous1D, Nektar::MultiRegions::DisContField1D, Nektar::MultiRegions::ContField2D, Nektar::MultiRegions::DisContField2D, Nektar::MultiRegions::ContField1D, Nektar::MultiRegions::DisContField3D, Nektar::MultiRegions::ContField3D, Nektar::MultiRegions::DisContField3DHomogeneous2D, Nektar::MultiRegions::ContField3DHomogeneous1D, and Nektar::MultiRegions::ContField3DHomogeneous2D.

Definition at line 2701 of file ExpList.cpp.

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

Referenced by HelmSolve(), and v_GetNumElmts().

         {
             boost::ignore_unused(inarray, outarray, flags, factors, varcoeff,
                                  varfactors, dirForcing, PhysSpaceForcing);
             NEKERROR(ErrorUtil::efatal, "HelmSolve not implemented.");
         }

◆ v_HomogeneousBwdTrans()

void Nektar::MultiRegions::ExpList::v_HomogeneousBwdTrans	(	const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray,
		CoeffState	coeffstate = `eLocal`,
		bool	Shuff = `true`,
		bool	UnShuff = `true`
	)

protectedvirtual

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

Definition at line 2755 of file ExpList.cpp.

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

Referenced by HomogeneousBwdTrans(), and v_GetNumElmts().

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

◆ v_HomogeneousEnergy()

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

protectedvirtual

Reimplemented in Nektar::MultiRegions::ExpList3DHomogeneous1D.

Definition at line 2030 of file ExpList.cpp.

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

Referenced by HomogeneousEnergy(), and v_GetNumElmts().

         {
             NEKERROR(ErrorUtil::efatal,
                      "This method is not defined or valid for this class type");
             Array<OneD, NekDouble> NoEnergy(1,0.0);
             return NoEnergy;
         }

◆ v_HomogeneousFwdTrans()

void Nektar::MultiRegions::ExpList::v_HomogeneousFwdTrans	(	const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray,
		CoeffState	coeffstate = `eLocal`,
		bool	Shuff = `true`,
		bool	UnShuff = `true`
	)

protectedvirtual

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

Definition at line 2744 of file ExpList.cpp.

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

Referenced by HomogeneousFwdTrans(), and v_GetNumElmts().

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

◆ v_ImposeDirichletConditions()

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

protectedvirtual

Reimplemented in Nektar::MultiRegions::ContField2D, Nektar::MultiRegions::ContField1D, Nektar::MultiRegions::ContField3D, Nektar::MultiRegions::ContField3DHomogeneous1D, and Nektar::MultiRegions::ContField3DHomogeneous2D.

Definition at line 2852 of file ExpList.cpp.

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

Referenced by ImposeDirichletConditions(), and v_GetNumElmts().

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

◆ v_Integral()

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

protectedvirtual

Reimplemented in Nektar::MultiRegions::ExpList2DHomogeneous1D.

Definition at line 1997 of file ExpList.cpp.

References m_comm, m_phys_offset, and Nektar::LibUtilities::ReduceSum.

Referenced by Integral(), and v_GetNumElmts().

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

◆ v_IProductWRTBase()

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

protectedvirtual

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

Definition at line 2926 of file ExpList.cpp.

References Nektar::Collections::eIProductWRTBase, m_coll_coeff_offset, m_coll_phys_offset, and m_collections.

Referenced by IProductWRTBase(), and v_GetNumElmts().

         {
             boost::ignore_unused(coeffstate);
             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]);
             }
         }

◆ v_IProductWRTBase_IterPerExp()

void Nektar::MultiRegions::ExpList::v_IProductWRTBase_IterPerExp	(	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::ExpListHomogeneous1D, and Nektar::MultiRegions::ExpListHomogeneous2D.

Definition at line 382 of file ExpList.cpp.

References Nektar::Collections::eIProductWRTBase, m_coll_coeff_offset, m_coll_phys_offset, and m_collections.

Referenced by IProductWRTBase_IterPerExp(), and v_GetNumElmts().

         {
             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]);
             }
         }

◆ 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::ExpList3DHomogeneous1D, and Nektar::MultiRegions::ExpList3DHomogeneous2D.

Definition at line 1967 of file ExpList.cpp.

References m_comm, m_phys_offset, Nektar::NullNekDouble1DArray, and Nektar::LibUtilities::ReduceSum.

Referenced by L2(), and v_GetNumElmts().

         {
             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);
         }

◆ v_LinearAdvectionDiffusionReactionSolve()

void 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,
		CoeffState	coeffstate = `eLocal`,
		const Array< OneD, const NekDouble > &	dirForcing = `NullNekDouble1DArray`
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::ContField2D, and Nektar::MultiRegions::ContField3D.

Definition at line 2716 of file ExpList.cpp.

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

Referenced by LinearAdvectionDiffusionReactionSolve(), and v_GetNumElmts().

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

◆ 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,
		CoeffState	coeffstate = `eLocal`,
		const Array< OneD, const NekDouble > &	dirForcing = `NullNekDouble1DArray`
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::ContField2D.

Definition at line 2730 of file ExpList.cpp.

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

Referenced by LinearAdvectionReactionSolve(), and v_GetNumElmts().

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

◆ v_LocalToGlobal() [1/2]

void Nektar::MultiRegions::ExpList::v_LocalToGlobal ( bool UseComm )

protectedvirtual

Reimplemented in Nektar::MultiRegions::ContField2D, Nektar::MultiRegions::ContField1D, Nektar::MultiRegions::ContField3D, Nektar::MultiRegions::ContField3DHomogeneous1D, and Nektar::MultiRegions::ContField3DHomogeneous2D.

Definition at line 2876 of file ExpList.cpp.

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

Referenced by LocalToGlobal(), and v_GetNumElmts().

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

◆ 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::ContField2D, Nektar::MultiRegions::ContField1D, and Nektar::MultiRegions::ContField3D.

Definition at line 2884 of file ExpList.cpp.

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

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

◆ v_MultiplyByInvMassMatrix()

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

protectedvirtual

Reimplemented in Nektar::MultiRegions::ContField2D, Nektar::MultiRegions::ContField1D, and Nektar::MultiRegions::ContField3D.

Definition at line 2691 of file ExpList.cpp.

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

Referenced by MultiplyByInvMassMatrix(), and v_GetNumElmts().

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

◆ v_NormVectorIProductWRTBase() [1/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 2796 of file ExpList.cpp.

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

Referenced by NormVectorIProductWRTBase(), and v_GetNumElmts().

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

◆ v_NormVectorIProductWRTBase() [2/2]

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

protectedvirtual

Definition at line 2806 of file ExpList.cpp.

References ASSERTL0, GetCoeff_Offset(), GetCoordim(), GetExpSize(), and GetPhys_Offset().

         {
             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:
                     ASSERTL0(false,"Dimension not supported");
                     break;
             }
         }

◆ 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::ExpListHomogeneous1D, and Nektar::MultiRegions::ExpListHomogeneous2D.

Definition at line 553 of file ExpList.cpp.

References Nektar::Collections::ePhysDeriv, m_coll_phys_offset, and m_collections.

Referenced by PhysDeriv(), v_GetNumElmts(), and v_PhysDeriv().

         {
             Array<OneD, NekDouble> e_out_d0;
             Array<OneD, NekDouble> e_out_d1;
             Array<OneD, NekDouble> e_out_d2;
             int offset;
             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);
 
             }
         }

◆ 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 576 of file ExpList.cpp.

References Nektar::MultiRegions::DirCartesianMap, and v_PhysDeriv().

         {
             Direction edir = DirCartesianMap[dir];
             v_PhysDeriv(edir, inarray,out_d);
         }

◆ 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::ExpListHomogeneous1D, and Nektar::MultiRegions::ExpListHomogeneous2D.

Definition at line 584 of file ExpList.cpp.

References Nektar::MultiRegions::eN, Nektar::Collections::ePhysDeriv, Nektar::MultiRegions::eS, m_coll_phys_offset, m_collections, and m_phys_offset.

         {
             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
             {
                 // 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);
                 }
             }
         }

◆ 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 697 of file ExpList.cpp.

References m_phys_offset, and Vmath::Vcopy().

Referenced by PhysDirectionalDeriv(), and v_GetNumElmts().

         {
             int npts_e;
             int coordim = (*m_exp)[0]->GetGeom()->GetCoordim();
             int nq      = direction.num_elements() / 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] );
             }
         }

◆ 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, Nektar::MultiRegions::ExpList2D, and Nektar::MultiRegions::ExpList3D.

Definition at line 2088 of file ExpList.cpp.

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

Referenced by PhysGalerkinProjection1DScaled(), and v_GetNumElmts().

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

◆ 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, Nektar::MultiRegions::ExpList2D, and Nektar::MultiRegions::ExpList3D.

Definition at line 2078 of file ExpList.cpp.

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

Referenced by PhysInterp1DScaled(), and v_GetNumElmts().

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

◆ v_ReadGlobalOptimizationParameters()

void Nektar::MultiRegions::ExpList::v_ReadGlobalOptimizationParameters ( )

protectedvirtual

Reimplemented in Nektar::MultiRegions::ExpList1D, Nektar::MultiRegions::ExpList2D, and Nektar::MultiRegions::ExpList3D.

Definition at line 3207 of file ExpList.cpp.

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

Referenced by ReadGlobalOptimizationParameters(), and v_GetNumElmts().

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

◆ 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::DisContField2D, Nektar::MultiRegions::DisContField1D, and Nektar::MultiRegions::DisContField3D.

Definition at line 1592 of file ExpList.cpp.

References m_exp, and m_graph.

Referenced by Reset(), v_GetNumElmts(), Nektar::MultiRegions::DisContField3D::v_Reset(), Nektar::MultiRegions::DisContField1D::v_Reset(), and Nektar::MultiRegions::DisContField2D::v_Reset().

         {
             // 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();
             }
         }

◆ v_SetHomo1DSpecVanVisc()

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

inlineprivatevirtual

Reimplemented in Nektar::MultiRegions::ExpListHomogeneous1D.

Definition at line 1534 of file ExpList.h.

References Nektar::ErrorUtil::efatal, NEKERROR, and v_GetPlane().

Referenced by SetHomo1DSpecVanVisc().

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

◆ v_SetHomoLen()

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

protectedvirtual

Reimplemented in Nektar::MultiRegions::ExpListHomogeneous1D.

Definition at line 2054 of file ExpList.cpp.

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

Referenced by SetHomoLen(), and v_GetNumElmts().

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

◆ v_SetUpPhysNormals()

void Nektar::MultiRegions::ExpList::v_SetUpPhysNormals ( )

protectedvirtual

Reimplemented in Nektar::MultiRegions::ExpList1D, Nektar::MultiRegions::ExpList2D, and Nektar::MultiRegions::ExpList3D.

Definition at line 3016 of file ExpList.cpp.

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

Referenced by SetUpPhysNormals(), and v_GetNumElmts().

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

◆ 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::ContField2D, and Nektar::MultiRegions::ContField3DHomogeneous1D.

Definition at line 826 of file ExpList.cpp.

References ASSERTL0, Nektar::LibUtilities::eGauss_Lagrange, Nektar::LibUtilities::eGLL_Lagrange, and m_exp.

Referenced by SmoothField(), and v_GetNumElmts().

         {
             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.");
         }

◆ v_UpdateBndCondExpansion()

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

protectedvirtual

Reimplemented in Nektar::MultiRegions::DisContField3DHomogeneous1D, Nektar::MultiRegions::DisContField2D, Nektar::MultiRegions::DisContField3D, Nektar::MultiRegions::DisContField1D, and Nektar::MultiRegions::DisContField3DHomogeneous2D.

Definition at line 2559 of file ExpList.cpp.

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

Referenced by UpdateBndCondExpansion(), and v_GetNumElmts().

         {
             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;
         }

◆ v_UpdateBndConditions()

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

privatevirtual

Reimplemented in Nektar::MultiRegions::DisContField3DHomogeneous1D, Nektar::MultiRegions::DisContField2D, Nektar::MultiRegions::DisContField3D, Nektar::MultiRegions::DisContField1D, and Nektar::MultiRegions::DisContField3DHomogeneous2D.

Definition at line 3227 of file ExpList.cpp.

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

Referenced by UpdateBndConditions(), and v_GetNumElmts().

         {
             NEKERROR(ErrorUtil::efatal,
                      "This method is not defined or valid for this class type");
             static Array<OneD, SpatialDomains::BoundaryConditionShPtr> result;
             return result;
         }

◆ 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

Reimplemented in Nektar::MultiRegions::ExpList1D.

Definition at line 2568 of file ExpList.cpp.

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

Referenced by Upwind(), and v_GetNumElmts().

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

◆ 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

Reimplemented in Nektar::MultiRegions::ExpList1D, Nektar::MultiRegions::ExpList2D, and Nektar::MultiRegions::ExpList0D.

Definition at line 2579 of file ExpList.cpp.

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

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

◆ v_VectorFlux()

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

protectedvirtual

Definition at line 2011 of file ExpList.cpp.

References m_phys_offset.

Referenced by v_GetNumElmts(), and VectorFlux().

         {
             NekDouble flux = 0.0;
             int       i    = 0;
             int       j;
 
             for (i = 0; i < (*m_exp).size(); ++i)
             {
                 Array<OneD, Array<OneD, NekDouble> > tmp(inarray.num_elements());
                 for (j = 0; j < inarray.num_elements(); ++j)
                 {
                     tmp[j] = Array<OneD, NekDouble>(inarray[j] + m_phys_offset[i]);
                 }
                 flux += (*m_exp)[i]->VectorFlux(tmp);
             }
 
             return flux;
         }

◆ v_WriteTecplotConnectivity()

void Nektar::MultiRegions::ExpList::v_WriteTecplotConnectivity	(	std::ostream &	outfile,
		int	expansion
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::ExpList3DHomogeneous1D.

Definition at line 1752 of file ExpList.cpp.

References ASSERTL0, and m_exp.

Referenced by v_GetNumElmts(), and WriteTecplotConnectivity().

         {
             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
             {
                 ASSERTL0(false,"Not set up for this dimension");
             }
         }

◆ 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 1829 of file ExpList.cpp.

References BwdTrans(), GetTotPoints(), m_coeffs, m_phys, m_phys_offset, and m_physState.

Referenced by v_GetNumElmts(), and WriteTecplotField().

         {
             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;
             }
         }

◆ 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 1619 of file ExpList.cpp.

References Nektar::MultiRegions::e3DH1D, Nektar::MultiRegions::e3DH2D, GetExp(), GetNumElmts(), and m_expType.

Referenced by v_GetNumElmts(), and WriteTecplotHeader().

         {
             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;
         }

◆ 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::ExpList2DHomogeneous1D, and Nektar::MultiRegions::ExpList1DHomogeneous2D.

Definition at line 1658 of file ExpList.cpp.

References ASSERTL0, Nektar::MultiRegions::e3DH1D, Nektar::MultiRegions::e3DH2D, GetCoordim(), GetCoords(), GetTotPoints(), GetZIDs(), m_exp, and m_expType.

Referenced by v_GetNumElmts(), and WriteTecplotZone().

         {
             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().num_elements();
                 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:
                     ASSERTL0(false,"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;
             }
         }

◆ v_WriteVtkPieceData()

void Nektar::MultiRegions::ExpList::v_WriteVtkPieceData	(	std::ostream &	outfile,
		int	expansion,
		std::string	var
	)

protectedvirtual

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

Definition at line 1891 of file ExpList.cpp.

References Nektar::NekConstants::kNekZeroTol, m_phys, and m_phys_offset.

Referenced by v_GetNumElmts(), and WriteVtkPieceData().

         {
             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;
         }

◆ v_WriteVtkPieceHeader()

void Nektar::MultiRegions::ExpList::v_WriteVtkPieceHeader	(	std::ostream &	outfile,
		int	expansion,
		int	istrip
	)

protectedvirtual

Reimplemented in Nektar::MultiRegions::ExpList1D, Nektar::MultiRegions::ExpList2D, Nektar::MultiRegions::ExpList3DHomogeneous1D, Nektar::MultiRegions::ExpList3DHomogeneous2D, Nektar::MultiRegions::ExpList2DHomogeneous1D, Nektar::MultiRegions::ExpList1DHomogeneous2D, and Nektar::MultiRegions::ExpList3D.

Definition at line 1877 of file ExpList.cpp.

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

Referenced by v_GetNumElmts(), and WriteVtkPieceHeader().

         {
             boost::ignore_unused(outfile, expansion, istrip);
             NEKERROR(ErrorUtil::efatal,
                      "Routine not implemented for this expansion.");
         }

◆ VectorFlux()

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

inline

Definition at line 566 of file ExpList.h.

References v_VectorFlux().

             {
                 return v_VectorFlux(inarray);
             }

◆ WriteTecplotConnectivity()

void Nektar::MultiRegions::ExpList::WriteTecplotConnectivity	(	std::ostream &	outfile,
		int	expansion = `-1`
	)

inline

Definition at line 417 of file ExpList.h.

References MULTI_REGIONS_EXPORT, v_WriteTecplotConnectivity(), WriteVtkFooter(), and WriteVtkHeader().

             {
                 v_WriteTecplotConnectivity(outfile, expansion);
             }

◆ WriteTecplotField()

void Nektar::MultiRegions::ExpList::WriteTecplotField	(	std::ostream &	outfile,
		int	expansion = `-1`
	)

inline

Definition at line 411 of file ExpList.h.

References v_WriteTecplotField().

             {
                 v_WriteTecplotField(outfile, expansion);
             }

◆ WriteTecplotHeader()

void Nektar::MultiRegions::ExpList::WriteTecplotHeader	(	std::ostream &	outfile,
		std::string	var = `""`
	)

inline

Definition at line 398 of file ExpList.h.

References v_WriteTecplotHeader().

             {
                 v_WriteTecplotHeader(outfile, var);
             }

◆ WriteTecplotZone()

void Nektar::MultiRegions::ExpList::WriteTecplotZone	(	std::ostream &	outfile,
		int	expansion = `-1`
	)

inline

Definition at line 404 of file ExpList.h.

References v_WriteTecplotZone().

             {
                 v_WriteTecplotZone(outfile, expansion);
             }

◆ WriteVtkFooter()

void Nektar::MultiRegions::ExpList::WriteVtkFooter ( std::ostream & outfile )

Definition at line 1871 of file ExpList.cpp.

Referenced by WriteTecplotConnectivity().

         {
             outfile << "  </UnstructuredGrid>" << endl;
             outfile << "</VTKFile>" << endl;
         }

◆ WriteVtkHeader()

void Nektar::MultiRegions::ExpList::WriteVtkHeader ( std::ostream & outfile )

Definition at line 1863 of file ExpList.cpp.

Referenced by WriteTecplotConnectivity().

         {
             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 436 of file ExpList.h.

References FillBndCondFromField(), GetCoeff(), GetCoeffs(), GetCoordim(), GetPhys(), GetShapeDimension(), GlobalToLocal(), ImposeDirichletConditions(), Linf(), LocalToGlobal(), MULTI_REGIONS_EXPORT, Nektar::NullNekDouble1DArray, SetCoeff(), SetCoeffs(), SetCoeffsArray(), and v_WriteVtkPieceData().

             {
                 v_WriteVtkPieceData(outfile, expansion, var);
             }

◆ WriteVtkPieceFooter()

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

Definition at line 1884 of file ExpList.cpp.

Referenced by WriteVtkPieceHeader().

         {
             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 426 of file ExpList.h.

References MULTI_REGIONS_EXPORT, v_WriteVtkPieceHeader(), and WriteVtkPieceFooter().

             {
                 v_WriteVtkPieceHeader(outfile, expansion, istrip);
             }

Member Data Documentation

◆ m_blockMat

BlockMatrixMapShPtr Nektar::MultiRegions::ExpList::m_blockMat

protected

Definition at line 1108 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 1101 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 1052 of file ExpList.h.

◆ 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 1095 of file ExpList.h.

Referenced by CreateCollections(), IProductWRTDerivBase(), v_BwdTrans_IterPerExp(), v_IProductWRTBase(), and v_IProductWRTBase_IterPerExp().

◆ 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 1098 of file ExpList.h.

Referenced by CreateCollections(), IProductWRTDerivBase(), v_BwdTrans_IterPerExp(), v_IProductWRTBase(), v_IProductWRTBase_IterPerExp(), and v_PhysDeriv().

◆ m_collections

Collections::CollectionVector Nektar::MultiRegions::ExpList::m_collections

protected

Definition at line 1092 of file ExpList.h.

Referenced by CreateCollections(), IProductWRTDerivBase(), v_BwdTrans_IterPerExp(), v_IProductWRTBase(), v_IProductWRTBase_IterPerExp(), and v_PhysDeriv().

◆ m_comm

LibUtilities::CommSharedPtr Nektar::MultiRegions::ExpList::m_comm

protected

Communicator.

Definition at line 1020 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 1116 of file ExpList.h.

Referenced by GetExpIndex(), Nektar::MultiRegions::ExpListHomogeneous1D::v_AppendFieldData(), Nektar::MultiRegions::ExpListHomogeneous1D::v_ExtractDataToCoeffs(), and 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 1090 of file ExpList.h.

◆ m_expType

ExpansionType Nektar::MultiRegions::ExpList::m_expType

Definition at line 1002 of file ExpList.h.

Referenced by GetExpType(), SetExpType(), v_WriteTecplotHeader(), and v_WriteTecplotZone().

◆ m_globalOptParam

NekOptimize::GlobalOptParamSharedPtr Nektar::MultiRegions::ExpList::m_globalOptParam

protected

Definition at line 1106 of file ExpList.h.

◆ m_graph

SpatialDomains::MeshGraphSharedPtr Nektar::MultiRegions::ExpList::m_graph

protected

Mesh associated with this expansion list.

Definition at line 1026 of file ExpList.h.

◆ 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 1030 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 1035 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 1069 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 1104 of file ExpList.h.

◆ 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 1078 of file ExpList.h.

Referenced by Nektar::MultiRegions::ExpList2D::ExpList2D(), GetPhysState(), PhysIntegral(), SetPhys(), SetPhysState(), UpdatePhys(), Nektar::MultiRegions::DisContField3D::v_ExtractTracePhys(), Nektar::MultiRegions::DisContField1D::v_ExtractTracePhys(), Nektar::MultiRegions::DisContField2D::v_ExtractTracePhys(), Nektar::MultiRegions::DisContField3DHomogeneous1D::v_ExtractTracePhys(), and v_WriteTecplotField().

◆ m_session

LibUtilities::SessionReaderSharedPtr Nektar::MultiRegions::ExpList::m_session

protected

Session.

Definition at line 1023 of file ExpList.h.

◆ m_WaveSpace

bool Nektar::MultiRegions::ExpList::m_WaveSpace

protected

Definition at line 1113 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}\).

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

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

Public Attributes

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Private Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ ExpList() [1/5]

◆ ExpList() [2/5]

◆ ExpList() [3/5]

◆ ExpList() [4/5]

◆ ExpList() [5/5]

◆ ~ExpList()

Member Function Documentation

◆ AddFwdBwdTraceIntegral()

◆ AddTraceIntegral() [1/2]

◆ AddTraceIntegral() [2/2]

◆ AppendFieldData() [1/2]

◆ AppendFieldData() [2/2]

◆ ApplyGeomInfo()

◆ BwdTrans()

◆ BwdTrans_IterPerExp()

◆ ClearGlobalLinSysManager()

◆ CreateCollections()

◆ CurlCurl()

◆ DealiasedDotProd()

◆ DealiasedProd()

◆ EvalBasisNumModesMax()

◆ EvalBasisNumModesMaxPerExp()

◆ EvaluateBoundaryConditions()

◆ ExponentialFilter()

◆ ExtractCoeffsToCoeffs()

◆ ExtractDataToCoeffs()

◆ ExtractElmtDataToCoeffs()

◆ ExtractElmtToBndPhys()

◆ ExtractFileBCs()

◆ ExtractPhysToBnd()

◆ ExtractPhysToBndElmt()

◆ ExtractTracePhys() [1/2]

◆ ExtractTracePhys() [2/2]

◆ FillBndCondFromField() [1/2]

◆ FillBndCondFromField() [2/2]

◆ FwdTrans()

◆ FwdTrans_BndConstrained()

◆ FwdTrans_IterPerExp()

◆ GenBlockMatrix()

◆ GeneralGetFieldDefinitions()

◆ GeneralMatrixOp()

◆ GeneralMatrixOp_IterPerExp()

◆ GenerateElementVector()

◆ GenGlobalBndLinSys()

◆ GenGlobalLinSys()

◆ GenGlobalMatrix()

◆ GenGlobalMatrixFull()

◆ Get1DScaledTotPoints()

◆ GetBCValues()

◆ GetBlockMatrix()

◆ GetBndCondExpansions()

◆ GetBndConditions()

◆ GetBndElmtExpansion()

◆ GetBoundaryCondition()

◆ GetBoundaryNormals()

◆ GetBoundaryToElmtMap()

◆ GetCoeff()

◆ GetCoeff_Offset()

◆ GetCoeffs() [1/2]

◆ GetCoeffs() [2/2]

◆ GetComm()

◆ GetCoordim()

◆ GetCoords()

◆ GetExp() [1/3]

◆ GetExp() [2/3]

◆ GetExp() [3/3]

◆ GetExpIndex() [1/2]

◆ GetExpIndex() [2/2]

◆ GetExpSize()

◆ GetExpType()

◆ GetFieldDefinitions() [1/2]

◆ GetFieldDefinitions() [2/2]