#include <CompressibleFlowSystemImplicit.h>
Inheritance diagram for Nektar::CFSImplicit:
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 | NonlinSysEvaluatorCoeff1D (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out, const bool &flag=true) |
| void | NonlinSysEvaluatorCoeff (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &out) |
| 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 &flag=false) |
| 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) | |
| 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 | 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, NekDouble > | v_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 bool | v_PostIntegrate (int step) override |
| virtual SOLVER_UTILS_EXPORT Array< OneD, NekDouble > | v_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 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) |
| virtual SOLVER_UTILS_EXPORT void | v_GetMovingFrameVelocities (Array< OneD, NekDouble > &vFrameVels) |
| virtual SOLVER_UTILS_EXPORT void | v_SetMovingFrameProjectionMat (const boost::numeric::ublas::matrix< NekDouble > &vProjMat) |
| virtual SOLVER_UTILS_EXPORT void | v_GetMovingFrameProjectionMat (boost::numeric::ublas::matrix< NekDouble > &vProjMat) |
| virtual SOLVER_UTILS_EXPORT void | v_SetMovingFrameDisp (const Array< OneD, NekDouble > &vFrameDisp) |
| virtual SOLVER_UTILS_EXPORT void | v_GetMovingFrameDisp (Array< OneD, NekDouble > &vFrameDisp) |
| virtual SOLVER_UTILS_EXPORT void | v_SetAeroForce (Array< OneD, NekDouble > forces) |
| virtual SOLVER_UTILS_EXPORT void | v_GetAeroForce (Array< OneD, NekDouble > forces) |
Protected Attributes | |
| bool | m_viscousJacFlag |
| bool | m_advectionJacFlag |
| bool | m_flagImplicitItsStatistics |
| int | m_nPadding = 1 |
| int | m_TotNewtonIts = 0 |
| int | m_TotLinIts = 0 |
| int | m_TotImpStages = 0 |
| Array< OneD, NekDouble > | m_magnitdEstimat |
| Estimate the magnitude of each conserved varibles. 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 |
| NekDouble | m_newtonRelativeIteTol |
| TensorOfArray4D< NekSingle > | m_stdSMatDataDBB |
| TensorOfArray5D< NekSingle > | m_stdSMatDataDBDB |
| LibUtilities::NekNonlinSysSharedPtr | m_nonlinsol |
| PreconCfsSharedPtr | m_preconCfs |
| bool | m_updateShockCaptPhys {true} |
| Protected Attributes inherited from Nektar::CompressibleFlowSystem | |
| SolverUtils::DiffusionSharedPtr | m_diffusion |
| ArtificialDiffusionSharedPtr | m_artificialDiffusion |
| Array< OneD, Array< OneD, NekDouble > > | m_vecLocs |
| NekDouble | m_gamma |
| std::string | m_shockCaptureType |
| NekDouble | m_filterAlpha |
| NekDouble | m_filterExponent |
| NekDouble | m_filterCutoff |
| bool | m_useFiltering |
| bool | m_useLocalTimeStep |
| Array< OneD, NekDouble > | m_muav |
| Array< OneD, NekDouble > | m_muavTrace |
| VariableConverterSharedPtr | m_varConv |
| std::vector< CFSBndCondSharedPtr > | m_bndConds |
| NekDouble | m_bndEvaluateTime |
| std::vector< SolverUtils::ForcingSharedPtr > | m_forcing |
| Protected Attributes inherited from Nektar::SolverUtils::AdvectionSystem | |
| SolverUtils::AdvectionSharedPtr | m_advObject |
| Advection term. 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::SessionFunctionSharedPtr > | m_sessionFunctions |
| Map of known SessionFunctions. More... | |
| LibUtilities::FieldIOSharedPtr | m_fld |
| Field input/output. More... | |
| Array< OneD, MultiRegions::ExpListSharedPtr > | m_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, NekDouble > | m_movingFrameVelsxyz |
| Moving frame of reference velocities (u, v, w, omega_x, omega_y, omega_z, a_x, a_y, a_z, domega_x, domega_y, domega_z) More... | |
| Array< OneD, NekDouble > | m_movingFrameData |
| Moving frame of reference angles with respect to the. More... | |
| boost::numeric::ublas::matrix< NekDouble > | m_movingFrameProjMat |
| Projection matrix for transformation between inertial and moving. 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... | |
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 46 of file CompressibleFlowSystemImplicit.h.
Constructor & Destructor Documentation
◆ CFSImplicit()
| Nektar::CFSImplicit::CFSImplicit | ( | const LibUtilities::SessionReaderSharedPtr & | pSession, |
| const SpatialDomains::MeshGraphSharedPtr & | pGraph | ||
| ) |
Definition at line 44 of file CompressibleFlowSystemImplicit.cpp.
47{
48}
CompressibleFlowSystem(const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
Definition: CompressibleFlowSystem.cpp:43
SOLVER_UTILS_EXPORT UnsteadySystem(const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
Initialises UnsteadySystem class members.
Definition: UnsteadySystem.cpp:74
◆ ~CFSImplicit()
|
overridedefault |
Member Function Documentation
◆ AddMatNSBlkDiagBnd()
template<typename DataType , typename TypeNekBlkMatSharedPtr >
|
protected |
Definition at line 1050 of file CompressibleFlowSystemImplicit.cpp.
1058{
1059 int nvariables = inarray.size();
1060
1061 LibUtilities::Timer timer;
1062 timer.Start();
1063 GetTraceJac(inarray, qfield, TraceJac, TraceJacDeriv, TraceJacDerivSign,
1064 TraceIPSymJacArray);
1065 timer.Stop();
1066 timer.AccumulateRegion("CFSImplicit::GetTraceJac", 10);
1067
1068 Array<OneD, TypeNekBlkMatSharedPtr> tmpJac;
1069 Array<OneD, Array<OneD, DataType>> tmpSign;
1070
1071 timer.Start();
1073 gmtxarray, tmpJac, tmpSign);
1074 timer.Stop();
1075 timer.AccumulateRegion("Advection::AddTraceJacToMap", 10);
1076}
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)
Definition: CompressibleFlowSystemImplicit.cpp:1169
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
Definition: EquationSystem.h:359
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 >
|
protected |
Definition at line 578 of file CompressibleFlowSystemImplicit.cpp.
584{
585 if (StdMatDataDBB.size() == 0)
586 {
587 CalcVolJacStdMat(StdMatDataDBB, StdMatDataDBDB);
588 }
589
591 int nvariable = inarray.size();
593 int nVar2 = nvariable * nvariable;
594 std::shared_ptr<LocalRegions::ExpansionVector> expvect =
595 m_fields[0]->GetExp();
596 int nTotElmt = (*expvect).size();
597
598 Array<OneD, NekDouble> mu(npoints, 0.0);
599 Array<OneD, NekDouble> DmuDT(npoints, 0.0);
601 {
602 CalcMuDmuDT(inarray, mu, DmuDT);
603 }
604
605 Array<OneD, NekDouble> normals;
606 Array<OneD, Array<OneD, NekDouble>> normal3D(3);
607 for (int i = 0; i < 3; i++)
608 {
609 normal3D[i] = Array<OneD, NekDouble>(3, 0.0);
610 }
611 normal3D[0][0] = 1.0;
612 normal3D[1][1] = 1.0;
613 normal3D[2][2] = 1.0;
614 Array<OneD, Array<OneD, NekDouble>> normalPnt(3);
615
616 DNekMatSharedPtr wspMat =
617 MemoryManager<DNekMat>::AllocateSharedPtr(nvariable, nvariable, 0.0);
619 nvariable - 1, nvariable, 0.0);
620
621 Array<OneD, DataType> GmatxData;
622 Array<OneD, DataType> MatData;
623
624 Array<OneD, NekDouble> tmppnts;
625 TensorOfArray3D<NekDouble> PntJacCons(
627 TensorOfArray3D<DataType> PntJacConsStd(
629 Array<OneD, Array<OneD, NekDouble>> ConsStdd(m_spacedim);
630 Array<OneD, Array<OneD, NekDouble>> ConsCurv(m_spacedim);
631 TensorOfArray4D<NekDouble> PntJacDerv(
633 TensorOfArray4D<DataType> PntJacDervStd(
635 TensorOfArray3D<NekDouble> DervStdd(
637 TensorOfArray3D<NekDouble> DervCurv(
640 {
641 PntJacDerv[ndir] = TensorOfArray3D<NekDouble>(m_spacedim);
642 PntJacDervStd[ndir] = TensorOfArray3D<DataType>(m_spacedim);
643 DervStdd[ndir] = Array<OneD, Array<OneD, NekDouble>>(m_spacedim);
644 DervCurv[ndir] = Array<OneD, Array<OneD, NekDouble>>(m_spacedim);
645 }
646
647 Array<OneD, NekDouble> locmu;
648 Array<OneD, NekDouble> locDmuDT;
649 Array<OneD, Array<OneD, NekDouble>> locVars(nvariable);
650 TensorOfArray3D<NekDouble> locDerv(m_spacedim);
652 {
653 locDerv[ndir] = Array<OneD, Array<OneD, NekDouble>>(nvariable);
654 }
655
656 int nElmtCoefOld = -1;
657 for (int ne = 0; ne < nTotElmt; ne++)
658 {
659 int nElmtCoef = (*expvect)[ne]->GetNcoeffs();
660 int nElmtCoef2 = nElmtCoef * nElmtCoef;
661 int nElmtPnt = (*expvect)[ne]->GetTotPoints();
662
665 int nQuotPlus = nQuot;
666 if (nRemd > 0)
667 {
668 nQuotPlus++;
669 }
671
672 if (nElmtPnt > PntJacCons[0].size() || nElmtCoef > nElmtCoefOld)
673 {
674 nElmtCoefOld = nElmtCoef;
675 for (int ndir = 0; ndir < 3; ndir++)
676 {
677 normalPnt[ndir] = Array<OneD, NekDouble>(npoints, 0.0);
678 }
679 tmppnts = Array<OneD, NekDouble>(nElmtPnt);
680 MatData = Array<OneD, DataType>(nElmtCoef2Paded * nVar2);
682 {
683 ConsCurv[ndir] = Array<OneD, NekDouble>(nElmtPnt);
684 ConsStdd[ndir] = Array<OneD, NekDouble>(nElmtPnt);
685 PntJacCons[ndir] =
686 Array<OneD, Array<OneD, NekDouble>>(nElmtPnt);
687 PntJacConsStd[ndir] =
688 Array<OneD, Array<OneD, DataType>>(nElmtPnt);
689 for (int i = 0; i < nElmtPnt; i++)
690 {
691 PntJacCons[ndir][i] = Array<OneD, NekDouble>(nVar2);
692 PntJacConsStd[ndir][i] = Array<OneD, DataType>(nVar2);
693 }
694
696 {
697 PntJacDerv[ndir][ndir1] =
698 Array<OneD, Array<OneD, NekDouble>>(nElmtPnt);
699 PntJacDervStd[ndir][ndir1] =
700 Array<OneD, Array<OneD, DataType>>(nElmtPnt);
701 DervStdd[ndir][ndir1] = Array<OneD, NekDouble>(nElmtPnt);
702 DervCurv[ndir][ndir1] = Array<OneD, NekDouble>(nElmtPnt);
703 for (int i = 0; i < nElmtPnt; i++)
704 {
705 PntJacDerv[ndir][ndir1][i] =
706 Array<OneD, NekDouble>(nVar2);
707 PntJacDervStd[ndir][ndir1][i] =
708 Array<OneD, DataType>(nVar2);
709 }
710 }
711 }
712 }
713
715 for (int j = 0; j < nvariable; j++)
716 {
717 locVars[j] = inarray[j] + noffset;
718 }
719
721 {
722 for (int nFluxDir = 0; nFluxDir < nSpaceDim; nFluxDir++)
723 {
724 normals = normal3D[nFluxDir];
725 GetFluxVectorJacDirElmt(nvariable, nElmtPnt, locVars, normals,
726 wspMat, PntJacCons[nFluxDir]);
727 }
728 }
729
731 {
732 for (int j = 0; j < nSpaceDim; j++)
733 {
734 for (int k = 0; k < nvariable; k++)
735 {
736 locDerv[j][k] = qfield[j][k] + noffset;
737 }
738 }
739 locmu = mu + noffset;
740 locDmuDT = DmuDT + noffset;
741 for (int nFluxDir = 0; nFluxDir < nSpaceDim; nFluxDir++)
742 {
743 normals = normal3D[nFluxDir];
744 MinusDiffusionFluxJacPoint(nvariable, nElmtPnt, locVars,
745 locDerv, locmu, locDmuDT, normals,
746 wspMatDrv, PntJacCons[nFluxDir]);
747 }
748 }
749
751 {
752 locmu = mu + noffset;
753 for (int nFluxDir = 0; nFluxDir < nSpaceDim; nFluxDir++)
754 {
755 Vmath::Fill(npoints, 1.0, normalPnt[nFluxDir], 1);
756 for (int nDervDir = 0; nDervDir < nSpaceDim; nDervDir++)
757 {
759 nvariable, nElmtPnt, nDervDir, locVars, locmu,
760 normalPnt, wspMatDrv, PntJacDerv[nFluxDir][nDervDir]);
761 }
762 Vmath::Fill(npoints, 0.0, normalPnt[nFluxDir], 1);
763 }
764 }
765
766 for (int n = 0; n < nvariable; n++)
767 {
768 for (int m = 0; m < nvariable; m++)
769 {
770 int nVarOffset = m + n * nvariable;
771 GmatxData = gmtxarray[m][n]->GetBlock(ne, ne)->GetPtr();
772
774 {
775 Vmath::Zero(nElmtPnt, ConsStdd[ndStd0], 1);
776 }
778 {
779 for (int i = 0; i < nElmtPnt; i++)
780 {
781 tmppnts[i] = PntJacCons[ndir][i][nVarOffset];
782 }
783 (*expvect)[ne]->AlignVectorToCollapsedDir(ndir, tmppnts,
784 ConsCurv);
786 {
787 Vmath::Vadd(nElmtPnt, ConsCurv[nd], 1, ConsStdd[nd], 1,
788 ConsStdd[nd], 1);
789 }
790 }
791
793 {
794 (*expvect)[ne]->MultiplyByQuadratureMetric(
795 ConsStdd[ndir], ConsStdd[ndir]); // weight with metric
796 for (int i = 0; i < nElmtPnt; i++)
797 {
798 PntJacConsStd[ndir][i][nVarOffset] =
799 DataType(ConsStdd[ndir][i]);
800 }
801 }
802 }
803 }
804
806 {
807 for (int m = 0; m < nvariable; m++)
808 {
809 for (int n = 0; n < nvariable; n++)
810 {
811 int nVarOffset = m + n * nvariable;
813 {
815 {
816 Vmath::Zero(nElmtPnt, DervStdd[ndStd0][ndStd1], 1);
817 }
818 }
820 {
822 {
823 for (int i = 0; i < nElmtPnt; i++)
824 {
825 tmppnts[i] =
826 PntJacDerv[nd0][nd1][i][nVarOffset];
827 }
828
829 (*expvect)[ne]->AlignVectorToCollapsedDir(
830 nd0, tmppnts, ConsCurv);
832 {
833 (*expvect)[ne]->AlignVectorToCollapsedDir(
834 nd1, ConsCurv[nd], DervCurv[nd]);
835 }
836
838 {
840 ndStd1++)
841 {
842 Vmath::Vadd(nElmtPnt,
843 DervCurv[ndStd0][ndStd1], 1,
844 DervStdd[ndStd0][ndStd1], 1,
845 DervStdd[ndStd0][ndStd1], 1);
846 }
847 }
848 }
849 }
851 {
853 {
854 (*expvect)[ne]->MultiplyByQuadratureMetric(
855 DervStdd[nd0][nd1],
856 DervStdd[nd0][nd1]); // weight with metric
857 for (int i = 0; i < nElmtPnt; i++)
858 {
859 PntJacDervStd[nd0][nd1][i][nVarOffset] =
860 -DataType(DervStdd[nd0][nd1][i]);
861 }
862 }
863 }
864 }
865 }
866 }
867
868 Vmath::Zero(nElmtCoef2Paded * nVar2, MatData, 1);
869 DataType one = 1.0;
871 {
872 for (int i = 0; i < nElmtPnt; i++)
873 {
874 Blas::Ger(nElmtCoef2Paded, nVar2, one,
875 &StdMatDataDBB[ne][ndir][i][0], 1,
876 &PntJacConsStd[ndir][i][0], 1, &MatData[0],
877 nElmtCoef2Paded);
878 }
879 }
880
882 {
884 {
886 {
887 for (int i = 0; i < nElmtPnt; i++)
888 {
889 Blas::Ger(nElmtCoef2Paded, nVar2, one,
890 &StdMatDataDBDB[ne][nd0][nd1][i][0], 1,
891 &PntJacDervStd[nd0][nd1][i][0], 1,
892 &MatData[0], nElmtCoef2Paded);
893 }
894 }
895 }
896 }
897
898 Array<OneD, DataType> tmpA;
899
900 for (int n = 0; n < nvariable; n++)
901 {
902 for (int m = 0; m < nvariable; m++)
903 {
904 int nVarOffset = m + n * nvariable;
905 GmatxData = gmtxarray[m][n]->GetBlock(ne, ne)->GetPtr();
906 Vmath::Vcopy(nElmtCoef2,
907 tmpA = MatData + nVarOffset * nElmtCoef2Paded, 1,
908 GmatxData, 1);
909 }
910 }
911 }
912}
void CalcVolJacStdMat(TensorOfArray4D< DataType > &StdMatDataDBB, TensorOfArray5D< DataType > &StdMatDataDBDB)
Definition: CompressibleFlowSystemImplicit.cpp:915
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)
Definition: CompressibleFlowSystemImplicit.h:304
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)
Definition: CompressibleFlowSystemImplicit.cpp:1712
bool m_viscousJacFlag
Definition: CompressibleFlowSystemImplicit.h:56
bool m_advectionJacFlag
Definition: CompressibleFlowSystemImplicit.h:57
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)
Definition: CompressibleFlowSystemImplicit.h:279
void CalcMuDmuDT(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, NekDouble > &mu, Array< OneD, NekDouble > &DmuDT)
Definition: CompressibleFlowSystemImplicit.h:333
static std::shared_ptr< DataType > AllocateSharedPtr(const Args &...args)
Allocate a shared pointer from the memory pool.
Definition: NekMemoryManager.hpp:166
SpatialDomains::MeshGraphSharedPtr m_graph
Pointer to graph defining mesh.
Definition: EquationSystem.h:363
SOLVER_UTILS_EXPORT int GetPhys_Offset(int n)
Definition: EquationSystem.h:754
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
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 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()
|
inlineprotected |
Definition at line 220 of file CompressibleFlowSystemImplicit.h.
223 {
224 mat =
226 SNekMatSharedPtr loc_matNvar;
227 for (int nelm = 0; nelm < nrow.size(); ++nelm)
228 {
229 int nrowsVars = nrow[nelm];
230 int ncolsVars = ncol[nelm];
231
232 loc_matNvar = MemoryManager<SNekMat>::AllocateSharedPtr(
233 nrowsVars, ncolsVars, 0.0);
234 mat->SetBlock(nelm, nelm, loc_matNvar);
235 }
236 }
References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), and Nektar::eDIAGONAL.
Referenced by ElmtVarInvMtrx(), and GetTraceJac().
◆ CalcMuDmuDT()
|
inlineprotected |
Definition at line 333 of file CompressibleFlowSystemImplicit.h.
335 {
336 v_CalcMuDmuDT(inarray, mu, DmuDT);
337 }
virtual void v_CalcMuDmuDT(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, NekDouble > &mu, Array< OneD, NekDouble > &DmuDT)
Definition: CompressibleFlowSystemImplicit.h:348
References v_CalcMuDmuDT().
Referenced by AddMatNSBlkDiagVol().
◆ CalcPhysDeriv()
|
inlineprotected |
Definition at line 327 of file CompressibleFlowSystemImplicit.h.
329 {
330 v_CalcPhysDeriv(inarray, qfield);
331 }
virtual void v_CalcPhysDeriv(const Array< OneD, const Array< OneD, NekDouble > > &inarray, TensorOfArray3D< NekDouble > &qfield)
Definition: CompressibleFlowSystemImplicit.h:356
References v_CalcPhysDeriv().
Referenced by CalcPreconMatBRJCoeff().
◆ CalcPreconMatBRJCoeff()
|
protected |
Definition at line 1492 of file CompressibleFlowSystemImplicit.cpp.
1501{
1502 TensorOfArray3D<NekDouble> qfield;
1503
1505 {
1506 CalcPhysDeriv(inarray, qfield);
1507 }
1508
1509 NekSingle zero = 0.0;
1510 Fill2DArrayOfBlkDiagonalMat(gmtxarray, zero);
1511
1512 LibUtilities::Timer timer;
1513 timer.Start();
1515 m_stdSMatDataDBDB);
1516 timer.Stop();
1517 timer.AccumulateRegion("CFSImplicit::AddMatNSBlkDiagVol", 2);
1518
1519 timer.Start();
1520 AddMatNSBlkDiagBnd(inarray, qfield, gmtxarray, TraceJac, TraceJacDeriv,
1521 TraceJacDerivSign, TraceIPSymJacArray);
1522 timer.Stop();
1523 timer.AccumulateRegion("CFSImplicit::AddMatNSBlkDiagBnd", 2);
1524
1525 MultiplyElmtInvMassPlusSource<NekSingle>(gmtxarray, m_TimeIntegLambda);
1526
1527 timer.Start();
1528 ElmtVarInvMtrx(gmtxarray, gmtVar, zero);
1529 timer.Stop();
1530 timer.AccumulateRegion("CFSImplicit::ElmtVarInvMtrx", 2);
1531
1532 TransTraceJacMatToArray(TraceJac, TraceJacArray);
1533}
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)
Definition: CompressibleFlowSystemImplicit.cpp:578
void ElmtVarInvMtrx(Array< OneD, Array< OneD, TypeNekBlkMatSharedPtr > > &gmtxarray, TypeNekBlkMatSharedPtr &gmtVar, const DataType &tmpDatatype)
Definition: CompressibleFlowSystemImplicit.cpp:1079
void TransTraceJacMatToArray(const Array< OneD, TypeNekBlkMatSharedPtr > &TraceJac, TensorOfArray4D< DataType > &TraceJacDerivArray)
Definition: CompressibleFlowSystemImplicit.cpp:1638
void CalcPhysDeriv(const Array< OneD, const Array< OneD, NekDouble > > &inarray, TensorOfArray3D< NekDouble > &qfield)
Definition: CompressibleFlowSystemImplicit.h:327
TensorOfArray4D< NekSingle > m_stdSMatDataDBB
Definition: CompressibleFlowSystemImplicit.h:79
TensorOfArray5D< NekSingle > m_stdSMatDataDBDB
Definition: CompressibleFlowSystemImplicit.h:80
NekDouble m_TimeIntegLambda
coefff of spacial derivatives(rhs or m_F in GLM) in calculating the residual of the whole equation(us...
Definition: CompressibleFlowSystemImplicit.h:74
void Fill2DArrayOfBlkDiagonalMat(Array< OneD, Array< OneD, TypeNekBlkMatSharedPtr > > &gmtxarray, const DataType valu)
Definition: CompressibleFlowSystemImplicit.cpp:1834
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)
Definition: CompressibleFlowSystemImplicit.cpp:1050
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()
Definition at line 461 of file CompressibleFlowSystemImplicit.cpp.
462{
464 unsigned int ntotal = inarray.size();
465 unsigned int npoints = ntotal / nvariables;
466
467 unsigned int nTotalGlobal = ntotal;
468 m_comm->GetSpaceComm()->AllReduce(nTotalGlobal,
470 unsigned int nTotalDOF = nTotalGlobal / nvariables;
471 NekDouble invTotalDOF = 1.0 / nTotalDOF;
472
473 m_inArrayNorm = 0.0;
474 m_magnitdEstimat = Array<OneD, NekDouble>(nvariables, 0.0);
475
476 for (int i = 0; i < nvariables; ++i)
477 {
478 int offset = i * npoints;
479 m_magnitdEstimat[i] =
480 Vmath::Dot(npoints, inarray + offset, inarray + offset);
481 }
484
485 for (int i = 0; i < nvariables; ++i)
486 {
488 }
489
490 for (int i = 2; i < nvariables - 1; ++i)
491 {
493 }
494
495 for (int i = 2; i < nvariables - 1; ++i)
496 {
498 }
499
500 for (int i = 0; i < nvariables; ++i)
501 {
503 }
505 {
506 for (int i = 0; i < nvariables; ++i)
507 {
509 << endl;
510 }
512 }
513}
Array< OneD, NekDouble > m_magnitdEstimat
Estimate the magnitude of each conserved varibles.
Definition: CompressibleFlowSystemImplicit.h:68
NekDouble m_inArrayNorm
Definition: CompressibleFlowSystemImplicit.h:75
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()
|
protected |
Definition at line 1417 of file CompressibleFlowSystemImplicit.cpp.
1432{
1434 {
1435 auto advWeakDGObject =
1436 std::dynamic_pointer_cast<SolverUtils::AdvectionWeakDG>(
1437 m_advObject);
1438 ASSERTL0(advWeakDGObject,
1439 "Use WeakDG for implicit compressible flow solver!");
1440 advWeakDGObject->AdvectTraceFlux(nConvectiveFields, m_fields, AdvVel,
1441 inarray, traceflux, m_bndEvaluateTime,
1442 vFwd, vBwd);
1443 }
1444 else
1445 {
1446 for (int i = 0; i < nConvectiveFields; i++)
1447 {
1448 traceflux[i] = Array<OneD, NekDouble>(nTracePts, 0.0);
1449 }
1450 }
1451
1453 {
1454 Array<OneD, Array<OneD, NekDouble>> visflux(nConvectiveFields);
1455 for (int i = 0; i < nConvectiveFields; i++)
1456 {
1457 visflux[i] = Array<OneD, NekDouble>(nTracePts, 0.0);
1458 }
1459
1460 string diffName;
1462 if (diffName == "InteriorPenalty")
1463 {
1464 m_diffusion->DiffuseTraceFlux(fields, inarray, qfield,
1465 NullNekDoubleTensorOfArray3D, visflux,
1466 vFwd, vBwd, nonZeroIndex);
1467 }
1468 else
1469 {
1471 "flow solver");
1472 // For LDGNS, the array size should be nConvectiveFields - 1
1473 Array<OneD, Array<OneD, NekDouble>> inBwd(nConvectiveFields - 1);
1474 Array<OneD, Array<OneD, NekDouble>> inFwd(nConvectiveFields - 1);
1475 for (int i = 0; i < nConvectiveFields - 1; ++i)
1476 {
1477 inBwd[i] = vBwd[i];
1478 inFwd[i] = vFwd[i];
1479 }
1480 m_diffusion->DiffuseTraceFlux(fields, inarray, qfield,
1481 NullNekDoubleTensorOfArray3D, visflux,
1482 inFwd, inBwd, nonZeroIndex);
1483 }
1484 for (int i = 0; i < nConvectiveFields; i++)
1485 {
1486 Vmath::Vsub(nTracePts, traceflux[i], 1, visflux[i], 1, traceflux[i],
1487 1);
1488 }
1489 }
1490}
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode....
Definition: ErrorUtil.hpp:242
NekDouble m_bndEvaluateTime
Definition: CompressibleFlowSystem.h:103
SolverUtils::DiffusionSharedPtr m_diffusion
Definition: CompressibleFlowSystem.h:76
static Array< OneD, Array< OneD, Array< OneD, NekDouble > > > NullNekDoubleTensorOfArray3D
Definition: SharedArray.hpp:891
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 >
|
protected |
Definition at line 915 of file CompressibleFlowSystemImplicit.cpp.
917{
918 std::shared_ptr<LocalRegions::ExpansionVector> expvect =
919 m_fields[0]->GetExp();
920 int nTotElmt = (*expvect).size();
921
922 StdMatDataDBB = TensorOfArray4D<DataType>(nTotElmt);
923 StdMatDataDBDB = TensorOfArray5D<DataType>(nTotElmt);
924
925 vector<DNekMatSharedPtr> VectStdDerivBase0;
926 vector<TensorOfArray3D<DataType>> VectStdDerivBase_Base;
927 vector<TensorOfArray4D<DataType>> VectStdDervBase_DervBase;
928 DNekMatSharedPtr MatStdDerivBase0;
929 Array<OneD, DNekMatSharedPtr> ArrayStdMat(m_spacedim);
930 Array<OneD, Array<OneD, NekDouble>> ArrayStdMatData(m_spacedim);
931 for (int ne = 0; ne < nTotElmt; ne++)
932 {
933 StdRegions::StdExpansionSharedPtr stdExp;
934 stdExp = (*expvect)[ne]->GetStdExp();
935 StdRegions::StdMatrixKey matkey(StdRegions::eDerivBase0,
936 stdExp->DetShapeType(), *stdExp);
937 MatStdDerivBase0 = stdExp->GetStdMatrix(matkey);
938
939 int nTotStdExp = VectStdDerivBase0.size();
940 int nFoundStdExp = -1;
941 for (int i = 0; i < nTotStdExp; i++)
942 {
943 if ((*VectStdDerivBase0[i]) == (*MatStdDerivBase0))
944 {
945 nFoundStdExp = i;
946 }
947 }
948 if (nFoundStdExp >= 0)
949 {
950 StdMatDataDBB[ne] = VectStdDerivBase_Base[nFoundStdExp];
951 StdMatDataDBDB[ne] = VectStdDervBase_DervBase[nFoundStdExp];
952 }
953 else
954 {
955 int nElmtCoef = (*expvect)[ne]->GetNcoeffs();
956 int nElmtCoef2 = nElmtCoef * nElmtCoef;
957 int nElmtPnt = (*expvect)[ne]->GetTotPoints();
958
961 int nQuotPlus = nQuot;
962 if (nRemd > 0)
963 {
964 nQuotPlus++;
965 }
967
968 ArrayStdMat[0] = MatStdDerivBase0;
970 {
971 StdRegions::StdMatrixKey matkey(
972 StdRegions::eDerivBase1, stdExp->DetShapeType(), *stdExp);
973 ArrayStdMat[1] = stdExp->GetStdMatrix(matkey);
974
976 {
977 StdRegions::StdMatrixKey matkey(StdRegions::eDerivBase2,
978 stdExp->DetShapeType(),
979 *stdExp);
980 ArrayStdMat[2] = stdExp->GetStdMatrix(matkey);
981 }
982 }
984 {
985 ArrayStdMatData[nd0] = ArrayStdMat[nd0]->GetPtr();
986 }
987
988 StdRegions::StdMatrixKey matkey(StdRegions::eBwdMat,
989 stdExp->DetShapeType(), *stdExp);
990 DNekMatSharedPtr BwdMat = stdExp->GetStdMatrix(matkey);
991 Array<OneD, NekDouble> BwdMatData = BwdMat->GetPtr();
992
993 TensorOfArray3D<DataType> tmpStdDBB(m_spacedim);
994 TensorOfArray4D<DataType> tmpStdDBDB(m_spacedim);
995
997 {
998 tmpStdDBB[nd0] = Array<OneD, Array<OneD, DataType>>(nElmtPnt);
999 for (int i = 0; i < nElmtPnt; i++)
1000 {
1001 tmpStdDBB[nd0][i] = Array<OneD, DataType>(nPaded, 0.0);
1002 for (int nc1 = 0; nc1 < nElmtCoef; nc1++)
1003 {
1004 int noffset = nc1 * nElmtCoef;
1005 for (int nc0 = 0; nc0 < nElmtCoef; nc0++)
1006 {
1007 tmpStdDBB[nd0][i][nc0 + noffset] = DataType(
1008 ArrayStdMatData[nd0][i * nElmtCoef + nc0] *
1009 BwdMatData[i * nElmtCoef + nc1]);
1010 }
1011 }
1012 }
1013
1014 tmpStdDBDB[nd0] = TensorOfArray3D<DataType>(m_spacedim);
1016 {
1017 tmpStdDBDB[nd0][nd1] =
1018 Array<OneD, Array<OneD, DataType>>(nElmtPnt);
1019 for (int i = 0; i < nElmtPnt; i++)
1020 {
1021 tmpStdDBDB[nd0][nd1][i] =
1022 Array<OneD, DataType>(nPaded, 0.0);
1023 for (int nc1 = 0; nc1 < nElmtCoef; nc1++)
1024 {
1025 int noffset = nc1 * nElmtCoef;
1026 for (int nc0 = 0; nc0 < nElmtCoef; nc0++)
1027 {
1028 tmpStdDBDB[nd0][nd1][i][nc0 + noffset] =
1029 DataType(
1030 ArrayStdMatData[nd0]
1031 [i * nElmtCoef + nc0] *
1032 ArrayStdMatData[nd1]
1033 [i * nElmtCoef + nc1]);
1034 }
1035 }
1036 }
1037 }
1038 }
1039 VectStdDerivBase0.push_back(MatStdDerivBase0);
1040 VectStdDerivBase_Base.push_back(tmpStdDBB);
1041 VectStdDervBase_DervBase.push_back(tmpStdDBDB);
1042
1043 StdMatDataDBB[ne] = tmpStdDBB;
1044 StdMatDataDBDB[ne] = tmpStdDBDB;
1045 }
1046 }
1047}
std::shared_ptr< StdExpansion > StdExpansionSharedPtr
Definition: StdExpansion.h:1768
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()
|
protected |
Compute the advection terms for the right-hand side.
Definition at line 374 of file CompressibleFlowSystemImplicit.cpp.
379{
380 int nvariables = inarray.size();
381 Array<OneD, Array<OneD, NekDouble>> advVel(m_spacedim);
382
383 auto advWeakDGObject =
384 std::dynamic_pointer_cast<SolverUtils::AdvectionWeakDG>(m_advObject);
385 ASSERTL0(advWeakDGObject,
386 "Use WeakDG for implicit compressible flow solver!");
387 advWeakDGObject->AdvectCoeffs(nvariables, m_fields, advVel, inarray,
388 outarray, time, pFwd, pBwd);
389}
References ASSERTL0, Nektar::SolverUtils::AdvectionSystem::m_advObject, Nektar::SolverUtils::EquationSystem::m_fields, and Nektar::SolverUtils::EquationSystem::m_spacedim.
Referenced by DoOdeRhsCoeff().
◆ DoDiffusionCoeff()
|
protected |
Add the diffusions terms to the right-hand side Similar to DoDiffusion() but with outarray in coefficient space.
Definition at line 395 of file CompressibleFlowSystemImplicit.cpp.
400{
401 v_DoDiffusionCoeff(inarray, outarray, pFwd, pBwd);
402}
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)
Definition: CompressibleFlowSystemImplicit.h:339
References v_DoDiffusionCoeff().
Referenced by DoOdeRhsCoeff().
◆ DoImplicitSolve()
|
protected |
Definition at line 404 of file CompressibleFlowSystemImplicit.cpp.
408{
409 unsigned int nvariables = inpnts.size();
411 unsigned int ntotal = nvariables * ncoeffs;
412
413 Array<OneD, NekDouble> inarray(ntotal);
414 Array<OneD, NekDouble> outarray(ntotal);
415 Array<OneD, NekDouble> tmpArray;
416
417 // Switch flag to make sure the physical shock capturing AV is updated
419
420 for (int i = 0; i < nvariables; ++i)
421 {
422 int noffset = i * ncoeffs;
423 tmpArray = inarray + noffset;
424 m_fields[i]->FwdTrans(inpnts[i], tmpArray);
425 }
426
427 DoImplicitSolveCoeff(inpnts, inarray, outarray, time, lambda);
428
429 for (int i = 0; i < nvariables; ++i)
430 {
431 int noffset = i * ncoeffs;
432 tmpArray = outarray + noffset;
433 m_fields[i]->BwdTrans(tmpArray, outpnt[i]);
434 }
435}
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)
Definition: CompressibleFlowSystemImplicit.cpp:437
bool m_updateShockCaptPhys
Definition: CompressibleFlowSystemImplicit.h:89
References DoImplicitSolveCoeff(), Nektar::SolverUtils::EquationSystem::m_fields, and m_updateShockCaptPhys.
Referenced by v_InitObject().
◆ DoImplicitSolveCoeff()
|
protected |
Definition at line 437 of file CompressibleFlowSystemImplicit.cpp.
441{
442 m_TimeIntegLambda = lambda;
443 m_bndEvaluateTime = time;
444 m_solutionPhys = inpnts;
445 unsigned int ntotal = inarray.size();
446
448 {
449 CalcRefValues(inarray);
450 }
451
453
455
457
458 m_TotImpStages++;
459}
LibUtilities::NekNonlinSysSharedPtr m_nonlinsol
Definition: CompressibleFlowSystemImplicit.h:82
int m_TotNewtonIts
Definition: CompressibleFlowSystemImplicit.h:63
void CalcRefValues(const Array< OneD, const NekDouble > &inarray)
Definition: CompressibleFlowSystemImplicit.cpp:461
int m_TotImpStages
Definition: CompressibleFlowSystemImplicit.h:65
Array< OneD, Array< OneD, NekDouble > > m_solutionPhys
Definition: CompressibleFlowSystemImplicit.h:70
NekDouble m_newtonRelativeIteTol
Definition: CompressibleFlowSystemImplicit.h:77
References CalcRefValues(), Nektar::CompressibleFlowSystem::m_bndEvaluateTime, m_inArrayNorm, m_newtonRelativeIteTol, m_nonlinsol, m_solutionPhys, m_TimeIntegLambda, m_TotImpStages, m_TotLinIts, m_TotNewtonIts, and tinysimd::sqrt().
Referenced by DoImplicitSolve().
◆ DoOdeImplicitRhs()
|
protected |
Definition at line 267 of file CompressibleFlowSystemImplicit.cpp.
270{
271 int nvariables = inarray.size();
273
274 Array<OneD, Array<OneD, NekDouble>> tmpOut(nvariables);
275 for (int i = 0; i < nvariables; ++i)
276 {
277 tmpOut[i] = Array<OneD, NekDouble>(ncoeffs);
278 }
279
280 DoOdeRhsCoeff(inarray, tmpOut, time);
281
282 for (int i = 0; i < nvariables; ++i)
283 {
284 m_fields[i]->BwdTrans(tmpOut[i], outarray[i]);
285 }
286}
void DoOdeRhsCoeff(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
Compute the right-hand side.
Definition: CompressibleFlowSystemImplicit.cpp:291
References DoOdeRhsCoeff(), and Nektar::SolverUtils::EquationSystem::m_fields.
Referenced by v_InitObject().
◆ DoOdeRhsCoeff()
|
protected |
Compute the right-hand side.
Definition at line 291 of file CompressibleFlowSystemImplicit.cpp.
294{
295 LibUtilities::Timer timer;
296
297 int nvariables = inarray.size();
300
301 m_bndEvaluateTime = time;
302
303 // Store forwards/backwards space along trace space
304 Array<OneD, Array<OneD, NekDouble>> Fwd(nvariables);
305 Array<OneD, Array<OneD, NekDouble>> Bwd(nvariables);
306
308 {
309 Fwd = NullNekDoubleArrayOfArray;
310 Bwd = NullNekDoubleArrayOfArray;
311 }
312 else
313 {
314 for (int i = 0; i < nvariables; ++i)
315 {
316 Fwd[i] = Array<OneD, NekDouble>(nTracePts, 0.0);
317 Bwd[i] = Array<OneD, NekDouble>(nTracePts, 0.0);
318 m_fields[i]->GetFwdBwdTracePhys(inarray[i], Fwd[i], Bwd[i]);
319 }
320 }
321
322 // Calculate advection
323 timer.Start();
324 DoAdvectionCoeff(inarray, outarray, time, Fwd, Bwd);
325 timer.Stop();
326 timer.AccumulateRegion("CFSImplicit::DoAdvectionCoeff", 2);
327
328 // Negate results
329 for (int i = 0; i < nvariables; ++i)
330 {
331 Vmath::Neg(ncoeffs, outarray[i], 1);
332 }
333
334 // Add diffusion terms
335 timer.Start();
336 DoDiffusionCoeff(inarray, outarray, Fwd, Bwd);
337 timer.Stop();
338 timer.AccumulateRegion("CFSImplicit::DoDiffusionCoeff", 2);
339
340 // Add forcing terms
342 {
343 x->ApplyCoeff(m_fields, inarray, outarray, time);
344 }
345
347 {
349 int nq, offset;
350 NekDouble fac;
351 Array<OneD, NekDouble> tmp;
352
353 Array<OneD, NekDouble> tstep(nElements, 0.0);
354 GetElmtTimeStep(inarray, tstep);
355
356 // Loop over elements
357 for (int n = 0; n < nElements; ++n)
358 {
359 nq = m_fields[0]->GetExp(n)->GetNcoeffs();
360 offset = m_fields[0]->GetCoeff_Offset(n);
361 fac = tstep[n] / m_timestep;
362 for (int i = 0; i < nvariables; ++i)
363 {
364 Vmath::Smul(nq, fac, outarray[i] + offset, 1,
365 tmp = outarray[i] + offset, 1);
366 }
367 }
368 }
369}
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...
Definition: CompressibleFlowSystemImplicit.cpp:395
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.
Definition: CompressibleFlowSystemImplicit.cpp:374
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.
Definition: CompressibleFlowSystem.cpp:551
bool m_useLocalTimeStep
Definition: CompressibleFlowSystem.h:89
std::vector< SolverUtils::ForcingSharedPtr > m_forcing
Definition: CompressibleFlowSystem.h:106
SOLVER_UTILS_EXPORT int GetTraceTotPoints()
Definition: EquationSystem.h:739
enum HomogeneousType m_HomogeneousType
Definition: EquationSystem.h:453
SOLVER_UTILS_EXPORT int GetNcoeffs()
Definition: EquationSystem.h:706
static Array< OneD, Array< OneD, NekDouble > > NullNekDoubleArrayOfArray
Definition: SharedArray.hpp:889
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 Nektar::LibUtilities::Timer::AccumulateRegion(), DoAdvectionCoeff(), DoDiffusionCoeff(), Nektar::SolverUtils::EquationSystem::eHomogeneous1D, Nektar::CompressibleFlowSystem::GetElmtTimeStep(), 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::SolverUtils::EquationSystem::m_timestep, Nektar::CompressibleFlowSystem::m_useLocalTimeStep, Vmath::Neg(), Nektar::NullNekDoubleArrayOfArray, Vmath::Smul(), Nektar::LibUtilities::Timer::Start(), and Nektar::LibUtilities::Timer::Stop().
Referenced by DoOdeImplicitRhs(), and NonlinSysEvaluatorCoeff().
◆ ElmtVarInvMtrx()
template<typename DataType , typename TypeNekBlkMatSharedPtr >
|
protected |
Definition at line 1079 of file CompressibleFlowSystemImplicit.cpp.
1083{
1084 int n1d = gmtxarray.size();
1085 int n2d = gmtxarray[0].size();
1086 int nConvectiveFields = n1d;
1087
1089
1090 Array<OneD, unsigned int> rowSizes;
1091 Array<OneD, unsigned int> colSizes;
1092
1093 gmtxarray[0][0]->GetBlockSizes(rowSizes, colSizes);
1094 int nTotElmt = rowSizes.size();
1095 int nElmtCoef = rowSizes[0] - 1;
1096 int nElmtCoef0 = -1;
1097 int blocksize = -1;
1098
1099 Array<OneD, unsigned int> tmprow(1);
1100 TypeNekBlkMatSharedPtr tmpGmtx;
1101
1102 Array<OneD, DataType> GMatData, ElmtMatData;
1103 Array<OneD, DataType> tmpArray1, tmpArray2;
1104
1105 for (int nelmt = 0; nelmt < nTotElmt; nelmt++)
1106 {
1107 int nrows = gmtxarray[0][0]->GetBlock(nelmt, nelmt)->GetRows();
1108 int ncols = gmtxarray[0][0]->GetBlock(nelmt, nelmt)->GetColumns();
1110
1111 nElmtCoef = nrows;
1112
1113 if (nElmtCoef0 != nElmtCoef)
1114 {
1115 nElmtCoef0 = nElmtCoef;
1116 int nElmtCoefVar = nElmtCoef0 * nConvectiveFields;
1117 blocksize = nElmtCoefVar * nElmtCoefVar;
1118 tmprow[0] = nElmtCoefVar;
1119 AllocateNekBlkMatDig(tmpGmtx, tmprow, tmprow);
1120 GMatData = tmpGmtx->GetBlock(0, 0)->GetPtr();
1121 }
1122
1123 for (int n = 0; n < nConvectiveFields; n++)
1124 {
1125 for (int m = 0; m < nConvectiveFields; m++)
1126 {
1127 ElmtMatData = gmtxarray[m][n]->GetBlock(nelmt, nelmt)->GetPtr();
1128
1129 for (int ncl = 0; ncl < nElmtCoef; ncl++)
1130 {
1131 int Goffset =
1132 (n * nElmtCoef + ncl) * nConvectiveFields * nElmtCoef +
1133 m * nElmtCoef;
1134 int Eoffset = ncl * nElmtCoef;
1135
1136 Vmath::Vcopy(nElmtCoef, tmpArray1 = ElmtMatData + Eoffset,
1137 1, tmpArray2 = GMatData + Goffset, 1);
1138 }
1139 }
1140 }
1141
1142 tmpGmtx->GetBlock(0, 0)->Invert();
1143
1144 for (int m = 0; m < nConvectiveFields; m++)
1145 {
1146 for (int n = 0; n < nConvectiveFields; n++)
1147 {
1148 ElmtMatData = gmtxarray[m][n]->GetBlock(nelmt, nelmt)->GetPtr();
1149
1150 for (int ncl = 0; ncl < nElmtCoef; ncl++)
1151 {
1152 int Goffset =
1153 (n * nElmtCoef + ncl) * nConvectiveFields * nElmtCoef +
1154 m * nElmtCoef;
1155 int Eoffset = ncl * nElmtCoef;
1156
1157 Vmath::Vcopy(nElmtCoef, tmpArray1 = GMatData + Goffset, 1,
1158 tmpArray2 = ElmtMatData + Eoffset, 1);
1159 }
1160 }
1161 }
1162 ElmtMatData = gmtVar->GetBlock(nelmt, nelmt)->GetPtr();
1163 Vmath::Vcopy(blocksize, GMatData, 1, ElmtMatData, 1);
1164 }
1165 return;
1166}
void AllocateNekBlkMatDig(SNekBlkMatSharedPtr &mat, const Array< OneD, unsigned int > nrow, const Array< OneD, unsigned int > ncol)
Definition: CompressibleFlowSystemImplicit.h:220
References AllocateNekBlkMatDig(), ASSERTL0, and Vmath::Vcopy().
Referenced by CalcPreconMatBRJCoeff().
◆ Fill1DArrayOfBlkDiagonalMat()
template<typename DataType , typename TypeNekBlkMatSharedPtr >
|
protected |
Definition at line 1847 of file CompressibleFlowSystemImplicit.cpp.
1849{
1850 int n1d = gmtxarray.size();
1851
1852 Array<OneD, unsigned int> rowSizes;
1853 Array<OneD, unsigned int> colSizes;
1854
1855 Array<OneD, DataType> loc_mat_arr;
1856
1857 for (int n1 = 0; n1 < n1d; ++n1)
1858 {
1859 gmtxarray[n1]->GetBlockSizes(rowSizes, colSizes);
1860 int nelmts = rowSizes.size();
1861
1862 for (int i = 0; i < nelmts; ++i)
1863 {
1864 loc_mat_arr = gmtxarray[n1]->GetBlock(i, i)->GetPtr();
1865
1866 int nrows = gmtxarray[n1]->GetBlock(i, i)->GetRows();
1867 int ncols = gmtxarray[n1]->GetBlock(i, i)->GetColumns();
1868
1869 Vmath::Fill(nrows * ncols, valu, loc_mat_arr, 1);
1870 }
1871 }
1872}
References Vmath::Fill().
Referenced by Fill2DArrayOfBlkDiagonalMat().
◆ Fill2DArrayOfBlkDiagonalMat()
template<typename DataType , typename TypeNekBlkMatSharedPtr >
|
protected |
Definition at line 1834 of file CompressibleFlowSystemImplicit.cpp.
1837{
1838 int n1d = gmtxarray.size();
1839
1840 for (int n1 = 0; n1 < n1d; ++n1)
1841 {
1842 Fill1DArrayOfBlkDiagonalMat(gmtxarray[n1], valu);
1843 }
1844}
void Fill1DArrayOfBlkDiagonalMat(Array< OneD, TypeNekBlkMatSharedPtr > &gmtxarray, const DataType valu)
Definition: CompressibleFlowSystemImplicit.cpp:1847
References Fill1DArrayOfBlkDiagonalMat().
Referenced by CalcPreconMatBRJCoeff().
◆ GetFluxDerivJacDirctn() [1/2]
|
inlineprotected |
Definition at line 317 of file CompressibleFlowSystemImplicit.h.
323 {
324 v_GetFluxDerivJacDirctn(explist, normals, nDervDir, inarray, ElmtJac);
325 }
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)
Definition: CompressibleFlowSystemImplicit.cpp:1680
References v_GetFluxDerivJacDirctn().
◆ GetFluxDerivJacDirctn() [2/2]
|
inlineprotected |
Definition at line 293 of file CompressibleFlowSystemImplicit.h.
299 {
300 v_GetFluxDerivJacDirctn(explist, normals, nDervDir, inarray,
301 ElmtJacArray, nFluxDir);
302 }
References v_GetFluxDerivJacDirctn().
◆ GetFluxDerivJacDirctnElmt()
|
inlineprotected |
Definition at line 304 of file CompressibleFlowSystemImplicit.h.
311 {
312 v_GetFluxDerivJacDirctnElmt(nConvectiveFields, nElmtPnt, nDervDir,
313 locVars, locmu, locnormal, wspMat,
314 PntJacArray);
315 }
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)
Definition: CompressibleFlowSystemImplicit.cpp:1691
References v_GetFluxDerivJacDirctnElmt().
Referenced by AddMatNSBlkDiagVol().
◆ GetFluxVectorJacDirElmt()
|
protected |
Definition at line 1712 of file CompressibleFlowSystemImplicit.cpp.
1717{
1718 Array<OneD, NekDouble> wspMatData = wspMat->GetPtr();
1719
1720 int matsize = nConvectiveFields * nConvectiveFields;
1721
1722 Array<OneD, NekDouble> pointVar(nConvectiveFields);
1723
1724 for (int npnt = 0; npnt < nElmtPnt; npnt++)
1725 {
1726 for (int j = 0; j < nConvectiveFields; j++)
1727 {
1728 pointVar[j] = locVars[j][npnt];
1729 }
1730
1731 GetFluxVectorJacPoint(nConvectiveFields, pointVar, normals, wspMat);
1732
1733 Vmath::Vcopy(matsize, wspMatData, 1, PntJacArray[npnt], 1);
1734 }
1735 return;
1736}
void GetFluxVectorJacPoint(const int nConvectiveFields, const Array< OneD, NekDouble > &conservVar, const Array< OneD, NekDouble > &normals, DNekMatSharedPtr &fluxJac)
Definition: CompressibleFlowSystemImplicit.cpp:1738
References GetFluxVectorJacPoint(), and Vmath::Vcopy().
Referenced by AddMatNSBlkDiagVol().
◆ GetFluxVectorJacPoint()
|
protected |
Definition at line 1738 of file CompressibleFlowSystemImplicit.cpp.
1741{
1742 int nvariables = conservVar.size();
1743 const int nvariables3D = 5;
1745
1746 NekDouble fsw, efix_StegerWarming;
1747 efix_StegerWarming = 0.0;
1748 fsw = 0.0; // exact flux Jacobian if fsw=0.0
1749 if (nvariables > expDim + 2)
1750 {
1752 }
1753
1754 Array<OneD, NekDouble> fluxJacData;
1755 ;
1756 fluxJacData = fluxJac->GetPtr();
1757
1758 if (nConvectiveFields == nvariables3D)
1759 {
1760 PointFluxJacobianPoint(conservVar, normals, fluxJac, efix_StegerWarming,
1761 fsw);
1762 }
1763 else
1764 {
1765 DNekMatSharedPtr PointFJac3D =
1766 MemoryManager<DNekMat>::AllocateSharedPtr(nvariables3D,
1767 nvariables3D, 0.0);
1768
1769 Array<OneD, NekDouble> PointFJac3DData;
1770 PointFJac3DData = PointFJac3D->GetPtr();
1771
1772 Array<OneD, NekDouble> PointFwd(nvariables3D, 0.0);
1773
1774 Array<OneD, unsigned int> index(nvariables);
1775
1776 index[nvariables - 1] = 4;
1777 for (int i = 0; i < nvariables - 1; i++)
1778 {
1779 index[i] = i;
1780 }
1781
1782 int nj = 0;
1783 int nk = 0;
1784 for (int j = 0; j < nvariables; j++)
1785 {
1786 nj = index[j];
1787 PointFwd[nj] = conservVar[j];
1788 }
1789
1790 PointFluxJacobianPoint(PointFwd, normals, PointFJac3D,
1791 efix_StegerWarming, fsw);
1792
1793 for (int j = 0; j < nvariables; j++)
1794 {
1795 nj = index[j];
1796 for (int k = 0; k < nvariables; k++)
1797 {
1798 nk = index[k];
1799 fluxJacData[j + k * nConvectiveFields] =
1800 PointFJac3DData[nj + nk * nvariables3D];
1801 }
1802 }
1803 }
1804}
#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)
Definition: CompressibleFlowSystemImplicit.cpp:1878
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 >
|
protected |
Definition at line 1169 of file CompressibleFlowSystemImplicit.cpp.
1176{
1177 int nvariables = inarray.size();
1179
1180 // Store forwards/backwards space along trace space
1181 Array<OneD, Array<OneD, NekDouble>> Fwd(nvariables);
1182 Array<OneD, Array<OneD, NekDouble>> Bwd(nvariables);
1183
1184 TypeNekBlkMatSharedPtr FJac, BJac;
1185 Array<OneD, unsigned int> n_blks1(nTracePts, nvariables);
1186
1187 if (TraceJac.size() > 0)
1188 {
1189 FJac = TraceJac[0];
1190 BJac = TraceJac[1];
1191 }
1192 else
1193 {
1194 TraceJac = Array<OneD, TypeNekBlkMatSharedPtr>(2);
1195
1196 AllocateNekBlkMatDig(FJac, n_blks1, n_blks1);
1197 AllocateNekBlkMatDig(BJac, n_blks1, n_blks1);
1198 }
1199
1201 {
1202 Fwd = NullNekDoubleArrayOfArray;
1203 Bwd = NullNekDoubleArrayOfArray;
1204 }
1205 else
1206 {
1207 for (int i = 0; i < nvariables; ++i)
1208 {
1209 Fwd[i] = Array<OneD, NekDouble>(nTracePts, 0.0);
1210 Bwd[i] = Array<OneD, NekDouble>(nTracePts, 0.0);
1211 m_fields[i]->GetFwdBwdTracePhys(inarray[i], Fwd[i], Bwd[i]);
1212 }
1213 }
1214
1215 Array<OneD, Array<OneD, NekDouble>> AdvVel(m_spacedim);
1216
1218 m_bndEvaluateTime, Fwd, Bwd, FJac, BJac,
1219 TraceIPSymJacArray);
1220
1221 TraceJac[0] = FJac;
1222 TraceJac[1] = BJac;
1223}
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)
Definition: CompressibleFlowSystemImplicit.cpp:1226
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()
|
protected |
Definition at line 87 of file CompressibleFlowSystemImplicit.cpp.
88{
91
94 {
96 }
99
100 // Create the key to hold settings for nonlin solver
101 LibUtilities::NekSysKey key = LibUtilities::NekSysKey();
102 // Load required LinSys parameters:
104 key.m_NekLinSysMaxIterations, 30);
107 31);
109 key.m_NekLinSysLeftPrecon, false);
111 key.m_NekLinSysRightPrecon, true);
112 // Load required NonLinSys parameters:
114 key.m_NekNonlinSysMaxIterations, 10);
116 key.m_NonlinIterTolRelativeL2, 1.0E-3);
118 key.m_LinSysRelativeTolInNonlin, 5.0E-2);
120 key.m_LinSysIterSolverTypeInNonlin, "GMRES");
121
122 int GMRESCentralDifference = 0;
124 0);
125 switch (GMRESCentralDifference)
126 {
127 case 1:
128 key.m_DifferenceFlag0 = true;
129 key.m_DifferenceFlag1 = false;
130 break;
131 case 2:
132 key.m_DifferenceFlag0 = true;
133 key.m_DifferenceFlag1 = true;
134 break;
135 default:
136 key.m_DifferenceFlag0 = false;
137 key.m_DifferenceFlag1 = false;
138 break;
139 }
140
141 // Initialize operator
142 LibUtilities::NekSysOperators nekSysOp;
144 nekSysOp.DefineNekSysLhsEval(&CFSImplicit::MatrixMultiplyMatrixFreeCoeff,
145 this);
147
148 // Initialize trace
150 locTraceToTraceMap->CalcLocTracePhysToTraceIDMap(m_fields[0]->GetTrace(),
151 m_spacedim);
152 for (int i = 1; i < nvariables; i++)
153 {
154 m_fields[i]->GetLocTraceToTraceMap()->SetLocTracePhysToTraceIDMap(
155 locTraceToTraceMap->GetLocTracephysToTraceIDMap());
156 }
157
158 // Initialize non-linear system
161 m_nonlinsol->SetSysOperators(nekSysOp);
162
163 // Initialize preconditioner
164 NekPreconCfsOperators preconOp;
165 preconOp.DefineCalcPreconMatBRJCoeff(&CFSImplicit::CalcPreconMatBRJCoeff,
166 this);
169 m_preconCfs->SetOperators(preconOp);
170}
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)
Definition: CompressibleFlowSystemImplicit.cpp:1492
void PreconCoeff(const Array< OneD, NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const bool &flag)
Definition: CompressibleFlowSystemImplicit.cpp:538
PreconCfsSharedPtr m_preconCfs
Definition: CompressibleFlowSystemImplicit.h:84
void NonlinSysEvaluatorCoeff1D(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out, const bool &flag=true)
Definition: CompressibleFlowSystemImplicit.cpp:209
void MatrixMultiplyMatrixFreeCoeff(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out, const bool &flag=false)
Definition: CompressibleFlowSystemImplicit.cpp:515
tBaseSharedPtr CreateInstance(tKey idKey, tParam... args)
Create an instance of the class referred to by idKey.
Definition: NekFactory.hpp:143
NekNonlinSysFactory & GetNekNonlinSysFactory()
Definition: NekNonlinSys.cpp:47
PreconCfsFactory & GetPreconCfsFactory()
Declaration of the boundary condition factory singleton.
Definition: PreconCfs.cpp:42
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::GetNekNonlinSysFactory(), Nektar::GetPreconCfsFactory(), Nektar::SolverUtils::EquationSystem::m_comm, Nektar::LibUtilities::NekSysKey::m_DifferenceFlag0, Nektar::LibUtilities::NekSysKey::m_DifferenceFlag1, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::LibUtilities::NekSysKey::m_KrylovMaxHessMatBand, Nektar::LibUtilities::NekSysKey::m_LinSysIterSolverTypeInNonlin, Nektar::LibUtilities::NekSysKey::m_LinSysMaxStorage, Nektar::LibUtilities::NekSysKey::m_LinSysRelativeTolInNonlin, Nektar::LibUtilities::NekSysKey::m_NekLinSysLeftPrecon, Nektar::LibUtilities::NekSysKey::m_NekLinSysMaxIterations, Nektar::LibUtilities::NekSysKey::m_NekLinSysRightPrecon, Nektar::LibUtilities::NekSysKey::m_NekNonlinSysMaxIterations, Nektar::LibUtilities::NekSysKey::m_NonlinIterTolRelativeL2, m_nonlinsol, m_preconCfs, Nektar::SolverUtils::EquationSystem::m_session, Nektar::SolverUtils::EquationSystem::m_spacedim, MatrixMultiplyMatrixFreeCoeff(), NonlinSysEvaluatorCoeff1D(), and PreconCoeff().
Referenced by v_InitObject().
◆ MatrixMultiplyMatrixFreeCoeff()
|
protected |
Definition at line 515 of file CompressibleFlowSystemImplicit.cpp.
518{
521
522 unsigned int ntotal = inarray.size();
524 m_comm->GetSpaceComm()->AllReduce(magninarray,
526 NekDouble eps =
528
529 Array<OneD, NekDouble> solplus{ntotal};
530 Array<OneD, NekDouble> resplus{ntotal};
531
532 Vmath::Svtvp(ntotal, eps, inarray, 1, solref, 1, solplus, 1);
533 NonlinSysEvaluatorCoeff1D(solplus, resplus, flag);
534 Vmath::Vsub(ntotal, resplus, 1, resref, 1, out, 1);
535 Vmath::Smul(ntotal, 1.0 / eps, out, 1, out, 1);
536}
NekDouble m_jacobiFreeEps
Definition: CompressibleFlowSystemImplicit.h:76
void Svtvp(int n, const T alpha, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Svtvp (scalar times vector plus vector): z = alpha*x + y.
Definition: Vmath.hpp:396
References 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()
|
inlineprotected |
Definition at line 279 of file CompressibleFlowSystemImplicit.h.
287 {
288 v_MinusDiffusionFluxJacPoint(nConvectiveFields, nElmtPnt, locVars,
289 locDerv, locmu, locDmuDT, normals, wspMat,
290 PntJacArray);
291 }
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)
Definition: CompressibleFlowSystemImplicit.cpp:1535
References v_MinusDiffusionFluxJacPoint().
Referenced by AddMatNSBlkDiagVol().
◆ MultiplyElmtInvMassPlusSource()
template<typename DataType , typename TypeNekBlkMatSharedPtr >
|
protected |
Definition at line 1550 of file CompressibleFlowSystemImplicit.cpp.
1553{
1555 std::shared_ptr<LocalRegions::ExpansionVector> pexp = explist->GetExp();
1556 int nTotElmt = (*pexp).size();
1558
1559 NekDouble Negdtlamda = -dtlamda;
1560
1561 Array<OneD, NekDouble> pseudotimefactor(nTotElmt, 0.0);
1562 Vmath::Fill(nTotElmt, Negdtlamda, pseudotimefactor, 1);
1563
1564 Array<OneD, DataType> GMatData;
1565 for (int m = 0; m < nConvectiveFields; m++)
1566 {
1567 for (int n = 0; n < nConvectiveFields; n++)
1568 {
1569 for (int nelmt = 0; nelmt < nTotElmt; nelmt++)
1570 {
1571 GMatData = gmtxarray[m][n]->GetBlock(nelmt, nelmt)->GetPtr();
1572 DataType factor = DataType(pseudotimefactor[nelmt]);
1573
1574 Vmath::Smul(GMatData.size(), factor, GMatData, 1, GMatData, 1);
1575 }
1576 }
1577 }
1578
1579 DNekMatSharedPtr MassMat;
1580 Array<OneD, NekDouble> BwdMatData, MassMatData, tmp;
1581 Array<OneD, NekDouble> tmp2;
1582 Array<OneD, DataType> MassMatDataDataType;
1584
1585 for (int nelmt = 0; nelmt < nTotElmt; nelmt++)
1586 {
1589 LibUtilities::ShapeType ElmtTypeNow =
1590 explist->GetExp(nelmt)->DetShapeType();
1591
1592 if (tmp.size() != nelmtcoef || (ElmtTypeNow != ElmtTypePrevious))
1593 {
1594 StdRegions::StdExpansionSharedPtr stdExp;
1595 stdExp = explist->GetExp(nelmt)->GetStdExp();
1596 StdRegions::StdMatrixKey matkey(StdRegions::eBwdTrans,
1597 stdExp->DetShapeType(), *stdExp);
1598
1599 DNekMatSharedPtr BwdMat = stdExp->GetStdMatrix(matkey);
1600 BwdMatData = BwdMat->GetPtr();
1601
1602 if (nelmtcoef != tmp.size())
1603 {
1604 tmp = Array<OneD, NekDouble>(nelmtcoef, 0.0);
1605 MassMat = MemoryManager<DNekMat>::AllocateSharedPtr(
1606 nelmtcoef, nelmtcoef, 0.0);
1607 MassMatData = MassMat->GetPtr();
1608 MassMatDataDataType =
1609 Array<OneD, DataType>(nelmtcoef * nelmtcoef);
1610 }
1611
1612 ElmtTypePrevious = ElmtTypeNow;
1613 }
1614
1615 for (int np = 0; np < nelmtcoef; np++)
1616 {
1617 explist->GetExp(nelmt)->IProductWRTBase(BwdMatData + np * nelmtpnts,
1618 tmp);
1619 Vmath::Vcopy(nelmtcoef, tmp, 1, tmp2 = MassMatData + np * nelmtcoef,
1620 1);
1621 }
1622 for (int i = 0; i < MassMatData.size(); i++)
1623 {
1624 MassMatDataDataType[i] = DataType(MassMatData[i]);
1625 }
1626
1627 for (int m = 0; m < nConvectiveFields; m++)
1628 {
1629 GMatData = gmtxarray[m][m]->GetBlock(nelmt, nelmt)->GetPtr();
1630 Vmath::Vadd(MassMatData.size(), MassMatDataDataType, 1, GMatData, 1,
1631 GMatData, 1);
1632 }
1633 }
1634 return;
1635}
SOLVER_UTILS_EXPORT int GetTotPoints()
Definition: EquationSystem.h:764
std::shared_ptr< ExpList > ExpListSharedPtr
Shared pointer to an ExpList object.
Definition: LocTraceToTraceMap.h:56
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()
|
protected |
Definition at line 231 of file CompressibleFlowSystemImplicit.cpp.
234{
235 LibUtilities::Timer timer;
236 unsigned int nvariable = inarray.size();
239
240 Array<OneD, Array<OneD, NekDouble>> inpnts(nvariable);
241
242 for (int i = 0; i < nvariable; ++i)
243 {
244 inpnts[i] = Array<OneD, NekDouble>(npoints, 0.0);
245 m_fields[i]->BwdTrans(inarray[i], inpnts[i]);
246 }
247
248 timer.Start();
250 timer.Stop();
251 timer.AccumulateRegion("CompressibleFlowSystem::DoOdeProjection", 1);
252
253 timer.Start();
255 timer.Stop();
256 timer.AccumulateRegion("CFSImplicit::DoOdeRhsCoeff", 1);
257
258 for (int i = 0; i < nvariable; ++i)
259 {
261 out[i], 1);
262 Vmath::Vsub(ncoeffs, out[i], 1,
263 m_nonlinsol->GetRefSourceVec() + i * ncoeffs, 1, out[i], 1);
264 }
265}
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...
Definition: CompressibleFlowSystem.cpp:291
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()
|
protected |
Definition at line 209 of file CompressibleFlowSystemImplicit.cpp.
212{
213 LibUtilities::Timer timer;
216 Array<OneD, Array<OneD, NekDouble>> in2D(nvariables);
217 Array<OneD, Array<OneD, NekDouble>> out2D(nvariables);
218 for (int i = 0; i < nvariables; ++i)
219 {
220 int offset = i * npoints;
221 in2D[i] = inarray + offset;
222 out2D[i] = out + offset;
223 }
224
225 timer.Start();
226 NonlinSysEvaluatorCoeff(in2D, out2D);
227 timer.Stop();
228 timer.AccumulateRegion("CFSImplicit::NonlinSysEvaluatorCoeff1D");
229}
void NonlinSysEvaluatorCoeff(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &out)
Definition: CompressibleFlowSystemImplicit.cpp:231
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 >
|
protected |
Definition at line 1226 of file CompressibleFlowSystemImplicit.cpp.
1236{
1238 int nvariables = nConvectiveFields;
1242
1243 Array<OneD, int> nonZeroIndex;
1244
1245 Array<OneD, Array<OneD, NekDouble>> tmpinarry(nvariables);
1246 for (int i = 0; i < nvariables; i++)
1247 {
1248 tmpinarry[i] = Array<OneD, NekDouble>(npoints, 0.0);
1249 Vmath::Vcopy(npoints, inarray[i], 1, tmpinarry[i], 1);
1250 }
1251
1252 // DmuDT of artificial diffusion is neglected
1253 // TODO: to consider the Jacobian of AV seperately
1254 Array<OneD, NekDouble> muvar = NullNekDouble1DArray;
1255 Array<OneD, NekDouble> MuVarTrace = NullNekDouble1DArray;
1256
1257 Array<OneD, Array<OneD, NekDouble>> numflux(nvariables);
1258 for (int i = 0; i < nvariables; ++i)
1259 {
1260 numflux[i] = Array<OneD, NekDouble>(nTracePts, 0.0);
1261 }
1262
1264 fields[0]->GetTraceMap();
1265 TensorOfArray3D<NekDouble> qBwd(nDim);
1266 TensorOfArray3D<NekDouble> qFwd(nDim);
1268 {
1269 for (int nd = 0; nd < nDim; ++nd)
1270 {
1271 qBwd[nd] = Array<OneD, Array<OneD, NekDouble>>(nConvectiveFields);
1272 qFwd[nd] = Array<OneD, Array<OneD, NekDouble>>(nConvectiveFields);
1273 for (int i = 0; i < nConvectiveFields; ++i)
1274 {
1275 qBwd[nd][i] = Array<OneD, NekDouble>(nTracePts, 0.0);
1276 qFwd[nd][i] = Array<OneD, NekDouble>(nTracePts, 0.0);
1277
1278 fields[i]->GetFwdBwdTracePhys(qfield[nd][i], qFwd[nd][i],
1279 qBwd[nd][i], true, true, false);
1280 TraceMap->GetAssemblyCommDG()->PerformExchange(qFwd[nd][i],
1281 qBwd[nd][i]);
1282 }
1283 }
1284 }
1285
1286 CalcTraceNumericalFlux(nConvectiveFields, nDim, npoints, nTracePts,
1287 PenaltyFactor2, fields, AdvVel, inarray, time,
1288 qfield, Fwd, Bwd, qFwd, qBwd, MuVarTrace,
1289 nonZeroIndex, numflux);
1290
1291 int nFields = nvariables;
1292 Array<OneD, Array<OneD, NekDouble>> plusFwd(nFields), plusBwd(nFields);
1293 Array<OneD, Array<OneD, NekDouble>> Jacvect(nFields);
1294 Array<OneD, Array<OneD, NekDouble>> FwdBnd(nFields);
1295 Array<OneD, Array<OneD, NekDouble>> plusflux(nFields);
1296 for (int i = 0; i < nFields; i++)
1297 {
1298 Jacvect[i] = Array<OneD, NekDouble>(nTracePts, 0.0);
1299 plusFwd[i] = Array<OneD, NekDouble>(nTracePts, 0.0);
1300 plusBwd[i] = Array<OneD, NekDouble>(nTracePts, 0.0);
1301 plusflux[i] = Array<OneD, NekDouble>(nTracePts, 0.0);
1302 FwdBnd[i] = Array<OneD, NekDouble>(nTracePts, 0.0);
1303 }
1304
1305 for (int i = 0; i < nFields; i++)
1306 {
1307 Vmath::Vcopy(nTracePts, Fwd[i], 1, plusFwd[i], 1);
1308 Vmath::Vcopy(nTracePts, Bwd[i], 1, plusBwd[i], 1);
1309 }
1310
1311 NekDouble eps = 1.0E-6;
1312
1313 Array<OneD, DataType> tmpMatData;
1314 // Fwd Jacobian
1315 for (int i = 0; i < nFields; i++)
1316 {
1318 NekDouble oepsvar = 1.0 / epsvar;
1319 Vmath::Sadd(nTracePts, epsvar, Fwd[i], 1, plusFwd[i], 1);
1320
1322 {
1323 for (int i = 0; i < nFields; i++)
1324 {
1325 Vmath::Vcopy(nTracePts, plusFwd[i], 1, FwdBnd[i], 1);
1326 }
1327 // Loop over user-defined boundary conditions
1329 {
1330 x->Apply(FwdBnd, tmpinarry, time);
1331 }
1332 }
1333
1334 for (int j = 0; j < nFields; j++)
1335 {
1336 m_fields[j]->FillBwdWithBoundCond(plusFwd[j], plusBwd[j]);
1337 }
1338
1339 CalcTraceNumericalFlux(nConvectiveFields, nDim, npoints, nTracePts,
1340 PenaltyFactor2, fields, AdvVel, inarray, time,
1341 qfield, plusFwd, plusBwd, qFwd, qBwd, MuVarTrace,
1342 nonZeroIndex, plusflux);
1343
1344 for (int n = 0; n < nFields; n++)
1345 {
1346 Vmath::Vsub(nTracePts, plusflux[n], 1, numflux[n], 1, Jacvect[n],
1347 1);
1348 Vmath::Smul(nTracePts, oepsvar, Jacvect[n], 1, Jacvect[n], 1);
1349 }
1350 for (int j = 0; j < nTracePts; j++)
1351 {
1352 tmpMatData = FJac->GetBlock(j, j)->GetPtr();
1353 for (int n = 0; n < nFields; n++)
1354 {
1355 tmpMatData[n + i * nFields] = DataType(Jacvect[n][j]);
1356 }
1357 }
1358
1359 Vmath::Vcopy(nTracePts, Fwd[i], 1, plusFwd[i], 1);
1360 }
1361
1362 // Reset the boundary conditions
1364 {
1365 for (int i = 0; i < nFields; i++)
1366 {
1367 Vmath::Vcopy(nTracePts, Fwd[i], 1, FwdBnd[i], 1);
1368 }
1369 // Loop over user-defined boundary conditions
1371 {
1372 x->Apply(FwdBnd, tmpinarry, time);
1373 }
1374 }
1375
1376 for (int i = 0; i < nFields; i++)
1377 {
1378 Vmath::Vcopy(nTracePts, Bwd[i], 1, plusBwd[i], 1);
1379 }
1380
1381 for (int i = 0; i < nFields; i++)
1382 {
1384 NekDouble oepsvar = 1.0 / epsvar;
1385
1386 Vmath::Sadd(nTracePts, epsvar, Bwd[i], 1, plusBwd[i], 1);
1387
1388 for (int j = 0; j < nFields; j++)
1389 {
1390 m_fields[j]->FillBwdWithBoundCond(Fwd[j], plusBwd[j]);
1391 }
1392
1393 CalcTraceNumericalFlux(nConvectiveFields, nDim, npoints, nTracePts,
1394 PenaltyFactor2, fields, AdvVel, inarray, time,
1395 qfield, Fwd, plusBwd, qFwd, qBwd, MuVarTrace,
1396 nonZeroIndex, plusflux);
1397
1398 for (int n = 0; n < nFields; n++)
1399 {
1400 Vmath::Vsub(nTracePts, plusflux[n], 1, numflux[n], 1, Jacvect[n],
1401 1);
1402 Vmath::Smul(nTracePts, oepsvar, Jacvect[n], 1, Jacvect[n], 1);
1403 }
1404 for (int j = 0; j < nTracePts; j++)
1405 {
1406 tmpMatData = BJac->GetBlock(j, j)->GetPtr();
1407 for (int n = 0; n < nFields; n++)
1408 {
1409 tmpMatData[n + i * nFields] = DataType(Jacvect[n][j]);
1410 }
1411 }
1412
1413 Vmath::Vcopy(nTracePts, Bwd[i], 1, plusBwd[i], 1);
1414 }
1415}
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)
Definition: CompressibleFlowSystemImplicit.cpp:1417
std::vector< CFSBndCondSharedPtr > m_bndConds
Definition: CompressibleFlowSystem.h:101
SOLVER_UTILS_EXPORT int GetNpoints()
Definition: EquationSystem.h:774
std::shared_ptr< AssemblyMapDG > AssemblyMapDGSharedPtr
Definition: AssemblyMapDG.h:46
static Array< OneD, NekDouble > NullNekDouble1DArray
Definition: SharedArray.hpp:888
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()
|
protected |
Definition at line 1878 of file CompressibleFlowSystemImplicit.cpp.
1883{
1884 Array<OneD, NekDouble> FJacData = FJac->GetPtr();
1885 const int nvariables3D = 5;
1886
1887 NekDouble ro, vx, vy, vz, ps, gama, ae;
1888 NekDouble a, a2, h, h0, v2, vn, eps, eps2;
1889 NekDouble nx, ny, nz;
1890 NekDouble sn, osn, nxa, nya, nza, vna;
1891 NekDouble l1, l4, l5, al1, al4, al5, x1, x2, x3, y1;
1892 NekDouble c1, d1, c2, d2, c3, d3, c4, d4, c5, d5;
1893 NekDouble sml_ssf = 1.0E-12;
1894
1896
1897 NekDouble rhoL = Fwd[0];
1898 NekDouble rhouL = Fwd[1];
1899 NekDouble rhovL = Fwd[2];
1900 NekDouble rhowL = Fwd[3];
1901 NekDouble EL = Fwd[4];
1902
1903 ro = rhoL;
1904 vx = rhouL / rhoL;
1905 vy = rhovL / rhoL;
1906 vz = rhowL / rhoL;
1907
1908 // Internal energy (per unit mass)
1909 NekDouble eL = (EL - 0.5 * (rhouL * vx + rhovL * vy + rhowL * vz)) / rhoL;
1910
1911 ps = m_varConv->Geteos()->GetPressure(rhoL, eL);
1912 gama = m_gamma;
1913
1914 ae = gama - 1.0;
1915 v2 = vx * vx + vy * vy + vz * vz;
1916 a2 = gama * ps / ro;
1917 h = a2 / ae;
1918
1919 h0 = h + 0.5 * v2;
1920 a = sqrt(a2);
1921
1922 nx = normals[0];
1923 ny = normals[1];
1924 nz = normals[2];
1925 vn = nx * vx + ny * vy + nz * vz;
1926 sn = std::max(sqrt(nx * nx + ny * ny + nz * nz), sml_ssf);
1927 osn = 1.0 / sn;
1928
1929 nxa = nx * osn;
1930 nya = ny * osn;
1931 nza = nz * osn;
1932 vna = vn * osn;
1933 l1 = vn;
1934 l4 = vn + sn * a;
1935 l5 = vn - sn * a;
1936
1937 eps = efix * sn;
1938 eps2 = eps * eps;
1939
1940 al1 = sqrt(l1 * l1 + eps2);
1941 al4 = sqrt(l4 * l4 + eps2);
1942 al5 = sqrt(l5 * l5 + eps2);
1943
1944 l1 = 0.5 * (fExactorSplt * l1 + fsw * al1);
1945 l4 = 0.5 * (fExactorSplt * l4 + fsw * al4);
1946 l5 = 0.5 * (fExactorSplt * l5 + fsw * al5);
1947
1948 x1 = 0.5 * (l4 + l5);
1949 x2 = 0.5 * (l4 - l5);
1950 x3 = x1 - l1;
1951 y1 = 0.5 * v2;
1952 c1 = ae * x3 / a2;
1953 d1 = x2 / a;
1954
1955 int nVar0 = 0;
1956 int nVar1 = nvariables3D;
1957 int nVar2 = 2 * nvariables3D;
1958 int nVar3 = 3 * nvariables3D;
1959 int nVar4 = 4 * nvariables3D;
1960 FJacData[nVar0] = c1 * y1 - d1 * vna + l1;
1961 FJacData[nVar1] = -c1 * vx + d1 * nxa;
1962 FJacData[nVar2] = -c1 * vy + d1 * nya;
1963 FJacData[nVar3] = -c1 * vz + d1 * nza;
1964 FJacData[nVar4] = c1;
1965 c2 = c1 * vx + d1 * nxa * ae;
1966 d2 = x3 * nxa + d1 * vx;
1967 FJacData[1 + nVar0] = c2 * y1 - d2 * vna;
1968 FJacData[1 + nVar1] = -c2 * vx + d2 * nxa + l1;
1969 FJacData[1 + nVar2] = -c2 * vy + d2 * nya;
1970 FJacData[1 + nVar3] = -c2 * vz + d2 * nza;
1971 FJacData[1 + nVar4] = c2;
1972 c3 = c1 * vy + d1 * nya * ae;
1973 d3 = x3 * nya + d1 * vy;
1974 FJacData[2 + nVar0] = c3 * y1 - d3 * vna;
1975 FJacData[2 + nVar1] = -c3 * vx + d3 * nxa;
1976 FJacData[2 + nVar2] = -c3 * vy + d3 * nya + l1;
1977 FJacData[2 + nVar3] = -c3 * vz + d3 * nza;
1978 FJacData[2 + nVar4] = c3;
1979 c4 = c1 * vz + d1 * nza * ae;
1980 d4 = x3 * nza + d1 * vz;
1981 FJacData[3 + nVar0] = c4 * y1 - d4 * vna;
1982 FJacData[3 + nVar1] = -c4 * vx + d4 * nxa;
1983 FJacData[3 + nVar2] = -c4 * vy + d4 * nya;
1984 FJacData[3 + nVar3] = -c4 * vz + d4 * nza + l1;
1985 FJacData[3 + nVar4] = c4;
1986 c5 = c1 * h0 + d1 * vna * ae;
1987 d5 = x3 * vna + d1 * h0;
1988 FJacData[4 + nVar0] = c5 * y1 - d5 * vna;
1989 FJacData[4 + nVar1] = -c5 * vx + d5 * nxa;
1990 FJacData[4 + nVar2] = -c5 * vy + d5 * nya;
1991 FJacData[4 + nVar3] = -c5 * vz + d5 * nza;
1992 FJacData[4 + nVar4] = c5 + l1;
1993}
VariableConverterSharedPtr m_varConv
Definition: CompressibleFlowSystem.h:98
References tinysimd::abs(), Nektar::CompressibleFlowSystem::m_gamma, Nektar::CompressibleFlowSystem::m_varConv, and tinysimd::sqrt().
Referenced by GetFluxVectorJacPoint().
◆ PreconCoeff()
|
protected |
Definition at line 538 of file CompressibleFlowSystemImplicit.cpp.
541{
542 LibUtilities::Timer timer, Gtimer;
543
544 Gtimer.Start();
546 m_TimeIntegLambda))
547 {
550 Array<OneD, Array<OneD, NekDouble>> intmp(nvariables);
551 for (int i = 0; i < nvariables; i++)
552 {
553 intmp[i] = Array<OneD, NekDouble>(nphspnt, 0.0);
554 }
555
556 timer.Start();
558 timer.Stop();
559 timer.AccumulateRegion("CompressibleFlowSystem::DoOdeProjection", 1);
560
561 timer.Start();
563 m_TimeIntegLambda);
564 timer.Stop();
565 timer.AccumulateRegion("PreconCfsOp::BuildPreconCfs", 1);
566 }
567
568 timer.Start();
570 timer.Stop();
571 timer.AccumulateRegion("PreconCfsOp::DoPreconCfs", 1);
572
573 Gtimer.Stop();
574 Gtimer.AccumulateRegion("CFSImplicit::PreconCoeff");
575}
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 >
|
protected |
Definition at line 1807 of file CompressibleFlowSystemImplicit.cpp.
1809{
1810 Array<OneD, unsigned int> rowSizes;
1811 Array<OneD, unsigned int> colSizes;
1812 BlkMat->GetBlockSizes(rowSizes, colSizes);
1813 int nDiagBlks = rowSizes.size();
1814 int nvar0 = rowSizes[1] - rowSizes[0];
1815 int nvar1 = colSizes[1] - colSizes[0];
1816
1817 Array<OneD, DataType> ElmtMatData;
1818
1819 for (int i = 0; i < nDiagBlks; i++)
1820 {
1821 ElmtMatData = BlkMat->GetBlock(i, i)->GetPtr();
1822 for (int n = 0; n < nvar1; n++)
1823 {
1824 int noffset = n * nvar0;
1825 for (int m = 0; m < nvar0; m++)
1826 {
1827 MatArray[m][n][i] = ElmtMatData[m + noffset];
1828 }
1829 }
1830 }
1831}
Referenced by TransTraceJacMatToArray().
◆ TransTraceJacMatToArray()
template<typename DataType , typename TypeNekBlkMatSharedPtr >
|
protected |
Definition at line 1638 of file CompressibleFlowSystemImplicit.cpp.
1641{
1642 int nFwdBwd, nDiagBlks, nvar0Jac, nvar1Jac;
1643
1644 Array<OneD, unsigned int> rowSizes;
1645 Array<OneD, unsigned int> colSizes;
1646 nFwdBwd = TraceJac.size();
1647 TraceJac[0]->GetBlockSizes(rowSizes, colSizes);
1648 nDiagBlks = rowSizes.size();
1649 nvar0Jac = rowSizes[1] - rowSizes[0];
1650 nvar1Jac = colSizes[1] - colSizes[0];
1651
1652 if (0 == TraceJacArray.size())
1653 {
1654 TraceJacArray = TensorOfArray4D<DataType>(nFwdBwd);
1655 for (int nlr = 0; nlr < nFwdBwd; nlr++)
1656 {
1657 TraceJacArray[nlr] = TensorOfArray3D<DataType>(nvar0Jac);
1658 for (int m = 0; m < nvar0Jac; m++)
1659 {
1660 TraceJacArray[nlr][m] =
1661 Array<OneD, Array<OneD, DataType>>(nvar1Jac);
1662 for (int n = 0; n < nvar1Jac; n++)
1663 {
1664 TraceJacArray[nlr][m][n] = Array<OneD, DataType>(nDiagBlks);
1665 }
1666 }
1667 }
1668 }
1669
1670 for (int nlr = 0; nlr < nFwdBwd; nlr++)
1671 {
1672 const TypeNekBlkMatSharedPtr tmpMat = TraceJac[nlr];
1673 TensorOfArray3D<DataType> tmpaa = TraceJacArray[nlr];
1674 TranSamesizeBlkDiagMatIntoArray(tmpMat, tmpaa);
1675 }
1676
1677 return;
1678}
void TranSamesizeBlkDiagMatIntoArray(const TypeNekBlkMatSharedPtr &BlkMat, TensorOfArray3D< DataType > &MatArray)
Definition: CompressibleFlowSystemImplicit.cpp:1807
References TranSamesizeBlkDiagMatIntoArray().
Referenced by CalcPreconMatBRJCoeff().
◆ v_CalcMuDmuDT()
|
inlineprotectedvirtual |
Reimplemented in Nektar::NavierStokesImplicitCFE.
Definition at line 348 of file CompressibleFlowSystemImplicit.h.
353 {
354 }
Referenced by CalcMuDmuDT().
◆ v_CalcPhysDeriv()
|
inlineprotectedvirtual |
Reimplemented in Nektar::NavierStokesImplicitCFE.
Definition at line 356 of file CompressibleFlowSystemImplicit.h.
360 {
361 }
Referenced by CalcPhysDeriv().
◆ v_DoDiffusionCoeff()
|
inlineprotectedvirtual |
Reimplemented in Nektar::NavierStokesImplicitCFE.
Definition at line 339 of file CompressibleFlowSystemImplicit.h.
345 {
346 }
Referenced by DoDiffusionCoeff().
◆ v_DoSolve()
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 172 of file CompressibleFlowSystemImplicit.cpp.
173{
174 m_TotNewtonIts = 0;
175 m_TotLinIts = 0;
176 m_TotImpStages = 0;
177 UnsteadySystem::v_DoSolve();
178}
SOLVER_UTILS_EXPORT void v_DoSolve() override
Solves an unsteady problem.
Definition: UnsteadySystem.cpp:210
References m_TotImpStages, m_TotLinIts, m_TotNewtonIts, and Nektar::SolverUtils::UnsteadySystem::v_DoSolve().
◆ v_GetFluxDerivJacDirctn() [1/2]
|
protectedvirtual |
Reimplemented in Nektar::NavierStokesImplicitCFE.
◆ v_GetFluxDerivJacDirctn() [2/2]
|
protectedvirtual |
Reimplemented in Nektar::NavierStokesImplicitCFE.
Definition at line 1680 of file CompressibleFlowSystemImplicit.cpp.
References Nektar::ErrorUtil::efatal, and NEKERROR.
Referenced by GetFluxDerivJacDirctn().
◆ v_GetFluxDerivJacDirctnElmt()
|
protectedvirtual |
Reimplemented in Nektar::NavierStokesImplicitCFE.
Definition at line 1691 of file CompressibleFlowSystemImplicit.cpp.
References Nektar::ErrorUtil::efatal, and NEKERROR.
Referenced by GetFluxDerivJacDirctnElmt().
◆ v_InitObject()
|
overrideprotectedvirtual |
Initialization object for CFSImplicit class.
Reimplemented from Nektar::CompressibleFlowSystem.
Reimplemented in Nektar::EulerImplicitCFE, and Nektar::NavierStokesImplicitCFE.
Definition at line 53 of file CompressibleFlowSystemImplicit.cpp.
54{
55 CompressibleFlowSystem::v_InitObject(DeclareFields);
58
59 // Initialise implicit parameters
62
64
66
68 1.0E-12);
70 "Please specify NewtonRelativeIteTol instead of "
71 "NewtonAbsoluteIteTol in XML session file");
72
73 int ntmp;
75 m_advectionJacFlag = (ntmp != 0);
76
78 m_viscousJacFlag = (ntmp != 0);
79
80 // Initialise implicit functors
83
85}
void DoOdeImplicitRhs(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
Definition: CompressibleFlowSystemImplicit.cpp:267
bool m_flagImplicitItsStatistics
Definition: CompressibleFlowSystemImplicit.h:58
void DoImplicitSolve(const Array< OneD, const Array< OneD, NekDouble > > &inpnts, Array< OneD, Array< OneD, NekDouble > > &outpnt, const NekDouble time, const NekDouble lambda)
Definition: CompressibleFlowSystemImplicit.cpp:404
void InitialiseNonlinSysSolver()
Definition: CompressibleFlowSystemImplicit.cpp:87
void v_InitObject(bool DeclareFields=true) override
Initialization object for CompressibleFlowSystem class.
Definition: CompressibleFlowSystem.cpp:53
void DefineOdeRhs(FuncPointerT func, ObjectPointerT obj)
Definition: TimeIntegrationSchemeOperators.h:84
void DefineImplicitSolve(FuncPointerT func, ObjectPointerT obj)
Definition: TimeIntegrationSchemeOperators.h:100
LibUtilities::TimeIntegrationSchemeOperators m_ode
The time integration scheme operators to use.
Definition: UnsteadySystem.h:88
bool m_explicitAdvection
Indicates if explicit or implicit treatment of advection is used.
Definition: UnsteadySystem.h:108
bool m_explicitDiffusion
Indicates if explicit or implicit treatment of diffusion is used.
Definition: UnsteadySystem.h:106
References Nektar::LibUtilities::TimeIntegrationSchemeOperators::DefineImplicitSolve(), Nektar::LibUtilities::TimeIntegrationSchemeOperators::DefineOdeRhs(), DoImplicitSolve(), DoOdeImplicitRhs(), InitialiseNonlinSysSolver(), m_advectionJacFlag, Nektar::SolverUtils::UnsteadySystem::m_explicitAdvection, Nektar::SolverUtils::UnsteadySystem::m_explicitDiffusion, m_flagImplicitItsStatistics, m_jacobiFreeEps, m_newtonRelativeIteTol, m_nPadding, Nektar::SolverUtils::UnsteadySystem::m_ode, Nektar::SolverUtils::EquationSystem::m_session, m_viscousJacFlag, Nektar::CompressibleFlowSystem::v_InitObject(), and WARNINGL0.
Referenced by Nektar::EulerImplicitCFE::v_InitObject(), and Nektar::NavierStokesImplicitCFE::v_InitObject().
◆ v_MinusDiffusionFluxJacPoint()
|
protectedvirtual |
Reimplemented in Nektar::NavierStokesImplicitCFE.
Definition at line 1535 of file CompressibleFlowSystemImplicit.cpp.
1545{
1546 // Do nothing by default
1547}
Referenced by MinusDiffusionFluxJacPoint().
◆ v_PrintStatusInformation()
|
overrideprotectedvirtual |
Print Status Information.
Reimplemented from Nektar::SolverUtils::UnsteadySystem.
Definition at line 180 of file CompressibleFlowSystemImplicit.cpp.
182{
183 UnsteadySystem::v_PrintStatusInformation(step, cpuTime);
184
187 {
188 cout << " &&"
192 }
193}
int m_infosteps
Number of time steps between outputting status information.
Definition: EquationSystem.h:390
virtual SOLVER_UTILS_EXPORT void v_PrintStatusInformation(const int step, const NekDouble cpuTime)
Print Status Information.
Definition: UnsteadySystem.cpp:543
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()
|
overrideprotectedvirtual |
Print Summary Statistics.
Reimplemented from Nektar::SolverUtils::UnsteadySystem.
Definition at line 195 of file CompressibleFlowSystemImplicit.cpp.
196{
197 UnsteadySystem::v_PrintSummaryStatistics(intTime);
198
200 {
201 cout << "-------------------------------------------" << endl
205 << "-------------------------------------------" << endl;
206 }
207}
virtual SOLVER_UTILS_EXPORT void v_PrintSummaryStatistics(const NekDouble intTime)
Print Summary Statistics.
Definition: UnsteadySystem.cpp:572
References m_flagImplicitItsStatistics, Nektar::SolverUtils::EquationSystem::m_session, m_TotImpStages, m_TotLinIts, m_TotNewtonIts, and Nektar::SolverUtils::UnsteadySystem::v_PrintSummaryStatistics().
◆ v_UpdateTimeStepCheck()
|
overrideprotectedvirtual |
Reimplemented from Nektar::SolverUtils::UnsteadySystem.
Definition at line 1995 of file CompressibleFlowSystemImplicit.cpp.
1996{
1997 bool flag =
2001 m_TimeIntegLambda);
2002}
NekDouble m_lastCheckTime
Definition: EquationSystem.h:379
References Nektar::SolverUtils::EquationSystem::m_checktime, Nektar::SolverUtils::EquationSystem::m_fintime, Nektar::SolverUtils::EquationSystem::m_lastCheckTime, m_preconCfs, Nektar::SolverUtils::EquationSystem::m_time, m_TimeIntegLambda, Nektar::SolverUtils::EquationSystem::m_timestep, and Nektar::NullNekDouble1DArray.
Member Data Documentation
◆ m_advectionJacFlag
|
protected |
Definition at line 57 of file CompressibleFlowSystemImplicit.h.
Referenced by AddMatNSBlkDiagVol(), CalcTraceNumericalFlux(), and v_InitObject().
◆ m_flagImplicitItsStatistics
|
protected |
Definition at line 58 of file CompressibleFlowSystemImplicit.h.
Referenced by v_InitObject(), v_PrintStatusInformation(), and v_PrintSummaryStatistics().
◆ m_inArrayNorm
|
protected |
Definition at line 75 of file CompressibleFlowSystemImplicit.h.
Referenced by CalcRefValues(), DoImplicitSolveCoeff(), and MatrixMultiplyMatrixFreeCoeff().
◆ m_jacobiFreeEps
|
protected |
Definition at line 76 of file CompressibleFlowSystemImplicit.h.
Referenced by MatrixMultiplyMatrixFreeCoeff(), and v_InitObject().
◆ m_magnitdEstimat
Estimate the magnitude of each conserved varibles.
Definition at line 68 of file CompressibleFlowSystemImplicit.h.
Referenced by CalcRefValues(), and NumCalcRiemFluxJac().
◆ m_newtonRelativeIteTol
|
protected |
Definition at line 77 of file CompressibleFlowSystemImplicit.h.
Referenced by DoImplicitSolveCoeff(), and v_InitObject().
◆ m_nonlinsol
|
protected |
Definition at line 82 of file CompressibleFlowSystemImplicit.h.
Referenced by DoImplicitSolveCoeff(), InitialiseNonlinSysSolver(), MatrixMultiplyMatrixFreeCoeff(), and NonlinSysEvaluatorCoeff().
◆ m_nPadding
|
protected |
Definition at line 60 of file CompressibleFlowSystemImplicit.h.
Referenced by AddMatNSBlkDiagVol(), CalcVolJacStdMat(), and v_InitObject().
◆ m_preconCfs
|
protected |
Definition at line 84 of file CompressibleFlowSystemImplicit.h.
Referenced by InitialiseNonlinSysSolver(), PreconCoeff(), and v_UpdateTimeStepCheck().
◆ m_solutionPhys
Definition at line 70 of file CompressibleFlowSystemImplicit.h.
Referenced by DoImplicitSolveCoeff(), and PreconCoeff().
◆ m_stdSMatDataDBB
|
protected |
Definition at line 79 of file CompressibleFlowSystemImplicit.h.
Referenced by CalcPreconMatBRJCoeff().
◆ m_stdSMatDataDBDB
|
protected |
Definition at line 80 of file CompressibleFlowSystemImplicit.h.
Referenced by CalcPreconMatBRJCoeff().
◆ m_TimeIntegLambda
|
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 74 of file CompressibleFlowSystemImplicit.h.
Referenced by CalcPreconMatBRJCoeff(), DoImplicitSolveCoeff(), NonlinSysEvaluatorCoeff(), PreconCoeff(), and v_UpdateTimeStepCheck().
◆ m_TotImpStages
|
protected |
Definition at line 65 of file CompressibleFlowSystemImplicit.h.
Referenced by DoImplicitSolveCoeff(), v_DoSolve(), v_PrintStatusInformation(), and v_PrintSummaryStatistics().
◆ m_TotLinIts
|
protected |
Definition at line 64 of file CompressibleFlowSystemImplicit.h.
Referenced by DoImplicitSolveCoeff(), v_DoSolve(), v_PrintStatusInformation(), and v_PrintSummaryStatistics().
◆ m_TotNewtonIts
|
protected |
Definition at line 63 of file CompressibleFlowSystemImplicit.h.
Referenced by DoImplicitSolveCoeff(), v_DoSolve(), v_PrintStatusInformation(), and v_PrintSummaryStatistics().
◆ m_updateShockCaptPhys
|
protected |
Definition at line 89 of file CompressibleFlowSystemImplicit.h.
Referenced by DoImplicitSolve(), and Nektar::NavierStokesImplicitCFE::v_DoDiffusionCoeff().
◆ m_viscousJacFlag
|
protected |
Definition at line 56 of file CompressibleFlowSystemImplicit.h.
Referenced by AddMatNSBlkDiagVol(), CalcPreconMatBRJCoeff(), CalcTraceNumericalFlux(), NumCalcRiemFluxJac(), v_InitObject(), and Nektar::EulerImplicitCFE::v_InitObject().
