Nektar++
Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
Nektar::CFSImplicit Class Reference

#include <CompressibleFlowSystemImplicit.h>

Inheritance diagram for Nektar::CFSImplicit:
[legend]

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. More...
 
Array< OneD, NekDoubleGetStabilityLimitVector (const Array< OneD, int > &ExpOrder)
 Function to calculate the stability limit for DG/CG (a vector of them). More...
 
- 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. More...
 
SOLVER_UTILS_EXPORT Array< OneD, NekDoubleGetElmtCFLVals (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. More...
 
SOLVER_UTILS_EXPORT NekDouble GetTimeStep (const Array< OneD, const Array< OneD, NekDouble > > &inarray)
 Calculate the larger time-step mantaining the problem stable. More...
 
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::TimeIntegrationSchemeSharedPtrGetTimeIntegrationScheme ()
 Returns the time integration scheme. More...
 
SOLVER_UTILS_EXPORT LibUtilities::TimeIntegrationSchemeOperatorsGetTimeIntegrationSchemeOperators ()
 Returns the time integration scheme operators. More...
 
- Public Member Functions inherited from Nektar::SolverUtils::EquationSystem
virtual SOLVER_UTILS_EXPORT ~EquationSystem ()
 Destructor. More...
 
SOLVER_UTILS_EXPORT void InitObject (bool DeclareField=true)
 Initialises the members of this object. More...
 
SOLVER_UTILS_EXPORT void DoInitialise (bool dumpInitialConditions=true)
 Perform any initialisation necessary before solving the problem. More...
 
SOLVER_UTILS_EXPORT void DoSolve ()
 Solve the problem. More...
 
SOLVER_UTILS_EXPORT void TransCoeffToPhys ()
 Transform from coefficient to physical space. More...
 
SOLVER_UTILS_EXPORT void TransPhysToCoeff ()
 Transform from physical to coefficient space. More...
 
SOLVER_UTILS_EXPORT void Output ()
 Perform output operations after solve. More...
 
SOLVER_UTILS_EXPORT std::string GetSessionName ()
 Get Session name. More...
 
template<class T >
std::shared_ptr< T > as ()
 
SOLVER_UTILS_EXPORT void ResetSessionName (std::string newname)
 Reset Session name. More...
 
SOLVER_UTILS_EXPORT LibUtilities::SessionReaderSharedPtr GetSession ()
 Get Session name. More...
 
SOLVER_UTILS_EXPORT MultiRegions::ExpListSharedPtr GetPressure ()
 Get pressure field if available. More...
 
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. More...
 
SOLVER_UTILS_EXPORT void SetLambda (NekDouble lambda)
 Set parameter m_lambda. More...
 
SOLVER_UTILS_EXPORT SessionFunctionSharedPtr GetFunction (std::string name, const MultiRegions::ExpListSharedPtr &field=MultiRegions::NullExpListSharedPtr, bool cache=false)
 Get a SessionFunction by name. More...
 
SOLVER_UTILS_EXPORT void SetInitialConditions (NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0)
 Initialise the data in the dependent fields. More...
 
SOLVER_UTILS_EXPORT void EvaluateExactSolution (int field, Array< OneD, NekDouble > &outfield, const NekDouble time)
 Evaluates an exact solution. More...
 
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. More...
 
SOLVER_UTILS_EXPORT NekDouble L2Error (unsigned int field, bool Normalised=false)
 Compute the L2 error of the fields. More...
 
SOLVER_UTILS_EXPORT NekDouble LinfError (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray)
 Linf error computation. More...
 
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. More...
 
SOLVER_UTILS_EXPORT Array< OneD, NekDoubleErrorExtraPoints (unsigned int field)
 Compute error (L2 and L_inf) over an larger set of quadrature points return [L2 Linf]. More...
 
SOLVER_UTILS_EXPORT void Checkpoint_Output (const int n)
 Write checkpoint file of m_fields. More...
 
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. More...
 
SOLVER_UTILS_EXPORT void Checkpoint_BaseFlow (const int n)
 Write base flow file of m_fields. More...
 
SOLVER_UTILS_EXPORT void WriteFld (const std::string &outname)
 Write field data to the given filename. More...
 
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. More...
 
SOLVER_UTILS_EXPORT void ImportFld (const std::string &infile, Array< OneD, MultiRegions::ExpListSharedPtr > &pFields)
 Input field data from the given file. More...
 
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. More...
 
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. More...
 
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. More...
 
SOLVER_UTILS_EXPORT void SessionSummary (SummaryList &vSummary)
 Write out a session summary. More...
 
SOLVER_UTILS_EXPORT Array< OneD, MultiRegions::ExpListSharedPtr > & UpdateFields ()
 
SOLVER_UTILS_EXPORT LibUtilities::FieldMetaDataMapUpdateFieldMetaDataMap ()
 Get hold of FieldInfoMap so it can be updated. More...
 
SOLVER_UTILS_EXPORT NekDouble GetTime ()
 Return final time. More...
 
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. More...
 
SOLVER_UTILS_EXPORT bool NegatedOp ()
 Identify if operator is negated in DoSolve. More...
 
- Public Member Functions inherited from Nektar::SolverUtils::ALEHelper
virtual ~ALEHelper ()=default
 
virtual SOLVER_UTILS_EXPORT void v_ALEInitObject (int spaceDim, Array< OneD, MultiRegions::ExpListSharedPtr > &fields)
 
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. More...
 
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)
 
const Array< OneD, const Array< OneD, NekDouble > > & GetGridVelocity ()
 
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)
 
- 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. More...
 
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. More...
 
SOLVER_UTILS_EXPORT void GetPressure (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &pressure)
 Extract array with pressure from physfield. More...
 
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. More...
 
SOLVER_UTILS_EXPORT void GetAeroForce (Array< OneD, NekDouble > forces)
 Get aerodynamic force and moment. More...
 

Protected Member Functions

void v_InitObject (bool DeclareFields=true) override
 Initialization object for CFSImplicit class. More...
 
void InitialiseNonlinSysSolver ()
 
void v_DoSolve () override
 Solves an unsteady problem. More...
 
void v_PrintStatusInformation (const int step, const NekDouble cpuTime) override
 Print Status Information. More...
 
void v_PrintSummaryStatistics (const NekDouble intTime) override
 Print Summary Statistics. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
void InitAdvection ()
 Create advection and diffusion objects for CFS. More...
 
void DoOdeRhs (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
 Compute the right-hand side. More...
 
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. More...
 
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. More...
 
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. More...
 
void GetFluxVector (const Array< OneD, const Array< OneD, NekDouble > > &physfield, TensorOfArray3D< NekDouble > &flux)
 Return the flux vector for the compressible Euler equations. More...
 
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. More...
 
void SetBoundaryConditions (Array< OneD, Array< OneD, NekDouble > > &physarray, NekDouble time)
 
void SetBoundaryConditionsBwdWeight ()
 Set up a weight on physical boundaries for boundary condition applications. More...
 
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. More...
 
NekDouble v_GetTimeStep (const Array< OneD, const Array< OneD, NekDouble > > &inarray) override
 Calculate the maximum timestep subject to CFL restrictions. More...
 
void v_GenerateSummary (SolverUtils::SummaryList &s) override
 Print a summary of time stepping parameters. More...
 
void v_SetInitialConditions (NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0) override
 Set up logic for residual calculation. More...
 
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, NekDoublev_GetMaxStdVelocity (const NekDouble SpeedSoundFactor) override
 Compute the advection velocity in the standard space for each element of the expansion. More...
 
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 void v_InitObject (bool DeclareField=true) override
 Initialisation object for EquationSystem. More...
 
SOLVER_UTILS_EXPORT bool v_PostIntegrate (int step) override
 
virtual SOLVER_UTILS_EXPORT Array< OneD, NekDoublev_GetMaxStdVelocity (const NekDouble SpeedSoundFactor=1.0)
 
- Protected Member Functions inherited from Nektar::SolverUtils::UnsteadySystem
SOLVER_UTILS_EXPORT UnsteadySystem (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
 Initialises UnsteadySystem class members. More...
 
SOLVER_UTILS_EXPORT void v_InitObject (bool DeclareField=true) override
 Init object for UnsteadySystem class. More...
 
SOLVER_UTILS_EXPORT void v_DoSolve () override
 Solves an unsteady problem. More...
 
virtual SOLVER_UTILS_EXPORT void v_PrintStatusInformation (const int step, const NekDouble cpuTime)
 Print Status Information. More...
 
virtual SOLVER_UTILS_EXPORT void v_PrintSummaryStatistics (const NekDouble intTime)
 Print Summary Statistics. More...
 
SOLVER_UTILS_EXPORT void v_DoInitialise (bool dumpInitialConditions=true) override
 Sets up initial conditions. More...
 
SOLVER_UTILS_EXPORT void v_GenerateSummary (SummaryList &s) override
 Print a summary of time stepping parameters. More...
 
virtual SOLVER_UTILS_EXPORT NekDouble v_GetTimeStep (const Array< OneD, const Array< OneD, NekDouble > > &inarray)
 Return the timestep to be used for the next step in the time-marching loop. More...
 
virtual SOLVER_UTILS_EXPORT bool v_PreIntegrate (int step)
 
virtual SOLVER_UTILS_EXPORT bool v_PostIntegrate (int step)
 
virtual SOLVER_UTILS_EXPORT bool v_RequireFwdTrans ()
 
virtual SOLVER_UTILS_EXPORT void v_SteadyStateResidual (int step, Array< OneD, NekDouble > &L2)
 
virtual SOLVER_UTILS_EXPORT bool v_UpdateTimeStepCheck ()
 
SOLVER_UTILS_EXPORT NekDouble MaxTimeStepEstimator ()
 Get the maximum timestep estimator for cfl control. More...
 
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. More...
 
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. More...
 
- Protected Member Functions inherited from Nektar::SolverUtils::EquationSystem
SOLVER_UTILS_EXPORT EquationSystem (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
 Initialises EquationSystem class members. More...
 
virtual SOLVER_UTILS_EXPORT void v_InitObject (bool DeclareFeld=true)
 Initialisation object for EquationSystem. More...
 
virtual SOLVER_UTILS_EXPORT void v_DoInitialise (bool dumpInitialConditions=true)
 Virtual function for initialisation implementation. More...
 
virtual SOLVER_UTILS_EXPORT void v_DoSolve ()
 Virtual function for solve implementation. More...
 
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. More...
 
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. More...
 
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. More...
 
virtual SOLVER_UTILS_EXPORT void v_TransCoeffToPhys ()
 Virtual function for transformation to physical space. More...
 
virtual SOLVER_UTILS_EXPORT void v_TransPhysToCoeff ()
 Virtual function for transformation to coefficient space. More...
 
virtual SOLVER_UTILS_EXPORT void v_GenerateSummary (SummaryList &l)
 Virtual function for generating summary information. More...
 
virtual SOLVER_UTILS_EXPORT void v_SetInitialConditions (NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0)
 
virtual SOLVER_UTILS_EXPORT void v_EvaluateExactSolution (unsigned int field, Array< OneD, NekDouble > &outfield, const NekDouble time)
 
virtual SOLVER_UTILS_EXPORT void v_Output (void)
 
virtual SOLVER_UTILS_EXPORT MultiRegions::ExpListSharedPtr v_GetPressure (void)
 
virtual SOLVER_UTILS_EXPORT bool v_NegatedOp (void)
 Virtual function to identify if operator is negated in DoSolve. More...
 
virtual SOLVER_UTILS_EXPORT void v_ExtraFldOutput (std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)
 
- Protected Member Functions inherited from Nektar::SolverUtils::FluidInterface
virtual SOLVER_UTILS_EXPORT void v_GetVelocity (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &velocity)=0
 
virtual SOLVER_UTILS_EXPORT bool v_HasConstantDensity ()=0
 
virtual SOLVER_UTILS_EXPORT void v_GetDensity (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &density)=0
 
virtual SOLVER_UTILS_EXPORT void v_GetPressure (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &pressure)=0
 
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, NekDoublem_magnitdEstimat
 Estimate the magnitude of each conserved varibles. More...
 
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) More...
 
NekDouble m_inArrayNorm = -1.0
 
NekDouble m_jacobiFreeEps
 
TensorOfArray4D< NekSinglem_stdSMatDataDBB
 
TensorOfArray5D< NekSinglem_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, NekDoublem_muav
 
Array< OneD, NekDoublem_muavTrace
 
VariableConverterSharedPtr m_varConv
 
std::vector< CFSBndCondSharedPtrm_bndConds
 
NekDouble m_bndEvaluateTime
 
std::vector< SolverUtils::ForcingSharedPtrm_forcing
 
- Protected Attributes inherited from Nektar::SolverUtils::AdvectionSystem
SolverUtils::AdvectionSharedPtr m_advObject
 Advection term. More...
 
- Protected Attributes inherited from Nektar::SolverUtils::UnsteadySystem
LibUtilities::TimeIntegrationSchemeSharedPtr m_intScheme
 Wrapper to the time integration scheme. More...
 
LibUtilities::TimeIntegrationSchemeOperators m_ode
 The time integration scheme operators to use. More...
 
Array< OneD, Array< OneD, NekDouble > > m_previousSolution
 Storage for previous solution for steady-state check. More...
 
std::vector< int > m_intVariables
 
NekDouble m_cflSafetyFactor
 CFL safety factor (comprise between 0 to 1). More...
 
NekDouble m_CFLGrowth
 CFL growth rate. More...
 
NekDouble m_CFLEnd
 Maximun cfl in cfl growth. More...
 
int m_abortSteps
 Number of steps between checks for abort conditions. More...
 
bool m_explicitDiffusion
 Indicates if explicit or implicit treatment of diffusion is used. More...
 
bool m_explicitAdvection
 Indicates if explicit or implicit treatment of advection is used. More...
 
bool m_explicitReaction
 Indicates if explicit or implicit treatment of reaction is used. More...
 
int m_steadyStateSteps
 Check for steady state at step interval. More...
 
NekDouble m_steadyStateTol
 Tolerance to which steady state should be evaluated at. More...
 
int m_filtersInfosteps
 Number of time steps between outputting filters information. More...
 
std::vector< std::pair< std::string, FilterSharedPtr > > m_filters
 
bool m_homoInitialFwd
 Flag to determine if simulation should start in homogeneous forward transformed state. More...
 
std::ofstream m_errFile
 
NekDouble m_epsilon
 Diffusion coefficient. More...
 
- Protected Attributes inherited from Nektar::SolverUtils::EquationSystem
LibUtilities::CommSharedPtr m_comm
 Communicator. More...
 
bool m_verbose
 
LibUtilities::SessionReaderSharedPtr m_session
 The session reader. More...
 
std::map< std::string, SolverUtils::SessionFunctionSharedPtrm_sessionFunctions
 Map of known SessionFunctions. More...
 
LibUtilities::FieldIOSharedPtr m_fld
 Field input/output. More...
 
Array< OneD, MultiRegions::ExpListSharedPtrm_fields
 Array holding all dependent variables. More...
 
SpatialDomains::BoundaryConditionsSharedPtr m_boundaryConditions
 Pointer to boundary conditions object. More...
 
SpatialDomains::MeshGraphSharedPtr m_graph
 Pointer to graph defining mesh. More...
 
std::string m_sessionName
 Name of the session. More...
 
NekDouble m_time
 Current time of simulation. More...
 
int m_initialStep
 Number of the step where the simulation should begin. More...
 
NekDouble m_fintime
 Finish time of the simulation. More...
 
NekDouble m_timestep
 Time step size. More...
 
NekDouble m_lambda
 Lambda constant in real system if one required. More...
 
NekDouble m_checktime
 Time between checkpoints. More...
 
NekDouble m_lastCheckTime
 
NekDouble m_TimeIncrementFactor
 
int m_nchk
 Number of checkpoints written so far. More...
 
int m_steps
 Number of steps to take. More...
 
int m_checksteps
 Number of steps between checkpoints. More...
 
int m_infosteps
 Number of time steps between outputting status information. More...
 
int m_iterPIT = 0
 Number of parallel-in-time time iteration. More...
 
int m_windowPIT = 0
 Index of windows for parallel-in-time time iteration. More...
 
int m_spacedim
 Spatial dimension (>= expansion dim). More...
 
int m_expdim
 Expansion dimension. More...
 
bool m_singleMode
 Flag to determine if single homogeneous mode is used. More...
 
bool m_halfMode
 Flag to determine if half homogeneous mode is used. More...
 
bool m_multipleModes
 Flag to determine if use multiple homogenenous modes are used. More...
 
bool m_useFFT
 Flag to determine if FFT is used for homogeneous transform. More...
 
bool m_homogen_dealiasing
 Flag to determine if dealiasing is used for homogeneous simulations. More...
 
bool m_specHP_dealiasing
 Flag to determine if dealisising is usde for the Spectral/hp element discretisation. More...
 
enum MultiRegions::ProjectionType m_projectionType
 Type of projection; e.g continuous or discontinuous. More...
 
Array< OneD, Array< OneD, NekDouble > > m_traceNormals
 Array holding trace normals for DG simulations in the forwards direction. More...
 
Array< OneD, bool > m_checkIfSystemSingular
 Flag to indicate if the fields should be checked for singularity. More...
 
LibUtilities::FieldMetaDataMap m_fieldMetaDataMap
 Map to identify relevant solver info to dump in output fields. More...
 
Array< OneD, NekDoublem_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. More...
 
std::vector< std::string > m_strFrameData
 variable name in m_movingFrameData More...
 
int m_NumQuadPointsError
 Number of Quadrature points used to work out the error. More...
 
enum HomogeneousType m_HomogeneousType
 
NekDouble m_LhomX
 physical length in X direction (if homogeneous) More...
 
NekDouble m_LhomY
 physical length in Y direction (if homogeneous) More...
 
NekDouble m_LhomZ
 physical length in Z direction (if homogeneous) More...
 
int m_npointsX
 number of points in X direction (if homogeneous) More...
 
int m_npointsY
 number of points in Y direction (if homogeneous) More...
 
int m_npointsZ
 number of points in Z direction (if homogeneous) More...
 
int m_HomoDirec
 number of homogenous directions More...
 
- Protected Attributes inherited from Nektar::SolverUtils::ALEHelper
Array< OneD, MultiRegions::ExpListSharedPtrm_fieldsALE
 
Array< OneD, Array< OneD, NekDouble > > m_gridVelocity
 
Array< OneD, Array< OneD, NekDouble > > m_gridVelocityTrace
 
std::vector< ALEBaseShPtrm_ALEs
 
bool m_ALESolver = false
 
bool m_ImplicitALESolver = 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.

45 : UnsteadySystem(pSession, pGraph), CompressibleFlowSystem(pSession, pGraph)
46{
47}
CompressibleFlowSystem(const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
SOLVER_UTILS_EXPORT UnsteadySystem(const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
Initialises UnsteadySystem class members.

◆ ~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 1066 of file CompressibleFlowSystemImplicit.cpp.

1074{
1075 int nvariables = inarray.size();
1076
1077 LibUtilities::Timer timer;
1078 timer.Start();
1079 GetTraceJac(inarray, qfield, TraceJac, TraceJacDeriv, TraceJacDerivSign,
1080 TraceIPSymJacArray);
1081 timer.Stop();
1082 timer.AccumulateRegion("CFSImplicit::GetTraceJac", 10);
1083
1084 Array<OneD, TypeNekBlkMatSharedPtr> tmpJac;
1085 Array<OneD, Array<OneD, DataType>> tmpSign;
1086
1087 timer.Start();
1088 m_advObject->AddTraceJacToMat(nvariables, m_spacedim, m_fields, TraceJac,
1089 gmtxarray, tmpJac, tmpSign);
1090 timer.Stop();
1091 timer.AccumulateRegion("Advection::AddTraceJacToMap", 10);
1092}
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)
SolverUtils::AdvectionSharedPtr m_advObject
Advection term.
int m_spacedim
Spatial dimension (>= expansion dim).
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.

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 594 of file CompressibleFlowSystemImplicit.cpp.

600{
601 if (StdMatDataDBB.size() == 0)
602 {
603 CalcVolJacStdMat(StdMatDataDBB, StdMatDataDBDB);
604 }
605
606 int nSpaceDim = m_graph->GetSpaceDimension();
607 int nvariable = inarray.size();
608 int npoints = m_fields[0]->GetTotPoints();
609 int nVar2 = nvariable * nvariable;
610 std::shared_ptr<LocalRegions::ExpansionVector> expvect =
611 m_fields[0]->GetExp();
612 int nTotElmt = (*expvect).size();
613
614 Array<OneD, NekDouble> mu(npoints, 0.0);
615 Array<OneD, NekDouble> DmuDT(npoints, 0.0);
617 {
618 CalcMuDmuDT(inarray, mu, DmuDT);
619 }
620
621 Array<OneD, NekDouble> normals;
622 Array<OneD, Array<OneD, NekDouble>> normal3D(3);
623 for (int i = 0; i < 3; i++)
624 {
625 normal3D[i] = Array<OneD, NekDouble>(3, 0.0);
626 }
627 normal3D[0][0] = 1.0;
628 normal3D[1][1] = 1.0;
629 normal3D[2][2] = 1.0;
630 Array<OneD, Array<OneD, NekDouble>> normalPnt(3);
631
632 DNekMatSharedPtr wspMat =
633 MemoryManager<DNekMat>::AllocateSharedPtr(nvariable, nvariable, 0.0);
635 nvariable - 1, nvariable, 0.0);
636
637 Array<OneD, DataType> GmatxData;
638 Array<OneD, DataType> MatData;
639
640 Array<OneD, NekDouble> tmppnts;
641 TensorOfArray3D<NekDouble> PntJacCons(
642 m_spacedim); // Nvar*Nvar*Ndir*Nelmt*Npnt
643 TensorOfArray3D<DataType> PntJacConsStd(
644 m_spacedim); // Nvar*Nvar*Ndir*Nelmt*Npnt
645 Array<OneD, Array<OneD, NekDouble>> ConsStdd(m_spacedim);
646 Array<OneD, Array<OneD, NekDouble>> ConsCurv(m_spacedim);
647 TensorOfArray4D<NekDouble> PntJacDerv(
648 m_spacedim); // Nvar*Nvar*Ndir*Nelmt*Npnt
649 TensorOfArray4D<DataType> PntJacDervStd(
650 m_spacedim); // Nvar*Nvar*Ndir*Nelmt*Npnt
651 TensorOfArray3D<NekDouble> DervStdd(
652 m_spacedim); // Nvar*Nvar*Ndir*Nelmt*Npnt
653 TensorOfArray3D<NekDouble> DervCurv(
654 m_spacedim); // Nvar*Nvar*Ndir*Nelmt*Npnt
655 for (int ndir = 0; ndir < m_spacedim; ndir++)
656 {
657 PntJacDerv[ndir] = TensorOfArray3D<NekDouble>(m_spacedim);
658 PntJacDervStd[ndir] = TensorOfArray3D<DataType>(m_spacedim);
659 DervStdd[ndir] = Array<OneD, Array<OneD, NekDouble>>(m_spacedim);
660 DervCurv[ndir] = Array<OneD, Array<OneD, NekDouble>>(m_spacedim);
661 }
662
663 Array<OneD, NekDouble> locmu;
664 Array<OneD, NekDouble> locDmuDT;
665 Array<OneD, Array<OneD, NekDouble>> locVars(nvariable);
666 TensorOfArray3D<NekDouble> locDerv(m_spacedim);
667 for (int ndir = 0; ndir < m_spacedim; ndir++)
668 {
669 locDerv[ndir] = Array<OneD, Array<OneD, NekDouble>>(nvariable);
670 }
671
672 int nElmtCoefOld = -1;
673 for (int ne = 0; ne < nTotElmt; ne++)
674 {
675 int nElmtCoef = (*expvect)[ne]->GetNcoeffs();
676 int nElmtCoef2 = nElmtCoef * nElmtCoef;
677 int nElmtPnt = (*expvect)[ne]->GetTotPoints();
678
679 int nQuot = nElmtCoef2 / m_nPadding;
680 int nRemd = nElmtCoef2 - nQuot * m_nPadding;
681 int nQuotPlus = nQuot;
682 if (nRemd > 0)
683 {
684 nQuotPlus++;
685 }
686 int nElmtCoef2Paded = nQuotPlus * m_nPadding;
687
688 if (nElmtPnt > PntJacCons[0].size() || nElmtCoef > nElmtCoefOld)
689 {
690 nElmtCoefOld = nElmtCoef;
691 for (int ndir = 0; ndir < 3; ndir++)
692 {
693 normalPnt[ndir] = Array<OneD, NekDouble>(npoints, 0.0);
694 }
695 tmppnts = Array<OneD, NekDouble>(nElmtPnt);
696 MatData = Array<OneD, DataType>(nElmtCoef2Paded * nVar2);
697 for (int ndir = 0; ndir < m_spacedim; ndir++)
698 {
699 ConsCurv[ndir] = Array<OneD, NekDouble>(nElmtPnt);
700 ConsStdd[ndir] = Array<OneD, NekDouble>(nElmtPnt);
701 PntJacCons[ndir] =
702 Array<OneD, Array<OneD, NekDouble>>(nElmtPnt);
703 PntJacConsStd[ndir] =
704 Array<OneD, Array<OneD, DataType>>(nElmtPnt);
705 for (int i = 0; i < nElmtPnt; i++)
706 {
707 PntJacCons[ndir][i] = Array<OneD, NekDouble>(nVar2);
708 PntJacConsStd[ndir][i] = Array<OneD, DataType>(nVar2);
709 }
710
711 for (int ndir1 = 0; ndir1 < m_spacedim; ndir1++)
712 {
713 PntJacDerv[ndir][ndir1] =
714 Array<OneD, Array<OneD, NekDouble>>(nElmtPnt);
715 PntJacDervStd[ndir][ndir1] =
716 Array<OneD, Array<OneD, DataType>>(nElmtPnt);
717 DervStdd[ndir][ndir1] = Array<OneD, NekDouble>(nElmtPnt);
718 DervCurv[ndir][ndir1] = Array<OneD, NekDouble>(nElmtPnt);
719 for (int i = 0; i < nElmtPnt; i++)
720 {
721 PntJacDerv[ndir][ndir1][i] =
722 Array<OneD, NekDouble>(nVar2);
723 PntJacDervStd[ndir][ndir1][i] =
724 Array<OneD, DataType>(nVar2);
725 }
726 }
727 }
728 }
729
730 int noffset = GetPhys_Offset(ne);
731 for (int j = 0; j < nvariable; j++)
732 {
733 locVars[j] = inarray[j] + noffset;
734 }
735
737 {
738 for (int nFluxDir = 0; nFluxDir < nSpaceDim; nFluxDir++)
739 {
740 normals = normal3D[nFluxDir];
741 GetFluxVectorJacDirElmt(nvariable, nElmtPnt, locVars, normals,
742 wspMat, PntJacCons[nFluxDir]);
743 }
744 }
745
747 {
748 for (int j = 0; j < nSpaceDim; j++)
749 {
750 for (int k = 0; k < nvariable; k++)
751 {
752 locDerv[j][k] = qfield[j][k] + noffset;
753 }
754 }
755 locmu = mu + noffset;
756 locDmuDT = DmuDT + noffset;
757 for (int nFluxDir = 0; nFluxDir < nSpaceDim; nFluxDir++)
758 {
759 normals = normal3D[nFluxDir];
760 MinusDiffusionFluxJacPoint(nvariable, nElmtPnt, locVars,
761 locDerv, locmu, locDmuDT, normals,
762 wspMatDrv, PntJacCons[nFluxDir]);
763 }
764 }
765
767 {
768 locmu = mu + noffset;
769 for (int nFluxDir = 0; nFluxDir < nSpaceDim; nFluxDir++)
770 {
771 Vmath::Fill(npoints, 1.0, normalPnt[nFluxDir], 1);
772 for (int nDervDir = 0; nDervDir < nSpaceDim; nDervDir++)
773 {
775 nvariable, nElmtPnt, nDervDir, locVars, locmu,
776 normalPnt, wspMatDrv, PntJacDerv[nFluxDir][nDervDir]);
777 }
778 Vmath::Fill(npoints, 0.0, normalPnt[nFluxDir], 1);
779 }
780 }
781
782 for (int n = 0; n < nvariable; n++)
783 {
784 for (int m = 0; m < nvariable; m++)
785 {
786 int nVarOffset = m + n * nvariable;
787 GmatxData = gmtxarray[m][n]->GetBlock(ne, ne)->GetPtr();
788
789 for (int ndStd0 = 0; ndStd0 < m_spacedim; ndStd0++)
790 {
791 Vmath::Zero(nElmtPnt, ConsStdd[ndStd0], 1);
792 }
793 for (int ndir = 0; ndir < m_spacedim; ndir++)
794 {
795 for (int i = 0; i < nElmtPnt; i++)
796 {
797 tmppnts[i] = PntJacCons[ndir][i][nVarOffset];
798 }
799 (*expvect)[ne]->AlignVectorToCollapsedDir(ndir, tmppnts,
800 ConsCurv);
801 for (int nd = 0; nd < m_spacedim; nd++)
802 {
803 Vmath::Vadd(nElmtPnt, ConsCurv[nd], 1, ConsStdd[nd], 1,
804 ConsStdd[nd], 1);
805 }
806 }
807
808 for (int ndir = 0; ndir < m_spacedim; ndir++)
809 {
810 (*expvect)[ne]->MultiplyByQuadratureMetric(
811 ConsStdd[ndir], ConsStdd[ndir]); // weight with metric
812 for (int i = 0; i < nElmtPnt; i++)
813 {
814 PntJacConsStd[ndir][i][nVarOffset] =
815 DataType(ConsStdd[ndir][i]);
816 }
817 }
818 }
819 }
820
822 {
823 for (int m = 0; m < nvariable; m++)
824 {
825 for (int n = 0; n < nvariable; n++)
826 {
827 int nVarOffset = m + n * nvariable;
828 for (int ndStd0 = 0; ndStd0 < m_spacedim; ndStd0++)
829 {
830 for (int ndStd1 = 0; ndStd1 < m_spacedim; ndStd1++)
831 {
832 Vmath::Zero(nElmtPnt, DervStdd[ndStd0][ndStd1], 1);
833 }
834 }
835 for (int nd0 = 0; nd0 < m_spacedim; nd0++)
836 {
837 for (int nd1 = 0; nd1 < m_spacedim; nd1++)
838 {
839 for (int i = 0; i < nElmtPnt; i++)
840 {
841 tmppnts[i] =
842 PntJacDerv[nd0][nd1][i][nVarOffset];
843 }
844
845 (*expvect)[ne]->AlignVectorToCollapsedDir(
846 nd0, tmppnts, ConsCurv);
847 for (int nd = 0; nd < m_spacedim; nd++)
848 {
849 (*expvect)[ne]->AlignVectorToCollapsedDir(
850 nd1, ConsCurv[nd], DervCurv[nd]);
851 }
852
853 for (int ndStd0 = 0; ndStd0 < m_spacedim; ndStd0++)
854 {
855 for (int ndStd1 = 0; ndStd1 < m_spacedim;
856 ndStd1++)
857 {
858 Vmath::Vadd(nElmtPnt,
859 DervCurv[ndStd0][ndStd1], 1,
860 DervStdd[ndStd0][ndStd1], 1,
861 DervStdd[ndStd0][ndStd1], 1);
862 }
863 }
864 }
865 }
866 for (int nd0 = 0; nd0 < m_spacedim; nd0++)
867 {
868 for (int nd1 = 0; nd1 < m_spacedim; nd1++)
869 {
870 (*expvect)[ne]->MultiplyByQuadratureMetric(
871 DervStdd[nd0][nd1],
872 DervStdd[nd0][nd1]); // weight with metric
873 for (int i = 0; i < nElmtPnt; i++)
874 {
875 PntJacDervStd[nd0][nd1][i][nVarOffset] =
876 -DataType(DervStdd[nd0][nd1][i]);
877 }
878 }
879 }
880 }
881 }
882 }
883
884 Vmath::Zero(nElmtCoef2Paded * nVar2, MatData, 1);
885 DataType one = 1.0;
886 for (int ndir = 0; ndir < m_spacedim; ndir++)
887 {
888 for (int i = 0; i < nElmtPnt; i++)
889 {
890 Blas::Ger(nElmtCoef2Paded, nVar2, one,
891 &StdMatDataDBB[ne][ndir][i][0], 1,
892 &PntJacConsStd[ndir][i][0], 1, &MatData[0],
893 nElmtCoef2Paded);
894 }
895 }
896
898 {
899 for (int nd0 = 0; nd0 < m_spacedim; nd0++)
900 {
901 for (int nd1 = 0; nd1 < m_spacedim; nd1++)
902 {
903 for (int i = 0; i < nElmtPnt; i++)
904 {
905 Blas::Ger(nElmtCoef2Paded, nVar2, one,
906 &StdMatDataDBDB[ne][nd0][nd1][i][0], 1,
907 &PntJacDervStd[nd0][nd1][i][0], 1,
908 &MatData[0], nElmtCoef2Paded);
909 }
910 }
911 }
912 }
913
914 Array<OneD, DataType> tmpA;
915
916 for (int n = 0; n < nvariable; n++)
917 {
918 for (int m = 0; m < nvariable; m++)
919 {
920 int nVarOffset = m + n * nvariable;
921 GmatxData = gmtxarray[m][n]->GetBlock(ne, ne)->GetPtr();
922 Vmath::Vcopy(nElmtCoef2,
923 tmpA = MatData + nVarOffset * nElmtCoef2Paded, 1,
924 GmatxData, 1);
925 }
926 }
927 }
928}
void CalcVolJacStdMat(TensorOfArray4D< DataType > &StdMatDataDBB, TensorOfArray5D< DataType > &StdMatDataDBDB)
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 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 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 CalcMuDmuDT(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, NekDouble > &mu, Array< OneD, NekDouble > &DmuDT)
static std::shared_ptr< DataType > AllocateSharedPtr(const Args &...args)
Allocate a shared pointer from the memory pool.
SpatialDomains::MeshGraphSharedPtr m_graph
Pointer to graph defining mesh.
SOLVER_UTILS_EXPORT int GetPhys_Offset(int n)
static void Ger(const int &m, const int &n, const double &alpha, const double *x, const int &incx, const double *y, const int &incy, double *a, const int &lda)
BLAS level 2: Matrix vector multiply A = alpha*x*y**T + A where A[m x n].
Definition: Blas.hpp:335
std::shared_ptr< DNekMat > DNekMatSharedPtr
Definition: NekTypeDefs.hpp:75
void Vadd(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Add vector z = x+y.
Definition: Vmath.hpp:180
void Zero(int n, T *x, const int incx)
Zero vector.
Definition: Vmath.hpp:273
void Fill(int n, const T alpha, T *x, const int incx)
Fill a vector with a constant value.
Definition: Vmath.hpp:54
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.hpp:825

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.

230 {
231 mat =
233 SNekMatSharedPtr loc_matNvar;
234 for (int nelm = 0; nelm < nrow.size(); ++nelm)
235 {
236 int nrowsVars = nrow[nelm];
237 int ncolsVars = ncol[nelm];
238
240 nrowsVars, ncolsVars, 0.0);
241 mat->SetBlock(nelm, nelm, loc_matNvar);
242 }
243 }
std::shared_ptr< SNekMat > SNekMatSharedPtr

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.

342 {
343 v_CalcMuDmuDT(inarray, mu, DmuDT);
344 }
virtual void v_CalcMuDmuDT(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, NekDouble > &mu, Array< OneD, NekDouble > &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.

336 {
337 v_CalcPhysDeriv(inarray, qfield);
338 }
virtual void v_CalcPhysDeriv(const Array< OneD, const Array< OneD, NekDouble > > &inarray, TensorOfArray3D< NekDouble > &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 1508 of file CompressibleFlowSystemImplicit.cpp.

1517{
1518 TensorOfArray3D<NekDouble> qfield;
1519
1520 if (m_viscousJacFlag)
1521 {
1522 CalcPhysDeriv(inarray, qfield);
1523 }
1524
1525 NekSingle zero = 0.0;
1526 Fill2DArrayOfBlkDiagonalMat(gmtxarray, zero);
1527
1528 LibUtilities::Timer timer;
1529 timer.Start();
1530 AddMatNSBlkDiagVol(inarray, qfield, gmtxarray, m_stdSMatDataDBB,
1532 timer.Stop();
1533 timer.AccumulateRegion("CFSImplicit::AddMatNSBlkDiagVol", 2);
1534
1535 timer.Start();
1536 AddMatNSBlkDiagBnd(inarray, qfield, gmtxarray, TraceJac, TraceJacDeriv,
1537 TraceJacDerivSign, TraceIPSymJacArray);
1538 timer.Stop();
1539 timer.AccumulateRegion("CFSImplicit::AddMatNSBlkDiagBnd", 2);
1540
1541 MultiplyElmtInvMassPlusSource<NekSingle>(gmtxarray, m_TimeIntegLambda);
1542
1543 timer.Start();
1544 ElmtVarInvMtrx(gmtxarray, gmtVar, zero);
1545 timer.Stop();
1546 timer.AccumulateRegion("CFSImplicit::ElmtVarInvMtrx", 2);
1547
1548 TransTraceJacMatToArray(TraceJac, TraceJacArray);
1549}
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)
void ElmtVarInvMtrx(Array< OneD, Array< OneD, TypeNekBlkMatSharedPtr > > &gmtxarray, TypeNekBlkMatSharedPtr &gmtVar, const DataType &tmpDatatype)
void TransTraceJacMatToArray(const Array< OneD, TypeNekBlkMatSharedPtr > &TraceJac, TensorOfArray4D< DataType > &TraceJacDerivArray)
void CalcPhysDeriv(const Array< OneD, const Array< OneD, NekDouble > > &inarray, TensorOfArray3D< NekDouble > &qfield)
TensorOfArray4D< NekSingle > m_stdSMatDataDBB
TensorOfArray5D< NekSingle > m_stdSMatDataDBDB
NekDouble m_TimeIntegLambda
coefff of spacial derivatives(rhs or m_F in GLM) in calculating the residual of the whole equation(us...
void Fill2DArrayOfBlkDiagonalMat(Array< OneD, Array< OneD, TypeNekBlkMatSharedPtr > > &gmtxarray, const DataType valu)
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)

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 463 of file CompressibleFlowSystemImplicit.cpp.

464{
465 unsigned int nvariables = m_fields.size();
466 unsigned int ntotal = inarray.size();
467 unsigned int npoints = ntotal / nvariables;
468
469 unsigned int nTotalGlobal = ntotal;
470 m_comm->GetSpaceComm()->AllReduce(nTotalGlobal,
472 unsigned int nTotalDOF = nTotalGlobal / nvariables;
473 NekDouble invTotalDOF = 1.0 / nTotalDOF;
474
475 m_inArrayNorm = 0.0;
476 m_magnitdEstimat = Array<OneD, NekDouble>(nvariables, 0.0);
477
478 for (int i = 0; i < nvariables; ++i)
479 {
480 int offset = i * npoints;
482 Vmath::Dot(npoints, inarray + offset, inarray + offset);
483 }
484 m_comm->GetSpaceComm()->AllReduce(m_magnitdEstimat,
486
487 for (int i = 0; i < nvariables; ++i)
488 {
490 }
491
492 for (int i = 2; i < nvariables - 1; ++i)
493 {
495 }
496
497 for (int i = 2; i < nvariables - 1; ++i)
498 {
500 }
501
502 for (int i = 0; i < nvariables; ++i)
503 {
504 m_magnitdEstimat[i] = sqrt(m_magnitdEstimat[i] * invTotalDOF);
505 }
506 if (m_comm->GetRank() == 0 && m_verbose)
507 {
508 for (int i = 0; i < nvariables; ++i)
509 {
510 std::cout << "m_magnitdEstimat[" << i
511 << "] = " << m_magnitdEstimat[i] << std::endl;
512 }
513 std::cout << "m_inArrayNorm = " << m_inArrayNorm << std::endl;
514 }
515}
Array< OneD, NekDouble > m_magnitdEstimat
Estimate the magnitude of each conserved varibles.
LibUtilities::CommSharedPtr m_comm
Communicator.
double NekDouble
T Dot(int n, const T *w, const T *x)
dot product
Definition: Vmath.hpp:761
scalarT< T > sqrt(scalarT< T > in)
Definition: scalar.hpp:285

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 1433 of file CompressibleFlowSystemImplicit.cpp.

1448{
1450 {
1451 auto advWeakDGObject =
1452 std::dynamic_pointer_cast<SolverUtils::AdvectionWeakDG>(
1453 m_advObject);
1454 ASSERTL0(advWeakDGObject,
1455 "Use WeakDG for implicit compressible flow solver!");
1456 advWeakDGObject->AdvectTraceFlux(nConvectiveFields, m_fields, AdvVel,
1457 inarray, traceflux, m_bndEvaluateTime,
1458 vFwd, vBwd);
1459 }
1460 else
1461 {
1462 for (int i = 0; i < nConvectiveFields; i++)
1463 {
1464 traceflux[i] = Array<OneD, NekDouble>(nTracePts, 0.0);
1465 }
1466 }
1467
1468 if (m_viscousJacFlag)
1469 {
1470 Array<OneD, Array<OneD, NekDouble>> visflux(nConvectiveFields);
1471 for (int i = 0; i < nConvectiveFields; i++)
1472 {
1473 visflux[i] = Array<OneD, NekDouble>(nTracePts, 0.0);
1474 }
1475
1476 std::string diffName;
1477 m_session->LoadSolverInfo("DiffusionType", diffName, "InteriorPenalty");
1478 if (diffName == "InteriorPenalty")
1479 {
1480 m_diffusion->DiffuseTraceFlux(fields, inarray, qfield,
1482 vFwd, vBwd, nonZeroIndex);
1483 }
1484 else
1485 {
1486 ASSERTL1(false, "LDGNS not yet validated for implicit compressible "
1487 "flow solver");
1488 // For LDGNS, the array size should be nConvectiveFields - 1
1489 Array<OneD, Array<OneD, NekDouble>> inBwd(nConvectiveFields - 1);
1490 Array<OneD, Array<OneD, NekDouble>> inFwd(nConvectiveFields - 1);
1491 for (int i = 0; i < nConvectiveFields - 1; ++i)
1492 {
1493 inBwd[i] = vBwd[i];
1494 inFwd[i] = vFwd[i];
1495 }
1496 m_diffusion->DiffuseTraceFlux(fields, inarray, qfield,
1498 inFwd, inBwd, nonZeroIndex);
1499 }
1500 for (int i = 0; i < nConvectiveFields; i++)
1501 {
1502 Vmath::Vsub(nTracePts, traceflux[i], 1, visflux[i], 1, traceflux[i],
1503 1);
1504 }
1505 }
1506}
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:208
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode....
Definition: ErrorUtil.hpp:242
SolverUtils::DiffusionSharedPtr m_diffusion
LibUtilities::SessionReaderSharedPtr m_session
The session reader.
static Array< OneD, Array< OneD, Array< OneD, NekDouble > > > NullNekDoubleTensorOfArray3D
void Vsub(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Subtract vector z = x-y.
Definition: Vmath.hpp:220

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 931 of file CompressibleFlowSystemImplicit.cpp.

933{
934 std::shared_ptr<LocalRegions::ExpansionVector> expvect =
935 m_fields[0]->GetExp();
936 int nTotElmt = (*expvect).size();
937
938 StdMatDataDBB = TensorOfArray4D<DataType>(nTotElmt);
939 StdMatDataDBDB = TensorOfArray5D<DataType>(nTotElmt);
940
941 std::vector<DNekMatSharedPtr> VectStdDerivBase0;
942 std::vector<TensorOfArray3D<DataType>> VectStdDerivBase_Base;
943 std::vector<TensorOfArray4D<DataType>> VectStdDervBase_DervBase;
944 DNekMatSharedPtr MatStdDerivBase0;
945 Array<OneD, DNekMatSharedPtr> ArrayStdMat(m_spacedim);
946 Array<OneD, Array<OneD, NekDouble>> ArrayStdMatData(m_spacedim);
947 for (int ne = 0; ne < nTotElmt; ne++)
948 {
950 stdExp = (*expvect)[ne]->GetStdExp();
951 StdRegions::StdMatrixKey matkey(StdRegions::eDerivBase0,
952 stdExp->DetShapeType(), *stdExp);
953 MatStdDerivBase0 = stdExp->GetStdMatrix(matkey);
954
955 int nTotStdExp = VectStdDerivBase0.size();
956 int nFoundStdExp = -1;
957 for (int i = 0; i < nTotStdExp; i++)
958 {
959 if ((*VectStdDerivBase0[i]) == (*MatStdDerivBase0))
960 {
961 nFoundStdExp = i;
962 }
963 }
964 if (nFoundStdExp >= 0)
965 {
966 StdMatDataDBB[ne] = VectStdDerivBase_Base[nFoundStdExp];
967 StdMatDataDBDB[ne] = VectStdDervBase_DervBase[nFoundStdExp];
968 }
969 else
970 {
971 int nElmtCoef = (*expvect)[ne]->GetNcoeffs();
972 int nElmtCoef2 = nElmtCoef * nElmtCoef;
973 int nElmtPnt = (*expvect)[ne]->GetTotPoints();
974
975 int nQuot = nElmtCoef2 / m_nPadding;
976 int nRemd = nElmtCoef2 - nQuot * m_nPadding;
977 int nQuotPlus = nQuot;
978 if (nRemd > 0)
979 {
980 nQuotPlus++;
981 }
982 int nPaded = nQuotPlus * m_nPadding;
983
984 ArrayStdMat[0] = MatStdDerivBase0;
985 if (m_spacedim > 1)
986 {
987 StdRegions::StdMatrixKey matkey(
988 StdRegions::eDerivBase1, stdExp->DetShapeType(), *stdExp);
989 ArrayStdMat[1] = stdExp->GetStdMatrix(matkey);
990
991 if (m_spacedim > 2)
992 {
993 StdRegions::StdMatrixKey matkey(StdRegions::eDerivBase2,
994 stdExp->DetShapeType(),
995 *stdExp);
996 ArrayStdMat[2] = stdExp->GetStdMatrix(matkey);
997 }
998 }
999 for (int nd0 = 0; nd0 < m_spacedim; nd0++)
1000 {
1001 ArrayStdMatData[nd0] = ArrayStdMat[nd0]->GetPtr();
1002 }
1003
1004 StdRegions::StdMatrixKey matkey(StdRegions::eBwdMat,
1005 stdExp->DetShapeType(), *stdExp);
1006 DNekMatSharedPtr BwdMat = stdExp->GetStdMatrix(matkey);
1007 Array<OneD, NekDouble> BwdMatData = BwdMat->GetPtr();
1008
1009 TensorOfArray3D<DataType> tmpStdDBB(m_spacedim);
1010 TensorOfArray4D<DataType> tmpStdDBDB(m_spacedim);
1011
1012 for (int nd0 = 0; nd0 < m_spacedim; nd0++)
1013 {
1014 tmpStdDBB[nd0] = Array<OneD, Array<OneD, DataType>>(nElmtPnt);
1015 for (int i = 0; i < nElmtPnt; i++)
1016 {
1017 tmpStdDBB[nd0][i] = Array<OneD, DataType>(nPaded, 0.0);
1018 for (int nc1 = 0; nc1 < nElmtCoef; nc1++)
1019 {
1020 int noffset = nc1 * nElmtCoef;
1021 for (int nc0 = 0; nc0 < nElmtCoef; nc0++)
1022 {
1023 tmpStdDBB[nd0][i][nc0 + noffset] = DataType(
1024 ArrayStdMatData[nd0][i * nElmtCoef + nc0] *
1025 BwdMatData[i * nElmtCoef + nc1]);
1026 }
1027 }
1028 }
1029
1030 tmpStdDBDB[nd0] = TensorOfArray3D<DataType>(m_spacedim);
1031 for (int nd1 = 0; nd1 < m_spacedim; nd1++)
1032 {
1033 tmpStdDBDB[nd0][nd1] =
1034 Array<OneD, Array<OneD, DataType>>(nElmtPnt);
1035 for (int i = 0; i < nElmtPnt; i++)
1036 {
1037 tmpStdDBDB[nd0][nd1][i] =
1038 Array<OneD, DataType>(nPaded, 0.0);
1039 for (int nc1 = 0; nc1 < nElmtCoef; nc1++)
1040 {
1041 int noffset = nc1 * nElmtCoef;
1042 for (int nc0 = 0; nc0 < nElmtCoef; nc0++)
1043 {
1044 tmpStdDBDB[nd0][nd1][i][nc0 + noffset] =
1045 DataType(
1046 ArrayStdMatData[nd0]
1047 [i * nElmtCoef + nc0] *
1048 ArrayStdMatData[nd1]
1049 [i * nElmtCoef + nc1]);
1050 }
1051 }
1052 }
1053 }
1054 }
1055 VectStdDerivBase0.push_back(MatStdDerivBase0);
1056 VectStdDerivBase_Base.push_back(tmpStdDBB);
1057 VectStdDervBase_DervBase.push_back(tmpStdDBDB);
1058
1059 StdMatDataDBB[ne] = tmpStdDBB;
1060 StdMatDataDBDB[ne] = tmpStdDBDB;
1061 }
1062 }
1063}
std::shared_ptr< StdExpansion > StdExpansionSharedPtr

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 343 of file CompressibleFlowSystemImplicit.cpp.

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

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 364 of file CompressibleFlowSystemImplicit.cpp.

369{
370 v_DoDiffusionCoeff(inarray, outarray, pFwd, pBwd);
371}
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)

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 373 of file CompressibleFlowSystemImplicit.cpp.

377{
378 unsigned int nvariables = inpnts.size();
379 unsigned int ncoeffs = m_fields[0]->GetNcoeffs();
380 unsigned int ntotal = nvariables * ncoeffs;
381
382 Array<OneD, NekDouble> inarray(ntotal);
383 Array<OneD, NekDouble> outarray(ntotal);
384 Array<OneD, NekDouble> tmpArray;
385 Array<OneD, Array<OneD, NekDouble>> tmpIn(nvariables);
386 Array<OneD, Array<OneD, NekDouble>> tmpOut(nvariables);
387 Array<OneD, Array<OneD, NekDouble>> tmpoutarray(nvariables);
388 // Switch flag to make sure the physical shock capturing AV is updated
390 if (m_ALESolver)
391 {
393 }
394 else
395 {
396 tmpIn = inpnts;
397 }
398 for (int i = 0; i < nvariables; ++i)
399 {
400 int noffset = i * ncoeffs;
401 tmpArray = inarray + noffset;
402 m_fields[i]->FwdTrans(tmpIn[i], tmpArray);
403 }
404
405 DoImplicitSolveCoeff(tmpIn, inarray, outarray, time, lambda);
406
407 if (m_ALESolver)
408 {
409
410 for (int i = 0; i < nvariables; ++i)
411 {
412 tmpOut[i] = Array<OneD, NekDouble>(tmpIn[0].size(), 0.0);
413 tmpoutarray[i] = Array<OneD, NekDouble>(ncoeffs, 0.0);
414 }
415 for (int i = 0; i < nvariables; ++i)
416 {
417 int noffset = i * ncoeffs;
418 tmpArray = outarray + noffset;
419 m_fields[i]->BwdTrans(tmpArray, tmpOut[i]);
420 }
421 MultiRegions::GlobalMatrixKey mkey(StdRegions::eMass);
422 for (int i = 0; i < nvariables; ++i)
423 {
424 m_fields[i]->FwdTrans(tmpOut[i], tmpoutarray[i]);
425 m_fields[i]->GeneralMatrixOp(mkey, tmpoutarray[i], outpnt[i]);
426 }
427 }
428 else
429 {
430 for (int i = 0; i < nvariables; ++i)
431 {
432 int noffset = i * ncoeffs;
433 tmpArray = outarray + noffset;
434 m_fields[i]->BwdTrans(tmpArray, outpnt[i]);
435 }
436 }
437}
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)
SOLVER_UTILS_EXPORT void ALEDoElmtInvMassBwdTrans(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)
Definition: ALEHelper.cpp:148

References Nektar::SolverUtils::ALEHelper::ALEDoElmtInvMassBwdTrans(), DoImplicitSolveCoeff(), Nektar::StdRegions::eMass, Nektar::SolverUtils::ALEHelper::m_ALESolver, Nektar::SolverUtils::EquationSystem::m_fields, 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 439 of file CompressibleFlowSystemImplicit.cpp.

443{
444 m_TimeIntegLambda = lambda;
445 m_bndEvaluateTime = time;
446 m_solutionPhys = inpnts;
447 unsigned int ntotal = inarray.size();
448
449 if (m_inArrayNorm < 0.0)
450 {
451 CalcRefValues(inarray);
452
453 m_nonlinsol->SetRhsMagnitude(m_inArrayNorm);
454 }
455
456 m_TotNewtonIts += m_nonlinsol->SolveSystem(ntotal, inarray, out);
457
458 m_TotLinIts += m_nonlinsol->GetNtotLinSysIts();
459
461}
void CalcRefValues(const Array< OneD, const NekDouble > &inarray)
Array< OneD, Array< OneD, NekDouble > > m_solutionPhys
LibUtilities::NekNonlinSysIterSharedPtr m_nonlinsol

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.

259{
260 int nvariables = inarray.size();
261 int ncoeffs = m_fields[0]->GetNcoeffs();
262
263 Array<OneD, Array<OneD, NekDouble>> tmpOut(nvariables);
264 for (int i = 0; i < nvariables; ++i)
265 {
266 tmpOut[i] = Array<OneD, NekDouble>(ncoeffs);
267 }
268
269 DoOdeRhsCoeff(inarray, tmpOut, time);
270
271 for (int i = 0; i < nvariables; ++i)
272 {
273 m_fields[i]->BwdTrans(tmpOut[i], outarray[i]);
274 }
275}
void DoOdeRhsCoeff(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
Compute the right-hand side.

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.

283{
284 ASSERTL0(
286 "Do not use Local Time-Stepping with implicit time-discretization");
287
288 LibUtilities::Timer timer;
289
290 int nvariables = inarray.size();
291 int nTracePts = GetTraceTotPoints();
292 int ncoeffs = GetNcoeffs();
293
294 m_bndEvaluateTime = time;
295
296 // Store forwards/backwards space along trace space
297 Array<OneD, Array<OneD, NekDouble>> Fwd(nvariables);
298 Array<OneD, Array<OneD, NekDouble>> Bwd(nvariables);
299
301 {
304 }
305 else
306 {
307 for (int i = 0; i < nvariables; ++i)
308 {
309 Fwd[i] = Array<OneD, NekDouble>(nTracePts, 0.0);
310 Bwd[i] = Array<OneD, NekDouble>(nTracePts, 0.0);
311 m_fields[i]->GetFwdBwdTracePhys(inarray[i], Fwd[i], Bwd[i]);
312 }
313 }
314
315 // Calculate advection
316 timer.Start();
317 DoAdvectionCoeff(inarray, outarray, time, Fwd, Bwd);
318 timer.Stop();
319 timer.AccumulateRegion("CFSImplicit::DoAdvectionCoeff", 2);
320
321 // Negate results
322 for (int i = 0; i < nvariables; ++i)
323 {
324 Vmath::Neg(ncoeffs, outarray[i], 1);
325 }
326
327 // Add diffusion terms
328 timer.Start();
329 DoDiffusionCoeff(inarray, outarray, Fwd, Bwd);
330 timer.Stop();
331 timer.AccumulateRegion("CFSImplicit::DoDiffusionCoeff", 2);
332
333 // Add forcing terms
334 for (auto &x : m_forcing)
335 {
336 x->ApplyCoeff(m_fields, inarray, outarray, time);
337 }
338}
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 coeffic...
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.
std::vector< SolverUtils::ForcingSharedPtr > m_forcing
SOLVER_UTILS_EXPORT int GetNcoeffs()
enum HomogeneousType m_HomogeneousType
SOLVER_UTILS_EXPORT int GetTraceTotPoints()
static Array< OneD, Array< OneD, NekDouble > > NullNekDoubleArrayOfArray
void Neg(int n, T *x, const int incx)
Negate x = -x.
Definition: Vmath.hpp:292

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 1095 of file CompressibleFlowSystemImplicit.cpp.

1099{
1100 int n1d = gmtxarray.size();
1101 int n2d = gmtxarray[0].size();
1102 int nConvectiveFields = n1d;
1103
1104 ASSERTL0(n1d == n2d, "ElmtVarInvMtrx requires n1d==n2d");
1105
1106 Array<OneD, unsigned int> rowSizes;
1107 Array<OneD, unsigned int> colSizes;
1108
1109 gmtxarray[0][0]->GetBlockSizes(rowSizes, colSizes);
1110 int nTotElmt = rowSizes.size();
1111 int nElmtCoef = rowSizes[0] - 1;
1112 int nElmtCoef0 = -1;
1113 int blocksize = -1;
1114
1115 Array<OneD, unsigned int> tmprow(1);
1116 TypeNekBlkMatSharedPtr tmpGmtx;
1117
1118 Array<OneD, DataType> GMatData, ElmtMatData;
1119 Array<OneD, DataType> tmpArray1, tmpArray2;
1120
1121 for (int nelmt = 0; nelmt < nTotElmt; nelmt++)
1122 {
1123 int nrows = gmtxarray[0][0]->GetBlock(nelmt, nelmt)->GetRows();
1124 int ncols = gmtxarray[0][0]->GetBlock(nelmt, nelmt)->GetColumns();
1125 ASSERTL0(nrows == ncols, "ElmtVarInvMtrx requires nrows==ncols");
1126
1127 nElmtCoef = nrows;
1128
1129 if (nElmtCoef0 != nElmtCoef)
1130 {
1131 nElmtCoef0 = nElmtCoef;
1132 int nElmtCoefVar = nElmtCoef0 * nConvectiveFields;
1133 blocksize = nElmtCoefVar * nElmtCoefVar;
1134 tmprow[0] = nElmtCoefVar;
1135 AllocateNekBlkMatDig(tmpGmtx, tmprow, tmprow);
1136 GMatData = tmpGmtx->GetBlock(0, 0)->GetPtr();
1137 }
1138
1139 for (int n = 0; n < nConvectiveFields; n++)
1140 {
1141 for (int m = 0; m < nConvectiveFields; m++)
1142 {
1143 ElmtMatData = gmtxarray[m][n]->GetBlock(nelmt, nelmt)->GetPtr();
1144
1145 for (int ncl = 0; ncl < nElmtCoef; ncl++)
1146 {
1147 int Goffset =
1148 (n * nElmtCoef + ncl) * nConvectiveFields * nElmtCoef +
1149 m * nElmtCoef;
1150 int Eoffset = ncl * nElmtCoef;
1151
1152 Vmath::Vcopy(nElmtCoef, tmpArray1 = ElmtMatData + Eoffset,
1153 1, tmpArray2 = GMatData + Goffset, 1);
1154 }
1155 }
1156 }
1157
1158 tmpGmtx->GetBlock(0, 0)->Invert();
1159
1160 for (int m = 0; m < nConvectiveFields; m++)
1161 {
1162 for (int n = 0; n < nConvectiveFields; n++)
1163 {
1164 ElmtMatData = gmtxarray[m][n]->GetBlock(nelmt, nelmt)->GetPtr();
1165
1166 for (int ncl = 0; ncl < nElmtCoef; ncl++)
1167 {
1168 int Goffset =
1169 (n * nElmtCoef + ncl) * nConvectiveFields * nElmtCoef +
1170 m * nElmtCoef;
1171 int Eoffset = ncl * nElmtCoef;
1172
1173 Vmath::Vcopy(nElmtCoef, tmpArray1 = GMatData + Goffset, 1,
1174 tmpArray2 = ElmtMatData + Eoffset, 1);
1175 }
1176 }
1177 }
1178 ElmtMatData = gmtVar->GetBlock(nelmt, nelmt)->GetPtr();
1179 Vmath::Vcopy(blocksize, GMatData, 1, ElmtMatData, 1);
1180 }
1181 return;
1182}
void AllocateNekBlkMatDig(SNekBlkMatSharedPtr &mat, const Array< OneD, unsigned int > nrow, const Array< OneD, unsigned int > ncol)

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 1863 of file CompressibleFlowSystemImplicit.cpp.

1865{
1866 int n1d = gmtxarray.size();
1867
1868 Array<OneD, unsigned int> rowSizes;
1869 Array<OneD, unsigned int> colSizes;
1870
1871 Array<OneD, DataType> loc_mat_arr;
1872
1873 for (int n1 = 0; n1 < n1d; ++n1)
1874 {
1875 gmtxarray[n1]->GetBlockSizes(rowSizes, colSizes);
1876 int nelmts = rowSizes.size();
1877
1878 for (int i = 0; i < nelmts; ++i)
1879 {
1880 loc_mat_arr = gmtxarray[n1]->GetBlock(i, i)->GetPtr();
1881
1882 int nrows = gmtxarray[n1]->GetBlock(i, i)->GetRows();
1883 int ncols = gmtxarray[n1]->GetBlock(i, i)->GetColumns();
1884
1885 Vmath::Fill(nrows * ncols, valu, loc_mat_arr, 1);
1886 }
1887 }
1888}

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 1850 of file CompressibleFlowSystemImplicit.cpp.

1853{
1854 int n1d = gmtxarray.size();
1855
1856 for (int n1 = 0; n1 < n1d; ++n1)
1857 {
1858 Fill1DArrayOfBlkDiagonalMat(gmtxarray[n1], valu);
1859 }
1860}
void Fill1DArrayOfBlkDiagonalMat(Array< OneD, TypeNekBlkMatSharedPtr > &gmtxarray, const DataType 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.

330 {
331 v_GetFluxDerivJacDirctn(explist, normals, nDervDir, inarray, ElmtJac);
332 }
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)

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.

306 {
307 v_GetFluxDerivJacDirctn(explist, normals, nDervDir, inarray,
308 ElmtJacArray, nFluxDir);
309 }

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.

318 {
319 v_GetFluxDerivJacDirctnElmt(nConvectiveFields, nElmtPnt, nDervDir,
320 locVars, locmu, locnormal, wspMat,
321 PntJacArray);
322 }
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)

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 1728 of file CompressibleFlowSystemImplicit.cpp.

1733{
1734 Array<OneD, NekDouble> wspMatData = wspMat->GetPtr();
1735
1736 int matsize = nConvectiveFields * nConvectiveFields;
1737
1738 Array<OneD, NekDouble> pointVar(nConvectiveFields);
1739
1740 for (int npnt = 0; npnt < nElmtPnt; npnt++)
1741 {
1742 for (int j = 0; j < nConvectiveFields; j++)
1743 {
1744 pointVar[j] = locVars[j][npnt];
1745 }
1746
1747 GetFluxVectorJacPoint(nConvectiveFields, pointVar, normals, wspMat);
1748
1749 Vmath::Vcopy(matsize, wspMatData, 1, PntJacArray[npnt], 1);
1750 }
1751 return;
1752}
void GetFluxVectorJacPoint(const int nConvectiveFields, const Array< OneD, NekDouble > &conservVar, const Array< OneD, NekDouble > &normals, DNekMatSharedPtr &fluxJac)

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 1754 of file CompressibleFlowSystemImplicit.cpp.

1757{
1758 int nvariables = conservVar.size();
1759 const int nvariables3D = 5;
1760 int expDim = m_spacedim;
1761
1762 NekDouble fsw, efix_StegerWarming;
1763 efix_StegerWarming = 0.0;
1764 fsw = 0.0; // exact flux Jacobian if fsw=0.0
1765 if (nvariables > expDim + 2)
1766 {
1767 NEKERROR(ErrorUtil::efatal, "nvariables > expDim+2 case not coded")
1768 }
1769
1770 Array<OneD, NekDouble> fluxJacData;
1771 ;
1772 fluxJacData = fluxJac->GetPtr();
1773
1774 if (nConvectiveFields == nvariables3D)
1775 {
1776 PointFluxJacobianPoint(conservVar, normals, fluxJac, efix_StegerWarming,
1777 fsw);
1778 }
1779 else
1780 {
1781 DNekMatSharedPtr PointFJac3D =
1783 nvariables3D, 0.0);
1784
1785 Array<OneD, NekDouble> PointFJac3DData;
1786 PointFJac3DData = PointFJac3D->GetPtr();
1787
1788 Array<OneD, NekDouble> PointFwd(nvariables3D, 0.0);
1789
1790 Array<OneD, unsigned int> index(nvariables);
1791
1792 index[nvariables - 1] = 4;
1793 for (int i = 0; i < nvariables - 1; i++)
1794 {
1795 index[i] = i;
1796 }
1797
1798 int nj = 0;
1799 int nk = 0;
1800 for (int j = 0; j < nvariables; j++)
1801 {
1802 nj = index[j];
1803 PointFwd[nj] = conservVar[j];
1804 }
1805
1806 PointFluxJacobianPoint(PointFwd, normals, PointFJac3D,
1807 efix_StegerWarming, fsw);
1808
1809 for (int j = 0; j < nvariables; j++)
1810 {
1811 nj = index[j];
1812 for (int k = 0; k < nvariables; k++)
1813 {
1814 nk = index[k];
1815 fluxJacData[j + k * nConvectiveFields] =
1816 PointFJac3DData[nj + nk * nvariables3D];
1817 }
1818 }
1819 }
1820}
#define NEKERROR(type, msg)
Assert Level 0 – Fundamental assert which is used whether in FULLDEBUG, DEBUG or OPT compilation mode...
Definition: ErrorUtil.hpp:202
void PointFluxJacobianPoint(const Array< OneD, NekDouble > &Fwd, const Array< OneD, NekDouble > &normals, DNekMatSharedPtr &FJac, const NekDouble efix, const NekDouble fsw)

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 1185 of file CompressibleFlowSystemImplicit.cpp.

1192{
1193 int nvariables = inarray.size();
1194 int nTracePts = GetTraceTotPoints();
1195
1196 // Store forwards/backwards space along trace space
1197 Array<OneD, Array<OneD, NekDouble>> Fwd(nvariables);
1198 Array<OneD, Array<OneD, NekDouble>> Bwd(nvariables);
1199
1200 TypeNekBlkMatSharedPtr FJac, BJac;
1201 Array<OneD, unsigned int> n_blks1(nTracePts, nvariables);
1202
1203 if (TraceJac.size() > 0)
1204 {
1205 FJac = TraceJac[0];
1206 BJac = TraceJac[1];
1207 }
1208 else
1209 {
1210 TraceJac = Array<OneD, TypeNekBlkMatSharedPtr>(2);
1211
1212 AllocateNekBlkMatDig(FJac, n_blks1, n_blks1);
1213 AllocateNekBlkMatDig(BJac, n_blks1, n_blks1);
1214 }
1215
1217 {
1220 }
1221 else
1222 {
1223 for (int i = 0; i < nvariables; ++i)
1224 {
1225 Fwd[i] = Array<OneD, NekDouble>(nTracePts, 0.0);
1226 Bwd[i] = Array<OneD, NekDouble>(nTracePts, 0.0);
1227 m_fields[i]->GetFwdBwdTracePhys(inarray[i], Fwd[i], Bwd[i]);
1228 }
1229 }
1230
1231 Array<OneD, Array<OneD, NekDouble>> AdvVel(m_spacedim);
1232
1233 NumCalcRiemFluxJac(nvariables, m_fields, AdvVel, inarray, qfield,
1234 m_bndEvaluateTime, Fwd, Bwd, FJac, BJac,
1235 TraceIPSymJacArray);
1236
1237 TraceJac[0] = FJac;
1238 TraceJac[1] = BJac;
1239}
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)

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.

82{
83 int nvariables = m_fields.size();
84 int ntotal = m_fields[0]->GetNcoeffs() * nvariables;
85
86 std::string SolverType = "Newton";
87 if (m_session->DefinesSolverInfo("NonlinSysIterSolver"))
88 {
89 SolverType = m_session->GetSolverInfo("NonlinSysIterSolver");
90 }
93 "NekNonlinSys '" + SolverType + "' is not defined.\n");
94
95 // Create the key to hold settings for nonlin solver
96 LibUtilities::NekSysKey key = LibUtilities::NekSysKey();
97 // Load required LinSys parameters:
98 m_session->LoadParameter("NekLinSysMaxIterations",
99 key.m_NekLinSysMaxIterations, 30);
100 m_session->LoadParameter("LinSysMaxStorage", key.m_LinSysMaxStorage, 30);
101 m_session->LoadParameter("LinSysRelativeTolInNonlin",
102 key.m_NekLinSysTolerance, 5.0E-2);
103 m_session->LoadParameter("GMRESMaxHessMatBand", key.m_KrylovMaxHessMatBand,
104 31);
105 m_session->MatchSolverInfo("GMRESLeftPrecon", "True",
106 key.m_NekLinSysLeftPrecon, false);
107 m_session->MatchSolverInfo("GMRESRightPrecon", "True",
108 key.m_NekLinSysRightPrecon, true);
109 int GMRESCentralDifference = 0;
110 m_session->LoadParameter("GMRESCentralDifference", GMRESCentralDifference,
111 0);
112 key.m_GMRESCentralDifference = (bool)GMRESCentralDifference;
113 // Load required NonLinSys parameters:
114 m_session->LoadParameter("NekNonlinSysMaxIterations",
115 key.m_NekNonlinSysMaxIterations, 10);
116 m_session->LoadParameter("NewtonRelativeIteTol",
117 key.m_NekNonLinSysTolerance, 1.0E-12);
118 WARNINGL0(!m_session->DefinesParameter("NewtonAbsoluteIteTol"),
119 "Please specify NewtonRelativeIteTol instead of "
120 "NewtonAbsoluteIteTol in XML session file");
121 m_session->LoadParameter("NonlinIterTolRelativeL2",
122 key.m_NonlinIterTolRelativeL2, 1.0E-3);
123 m_session->LoadSolverInfo("LinSysIterSolverTypeInNonlin",
124 key.m_LinSysIterSolverTypeInNonlin, "GMRES");
125
126 // Initialize operator
127 LibUtilities::NekSysOperators nekSysOp;
128 nekSysOp.DefineNekSysResEval(&CFSImplicit::NonlinSysEvaluatorCoeff1D, this);
129 nekSysOp.DefineNekSysLhsEval(&CFSImplicit::MatrixMultiplyMatrixFreeCoeff,
130 this);
131 nekSysOp.DefineNekSysPrecon(&CFSImplicit::PreconCoeff, this);
132
133 // Initialize trace
134 const auto locTraceToTraceMap = m_fields[0]->GetLocTraceToTraceMap();
135 locTraceToTraceMap->CalcLocTracePhysToTraceIDMap(m_fields[0]->GetTrace(),
136 m_spacedim);
137 for (int i = 1; i < nvariables; i++)
138 {
139 m_fields[i]->GetLocTraceToTraceMap()->SetLocTracePhysToTraceIDMap(
140 locTraceToTraceMap->GetLocTracephysToTraceIDMap());
141 }
142
143 // Initialize non-linear system
145 "Newton", m_session, m_comm->GetRowComm(), ntotal, key);
146 m_nonlinsol->SetSysOperators(nekSysOp);
147
148 // Initialize preconditioner
149 NekPreconCfsOperators preconOp;
150 preconOp.DefineCalcPreconMatBRJCoeff(&CFSImplicit::CalcPreconMatBRJCoeff,
151 this);
154 m_preconCfs->SetOperators(preconOp);
155}
#define WARNINGL0(condition, msg)
Definition: ErrorUtil.hpp:215
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)
void PreconCoeff(const Array< OneD, NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const bool &flag)
void NonlinSysEvaluatorCoeff1D(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out, const bool &flag)
void MatrixMultiplyMatrixFreeCoeff(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out, const bool &centralDifferenceFlag)
tBaseSharedPtr CreateInstance(tKey idKey, tParam... args)
Create an instance of the class referred to by idKey.
NekNonlinSysIterFactory & GetNekNonlinSysIterFactory()
PreconCfsFactory & GetPreconCfsFactory()
Declaration of the boundary condition factory singleton.
Definition: PreconCfs.cpp:41

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 517 of file CompressibleFlowSystemImplicit.cpp.

520{
521 const Array<OneD, const NekDouble> solref = m_nonlinsol->GetRefSolution();
522
523 unsigned int ntotal = inarray.size();
524 NekDouble magninarray = Vmath::Dot(ntotal, inarray, inarray);
525 m_comm->GetSpaceComm()->AllReduce(magninarray,
527 NekDouble eps =
528 m_jacobiFreeEps * sqrt((sqrt(m_inArrayNorm) + 1.0) / magninarray);
529
530 Array<OneD, NekDouble> solplus{ntotal};
531 Array<OneD, NekDouble> resplus{ntotal};
532 Vmath::Svtvp(ntotal, eps, inarray, 1, solref, 1, solplus, 1);
533 NonlinSysEvaluatorCoeff1D(solplus, resplus, !centralDifferenceFlag);
534
535 if (centralDifferenceFlag)
536 {
537 Array<OneD, NekDouble> solminus{ntotal};
538 Array<OneD, NekDouble> resminus{ntotal};
539 Vmath::Svtvp(ntotal, -1.0 * eps, inarray, 1, solref, 1, solminus, 1);
540 NonlinSysEvaluatorCoeff1D(solminus, resminus, false);
541 Vmath::Vsub(ntotal, resplus, 1, resminus, 1, out, 1);
542 Vmath::Smul(ntotal, 0.5 / eps, out, 1, out, 1);
543 }
544 else
545 {
546 const Array<OneD, const NekDouble> resref =
547 m_nonlinsol->GetRefResidual();
548
549 Vmath::Vsub(ntotal, resplus, 1, resref, 1, out, 1);
550 Vmath::Smul(ntotal, 1.0 / eps, out, 1, out, 1);
551 }
552}
void Svtvp(int n, const T alpha, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Svtvp (scalar times vector plus vector): z = alpha*x + y.
Definition: Vmath.hpp:396
void Smul(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Scalar multiply y = alpha*x.
Definition: Vmath.hpp:100

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.

294 {
295 v_MinusDiffusionFluxJacPoint(nConvectiveFields, nElmtPnt, locVars,
296 locDerv, locmu, locDmuDT, normals, wspMat,
297 PntJacArray);
298 }
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)

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 1566 of file CompressibleFlowSystemImplicit.cpp.

1569{
1571 std::shared_ptr<LocalRegions::ExpansionVector> pexp = explist->GetExp();
1572 int nTotElmt = (*pexp).size();
1573 int nConvectiveFields = m_fields.size();
1574
1575 NekDouble Negdtlamda = -dtlamda;
1576
1577 Array<OneD, NekDouble> pseudotimefactor(nTotElmt, 0.0);
1578 Vmath::Fill(nTotElmt, Negdtlamda, pseudotimefactor, 1);
1579
1580 Array<OneD, DataType> GMatData;
1581 for (int m = 0; m < nConvectiveFields; m++)
1582 {
1583 for (int n = 0; n < nConvectiveFields; n++)
1584 {
1585 for (int nelmt = 0; nelmt < nTotElmt; nelmt++)
1586 {
1587 GMatData = gmtxarray[m][n]->GetBlock(nelmt, nelmt)->GetPtr();
1588 DataType factor = DataType(pseudotimefactor[nelmt]);
1589
1590 Vmath::Smul(GMatData.size(), factor, GMatData, 1, GMatData, 1);
1591 }
1592 }
1593 }
1594
1595 DNekMatSharedPtr MassMat;
1596 Array<OneD, NekDouble> BwdMatData, MassMatData, tmp;
1597 Array<OneD, NekDouble> tmp2;
1598 Array<OneD, DataType> MassMatDataDataType;
1600
1601 for (int nelmt = 0; nelmt < nTotElmt; nelmt++)
1602 {
1603 int nelmtcoef = GetNcoeffs(nelmt);
1604 int nelmtpnts = GetTotPoints(nelmt);
1605 LibUtilities::ShapeType ElmtTypeNow =
1606 explist->GetExp(nelmt)->DetShapeType();
1607
1608 if (tmp.size() != nelmtcoef || (ElmtTypeNow != ElmtTypePrevious))
1609 {
1611 stdExp = explist->GetExp(nelmt)->GetStdExp();
1612 StdRegions::StdMatrixKey matkey(StdRegions::eBwdTrans,
1613 stdExp->DetShapeType(), *stdExp);
1614
1615 DNekMatSharedPtr BwdMat = stdExp->GetStdMatrix(matkey);
1616 BwdMatData = BwdMat->GetPtr();
1617
1618 if (nelmtcoef != tmp.size())
1619 {
1620 tmp = Array<OneD, NekDouble>(nelmtcoef, 0.0);
1622 nelmtcoef, nelmtcoef, 0.0);
1623 MassMatData = MassMat->GetPtr();
1624 MassMatDataDataType =
1625 Array<OneD, DataType>(nelmtcoef * nelmtcoef);
1626 }
1627
1628 ElmtTypePrevious = ElmtTypeNow;
1629 }
1630
1631 for (int np = 0; np < nelmtcoef; np++)
1632 {
1633 explist->GetExp(nelmt)->IProductWRTBase(BwdMatData + np * nelmtpnts,
1634 tmp);
1635 Vmath::Vcopy(nelmtcoef, tmp, 1, tmp2 = MassMatData + np * nelmtcoef,
1636 1);
1637 }
1638 for (int i = 0; i < MassMatData.size(); i++)
1639 {
1640 MassMatDataDataType[i] = DataType(MassMatData[i]);
1641 }
1642
1643 for (int m = 0; m < nConvectiveFields; m++)
1644 {
1645 GMatData = gmtxarray[m][m]->GetBlock(nelmt, nelmt)->GetPtr();
1646 Vmath::Vadd(MassMatData.size(), MassMatDataDataType, 1, GMatData, 1,
1647 GMatData, 1);
1648 }
1649 }
1650 return;
1651}
SOLVER_UTILS_EXPORT int GetTotPoints()
std::shared_ptr< ExpList > ExpListSharedPtr
Shared pointer to an ExpList object.

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, Nektar::Array< OneD, const DataType >::size(), 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.

219{
220 LibUtilities::Timer timer;
221 unsigned int nvariable = inarray.size();
222 unsigned int ncoeffs = m_fields[0]->GetNcoeffs();
223 unsigned int npoints = m_fields[0]->GetNpoints();
224
225 Array<OneD, Array<OneD, NekDouble>> inpnts(nvariable);
226
227 for (int i = 0; i < nvariable; ++i)
228 {
229 inpnts[i] = Array<OneD, NekDouble>(npoints, 0.0);
230 m_fields[i]->BwdTrans(inarray[i], inpnts[i]);
231 }
232
233 timer.Start();
234 DoOdeProjection(inpnts, inpnts, m_bndEvaluateTime);
235 timer.Stop();
236 timer.AccumulateRegion("CompressibleFlowSystem::DoOdeProjection", 1);
237
238 timer.Start();
239 DoOdeRhsCoeff(inpnts, out, m_bndEvaluateTime);
240 timer.Stop();
241 timer.AccumulateRegion("CFSImplicit::DoOdeRhsCoeff", 1);
242
243 for (int i = 0; i < nvariable; ++i)
244 {
245 Vmath::Svtvp(ncoeffs, -m_TimeIntegLambda, out[i], 1, inarray[i], 1,
246 out[i], 1);
247 if (flag)
248 {
249 Vmath::Vsub(ncoeffs, out[i], 1,
250 m_nonlinsol->GetRefSourceVec() + i * ncoeffs, 1, out[i],
251 1);
252 }
253 }
254}
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 discontinu...

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.

197{
198 LibUtilities::Timer timer;
199 unsigned int nvariables = m_fields.size();
200 unsigned int ncoeffs = m_fields[0]->GetNcoeffs();
201 Array<OneD, Array<OneD, NekDouble>> in2D(nvariables);
202 Array<OneD, Array<OneD, NekDouble>> out2D(nvariables);
203 for (int i = 0; i < nvariables; ++i)
204 {
205 int offset = i * ncoeffs;
206 in2D[i] = inarray + offset;
207 out2D[i] = out + offset;
208 }
209
210 timer.Start();
211 NonlinSysEvaluatorCoeff(in2D, out2D, flag);
212 timer.Stop();
213 timer.AccumulateRegion("CFSImplicit::NonlinSysEvaluatorCoeff1D");
214}
void NonlinSysEvaluatorCoeff(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &out, const bool &flag)

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 1242 of file CompressibleFlowSystemImplicit.cpp.

1252{
1253 const NekDouble PenaltyFactor2 = 0.0;
1254 int nvariables = nConvectiveFields;
1255 int npoints = GetNpoints();
1256 int nTracePts = GetTraceTotPoints();
1257 int nDim = m_spacedim;
1258
1259 Array<OneD, int> nonZeroIndex;
1260
1261 Array<OneD, Array<OneD, NekDouble>> tmpinarry(nvariables);
1262 for (int i = 0; i < nvariables; i++)
1263 {
1264 tmpinarry[i] = Array<OneD, NekDouble>(npoints, 0.0);
1265 Vmath::Vcopy(npoints, inarray[i], 1, tmpinarry[i], 1);
1266 }
1267
1268 // DmuDT of artificial diffusion is neglected
1269 // TODO: to consider the Jacobian of AV seperately
1270 Array<OneD, NekDouble> muvar = NullNekDouble1DArray;
1271 Array<OneD, NekDouble> MuVarTrace = NullNekDouble1DArray;
1272
1273 Array<OneD, Array<OneD, NekDouble>> numflux(nvariables);
1274 for (int i = 0; i < nvariables; ++i)
1275 {
1276 numflux[i] = Array<OneD, NekDouble>(nTracePts, 0.0);
1277 }
1278
1280 fields[0]->GetTraceMap();
1281 TensorOfArray3D<NekDouble> qBwd(nDim);
1282 TensorOfArray3D<NekDouble> qFwd(nDim);
1283 if (m_viscousJacFlag)
1284 {
1285 for (int nd = 0; nd < nDim; ++nd)
1286 {
1287 qBwd[nd] = Array<OneD, Array<OneD, NekDouble>>(nConvectiveFields);
1288 qFwd[nd] = Array<OneD, Array<OneD, NekDouble>>(nConvectiveFields);
1289 for (int i = 0; i < nConvectiveFields; ++i)
1290 {
1291 qBwd[nd][i] = Array<OneD, NekDouble>(nTracePts, 0.0);
1292 qFwd[nd][i] = Array<OneD, NekDouble>(nTracePts, 0.0);
1293
1294 fields[i]->GetFwdBwdTracePhys(qfield[nd][i], qFwd[nd][i],
1295 qBwd[nd][i], true, true, false);
1296 TraceMap->GetAssemblyCommDG()->PerformExchange(qFwd[nd][i],
1297 qBwd[nd][i]);
1298 }
1299 }
1300 }
1301
1302 CalcTraceNumericalFlux(nConvectiveFields, nDim, npoints, nTracePts,
1303 PenaltyFactor2, fields, AdvVel, inarray, time,
1304 qfield, Fwd, Bwd, qFwd, qBwd, MuVarTrace,
1305 nonZeroIndex, numflux);
1306
1307 int nFields = nvariables;
1308 Array<OneD, Array<OneD, NekDouble>> plusFwd(nFields), plusBwd(nFields);
1309 Array<OneD, Array<OneD, NekDouble>> Jacvect(nFields);
1310 Array<OneD, Array<OneD, NekDouble>> FwdBnd(nFields);
1311 Array<OneD, Array<OneD, NekDouble>> plusflux(nFields);
1312 for (int i = 0; i < nFields; i++)
1313 {
1314 Jacvect[i] = Array<OneD, NekDouble>(nTracePts, 0.0);
1315 plusFwd[i] = Array<OneD, NekDouble>(nTracePts, 0.0);
1316 plusBwd[i] = Array<OneD, NekDouble>(nTracePts, 0.0);
1317 plusflux[i] = Array<OneD, NekDouble>(nTracePts, 0.0);
1318 FwdBnd[i] = Array<OneD, NekDouble>(nTracePts, 0.0);
1319 }
1320
1321 for (int i = 0; i < nFields; i++)
1322 {
1323 Vmath::Vcopy(nTracePts, Fwd[i], 1, plusFwd[i], 1);
1324 Vmath::Vcopy(nTracePts, Bwd[i], 1, plusBwd[i], 1);
1325 }
1326
1327 NekDouble eps = 1.0E-6;
1328
1329 Array<OneD, DataType> tmpMatData;
1330 // Fwd Jacobian
1331 for (int i = 0; i < nFields; i++)
1332 {
1333 NekDouble epsvar = eps * m_magnitdEstimat[i];
1334 NekDouble oepsvar = 1.0 / epsvar;
1335 Vmath::Sadd(nTracePts, epsvar, Fwd[i], 1, plusFwd[i], 1);
1336
1337 if (m_bndConds.size())
1338 {
1339 for (int i = 0; i < nFields; i++)
1340 {
1341 Vmath::Vcopy(nTracePts, plusFwd[i], 1, FwdBnd[i], 1);
1342 }
1343 // Loop over user-defined boundary conditions
1344 for (auto &x : m_bndConds)
1345 {
1346 x->Apply(FwdBnd, tmpinarry, time);
1347 }
1348 }
1349
1350 for (int j = 0; j < nFields; j++)
1351 {
1352 m_fields[j]->FillBwdWithBoundCond(plusFwd[j], plusBwd[j]);
1353 }
1354
1355 CalcTraceNumericalFlux(nConvectiveFields, nDim, npoints, nTracePts,
1356 PenaltyFactor2, fields, AdvVel, inarray, time,
1357 qfield, plusFwd, plusBwd, qFwd, qBwd, MuVarTrace,
1358 nonZeroIndex, plusflux);
1359
1360 for (int n = 0; n < nFields; n++)
1361 {
1362 Vmath::Vsub(nTracePts, plusflux[n], 1, numflux[n], 1, Jacvect[n],
1363 1);
1364 Vmath::Smul(nTracePts, oepsvar, Jacvect[n], 1, Jacvect[n], 1);
1365 }
1366 for (int j = 0; j < nTracePts; j++)
1367 {
1368 tmpMatData = FJac->GetBlock(j, j)->GetPtr();
1369 for (int n = 0; n < nFields; n++)
1370 {
1371 tmpMatData[n + i * nFields] = DataType(Jacvect[n][j]);
1372 }
1373 }
1374
1375 Vmath::Vcopy(nTracePts, Fwd[i], 1, plusFwd[i], 1);
1376 }
1377
1378 // Reset the boundary conditions
1379 if (m_bndConds.size())
1380 {
1381 for (int i = 0; i < nFields; i++)
1382 {
1383 Vmath::Vcopy(nTracePts, Fwd[i], 1, FwdBnd[i], 1);
1384 }
1385 // Loop over user-defined boundary conditions
1386 for (auto &x : m_bndConds)
1387 {
1388 x->Apply(FwdBnd, tmpinarry, time);
1389 }
1390 }
1391
1392 for (int i = 0; i < nFields; i++)
1393 {
1394 Vmath::Vcopy(nTracePts, Bwd[i], 1, plusBwd[i], 1);
1395 }
1396
1397 for (int i = 0; i < nFields; i++)
1398 {
1399 NekDouble epsvar = eps * m_magnitdEstimat[i];
1400 NekDouble oepsvar = 1.0 / epsvar;
1401
1402 Vmath::Sadd(nTracePts, epsvar, Bwd[i], 1, plusBwd[i], 1);
1403
1404 for (int j = 0; j < nFields; j++)
1405 {
1406 m_fields[j]->FillBwdWithBoundCond(Fwd[j], plusBwd[j]);
1407 }
1408
1409 CalcTraceNumericalFlux(nConvectiveFields, nDim, npoints, nTracePts,
1410 PenaltyFactor2, fields, AdvVel, inarray, time,
1411 qfield, Fwd, plusBwd, qFwd, qBwd, MuVarTrace,
1412 nonZeroIndex, plusflux);
1413
1414 for (int n = 0; n < nFields; n++)
1415 {
1416 Vmath::Vsub(nTracePts, plusflux[n], 1, numflux[n], 1, Jacvect[n],
1417 1);
1418 Vmath::Smul(nTracePts, oepsvar, Jacvect[n], 1, Jacvect[n], 1);
1419 }
1420 for (int j = 0; j < nTracePts; j++)
1421 {
1422 tmpMatData = BJac->GetBlock(j, j)->GetPtr();
1423 for (int n = 0; n < nFields; n++)
1424 {
1425 tmpMatData[n + i * nFields] = DataType(Jacvect[n][j]);
1426 }
1427 }
1428
1429 Vmath::Vcopy(nTracePts, Bwd[i], 1, plusBwd[i], 1);
1430 }
1431}
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)
std::vector< CFSBndCondSharedPtr > m_bndConds
SOLVER_UTILS_EXPORT int GetNpoints()
std::shared_ptr< AssemblyMapDG > AssemblyMapDGSharedPtr
Definition: AssemblyMapDG.h:46
static Array< OneD, NekDouble > NullNekDouble1DArray
void Sadd(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Add vector y = alpha + x.
Definition: Vmath.hpp:194

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 1894 of file CompressibleFlowSystemImplicit.cpp.

1899{
1900 Array<OneD, NekDouble> FJacData = FJac->GetPtr();
1901 const int nvariables3D = 5;
1902
1903 NekDouble ro, vx, vy, vz, ps, gama, ae;
1904 NekDouble a, a2, h, h0, v2, vn, eps, eps2;
1905 NekDouble nx, ny, nz;
1906 NekDouble sn, osn, nxa, nya, nza, vna;
1907 NekDouble l1, l4, l5, al1, al4, al5, x1, x2, x3, y1;
1908 NekDouble c1, d1, c2, d2, c3, d3, c4, d4, c5, d5;
1909 NekDouble sml_ssf = 1.0E-12;
1910
1911 NekDouble fExactorSplt = 2.0 - abs(fsw); // if fsw=+-1 calculate
1912
1913 NekDouble rhoL = Fwd[0];
1914 NekDouble rhouL = Fwd[1];
1915 NekDouble rhovL = Fwd[2];
1916 NekDouble rhowL = Fwd[3];
1917 NekDouble EL = Fwd[4];
1918
1919 ro = rhoL;
1920 vx = rhouL / rhoL;
1921 vy = rhovL / rhoL;
1922 vz = rhowL / rhoL;
1923
1924 // Internal energy (per unit mass)
1925 NekDouble eL = (EL - 0.5 * (rhouL * vx + rhovL * vy + rhowL * vz)) / rhoL;
1926
1927 ps = m_varConv->Geteos()->GetPressure(rhoL, eL);
1928 gama = m_gamma;
1929
1930 ae = gama - 1.0;
1931 v2 = vx * vx + vy * vy + vz * vz;
1932 a2 = gama * ps / ro;
1933 h = a2 / ae;
1934
1935 h0 = h + 0.5 * v2;
1936 a = sqrt(a2);
1937
1938 nx = normals[0];
1939 ny = normals[1];
1940 nz = normals[2];
1941 vn = nx * vx + ny * vy + nz * vz;
1942 sn = std::max(sqrt(nx * nx + ny * ny + nz * nz), sml_ssf);
1943 osn = 1.0 / sn;
1944
1945 nxa = nx * osn;
1946 nya = ny * osn;
1947 nza = nz * osn;
1948 vna = vn * osn;
1949 l1 = vn;
1950 l4 = vn + sn * a;
1951 l5 = vn - sn * a;
1952
1953 eps = efix * sn;
1954 eps2 = eps * eps;
1955
1956 al1 = sqrt(l1 * l1 + eps2);
1957 al4 = sqrt(l4 * l4 + eps2);
1958 al5 = sqrt(l5 * l5 + eps2);
1959
1960 l1 = 0.5 * (fExactorSplt * l1 + fsw * al1);
1961 l4 = 0.5 * (fExactorSplt * l4 + fsw * al4);
1962 l5 = 0.5 * (fExactorSplt * l5 + fsw * al5);
1963
1964 x1 = 0.5 * (l4 + l5);
1965 x2 = 0.5 * (l4 - l5);
1966 x3 = x1 - l1;
1967 y1 = 0.5 * v2;
1968 c1 = ae * x3 / a2;
1969 d1 = x2 / a;
1970
1971 int nVar0 = 0;
1972 int nVar1 = nvariables3D;
1973 int nVar2 = 2 * nvariables3D;
1974 int nVar3 = 3 * nvariables3D;
1975 int nVar4 = 4 * nvariables3D;
1976 FJacData[nVar0] = c1 * y1 - d1 * vna + l1;
1977 FJacData[nVar1] = -c1 * vx + d1 * nxa;
1978 FJacData[nVar2] = -c1 * vy + d1 * nya;
1979 FJacData[nVar3] = -c1 * vz + d1 * nza;
1980 FJacData[nVar4] = c1;
1981 c2 = c1 * vx + d1 * nxa * ae;
1982 d2 = x3 * nxa + d1 * vx;
1983 FJacData[1 + nVar0] = c2 * y1 - d2 * vna;
1984 FJacData[1 + nVar1] = -c2 * vx + d2 * nxa + l1;
1985 FJacData[1 + nVar2] = -c2 * vy + d2 * nya;
1986 FJacData[1 + nVar3] = -c2 * vz + d2 * nza;
1987 FJacData[1 + nVar4] = c2;
1988 c3 = c1 * vy + d1 * nya * ae;
1989 d3 = x3 * nya + d1 * vy;
1990 FJacData[2 + nVar0] = c3 * y1 - d3 * vna;
1991 FJacData[2 + nVar1] = -c3 * vx + d3 * nxa;
1992 FJacData[2 + nVar2] = -c3 * vy + d3 * nya + l1;
1993 FJacData[2 + nVar3] = -c3 * vz + d3 * nza;
1994 FJacData[2 + nVar4] = c3;
1995 c4 = c1 * vz + d1 * nza * ae;
1996 d4 = x3 * nza + d1 * vz;
1997 FJacData[3 + nVar0] = c4 * y1 - d4 * vna;
1998 FJacData[3 + nVar1] = -c4 * vx + d4 * nxa;
1999 FJacData[3 + nVar2] = -c4 * vy + d4 * nya;
2000 FJacData[3 + nVar3] = -c4 * vz + d4 * nza + l1;
2001 FJacData[3 + nVar4] = c4;
2002 c5 = c1 * h0 + d1 * vna * ae;
2003 d5 = x3 * vna + d1 * h0;
2004 FJacData[4 + nVar0] = c5 * y1 - d5 * vna;
2005 FJacData[4 + nVar1] = -c5 * vx + d5 * nxa;
2006 FJacData[4 + nVar2] = -c5 * vy + d5 * nya;
2007 FJacData[4 + nVar3] = -c5 * vz + d5 * nza;
2008 FJacData[4 + nVar4] = c5 + l1;
2009}
VariableConverterSharedPtr m_varConv
scalarT< T > abs(scalarT< T > in)
Definition: scalar.hpp:289

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 554 of file CompressibleFlowSystemImplicit.cpp.

557{
558 LibUtilities::Timer timer, Gtimer;
559
560 Gtimer.Start();
561 if (m_preconCfs->UpdatePreconMatCheck(NullNekDouble1DArray,
563 {
564 int nvariables = m_solutionPhys.size();
565 int nphspnt = m_solutionPhys[nvariables - 1].size();
566 Array<OneD, Array<OneD, NekDouble>> intmp(nvariables);
567 for (int i = 0; i < nvariables; i++)
568 {
569 intmp[i] = Array<OneD, NekDouble>(nphspnt, 0.0);
570 }
571
572 timer.Start();
574 timer.Stop();
575 timer.AccumulateRegion("CompressibleFlowSystem::DoOdeProjection", 1);
576
577 timer.Start();
578 m_preconCfs->BuildPreconCfs(m_fields, intmp, m_bndEvaluateTime,
580 timer.Stop();
581 timer.AccumulateRegion("PreconCfsOp::BuildPreconCfs", 1);
582 }
583
584 timer.Start();
585 m_preconCfs->DoPreconCfs(m_fields, inarray, outarray, flag);
586 timer.Stop();
587 timer.AccumulateRegion("PreconCfsOp::DoPreconCfs", 1);
588
589 Gtimer.Stop();
590 Gtimer.AccumulateRegion("CFSImplicit::PreconCoeff");
591}

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 1823 of file CompressibleFlowSystemImplicit.cpp.

1825{
1826 Array<OneD, unsigned int> rowSizes;
1827 Array<OneD, unsigned int> colSizes;
1828 BlkMat->GetBlockSizes(rowSizes, colSizes);
1829 int nDiagBlks = rowSizes.size();
1830 int nvar0 = rowSizes[1] - rowSizes[0];
1831 int nvar1 = colSizes[1] - colSizes[0];
1832
1833 Array<OneD, DataType> ElmtMatData;
1834
1835 for (int i = 0; i < nDiagBlks; i++)
1836 {
1837 ElmtMatData = BlkMat->GetBlock(i, i)->GetPtr();
1838 for (int n = 0; n < nvar1; n++)
1839 {
1840 int noffset = n * nvar0;
1841 for (int m = 0; m < nvar0; m++)
1842 {
1843 MatArray[m][n][i] = ElmtMatData[m + noffset];
1844 }
1845 }
1846 }
1847}

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 1654 of file CompressibleFlowSystemImplicit.cpp.

1657{
1658 int nFwdBwd, nDiagBlks, nvar0Jac, nvar1Jac;
1659
1660 Array<OneD, unsigned int> rowSizes;
1661 Array<OneD, unsigned int> colSizes;
1662 nFwdBwd = TraceJac.size();
1663 TraceJac[0]->GetBlockSizes(rowSizes, colSizes);
1664 nDiagBlks = rowSizes.size();
1665 nvar0Jac = rowSizes[1] - rowSizes[0];
1666 nvar1Jac = colSizes[1] - colSizes[0];
1667
1668 if (0 == TraceJacArray.size())
1669 {
1670 TraceJacArray = TensorOfArray4D<DataType>(nFwdBwd);
1671 for (int nlr = 0; nlr < nFwdBwd; nlr++)
1672 {
1673 TraceJacArray[nlr] = TensorOfArray3D<DataType>(nvar0Jac);
1674 for (int m = 0; m < nvar0Jac; m++)
1675 {
1676 TraceJacArray[nlr][m] =
1677 Array<OneD, Array<OneD, DataType>>(nvar1Jac);
1678 for (int n = 0; n < nvar1Jac; n++)
1679 {
1680 TraceJacArray[nlr][m][n] = Array<OneD, DataType>(nDiagBlks);
1681 }
1682 }
1683 }
1684 }
1685
1686 for (int nlr = 0; nlr < nFwdBwd; nlr++)
1687 {
1688 const TypeNekBlkMatSharedPtr tmpMat = TraceJac[nlr];
1689 TensorOfArray3D<DataType> tmpaa = TraceJacArray[nlr];
1690 TranSamesizeBlkDiagMatIntoArray(tmpMat, tmpaa);
1691 }
1692
1693 return;
1694}
void TranSamesizeBlkDiagMatIntoArray(const TypeNekBlkMatSharedPtr &BlkMat, TensorOfArray3D< DataType > &MatArray)

References TranSamesizeBlkDiagMatIntoArray().

Referenced by CalcPreconMatBRJCoeff().

◆ v_ALEInitObject()

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

Reimplemented from Nektar::CompressibleFlowSystem.

Definition at line 2020 of file CompressibleFlowSystemImplicit.cpp.

2022{
2023 m_ImplicitALESolver = true;
2024 fields[0]->GetGraph()->GetMovement()->SetImplicitALEFlag(
2026 m_spaceDim = spaceDim;
2027 m_fieldsALE = fields;
2028
2029 // Initialise grid velocities as 0s
2030 m_gridVelocity = Array<OneD, Array<OneD, NekDouble>>(m_spaceDim);
2031 m_gridVelocityTrace = Array<OneD, Array<OneD, NekDouble>>(m_spaceDim);
2032 for (int i = 0; i < spaceDim; ++i)
2033 {
2034 m_gridVelocity[i] =
2035 Array<OneD, NekDouble>(fields[0]->GetTotPoints(), 0.0);
2037 Array<OneD, NekDouble>(fields[0]->GetTrace()->GetTotPoints(), 0.0);
2038 }
2039 ALEHelper::InitObject(spaceDim, fields);
2040}
Array< OneD, MultiRegions::ExpListSharedPtr > m_fieldsALE
Definition: ALEHelper.h:88
SOLVER_UTILS_EXPORT void InitObject(int spaceDim, Array< OneD, MultiRegions::ExpListSharedPtr > &fields)
Definition: ALEHelper.cpp:48
Array< OneD, Array< OneD, NekDouble > > m_gridVelocityTrace
Definition: ALEHelper.h:90
Array< OneD, Array< OneD, NekDouble > > m_gridVelocity
Definition: ALEHelper.h:89

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

360 {
361 }

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.

367 {
368 }

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.

352 {
353 }

Referenced by DoDiffusionCoeff().

◆ v_DoSolve()

void Nektar::CFSImplicit::v_DoSolve ( void  )
overrideprotectedvirtual

Solves an unsteady problem.

Initialises the time integration scheme (as specified in the session file), and perform the time integration.

Reimplemented from Nektar::SolverUtils::UnsteadySystem.

Definition at line 157 of file CompressibleFlowSystemImplicit.cpp.

158{
159 m_TotNewtonIts = 0;
160 m_TotLinIts = 0;
161 m_TotImpStages = 0;
163}
SOLVER_UTILS_EXPORT void v_DoSolve() override
Solves an unsteady problem.

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

◆ 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 1696 of file CompressibleFlowSystemImplicit.cpp.

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

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

Referenced by 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 1707 of file CompressibleFlowSystemImplicit.cpp.

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

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

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

Definition at line 52 of file CompressibleFlowSystemImplicit.cpp.

53{
55 m_explicitAdvection = false;
56 m_explicitDiffusion = false;
57
58 // Initialise implicit parameters
59 m_session->MatchSolverInfo("FLAGIMPLICITITSSTATISTICS", "True",
61
62 m_session->LoadParameter("JacobiFreeEps", m_jacobiFreeEps,
64
65 m_session->LoadParameter("nPadding", m_nPadding, 4);
66
67 int ntmp;
68 m_session->LoadParameter("AdvectionJacFlag", ntmp, 1);
69 m_advectionJacFlag = (ntmp != 0);
70
71 m_session->LoadParameter("ViscousJacFlag", ntmp, 1);
72 m_viscousJacFlag = (ntmp != 0);
73
74 // Initialise implicit functors
77
79}
void DoOdeImplicitRhs(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
void DoImplicitSolve(const Array< OneD, const Array< OneD, NekDouble > > &inpnts, Array< OneD, Array< OneD, NekDouble > > &outpnt, const NekDouble time, const NekDouble lambda)
void v_InitObject(bool DeclareFields=true) override
Initialization object for CompressibleFlowSystem class.
void DefineOdeRhs(FuncPointerT func, ObjectPointerT obj)
void DefineImplicitSolve(FuncPointerT func, ObjectPointerT obj)
LibUtilities::TimeIntegrationSchemeOperators m_ode
The time integration scheme operators to use.
bool m_explicitAdvection
Indicates if explicit or implicit treatment of advection is used.
bool m_explicitDiffusion
Indicates if explicit or implicit treatment of diffusion is used.
static const NekDouble kNekMachineEpsilon

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 1551 of file CompressibleFlowSystemImplicit.cpp.

1561{
1562 // Do nothing by default
1563}

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.

167{
169
170 if (m_infosteps && m_session->GetComm()->GetSpaceComm()->GetRank() == 0 &&
171 !((step + 1) % m_infosteps) && m_flagImplicitItsStatistics)
172 {
173 std::cout << " &&"
174 << " TotImpStages= " << m_TotImpStages
175 << " TotNewtonIts= " << m_TotNewtonIts
176 << " TotLinearIts = " << m_TotLinIts << std::endl;
177 }
178}
int m_infosteps
Number of time steps between outputting status information.
virtual SOLVER_UTILS_EXPORT void v_PrintStatusInformation(const int step, const NekDouble cpuTime)
Print Status Information.

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.

181{
183
184 if (m_session->GetComm()->GetRank() == 0 && m_flagImplicitItsStatistics)
185 {
186 std::cout << "-------------------------------------------" << std::endl
187 << "Total Implicit Stages: " << m_TotImpStages << std::endl
188 << "Total Newton Its : " << m_TotNewtonIts << std::endl
189 << "Total Linear Its : " << m_TotLinIts << std::endl
190 << "-------------------------------------------" << std::endl;
191 }
192}
virtual SOLVER_UTILS_EXPORT void v_PrintSummaryStatistics(const NekDouble intTime)
Print Summary Statistics.

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

Member Data Documentation

◆ m_advectionJacFlag

bool Nektar::CFSImplicit::m_advectionJacFlag
protected

◆ m_flagImplicitItsStatistics

bool Nektar::CFSImplicit::m_flagImplicitItsStatistics
protected

◆ m_inArrayNorm

NekDouble Nektar::CFSImplicit::m_inArrayNorm = -1.0
protected

◆ 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

◆ m_nPadding

int Nektar::CFSImplicit::m_nPadding = 1
protected

◆ m_preconCfs

PreconCfsSharedPtr Nektar::CFSImplicit::m_preconCfs
protected

◆ 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

◆ m_TotLinIts

int Nektar::CFSImplicit::m_TotLinIts = 0
protected

◆ m_TotNewtonIts

int Nektar::CFSImplicit::m_TotNewtonIts = 0
protected

◆ m_updateShockCaptPhys

bool Nektar::CFSImplicit::m_updateShockCaptPhys {true}
protected

◆ m_viscousJacFlag

bool Nektar::CFSImplicit::m_viscousJacFlag
protected