Nektar::CFSImplicit Class Reference

#include <CompressibleFlowSystemImplicit.h>

Inheritance diagram for Nektar::CFSImplicit:

Public Member Functions
	CFSImplicit (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
	~CFSImplicit () override=default
Public Member Functions inherited from Nektar::CompressibleFlowSystem
NekDouble	GetStabilityLimit (int n)
	Function to calculate the stability limit for DG/CG.
Array< OneD, NekDouble >	GetStabilityLimitVector (const Array< OneD, int > &ExpOrder)
	Function to calculate the stability limit for DG/CG (a vector of them).
Public Member Functions inherited from Nektar::SolverUtils::AdvectionSystem
SOLVER_UTILS_EXPORT	AdvectionSystem (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
SOLVER_UTILS_EXPORT	~AdvectionSystem () override=default
SOLVER_UTILS_EXPORT AdvectionSharedPtr	GetAdvObject ()
	Returns the advection object held by this instance.
SOLVER_UTILS_EXPORT Array< OneD, NekDouble >	GetElmtCFLVals (const bool FlagAcousticCFL=true)
SOLVER_UTILS_EXPORT NekDouble	GetCFLEstimate (int &elmtid)
Public Member Functions inherited from Nektar::SolverUtils::UnsteadySystem
SOLVER_UTILS_EXPORT	~UnsteadySystem () override=default
	Destructor.
SOLVER_UTILS_EXPORT NekDouble	GetTimeStep (const Array< OneD, const Array< OneD, NekDouble > > &inarray)
	Calculate the larger time-step mantaining the problem stable.
SOLVER_UTILS_EXPORT NekDouble	GetTimeStep ()
SOLVER_UTILS_EXPORT void	SetTimeStep (const NekDouble timestep)
SOLVER_UTILS_EXPORT void	SteadyStateResidual (int step, Array< OneD, NekDouble > &L2)
SOLVER_UTILS_EXPORT LibUtilities::TimeIntegrationSchemeSharedPtr &	GetTimeIntegrationScheme ()
	Returns the time integration scheme.
SOLVER_UTILS_EXPORT LibUtilities::TimeIntegrationSchemeOperators &	GetTimeIntegrationSchemeOperators ()
	Returns the time integration scheme operators.
Public Member Functions inherited from Nektar::SolverUtils::EquationSystem
virtual SOLVER_UTILS_EXPORT	~EquationSystem ()
	Destructor.
SOLVER_UTILS_EXPORT void	InitObject (bool DeclareField=true)
	Initialises the members of this object.
SOLVER_UTILS_EXPORT void	DoInitialise (bool dumpInitialConditions=true)
	Perform any initialisation necessary before solving the problem.
SOLVER_UTILS_EXPORT void	DoSolve ()
	Solve the problem.
SOLVER_UTILS_EXPORT void	TransCoeffToPhys ()
	Transform from coefficient to physical space.
SOLVER_UTILS_EXPORT void	TransPhysToCoeff ()
	Transform from physical to coefficient space.
SOLVER_UTILS_EXPORT void	Output ()
	Perform output operations after solve.
SOLVER_UTILS_EXPORT std::string	GetSessionName ()
	Get Session name.
template<class T >
std::shared_ptr< T >	as ()
SOLVER_UTILS_EXPORT void	ResetSessionName (std::string newname)
	Reset Session name.
SOLVER_UTILS_EXPORT LibUtilities::SessionReaderSharedPtr	GetSession ()
	Get Session name.
SOLVER_UTILS_EXPORT MultiRegions::ExpListSharedPtr	GetPressure ()
	Get pressure field if available.
SOLVER_UTILS_EXPORT void	ExtraFldOutput (std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)
SOLVER_UTILS_EXPORT void	PrintSummary (std::ostream &out)
	Print a summary of parameters and solver characteristics.
SOLVER_UTILS_EXPORT void	SetLambda (NekDouble lambda)
	Set parameter m_lambda.
SOLVER_UTILS_EXPORT SessionFunctionSharedPtr	GetFunction (std::string name, const MultiRegions::ExpListSharedPtr &field=MultiRegions::NullExpListSharedPtr, bool cache=false)
	Get a SessionFunction by name.
SOLVER_UTILS_EXPORT void	SetInitialConditions (NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0)
	Initialise the data in the dependent fields.
SOLVER_UTILS_EXPORT void	EvaluateExactSolution (int field, Array< OneD, NekDouble > &outfield, const NekDouble time)
	Evaluates an exact solution.
SOLVER_UTILS_EXPORT NekDouble	L2Error (unsigned int field, const Array< OneD, NekDouble > &exactsoln, bool Normalised=false)
	Compute the L2 error between fields and a given exact solution.
SOLVER_UTILS_EXPORT NekDouble	L2Error (unsigned int field, bool Normalised=false)
	Compute the L2 error of the fields.
SOLVER_UTILS_EXPORT NekDouble	LinfError (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray)
	Linf error computation.
SOLVER_UTILS_EXPORT NekDouble	H1Error (unsigned int field, const Array< OneD, NekDouble > &exactsoln, bool Normalised=false)
	Compute the H1 error between fields and a given exact solution.
SOLVER_UTILS_EXPORT Array< OneD, NekDouble >	ErrorExtraPoints (unsigned int field)
	Compute error (L2 and L_inf) over an larger set of quadrature points return [L2 Linf].
SOLVER_UTILS_EXPORT void	Checkpoint_Output (const int n)
	Write checkpoint file of m_fields.
SOLVER_UTILS_EXPORT void	Checkpoint_Output (const int n, MultiRegions::ExpListSharedPtr &field, std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)
	Write checkpoint file of custom data fields.
SOLVER_UTILS_EXPORT void	Checkpoint_BaseFlow (const int n)
	Write base flow file of m_fields.
SOLVER_UTILS_EXPORT void	WriteFld (const std::string &outname)
	Write field data to the given filename.
SOLVER_UTILS_EXPORT void	WriteFld (const std::string &outname, MultiRegions::ExpListSharedPtr &field, std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)
	Write input fields to the given filename.
SOLVER_UTILS_EXPORT void	ImportFld (const std::string &infile, Array< OneD, MultiRegions::ExpListSharedPtr > &pFields)
	Input field data from the given file.
SOLVER_UTILS_EXPORT void	ImportFldToMultiDomains (const std::string &infile, Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const int ndomains)
	Input field data from the given file to multiple domains.
SOLVER_UTILS_EXPORT void	ImportFld (const std::string &infile, std::vector< std::string > &fieldStr, Array< OneD, Array< OneD, NekDouble > > &coeffs)
	Output a field. Input field data into array from the given file.
SOLVER_UTILS_EXPORT void	ImportFld (const std::string &infile, MultiRegions::ExpListSharedPtr &pField, std::string &pFieldName)
	Output a field. Input field data into ExpList from the given file.
SOLVER_UTILS_EXPORT void	SessionSummary (SummaryList &vSummary)
	Write out a session summary.
SOLVER_UTILS_EXPORT Array< OneD, MultiRegions::ExpListSharedPtr > &	UpdateFields ()
SOLVER_UTILS_EXPORT LibUtilities::FieldMetaDataMap &	UpdateFieldMetaDataMap ()
	Get hold of FieldInfoMap so it can be updated.
SOLVER_UTILS_EXPORT NekDouble	GetTime ()
	Return final time.
SOLVER_UTILS_EXPORT int	GetNcoeffs ()
SOLVER_UTILS_EXPORT int	GetNcoeffs (const int eid)
SOLVER_UTILS_EXPORT int	GetNumExpModes ()
SOLVER_UTILS_EXPORT const Array< OneD, int >	GetNumExpModesPerExp ()
SOLVER_UTILS_EXPORT int	GetNvariables ()
SOLVER_UTILS_EXPORT const std::string	GetVariable (unsigned int i)
SOLVER_UTILS_EXPORT int	GetTraceTotPoints ()
SOLVER_UTILS_EXPORT int	GetTraceNpoints ()
SOLVER_UTILS_EXPORT int	GetExpSize ()
SOLVER_UTILS_EXPORT int	GetPhys_Offset (int n)
SOLVER_UTILS_EXPORT int	GetCoeff_Offset (int n)
SOLVER_UTILS_EXPORT int	GetTotPoints ()
SOLVER_UTILS_EXPORT int	GetTotPoints (int n)
SOLVER_UTILS_EXPORT int	GetNpoints ()
SOLVER_UTILS_EXPORT int	GetSteps ()
SOLVER_UTILS_EXPORT void	SetSteps (const int steps)
SOLVER_UTILS_EXPORT NekDouble	GetTimeStep ()
SOLVER_UTILS_EXPORT void	CopyFromPhysField (const int i, Array< OneD, NekDouble > &output)
SOLVER_UTILS_EXPORT void	CopyToPhysField (const int i, const Array< OneD, const NekDouble > &input)
SOLVER_UTILS_EXPORT Array< OneD, NekDouble > &	UpdatePhysField (const int i)
SOLVER_UTILS_EXPORT void	ZeroPhysFields ()
SOLVER_UTILS_EXPORT void	FwdTransFields ()
SOLVER_UTILS_EXPORT void	SetModifiedBasis (const bool modbasis)
SOLVER_UTILS_EXPORT int	GetCheckpointNumber ()
SOLVER_UTILS_EXPORT void	SetCheckpointNumber (int num)
SOLVER_UTILS_EXPORT int	GetCheckpointSteps ()
SOLVER_UTILS_EXPORT void	SetCheckpointSteps (int num)
SOLVER_UTILS_EXPORT int	GetInfoSteps ()
SOLVER_UTILS_EXPORT void	SetInfoSteps (int num)
SOLVER_UTILS_EXPORT void	SetIterationNumberPIT (int num)
SOLVER_UTILS_EXPORT void	SetWindowNumberPIT (int num)
SOLVER_UTILS_EXPORT Array< OneD, const Array< OneD, NekDouble > >	GetTraceNormals ()
SOLVER_UTILS_EXPORT void	SetTime (const NekDouble time)
SOLVER_UTILS_EXPORT void	SetTimeStep (const NekDouble timestep)
SOLVER_UTILS_EXPORT void	SetInitialStep (const int step)
SOLVER_UTILS_EXPORT void	SetBoundaryConditions (NekDouble time)
	Evaluates the boundary conditions at the given time.
SOLVER_UTILS_EXPORT bool	NegatedOp ()
	Identify if operator is negated in DoSolve.
Public Member Functions inherited from Nektar::SolverUtils::ALEHelper
virtual	~ALEHelper ()=default
SOLVER_UTILS_EXPORT void	InitObject (int spaceDim, Array< OneD, MultiRegions::ExpListSharedPtr > &fields)
virtual SOLVER_UTILS_EXPORT void	v_UpdateGridVelocity (const NekDouble &time)
virtual SOLVER_UTILS_EXPORT void	v_ALEPreMultiplyMass (Array< OneD, Array< OneD, NekDouble > > &fields)
SOLVER_UTILS_EXPORT void	ALEDoElmtInvMass (Array< OneD, Array< OneD, NekDouble > > &traceNormals, Array< OneD, Array< OneD, NekDouble > > &fields, NekDouble time)
	Update m_fields with u^n by multiplying by inverse mass matrix. That's then used in e.g. checkpoint output and L^2 error calculation.
SOLVER_UTILS_EXPORT void	ALEDoElmtInvMassBwdTrans (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)
SOLVER_UTILS_EXPORT void	MoveMesh (const NekDouble &time, Array< OneD, Array< OneD, NekDouble > > &traceNormals)
SOLVER_UTILS_EXPORT void	ResetMatricesNormal (Array< OneD, Array< OneD, NekDouble > > &traceNormals)
SOLVER_UTILS_EXPORT void	UpdateNormalsFlag ()
const Array< OneD, const Array< OneD, NekDouble > > &	GetGridVelocity ()
bool &	GetUpdateNormalsFlag ()
SOLVER_UTILS_EXPORT const Array< OneD, const Array< OneD, NekDouble > > &	GetGridVelocityTrace ()
SOLVER_UTILS_EXPORT void	ExtraFldOutputGridVelocity (std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)
SOLVER_UTILS_EXPORT void	ExtraFldOutputGrid (std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)
Public Member Functions inherited from Nektar::SolverUtils::FluidInterface
virtual	~FluidInterface ()=default
SOLVER_UTILS_EXPORT void	GetVelocity (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &velocity)
	Extract array with velocity from physfield.
SOLVER_UTILS_EXPORT bool	HasConstantDensity ()
SOLVER_UTILS_EXPORT void	GetDensity (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &density)
	Extract array with density from physfield.
SOLVER_UTILS_EXPORT void	GetPressure (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &pressure)
	Extract array with pressure from physfield.
SOLVER_UTILS_EXPORT void	SetMovingFrameVelocities (const Array< OneD, NekDouble > &vFrameVels, const int step)
SOLVER_UTILS_EXPORT bool	GetMovingFrameVelocities (Array< OneD, NekDouble > &vFrameVels, const int step)
SOLVER_UTILS_EXPORT void	SetMovingFrameDisp (const Array< OneD, NekDouble > &vFrameDisp, const int step)
SOLVER_UTILS_EXPORT void	SetMovingFramePivot (const Array< OneD, NekDouble > &vFramePivot)
SOLVER_UTILS_EXPORT bool	GetMovingFrameDisp (Array< OneD, NekDouble > &vFrameDisp, const int step)
SOLVER_UTILS_EXPORT void	SetAeroForce (Array< OneD, NekDouble > forces)
	Set aerodynamic force and moment.
SOLVER_UTILS_EXPORT void	GetAeroForce (Array< OneD, NekDouble > forces)
	Get aerodynamic force and moment.

Protected Member Functions
void	v_InitObject (bool DeclareFields=true) override
	Initialization object for CFSImplicit class.
void	InitialiseNonlinSysSolver ()
void	v_DoSolve () override
	Virtual function for solve implementation.
void	v_PrintStatusInformation (const int step, const NekDouble cpuTime) override
	Print Status Information.
void	v_PrintSummaryStatistics (const NekDouble intTime) override
	Print Summary Statistics.
void	v_ALEInitObject (int spaceDim, Array< OneD, MultiRegions::ExpListSharedPtr > &fields) override
void	NonlinSysEvaluatorCoeff1D (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out, const bool &flag)
void	NonlinSysEvaluatorCoeff (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &out, const bool &flag)
void	DoOdeImplicitRhs (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
void	DoOdeRhsCoeff (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
	Compute the right-hand side.
void	DoAdvectionCoeff (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time, const Array< OneD, const Array< OneD, NekDouble > > &pFwd, const Array< OneD, const Array< OneD, NekDouble > > &pBwd)
	Compute the advection terms for the right-hand side.
void	DoDiffusionCoeff (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const Array< OneD, const Array< OneD, NekDouble > > &pFwd, const Array< OneD, const Array< OneD, NekDouble > > &pBwd)
	Add the diffusions terms to the right-hand side Similar to DoDiffusion() but with outarray in coefficient space.
void	DoImplicitSolve (const Array< OneD, const Array< OneD, NekDouble > > &inpnts, Array< OneD, Array< OneD, NekDouble > > &outpnt, const NekDouble time, const NekDouble lambda)
void	DoImplicitSolveCoeff (const Array< OneD, const Array< OneD, NekDouble > > &inpnts, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out, const NekDouble time, const NekDouble lambda)
void	MatrixMultiplyMatrixFreeCoeff (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out, const bool &centralDifferenceFlag)
void	CalcRefValues (const Array< OneD, const NekDouble > &inarray)
void	PreconCoeff (const Array< OneD, NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const bool &flag)
template<typename DataType , typename TypeNekBlkMatSharedPtr >
void	AddMatNSBlkDiagVol (const Array< OneD, const Array< OneD, NekDouble > > &inarray, const Array< OneD, const TensorOfArray2D< NekDouble > > &qfield, Array< OneD, Array< OneD, TypeNekBlkMatSharedPtr > > &gmtxarray, TensorOfArray4D< DataType > &StdMatDataDBB, TensorOfArray5D< DataType > &StdMatDataDBDB)
template<typename DataType >
void	CalcVolJacStdMat (TensorOfArray4D< DataType > &StdMatDataDBB, TensorOfArray5D< DataType > &StdMatDataDBDB)
template<typename DataType , typename TypeNekBlkMatSharedPtr >
void	AddMatNSBlkDiagBnd (const Array< OneD, const Array< OneD, NekDouble > > &inarray, TensorOfArray3D< NekDouble > &qfield, TensorOfArray2D< TypeNekBlkMatSharedPtr > &gmtxarray, Array< OneD, TypeNekBlkMatSharedPtr > &TraceJac, Array< OneD, TypeNekBlkMatSharedPtr > &TraceJacDeriv, Array< OneD, Array< OneD, DataType > > &TraceJacDerivSign, TensorOfArray5D< DataType > &TraceIPSymJacArray)
template<typename DataType , typename TypeNekBlkMatSharedPtr >
void	ElmtVarInvMtrx (Array< OneD, Array< OneD, TypeNekBlkMatSharedPtr > > &gmtxarray, TypeNekBlkMatSharedPtr &gmtVar, const DataType &tmpDatatype)
template<typename DataType , typename TypeNekBlkMatSharedPtr >
void	GetTraceJac (const Array< OneD, const Array< OneD, NekDouble > > &inarray, TensorOfArray3D< NekDouble > &qfield, Array< OneD, TypeNekBlkMatSharedPtr > &TraceJac, Array< OneD, TypeNekBlkMatSharedPtr > &TraceJacDeriv, Array< OneD, Array< OneD, DataType > > &TraceJacDerivSign, TensorOfArray5D< DataType > &TraceIPSymJacArray)
template<typename DataType , typename TypeNekBlkMatSharedPtr >
void	NumCalcRiemFluxJac (const int nConvectiveFields, const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, const Array< OneD, NekDouble > > &AdvVel, const Array< OneD, const Array< OneD, NekDouble > > &inarray, TensorOfArray3D< NekDouble > &qfield, const NekDouble &time, const Array< OneD, const Array< OneD, NekDouble > > &Fwd, const Array< OneD, const Array< OneD, NekDouble > > &Bwd, TypeNekBlkMatSharedPtr &FJac, TypeNekBlkMatSharedPtr &BJac, TensorOfArray5D< DataType > &TraceIPSymJacArray)
void	PointFluxJacobianPoint (const Array< OneD, NekDouble > &Fwd, const Array< OneD, NekDouble > &normals, DNekMatSharedPtr &FJac, const NekDouble efix, const NekDouble fsw)
template<typename DataType , typename TypeNekBlkMatSharedPtr >
void	TranSamesizeBlkDiagMatIntoArray (const TypeNekBlkMatSharedPtr &BlkMat, TensorOfArray3D< DataType > &MatArray)
template<typename DataType , typename TypeNekBlkMatSharedPtr >
void	TransTraceJacMatToArray (const Array< OneD, TypeNekBlkMatSharedPtr > &TraceJac, TensorOfArray4D< DataType > &TraceJacDerivArray)
template<typename DataType , typename TypeNekBlkMatSharedPtr >
void	Fill2DArrayOfBlkDiagonalMat (Array< OneD, Array< OneD, TypeNekBlkMatSharedPtr > > &gmtxarray, const DataType valu)
template<typename DataType , typename TypeNekBlkMatSharedPtr >
void	Fill1DArrayOfBlkDiagonalMat (Array< OneD, TypeNekBlkMatSharedPtr > &gmtxarray, const DataType valu)
void	AllocateNekBlkMatDig (SNekBlkMatSharedPtr &mat, const Array< OneD, unsigned int > nrow, const Array< OneD, unsigned int > ncol)
void	CalcPreconMatBRJCoeff (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, SNekBlkMatSharedPtr > > &gmtxarray, SNekBlkMatSharedPtr &gmtVar, Array< OneD, SNekBlkMatSharedPtr > &TraceJac, Array< OneD, SNekBlkMatSharedPtr > &TraceJacDeriv, Array< OneD, Array< OneD, NekSingle > > &TraceJacDerivSign, TensorOfArray4D< NekSingle > &TraceJacArray, TensorOfArray4D< NekSingle > &TraceJacDerivArray, TensorOfArray5D< NekSingle > &TraceIPSymJacArray)
template<typename DataType , typename TypeNekBlkMatSharedPtr >
void	MultiplyElmtInvMassPlusSource (Array< OneD, Array< OneD, TypeNekBlkMatSharedPtr > > &gmtxarray, const NekDouble dtlamda)
void	GetFluxVectorJacDirElmt (const int nConvectiveFields, const int nElmtPnt, const Array< OneD, const Array< OneD, NekDouble > > &locVars, const Array< OneD, NekDouble > &normals, DNekMatSharedPtr &wspMat, Array< OneD, Array< OneD, NekDouble > > &PntJacArray)
void	GetFluxVectorJacPoint (const int nConvectiveFields, const Array< OneD, NekDouble > &conservVar, const Array< OneD, NekDouble > &normals, DNekMatSharedPtr &fluxJac)
void	CalcTraceNumericalFlux (const int nConvectiveFields, const int nDim, const int nPts, const int nTracePts, const NekDouble PenaltyFactor2, const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, const Array< OneD, NekDouble > > &AdvVel, const Array< OneD, const Array< OneD, NekDouble > > &inarray, const NekDouble time, TensorOfArray3D< NekDouble > &qfield, const Array< OneD, const Array< OneD, NekDouble > > &vFwd, const Array< OneD, const Array< OneD, NekDouble > > &vBwd, const Array< OneD, const TensorOfArray2D< NekDouble > > &qFwd, const Array< OneD, const TensorOfArray2D< NekDouble > > &qBwd, const Array< OneD, NekDouble > &MuVarTrace, Array< OneD, int > &nonZeroIndex, Array< OneD, Array< OneD, NekDouble > > &traceflux)
void	MinusDiffusionFluxJacPoint (const int nConvectiveFields, const int nElmtPnt, const Array< OneD, const Array< OneD, NekDouble > > &locVars, const TensorOfArray3D< NekDouble > &locDerv, const Array< OneD, NekDouble > &locmu, const Array< OneD, NekDouble > &locDmuDT, const Array< OneD, NekDouble > &normals, DNekMatSharedPtr &wspMat, Array< OneD, Array< OneD, NekDouble > > &PntJacArray)
void	GetFluxDerivJacDirctn (const MultiRegions::ExpListSharedPtr &explist, const Array< OneD, const Array< OneD, NekDouble > > &normals, const int nDervDir, const Array< OneD, const Array< OneD, NekDouble > > &inarray, TensorOfArray5D< NekDouble > &ElmtJacArray, const int nFluxDir)
void	GetFluxDerivJacDirctnElmt (const int nConvectiveFields, const int nElmtPnt, const int nDervDir, const Array< OneD, const Array< OneD, NekDouble > > &locVars, const Array< OneD, NekDouble > &locmu, const Array< OneD, const Array< OneD, NekDouble > > &locnormal, DNekMatSharedPtr &wspMat, Array< OneD, Array< OneD, NekDouble > > &PntJacArray)
void	GetFluxDerivJacDirctn (const MultiRegions::ExpListSharedPtr &explist, const Array< OneD, const Array< OneD, NekDouble > > &normals, const int nDervDir, const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, DNekMatSharedPtr > > &ElmtJac)
void	CalcPhysDeriv (const Array< OneD, const Array< OneD, NekDouble > > &inarray, TensorOfArray3D< NekDouble > &qfield)
void	CalcMuDmuDT (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, NekDouble > &mu, Array< OneD, NekDouble > &DmuDT)
virtual void	v_DoDiffusionCoeff (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const Array< OneD, const Array< OneD, NekDouble > > &pFwd, const Array< OneD, const Array< OneD, NekDouble > > &pBwd)
virtual void	v_CalcMuDmuDT (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, NekDouble > &mu, Array< OneD, NekDouble > &DmuDT)
virtual void	v_CalcPhysDeriv (const Array< OneD, const Array< OneD, NekDouble > > &inarray, TensorOfArray3D< NekDouble > &qfield)
virtual void	v_MinusDiffusionFluxJacPoint (const int nConvectiveFields, const int nElmtPnt, const Array< OneD, const Array< OneD, NekDouble > > &locVars, const TensorOfArray3D< NekDouble > &locDerv, const Array< OneD, NekDouble > &locmu, const Array< OneD, NekDouble > &locDmuDT, const Array< OneD, NekDouble > &normals, DNekMatSharedPtr &wspMat, Array< OneD, Array< OneD, NekDouble > > &PntJacArray)
virtual void	v_GetFluxDerivJacDirctn (const MultiRegions::ExpListSharedPtr &explist, const Array< OneD, const Array< OneD, NekDouble > > &normals, const int nDervDir, const Array< OneD, const Array< OneD, NekDouble > > &inarray, TensorOfArray5D< NekDouble > &ElmtJacArray, const int nFluxDir)
virtual void	v_GetFluxDerivJacDirctnElmt (const int nConvectiveFields, const int nElmtPnt, const int nDervDir, const Array< OneD, const Array< OneD, NekDouble > > &locVars, const Array< OneD, NekDouble > &locmu, const Array< OneD, const Array< OneD, NekDouble > > &locnormal, DNekMatSharedPtr &wspMat, Array< OneD, Array< OneD, NekDouble > > &PntJacArray)
virtual void	v_GetFluxDerivJacDirctn (const MultiRegions::ExpListSharedPtr &explist, const Array< OneD, const Array< OneD, NekDouble > > &normals, const int nDervDir, const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, DNekMatSharedPtr > > &ElmtJac)
bool	v_UpdateTimeStepCheck () override
Protected Member Functions inherited from Nektar::CompressibleFlowSystem
	CompressibleFlowSystem (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
	~CompressibleFlowSystem () override=default
void	v_InitObject (bool DeclareFields=true) override
	Initialization object for CompressibleFlowSystem class.
void	v_GetPressure (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &pressure) override
void	v_GetDensity (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &density) override
bool	v_HasConstantDensity () override
void	v_GetVelocity (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &velocity) override
void	v_ALEInitObject (int spaceDim, Array< OneD, MultiRegions::ExpListSharedPtr > &fields) override
void	InitialiseParameters ()
	Load CFS parameters from the session file.
void	InitAdvection ()
	Create advection and diffusion objects for CFS.
void	DoOdeRhs (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
	Compute the right-hand side.
void	DoOdeProjection (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
	Compute the projection and call the method for imposing the boundary conditions in case of discontinuous projection.
void	DoAdvection (const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time, const Array< OneD, Array< OneD, NekDouble > > &pFwd, const Array< OneD, Array< OneD, NekDouble > > &pBwd)
	Compute the advection terms for the right-hand side.
void	DoDiffusion (const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const Array< OneD, Array< OneD, NekDouble > > &pFwd, const Array< OneD, Array< OneD, NekDouble > > &pBwd)
	Add the diffusions terms to the right-hand side.
void	GetFluxVector (const Array< OneD, const Array< OneD, NekDouble > > &physfield, TensorOfArray3D< NekDouble > &flux)
	Return the flux vector for the compressible Euler equations.
void	GetFluxVectorDeAlias (const Array< OneD, const Array< OneD, NekDouble > > &physfield, TensorOfArray3D< NekDouble > &flux)
	Return the flux vector for the compressible Euler equations by using the de-aliasing technique.
void	SetBoundaryConditions (Array< OneD, Array< OneD, NekDouble > > &physarray, NekDouble time)
void	SetBoundaryConditionsBwdWeight ()
	Set up a weight on physical boundaries for boundary condition applications.
void	GetElmtTimeStep (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, NekDouble > &tstep)
	Calculate the maximum timestep on each element subject to CFL restrictions.
NekDouble	v_GetTimeStep (const Array< OneD, const Array< OneD, NekDouble > > &inarray) override
	Calculate the maximum timestep subject to CFL restrictions.
void	v_GenerateSummary (SolverUtils::SummaryList &s) override
	Print a summary of time stepping parameters.
void	v_SetInitialConditions (NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0) override
	Set up logic for residual calculation.
void	v_EvaluateExactSolution (unsigned int field, Array< OneD, NekDouble > &outfield, const NekDouble time=0.0) override
NekDouble	GetGamma ()
const Array< OneD, const Array< OneD, NekDouble > > &	GetVecLocs ()
const Array< OneD, const Array< OneD, NekDouble > > &	GetNormals ()
MultiRegions::ExpListSharedPtr	v_GetPressure () override
void	v_ExtraFldOutput (std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables) override
virtual void	v_DoDiffusion (const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const Array< OneD, Array< OneD, NekDouble > > &pFwd, const Array< OneD, Array< OneD, NekDouble > > &pBwd)=0
Array< OneD, NekDouble >	v_GetMaxStdVelocity (const NekDouble SpeedSoundFactor) override
	Compute the advection velocity in the standard space for each element of the expansion.
void	v_SteadyStateResidual (int step, Array< OneD, NekDouble > &L2) override
virtual bool	v_SupportsShockCaptType (const std::string type) const =0
Protected Member Functions inherited from Nektar::SolverUtils::AdvectionSystem
SOLVER_UTILS_EXPORT bool	v_PostIntegrate (int step) override
Protected Member Functions inherited from Nektar::SolverUtils::UnsteadySystem
SOLVER_UTILS_EXPORT	UnsteadySystem (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
	Initialises UnsteadySystem class members.
SOLVER_UTILS_EXPORT void	v_InitObject (bool DeclareField=true) override
	Init object for UnsteadySystem class.
SOLVER_UTILS_EXPORT void	v_DoSolve () override
	Solves an unsteady problem.
SOLVER_UTILS_EXPORT void	v_DoInitialise (bool dumpInitialConditions=true) override
	Sets up initial conditions.
SOLVER_UTILS_EXPORT void	v_GenerateSummary (SummaryList &s) override
	Print a summary of time stepping parameters.
virtual SOLVER_UTILS_EXPORT bool	v_PreIntegrate (int step)
virtual SOLVER_UTILS_EXPORT bool	v_RequireFwdTrans ()
SOLVER_UTILS_EXPORT NekDouble	MaxTimeStepEstimator ()
	Get the maximum timestep estimator for cfl control.
SOLVER_UTILS_EXPORT void	CheckForRestartTime (NekDouble &time, int &nchk)
SOLVER_UTILS_EXPORT void	SVVVarDiffCoeff (const Array< OneD, Array< OneD, NekDouble > > vel, StdRegions::VarCoeffMap &varCoeffMap)
	Evaluate the SVV diffusion coefficient according to Moura's paper where it should proportional to h time velocity.
SOLVER_UTILS_EXPORT void	DoDummyProjection (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
	Perform dummy projection.
Protected Member Functions inherited from Nektar::SolverUtils::EquationSystem
SOLVER_UTILS_EXPORT	EquationSystem (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
	Initialises EquationSystem class members.
virtual SOLVER_UTILS_EXPORT NekDouble	v_LinfError (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray)
	Virtual function for the L_inf error computation between fields and a given exact solution.
virtual SOLVER_UTILS_EXPORT NekDouble	v_L2Error (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray, bool Normalised=false)
	Virtual function for the L_2 error computation between fields and a given exact solution.
virtual SOLVER_UTILS_EXPORT NekDouble	v_H1Error (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray, bool Normalised=false)
	Virtual function for the H_1 error computation between fields and a given exact solution.
virtual SOLVER_UTILS_EXPORT void	v_TransCoeffToPhys ()
	Virtual function for transformation to physical space.
virtual SOLVER_UTILS_EXPORT void	v_TransPhysToCoeff ()
	Virtual function for transformation to coefficient space.
virtual SOLVER_UTILS_EXPORT void	v_Output (void)
virtual SOLVER_UTILS_EXPORT bool	v_NegatedOp (void)
	Virtual function to identify if operator is negated in DoSolve.
Protected Member Functions inherited from Nektar::SolverUtils::FluidInterface
virtual SOLVER_UTILS_EXPORT void	v_SetMovingFrameVelocities (const Array< OneD, NekDouble > &vFrameVels, const int step)
virtual SOLVER_UTILS_EXPORT bool	v_GetMovingFrameVelocities (Array< OneD, NekDouble > &vFrameVels, const int step)
virtual SOLVER_UTILS_EXPORT void	v_SetMovingFrameDisp (const Array< OneD, NekDouble > &vFrameDisp, const int step)
virtual SOLVER_UTILS_EXPORT void	v_SetMovingFramePivot (const Array< OneD, NekDouble > &vFramePivot)
virtual SOLVER_UTILS_EXPORT bool	v_GetMovingFrameDisp (Array< OneD, NekDouble > &vFrameDisp, const int step)
virtual SOLVER_UTILS_EXPORT void	v_SetAeroForce (Array< OneD, NekDouble > forces)
virtual SOLVER_UTILS_EXPORT void	v_GetAeroForce (Array< OneD, NekDouble > forces)

Protected Attributes
bool	m_viscousJacFlag
bool	m_advectionJacFlag
bool	m_flagImplicitItsStatistics
int	m_nPadding = 1
int	m_TotNewtonIts = 0
int	m_TotLinIts = 0
int	m_TotImpStages = 0
Array< OneD, NekDouble >	m_magnitdEstimat
	Estimate the magnitude of each conserved varibles.
Array< OneD, Array< OneD, NekDouble > >	m_solutionPhys
NekDouble	m_TimeIntegLambda = 0.0
	coefff of spacial derivatives(rhs or m_F in GLM) in calculating the residual of the whole equation(used in unsteady time integrations)
NekDouble	m_inArrayNorm = -1.0
NekDouble	m_jacobiFreeEps
TensorOfArray4D< NekSingle >	m_stdSMatDataDBB
TensorOfArray5D< NekSingle >	m_stdSMatDataDBDB
LibUtilities::NekNonlinSysIterSharedPtr	m_nonlinsol
PreconCfsSharedPtr	m_preconCfs
bool	m_updateShockCaptPhys {true}
Protected Attributes inherited from Nektar::CompressibleFlowSystem
SolverUtils::DiffusionSharedPtr	m_diffusion
ArtificialDiffusionSharedPtr	m_artificialDiffusion
Array< OneD, Array< OneD, NekDouble > >	m_vecLocs
NekDouble	m_gamma
std::string	m_shockCaptureType
NekDouble	m_filterAlpha
NekDouble	m_filterExponent
NekDouble	m_filterCutoff
bool	m_useFiltering
bool	m_useLocalTimeStep
Array< OneD, NekDouble >	m_muav
Array< OneD, NekDouble >	m_muavTrace
VariableConverterSharedPtr	m_varConv
std::vector< CFSBndCondSharedPtr >	m_bndConds
NekDouble	m_bndEvaluateTime
std::vector< SolverUtils::ForcingSharedPtr >	m_forcing
Protected Attributes inherited from Nektar::SolverUtils::AdvectionSystem
SolverUtils::AdvectionSharedPtr	m_advObject
	Advection term.
Protected Attributes inherited from Nektar::SolverUtils::UnsteadySystem
LibUtilities::TimeIntegrationSchemeSharedPtr	m_intScheme
	Wrapper to the time integration scheme.
LibUtilities::TimeIntegrationSchemeOperators	m_ode
	The time integration scheme operators to use.
Array< OneD, Array< OneD, NekDouble > >	m_previousSolution
	Storage for previous solution for steady-state check.
std::vector< int >	m_intVariables
NekDouble	m_cflSafetyFactor
	CFL safety factor (comprise between 0 to 1).
NekDouble	m_CFLGrowth
	CFL growth rate.
NekDouble	m_CFLEnd
	Maximun cfl in cfl growth.
int	m_abortSteps
	Number of steps between checks for abort conditions.
bool	m_explicitDiffusion
	Indicates if explicit or implicit treatment of diffusion is used.
bool	m_explicitAdvection
	Indicates if explicit or implicit treatment of advection is used.
bool	m_explicitReaction
	Indicates if explicit or implicit treatment of reaction is used.
int	m_steadyStateSteps
	Check for steady state at step interval.
NekDouble	m_steadyStateTol
	Tolerance to which steady state should be evaluated at.
int	m_filtersInfosteps
	Number of time steps between outputting filters information.
std::vector< std::pair< std::string, FilterSharedPtr > >	m_filters
bool	m_homoInitialFwd
	Flag to determine if simulation should start in homogeneous forward transformed state.
std::ofstream	m_errFile
NekDouble	m_epsilon
	Diffusion coefficient.
Protected Attributes inherited from Nektar::SolverUtils::EquationSystem
LibUtilities::CommSharedPtr	m_comm
	Communicator.
bool	m_verbose
LibUtilities::SessionReaderSharedPtr	m_session
	The session reader.
std::map< std::string, SolverUtils::SessionFunctionSharedPtr >	m_sessionFunctions
	Map of known SessionFunctions.
LibUtilities::FieldIOSharedPtr	m_fld
	Field input/output.
Array< OneD, MultiRegions::ExpListSharedPtr >	m_fields
	Array holding all dependent variables.
SpatialDomains::BoundaryConditionsSharedPtr	m_boundaryConditions
	Pointer to boundary conditions object.
SpatialDomains::MeshGraphSharedPtr	m_graph
	Pointer to graph defining mesh.
std::string	m_sessionName
	Name of the session.
NekDouble	m_time
	Current time of simulation.
int	m_initialStep
	Number of the step where the simulation should begin.
NekDouble	m_fintime
	Finish time of the simulation.
NekDouble	m_timestep
	Time step size.
NekDouble	m_lambda
	Lambda constant in real system if one required.
NekDouble	m_checktime
	Time between checkpoints.
NekDouble	m_lastCheckTime
NekDouble	m_TimeIncrementFactor
int	m_nchk
	Number of checkpoints written so far.
int	m_steps
	Number of steps to take.
int	m_checksteps
	Number of steps between checkpoints.
int	m_infosteps
	Number of time steps between outputting status information.
int	m_iterPIT = 0
	Number of parallel-in-time time iteration.
int	m_windowPIT = 0
	Index of windows for parallel-in-time time iteration.
int	m_spacedim
	Spatial dimension (>= expansion dim).
int	m_expdim
	Expansion dimension.
bool	m_singleMode
	Flag to determine if single homogeneous mode is used.
bool	m_halfMode
	Flag to determine if half homogeneous mode is used.
bool	m_multipleModes
	Flag to determine if use multiple homogenenous modes are used.
bool	m_useFFT
	Flag to determine if FFT is used for homogeneous transform.
bool	m_homogen_dealiasing
	Flag to determine if dealiasing is used for homogeneous simulations.
bool	m_specHP_dealiasing
	Flag to determine if dealisising is usde for the Spectral/hp element discretisation.
enum MultiRegions::ProjectionType	m_projectionType
	Type of projection; e.g continuous or discontinuous.
Array< OneD, Array< OneD, NekDouble > >	m_traceNormals
	Array holding trace normals for DG simulations in the forwards direction.
Array< OneD, bool >	m_checkIfSystemSingular
	Flag to indicate if the fields should be checked for singularity.
LibUtilities::FieldMetaDataMap	m_fieldMetaDataMap
	Map to identify relevant solver info to dump in output fields.
Array< OneD, NekDouble >	m_movingFrameData
	Moving reference frame status in the inertial frame X, Y, Z, Theta_x, Theta_y, Theta_z, U, V, W, Omega_x, Omega_y, Omega_z, A_x, A_y, A_z, DOmega_x, DOmega_y, DOmega_z, pivot_x, pivot_y, pivot_z.
std::vector< std::string >	m_strFrameData
	variable name in m_movingFrameData
int	m_NumQuadPointsError
	Number of Quadrature points used to work out the error.
enum HomogeneousType	m_HomogeneousType
NekDouble	m_LhomX
	physical length in X direction (if homogeneous)
NekDouble	m_LhomY
	physical length in Y direction (if homogeneous)
NekDouble	m_LhomZ
	physical length in Z direction (if homogeneous)
int	m_npointsX
	number of points in X direction (if homogeneous)
int	m_npointsY
	number of points in Y direction (if homogeneous)
int	m_npointsZ
	number of points in Z direction (if homogeneous)
int	m_HomoDirec
	number of homogenous directions
Protected Attributes inherited from Nektar::SolverUtils::ALEHelper
Array< OneD, MultiRegions::ExpListSharedPtr >	m_fieldsALE
Array< OneD, Array< OneD, NekDouble > >	m_gridVelocity
Array< OneD, Array< OneD, NekDouble > >	m_gridVelocityTrace
std::vector< ALEBaseShPtr >	m_ALEs
bool	m_ALESolver = false
bool	m_meshDistorted = false
bool	m_implicitALESolver = false
bool	m_updateNormals = false
NekDouble	m_prevStageTime = 0.0
int	m_spaceDim

Additional Inherited Members
Static Public Attributes inherited from Nektar::SolverUtils::UnsteadySystem
static std::string	cmdSetStartTime
static std::string	cmdSetStartChkNum
Protected Types inherited from Nektar::SolverUtils::EquationSystem
enum	HomogeneousType { eHomogeneous1D , eHomogeneous2D , eHomogeneous3D , eNotHomogeneous }
	Parameter for homogeneous expansions. More...
Static Protected Attributes inherited from Nektar::SolverUtils::EquationSystem
static std::string	equationSystemTypeLookupIds []
static std::string	projectionTypeLookupIds []

Detailed Description

Definition at line 50 of file CompressibleFlowSystemImplicit.h.

Constructor & Destructor Documentation

CFSImplicit()

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

Definition at line 43 of file CompressibleFlowSystemImplicit.cpp.

    : UnsteadySystem(pSession, pGraph), CompressibleFlowSystem(pSession, pGraph)
{
}

~CFSImplicit()

Nektar::CFSImplicit::~CFSImplicit ( )

overridedefault

Member Function Documentation

AddMatNSBlkDiagBnd()

template<typename DataType , typename TypeNekBlkMatSharedPtr >

void Nektar::CFSImplicit::AddMatNSBlkDiagBnd ( const Array< OneD, const Array< OneD, NekDouble > > &  inarray, TensorOfArray3D< NekDouble > &  qfield, TensorOfArray2D< TypeNekBlkMatSharedPtr > &  gmtxarray, Array< OneD, TypeNekBlkMatSharedPtr > &  TraceJac, Array< OneD, TypeNekBlkMatSharedPtr > &  TraceJacDeriv, Array< OneD, Array< OneD, DataType > > &  TraceJacDerivSign, TensorOfArray5D< DataType > &  TraceIPSymJacArray  )

protected

Definition at line 1073 of file CompressibleFlowSystemImplicit.cpp.

{
    int nvariables = inarray.size();
 
    LibUtilities::Timer timer;
    timer.Start();
    GetTraceJac(inarray, qfield, TraceJac, TraceJacDeriv, TraceJacDerivSign,
                TraceIPSymJacArray);
    timer.Stop();
    timer.AccumulateRegion("CFSImplicit::GetTraceJac", 10);
 
    Array<OneD, TypeNekBlkMatSharedPtr> tmpJac;
    Array<OneD, Array<OneD, DataType>> tmpSign;
 
    timer.Start();
    m_advObject->AddTraceJacToMat(nvariables, m_spacedim, m_fields, TraceJac,
                                  gmtxarray, tmpJac, tmpSign);
    timer.Stop();
    timer.AccumulateRegion("Advection::AddTraceJacToMap", 10);
}

References Nektar::LibUtilities::Timer::AccumulateRegion(), GetTraceJac(), Nektar::SolverUtils::AdvectionSystem::m_advObject, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::EquationSystem::m_spacedim, Nektar::LibUtilities::Timer::Start(), and Nektar::LibUtilities::Timer::Stop().

Referenced by CalcPreconMatBRJCoeff().

AddMatNSBlkDiagVol()

template<typename DataType , typename TypeNekBlkMatSharedPtr >

void Nektar::CFSImplicit::AddMatNSBlkDiagVol ( const Array< OneD, const Array< OneD, NekDouble > > &  inarray, const Array< OneD, const TensorOfArray2D< NekDouble > > &  qfield, Array< OneD, Array< OneD, TypeNekBlkMatSharedPtr > > &  gmtxarray, TensorOfArray4D< DataType > &  StdMatDataDBB, TensorOfArray5D< DataType > &  StdMatDataDBDB  )

protected

Definition at line 601 of file CompressibleFlowSystemImplicit.cpp.

{
    if (StdMatDataDBB.size() == 0)
    {
        CalcVolJacStdMat(StdMatDataDBB, StdMatDataDBDB);
    }
 
    int nSpaceDim = m_graph->GetSpaceDimension();
    int nvariable = inarray.size();
    int npoints   = m_fields[0]->GetTotPoints();
    int nVar2     = nvariable * nvariable;
    std::shared_ptr<LocalRegions::ExpansionVector> expvect =
        m_fields[0]->GetExp();
    int nTotElmt = (*expvect).size();
 
    Array<OneD, NekDouble> mu(npoints, 0.0);
    Array<OneD, NekDouble> DmuDT(npoints, 0.0);
    if (m_viscousJacFlag)
    {
        CalcMuDmuDT(inarray, mu, DmuDT);
    }
 
    Array<OneD, NekDouble> normals;
    Array<OneD, Array<OneD, NekDouble>> normal3D(3);
    for (int i = 0; i < 3; i++)
    {
        normal3D[i] = Array<OneD, NekDouble>(3, 0.0);
    }
    normal3D[0][0] = 1.0;
    normal3D[1][1] = 1.0;
    normal3D[2][2] = 1.0;
    Array<OneD, Array<OneD, NekDouble>> normalPnt(3);
 
    DNekMatSharedPtr wspMat =
        MemoryManager<DNekMat>::AllocateSharedPtr(nvariable, nvariable, 0.0);
    DNekMatSharedPtr wspMatDrv = MemoryManager<DNekMat>::AllocateSharedPtr(
        nvariable - 1, nvariable, 0.0);
 
    Array<OneD, DataType> GmatxData;
    Array<OneD, DataType> MatData;
 
    Array<OneD, NekDouble> tmppnts;
    TensorOfArray3D<NekDouble> PntJacCons(
        m_spacedim); // Nvar*Nvar*Ndir*Nelmt*Npnt
    TensorOfArray3D<DataType> PntJacConsStd(
        m_spacedim); // Nvar*Nvar*Ndir*Nelmt*Npnt
    Array<OneD, Array<OneD, NekDouble>> ConsStdd(m_spacedim);
    Array<OneD, Array<OneD, NekDouble>> ConsCurv(m_spacedim);
    TensorOfArray4D<NekDouble> PntJacDerv(
        m_spacedim); // Nvar*Nvar*Ndir*Nelmt*Npnt
    TensorOfArray4D<DataType> PntJacDervStd(
        m_spacedim); // Nvar*Nvar*Ndir*Nelmt*Npnt
    TensorOfArray3D<NekDouble> DervStdd(
        m_spacedim); // Nvar*Nvar*Ndir*Nelmt*Npnt
    TensorOfArray3D<NekDouble> DervCurv(
        m_spacedim); // Nvar*Nvar*Ndir*Nelmt*Npnt
    for (int ndir = 0; ndir < m_spacedim; ndir++)
    {
        PntJacDerv[ndir]    = TensorOfArray3D<NekDouble>(m_spacedim);
        PntJacDervStd[ndir] = TensorOfArray3D<DataType>(m_spacedim);
        DervStdd[ndir]      = Array<OneD, Array<OneD, NekDouble>>(m_spacedim);
        DervCurv[ndir]      = Array<OneD, Array<OneD, NekDouble>>(m_spacedim);
    }
 
    Array<OneD, NekDouble> locmu;
    Array<OneD, NekDouble> locDmuDT;
    Array<OneD, Array<OneD, NekDouble>> locVars(nvariable);
    TensorOfArray3D<NekDouble> locDerv(m_spacedim);
    for (int ndir = 0; ndir < m_spacedim; ndir++)
    {
        locDerv[ndir] = Array<OneD, Array<OneD, NekDouble>>(nvariable);
    }
 
    int nElmtCoefOld = -1;
    for (int ne = 0; ne < nTotElmt; ne++)
    {
        int nElmtCoef  = (*expvect)[ne]->GetNcoeffs();
        int nElmtCoef2 = nElmtCoef * nElmtCoef;
        int nElmtPnt   = (*expvect)[ne]->GetTotPoints();
 
        int nQuot     = nElmtCoef2 / m_nPadding;
        int nRemd     = nElmtCoef2 - nQuot * m_nPadding;
        int nQuotPlus = nQuot;
        if (nRemd > 0)
        {
            nQuotPlus++;
        }
        int nElmtCoef2Paded = nQuotPlus * m_nPadding;
 
        if (nElmtPnt > PntJacCons[0].size() || nElmtCoef > nElmtCoefOld)
        {
            nElmtCoefOld = nElmtCoef;
            for (int ndir = 0; ndir < 3; ndir++)
            {
                normalPnt[ndir] = Array<OneD, NekDouble>(npoints, 0.0);
            }
            tmppnts = Array<OneD, NekDouble>(nElmtPnt);
            MatData = Array<OneD, DataType>(nElmtCoef2Paded * nVar2);
            for (int ndir = 0; ndir < m_spacedim; ndir++)
            {
                ConsCurv[ndir] = Array<OneD, NekDouble>(nElmtPnt);
                ConsStdd[ndir] = Array<OneD, NekDouble>(nElmtPnt);
                PntJacCons[ndir] =
                    Array<OneD, Array<OneD, NekDouble>>(nElmtPnt);
                PntJacConsStd[ndir] =
                    Array<OneD, Array<OneD, DataType>>(nElmtPnt);
                for (int i = 0; i < nElmtPnt; i++)
                {
                    PntJacCons[ndir][i]    = Array<OneD, NekDouble>(nVar2);
                    PntJacConsStd[ndir][i] = Array<OneD, DataType>(nVar2);
                }
 
                for (int ndir1 = 0; ndir1 < m_spacedim; ndir1++)
                {
                    PntJacDerv[ndir][ndir1] =
                        Array<OneD, Array<OneD, NekDouble>>(nElmtPnt);
                    PntJacDervStd[ndir][ndir1] =
                        Array<OneD, Array<OneD, DataType>>(nElmtPnt);
                    DervStdd[ndir][ndir1] = Array<OneD, NekDouble>(nElmtPnt);
                    DervCurv[ndir][ndir1] = Array<OneD, NekDouble>(nElmtPnt);
                    for (int i = 0; i < nElmtPnt; i++)
                    {
                        PntJacDerv[ndir][ndir1][i] =
                            Array<OneD, NekDouble>(nVar2);
                        PntJacDervStd[ndir][ndir1][i] =
                            Array<OneD, DataType>(nVar2);
                    }
                }
            }
        }
 
        int noffset = GetPhys_Offset(ne);
        for (int j = 0; j < nvariable; j++)
        {
            locVars[j] = inarray[j] + noffset;
        }
 
        if (m_advectionJacFlag)
        {
            for (int nFluxDir = 0; nFluxDir < nSpaceDim; nFluxDir++)
            {
                normals = normal3D[nFluxDir];
                GetFluxVectorJacDirElmt(nvariable, nElmtPnt, locVars, normals,
                                        wspMat, PntJacCons[nFluxDir]);
            }
        }
 
        if (m_viscousJacFlag)
        {
            for (int j = 0; j < nSpaceDim; j++)
            {
                for (int k = 0; k < nvariable; k++)
                {
                    locDerv[j][k] = qfield[j][k] + noffset;
                }
            }
            locmu    = mu + noffset;
            locDmuDT = DmuDT + noffset;
            for (int nFluxDir = 0; nFluxDir < nSpaceDim; nFluxDir++)
            {
                normals = normal3D[nFluxDir];
                MinusDiffusionFluxJacPoint(nvariable, nElmtPnt, locVars,
                                           locDerv, locmu, locDmuDT, normals,
                                           wspMatDrv, PntJacCons[nFluxDir]);
            }
        }
 
        if (m_viscousJacFlag)
        {
            locmu = mu + noffset;
            for (int nFluxDir = 0; nFluxDir < nSpaceDim; nFluxDir++)
            {
                Vmath::Fill(npoints, 1.0, normalPnt[nFluxDir], 1);
                for (int nDervDir = 0; nDervDir < nSpaceDim; nDervDir++)
                {
                    GetFluxDerivJacDirctnElmt(
                        nvariable, nElmtPnt, nDervDir, locVars, locmu,
                        normalPnt, wspMatDrv, PntJacDerv[nFluxDir][nDervDir]);
                }
                Vmath::Fill(npoints, 0.0, normalPnt[nFluxDir], 1);
            }
        }
 
        for (int n = 0; n < nvariable; n++)
        {
            for (int m = 0; m < nvariable; m++)
            {
                int nVarOffset = m + n * nvariable;
                GmatxData      = gmtxarray[m][n]->GetBlock(ne, ne)->GetPtr();
 
                for (int ndStd0 = 0; ndStd0 < m_spacedim; ndStd0++)
                {
                    Vmath::Zero(nElmtPnt, ConsStdd[ndStd0], 1);
                }
                for (int ndir = 0; ndir < m_spacedim; ndir++)
                {
                    for (int i = 0; i < nElmtPnt; i++)
                    {
                        tmppnts[i] = PntJacCons[ndir][i][nVarOffset];
                    }
                    (*expvect)[ne]->AlignVectorToCollapsedDir(ndir, tmppnts,
                                                              ConsCurv);
                    for (int nd = 0; nd < m_spacedim; nd++)
                    {
                        Vmath::Vadd(nElmtPnt, ConsCurv[nd], 1, ConsStdd[nd], 1,
                                    ConsStdd[nd], 1);
                    }
                }
 
                for (int ndir = 0; ndir < m_spacedim; ndir++)
                {
                    (*expvect)[ne]->MultiplyByQuadratureMetric(
                        ConsStdd[ndir], ConsStdd[ndir]); // weight with metric
                    for (int i = 0; i < nElmtPnt; i++)
                    {
                        PntJacConsStd[ndir][i][nVarOffset] =
                            DataType(ConsStdd[ndir][i]);
                    }
                }
            }
        }
 
        if (m_viscousJacFlag)
        {
            for (int m = 0; m < nvariable; m++)
            {
                for (int n = 0; n < nvariable; n++)
                {
                    int nVarOffset = m + n * nvariable;
                    for (int ndStd0 = 0; ndStd0 < m_spacedim; ndStd0++)
                    {
                        for (int ndStd1 = 0; ndStd1 < m_spacedim; ndStd1++)
                        {
                            Vmath::Zero(nElmtPnt, DervStdd[ndStd0][ndStd1], 1);
                        }
                    }
                    for (int nd0 = 0; nd0 < m_spacedim; nd0++)
                    {
                        for (int nd1 = 0; nd1 < m_spacedim; nd1++)
                        {
                            for (int i = 0; i < nElmtPnt; i++)
                            {
                                tmppnts[i] =
                                    PntJacDerv[nd0][nd1][i][nVarOffset];
                            }
 
                            (*expvect)[ne]->AlignVectorToCollapsedDir(
                                nd0, tmppnts, ConsCurv);
                            for (int nd = 0; nd < m_spacedim; nd++)
                            {
                                (*expvect)[ne]->AlignVectorToCollapsedDir(
                                    nd1, ConsCurv[nd], DervCurv[nd]);
                            }
 
                            for (int ndStd0 = 0; ndStd0 < m_spacedim; ndStd0++)
                            {
                                for (int ndStd1 = 0; ndStd1 < m_spacedim;
                                     ndStd1++)
                                {
                                    Vmath::Vadd(nElmtPnt,
                                                DervCurv[ndStd0][ndStd1], 1,
                                                DervStdd[ndStd0][ndStd1], 1,
                                                DervStdd[ndStd0][ndStd1], 1);
                                }
                            }
                        }
                    }
                    for (int nd0 = 0; nd0 < m_spacedim; nd0++)
                    {
                        for (int nd1 = 0; nd1 < m_spacedim; nd1++)
                        {
                            (*expvect)[ne]->MultiplyByQuadratureMetric(
                                DervStdd[nd0][nd1],
                                DervStdd[nd0][nd1]); // weight with metric
                            for (int i = 0; i < nElmtPnt; i++)
                            {
                                PntJacDervStd[nd0][nd1][i][nVarOffset] =
                                    -DataType(DervStdd[nd0][nd1][i]);
                            }
                        }
                    }
                }
            }
        }
 
        Vmath::Zero(nElmtCoef2Paded * nVar2, MatData, 1);
        DataType one = 1.0;
        for (int ndir = 0; ndir < m_spacedim; ndir++)
        {
            for (int i = 0; i < nElmtPnt; i++)
            {
                Blas::Ger(nElmtCoef2Paded, nVar2, one,
                          &StdMatDataDBB[ne][ndir][i][0], 1,
                          &PntJacConsStd[ndir][i][0], 1, &MatData[0],
                          nElmtCoef2Paded);
            }
        }
 
        if (m_viscousJacFlag)
        {
            for (int nd0 = 0; nd0 < m_spacedim; nd0++)
            {
                for (int nd1 = 0; nd1 < m_spacedim; nd1++)
                {
                    for (int i = 0; i < nElmtPnt; i++)
                    {
                        Blas::Ger(nElmtCoef2Paded, nVar2, one,
                                  &StdMatDataDBDB[ne][nd0][nd1][i][0], 1,
                                  &PntJacDervStd[nd0][nd1][i][0], 1,
                                  &MatData[0], nElmtCoef2Paded);
                    }
                }
            }
        }
 
        Array<OneD, DataType> tmpA;
 
        for (int n = 0; n < nvariable; n++)
        {
            for (int m = 0; m < nvariable; m++)
            {
                int nVarOffset = m + n * nvariable;
                GmatxData      = gmtxarray[m][n]->GetBlock(ne, ne)->GetPtr();
                Vmath::Vcopy(nElmtCoef2,
                             tmpA = MatData + nVarOffset * nElmtCoef2Paded, 1,
                             GmatxData, 1);
            }
        }
    }
}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), CalcMuDmuDT(), CalcVolJacStdMat(), Vmath::Fill(), Blas::Ger(), GetFluxDerivJacDirctnElmt(), GetFluxVectorJacDirElmt(), Nektar::SolverUtils::EquationSystem::GetPhys_Offset(), m_advectionJacFlag, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::EquationSystem::m_graph, m_nPadding, Nektar::SolverUtils::EquationSystem::m_spacedim, m_viscousJacFlag, MinusDiffusionFluxJacPoint(), Vmath::Vadd(), Vmath::Vcopy(), and Vmath::Zero().

Referenced by CalcPreconMatBRJCoeff().

AllocateNekBlkMatDig()

void Nektar::CFSImplicit::AllocateNekBlkMatDig ( SNekBlkMatSharedPtr &  mat, const Array< OneD, unsigned int >  nrow, const Array< OneD, unsigned int >  ncol  )

inlineprotected

Definition at line 227 of file CompressibleFlowSystemImplicit.h.

    {
        mat =
            MemoryManager<SNekBlkMat>::AllocateSharedPtr(nrow, ncol, eDIAGONAL);
        SNekMatSharedPtr loc_matNvar;
        for (int nelm = 0; nelm < nrow.size(); ++nelm)
        {
            int nrowsVars = nrow[nelm];
            int ncolsVars = ncol[nelm];
 
            loc_matNvar = MemoryManager<SNekMat>::AllocateSharedPtr(
                nrowsVars, ncolsVars, 0.0);
            mat->SetBlock(nelm, nelm, loc_matNvar);
        }
    }

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), and Nektar::eDIAGONAL.

Referenced by ElmtVarInvMtrx(), and GetTraceJac().

CalcMuDmuDT()

void Nektar::CFSImplicit::CalcMuDmuDT ( const Array< OneD, const Array< OneD, NekDouble > > &  inarray, Array< OneD, NekDouble > &  mu, Array< OneD, NekDouble > &  DmuDT  )

inlineprotected

Definition at line 340 of file CompressibleFlowSystemImplicit.h.

    {
        v_CalcMuDmuDT(inarray, mu, DmuDT);
    }

References v_CalcMuDmuDT().

Referenced by AddMatNSBlkDiagVol().

CalcPhysDeriv()

void Nektar::CFSImplicit::CalcPhysDeriv ( const Array< OneD, const Array< OneD, NekDouble > > &  inarray, TensorOfArray3D< NekDouble > &  qfield  )

inlineprotected

Definition at line 334 of file CompressibleFlowSystemImplicit.h.

    {
        v_CalcPhysDeriv(inarray, qfield);
    }

References v_CalcPhysDeriv().

Referenced by CalcPreconMatBRJCoeff().

CalcPreconMatBRJCoeff()

void Nektar::CFSImplicit::CalcPreconMatBRJCoeff ( const Array< OneD, const Array< OneD, NekDouble > > &  inarray, Array< OneD, Array< OneD, SNekBlkMatSharedPtr > > &  gmtxarray, SNekBlkMatSharedPtr &  gmtVar, Array< OneD, SNekBlkMatSharedPtr > &  TraceJac, Array< OneD, SNekBlkMatSharedPtr > &  TraceJacDeriv, Array< OneD, Array< OneD, NekSingle > > &  TraceJacDerivSign, TensorOfArray4D< NekSingle > &  TraceJacArray, TensorOfArray4D< NekSingle > &  TraceJacDerivArray, TensorOfArray5D< NekSingle > &  TraceIPSymJacArray  )

protected

Definition at line 1518 of file CompressibleFlowSystemImplicit.cpp.

{
    TensorOfArray3D<NekDouble> qfield;
 
    if (m_viscousJacFlag)
    {
        CalcPhysDeriv(inarray, qfield);
    }
 
    NekSingle zero = 0.0;
    Fill2DArrayOfBlkDiagonalMat(gmtxarray, zero);
 
    LibUtilities::Timer timer;
    timer.Start();
    AddMatNSBlkDiagVol(inarray, qfield, gmtxarray, m_stdSMatDataDBB,
                       m_stdSMatDataDBDB);
    timer.Stop();
    timer.AccumulateRegion("CFSImplicit::AddMatNSBlkDiagVol", 2);
 
    timer.Start();
    AddMatNSBlkDiagBnd(inarray, qfield, gmtxarray, TraceJac, TraceJacDeriv,
                       TraceJacDerivSign, TraceIPSymJacArray);
    timer.Stop();
    timer.AccumulateRegion("CFSImplicit::AddMatNSBlkDiagBnd", 2);
 
    MultiplyElmtInvMassPlusSource<NekSingle>(gmtxarray, m_TimeIntegLambda);
 
    timer.Start();
    ElmtVarInvMtrx(gmtxarray, gmtVar, zero);
    timer.Stop();
    timer.AccumulateRegion("CFSImplicit::ElmtVarInvMtrx", 2);
 
    TransTraceJacMatToArray(TraceJac, TraceJacArray);
}

References Nektar::LibUtilities::Timer::AccumulateRegion(), AddMatNSBlkDiagBnd(), AddMatNSBlkDiagVol(), CalcPhysDeriv(), ElmtVarInvMtrx(), Fill2DArrayOfBlkDiagonalMat(), m_stdSMatDataDBB, m_stdSMatDataDBDB, m_TimeIntegLambda, m_viscousJacFlag, Nektar::LibUtilities::Timer::Start(), Nektar::LibUtilities::Timer::Stop(), and TransTraceJacMatToArray().

Referenced by InitialiseNonlinSysSolver().

CalcRefValues()

void Nektar::CFSImplicit::CalcRefValues ( const Array< OneD, const NekDouble > &  inarray )

protected

Definition at line 470 of file CompressibleFlowSystemImplicit.cpp.

{
    unsigned int nvariables = m_fields.size();
    unsigned int ntotal     = inarray.size();
    unsigned int npoints    = ntotal / nvariables;
 
    unsigned int nTotalGlobal = ntotal;
    m_comm->GetSpaceComm()->AllReduce(nTotalGlobal,
                                      Nektar::LibUtilities::ReduceSum);
    unsigned int nTotalDOF = nTotalGlobal / nvariables;
    NekDouble invTotalDOF  = 1.0 / nTotalDOF;
 
    m_inArrayNorm    = 0.0;
    m_magnitdEstimat = Array<OneD, NekDouble>(nvariables, 0.0);
 
    for (int i = 0; i < nvariables; ++i)
    {
        int offset = i * npoints;
        m_magnitdEstimat[i] =
            Vmath::Dot(npoints, inarray + offset, inarray + offset);
    }
    m_comm->GetSpaceComm()->AllReduce(m_magnitdEstimat,
                                      Nektar::LibUtilities::ReduceSum);
 
    for (int i = 0; i < nvariables; ++i)
    {
        m_inArrayNorm += m_magnitdEstimat[i];
    }
 
    for (int i = 2; i < nvariables - 1; ++i)
    {
        m_magnitdEstimat[1] += m_magnitdEstimat[i];
    }
 
    for (int i = 2; i < nvariables - 1; ++i)
    {
        m_magnitdEstimat[i] = m_magnitdEstimat[1];
    }
 
    for (int i = 0; i < nvariables; ++i)
    {
        m_magnitdEstimat[i] = sqrt(m_magnitdEstimat[i] * invTotalDOF);
    }
    if (m_comm->GetRank() == 0 && m_verbose)
    {
        for (int i = 0; i < nvariables; ++i)
        {
            std::cout << "m_magnitdEstimat[" << i
                      << "]    = " << m_magnitdEstimat[i] << std::endl;
        }
        std::cout << "m_inArrayNorm    = " << m_inArrayNorm << std::endl;
    }
}

References Vmath::Dot(), Nektar::SolverUtils::EquationSystem::m_comm, Nektar::SolverUtils::EquationSystem::m_fields, m_inArrayNorm, m_magnitdEstimat, Nektar::SolverUtils::EquationSystem::m_verbose, Nektar::LibUtilities::ReduceSum, and tinysimd::sqrt().

Referenced by DoImplicitSolveCoeff().

CalcTraceNumericalFlux()

void Nektar::CFSImplicit::CalcTraceNumericalFlux ( const int  nConvectiveFields, const int  nDim, const int  nPts, const int  nTracePts, const NekDouble  PenaltyFactor2, const Array< OneD, MultiRegions::ExpListSharedPtr > &  fields, const Array< OneD, const Array< OneD, NekDouble > > &  AdvVel, const Array< OneD, const Array< OneD, NekDouble > > &  inarray, const NekDouble  time, TensorOfArray3D< NekDouble > &  qfield, const Array< OneD, const Array< OneD, NekDouble > > &  vFwd, const Array< OneD, const Array< OneD, NekDouble > > &  vBwd, const Array< OneD, const TensorOfArray2D< NekDouble > > &  qFwd, const Array< OneD, const TensorOfArray2D< NekDouble > > &  qBwd, const Array< OneD, NekDouble > &  MuVarTrace, Array< OneD, int > &  nonZeroIndex, Array< OneD, Array< OneD, NekDouble > > &  traceflux  )

protected

Definition at line 1443 of file CompressibleFlowSystemImplicit.cpp.

{
    if (m_advectionJacFlag)
    {
        auto advWeakDGObject =
            std::dynamic_pointer_cast<SolverUtils::AdvectionWeakDG>(
                m_advObject);
        ASSERTL0(advWeakDGObject,
                 "Use WeakDG for implicit compressible flow solver!");
        advWeakDGObject->AdvectTraceFlux(nConvectiveFields, m_fields, AdvVel,
                                         inarray, traceflux, m_bndEvaluateTime,
                                         vFwd, vBwd);
    }
    else
    {
        for (int i = 0; i < nConvectiveFields; i++)
        {
            traceflux[i] = Array<OneD, NekDouble>(nTracePts, 0.0);
        }
    }
 
    if (m_viscousJacFlag)
    {
        Array<OneD, Array<OneD, NekDouble>> visflux(nConvectiveFields);
        for (int i = 0; i < nConvectiveFields; i++)
        {
            visflux[i] = Array<OneD, NekDouble>(nTracePts, 0.0);
        }
 
        std::string diffName;
        m_session->LoadSolverInfo("DiffusionType", diffName, "InteriorPenalty");
        if (diffName == "InteriorPenalty")
        {
            m_diffusion->DiffuseTraceFlux(fields, inarray, qfield,
                                          NullNekDoubleTensorOfArray3D, visflux,
                                          vFwd, vBwd, nonZeroIndex);
        }
        else
        {
            ASSERTL1(false, "LDGNS not yet validated for implicit compressible "
                            "flow solver");
            // For LDGNS, the array size should be nConvectiveFields - 1
            Array<OneD, Array<OneD, NekDouble>> inBwd(nConvectiveFields - 1);
            Array<OneD, Array<OneD, NekDouble>> inFwd(nConvectiveFields - 1);
            for (int i = 0; i < nConvectiveFields - 1; ++i)
            {
                inBwd[i] = vBwd[i];
                inFwd[i] = vFwd[i];
            }
            m_diffusion->DiffuseTraceFlux(fields, inarray, qfield,
                                          NullNekDoubleTensorOfArray3D, visflux,
                                          inFwd, inBwd, nonZeroIndex);
        }
        for (int i = 0; i < nConvectiveFields; i++)
        {
            Vmath::Vsub(nTracePts, traceflux[i], 1, visflux[i], 1, traceflux[i],
                        1);
        }
    }
}

References ASSERTL0, ASSERTL1, m_advectionJacFlag, Nektar::SolverUtils::AdvectionSystem::m_advObject, Nektar::CompressibleFlowSystem::m_bndEvaluateTime, Nektar::CompressibleFlowSystem::m_diffusion, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::EquationSystem::m_session, m_viscousJacFlag, Nektar::NullNekDoubleTensorOfArray3D, and Vmath::Vsub().

Referenced by NumCalcRiemFluxJac().

CalcVolJacStdMat()

template<typename DataType >

void Nektar::CFSImplicit::CalcVolJacStdMat ( TensorOfArray4D< DataType > &  StdMatDataDBB, TensorOfArray5D< DataType > &  StdMatDataDBDB  )

protected

Definition at line 938 of file CompressibleFlowSystemImplicit.cpp.

{
    std::shared_ptr<LocalRegions::ExpansionVector> expvect =
        m_fields[0]->GetExp();
    int nTotElmt = (*expvect).size();
 
    StdMatDataDBB  = TensorOfArray4D<DataType>(nTotElmt);
    StdMatDataDBDB = TensorOfArray5D<DataType>(nTotElmt);
 
    std::vector<DNekMatSharedPtr> VectStdDerivBase0;
    std::vector<TensorOfArray3D<DataType>> VectStdDerivBase_Base;
    std::vector<TensorOfArray4D<DataType>> VectStdDervBase_DervBase;
    DNekMatSharedPtr MatStdDerivBase0;
    Array<OneD, DNekMatSharedPtr> ArrayStdMat(m_spacedim);
    Array<OneD, Array<OneD, NekDouble>> ArrayStdMatData(m_spacedim);
    for (int ne = 0; ne < nTotElmt; ne++)
    {
        StdRegions::StdExpansionSharedPtr stdExp;
        stdExp = (*expvect)[ne]->GetStdExp();
        StdRegions::StdMatrixKey matkey(StdRegions::eDerivBase0,
                                        stdExp->DetShapeType(), *stdExp);
        MatStdDerivBase0 = stdExp->GetStdMatrix(matkey);
 
        int nTotStdExp   = VectStdDerivBase0.size();
        int nFoundStdExp = -1;
        for (int i = 0; i < nTotStdExp; i++)
        {
            if ((*VectStdDerivBase0[i]) == (*MatStdDerivBase0))
            {
                nFoundStdExp = i;
            }
        }
        if (nFoundStdExp >= 0)
        {
            StdMatDataDBB[ne]  = VectStdDerivBase_Base[nFoundStdExp];
            StdMatDataDBDB[ne] = VectStdDervBase_DervBase[nFoundStdExp];
        }
        else
        {
            int nElmtCoef  = (*expvect)[ne]->GetNcoeffs();
            int nElmtCoef2 = nElmtCoef * nElmtCoef;
            int nElmtPnt   = (*expvect)[ne]->GetTotPoints();
 
            int nQuot     = nElmtCoef2 / m_nPadding;
            int nRemd     = nElmtCoef2 - nQuot * m_nPadding;
            int nQuotPlus = nQuot;
            if (nRemd > 0)
            {
                nQuotPlus++;
            }
            int nPaded = nQuotPlus * m_nPadding;
 
            ArrayStdMat[0] = MatStdDerivBase0;
            if (m_spacedim > 1)
            {
                StdRegions::StdMatrixKey matkey(
                    StdRegions::eDerivBase1, stdExp->DetShapeType(), *stdExp);
                ArrayStdMat[1] = stdExp->GetStdMatrix(matkey);
 
                if (m_spacedim > 2)
                {
                    StdRegions::StdMatrixKey matkey(StdRegions::eDerivBase2,
                                                    stdExp->DetShapeType(),
                                                    *stdExp);
                    ArrayStdMat[2] = stdExp->GetStdMatrix(matkey);
                }
            }
            for (int nd0 = 0; nd0 < m_spacedim; nd0++)
            {
                ArrayStdMatData[nd0] = ArrayStdMat[nd0]->GetPtr();
            }
 
            StdRegions::StdMatrixKey matkey(StdRegions::eBwdMat,
                                            stdExp->DetShapeType(), *stdExp);
            DNekMatSharedPtr BwdMat           = stdExp->GetStdMatrix(matkey);
            Array<OneD, NekDouble> BwdMatData = BwdMat->GetPtr();
 
            TensorOfArray3D<DataType> tmpStdDBB(m_spacedim);
            TensorOfArray4D<DataType> tmpStdDBDB(m_spacedim);
 
            for (int nd0 = 0; nd0 < m_spacedim; nd0++)
            {
                tmpStdDBB[nd0] = Array<OneD, Array<OneD, DataType>>(nElmtPnt);
                for (int i = 0; i < nElmtPnt; i++)
                {
                    tmpStdDBB[nd0][i] = Array<OneD, DataType>(nPaded, 0.0);
                    for (int nc1 = 0; nc1 < nElmtCoef; nc1++)
                    {
                        int noffset = nc1 * nElmtCoef;
                        for (int nc0 = 0; nc0 < nElmtCoef; nc0++)
                        {
                            tmpStdDBB[nd0][i][nc0 + noffset] = DataType(
                                ArrayStdMatData[nd0][i * nElmtCoef + nc0] *
                                BwdMatData[i * nElmtCoef + nc1]);
                        }
                    }
                }
 
                tmpStdDBDB[nd0] = TensorOfArray3D<DataType>(m_spacedim);
                for (int nd1 = 0; nd1 < m_spacedim; nd1++)
                {
                    tmpStdDBDB[nd0][nd1] =
                        Array<OneD, Array<OneD, DataType>>(nElmtPnt);
                    for (int i = 0; i < nElmtPnt; i++)
                    {
                        tmpStdDBDB[nd0][nd1][i] =
                            Array<OneD, DataType>(nPaded, 0.0);
                        for (int nc1 = 0; nc1 < nElmtCoef; nc1++)
                        {
                            int noffset = nc1 * nElmtCoef;
                            for (int nc0 = 0; nc0 < nElmtCoef; nc0++)
                            {
                                tmpStdDBDB[nd0][nd1][i][nc0 + noffset] =
                                    DataType(
                                        ArrayStdMatData[nd0]
                                                       [i * nElmtCoef + nc0] *
                                        ArrayStdMatData[nd1]
                                                       [i * nElmtCoef + nc1]);
                            }
                        }
                    }
                }
            }
            VectStdDerivBase0.push_back(MatStdDerivBase0);
            VectStdDerivBase_Base.push_back(tmpStdDBB);
            VectStdDervBase_DervBase.push_back(tmpStdDBDB);
 
            StdMatDataDBB[ne]  = tmpStdDBB;
            StdMatDataDBDB[ne] = tmpStdDBDB;
        }
    }
}

References Nektar::StdRegions::eBwdMat, Nektar::StdRegions::eDerivBase0, Nektar::StdRegions::eDerivBase1, Nektar::StdRegions::eDerivBase2, Nektar::SolverUtils::EquationSystem::m_fields, m_nPadding, and Nektar::SolverUtils::EquationSystem::m_spacedim.

Referenced by AddMatNSBlkDiagVol().

DoAdvectionCoeff()

void Nektar::CFSImplicit::DoAdvectionCoeff ( const Array< OneD, const Array< OneD, NekDouble > > &  inarray, Array< OneD, Array< OneD, NekDouble > > &  outarray, const NekDouble  time, const Array< OneD, const Array< OneD, NekDouble > > &  pFwd, const Array< OneD, const Array< OneD, NekDouble > > &  pBwd  )

protected

Compute the advection terms for the right-hand side.

Definition at line 347 of file CompressibleFlowSystemImplicit.cpp.

{
    int nvariables = inarray.size();
    Array<OneD, Array<OneD, NekDouble>> advVel(m_spacedim);
 
    auto advWeakDGObject =
        std::dynamic_pointer_cast<SolverUtils::AdvectionWeakDG>(m_advObject);
    ASSERTL0(advWeakDGObject,
             "Use WeakDG for implicit compressible flow solver!");
    advWeakDGObject->AdvectCoeffs(nvariables, m_fields, advVel, inarray,
                                  outarray, time, pFwd, pBwd);
}

References ASSERTL0, Nektar::SolverUtils::AdvectionSystem::m_advObject, Nektar::SolverUtils::EquationSystem::m_fields, and Nektar::SolverUtils::EquationSystem::m_spacedim.

Referenced by DoOdeRhsCoeff().

DoDiffusionCoeff()

void Nektar::CFSImplicit::DoDiffusionCoeff ( const Array< OneD, const Array< OneD, NekDouble > > &  inarray, Array< OneD, Array< OneD, NekDouble > > &  outarray, const Array< OneD, const Array< OneD, NekDouble > > &  pFwd, const Array< OneD, const Array< OneD, NekDouble > > &  pBwd  )

protected

Add the diffusions terms to the right-hand side Similar to DoDiffusion() but with outarray in coefficient space.

Definition at line 368 of file CompressibleFlowSystemImplicit.cpp.

{
    v_DoDiffusionCoeff(inarray, outarray, pFwd, pBwd);
}

References v_DoDiffusionCoeff().

Referenced by DoOdeRhsCoeff().

DoImplicitSolve()

void Nektar::CFSImplicit::DoImplicitSolve ( const Array< OneD, const Array< OneD, NekDouble > > &  inpnts, Array< OneD, Array< OneD, NekDouble > > &  outpnt, const NekDouble  time, const NekDouble  lambda  )

protected

Definition at line 377 of file CompressibleFlowSystemImplicit.cpp.

{
    unsigned int nvariables = inpnts.size();
    unsigned int ncoeffs    = m_fields[0]->GetNcoeffs();
    unsigned int ntotal     = nvariables * ncoeffs;
 
    Array<OneD, NekDouble> inarray(ntotal);
    Array<OneD, NekDouble> outarray(ntotal);
    Array<OneD, NekDouble> tmpArray;
    Array<OneD, Array<OneD, NekDouble>> tmpIn(nvariables);
    Array<OneD, Array<OneD, NekDouble>> tmpOut(nvariables);
    Array<OneD, Array<OneD, NekDouble>> tmpoutarray(nvariables);
 
    // Switch flag to make sure the physical shock capturing AV is updated
    m_updateShockCaptPhys = true;
 
    if (m_meshDistorted)
    {
        ALEHelper::ALEDoElmtInvMassBwdTrans(inpnts, tmpIn);
    }
    else
    {
        tmpIn = inpnts;
    }
 
    for (int i = 0; i < nvariables; ++i)
    {
        int noffset = i * ncoeffs;
        tmpArray    = inarray + noffset;
        m_fields[i]->FwdTrans(tmpIn[i], tmpArray);
    }
 
    DoImplicitSolveCoeff(tmpIn, inarray, outarray, time, lambda);
 
    if (m_meshDistorted)
    {
 
        for (int i = 0; i < nvariables; ++i)
        {
            tmpOut[i]      = Array<OneD, NekDouble>(tmpIn[0].size(), 0.0);
            tmpoutarray[i] = Array<OneD, NekDouble>(ncoeffs, 0.0);
        }
        for (int i = 0; i < nvariables; ++i)
        {
            int noffset = i * ncoeffs;
            tmpArray    = outarray + noffset;
            m_fields[i]->BwdTrans(tmpArray, tmpOut[i]);
        }
        MultiRegions::GlobalMatrixKey mkey(StdRegions::eMass);
        for (int i = 0; i < nvariables; ++i)
        {
            m_fields[i]->FwdTrans(tmpOut[i], tmpoutarray[i]);
            m_fields[i]->GeneralMatrixOp(mkey, tmpoutarray[i], outpnt[i]);
        }
    }
    else
    {
        for (int i = 0; i < nvariables; ++i)
        {
            int noffset = i * ncoeffs;
            tmpArray    = outarray + noffset;
            m_fields[i]->BwdTrans(tmpArray, outpnt[i]);
        }
    }
}

References Nektar::SolverUtils::ALEHelper::ALEDoElmtInvMassBwdTrans(), DoImplicitSolveCoeff(), Nektar::StdRegions::eMass, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::ALEHelper::m_meshDistorted, and m_updateShockCaptPhys.

Referenced by v_InitObject().

DoImplicitSolveCoeff()

void Nektar::CFSImplicit::DoImplicitSolveCoeff ( const Array< OneD, const Array< OneD, NekDouble > > &  inpnts, const Array< OneD, const NekDouble > &  inarray, Array< OneD, NekDouble > &  out, const NekDouble  time, const NekDouble  lambda  )

protected

Definition at line 446 of file CompressibleFlowSystemImplicit.cpp.

{
    m_TimeIntegLambda   = lambda;
    m_bndEvaluateTime   = time;
    m_solutionPhys      = inpnts;
    unsigned int ntotal = inarray.size();
 
    if (m_inArrayNorm < 0.0)
    {
        CalcRefValues(inarray);
 
        m_nonlinsol->SetRhsMagnitude(m_inArrayNorm);
    }
 
    m_TotNewtonIts += m_nonlinsol->SolveSystem(ntotal, inarray, out);
 
    m_TotLinIts += m_nonlinsol->GetNtotLinSysIts();
 
    m_TotImpStages++;
}

References CalcRefValues(), Nektar::CompressibleFlowSystem::m_bndEvaluateTime, m_inArrayNorm, m_nonlinsol, m_solutionPhys, m_TimeIntegLambda, m_TotImpStages, m_TotLinIts, and m_TotNewtonIts.

Referenced by DoImplicitSolve().

DoOdeImplicitRhs()

void Nektar::CFSImplicit::DoOdeImplicitRhs ( const Array< OneD, const Array< OneD, NekDouble > > &  inarray, Array< OneD, Array< OneD, NekDouble > > &  outarray, const NekDouble  time  )

protected

Definition at line 256 of file CompressibleFlowSystemImplicit.cpp.

{
    int nvariables = inarray.size();
    int ncoeffs    = m_fields[0]->GetNcoeffs();
 
    Array<OneD, Array<OneD, NekDouble>> tmpOut(nvariables);
    for (int i = 0; i < nvariables; ++i)
    {
        tmpOut[i] = Array<OneD, NekDouble>(ncoeffs);
    }
 
    DoOdeRhsCoeff(inarray, tmpOut, time);
 
    for (int i = 0; i < nvariables; ++i)
    {
        m_fields[i]->BwdTrans(tmpOut[i], outarray[i]);
    }
}

References DoOdeRhsCoeff(), and Nektar::SolverUtils::EquationSystem::m_fields.

Referenced by v_InitObject().

DoOdeRhsCoeff()

void Nektar::CFSImplicit::DoOdeRhsCoeff ( const Array< OneD, const Array< OneD, NekDouble > > &  inarray, Array< OneD, Array< OneD, NekDouble > > &  outarray, const NekDouble  time  )

protected

Compute the right-hand side.

Definition at line 280 of file CompressibleFlowSystemImplicit.cpp.

{
    ASSERTL0(
        !m_useLocalTimeStep,
        "Do not use Local Time-Stepping with implicit time-discretization");
 
    LibUtilities::Timer timer;
 
    int nvariables = inarray.size();
    int nTracePts  = GetTraceTotPoints();
    int ncoeffs    = GetNcoeffs();
 
    m_bndEvaluateTime = time;
 
    // Store forwards/backwards space along trace space
    Array<OneD, Array<OneD, NekDouble>> Fwd(nvariables);
    Array<OneD, Array<OneD, NekDouble>> Bwd(nvariables);
 
    if (m_HomogeneousType == eHomogeneous1D)
    {
        Fwd = NullNekDoubleArrayOfArray;
        Bwd = NullNekDoubleArrayOfArray;
    }
    else
    {
        for (int i = 0; i < nvariables; ++i)
        {
            Fwd[i] = Array<OneD, NekDouble>(nTracePts, 0.0);
            Bwd[i] = Array<OneD, NekDouble>(nTracePts, 0.0);
            m_fields[i]->GetFwdBwdTracePhys(inarray[i], Fwd[i], Bwd[i]);
        }
        m_fields[0]->PeriodicBwdRot(Bwd);
        if (m_fields[0]->GetGraph()->GetMovement()->GetSectorRotateFlag())
        {
            m_fields[0]->RotLocalBwdTrace(Bwd);
        }
    }
 
    timer.Start();
    DoAdvectionCoeff(inarray, outarray, time, Fwd, Bwd);
    timer.Stop();
    timer.AccumulateRegion("CFSImplicit::DoAdvectionCoeff", 2);
 
    // Negate results
    for (int i = 0; i < nvariables; ++i)
    {
        Vmath::Neg(ncoeffs, outarray[i], 1);
    }
 
    // Add diffusion terms
    timer.Start();
    DoDiffusionCoeff(inarray, outarray, Fwd, Bwd);
    timer.Stop();
    timer.AccumulateRegion("CFSImplicit::DoDiffusionCoeff", 2);
 
    // Add forcing terms
    for (auto &x : m_forcing)
    {
        x->ApplyCoeff(m_fields, inarray, outarray, time);
    }
}

References Nektar::LibUtilities::Timer::AccumulateRegion(), ASSERTL0, DoAdvectionCoeff(), DoDiffusionCoeff(), Nektar::SolverUtils::EquationSystem::eHomogeneous1D, Nektar::SolverUtils::EquationSystem::GetNcoeffs(), Nektar::SolverUtils::EquationSystem::GetTraceTotPoints(), Nektar::CompressibleFlowSystem::m_bndEvaluateTime, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::CompressibleFlowSystem::m_forcing, Nektar::SolverUtils::EquationSystem::m_HomogeneousType, Nektar::CompressibleFlowSystem::m_useLocalTimeStep, Vmath::Neg(), Nektar::NullNekDoubleArrayOfArray, Nektar::LibUtilities::Timer::Start(), and Nektar::LibUtilities::Timer::Stop().

Referenced by DoOdeImplicitRhs(), and NonlinSysEvaluatorCoeff().

ElmtVarInvMtrx()

template<typename DataType , typename TypeNekBlkMatSharedPtr >

void Nektar::CFSImplicit::ElmtVarInvMtrx ( Array< OneD, Array< OneD, TypeNekBlkMatSharedPtr > > &  gmtxarray, TypeNekBlkMatSharedPtr &  gmtVar, const DataType &  tmpDatatype  )

protected

Definition at line 1102 of file CompressibleFlowSystemImplicit.cpp.

{
    int n1d               = gmtxarray.size();
    int n2d               = gmtxarray[0].size();
    int nConvectiveFields = n1d;
 
    ASSERTL0(n1d == n2d, "ElmtVarInvMtrx requires n1d==n2d");
 
    Array<OneD, unsigned int> rowSizes;
    Array<OneD, unsigned int> colSizes;
 
    gmtxarray[0][0]->GetBlockSizes(rowSizes, colSizes);
    int nTotElmt   = rowSizes.size();
    int nElmtCoef  = rowSizes[0] - 1;
    int nElmtCoef0 = -1;
    int blocksize  = -1;
 
    Array<OneD, unsigned int> tmprow(1);
    TypeNekBlkMatSharedPtr tmpGmtx;
 
    Array<OneD, DataType> GMatData, ElmtMatData;
    Array<OneD, DataType> tmpArray1, tmpArray2;
 
    for (int nelmt = 0; nelmt < nTotElmt; nelmt++)
    {
        int nrows = gmtxarray[0][0]->GetBlock(nelmt, nelmt)->GetRows();
        int ncols = gmtxarray[0][0]->GetBlock(nelmt, nelmt)->GetColumns();
        ASSERTL0(nrows == ncols, "ElmtVarInvMtrx requires nrows==ncols");
 
        nElmtCoef = nrows;
 
        if (nElmtCoef0 != nElmtCoef)
        {
            nElmtCoef0       = nElmtCoef;
            int nElmtCoefVar = nElmtCoef0 * nConvectiveFields;
            blocksize        = nElmtCoefVar * nElmtCoefVar;
            tmprow[0]        = nElmtCoefVar;
            AllocateNekBlkMatDig(tmpGmtx, tmprow, tmprow);
            GMatData = tmpGmtx->GetBlock(0, 0)->GetPtr();
        }
 
        for (int n = 0; n < nConvectiveFields; n++)
        {
            for (int m = 0; m < nConvectiveFields; m++)
            {
                ElmtMatData = gmtxarray[m][n]->GetBlock(nelmt, nelmt)->GetPtr();
 
                for (int ncl = 0; ncl < nElmtCoef; ncl++)
                {
                    int Goffset =
                        (n * nElmtCoef + ncl) * nConvectiveFields * nElmtCoef +
                        m * nElmtCoef;
                    int Eoffset = ncl * nElmtCoef;
 
                    Vmath::Vcopy(nElmtCoef, tmpArray1 = ElmtMatData + Eoffset,
                                 1, tmpArray2         = GMatData + Goffset, 1);
                }
            }
        }
 
        tmpGmtx->GetBlock(0, 0)->Invert();
 
        for (int m = 0; m < nConvectiveFields; m++)
        {
            for (int n = 0; n < nConvectiveFields; n++)
            {
                ElmtMatData = gmtxarray[m][n]->GetBlock(nelmt, nelmt)->GetPtr();
 
                for (int ncl = 0; ncl < nElmtCoef; ncl++)
                {
                    int Goffset =
                        (n * nElmtCoef + ncl) * nConvectiveFields * nElmtCoef +
                        m * nElmtCoef;
                    int Eoffset = ncl * nElmtCoef;
 
                    Vmath::Vcopy(nElmtCoef, tmpArray1 = GMatData + Goffset, 1,
                                 tmpArray2 = ElmtMatData + Eoffset, 1);
                }
            }
        }
        ElmtMatData = gmtVar->GetBlock(nelmt, nelmt)->GetPtr();
        Vmath::Vcopy(blocksize, GMatData, 1, ElmtMatData, 1);
    }
    return;
}

References AllocateNekBlkMatDig(), ASSERTL0, and Vmath::Vcopy().

Referenced by CalcPreconMatBRJCoeff().

Fill1DArrayOfBlkDiagonalMat()

template<typename DataType , typename TypeNekBlkMatSharedPtr >

void Nektar::CFSImplicit::Fill1DArrayOfBlkDiagonalMat ( Array< OneD, TypeNekBlkMatSharedPtr > &  gmtxarray, const DataType  valu  )

protected

Definition at line 1873 of file CompressibleFlowSystemImplicit.cpp.

{
    int n1d = gmtxarray.size();
 
    Array<OneD, unsigned int> rowSizes;
    Array<OneD, unsigned int> colSizes;
 
    Array<OneD, DataType> loc_mat_arr;
 
    for (int n1 = 0; n1 < n1d; ++n1)
    {
        gmtxarray[n1]->GetBlockSizes(rowSizes, colSizes);
        int nelmts = rowSizes.size();
 
        for (int i = 0; i < nelmts; ++i)
        {
            loc_mat_arr = gmtxarray[n1]->GetBlock(i, i)->GetPtr();
 
            int nrows = gmtxarray[n1]->GetBlock(i, i)->GetRows();
            int ncols = gmtxarray[n1]->GetBlock(i, i)->GetColumns();
 
            Vmath::Fill(nrows * ncols, valu, loc_mat_arr, 1);
        }
    }
}

References Vmath::Fill().

Referenced by Fill2DArrayOfBlkDiagonalMat().

Fill2DArrayOfBlkDiagonalMat()

template<typename DataType , typename TypeNekBlkMatSharedPtr >

void Nektar::CFSImplicit::Fill2DArrayOfBlkDiagonalMat ( Array< OneD, Array< OneD, TypeNekBlkMatSharedPtr > > &  gmtxarray, const DataType  valu  )

protected

Definition at line 1860 of file CompressibleFlowSystemImplicit.cpp.

{
    int n1d = gmtxarray.size();
 
    for (int n1 = 0; n1 < n1d; ++n1)
    {
        Fill1DArrayOfBlkDiagonalMat(gmtxarray[n1], valu);
    }
}

References Fill1DArrayOfBlkDiagonalMat().

Referenced by CalcPreconMatBRJCoeff().

GetFluxDerivJacDirctn() [1/2]

void Nektar::CFSImplicit::GetFluxDerivJacDirctn ( const MultiRegions::ExpListSharedPtr &  explist, const Array< OneD, const Array< OneD, NekDouble > > &  normals, const int  nDervDir, const Array< OneD, const Array< OneD, NekDouble > > &  inarray, Array< OneD, Array< OneD, DNekMatSharedPtr > > &  ElmtJac  )

inlineprotected

Definition at line 324 of file CompressibleFlowSystemImplicit.h.

    {
        v_GetFluxDerivJacDirctn(explist, normals, nDervDir, inarray, ElmtJac);
    }

References v_GetFluxDerivJacDirctn().

GetFluxDerivJacDirctn() [2/2]

void Nektar::CFSImplicit::GetFluxDerivJacDirctn ( const MultiRegions::ExpListSharedPtr &  explist, const Array< OneD, const Array< OneD, NekDouble > > &  normals, const int  nDervDir, const Array< OneD, const Array< OneD, NekDouble > > &  inarray, TensorOfArray5D< NekDouble > &  ElmtJacArray, const int  nFluxDir  )

inlineprotected

Definition at line 300 of file CompressibleFlowSystemImplicit.h.

    {
        v_GetFluxDerivJacDirctn(explist, normals, nDervDir, inarray,
                                ElmtJacArray, nFluxDir);
    }

References v_GetFluxDerivJacDirctn().

GetFluxDerivJacDirctnElmt()

void Nektar::CFSImplicit::GetFluxDerivJacDirctnElmt ( const int  nConvectiveFields, const int  nElmtPnt, const int  nDervDir, const Array< OneD, const Array< OneD, NekDouble > > &  locVars, const Array< OneD, NekDouble > &  locmu, const Array< OneD, const Array< OneD, NekDouble > > &  locnormal, DNekMatSharedPtr &  wspMat, Array< OneD, Array< OneD, NekDouble > > &  PntJacArray  )

inlineprotected

Definition at line 311 of file CompressibleFlowSystemImplicit.h.

    {
        v_GetFluxDerivJacDirctnElmt(nConvectiveFields, nElmtPnt, nDervDir,
                                    locVars, locmu, locnormal, wspMat,
                                    PntJacArray);
    }

References v_GetFluxDerivJacDirctnElmt().

Referenced by AddMatNSBlkDiagVol().

GetFluxVectorJacDirElmt()

void Nektar::CFSImplicit::GetFluxVectorJacDirElmt ( const int  nConvectiveFields, const int  nElmtPnt, const Array< OneD, const Array< OneD, NekDouble > > &  locVars, const Array< OneD, NekDouble > &  normals, DNekMatSharedPtr &  wspMat, Array< OneD, Array< OneD, NekDouble > > &  PntJacArray  )

protected

Definition at line 1738 of file CompressibleFlowSystemImplicit.cpp.

{
    Array<OneD, NekDouble> wspMatData = wspMat->GetPtr();
 
    int matsize = nConvectiveFields * nConvectiveFields;
 
    Array<OneD, NekDouble> pointVar(nConvectiveFields);
 
    for (int npnt = 0; npnt < nElmtPnt; npnt++)
    {
        for (int j = 0; j < nConvectiveFields; j++)
        {
            pointVar[j] = locVars[j][npnt];
        }
 
        GetFluxVectorJacPoint(nConvectiveFields, pointVar, normals, wspMat);
 
        Vmath::Vcopy(matsize, wspMatData, 1, PntJacArray[npnt], 1);
    }
    return;
}

References GetFluxVectorJacPoint(), and Vmath::Vcopy().

Referenced by AddMatNSBlkDiagVol().

GetFluxVectorJacPoint()

void Nektar::CFSImplicit::GetFluxVectorJacPoint ( const int  nConvectiveFields, const Array< OneD, NekDouble > &  conservVar, const Array< OneD, NekDouble > &  normals, DNekMatSharedPtr &  fluxJac  )

protected

Definition at line 1764 of file CompressibleFlowSystemImplicit.cpp.

{
    int nvariables         = conservVar.size();
    const int nvariables3D = 5;
    int expDim             = m_spacedim;
 
    NekDouble fsw, efix_StegerWarming;
    efix_StegerWarming = 0.0;
    fsw                = 0.0; // exact flux Jacobian if fsw=0.0
    if (nvariables > expDim + 2)
    {
        NEKERROR(ErrorUtil::efatal, "nvariables > expDim+2 case not coded")
    }
 
    Array<OneD, NekDouble> fluxJacData;
    ;
    fluxJacData = fluxJac->GetPtr();
 
    if (nConvectiveFields == nvariables3D)
    {
        PointFluxJacobianPoint(conservVar, normals, fluxJac, efix_StegerWarming,
                               fsw);
    }
    else
    {
        DNekMatSharedPtr PointFJac3D =
            MemoryManager<DNekMat>::AllocateSharedPtr(nvariables3D,
                                                      nvariables3D, 0.0);
 
        Array<OneD, NekDouble> PointFJac3DData;
        PointFJac3DData = PointFJac3D->GetPtr();
 
        Array<OneD, NekDouble> PointFwd(nvariables3D, 0.0);
 
        Array<OneD, unsigned int> index(nvariables);
 
        index[nvariables - 1] = 4;
        for (int i = 0; i < nvariables - 1; i++)
        {
            index[i] = i;
        }
 
        int nj = 0;
        int nk = 0;
        for (int j = 0; j < nvariables; j++)
        {
            nj           = index[j];
            PointFwd[nj] = conservVar[j];
        }
 
        PointFluxJacobianPoint(PointFwd, normals, PointFJac3D,
                               efix_StegerWarming, fsw);
 
        for (int j = 0; j < nvariables; j++)
        {
            nj = index[j];
            for (int k = 0; k < nvariables; k++)
            {
                nk = index[k];
                fluxJacData[j + k * nConvectiveFields] =
                    PointFJac3DData[nj + nk * nvariables3D];
            }
        }
    }
}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::ErrorUtil::efatal, Nektar::SolverUtils::EquationSystem::m_spacedim, NEKERROR, and PointFluxJacobianPoint().

Referenced by GetFluxVectorJacDirElmt().

GetTraceJac()

template<typename DataType , typename TypeNekBlkMatSharedPtr >

void Nektar::CFSImplicit::GetTraceJac ( const Array< OneD, const Array< OneD, NekDouble > > &  inarray, TensorOfArray3D< NekDouble > &  qfield, Array< OneD, TypeNekBlkMatSharedPtr > &  TraceJac, Array< OneD, TypeNekBlkMatSharedPtr > &  TraceJacDeriv, Array< OneD, Array< OneD, DataType > > &  TraceJacDerivSign, TensorOfArray5D< DataType > &  TraceIPSymJacArray  )

protected

Definition at line 1192 of file CompressibleFlowSystemImplicit.cpp.

{
    int nvariables = inarray.size();
    int nTracePts  = GetTraceTotPoints();
 
    // Store forwards/backwards space along trace space
    Array<OneD, Array<OneD, NekDouble>> Fwd(nvariables);
    Array<OneD, Array<OneD, NekDouble>> Bwd(nvariables);
 
    TypeNekBlkMatSharedPtr FJac, BJac;
    Array<OneD, unsigned int> n_blks1(nTracePts, nvariables);
 
    if (TraceJac.size() > 0)
    {
        FJac = TraceJac[0];
        BJac = TraceJac[1];
    }
    else
    {
        TraceJac = Array<OneD, TypeNekBlkMatSharedPtr>(2);
 
        AllocateNekBlkMatDig(FJac, n_blks1, n_blks1);
        AllocateNekBlkMatDig(BJac, n_blks1, n_blks1);
    }
 
    if (m_HomogeneousType == eHomogeneous1D)
    {
        Fwd = NullNekDoubleArrayOfArray;
        Bwd = NullNekDoubleArrayOfArray;
    }
    else
    {
        for (int i = 0; i < nvariables; ++i)
        {
            Fwd[i] = Array<OneD, NekDouble>(nTracePts, 0.0);
            Bwd[i] = Array<OneD, NekDouble>(nTracePts, 0.0);
            m_fields[i]->GetFwdBwdTracePhys(inarray[i], Fwd[i], Bwd[i]);
        }
    }
 
    Array<OneD, Array<OneD, NekDouble>> AdvVel(m_spacedim);
 
    NumCalcRiemFluxJac(nvariables, m_fields, AdvVel, inarray, qfield,
                       m_bndEvaluateTime, Fwd, Bwd, FJac, BJac,
                       TraceIPSymJacArray);
 
    TraceJac[0] = FJac;
    TraceJac[1] = BJac;
}

References AllocateNekBlkMatDig(), Nektar::SolverUtils::EquationSystem::eHomogeneous1D, Nektar::SolverUtils::EquationSystem::GetTraceTotPoints(), Nektar::CompressibleFlowSystem::m_bndEvaluateTime, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::EquationSystem::m_HomogeneousType, Nektar::SolverUtils::EquationSystem::m_spacedim, Nektar::NullNekDoubleArrayOfArray, and NumCalcRiemFluxJac().

Referenced by AddMatNSBlkDiagBnd().

InitialiseNonlinSysSolver()

void Nektar::CFSImplicit::InitialiseNonlinSysSolver ( )

protected

Definition at line 81 of file CompressibleFlowSystemImplicit.cpp.

{
    int nvariables = m_fields.size();
    int ntotal     = m_fields[0]->GetNcoeffs() * nvariables;
 
    std::string SolverType = "Newton";
    if (m_session->DefinesSolverInfo("NonlinSysIterSolver"))
    {
        SolverType = m_session->GetSolverInfo("NonlinSysIterSolver");
    }
    ASSERTL0(
        LibUtilities::GetNekNonlinSysIterFactory().ModuleExists(SolverType),
        "NekNonlinSys '" + SolverType + "' is not defined.\n");
 
    // Create the key to hold settings for nonlin solver
    LibUtilities::NekSysKey key = LibUtilities::NekSysKey();
    // Load required LinSys parameters:
    m_session->LoadParameter("NekLinSysMaxIterations",
                             key.m_NekLinSysMaxIterations, 30);
    m_session->LoadParameter("LinSysMaxStorage", key.m_LinSysMaxStorage, 30);
    m_session->LoadParameter("LinSysRelativeTolInNonlin",
                             key.m_NekLinSysTolerance, 5.0E-2);
    m_session->LoadParameter("GMRESMaxHessMatBand", key.m_KrylovMaxHessMatBand,
                             31);
    m_session->MatchSolverInfo("GMRESLeftPrecon", "True",
                               key.m_NekLinSysLeftPrecon, false);
    m_session->MatchSolverInfo("GMRESRightPrecon", "True",
                               key.m_NekLinSysRightPrecon, true);
    int GMRESCentralDifference = 0;
    m_session->LoadParameter("GMRESCentralDifference", GMRESCentralDifference,
                             0);
    key.m_GMRESCentralDifference = (bool)GMRESCentralDifference;
    // Load required NonLinSys parameters:
    m_session->LoadParameter("NekNonlinSysMaxIterations",
                             key.m_NekNonlinSysMaxIterations, 10);
    m_session->LoadParameter("NewtonRelativeIteTol",
                             key.m_NekNonLinSysTolerance, 1.0E-12);
    WARNINGL0(!m_session->DefinesParameter("NewtonAbsoluteIteTol"),
              "Please specify NewtonRelativeIteTol instead of "
              "NewtonAbsoluteIteTol in XML session file");
    m_session->LoadParameter("NonlinIterTolRelativeL2",
                             key.m_NonlinIterTolRelativeL2, 1.0E-3);
    m_session->LoadSolverInfo("LinSysIterSolverTypeInNonlin",
                              key.m_LinSysIterSolverTypeInNonlin, "GMRES");
 
    // Initialize operator
    LibUtilities::NekSysOperators nekSysOp;
    nekSysOp.DefineNekSysResEval(&CFSImplicit::NonlinSysEvaluatorCoeff1D, this);
    nekSysOp.DefineNekSysLhsEval(&CFSImplicit::MatrixMultiplyMatrixFreeCoeff,
                                 this);
    nekSysOp.DefineNekSysPrecon(&CFSImplicit::PreconCoeff, this);
 
    // Initialize trace
    const auto locTraceToTraceMap = m_fields[0]->GetLocTraceToTraceMap();
    locTraceToTraceMap->CalcLocTracePhysToTraceIDMap(m_fields[0]->GetTrace(),
                                                     m_spacedim);
    for (int i = 1; i < nvariables; i++)
    {
        m_fields[i]->GetLocTraceToTraceMap()->SetLocTracePhysToTraceIDMap(
            locTraceToTraceMap->GetLocTracephysToTraceIDMap());
    }
 
    // Initialize non-linear system
    m_nonlinsol = LibUtilities::GetNekNonlinSysIterFactory().CreateInstance(
        "Newton", m_session, m_comm->GetRowComm(), ntotal, key);
    m_nonlinsol->SetSysOperators(nekSysOp);
 
    // Initialize preconditioner
    NekPreconCfsOperators preconOp;
    preconOp.DefineCalcPreconMatBRJCoeff(&CFSImplicit::CalcPreconMatBRJCoeff,
                                         this);
    m_preconCfs = GetPreconCfsFactory().CreateInstance("PreconCfsBRJ", m_fields,
                                                       m_session, m_comm);
    m_preconCfs->SetOperators(preconOp);
}

References ASSERTL0, CalcPreconMatBRJCoeff(), Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::CreateInstance(), Nektar::NekPreconCfsOperators::DefineCalcPreconMatBRJCoeff(), Nektar::LibUtilities::NekSysOperators::DefineNekSysLhsEval(), Nektar::LibUtilities::NekSysOperators::DefineNekSysPrecon(), Nektar::LibUtilities::NekSysOperators::DefineNekSysResEval(), Nektar::LibUtilities::GetNekNonlinSysIterFactory(), Nektar::GetPreconCfsFactory(), Nektar::SolverUtils::EquationSystem::m_comm, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::LibUtilities::NekSysKey::m_GMRESCentralDifference, Nektar::LibUtilities::NekSysKey::m_KrylovMaxHessMatBand, Nektar::LibUtilities::NekSysKey::m_LinSysIterSolverTypeInNonlin, Nektar::LibUtilities::NekSysKey::m_LinSysMaxStorage, Nektar::LibUtilities::NekSysKey::m_NekLinSysLeftPrecon, Nektar::LibUtilities::NekSysKey::m_NekLinSysMaxIterations, Nektar::LibUtilities::NekSysKey::m_NekLinSysRightPrecon, Nektar::LibUtilities::NekSysKey::m_NekLinSysTolerance, Nektar::LibUtilities::NekSysKey::m_NekNonlinSysMaxIterations, Nektar::LibUtilities::NekSysKey::m_NekNonLinSysTolerance, Nektar::LibUtilities::NekSysKey::m_NonlinIterTolRelativeL2, m_nonlinsol, m_preconCfs, Nektar::SolverUtils::EquationSystem::m_session, Nektar::SolverUtils::EquationSystem::m_spacedim, MatrixMultiplyMatrixFreeCoeff(), NonlinSysEvaluatorCoeff1D(), PreconCoeff(), and WARNINGL0.

Referenced by v_InitObject().

MatrixMultiplyMatrixFreeCoeff()

void Nektar::CFSImplicit::MatrixMultiplyMatrixFreeCoeff ( const Array< OneD, const NekDouble > &  inarray, Array< OneD, NekDouble > &  out, const bool &  centralDifferenceFlag  )

protected

Definition at line 524 of file CompressibleFlowSystemImplicit.cpp.

{
    const Array<OneD, const NekDouble> solref = m_nonlinsol->GetRefSolution();
 
    unsigned int ntotal   = inarray.size();
    NekDouble magninarray = Vmath::Dot(ntotal, inarray, inarray);
    m_comm->GetSpaceComm()->AllReduce(magninarray,
                                      Nektar::LibUtilities::ReduceSum);
    NekDouble eps =
        m_jacobiFreeEps * sqrt((sqrt(m_inArrayNorm) + 1.0) / magninarray);
 
    Array<OneD, NekDouble> solplus{ntotal};
    Array<OneD, NekDouble> resplus{ntotal};
    Vmath::Svtvp(ntotal, eps, inarray, 1, solref, 1, solplus, 1);
    NonlinSysEvaluatorCoeff1D(solplus, resplus, !centralDifferenceFlag);
 
    if (centralDifferenceFlag)
    {
        Array<OneD, NekDouble> solminus{ntotal};
        Array<OneD, NekDouble> resminus{ntotal};
        Vmath::Svtvp(ntotal, -1.0 * eps, inarray, 1, solref, 1, solminus, 1);
        NonlinSysEvaluatorCoeff1D(solminus, resminus, false);
        Vmath::Vsub(ntotal, resplus, 1, resminus, 1, out, 1);
        Vmath::Smul(ntotal, 0.5 / eps, out, 1, out, 1);
    }
    else
    {
        const Array<OneD, const NekDouble> resref =
            m_nonlinsol->GetRefResidual();
 
        Vmath::Vsub(ntotal, resplus, 1, resref, 1, out, 1);
        Vmath::Smul(ntotal, 1.0 / eps, out, 1, out, 1);
    }
}

References Vmath::Dot(), Nektar::SolverUtils::EquationSystem::m_comm, m_inArrayNorm, m_jacobiFreeEps, m_nonlinsol, NonlinSysEvaluatorCoeff1D(), Nektar::LibUtilities::ReduceSum, Vmath::Smul(), tinysimd::sqrt(), Vmath::Svtvp(), and Vmath::Vsub().

Referenced by InitialiseNonlinSysSolver().

MinusDiffusionFluxJacPoint()

void Nektar::CFSImplicit::MinusDiffusionFluxJacPoint ( const int  nConvectiveFields, const int  nElmtPnt, const Array< OneD, const Array< OneD, NekDouble > > &  locVars, const TensorOfArray3D< NekDouble > &  locDerv, const Array< OneD, NekDouble > &  locmu, const Array< OneD, NekDouble > &  locDmuDT, const Array< OneD, NekDouble > &  normals, DNekMatSharedPtr &  wspMat, Array< OneD, Array< OneD, NekDouble > > &  PntJacArray  )

inlineprotected

Definition at line 286 of file CompressibleFlowSystemImplicit.h.

    {
        v_MinusDiffusionFluxJacPoint(nConvectiveFields, nElmtPnt, locVars,
                                     locDerv, locmu, locDmuDT, normals, wspMat,
                                     PntJacArray);
    }

References v_MinusDiffusionFluxJacPoint().

Referenced by AddMatNSBlkDiagVol().

MultiplyElmtInvMassPlusSource()

template<typename DataType , typename TypeNekBlkMatSharedPtr >

void Nektar::CFSImplicit::MultiplyElmtInvMassPlusSource ( Array< OneD, Array< OneD, TypeNekBlkMatSharedPtr > > &  gmtxarray, const NekDouble  dtlamda  )

protected

Definition at line 1576 of file CompressibleFlowSystemImplicit.cpp.

{
    MultiRegions::ExpListSharedPtr explist              = m_fields[0];
    std::shared_ptr<LocalRegions::ExpansionVector> pexp = explist->GetExp();
    int nTotElmt                                        = (*pexp).size();
    int nConvectiveFields                               = m_fields.size();
 
    NekDouble Negdtlamda = -dtlamda;
 
    Array<OneD, NekDouble> pseudotimefactor(nTotElmt, 0.0);
    Vmath::Fill(nTotElmt, Negdtlamda, pseudotimefactor, 1);
 
    Array<OneD, DataType> GMatData;
    for (int m = 0; m < nConvectiveFields; m++)
    {
        for (int n = 0; n < nConvectiveFields; n++)
        {
            for (int nelmt = 0; nelmt < nTotElmt; nelmt++)
            {
                GMatData = gmtxarray[m][n]->GetBlock(nelmt, nelmt)->GetPtr();
                DataType factor = DataType(pseudotimefactor[nelmt]);
 
                Vmath::Smul(GMatData.size(), factor, GMatData, 1, GMatData, 1);
            }
        }
    }
 
    DNekMatSharedPtr MassMat;
    Array<OneD, NekDouble> BwdMatData, MassMatData, tmp;
    Array<OneD, NekDouble> tmp2;
    Array<OneD, DataType> MassMatDataDataType;
    LibUtilities::ShapeType ElmtTypePrevious = LibUtilities::eNoShapeType;
 
    for (int nelmt = 0; nelmt < nTotElmt; nelmt++)
    {
        int nelmtcoef = GetNcoeffs(nelmt);
        int nelmtpnts = GetTotPoints(nelmt);
        LibUtilities::ShapeType ElmtTypeNow =
            explist->GetExp(nelmt)->DetShapeType();
 
        if (tmp.size() != nelmtcoef || (ElmtTypeNow != ElmtTypePrevious))
        {
            StdRegions::StdExpansionSharedPtr stdExp;
            stdExp = explist->GetExp(nelmt)->GetStdExp();
            StdRegions::StdMatrixKey matkey(StdRegions::eBwdTrans,
                                            stdExp->DetShapeType(), *stdExp);
 
            DNekMatSharedPtr BwdMat = stdExp->GetStdMatrix(matkey);
            BwdMatData              = BwdMat->GetPtr();
 
            if (nelmtcoef != tmp.size())
            {
                tmp     = Array<OneD, NekDouble>(nelmtcoef, 0.0);
                MassMat = MemoryManager<DNekMat>::AllocateSharedPtr(
                    nelmtcoef, nelmtcoef, 0.0);
                MassMatData = MassMat->GetPtr();
                MassMatDataDataType =
                    Array<OneD, DataType>(nelmtcoef * nelmtcoef);
            }
 
            ElmtTypePrevious = ElmtTypeNow;
        }
 
        for (int np = 0; np < nelmtcoef; np++)
        {
            explist->GetExp(nelmt)->IProductWRTBase(BwdMatData + np * nelmtpnts,
                                                    tmp);
            Vmath::Vcopy(nelmtcoef, tmp, 1, tmp2 = MassMatData + np * nelmtcoef,
                         1);
        }
        for (int i = 0; i < MassMatData.size(); i++)
        {
            MassMatDataDataType[i] = DataType(MassMatData[i]);
        }
 
        for (int m = 0; m < nConvectiveFields; m++)
        {
            GMatData = gmtxarray[m][m]->GetBlock(nelmt, nelmt)->GetPtr();
            Vmath::Vadd(MassMatData.size(), MassMatDataDataType, 1, GMatData, 1,
                        GMatData, 1);
        }
    }
    return;
}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::StdRegions::eBwdTrans, Nektar::LibUtilities::eNoShapeType, Vmath::Fill(), Nektar::SolverUtils::EquationSystem::GetNcoeffs(), Nektar::SolverUtils::EquationSystem::GetTotPoints(), Nektar::SolverUtils::EquationSystem::m_fields, Vmath::Smul(), Vmath::Vadd(), and Vmath::Vcopy().

NonlinSysEvaluatorCoeff()

void Nektar::CFSImplicit::NonlinSysEvaluatorCoeff ( const Array< OneD, const Array< OneD, NekDouble > > &  inarray, Array< OneD, Array< OneD, NekDouble > > &  out, const bool &  flag  )

protected

Definition at line 216 of file CompressibleFlowSystemImplicit.cpp.

{
    LibUtilities::Timer timer;
    unsigned int nvariable = inarray.size();
    unsigned int ncoeffs   = m_fields[0]->GetNcoeffs();
    unsigned int npoints   = m_fields[0]->GetNpoints();
 
    Array<OneD, Array<OneD, NekDouble>> inpnts(nvariable);
 
    for (int i = 0; i < nvariable; ++i)
    {
        inpnts[i] = Array<OneD, NekDouble>(npoints, 0.0);
        m_fields[i]->BwdTrans(inarray[i], inpnts[i]);
    }
 
    timer.Start();
    DoOdeProjection(inpnts, inpnts, m_bndEvaluateTime);
    timer.Stop();
    timer.AccumulateRegion("CompressibleFlowSystem::DoOdeProjection", 1);
 
    timer.Start();
    DoOdeRhsCoeff(inpnts, out, m_bndEvaluateTime);
    timer.Stop();
    timer.AccumulateRegion("CFSImplicit::DoOdeRhsCoeff", 1);
 
    for (int i = 0; i < nvariable; ++i)
    {
        Vmath::Svtvp(ncoeffs, -m_TimeIntegLambda, out[i], 1, inarray[i], 1,
                     out[i], 1);
        if (flag)
        {
            Vmath::Vsub(ncoeffs, out[i], 1,
                        m_nonlinsol->GetRefSourceVec() + i * ncoeffs, 1, out[i],
                        1);
        }
    }
}

References Nektar::LibUtilities::Timer::AccumulateRegion(), Nektar::CompressibleFlowSystem::DoOdeProjection(), DoOdeRhsCoeff(), Nektar::CompressibleFlowSystem::m_bndEvaluateTime, Nektar::SolverUtils::EquationSystem::m_fields, m_nonlinsol, m_TimeIntegLambda, Nektar::LibUtilities::Timer::Start(), Nektar::LibUtilities::Timer::Stop(), Vmath::Svtvp(), and Vmath::Vsub().

Referenced by NonlinSysEvaluatorCoeff1D().

NonlinSysEvaluatorCoeff1D()

void Nektar::CFSImplicit::NonlinSysEvaluatorCoeff1D ( const Array< OneD, const NekDouble > &  inarray, Array< OneD, NekDouble > &  out, const bool &  flag  )

protected

Definition at line 194 of file CompressibleFlowSystemImplicit.cpp.

{
    LibUtilities::Timer timer;
    unsigned int nvariables = m_fields.size();
    unsigned int ncoeffs    = m_fields[0]->GetNcoeffs();
    Array<OneD, Array<OneD, NekDouble>> in2D(nvariables);
    Array<OneD, Array<OneD, NekDouble>> out2D(nvariables);
    for (int i = 0; i < nvariables; ++i)
    {
        int offset = i * ncoeffs;
        in2D[i]    = inarray + offset;
        out2D[i]   = out + offset;
    }
 
    timer.Start();
    NonlinSysEvaluatorCoeff(in2D, out2D, flag);
    timer.Stop();
    timer.AccumulateRegion("CFSImplicit::NonlinSysEvaluatorCoeff1D");
}

References Nektar::LibUtilities::Timer::AccumulateRegion(), Nektar::SolverUtils::EquationSystem::m_fields, NonlinSysEvaluatorCoeff(), Nektar::LibUtilities::Timer::Start(), and Nektar::LibUtilities::Timer::Stop().

Referenced by InitialiseNonlinSysSolver(), and MatrixMultiplyMatrixFreeCoeff().

NumCalcRiemFluxJac()

template<typename DataType , typename TypeNekBlkMatSharedPtr >

void Nektar::CFSImplicit::NumCalcRiemFluxJac ( const int  nConvectiveFields, const Array< OneD, MultiRegions::ExpListSharedPtr > &  fields, const Array< OneD, const Array< OneD, NekDouble > > &  AdvVel, const Array< OneD, const Array< OneD, NekDouble > > &  inarray, TensorOfArray3D< NekDouble > &  qfield, const NekDouble &  time, const Array< OneD, const Array< OneD, NekDouble > > &  Fwd, const Array< OneD, const Array< OneD, NekDouble > > &  Bwd, TypeNekBlkMatSharedPtr &  FJac, TypeNekBlkMatSharedPtr &  BJac, TensorOfArray5D< DataType > &  TraceIPSymJacArray  )

protected

Definition at line 1249 of file CompressibleFlowSystemImplicit.cpp.

{
    const NekDouble PenaltyFactor2 = 0.0;
    int nvariables                 = nConvectiveFields;
    int npoints                    = GetNpoints();
    int nTracePts                  = GetTraceTotPoints();
    int nDim                       = m_spacedim;
 
    Array<OneD, int> nonZeroIndex;
 
    Array<OneD, Array<OneD, NekDouble>> tmpinarry(nvariables);
    for (int i = 0; i < nvariables; i++)
    {
        tmpinarry[i] = Array<OneD, NekDouble>(npoints, 0.0);
        Vmath::Vcopy(npoints, inarray[i], 1, tmpinarry[i], 1);
    }
 
    // DmuDT of artificial diffusion is neglected
    // TODO: to consider the Jacobian of AV seperately
    Array<OneD, NekDouble> muvar      = NullNekDouble1DArray;
    Array<OneD, NekDouble> MuVarTrace = NullNekDouble1DArray;
 
    Array<OneD, Array<OneD, NekDouble>> numflux(nvariables);
    for (int i = 0; i < nvariables; ++i)
    {
        numflux[i] = Array<OneD, NekDouble>(nTracePts, 0.0);
    }
 
    const MultiRegions::AssemblyMapDGSharedPtr TraceMap =
        fields[0]->GetTraceMap();
    const MultiRegions::InterfaceMapDGSharedPtr InterfaceMap =
        fields[0]->GetInterfaceMap();
    TensorOfArray3D<NekDouble> qBwd(nDim);
    TensorOfArray3D<NekDouble> qFwd(nDim);
    if (m_viscousJacFlag)
    {
        for (int nd = 0; nd < nDim; ++nd)
        {
            qBwd[nd] = Array<OneD, Array<OneD, NekDouble>>(nConvectiveFields);
            qFwd[nd] = Array<OneD, Array<OneD, NekDouble>>(nConvectiveFields);
            for (int i = 0; i < nConvectiveFields; ++i)
            {
                qBwd[nd][i] = Array<OneD, NekDouble>(nTracePts, 0.0);
                qFwd[nd][i] = Array<OneD, NekDouble>(nTracePts, 0.0);
 
                fields[i]->GetFwdBwdTracePhys(qfield[nd][i], qFwd[nd][i],
                                              qBwd[nd][i], true, true, false);
                TraceMap->GetAssemblyCommDG()->PerformExchange(qFwd[nd][i],
                                                               qBwd[nd][i]);
                InterfaceMap->ExchangeTrace(qFwd[nd][i], qBwd[nd][i]);
            }
        }
    }
 
    CalcTraceNumericalFlux(nConvectiveFields, nDim, npoints, nTracePts,
                           PenaltyFactor2, fields, AdvVel, inarray, time,
                           qfield, Fwd, Bwd, qFwd, qBwd, MuVarTrace,
                           nonZeroIndex, numflux);
 
    int nFields = nvariables;
    Array<OneD, Array<OneD, NekDouble>> plusFwd(nFields), plusBwd(nFields);
    Array<OneD, Array<OneD, NekDouble>> Jacvect(nFields);
    Array<OneD, Array<OneD, NekDouble>> FwdBnd(nFields);
    Array<OneD, Array<OneD, NekDouble>> plusflux(nFields);
    for (int i = 0; i < nFields; i++)
    {
        Jacvect[i]  = Array<OneD, NekDouble>(nTracePts, 0.0);
        plusFwd[i]  = Array<OneD, NekDouble>(nTracePts, 0.0);
        plusBwd[i]  = Array<OneD, NekDouble>(nTracePts, 0.0);
        plusflux[i] = Array<OneD, NekDouble>(nTracePts, 0.0);
        FwdBnd[i]   = Array<OneD, NekDouble>(nTracePts, 0.0);
    }
 
    for (int i = 0; i < nFields; i++)
    {
        Vmath::Vcopy(nTracePts, Fwd[i], 1, plusFwd[i], 1);
        Vmath::Vcopy(nTracePts, Bwd[i], 1, plusBwd[i], 1);
    }
 
    NekDouble eps = 1.0E-6;
 
    Array<OneD, DataType> tmpMatData;
    // Fwd Jacobian
    for (int i = 0; i < nFields; i++)
    {
        NekDouble epsvar  = eps * m_magnitdEstimat[i];
        NekDouble oepsvar = 1.0 / epsvar;
        Vmath::Sadd(nTracePts, epsvar, Fwd[i], 1, plusFwd[i], 1);
 
        if (m_bndConds.size())
        {
            for (int i = 0; i < nFields; i++)
            {
                Vmath::Vcopy(nTracePts, plusFwd[i], 1, FwdBnd[i], 1);
            }
            // Loop over user-defined boundary conditions
            for (auto &x : m_bndConds)
            {
                x->Apply(FwdBnd, tmpinarry, time);
            }
        }
 
        for (int j = 0; j < nFields; j++)
        {
            m_fields[j]->FillBwdWithBoundCond(plusFwd[j], plusBwd[j]);
        }
 
        CalcTraceNumericalFlux(nConvectiveFields, nDim, npoints, nTracePts,
                               PenaltyFactor2, fields, AdvVel, inarray, time,
                               qfield, plusFwd, plusBwd, qFwd, qBwd, MuVarTrace,
                               nonZeroIndex, plusflux);
 
        for (int n = 0; n < nFields; n++)
        {
            Vmath::Vsub(nTracePts, plusflux[n], 1, numflux[n], 1, Jacvect[n],
                        1);
            Vmath::Smul(nTracePts, oepsvar, Jacvect[n], 1, Jacvect[n], 1);
        }
        for (int j = 0; j < nTracePts; j++)
        {
            tmpMatData = FJac->GetBlock(j, j)->GetPtr();
            for (int n = 0; n < nFields; n++)
            {
                tmpMatData[n + i * nFields] = DataType(Jacvect[n][j]);
            }
        }
 
        Vmath::Vcopy(nTracePts, Fwd[i], 1, plusFwd[i], 1);
    }
 
    // Reset the boundary conditions
    if (m_bndConds.size())
    {
        for (int i = 0; i < nFields; i++)
        {
            Vmath::Vcopy(nTracePts, Fwd[i], 1, FwdBnd[i], 1);
        }
        // Loop over user-defined boundary conditions
        for (auto &x : m_bndConds)
        {
            x->Apply(FwdBnd, tmpinarry, time);
        }
    }
 
    for (int i = 0; i < nFields; i++)
    {
        Vmath::Vcopy(nTracePts, Bwd[i], 1, plusBwd[i], 1);
    }
 
    for (int i = 0; i < nFields; i++)
    {
        NekDouble epsvar  = eps * m_magnitdEstimat[i];
        NekDouble oepsvar = 1.0 / epsvar;
 
        Vmath::Sadd(nTracePts, epsvar, Bwd[i], 1, plusBwd[i], 1);
 
        for (int j = 0; j < nFields; j++)
        {
            m_fields[j]->FillBwdWithBoundCond(Fwd[j], plusBwd[j]);
        }
 
        CalcTraceNumericalFlux(nConvectiveFields, nDim, npoints, nTracePts,
                               PenaltyFactor2, fields, AdvVel, inarray, time,
                               qfield, Fwd, plusBwd, qFwd, qBwd, MuVarTrace,
                               nonZeroIndex, plusflux);
 
        for (int n = 0; n < nFields; n++)
        {
            Vmath::Vsub(nTracePts, plusflux[n], 1, numflux[n], 1, Jacvect[n],
                        1);
            Vmath::Smul(nTracePts, oepsvar, Jacvect[n], 1, Jacvect[n], 1);
        }
        for (int j = 0; j < nTracePts; j++)
        {
            tmpMatData = BJac->GetBlock(j, j)->GetPtr();
            for (int n = 0; n < nFields; n++)
            {
                tmpMatData[n + i * nFields] = DataType(Jacvect[n][j]);
            }
        }
 
        Vmath::Vcopy(nTracePts, Bwd[i], 1, plusBwd[i], 1);
    }
}

References CalcTraceNumericalFlux(), Nektar::SolverUtils::EquationSystem::GetNpoints(), Nektar::SolverUtils::EquationSystem::GetTraceTotPoints(), Nektar::CompressibleFlowSystem::m_bndConds, Nektar::SolverUtils::EquationSystem::m_fields, m_magnitdEstimat, Nektar::SolverUtils::EquationSystem::m_spacedim, m_viscousJacFlag, Nektar::NullNekDouble1DArray, Vmath::Sadd(), Vmath::Smul(), Vmath::Vcopy(), and Vmath::Vsub().

Referenced by GetTraceJac().

PointFluxJacobianPoint()

void Nektar::CFSImplicit::PointFluxJacobianPoint ( const Array< OneD, NekDouble > &  Fwd, const Array< OneD, NekDouble > &  normals, DNekMatSharedPtr &  FJac, const NekDouble  efix, const NekDouble  fsw  )

protected

Definition at line 1904 of file CompressibleFlowSystemImplicit.cpp.

{
    Array<OneD, NekDouble> FJacData = FJac->GetPtr();
    const int nvariables3D          = 5;
 
    NekDouble ro, vx, vy, vz, ps, gama, ae;
    NekDouble a, a2, h, h0, v2, vn, eps, eps2;
    NekDouble nx, ny, nz;
    NekDouble sn, osn, nxa, nya, nza, vna;
    NekDouble l1, l4, l5, al1, al4, al5, x1, x2, x3, y1;
    NekDouble c1, d1, c2, d2, c3, d3, c4, d4, c5, d5;
    NekDouble sml_ssf = 1.0E-12;
 
    NekDouble fExactorSplt = 2.0 - abs(fsw); // if fsw=+-1 calculate
 
    NekDouble rhoL  = Fwd[0];
    NekDouble rhouL = Fwd[1];
    NekDouble rhovL = Fwd[2];
    NekDouble rhowL = Fwd[3];
    NekDouble EL    = Fwd[4];
 
    ro = rhoL;
    vx = rhouL / rhoL;
    vy = rhovL / rhoL;
    vz = rhowL / rhoL;
 
    // Internal energy (per unit mass)
    NekDouble eL = (EL - 0.5 * (rhouL * vx + rhovL * vy + rhowL * vz)) / rhoL;
 
    ps   = m_varConv->Geteos()->GetPressure(rhoL, eL);
    gama = m_gamma;
 
    ae = gama - 1.0;
    v2 = vx * vx + vy * vy + vz * vz;
    a2 = gama * ps / ro;
    h  = a2 / ae;
 
    h0 = h + 0.5 * v2;
    a  = sqrt(a2);
 
    nx  = normals[0];
    ny  = normals[1];
    nz  = normals[2];
    vn  = nx * vx + ny * vy + nz * vz;
    sn  = std::max(sqrt(nx * nx + ny * ny + nz * nz), sml_ssf);
    osn = 1.0 / sn;
 
    nxa = nx * osn;
    nya = ny * osn;
    nza = nz * osn;
    vna = vn * osn;
    l1  = vn;
    l4  = vn + sn * a;
    l5  = vn - sn * a;
 
    eps  = efix * sn;
    eps2 = eps * eps;
 
    al1 = sqrt(l1 * l1 + eps2);
    al4 = sqrt(l4 * l4 + eps2);
    al5 = sqrt(l5 * l5 + eps2);
 
    l1 = 0.5 * (fExactorSplt * l1 + fsw * al1);
    l4 = 0.5 * (fExactorSplt * l4 + fsw * al4);
    l5 = 0.5 * (fExactorSplt * l5 + fsw * al5);
 
    x1 = 0.5 * (l4 + l5);
    x2 = 0.5 * (l4 - l5);
    x3 = x1 - l1;
    y1 = 0.5 * v2;
    c1 = ae * x3 / a2;
    d1 = x2 / a;
 
    int nVar0           = 0;
    int nVar1           = nvariables3D;
    int nVar2           = 2 * nvariables3D;
    int nVar3           = 3 * nvariables3D;
    int nVar4           = 4 * nvariables3D;
    FJacData[nVar0]     = c1 * y1 - d1 * vna + l1;
    FJacData[nVar1]     = -c1 * vx + d1 * nxa;
    FJacData[nVar2]     = -c1 * vy + d1 * nya;
    FJacData[nVar3]     = -c1 * vz + d1 * nza;
    FJacData[nVar4]     = c1;
    c2                  = c1 * vx + d1 * nxa * ae;
    d2                  = x3 * nxa + d1 * vx;
    FJacData[1 + nVar0] = c2 * y1 - d2 * vna;
    FJacData[1 + nVar1] = -c2 * vx + d2 * nxa + l1;
    FJacData[1 + nVar2] = -c2 * vy + d2 * nya;
    FJacData[1 + nVar3] = -c2 * vz + d2 * nza;
    FJacData[1 + nVar4] = c2;
    c3                  = c1 * vy + d1 * nya * ae;
    d3                  = x3 * nya + d1 * vy;
    FJacData[2 + nVar0] = c3 * y1 - d3 * vna;
    FJacData[2 + nVar1] = -c3 * vx + d3 * nxa;
    FJacData[2 + nVar2] = -c3 * vy + d3 * nya + l1;
    FJacData[2 + nVar3] = -c3 * vz + d3 * nza;
    FJacData[2 + nVar4] = c3;
    c4                  = c1 * vz + d1 * nza * ae;
    d4                  = x3 * nza + d1 * vz;
    FJacData[3 + nVar0] = c4 * y1 - d4 * vna;
    FJacData[3 + nVar1] = -c4 * vx + d4 * nxa;
    FJacData[3 + nVar2] = -c4 * vy + d4 * nya;
    FJacData[3 + nVar3] = -c4 * vz + d4 * nza + l1;
    FJacData[3 + nVar4] = c4;
    c5                  = c1 * h0 + d1 * vna * ae;
    d5                  = x3 * vna + d1 * h0;
    FJacData[4 + nVar0] = c5 * y1 - d5 * vna;
    FJacData[4 + nVar1] = -c5 * vx + d5 * nxa;
    FJacData[4 + nVar2] = -c5 * vy + d5 * nya;
    FJacData[4 + nVar3] = -c5 * vz + d5 * nza;
    FJacData[4 + nVar4] = c5 + l1;
}

References tinysimd::abs(), Nektar::CompressibleFlowSystem::m_gamma, Nektar::CompressibleFlowSystem::m_varConv, and tinysimd::sqrt().

Referenced by GetFluxVectorJacPoint().

PreconCoeff()

void Nektar::CFSImplicit::PreconCoeff ( const Array< OneD, NekDouble > &  inarray, Array< OneD, NekDouble > &  outarray, const bool &  flag  )

protected

Definition at line 561 of file CompressibleFlowSystemImplicit.cpp.

{
    LibUtilities::Timer timer, Gtimer;
 
    Gtimer.Start();
    if (m_preconCfs->UpdatePreconMatCheck(NullNekDouble1DArray,
                                          m_TimeIntegLambda))
    {
        int nvariables = m_solutionPhys.size();
        int nphspnt    = m_solutionPhys[nvariables - 1].size();
        Array<OneD, Array<OneD, NekDouble>> intmp(nvariables);
        for (int i = 0; i < nvariables; i++)
        {
            intmp[i] = Array<OneD, NekDouble>(nphspnt, 0.0);
        }
 
        timer.Start();
        DoOdeProjection(m_solutionPhys, intmp, m_bndEvaluateTime);
        timer.Stop();
        timer.AccumulateRegion("CompressibleFlowSystem::DoOdeProjection", 1);
 
        timer.Start();
        m_preconCfs->BuildPreconCfs(m_fields, intmp, m_bndEvaluateTime,
                                    m_TimeIntegLambda);
        timer.Stop();
        timer.AccumulateRegion("PreconCfsOp::BuildPreconCfs", 1);
    }
 
    timer.Start();
    m_preconCfs->DoPreconCfs(m_fields, inarray, outarray, flag);
    timer.Stop();
    timer.AccumulateRegion("PreconCfsOp::DoPreconCfs", 1);
 
    Gtimer.Stop();
    Gtimer.AccumulateRegion("CFSImplicit::PreconCoeff");
}

References Nektar::LibUtilities::Timer::AccumulateRegion(), Nektar::CompressibleFlowSystem::DoOdeProjection(), Nektar::CompressibleFlowSystem::m_bndEvaluateTime, Nektar::SolverUtils::EquationSystem::m_fields, m_preconCfs, m_solutionPhys, m_TimeIntegLambda, Nektar::NullNekDouble1DArray, Nektar::LibUtilities::Timer::Start(), and Nektar::LibUtilities::Timer::Stop().

Referenced by InitialiseNonlinSysSolver().

TranSamesizeBlkDiagMatIntoArray()

template<typename DataType , typename TypeNekBlkMatSharedPtr >

void Nektar::CFSImplicit::TranSamesizeBlkDiagMatIntoArray ( const TypeNekBlkMatSharedPtr &  BlkMat, TensorOfArray3D< DataType > &  MatArray  )

protected

Definition at line 1833 of file CompressibleFlowSystemImplicit.cpp.

{
    Array<OneD, unsigned int> rowSizes;
    Array<OneD, unsigned int> colSizes;
    BlkMat->GetBlockSizes(rowSizes, colSizes);
    int nDiagBlks = rowSizes.size();
    int nvar0     = rowSizes[1] - rowSizes[0];
    int nvar1     = colSizes[1] - colSizes[0];
 
    Array<OneD, DataType> ElmtMatData;
 
    for (int i = 0; i < nDiagBlks; i++)
    {
        ElmtMatData = BlkMat->GetBlock(i, i)->GetPtr();
        for (int n = 0; n < nvar1; n++)
        {
            int noffset = n * nvar0;
            for (int m = 0; m < nvar0; m++)
            {
                MatArray[m][n][i] = ElmtMatData[m + noffset];
            }
        }
    }
}

Referenced by TransTraceJacMatToArray().

TransTraceJacMatToArray()

template<typename DataType , typename TypeNekBlkMatSharedPtr >

void Nektar::CFSImplicit::TransTraceJacMatToArray ( const Array< OneD, TypeNekBlkMatSharedPtr > &  TraceJac, TensorOfArray4D< DataType > &  TraceJacDerivArray  )

protected

Definition at line 1664 of file CompressibleFlowSystemImplicit.cpp.

{
    int nFwdBwd, nDiagBlks, nvar0Jac, nvar1Jac;
 
    Array<OneD, unsigned int> rowSizes;
    Array<OneD, unsigned int> colSizes;
    nFwdBwd = TraceJac.size();
    TraceJac[0]->GetBlockSizes(rowSizes, colSizes);
    nDiagBlks = rowSizes.size();
    nvar0Jac  = rowSizes[1] - rowSizes[0];
    nvar1Jac  = colSizes[1] - colSizes[0];
 
    if (0 == TraceJacArray.size())
    {
        TraceJacArray = TensorOfArray4D<DataType>(nFwdBwd);
        for (int nlr = 0; nlr < nFwdBwd; nlr++)
        {
            TraceJacArray[nlr] = TensorOfArray3D<DataType>(nvar0Jac);
            for (int m = 0; m < nvar0Jac; m++)
            {
                TraceJacArray[nlr][m] =
                    Array<OneD, Array<OneD, DataType>>(nvar1Jac);
                for (int n = 0; n < nvar1Jac; n++)
                {
                    TraceJacArray[nlr][m][n] = Array<OneD, DataType>(nDiagBlks);
                }
            }
        }
    }
 
    for (int nlr = 0; nlr < nFwdBwd; nlr++)
    {
        const TypeNekBlkMatSharedPtr tmpMat = TraceJac[nlr];
        TensorOfArray3D<DataType> tmpaa     = TraceJacArray[nlr];
        TranSamesizeBlkDiagMatIntoArray(tmpMat, tmpaa);
    }
 
    return;
}

References TranSamesizeBlkDiagMatIntoArray().

Referenced by CalcPreconMatBRJCoeff().

v_ALEInitObject()

void Nektar::CFSImplicit::v_ALEInitObject ( int  spaceDim, Array< OneD, MultiRegions::ExpListSharedPtr > &  fields  )

overrideprotectedvirtual

Reimplemented from Nektar::SolverUtils::ALEHelper.

Definition at line 2030 of file CompressibleFlowSystemImplicit.cpp.

{
    m_implicitALESolver = true;
 
    if (fields[0]->GetGraph() != nullptr)
    {
        fields[0]->GetGraph()->GetMovement()->SetImplicitALEFlag(
            m_implicitALESolver);
        fields[0]->GetGraph()->GetMovement()->SetMeshDistortedFlag(
            m_meshDistorted);
    }
 
    m_spaceDim  = spaceDim;
    m_fieldsALE = fields;
 
    // Initialise grid velocities as 0s
    m_gridVelocity      = Array<OneD, Array<OneD, NekDouble>>(m_spaceDim);
    m_gridVelocityTrace = Array<OneD, Array<OneD, NekDouble>>(m_spaceDim);
    for (int i = 0; i < spaceDim; ++i)
    {
        m_gridVelocity[i] =
            Array<OneD, NekDouble>(fields[0]->GetTotPoints(), 0.0);
        m_gridVelocityTrace[i] =
            Array<OneD, NekDouble>(fields[0]->GetTrace()->GetTotPoints(), 0.0);
    }
    ALEHelper::InitObject(spaceDim, fields);
}

References Nektar::SolverUtils::EquationSystem::GetTotPoints(), Nektar::SolverUtils::ALEHelper::InitObject(), Nektar::SolverUtils::ALEHelper::m_fieldsALE, Nektar::SolverUtils::ALEHelper::m_gridVelocity, Nektar::SolverUtils::ALEHelper::m_gridVelocityTrace, Nektar::SolverUtils::ALEHelper::m_implicitALESolver, Nektar::SolverUtils::ALEHelper::m_meshDistorted, and Nektar::SolverUtils::ALEHelper::m_spaceDim.

v_CalcMuDmuDT()

virtual void Nektar::CFSImplicit::v_CalcMuDmuDT ( const Array< OneD, const Array< OneD, NekDouble > > &  inarray, Array< OneD, NekDouble > &  mu, Array< OneD, NekDouble > &  DmuDT  )

inlineprotectedvirtual

Reimplemented in Nektar::NavierStokesImplicitCFE.

Definition at line 355 of file CompressibleFlowSystemImplicit.h.

    {
    }

Referenced by CalcMuDmuDT().

v_CalcPhysDeriv()

virtual void Nektar::CFSImplicit::v_CalcPhysDeriv ( const Array< OneD, const Array< OneD, NekDouble > > &  inarray, TensorOfArray3D< NekDouble > &  qfield  )

inlineprotectedvirtual

Reimplemented in Nektar::NavierStokesImplicitCFE.

Definition at line 363 of file CompressibleFlowSystemImplicit.h.

    {
    }

Referenced by CalcPhysDeriv().

v_DoDiffusionCoeff()

virtual void Nektar::CFSImplicit::v_DoDiffusionCoeff ( const Array< OneD, const Array< OneD, NekDouble > > &  inarray, Array< OneD, Array< OneD, NekDouble > > &  outarray, const Array< OneD, const Array< OneD, NekDouble > > &  pFwd, const Array< OneD, const Array< OneD, NekDouble > > &  pBwd  )

inlineprotectedvirtual

Reimplemented in Nektar::NavierStokesImplicitCFE.

Definition at line 346 of file CompressibleFlowSystemImplicit.h.

    {
    }

Referenced by DoDiffusionCoeff().

v_DoSolve()

void Nektar::CFSImplicit::v_DoSolve ( void  )

overrideprotectedvirtual

Virtual function for solve implementation.

Reimplemented from Nektar::SolverUtils::EquationSystem.

Definition at line 157 of file CompressibleFlowSystemImplicit.cpp.

{
    m_TotNewtonIts = 0;
    m_TotLinIts    = 0;
    m_TotImpStages = 0;
    UnsteadySystem::v_DoSolve();
}

References m_TotImpStages, m_TotLinIts, m_TotNewtonIts, and Nektar::SolverUtils::UnsteadySystem::v_DoSolve().

v_GetFluxDerivJacDirctn() [1/2]

virtual void Nektar::CFSImplicit::v_GetFluxDerivJacDirctn ( const MultiRegions::ExpListSharedPtr &  explist, const Array< OneD, const Array< OneD, NekDouble > > &  normals, const int  nDervDir, const Array< OneD, const Array< OneD, NekDouble > > &  inarray, Array< OneD, Array< OneD, DNekMatSharedPtr > > &  ElmtJac  )

protectedvirtual

Reimplemented in Nektar::NavierStokesImplicitCFE.

v_GetFluxDerivJacDirctn() [2/2]

void Nektar::CFSImplicit::v_GetFluxDerivJacDirctn ( const MultiRegions::ExpListSharedPtr &  explist, const Array< OneD, const Array< OneD, NekDouble > > &  normals, const int  nDervDir, const Array< OneD, const Array< OneD, NekDouble > > &  inarray, TensorOfArray5D< NekDouble > &  ElmtJacArray, const int  nFluxDir  )

protectedvirtual

Reimplemented in Nektar::NavierStokesImplicitCFE.

Definition at line 1706 of file CompressibleFlowSystemImplicit.cpp.

{
    NEKERROR(ErrorUtil::efatal, "v_GetFluxDerivJacDirctn not coded");
}

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

Referenced by GetFluxDerivJacDirctn(), and GetFluxDerivJacDirctn().

v_GetFluxDerivJacDirctnElmt()

void Nektar::CFSImplicit::v_GetFluxDerivJacDirctnElmt ( const int  nConvectiveFields, const int  nElmtPnt, const int  nDervDir, const Array< OneD, const Array< OneD, NekDouble > > &  locVars, const Array< OneD, NekDouble > &  locmu, const Array< OneD, const Array< OneD, NekDouble > > &  locnormal, DNekMatSharedPtr &  wspMat, Array< OneD, Array< OneD, NekDouble > > &  PntJacArray  )

protectedvirtual

Reimplemented in Nektar::NavierStokesImplicitCFE.

Definition at line 1717 of file CompressibleFlowSystemImplicit.cpp.

{
    NEKERROR(ErrorUtil::efatal, "v_GetFluxDerivJacDirctn not coded");
}

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

Referenced by GetFluxDerivJacDirctnElmt().

v_InitObject()

void Nektar::CFSImplicit::v_InitObject ( bool  DeclareFields = true )

overrideprotectedvirtual

Initialization object for CFSImplicit class.

Reimplemented from Nektar::SolverUtils::AdvectionSystem.

Reimplemented in Nektar::EulerImplicitCFE, and Nektar::NavierStokesImplicitCFE.

Definition at line 52 of file CompressibleFlowSystemImplicit.cpp.

{
    CompressibleFlowSystem::v_InitObject(DeclareFields);
    m_explicitAdvection = false;
    m_explicitDiffusion = false;
 
    // Initialise implicit parameters
    m_session->MatchSolverInfo("FLAGIMPLICITITSSTATISTICS", "True",
                               m_flagImplicitItsStatistics, false);
 
    m_session->LoadParameter("JacobiFreeEps", m_jacobiFreeEps,
                             sqrt(NekConstants::kNekMachineEpsilon));
 
    m_session->LoadParameter("nPadding", m_nPadding, 4);
 
    int ntmp;
    m_session->LoadParameter("AdvectionJacFlag", ntmp, 1);
    m_advectionJacFlag = (ntmp != 0);
 
    m_session->LoadParameter("ViscousJacFlag", ntmp, 1);
    m_viscousJacFlag = (ntmp != 0);
 
    // Initialise implicit functors
    m_ode.DefineOdeRhs(&CFSImplicit::DoOdeImplicitRhs, this);
    m_ode.DefineImplicitSolve(&CFSImplicit::DoImplicitSolve, this);
 
    InitialiseNonlinSysSolver();
}

References Nektar::LibUtilities::TimeIntegrationSchemeOperators::DefineImplicitSolve(), Nektar::LibUtilities::TimeIntegrationSchemeOperators::DefineOdeRhs(), DoImplicitSolve(), DoOdeImplicitRhs(), InitialiseNonlinSysSolver(), Nektar::NekConstants::kNekMachineEpsilon, m_advectionJacFlag, Nektar::SolverUtils::UnsteadySystem::m_explicitAdvection, Nektar::SolverUtils::UnsteadySystem::m_explicitDiffusion, m_flagImplicitItsStatistics, m_jacobiFreeEps, m_nPadding, Nektar::SolverUtils::UnsteadySystem::m_ode, Nektar::SolverUtils::EquationSystem::m_session, m_viscousJacFlag, tinysimd::sqrt(), and Nektar::CompressibleFlowSystem::v_InitObject().

Referenced by Nektar::EulerImplicitCFE::v_InitObject(), and Nektar::NavierStokesImplicitCFE::v_InitObject().

v_MinusDiffusionFluxJacPoint()

void Nektar::CFSImplicit::v_MinusDiffusionFluxJacPoint ( const int  nConvectiveFields, const int  nElmtPnt, const Array< OneD, const Array< OneD, NekDouble > > &  locVars, const TensorOfArray3D< NekDouble > &  locDerv, const Array< OneD, NekDouble > &  locmu, const Array< OneD, NekDouble > &  locDmuDT, const Array< OneD, NekDouble > &  normals, DNekMatSharedPtr &  wspMat, Array< OneD, Array< OneD, NekDouble > > &  PntJacArray  )

protectedvirtual

Reimplemented in Nektar::NavierStokesImplicitCFE.

Definition at line 1561 of file CompressibleFlowSystemImplicit.cpp.

{
    // Do nothing by default
}

Referenced by MinusDiffusionFluxJacPoint().

v_PrintStatusInformation()

void Nektar::CFSImplicit::v_PrintStatusInformation ( const int  step, const NekDouble  cpuTime  )

overrideprotectedvirtual

Print Status Information.

Reimplemented from Nektar::SolverUtils::UnsteadySystem.

Definition at line 165 of file CompressibleFlowSystemImplicit.cpp.

{
    UnsteadySystem::v_PrintStatusInformation(step, cpuTime);
 
    if (m_infosteps && m_session->GetComm()->GetSpaceComm()->GetRank() == 0 &&
        !((step + 1) % m_infosteps) && m_flagImplicitItsStatistics)
    {
        std::cout << "       &&"
                  << " TotImpStages= " << m_TotImpStages
                  << " TotNewtonIts= " << m_TotNewtonIts
                  << " TotLinearIts = " << m_TotLinIts << std::endl;
    }
}

References m_flagImplicitItsStatistics, Nektar::SolverUtils::EquationSystem::m_infosteps, Nektar::SolverUtils::EquationSystem::m_session, m_TotImpStages, m_TotLinIts, m_TotNewtonIts, and Nektar::SolverUtils::UnsteadySystem::v_PrintStatusInformation().

v_PrintSummaryStatistics()

void Nektar::CFSImplicit::v_PrintSummaryStatistics ( const NekDouble  intTime )

overrideprotectedvirtual

Print Summary Statistics.

Reimplemented from Nektar::SolverUtils::UnsteadySystem.

Definition at line 180 of file CompressibleFlowSystemImplicit.cpp.

{
    UnsteadySystem::v_PrintSummaryStatistics(intTime);
 
    if (m_session->GetComm()->GetRank() == 0 && m_flagImplicitItsStatistics)
    {
        std::cout << "-------------------------------------------" << std::endl
                  << "Total Implicit Stages: " << m_TotImpStages << std::endl
                  << "Total Newton Its     : " << m_TotNewtonIts << std::endl
                  << "Total Linear Its     : " << m_TotLinIts << std::endl
                  << "-------------------------------------------" << std::endl;
    }
}

References m_flagImplicitItsStatistics, Nektar::SolverUtils::EquationSystem::m_session, m_TotImpStages, m_TotLinIts, m_TotNewtonIts, and Nektar::SolverUtils::UnsteadySystem::v_PrintSummaryStatistics().

v_UpdateTimeStepCheck()

bool Nektar::CFSImplicit::v_UpdateTimeStepCheck ( void  )

overrideprotectedvirtual

Reimplemented from Nektar::SolverUtils::UnsteadySystem.

Definition at line 2021 of file CompressibleFlowSystemImplicit.cpp.

{
    bool flag =
        (m_time + m_timestep > m_fintime && m_fintime > 0.0) ||
        (m_checktime && m_time + m_timestep - m_lastCheckTime >= m_checktime);
    return flag || m_preconCfs->UpdatePreconMatCheck(NullNekDouble1DArray,
                                                     m_TimeIntegLambda);
}

References Nektar::SolverUtils::EquationSystem::m_checktime, Nektar::SolverUtils::EquationSystem::m_fintime, Nektar::SolverUtils::EquationSystem::m_lastCheckTime, m_preconCfs, Nektar::SolverUtils::EquationSystem::m_time, m_TimeIntegLambda, Nektar::SolverUtils::EquationSystem::m_timestep, and Nektar::NullNekDouble1DArray.

Member Data Documentation

m_advectionJacFlag

bool Nektar::CFSImplicit::m_advectionJacFlag

protected

Definition at line 61 of file CompressibleFlowSystemImplicit.h.

Referenced by AddMatNSBlkDiagVol(), CalcTraceNumericalFlux(), and v_InitObject().

m_flagImplicitItsStatistics

bool Nektar::CFSImplicit::m_flagImplicitItsStatistics

protected

Definition at line 62 of file CompressibleFlowSystemImplicit.h.

Referenced by v_InitObject(), v_PrintStatusInformation(), and v_PrintSummaryStatistics().

m_inArrayNorm

NekDouble Nektar::CFSImplicit::m_inArrayNorm = -1.0

protected

Definition at line 79 of file CompressibleFlowSystemImplicit.h.

Referenced by CalcRefValues(), DoImplicitSolveCoeff(), and MatrixMultiplyMatrixFreeCoeff().

m_jacobiFreeEps

NekDouble Nektar::CFSImplicit::m_jacobiFreeEps

protected

Definition at line 80 of file CompressibleFlowSystemImplicit.h.

Referenced by MatrixMultiplyMatrixFreeCoeff(), and v_InitObject().

m_magnitdEstimat

Array<OneD, NekDouble> Nektar::CFSImplicit::m_magnitdEstimat

protected

Estimate the magnitude of each conserved varibles.

Definition at line 72 of file CompressibleFlowSystemImplicit.h.

Referenced by CalcRefValues(), and NumCalcRiemFluxJac().

m_nonlinsol

LibUtilities::NekNonlinSysIterSharedPtr Nektar::CFSImplicit::m_nonlinsol

protected

Definition at line 85 of file CompressibleFlowSystemImplicit.h.

Referenced by DoImplicitSolveCoeff(), InitialiseNonlinSysSolver(), MatrixMultiplyMatrixFreeCoeff(), and NonlinSysEvaluatorCoeff().

m_nPadding

int Nektar::CFSImplicit::m_nPadding = 1

protected

Definition at line 64 of file CompressibleFlowSystemImplicit.h.

Referenced by AddMatNSBlkDiagVol(), CalcVolJacStdMat(), and v_InitObject().

m_preconCfs

PreconCfsSharedPtr Nektar::CFSImplicit::m_preconCfs

protected

Definition at line 87 of file CompressibleFlowSystemImplicit.h.

Referenced by InitialiseNonlinSysSolver(), PreconCoeff(), and v_UpdateTimeStepCheck().

m_solutionPhys

Array<OneD, Array<OneD, NekDouble> > Nektar::CFSImplicit::m_solutionPhys

protected

Definition at line 74 of file CompressibleFlowSystemImplicit.h.

Referenced by DoImplicitSolveCoeff(), and PreconCoeff().

m_stdSMatDataDBB

TensorOfArray4D<NekSingle> Nektar::CFSImplicit::m_stdSMatDataDBB

protected

Definition at line 82 of file CompressibleFlowSystemImplicit.h.

Referenced by CalcPreconMatBRJCoeff().

m_stdSMatDataDBDB

TensorOfArray5D<NekSingle> Nektar::CFSImplicit::m_stdSMatDataDBDB

protected

Definition at line 83 of file CompressibleFlowSystemImplicit.h.

Referenced by CalcPreconMatBRJCoeff().

m_TimeIntegLambda

NekDouble Nektar::CFSImplicit::m_TimeIntegLambda = 0.0

protected

coefff of spacial derivatives(rhs or m_F in GLM) in calculating the residual of the whole equation(used in unsteady time integrations)

Definition at line 78 of file CompressibleFlowSystemImplicit.h.

Referenced by CalcPreconMatBRJCoeff(), DoImplicitSolveCoeff(), NonlinSysEvaluatorCoeff(), PreconCoeff(), and v_UpdateTimeStepCheck().

m_TotImpStages

int Nektar::CFSImplicit::m_TotImpStages = 0

protected

Definition at line 69 of file CompressibleFlowSystemImplicit.h.

Referenced by DoImplicitSolveCoeff(), v_DoSolve(), v_PrintStatusInformation(), and v_PrintSummaryStatistics().

m_TotLinIts

int Nektar::CFSImplicit::m_TotLinIts = 0

protected

Definition at line 68 of file CompressibleFlowSystemImplicit.h.

Referenced by DoImplicitSolveCoeff(), v_DoSolve(), v_PrintStatusInformation(), and v_PrintSummaryStatistics().

m_TotNewtonIts

int Nektar::CFSImplicit::m_TotNewtonIts = 0

protected

Definition at line 67 of file CompressibleFlowSystemImplicit.h.

Referenced by DoImplicitSolveCoeff(), v_DoSolve(), v_PrintStatusInformation(), and v_PrintSummaryStatistics().

m_updateShockCaptPhys

bool Nektar::CFSImplicit::m_updateShockCaptPhys {true}

protected

Definition at line 92 of file CompressibleFlowSystemImplicit.h.

{true};

Referenced by DoImplicitSolve(), and Nektar::NavierStokesImplicitCFE::v_DoDiffusionCoeff().

m_viscousJacFlag

bool Nektar::CFSImplicit::m_viscousJacFlag

protected

Definition at line 60 of file CompressibleFlowSystemImplicit.h.

Referenced by AddMatNSBlkDiagVol(), CalcPreconMatBRJCoeff(), CalcTraceNumericalFlux(), NumCalcRiemFluxJac(), v_InitObject(), and Nektar::EulerImplicitCFE::v_InitObject().