Euler Module¶

Compressible Navier-Stokes solvers (2D/3D, SA, k-omega RANS).

Namespace Overview¶

namespace Euler

Typedefs

using tCellScalarFGet = std::function<real(index)>

using tCellScalarList = std::vector<std::tuple<std::string, const tCellScalarFGet>>

Enums

enum EulerModel

Values:

enumerator NS

enumerator NS_SA

enumerator NS_2D

enumerator NS_3D

enumerator NS_SA_3D

enumerator NS_2EQ

enumerator NS_2EQ_3D

enumerator NS_EX

enumerator NS_EX_3D

enum RANSModel

Values:

enumerator RANS_Unknown

enumerator RANS_None

enumerator RANS_SA

enumerator RANS_KOWilcox

enumerator RANS_KOSST

enumerator RANS_RKE

enum EulerBCType

Values:

enumerator BCUnknown

enumerator BCFar

enumerator BCWall

enumerator BCWallInvis

enumerator BCWallIsothermal

enumerator BCOut

enumerator BCOutP

enumerator BCIn

enumerator BCInPsTs

enumerator BCSym

enumerator BCSpecial

Functions

DNDS_DEFINE_ENUM_JSON (RANSModel, { {RANS_Unknown, nullptr}, {RANS_None, "RANS_None"}, {RANS_SA, "RANS_SA"}, {RANS_KOWilcox, "RANS_KOWilcox"}, {RANS_KOSST, "RANS_KOSST"}, {RANS_RKE, "RANS_RKE"}, }) const expr static inline int getnVarsFixed(const EulerModel model)

static inline constexpr int getNVars(EulerModel model)

static inline constexpr int getDim_Fixed(const EulerModel model)

static inline constexpr int getGeomDim_Fixed(const EulerModel model)

template<int nVarsFixed, int mul> static inline constexpr int nvarsFixedMultiply()

DNDS_DEFINE_ENUM_JSON (EulerBCType, { {BCUnknown, nullptr}, {BCFar, "BCFar"}, {BCWall, "BCWall"}, {BCWallIsothermal, "BCWallIsothermal"}, {BCWallInvis, "BCWallInvis"}, {BCOut, "BCOut"}, {BCOutP, "BCOutP"}, {BCIn, "BCIn"}, {BCInPsTs, "BCInPsTs"}, {BCSym, "BCSym"}, {BCSpecial, "BCSpecial"}, }) inline std

inline nlohmann::ordered_json bcSettingsSchema()

DNDS_SWITCH_INTELLISENSE (template< EulerModel model >,) void EulerEvaluator< model >

DNDS_SWITCH_INTELLISENSE (template< EulerModel model >, template<>) void EulerEvaluator< model >

void paste_read_restart_with_cell_ordering(EulerSolver<model> &self, typename EulerSolver<model>::TDof &u, typename EulerSolver<model>::TDof &uRead, Serializer::SerializerBaseSSP serializerP)

static inline constexpr const char *getSingleBlockAppName(const EulerModel model)

template<EulerModel model> int RunSingleBlockConsoleApp(int argc, char *argv[])

Variables

static const auto model = NS_SA

static const auto model = NS_SA

static const auto model = NS_SA

static const auto model = NS_SA

static const auto model = NS_SA

static const auto model = NS

template<int nVarsFixed> struct AnchorPointRecorder

Public Types

using TU = Eigen::Vector<real, nVarsFixed>

Public Functions

inline AnchorPointRecorder(const MPIInfo &_mpi)

inline void Reset()

inline void AddAnchor(const TU &vin, real nDist)

inline void ObtainAnchorMPI()

Public Members

MPIInfo mpi

TU val

real dist = {veryLargeReal}

template<int nVarsFixed> class ArrayDOFV : public DNDS::ArrayDof<nVarsFixed>

Public Types

using t_self = ArrayDOFV<nVarsFixed>

using t_base = CFV::tUDof<nVarsFixed>

using t_element_mat = typename t_base::t_element_mat

Public Functions

inline void setConstant(real R)

inline void setConstant(const Eigen::Ref<const t_element_mat> &R)

inline void operator+=(const t_self &R)

inline void operator-=(const t_self &R)

inline void operator*=(real R)

inline void operator=(const t_self &R)

inline void addTo(const t_self &R, real r)

inline void operator*=(const std::vector<real> &R)

template<int nVarsFixed_T = nVarsFixed> inline std::enable_if_t<!(nVarsFixed_T == 1)> operator*=(const ArrayDOFV<1> &R)

inline void operator+=(const Eigen::Vector<real, nVarsFixed> &R)

inline void operator+=(real R)

inline void operator*=(const Eigen::Vector<real, nVarsFixed> &R)

inline void operator*=(const t_self &R)

inline void operator/=(const t_self &R)

inline real norm2()

inline Eigen::Vector<real, nVarsFixed> componentWiseNorm1()

inline Eigen::Vector<real, nVarsFixed> min()

inline real dot(const t_self &R)

template<class TMultL, class TMultR> inline real dot(const t_self &R, TMultL &&mL, TMultR &&mR)

template<class TR> inline void setMaxWith(TR R)

template<int nVarsFixed, int gDim> class ArrayGRADV : public DNDS::ArrayDof<nVarsFixed, gDim>

Public Types

using t_self = ArrayGRADV<nVarsFixed, gDim>

using t_base = CFV::tUGrad<nVarsFixed, gDim>

Public Functions

inline void setConstant(real R)

template<class TR> inline void setConstant(const TR &R)

inline void operator+=(t_self &R)

inline void operator-=(t_self &R)

inline void operator*=(real R)

inline void operator*=(std::vector<real> &R)

inline void operator*=(ArrayDOFV<1> &R)

inline void operator*=(const Eigen::Array<real, 1, nVarsFixed> &R)

inline void operator=(t_self &R)

template<int nVarsFixed> class ArrayRECV : public DNDS::ArrayDof<nVarsFixed>

Public Types

using t_self = ArrayRECV<nVarsFixed>

using t_base = CFV::tURec<nVarsFixed>

Public Functions

inline void setConstant(real R)

template<class TR> inline void setConstant(const TR &R)

inline void operator+=(const t_self &R)

inline void operator-=(const t_self &R)

inline void operator*=(real R)

inline void operator*=(const std::vector<real> &R)

inline void operator*=(const ArrayDOFV<1> &R)

inline void operator*=(const Eigen::Array<real, 1, nVarsFixed> &R)

inline void operator=(const t_self &R)

inline void addTo(const t_self &R, const Eigen::Array<real, 1, nVarsFixed> &r)

inline void addTo(const t_self &R, real r)

inline real norm2()

inline real dot(const t_self &R)

inline auto dotV(const t_self &R)

template<EulerModel model> class BoundaryHandler

Public Types

using TU_R = Eigen::Vector<real, nVarsFixed>

using TU = Eigen::VectorFMTSafe<real, nVarsFixed>

using TFlags = std::map<std::string, uint32_t>

Public Functions

inline BoundaryHandler(int _nVars)

inline std::vector<std::string> GetAllNames()

inline Geom::t_index size()

inline void RenewID2name()

inline void PushBCWithJson(const json &gS)

inline Geom::t_index GetIDFromName(const std::string &name)

inline auto GetNameFormID(Geom::t_index id)

inline EulerBCType GetTypeFromID(Geom::t_index id)

inline TU GetValueFromID(Geom::t_index id)

inline Eigen::Vector<real, Eigen::Dynamic> GetValueExtraFromID(Geom::t_index id)

inline uint32_t GetFlagFromID(Geom::t_index id, const std::string &key)

inline uint32_t GetFlagFromIDSoft(Geom::t_index id, const std::string &key)

Public Static Attributes

static const int nVarsFixed = getnVarsFixed(model)

Friends

inline friend void from_json(const json &j, BoundaryHandler<model> &bc)

inline friend void to_json(json &j, const BoundaryHandler<model> &bc)

class CLDriver

Public Functions

inline CLDriver(const CLDriverSettings &settingsIn)

inline real GetAOA()

inline void Update(index iter, real CL, const MPIInfo &mpi)

inline bool ConvergedAtTarget()

inline Geom::tGPoint GetAOARotation()

inline Geom::tPoint GetCL0Direction()

inline Geom::tPoint GetCD0Direction()

inline real GetForce2CoeffRatio()

struct CLDriverSettings

Public Members

real AOAInit = 0.0

std::string AOAAxis = "z"

std::string CL0Axis = "y"

std::string CD0Axis = "x"

real refArea = 1.0

real refDynamicPressure = 0.5

real targetCL = 0.0

real CLIncrementRelax = 0.25

real thresholdTargetRatio = 0.5

index nIterStartDrive = INT32_MAX

index nIterConvergeMin = 50

real CLconvergeThreshold = 1e-3

index CLconvergeWindow = 10

index CLconvergeLongWindow = 100

real CLconvergeLongThreshold = 1e-4

bool CLconvergeLongStrictAoA = false

template<EulerModel model = NS> class EulerEvaluator

RHS evaluation flags (bitwise OR combinable)

static const uint64_t RHS_No_Flags = 0x0ull

static const uint64_t RHS_Ignore_Viscosity = 0x1ull << 0

static const uint64_t RHS_Dont_Update_Integration = 0x1ull << 1

static const uint64_t RHS_Dont_Record_Bud_Flux = 0x1ull << 2

static const uint64_t RHS_Direct_2nd_Rec = 0x1ull << 8

static const uint64_t RHS_Direct_2nd_Rec_1st_Conv = 0x1ull << 9

static const uint64_t RHS_Direct_2nd_Rec_use_limiter = 0x1ull << 10

static const uint64_t RHS_Direct_2nd_Rec_already_have_uGradBufNoLim = 0x1ull << 11

static const uint64_t RHS_Recover_IncFScale = 0x1ull << 12

Limiter flags

static const uint64_t LIMITER_UGRAD_No_Flags = 0x0ull

static const uint64_t LIMITER_UGRAD_Disable_Shock_Limiter = 0x1ull << 0

Public Types

using Traits = EulerModelTraits<model>

typedef Eigen::VectorFMTSafe<real, dim> TVec

typedef Eigen::MatrixFMTSafe<real, dim, Eigen::Dynamic, Eigen::ColMajor, dim, MaxBatch> TVec_Batch

typedef Eigen::MatrixFMTSafe<real, dim, dim> TMat

typedef Eigen::MatrixFMTSafe<real, dim, Eigen::Dynamic, Eigen::ColMajor, dim, MaxBatchMult(3)> TMat_Batch

typedef Eigen::VectorFMTSafe<real, nVarsFixed> TU

typedef Eigen::MatrixFMTSafe<real, nVarsFixed, Eigen::Dynamic, Eigen::ColMajor, nVarsFixed, MaxBatch> TU_Batch

typedef Eigen::MatrixFMTSafe<real, 1, Eigen::Dynamic, Eigen::RowMajor, 1, MaxBatch> TReal_Batch

typedef Eigen::MatrixFMTSafe<real, nVarsFixed, nVarsFixed> TJacobianU

typedef Eigen::MatrixFMTSafe<real, dim, nVarsFixed> TDiffU

typedef Eigen::MatrixFMTSafe<real, Eigen::Dynamic, nVarsFixed, Eigen::ColMajor, MaxBatchMult(3)> TDiffU_Batch

typedef Eigen::MatrixFMTSafe<real, nVarsFixed, dim> TDiffUTransposed

typedef ArrayDOFV<nVarsFixed> TDof

typedef ArrayRECV<nVarsFixed> TRec

typedef ArrayRECV<1> TScalar

typedef CFV::VariationalReconstruction<gDim> TVFV

typedef ssp<CFV::VariationalReconstruction<gDim>> TpVFV

typedef ssp<BoundaryHandler<model>> TpBCHandler

using tFCompareField = std::function<TU(const Geom::tPoint&, real)>

using tFCompareFieldWeight = std::function<real(const Geom::tPoint&, real)>

Public Functions

inline void setPassiveDiscardSource(bool n)

inline int GetAxisSymmetric()

inline EulerEvaluator(const decltype(mesh) &Nmesh, const decltype(vfv) &Nvfv, const decltype(pBCHandler) &npBCHandler, const EulerEvaluatorSettings<model> &nSettings, int n_nVars = getNVars(model))

void GetWallDist()

void EvaluateDt(ArrayDOFV<1> &dt, ArrayDOFV<nVarsFixed> &u, ArrayRECV<nVarsFixed> &uRec, real CFL, real &dtMinall, real MaxDt, bool UseLocaldt, real t, uint64_t flags = DT_No_Flags)

void EvaluateRHS(ArrayDOFV<nVarsFixed> &rhs, JacobianDiagBlock<nVarsFixed> &JSource, ArrayDOFV<nVarsFixed> &u, ArrayRECV<nVarsFixed> &uRecUnlim, ArrayRECV<nVarsFixed> &uRec, ArrayDOFV<1> &uRecBeta, ArrayDOFV<1> &cellRHSAlpha, bool onlyOnHalfAlpha, real t, uint64_t flags = RHS_No_Flags)

void LUSGSMatrixInit(JacobianDiagBlock<nVarsFixed> &JDiag, JacobianDiagBlock<nVarsFixed> &JSource, ArrayDOFV<1> &dTau, real dt, real alphaDiag, ArrayDOFV<nVarsFixed> &u, ArrayRECV<nVarsFixed> &uRec, int jacobianCode, real t)

void LUSGSMatrixVec(real alphaDiag, real t, ArrayDOFV<nVarsFixed> &u, ArrayDOFV<nVarsFixed> &uInc, JacobianDiagBlock<nVarsFixed> &JDiag, ArrayDOFV<nVarsFixed> &AuInc)

void LUSGSMatrixToJacobianLU(real alphaDiag, real t, ArrayDOFV<nVarsFixed> &u, JacobianDiagBlock<nVarsFixed> &JDiag, JacobianLocalLU<nVarsFixed> &jacLU)

void UpdateLUSGSForward(real alphaDiag, real t, ArrayDOFV<nVarsFixed> &rhs, ArrayDOFV<nVarsFixed> &u, ArrayDOFV<nVarsFixed> &uInc, JacobianDiagBlock<nVarsFixed> &JDiag, ArrayDOFV<nVarsFixed> &uIncNew)

void UpdateLUSGSBackward(real alphaDiag, real t, ArrayDOFV<nVarsFixed> &rhs, ArrayDOFV<nVarsFixed> &u, ArrayDOFV<nVarsFixed> &uInc, JacobianDiagBlock<nVarsFixed> &JDiag, ArrayDOFV<nVarsFixed> &uIncNew)

void UpdateSGS(real alphaDiag, real t, ArrayDOFV<nVarsFixed> &rhs, ArrayDOFV<nVarsFixed> &u, ArrayDOFV<nVarsFixed> &uInc, ArrayDOFV<nVarsFixed> &uIncNew, JacobianDiagBlock<nVarsFixed> &JDiag, bool forward, bool gsUpdate, TU &sumInc, bool uIncIsZero = false)

void LUSGSMatrixSolveJacobianLU(real alphaDiag, real t, ArrayDOFV<nVarsFixed> &rhs, ArrayDOFV<nVarsFixed> &u, ArrayDOFV<nVarsFixed> &uInc, ArrayDOFV<nVarsFixed> &uIncNew, ArrayDOFV<nVarsFixed> &bBuf, JacobianDiagBlock<nVarsFixed> &JDiag, JacobianLocalLU<nVarsFixed> &jacLU, bool uIncIsZero, TU &sumInc)

void UpdateSGSWithRec(real alphaDiag, real t, ArrayDOFV<nVarsFixed> &rhs, ArrayDOFV<nVarsFixed> &u, ArrayRECV<nVarsFixed> &uRec, ArrayDOFV<nVarsFixed> &uInc, ArrayRECV<nVarsFixed> &uRecInc, JacobianDiagBlock<nVarsFixed> &JDiag, bool forward, TU &sumInc)

void FixUMaxFilter(ArrayDOFV<nVarsFixed> &u)

void TimeAverageAddition(ArrayDOFV<nVarsFixed> &w, ArrayDOFV<nVarsFixed> &wAveraged, real dt, real &tCur)

void MeanValueCons2Prim(ArrayDOFV<nVarsFixed> &u, ArrayDOFV<nVarsFixed> &w)

void MeanValuePrim2Cons(ArrayDOFV<nVarsFixed> &w, ArrayDOFV<nVarsFixed> &u)

void EvaluateNorm(Eigen::Vector<real, -1> &res, ArrayDOFV<nVarsFixed> &rhs, index P = 1, bool volWise = false, bool average = false)

void EvaluateRecNorm(Eigen::Vector<real, -1> &res, ArrayDOFV<nVarsFixed> &u, ArrayRECV<nVarsFixed> &uRec, index P = 1, bool compare = false, const tFCompareField &FCompareField = [](const Geom::tPoint &p, real t) { return TU::Zero();}, const tFCompareFieldWeight &FCompareFieldWeight = [](const Geom::tPoint &p, real t) { return 1.0;}, real t = 0)

void LimiterUGrad(ArrayDOFV<nVarsFixed> &u, ArrayGRADV<nVarsFixed, gDim> &uGrad, ArrayGRADV<nVarsFixed, gDim> &uGradNew, uint64_t flags = LIMITER_UGRAD_No_Flags)

void EvaluateURecBeta(ArrayDOFV<nVarsFixed> &u, ArrayRECV<nVarsFixed> &uRec, ArrayDOFV<1> &uRecBeta, index &nLim, real &betaMin, int flag)

bool AssertMeanValuePP(ArrayDOFV<nVarsFixed> &u, bool panic)

void EvaluateCellRHSAlpha(ArrayDOFV<nVarsFixed> &u, ArrayRECV<nVarsFixed> &uRec, ArrayDOFV<1> &uRecBeta, ArrayDOFV<nVarsFixed> &res, ArrayDOFV<1> &cellRHSAlpha, index &nLim, real &alphaMin, real relax, int compress = 1, int flag = 0)

void EvaluateCellRHSAlphaExpansion(ArrayDOFV<nVarsFixed> &u, ArrayRECV<nVarsFixed> &uRec, ArrayDOFV<1> &uRecBeta, ArrayDOFV<nVarsFixed> &res, ArrayDOFV<1> &cellRHSAlpha, index &nLim, real alphaMin)

void MinSmoothDTau(ArrayDOFV<1> &dTau, ArrayDOFV<1> &dTauNew)

inline real muEff(const TU &U, real T)

inline real getMuTur(const TU &uMean, const TDiffU &GradUMeanXY, real muRef, real muf, index iFace)

inline void visFluxTurVariable(const TU &UMeanXYC, const TDiffU &DiffUxyPrimC, real muRef, real mufPhy, real muTur, const TVec &uNormC, index iFace, TU &VisFlux)

inline void UFromCell2Face(TU &u, index iFace, index iCell, rowsize if2c)

inline void UFromFace2Cell(TU &u, index iFace, index iCell, rowsize if2c)

inline void UFromOtherCell(TU &u, index iFace, index iCell, index iCellOther, rowsize if2c)

inline void DiffUFromCell2Face(TDiffU &u, index iFace, index iCell, rowsize if2c, bool reverse = false)

void fluxFace(const TU_Batch &ULxy, const TU_Batch &URxy, const TU &ULMeanXy, const TU &URMeanXy, const TDiffU_Batch &DiffUxy, const TDiffU_Batch &DiffUxyPrim, const TVec_Batch &unitNorm, const TVec_Batch &vg, const TVec &unitNormC, const TVec &vgC, TU_Batch &FLfix, TU_Batch &FRfix, TU_Batch &finc, TReal_Batch &lam0V, TReal_Batch &lam123V, TReal_Batch &lam4V, Geom::t_index btype, typename Gas::RiemannSolverType rsType, index iFace, bool ignoreVis)

TU source(const TU &UMeanXy, const TDiffU &DiffUxy, const Geom::tPoint &pPhy, TJacobianU &jacobian, index iCell, index ig, int Mode)

inline auto fluxJacobian0_Right(TU &UR, const TVec &uNorm, Geom::t_index btype)

inline TU fluxJacobian0_Right_Times_du(const TU &U, const TU &UOther, const TVec &n, const TVec &vg, Geom::t_index btype, const TU &dU, real lambdaMain, real lambdaC, real lambdaVis, real lambda0, real lambda123, real lambda4, int useRoeTerm, int incFsign = -1, int omitF = 0)

inline TVec GetFaceVGrid(index iFace, index iG)

inline TVec GetFaceVGrid(index iFace, index iG, const Geom::tPoint &pPhy)

inline TVec GetFaceVGridFromCell(index iFace, index iCell, int if2c, index iG)

inline void TransformVelocityRotatingFrame(TU &U, const Geom::tPoint &pPhysics, int direction)

inline void TransformURotatingFrame(TU &U, const Geom::tPoint &pPhysics, int direction)

inline void TransformURotatingFrame_ABS_VELO(TU &U, const Geom::tPoint &pPhysics, int direction)

inline void updateBCAnchors(ArrayDOFV<nVarsFixed> &u, ArrayRECV<nVarsFixed> &uRec)

void updateBCProfiles(ArrayDOFV<nVarsFixed> &u, ArrayRECV<nVarsFixed> &uRec)

void updateBCProfilesPressureRadialEq()

TU generateBoundaryValue(TU &ULxy, const TU &ULMeanXy, index iCell, index iFace, int iG, const TVec &uNorm, const TMat &normBase, const Geom::tPoint &pPhysics, real t, Geom::t_index btype, bool fixUL = false, int geomMode = 0, int linMode = 0)

inline void PrintBCProfiles(const std::string &name, ArrayDOFV<nVarsFixed> &u, ArrayRECV<nVarsFixed> &uRec)

inline void ConsoleOutputBndIntegrations()

inline void BndIntegrationLogWriteLine(const std::string &name, index step, index stage, index iter)

inline std::tuple<real, real, real> CLDriverGetIntegrationUpdate(index iter)

inline TU CompressRecPart(const TU &umean, const TU &uRecInc, bool &compressed)

inline TU CompressInc(const TU &u, const TU &uInc)

inline void FixIncrement(ArrayDOFV<nVarsFixed> &cx, ArrayDOFV<nVarsFixed> &cxInc, real alpha = 1.0)

inline void AddFixedIncrement(ArrayDOFV<nVarsFixed> &cx, ArrayDOFV<nVarsFixed> &cxInc, real alpha = 1.0)

inline void CentralSmoothResidual(ArrayDOFV<nVarsFixed> &r, ArrayDOFV<nVarsFixed> &rs, ArrayDOFV<nVarsFixed> &rtemp, int nStep = 0)

void InitializeUDOF(ArrayDOFV<nVarsFixed> &u)

void InitializeOutputPicker(OutputPicker &op, OutputOverlapDataRefs dataRefs)

Public Members

ssp<Geom::UnstructuredMesh> mesh

ssp<BoundaryHandler<model>> pBCHandler

int kAv = 0

std::vector<real> lambdaFace

std::vector<real> lambdaFaceC

std::vector<real> lambdaFaceVis

std::vector<real> lambdaFace0

std::vector<real> lambdaFace123

std::vector<real> lambdaFace4

std::vector<real> deltaLambdaFace

ArrayDOFV<1> deltaLambdaCell

std::vector<TDiffU> gradUFix

std::vector<Eigen::Vector<real, Eigen::Dynamic>> dWall

std::vector<real> dWallFace

std::map<Geom::t_index, AnchorPointRecorder<nVarsFixed>> anchorRecorders

std::map<Geom::t_index, OneDimProfile<nVarsFixed>> profileRecorders

std::map<Geom::t_index, IntegrationRecorder> bndIntegrations

std::map<Geom::t_index, std::ofstream> bndIntegrationLogs

std::set<Geom::t_index> cLDriverBndIDs

std::unique_ptr<CLDriver> pCLDriver

ArrayGRADV<nVarsFixed, gDim> uGradBufNoLim

Eigen::Vector<real, -1> fluxWallSum

std::vector<TU> fluxBnd

std::vector<TVec> fluxBndForceT

index nFaceReducedOrder = 0

ssp<Direct::SerialSymLUStructure> symLU

EulerEvaluatorSettings<model> settings

Public Static Functions

static inline constexpr int MaxBatchMult(int n)

static inline void InitializeFV(ssp<Geom::UnstructuredMesh> &mesh, TpVFV vfv, TpBCHandler pBCHandler)

Public Static Attributes

static const int nVarsFixed = getnVarsFixed(model)

static const int dim = getDim_Fixed(model)

static const int gDim = getGeomDim_Fixed(model)

static const auto I4 = dim + 1

static const int MaxBatch = 16

static const uint64_t DT_No_Flags = 0x0ull

static const uint64_t DT_Dont_update_lambda01234 = 0x1ull << 0

static const int EvaluateURecBeta_DEFAULT = 0x00

static const int EvaluateURecBeta_COMPRESS_TO_MEAN = 0x01

static const int EvaluateCellRHSAlpha_DEFAULT = 0x00

static const int EvaluateCellRHSAlpha_MIN_IF_NOT_ONE = 0x01

static const int EvaluateCellRHSAlpha_MIN_ALL = 0x02

struct OutputOverlapDataRefs

Public Members

ArrayDOFV<nVarsFixed> &u

ArrayRECV<nVarsFixed> &uRec

ArrayDOFV<1> &betaPP

ArrayDOFV<1> &alphaPP

template<EulerModel model> struct EulerEvaluatorSettings

Jacobian Options

bool useScalarJacobian = false

bool useRoeJacobian = false

bool noRsOnWall = false

bool noGRPOnWall = false

bool ignoreSourceTerm = false

Reconstruction

int direct2ndRecMethod = 1

int specialBuiltinInitializer = 0

real uRecAlphaCompressPower = 1

real uRecBetaCompressPower = 1

bool forceVolURecBeta = true

bool ppEpsIsRelaxed = false

Riemann Solver Configuration

Gas::RiemannSolverType rsType = Gas::Roe

Gas::RiemannSolverType rsTypeAux = Gas::UnknownRS

Gas::RiemannSolverType rsTypeWall = Gas::UnknownRS

real rsFixScale = 1

real rsIncFScale = 1

int rsMeanValueEig = 0

int rsRotateScheme = 0

Wall-Distance Computation

real minWallDist = 1e-12

int wallDistExection = 0

real wallDistRefineMax = 1

int wallDistScheme = 0

int wallDistCellLoadSize = 1024 * 32

int wallDistIter = 1000

int wallDistLinSolver = 0

real wallDistResTol = 1e-4

int wallDistIterStart = 100

int wallDistPoissonP = 2

real wallDistDTauScale = 100.

int wallDistNJacobiSweep = 10

RANS / DES Configuration

real SADESScale = veryLargeReal

int SADESMode = 1

RANSModel ransModel = RANSModel::RANS_None

int ransUseQCR = 0

int ransSARotCorrection = 1

int ransEigScheme = 0

int ransForce2nd = 0

int ransSource2nd = 0

Viscous Flux and Source Options

int source2nd = 0

int usePrimGradInVisFlux = 0

int useSourceGradFixGG = 0

int nCentralSmoothStep = 0

real centralSmoothEps = 0.5

Eigen::Vector<real, 3> constMassForce = Eigen::Vector<real, 3>{0, 0, 0}

Public Types

using Traits = EulerModelTraits<model>

Public Functions

EulerEvaluatorSettings() = default

inline EulerEvaluatorSettings(int nVars)

inline void finalize()

Public Members

real RANSBottomLimit = 0.01

struct DNDS::Euler::EulerEvaluatorSettings::FrameConstRotation frameConstRotation

CLDriverSettings cLDriverSettings

std::vector<std::string> cLDriverBCNames

Eigen::Vector<real, -1> farFieldStaticValue = Eigen::Vector<real, 5>{1, 0, 0, 0, 2.5}

std::vector<BoxInitializer> boxInitializers

std::vector<PlaneInitializer> planeInitializers

std::vector<ExprtkInitializer> exprtkInitializers

struct DNDS::Euler::EulerEvaluatorSettings::IdealGasProperty idealGasProperty

int _nVars = 0

Eigen::Vector<real, -1> refU

Eigen::Vector<real, -1> refUPrim

Public Static Attributes

static const int nVarsFixed = getnVarsFixed(model)

static const int dim = getDim_Fixed(model)

static const int gDim = getGeomDim_Fixed(model)

static const auto I4 = dim + 1

struct BoxInitializer

Public Members

real z1 = {0}

Eigen::Vector<real, -1> v

struct ExprtkInitializer

Public Functions

inline std::string GetExpr() const

Public Members

std::vector<std::string> exprs

struct FrameConstRotation

Public Functions

inline real Omega()

inline Geom::tPoint vOmega()

inline Geom::tPoint rVec(const Geom::tPoint &r)

inline Geom::tGPoint rtzFrame(const Geom::tPoint &r)

Public Members

bool enabled = false

Geom::tPoint axis = Geom::tPoint{0, 0, 1}

Geom::tPoint center = Geom::tPoint{0, 0, 0}

real rpm = 0

struct IdealGasProperty

Public Functions

inline void recomputeDerived()

Public Members

real gamma = 1.4

real Rgas = 1

real muGas = 1

real prGas = 0.72

real CpGas = Rgas * gamma / (gamma - 1)

real TRef = 273.15

real CSutherland = 110.4

int muModel = 1

struct PlaneInitializer

Public Members

real h = {0}

Eigen::Vector<real, -1> v

template<EulerModel model> struct EulerModelTraits

Public Static Attributes

static constexpr int nVarsFixed = getnVarsFixed(model)

static constexpr int dim = getDim_Fixed(model)

static constexpr int gDim = getGeomDim_Fixed(model)

static constexpr bool hasSA = (model == NS_SA || model == NS_SA_3D)

static constexpr bool has2EQ = (model == NS_2EQ || model == NS_2EQ_3D)

static constexpr bool hasRANS = hasSA || has2EQ

static constexpr int nRANSVars = hasSA ? 1 : (has2EQ ? 2 : 0)

static constexpr bool isExtended = (model == NS_EX || model == NS_EX_3D)

static constexpr bool isPlainNS = !hasRANS && !isExtended

static constexpr bool isGeom2D = (gDim == 2)

static constexpr bool isGeom3D = (gDim == 3)

template<EulerModel model> class EulerSolver

Accessors

inline auto getMPI() const

inline auto getMesh() const

inline auto getVFV() const

Test accessors (for unit testing the evaluator pipeline)

inline auto &getU()

inline auto &getURec()

inline auto &getURecNew()

inline auto &getURecLimited()

inline auto &getEval()

inline auto &getConfiguration()

inline auto &getJSource()

inline auto &getBetaPP()

inline auto &getAlphaPP()

inline auto &getDTauTmp()

inline auto &getIfUseLimiter()

inline auto &getBCHandler()

Public Types

enum PrintDataMode

Values:

enumerator PrintDataLatest

enumerator PrintDataTimeAverage

typedef EulerEvaluator<model> TEval

typedef TEval::TU TU

typedef TEval::TDiffU TDiffU

typedef TEval::TJacobianU TJacobianU

typedef TEval::TVec TVec

typedef TEval::TMat TMat

typedef TEval::TDof TDof

typedef TEval::TRec TRec

typedef TEval::TScalar TScalar

typedef TEval::TVFV TVFV

typedef TEval::TpVFV TpVFV

using tGMRES_u = Linear::GMRES_LeftPreconditioned<TDof>

using tGMRES_uRec = Linear::GMRES_LeftPreconditioned<TRec>

using tPCG_uRec = Linear::PCG_PreconditionedRes<TRec, Eigen::Array<real, 1, Eigen::Dynamic>>

using tAdditionalCellScalarList = tCellScalarList

Public Functions

inline EulerSolver(const MPIInfo &nmpi, int n_nVars = getNVars(model))

inline ~EulerSolver()

inline void ConfigureFromJson(const std::string &jsonName, bool read = false, const std::string &jsonMergeName = "", const std::vector<std::string> &overwriteKeys = {}, const std::vector<std::string> &overwriteValues = {})

void ReadMeshAndInitialize()

inline void PrintConfig(bool updateCommit = false)

void ReadRestart(std::string fname)

void ReadRestartOtherSolver(std::string fname, const std::vector<int> &dimStore)

void PrintRestart(std::string fname)

void PrintData(const std::string &fname, const std::string &fnameSeries, const tCellScalarFGet &odeResidualF, tAdditionalCellScalarList &additionalCellScalars, TEval &eval, real TSimu = -1.0, PrintDataMode mode = PrintDataLatest)

inline void WriteSerializer(Serializer::SerializerBaseSSP serializerP, const std::string &name)

template<class TVal> inline std::enable_if_t<std::is_arithmetic_v<std::remove_reference_t<TVal>>> FillLogValue(tLogSimpleDIValueMap &v_map, const std::string &name, TVal &&val)

template<class TVal> inline std::enable_if_t<!std::is_arithmetic_v<std::remove_reference_t<TVal>>> FillLogValue(tLogSimpleDIValueMap &v_map, const std::string &name, TVal &&val)

inline std::tuple<std::unique_ptr<CsvLog>, tLogSimpleDIValueMap> LogErrInitialize()

void RunImplicitEuler()

void InitializeRunningEnvironment(RunningEnvironment &env)

void solveLinear(real alphaDiag, real t, TDof &cres, TDof &cx, TDof &cxInc, TRec &uRecC, TRec uRecIncC, JacobianDiagBlock<nVarsFixed> &JDC, tGMRES_u &gmres, int gridLevel)

void doPrecondition(real alphaDiag, real t, TDof &crhs, TDof &cx, TDof &cxInc, TDof &uTemp, JacobianDiagBlock<nVarsFixed> &JDC, TU &sgsRes, bool &inputIsZero, bool &hasLUDone, int gridLevel)

bool functor_fstop(int iter, ArrayDOFV<nVarsFixed> &cres, int iStep, RunningEnvironment &env)

bool functor_fmainloop(RunningEnvironment &env)

Public Members

nlohmann::ordered_json gSetting

std::string output_stamp = ""

Public Static Attributes

static const int nVarsFixed = TEval::nVarsFixed

static const int dim = TEval::dim

static const int gDim = TEval::gDim

static const int I4 = TEval::I4

struct Configuration

Public Functions

inline void ReadWriteJson(nlohmann::ordered_json &jsonObj, int nVars, bool read)

Public Members

EulerEvaluatorSettings<model> eulerSettings

CFV::VRSettings vfvSettings

nlohmann::ordered_json bcSettings = nlohmann::ordered_json::array()

std::map<std::string, std::string> bcNameMapping

struct BoundaryDefinition

struct ConvergenceControl

struct DataIOControl

struct ImplicitCFLControl

struct ImplicitReconstructionControl

struct LimiterControl

struct LinearSolverControl

struct CoarseGridLinearSolverControl

struct Others

struct OutputControl

struct RestartState

struct TimeAverageControl

struct TimeMarchControl

struct RunningEnvironment

struct IntegrationRecorder

Public Functions

inline IntegrationRecorder(const MPIInfo &_nmpi, int siz)

inline void Reset()

template<class TU> inline void Add(TU &&add, real dAdd)

inline void Reduce()

Public Members

Eigen::Vector<real, Eigen::Dynamic> v

real div

MPIInfo mpi

template<int nVarsFixed> class JacobianDiagBlock

Public Types

using TU = Eigen::Vector<real, nVarsFixed>

using tComponent = Eigen::Matrix<real, nVarsFixed, nVarsFixed>

using tComponentDiag = Eigen::Vector<real, nVarsFixed>

Public Functions

inline JacobianDiagBlock()

inline void SetModeAndInit(int mode, int nVarsC, ArrayDOFV<nVarsFixed> &mock)

inline bool isBlock() const

inline auto getBlock(index iCell)

inline auto getDiag(index iCell)

inline tComponent getValue(index iCell) const

inline index Size()

inline void GetInvert()

template<class TV> inline TU MatVecLeft(index iCell, TV v)

template<class TV> inline TU MatVecLeftInvert(index iCell, TV v)

inline void clearValues()

template<int nVarsFixed> struct JacobianLocalLDLT : public DNDS::Direct::LocalLDLTBase<JacobianLocalLDLT<nVarsFixed>, Eigen::Matrix<real, nVarsFixed, nVarsFixed>, ArrayDOFV<nVarsFixed>>

Public Types

using tLocalMat = ArrayEigenUniMatrixBatch<nVarsFixed, nVarsFixed>

using tComponent = Eigen::Matrix<real, nVarsFixed, nVarsFixed>

using tVec = ArrayDOFV<nVarsFixed>

using tBase = Direct::LocalLDLTBase<JacobianLocalLDLT<nVarsFixed>, Eigen::Matrix<real, nVarsFixed, nVarsFixed>, ArrayDOFV<nVarsFixed>>

Public Functions

inline JacobianLocalLDLT(const ssp<Direct::SerialSymLUStructure> &nMesh, int nVarsC)

inline void setZero()

inline auto GetDiag(index i)

inline auto GetLower(index i, int iInLow)

inline void PrintLog()

inline tComponent InvertDiag(const tComponent &v)

Public Members

tLocalMat LDU

template<int nVarsFixed> struct JacobianLocalLU : public DNDS::Direct::LocalLUBase<JacobianLocalLU<nVarsFixed>, Eigen::Matrix<real, nVarsFixed, nVarsFixed>, ArrayDOFV<nVarsFixed>>

Public Types

using tLocalMat = ArrayEigenUniMatrixBatch<nVarsFixed, nVarsFixed>

using tComponent = Eigen::Matrix<real, nVarsFixed, nVarsFixed>

using tVec = ArrayDOFV<nVarsFixed>

using tBase = Direct::LocalLUBase<JacobianLocalLU<nVarsFixed>, Eigen::Matrix<real, nVarsFixed, nVarsFixed>, ArrayDOFV<nVarsFixed>>

Public Functions

inline JacobianLocalLU(const ssp<Direct::SerialSymLUStructure> &nMesh, int nVarsC)

inline void setZero()

inline auto GetDiag(index i)

inline auto GetLower(index i, int iInLow)

inline auto GetUpper(index i, int iInUpp)

inline void PrintLog()

inline tComponent InvertDiag(const tComponent &v)

Public Members

tLocalMat LDU

template<int nVarsFixed> class JacobianValue

Public Types

enum Type

Values:

enumerator Diagonal

enumerator DiagonalBlock

enumerator Full

Public Functions

inline void SetDiagonal(ArrayDOFV<nVarsFixed> &uDof)

inline void SetDiagonalBlock(ArrayDOFV<nVarsFixed> &uDof)

inline void SetFull(ArrayDOFV<nVarsFixed> &uDof, Geom::tAdjPair &cell2cell)

inline void InverseDiag()

Public Members

ArrayDOFV<nVarsFixed> diag

ArrayDOFV<nVarsFixed> diagInv

ArrayEigenMatrix<nVarsFixed, nVarsFixed> diagBlock

ArrayEigenMatrix<nVarsFixed, nVarsFixed> diagBlockInv

ArrayRECV<nVarsFixed> offDiagBlock

template<int nVarsFixed> struct OneDimProfile

Public Functions

inline OneDimProfile(const MPIInfo &_mpi)

inline void SortNodes()

inline index Size() const

inline real Len(index i)

inline void GenerateUniform(index size, int nvars, real minV, real maxV)

inline void GenerateTanh(index size, int nvars, real minV, real maxV, real d0)

inline void SetZero()

template<class TU> inline void AddSimpleInterval(TU vmean, real divV, real lV, real rV)

inline void Reduce()

inline Eigen::Vector<real, nVarsFixed> Get(index i) const

inline Eigen::Vector<real, nVarsFixed> GetPlain(real v) const

inline void OutProfileCSV(std::ostream &o, bool title = true, int precision = 16)

Public Members

MPIInfo mpi

Eigen::Vector<real, Eigen::Dynamic> nodes

Eigen::Matrix<real, nVarsFixed, Eigen::Dynamic> v

Eigen::RowVector<real, Eigen::Dynamic> div

class OutputPicker

Public Types

using tMap = std::map<std::string, tCellScalarFGet>

Public Functions

inline void setMap(const tMap &v)

inline tCellScalarList getSubsetList(const std::vector<std::string> &names)

template<class TU> struct TU_P_Reduction

namespace Gas

Typedefs

using tVec = Eigen::Vector3d

using tVec2 = Eigen::Vector2d

Enums

enum RiemannSolverType

Values:

enumerator UnknownRS

enumerator Roe

enumerator HLLC

enumerator HLLEP

enumerator HLLEP_V1

enumerator Roe_M1

enumerator Roe_M2

enumerator Roe_M3

enumerator Roe_M4

enumerator Roe_M5

enumerator Roe_M6

enumerator Roe_M7

enumerator Roe_M8

enumerator Roe_M9

Functions

DNDS_DEFINE_ENUM_JSON (RiemannSolverType, { {UnknownRS, "UnknownRS"}, {Roe, "Roe"}, {HLLC, "HLLC"}, {HLLEP, "HLLEP"}, {HLLEP_V1, "HLLEP_V1"}, {Roe_M1, "Roe_M1"}, {Roe_M2, "Roe_M2"}, {Roe_M3, "Roe_M3"}, {Roe_M4, "Roe_M4"}, {Roe_M5, "Roe_M5"}, {Roe_M6, "Roe_M6"}, {Roe_M7, "Roe_M7"}, {Roe_M8, "Roe_M8"}, {Roe_M9, "Roe_M9"}, }) template< int dim

class TeV inline void EulerGasRightEigenVector (const TVec &velo, real Vsqr, real H, real a, TeV &ReV)

template<int dim = 3, class TVec, class TeV> inline void EulerGasLeftEigenVector(const TVec &velo, real Vsqr, real H, real a, real gamma, TeV &LeV)

inline void IdealGasThermal(real E, real rho, real vSqr, real gamma, real &p, real &asqr, real &H)

template<int dim = 3, typename TULm, typename TURm, typename TFdumpInfo> RoePreamble<dim> ComputeRoePreamble(const TULm &ULm, const TURm &URm, real gamma, const TFdumpInfo &dumpInfo)

template<int dim = 3, class TCons, class TPrim> inline void IdealGasThermalConservative2Primitive(const TCons &U, TPrim &prim, real gamma)

template<int dim = 3, class TCons, class TPrim> inline void IdealGasThermalPrimitive2Conservative(const TPrim &prim, TCons &U, real gamma)

template<int dim = 3, class TPrim> std::tuple<real, real> IdealGasThermalPrimitiveGetP0T0(const TPrim &prim, real gamma, real rg)

template<int dim = 3, typename TU, typename TF, class TVec, class TVecVG> inline void GasInviscidFlux(const TU &U, const TVec &velo, const TVecVG &vg, real p, TF &F)

template<int dim = 3, typename TU, typename TF, class TVec, class TVecN, class TVecVG> inline void GasInviscidFlux_XY(const TU &U, const TVec &velo, const TVecVG &vg, const TVecN &n, real p, TF &F)

template<int dim = 3, typename TU, typename TF, class TVec, class TVecVG, class TP> inline void GasInviscidFlux_Batch(const TU &U, const TVec &velo, const TVecVG &vg, TP &&p, TF &F)

template<int dim = 3, typename TU, typename TF, class TVec, class TVecVG, class TVecN, class TP> inline void GasInviscidFlux_XY_Batch(const TU &U, const TVec &velo, const TVecVG &vg, const TVecN &n, TP &&p, TF &F)

template<int dim = 3, typename TU, class TVec> inline void IdealGasUIncrement(const TU &U, const TU &dU, const TVec &velo, real gamma, TVec &dVelo, real &dp)

template<int dim = 3, typename TU, typename TF, class TVec, class TVecVG> inline void GasInviscidFluxFacialIncrement(const TU &U, const TU &dU, const TVec &unitNorm, const TVecVG &velo, const TVec &dVelo, const TVec &vg, real dp, real p, TF &F)

template<int dim = 3, typename TU> inline auto IdealGas_EulerGasRightEigenVector(const TU &U, real gamma)

template<int dim = 3, typename TU> inline auto IdealGas_EulerGasLeftEigenVector(const TU &U, real gamma)

template<int dim = 3, int type = 0, typename TUL, typename TUR, typename TULm, typename TURm, typename TVecVG, typename TVecN, typename TF, typename TFdumpInfo> void HLLEPFlux_IdealGas(const TUL &UL, const TUR &UR, const TULm &ULm, const TURm &URm, const TVecVG &vg, const TVecN &n, real gamma, TF &F, real dLambda, real fixScale, const TFdumpInfo &dumpInfo, real &lam0, real &lam123, real &lam4)

template<int dim = 3, typename TUL, typename TUR, typename TULm, typename TURm, typename TVecVG, typename TVecN, typename TF, typename TFdumpInfo> void HLLCFlux_IdealGas_HartenYee(const TUL &UL, const TUR &UR, const TULm &ULm, const TURm &URm, const TVecVG &vg, const TVecN &n, real gamma, TF &F, real dLambda, real fixScale, const TFdumpInfo &dumpInfo, real &lam0, real &lam123, real &lam4)

template<int eigScheme> void Roe_EntropyFixer(const real aL, const real aR, const real aAve, const real uL, const real uR, const real uAve, const real VL, const real VR, const real VAve, real dLambda, real fixScale, real incFScale, real &lam0, real &lam123, real &lam4)

template<int dim = 3, int eigScheme = 0, typename TUL, typename TUR, typename TULm, typename TURm, typename TVecVG, typename TVecN, typename TF, typename TFdumpInfo> void RoeFlux_IdealGas_HartenYee(const TUL &UL, const TUR &UR, const TULm &ULm, const TURm &URm, const TVecVG &vg, const TVecN &n, real gamma, TF &F, real dLambda, real fixScale, real incFScale, const TFdumpInfo &dumpInfo, real &lam0, real &lam123, real &lam4)

template<int dim = 3, typename TUL, typename TUR, typename TVecV, typename TUOut> void GetRoeAverage(const TUL &UL, const TUR &UR, real gamma, TVecV &veloRoe, real &vsqrRoe, real &aRoe, real &asqrRoe, real &HRoe, TUOut &UOut)

template<int dim = 3, typename TDU, typename TDF, typename TVecV, typename TVecN> void RoeFluxIncFDiff(const TDU &incU, const TVecN &n, const TVecV &veloRoe, real vsqrRoe, real aRoe, real asqrRoe, real HRoe, real lam0, real lam123, real lam4, real gamma, TDF &incF)

template<int dim = 3, int eigScheme = 0, typename TUL, typename TUR, typename TULm, typename TURm, typename TVecVG, typename TVecVGm, typename TVecN, typename TVecNm, typename TF, typename TFdumpInfo> void RoeFlux_IdealGas_HartenYee_Batch(const TUL &UL, const TUR &UR, const TULm &ULm, const TURm &URm, const TVecVG &vg, const TVecVGm &vgm, const TVecN &n, const TVecNm &nm, real gamma, TF &F, real dLambda, real fixScale, real incFScale, const TFdumpInfo &dumpInfo, real &lam0, real &lam123, real &lam4)

template<int dim = 3, typename TUL, typename TUR, typename TULm, typename TURm, typename TVecVG, typename TVecN, typename TF, typename TFdumpInfo> void InviscidFlux_IdealGas_Dispatcher(RiemannSolverType type, TUL &&UL, TUR &&UR, TULm &&ULm, TURm &&URm, TVecVG &&vg, TVecN &&n, real gamma, TF &&F, real dLambda, real fixScale, real incFScale, TFdumpInfo &&dumpInfo, real &lam0, real &lam123, real &lam4)

template<int dim = 3, typename TUL, typename TUR, typename TULm, typename TURm, typename TVecVG, typename TVecVGm, typename TVecN, typename TVecNm, typename TF, typename TFdumpInfo> void InviscidFlux_IdealGas_Batch_Dispatcher(RiemannSolverType type, TUL &&UL, TUR &&UR, TULm &&ULm, TURm &&URm, TVecVG &&vg, TVecVGm &&vgm, TVecN &&n, TVecNm &&nm, real gamma, TF &&F, real dLambda, real fixScale, real incFScale, TFdumpInfo &dumpInfo, real &lam0, real &lam123, real &lam4)

template<int dim = 3, typename TU, typename TGradU, typename TFlux, typename TNorm> void ViscousFlux_IdealGas(const TU &U, const TGradU &GradUPrim, TNorm norm, bool adiabatic, real gamma, real mu, real mutRatio, bool mutQCRFix, real k, real Cp, TFlux &Flux)

template<int dim = 3, typename TU, typename TGradU, typename TGradUPrim> void GradientCons2Prim_IdealGas(const TU &U, const TGradU &GradU, TGradUPrim &GradUPrim, real gamma)

template<int dim, typename TU, typename TGradU> auto GetGradVelo(const TU &U, const TGradU &GradU)

template<int dim = 3, int scheme = 0, int nVarsFixed, typename TU, typename TUInc> real IdealGasGetCompressionRatioPressure(const TU &u, const TUInc &uInc, real newrhoEinteralNew)

Variables

static const int MaxBatch = 16

static constexpr real kScaleHartenYee = IdealGas::kScaleHartenYee

static constexpr real kScaleLD = IdealGas::kScaleLD

static constexpr real kScaleHFix = IdealGas::kScaleHFix

template<int dim> struct RoePreamble

Public Members

TVec veloRm

real HRm

real vsqrRm

TVec veloRoe

real sqrtRhoRm

real aRoe

namespace RANS

Functions

template<int dim, class TU, class TDiffU> real GetMut_RealizableKe(TU &&UMeanXy, TDiffU &&DiffUxy, real muf, real d)

template<int dim, class TU, class TN, class TDiffU, class TVFlux> void GetVisFlux_RealizableKe(TU &&UMeanXy, TDiffU &&DiffUxyPrim, TN &&uNorm, real mut, real d, real muPhy, TVFlux &vFlux)

template<int dim, class TU, class TDiffU, class TSource> void GetSource_RealizableKe(TU &&UMeanXy, TDiffU &&DiffUxy, real muf, real d, TSource &source, int mode)

template<int dim, class TU> std::tuple<real, real> SolveZeroGradEquilibrium(TU &u, real muPhy)

template<int dim, class TU, class TDiffU, class TSource> void GetSourceJacobianDiag_RealizableKe(TU &&UMeanXy, TDiffU &&DiffUxy, real muf, TSource &source)

template<int dim, class TU, class TDiffU, class TSource> void GetSourceJacobianDiag_RealizableKe_ND(TU &&UMeanXy, TDiffU &&DiffUxy, real muf, TSource &source)

template<int dim, class TU, class TDiffU> real GetMut_SST(TU &&UMeanXy, TDiffU &&DiffUxy, real muf, real d)

template<int dim, class TU, class TN, class TDiffU, class TVFlux> void GetVisFlux_SST(TU &&UMeanXy, TDiffU &&DiffUxyPrim, TN &&uNorm, real mutIn, real d, real muf, TVFlux &vFlux)

template<int dim, class TU, class TDiffU, class TSource> void GetSource_SST(TU &&UMeanXy, TDiffU &&DiffUxy, real muf, real d, real lLES, TSource &source, int mode)

template<int dim, class TU, class TDiffU> real GetMut_KOWilcox(TU &&UMeanXy, TDiffU &&DiffUxy, real muf, real d)

template<int dim, class TU, class TN, class TDiffU, class TVFlux> void GetVisFlux_KOWilcox(TU &&UMeanXy, TDiffU &&DiffUxyPrim, TN &&uNorm, real mutIn, real d, real muf, TVFlux &vFlux)

template<int dim, class TU, class TDiffU, class TSource> void GetSource_KOWilcox(TU &&UMeanXy, TDiffU &&DiffUxy, real muf, real d, TSource &source, int mode)

template<int dim, class TU, class TDiffU, class TSource> void GetSource_SA(TU &&UMeanXy, TDiffU &&DiffUxy, real muRef, real mufPhy, real gamma, real d, real lLES, real hMax, int DESMode, TSource &source, int rotCor, int mode)

Variables

static constexpr real kWallOmegaCoeff = 800.0

namespace SA

Variables

static constexpr real cnu1 = 7.1

static constexpr real cn1 = 16.0

static constexpr real sigma = 2.0 / 3.0

namespace SpecialFields

Functions

template<EulerModel model = NS> auto IsentropicVortex10(EulerEvaluator<model> &eval, const Geom::tPoint &x, real t, int cnVars, real chi)

template<EulerModel model = NS> auto IsentropicVortex30(EulerEvaluator<model> &eval, const Geom::tPoint &x, real t, int cnVars)

template<EulerModel model = NS> auto IsentropicVortexCent(EulerEvaluator<model> &eval, const Geom::tPoint &x, real t, int cnVars)