MAIA bb96820c
Multiphysics at AIA
Loading...
Searching...
No Matches
Classes | Public Member Functions | Public Attributes | Static Public Attributes | Protected Member Functions | Static Protected Member Functions | Protected Attributes | List of all members
FvSysEqnNS< nDim > Class Template Reference

#include <fvcartesiansyseqnns.h>

Inheritance diagram for FvSysEqnNS< nDim >:
[legend]
Collaboration diagram for FvSysEqnNS< nDim >:
[legend]

Classes

struct  AdditionalVariables
 No additional variables are used in this SysEqn. More...
 
struct  ConservativeVariables
 Static indices for accessing conservative variables in nDim spatial dimensions. More...
 
struct  FluxVariables
 Static indices for accessing flux variables in this SysEqn identical to the conservative variables. More...
 
struct  PrimitiveVariables
 Static indices for accessing primitive variables in nDim spatial dimensions. More...
 
struct  SurfaceCoefficients
 

Public Member Functions

 FvSysEqnNS (const MInt solverId, const MInt noSpecies)
 
template<MInt scheme = AUSM>
void Ausm (const MInt orientation, const MFloat upwindCoefficient, const MFloat A, const MFloat *const leftVars, const MFloat *const rightVars, const MFloat *const srfcCoeff, MFloat *const flux)
 
void Ausm_ (const MInt orientation, const MFloat upwindCoefficient, const MFloat A, const MFloat *const leftVars, const MFloat *const rightVars, const MFloat *const NotUsed(srfcCoeff), MFloat *const flux)
 
void AusmPlus_ (const MInt orientation, const MFloat upwindCoefficient, const MFloat A, const MFloat *const leftVars, const MFloat *const rightVars, const MFloat *const NotUsed(srfcCoeff), MFloat *const flux)
 
void Slau_ (const MInt orientation, const MFloat NotUsed(upwindCoefficient), const MFloat A, const MFloat *const leftVars, const MFloat *const rightVars, const MFloat *const NotUsed(srfcCoeff), MFloat *const flux)
 
void AusmBndryCorrection (const MInt orientation, const MFloat A, const MFloat *const leftVars, const MFloat *const rightVars, MFloat *const flux)
 
void AusmALECorrection (const MInt orientation, const MFloat A, MFloat *const flux, MFloat *const surfVars, const MFloat *const bndrySurfVars)
 
template<MInt centralizeScheme>
void centralizeSurfaceVariables (MFloat *const varL, MFloat *const varR, const MInt orientation, const MFloat levelFac)
 
template<MInt stencil>
void viscousFlux (const MInt orientation, const MFloat A, const MFloat *const vars0, const MFloat *const vars1, const MFloat *const slope0, const MFloat *const slope1, const MFloat *const srfcCoeff, const MFloat f0, const MFloat f1, MFloat *const flux)
 
template<MInt stencil>
void viscousFlux (const MInt orientation, const MFloat A, const MBool isBndry, const MFloat *const surfaceCoords, const MFloat *const coord0, const MFloat *const coord1, const MFloat *const cellVars0, const MFloat *const cellVars1, const MFloat *const vars0, const MFloat *const vars1, const MFloat *const slope0, const MFloat *const slope1, const MFloat f0, const MFloat f1, MFloat *const flux)
 
void viscousFluxFivePoint (const MInt orientation, const MFloat A, const MFloat *const vars0, const MFloat *const vars1, const MFloat *const slope0, const MFloat *const slope1, const MFloat *const NotUsed(srfcCoeff), const MFloat f0, const MFloat f1, MFloat *const flux)
 
void viscousFluxThreePoint (const MInt orientation, const MFloat A, const MBool isBndry, const MFloat *const surfaceCoords, const MFloat *const coord0, const MFloat *const coord1, const MFloat *const cellVars0, const MFloat *const cellVars1, const MFloat *const vars0, const MFloat *const vars1, const MFloat *const slope0, const MFloat *const slope1, const MFloat f0, const MFloat f1, MFloat *const flux)
 
void viscousFluxStabilized (const MInt orientation, const MFloat A, const MBool isBndry, const MFloat *const surfaceCoords, const MFloat *const coord0, const MFloat *const coord1, const MFloat *const cellVars0, const MFloat *const cellVars1, const MFloat *const vars0, const MFloat *const vars1, const MFloat *const slope0, const MFloat *const slope1, const MFloat f0, const MFloat f1, MFloat *const flux)
 Computes the viscous fluxes using a five-point stencil (less dissipative) blended with a compact stencil (increased stability). Short: (1-enhanceThreePointViscFluxFactor)*FIVE_POINT + enhanceThreePointViscFluxFactor*THREE_POINT Default for centralizeViscousFlux is 0.1 if not defined in property file. More...
 
template<MInt stencil>
void wmViscousFluxCorrection (const MInt orientation, const MFloat A, const MFloat *const vars0, const MFloat *const vars1, const MFloat *const slope0, const MFloat *const slope1, const MFloat f0, const MFloat f1, MFloat *const flux, MFloat const mue_wm)
 
void wmViscousFluxCorrectionFivePoint (const MInt orientation, const MFloat A, const MFloat *const vars0, const MFloat *const vars1, const MFloat *const slope0, const MFloat *const slope1, const MFloat f0, const MFloat f1, MFloat *const flux, MFloat const mue_wm)
 
void computePrimitiveVariables (const MFloat *const cvarsCell, MFloat *const pvarsCell, const MFloat *const NotUsed(avarsCell))
 
void computeConservativeVariables (const MFloat *const pvarsCell, MFloat *const cvarsCell, const MFloat *const NotUsed(avarsCell))
 
std::vector< std::vector< MFloat > > conservativeSlopes (const MFloat *const pvarsCell, const MFloat *const cvarsCell, const MFloat *const avarsCell, const MFloat *const slopesCell)
 
void computeVolumeForces (const MInt, MFloat *, MFloat *, const MFloat, const MFloat *const, const MInt, const MInt *const, const MFloat *const, const MInt, MFloat)
 
constexpr MFloat speedOfSound (const MFloat density, const MFloat pressure)
 Speed of sound: a = sqrt(gamma * pressure / density) More...
 
constexpr MFloat speedOfSoundSquared (const MFloat density, const MFloat pressure)
 speed of sound squared a^2 = gamma * pressure / density More...
 
constexpr MFloat speedOfSound (const MFloat temperature)
 Speed of sound: a = sqrt(T) More...
 
constexpr MFloat temperature_ES (const MFloat density, const MFloat pressure)
 Temperature: T = gamma * pressure / density (equation of state - ideal gas law) More...
 
constexpr MFloat pressure_ES (const MFloat temperture, const MFloat density)
 pressure: p = rho * T / gamma (equation of state - ideal gas law) More...
 
constexpr MFloat density_ES (const MFloat pressure, const MFloat temperature)
 density: rho = gamma * p / T (equation of state - ideal gas law) More...
 
constexpr MFloat temperature_IR (const MFloat Ma)
 Temperature: T = 1 / (1 + (gamma - 1)/2 * Ma^2) (isentropic relationship) More...
 
constexpr MFloat pressure_IR (const MFloat temperature)
 
constexpr MFloat pressure_IRit (const MFloat pressure, const MFloat massFlux)
 
constexpr MFloat density_IR (const MFloat temperature)
 density: rho = T^(1/(gamma -1 )) (isentropic relationship) More...
 
constexpr MFloat density_IR_P (const MFloat pressure)
 density: rho = (p * gamma)^(1/gamma) (isentropic relationship) More...
 
constexpr MFloat pressure (const MFloat density, const MFloat momentumDensitySquared, const MFloat energyDensity)
 
constexpr MFloat internalEnergy (const MFloat pressure, const MFloat density, const MFloat velocitySquared)
 
constexpr MFloat pressureEnergy (const MFloat pressure)
 
constexpr MFloat enthalpy (const MFloat pressure, const MFloat density)
 enthalpy from primitive variables More...
 
constexpr MFloat entropy (const MFloat pressure, const MFloat density)
 entropy from primitive variables More...
 
constexpr MFloat CroccoBusemann (const MFloat Ma, const MFloat x)
 Crocco-Busemann relation. More...
 
constexpr MFloat vanDriest (const MFloat Ma)
 van-Driest Transformation (correspods to R*H) More...
 
constexpr MFloat sutherlandLaw (const MFloat T)
 
MFloat computeTimeStepEulerMagnitude (const MFloat rho, const std::array< MFloat, nDim > u, const MFloat p, const MFloat C, const MFloat dx)
 
constexpr MFloat gamma_Ref ()
 
constexpr MFloat cp_Ref ()
 
constexpr MFloat cv_Ref ()
 
constexpr MFloat p_Ref ()
 
constexpr MFloat computeTimeStepDiffusion (const MFloat diffusion_coefficient, const MFloat C, const MFloat dx)
 

Public Attributes

MFloat m_Re0 = {}
 
MFloat m_muInfinity = {}
 
ConservativeVariables * CV = nullptr
 
FluxVariables * FV = nullptr
 
PrimitiveVariables * PV = nullptr
 
AdditionalVariables * AV = nullptr
 
SurfaceCoefficients * SC = nullptr
 

Static Public Attributes

static constexpr MInt m_noRansEquations = 0
 
static constexpr MInt m_ransModel = NORANS
 
static constexpr MBool hasAV = false
 
static constexpr MBool hasSC = false
 
static const MUint index0 [nDim]
 
static const MUint index1 [nDim]
 

Protected Member Functions

void readProperties ()
 

Static Protected Member Functions

static MFloat sgn (MFloat val)
 
static constexpr std::array< MInt, nDim > getArray012 ()
 

Protected Attributes

MUint m_noSpecies
 
MInt m_solverId
 
MFloat m_gamma = 1.4
 
MFloat m_gammaMinusOne = m_gamma - 1
 
MFloat m_F1BGammaMinusOne = 1 / m_gammaMinusOne
 
MFloat m_FGammaBGammaMinusOne = m_gamma / m_gammaMinusOne
 
MFloat m_F1BGamma = 1 / m_gamma
 
MFloat m_Pr = 0.72
 
MFloat m_F1BPr = 1 / m_Pr
 
MFloat m_referenceTemperature = {}
 
MFloat m_sutherlandPlusOne = {}
 
MFloat m_sutherlandConstant = {}
 
MFloat m_sutherlandPlusOneThermal = {}
 
MFloat m_sutherlandConstantThermal = {}
 
MFloat m_gFGMOrPr = {}
 
MFloat m_enhanceThreePointViscFluxFactor {}
 
MFloat m_centralizeSurfaceVariablesFactor = 0.0
 

Detailed Description

template<MInt nDim>
class FvSysEqnNS< nDim >

Definition at line 31 of file fvcartesiansyseqnns.h.

Constructor & Destructor Documentation

◆ FvSysEqnNS()

template<MInt nDim>
FvSysEqnNS< nDim >::FvSysEqnNS ( const MInt  solverId,
const MInt  noSpecies 
)

Definition at line 10 of file fvcartesiansyseqnns.cpp.

10 : m_solverId(solverId) {
11 CV = new ConservativeVariables(noSpecies);
12 PV = new PrimitiveVariables(noSpecies);
13 FV = new FluxVariables(noSpecies);
14
15 readProperties();
16}
FvSysEqnNS::CV
ConservativeVariables * CV
Definition: fvcartesiansyseqnns.h:342
FvSysEqnNS::PV
PrimitiveVariables * PV
Definition: fvcartesiansyseqnns.h:344
FvSysEqnNS::readProperties
void readProperties()
FvSysEqnNS::FV
FluxVariables * FV
Definition: fvcartesiansyseqnns.h:343

Member Function Documentation

◆ Ausm()

template<MInt nDim>
template<MInt scheme = AUSM>
void FvSysEqnNS< nDim >::Ausm ( const MInt  orientation,
const MFloat  upwindCoefficient,
const MFloat  A,
const MFloat *const  leftVars,
const MFloat *const  rightVars,
const MFloat *const  srfcCoeff,
MFloat *const  flux 
)
inline

Definition at line 39 of file fvcartesiansyseqnns.h.

40 {
41 IF_CONSTEXPR(scheme == AUSM) { Ausm_(orientation, upwindCoefficient, A, leftVars, rightVars, srfcCoeff, flux); }
42 else IF_CONSTEXPR(scheme == AUSMPLUS) {
43 AusmPlus_(orientation, upwindCoefficient, A, leftVars, rightVars, srfcCoeff, flux);
44 }
45 else IF_CONSTEXPR(scheme == SLAU) {
46 Slau_(orientation, upwindCoefficient, A, leftVars, rightVars, srfcCoeff, flux);
47 }
48 }
FvSysEqnNS::Ausm_
void Ausm_(const MInt orientation, const MFloat upwindCoefficient, const MFloat A, const MFloat *const leftVars, const MFloat *const rightVars, const MFloat *const NotUsed(srfcCoeff), MFloat *const flux)
Definition: fvcartesiansyseqnns.h:436
FvSysEqnNS::AusmPlus_
void AusmPlus_(const MInt orientation, const MFloat upwindCoefficient, const MFloat A, const MFloat *const leftVars, const MFloat *const rightVars, const MFloat *const NotUsed(srfcCoeff), MFloat *const flux)
Definition: fvcartesiansyseqnns.h:497
FvSysEqnNS::Slau_
void Slau_(const MInt orientation, const MFloat NotUsed(upwindCoefficient), const MFloat A, const MFloat *const leftVars, const MFloat *const rightVars, const MFloat *const NotUsed(srfcCoeff), MFloat *const flux)
Definition: fvcartesiansyseqnns.h:557
SLAU
@ SLAU
Definition: enums.h:182
AUSM
@ AUSM
Definition: enums.h:182
AUSMPLUS
@ AUSMPLUS
Definition: enums.h:182

◆ Ausm_()

template<MInt nDim>
void FvSysEqnNS< nDim >::Ausm_ ( const MInt  orientation,
const MFloat  upwindCoefficient,
const MFloat  A,
const MFloat *const  leftVars,
const MFloat *const  rightVars,
const MFloat *const   NotUsedsrfcCoeff,
MFloat *const  flux 
)
inline

Definition at line 436 of file fvcartesiansyseqnns.h.

438 {
439 // catch the primitive variables rho and p,
440 // compute speed of sound, and interface mach number
441 const MFloat RHOL = leftVars[PV->RHO];
442 const MFloat PL = leftVars[PV->P];
443 const MFloat AL = sqrt(m_gamma * mMax(MFloatEps, PL / mMax(MFloatEps, RHOL)));
444 const MFloat ML = leftVars[orientation] / AL;
445
446 const MFloat RHOR = rightVars[PV->RHO];
447 const MFloat PR = rightVars[PV->P];
448 const MFloat AR = sqrt(m_gamma * mMax(MFloatEps, PR / mMax(MFloatEps, RHOR)));
449 const MFloat MR = rightVars[orientation] / AR;
450
451 // calculation of the resulting pressure and mach number on the surface
452 const MFloat MLR = 0.5 * (ML + MR);
453 const MFloat PLR = PL * (0.5 + upwindCoefficient * ML) + PR * (0.5 - upwindCoefficient * MR);
454
455 // calculation of the left and right rho*a
456 const MFloat RHO_AL = RHOL * AL;
457 const MFloat RHO_AR = RHOR * AR;
458
459 // calculation of the resulting mass flux through the surface
460 const MFloat RHO_U2 = 0.25 * (MLR * (RHO_AL + RHO_AR) + fabs(MLR) * (RHO_AL - RHO_AR));
461 const MFloat AbsRHO_U2 = fabs(RHO_U2);
462
463 // calculation of the energy:
464 const MFloat PLfRHOL = PL / RHOL;
465 const MFloat PRfRHOR = PR / RHOR;
466
467 // velocity magnitudes
468 const MFloat U2L = std::inner_product(&leftVars[PV->U], &leftVars[PV->U] + nDim, &leftVars[PV->U], 0.0);
469 const MFloat U2R = std::inner_product(&rightVars[PV->U], &rightVars[PV->U] + nDim, &rightVars[PV->U], 0.0);
470
471 const MFloat e0 = PLfRHOL * m_F1BGammaMinusOne + 0.5 * U2L + PLfRHOL;
472 const MFloat e1 = PRfRHOR * m_F1BGammaMinusOne + 0.5 * U2R + PRfRHOR;
473
474 std::array<MFloat, nDim> pFactor{};
475 pFactor[orientation] = 1.0;
476
477 for(MUint n = 0; n < nDim; n++) {
478 flux[FV->RHO_VV[n]] = (RHO_U2 * (leftVars[PV->VV[n]] + rightVars[PV->VV[n]])
479 + AbsRHO_U2 * (leftVars[PV->VV[n]] - rightVars[PV->VV[n]]) + PLR * pFactor[n])
480 * A;
481 }
482
483 flux[FV->RHO_E] = (RHO_U2 * (e0 + e1) + AbsRHO_U2 * (e0 - e1)) * A;
484 flux[FV->RHO] = 2.0 * RHO_U2 * A;
485
486 // Flux calculation for species transport
487 // TODO labels:FV @Julian, Make noSpecies constexpr
488 for(MUint s = 0; s < PV->m_noSpecies; ++s) {
489 const MFloat YsL = leftVars[PV->Y[s]];
490 const MFloat YsR = rightVars[PV->Y[s]];
491 flux[FV->RHO_Y[s]] = (RHO_U2 * (YsL + YsR) + AbsRHO_U2 * (YsL - YsR)) * A;
492 }
493}
FvSysEqnNS::m_F1BGammaMinusOne
MFloat m_F1BGammaMinusOne
Definition: fvcartesiansyseqnns.h:296
mMax
constexpr T mMax(const T &x, const T &y)
Definition: functions.h:94
MUint
uint32_t MUint
Definition: maiatypes.h:63
MFloat
double MFloat
Definition: maiatypes.h:52
FvSysEqnNS::ConservativeVariables::RHO_VV
static constexpr std::array< MInt, nDim > RHO_VV
Definition: fvcartesiansyseqnns.h:366
FvSysEqnNS::PrimitiveVariables::VV
static constexpr std::array< MInt, nDim > VV
Definition: fvcartesiansyseqnns.h:397

◆ AusmALECorrection()

template<MInt nDim>
void FvSysEqnNS< nDim >::AusmALECorrection ( const MInt  orientation,
const MFloat  A,
MFloat *const  flux,
MFloat *const  surfVars,
const MFloat *const  bndrySurfVars 
)
inline

Definition at line 647 of file fvcartesiansyseqnns.h.

651 {
652 surfVars[PV->VV[orientation]] = bndrySurfVars[PV->VV[orientation]];
653 surfVars[PV->noVariables + PV->VV[orientation]] = bndrySurfVars[PV->VV[orientation]];
654
655 for(MInt v = 0; v < FV->noVariables; ++v) {
656 flux[v] = 0.0;
657 }
658
659 flux[CV->RHO_VV[orientation]] = bndrySurfVars[PV->P] * A;
660 flux[CV->RHO_E] = bndrySurfVars[PV->P] * bndrySurfVars[PV->VV[orientation]] * A;
661}
MInt
int32_t MInt
Definition: maiatypes.h:62

◆ AusmBndryCorrection()

template<MInt nDim>
void FvSysEqnNS< nDim >::AusmBndryCorrection ( const MInt  orientation,
const MFloat  A,
const MFloat *const  leftVars,
const MFloat *const  rightVars,
MFloat *const  flux 
)
inline

Definition at line 623 of file fvcartesiansyseqnns.h.

624 {
625 const MFloat PL = leftVars[PV->P];
626 const MFloat PR = rightVars[PV->P];
627 const MFloat PLR = 0.5 * (PR + PL);
628
629 std::array<MFloat, nDim> pFactor{};
630 pFactor[orientation] = 1.0;
631
632 for(MUint n = 0; n < nDim; n++) {
633 flux[FV->RHO_VV[n]] = PLR * pFactor[n] * A;
634 }
635
636 flux[FV->RHO_E] = 0.0;
637 flux[FV->RHO] = 0.0;
638
639 // Flux calculation for species transport
640 // TODO labels:FV @Julian, Make noSpecies constexpr
641 for(MUint s = 0; s < PV->m_noSpecies; ++s) {
642 flux[FV->RHO_Y[s]] = 0.0;
643 }
644}

◆ AusmPlus_()

template<MInt nDim>
void FvSysEqnNS< nDim >::AusmPlus_ ( const MInt  orientation,
const MFloat  upwindCoefficient,
const MFloat  A,
const MFloat *const  leftVars,
const MFloat *const  rightVars,
const MFloat *const   NotUsedsrfcCoeff,
MFloat *const  flux 
)
inline

Definition at line 497 of file fvcartesiansyseqnns.h.

499 {
500 if(PV->m_noSpecies > 0) {
501 mTerm(1, "Not yet implemented for multiple-species!");
502 }
503
504 std::array<MFloat, nDim> pFactor = {};
505 pFactor[orientation] = F1;
506
507 MFloat UL = leftVars[PV->U];
508 MFloat VL = leftVars[PV->V];
509 MFloat WL = 0.0;
510 IF_CONSTEXPR(nDim == 3) { WL = leftVars[PV->W]; }
511 MFloat RL = leftVars[PV->RHO];
512 MFloat PL = leftVars[PV->P];
513
514 MFloat UR = rightVars[PV->U];
515 MFloat VR = rightVars[PV->V];
516 MFloat WR = 0.0;
517 IF_CONSTEXPR(nDim == 3) { WR = rightVars[PV->W]; }
518 MFloat RR = rightVars[PV->RHO];
519 MFloat PR = rightVars[PV->P];
520
521 MFloat ql = leftVars[orientation];
522 MFloat AL = sqrt(m_gamma * PL / RL);
523 MFloat KL = 0.0;
524 KL = F1B2 * (UL * UL + VL * VL);
525 IF_CONSTEXPR(nDim == 3) { KL = F1B2 * (UL * UL + VL * VL + WL * WL); }
526 MFloat HL = (m_gamma * PL) / (m_gammaMinusOne * RL) + KL;
527
528 MFloat qr = rightVars[orientation];
529 MFloat AR = sqrt(m_gamma * PR / RR);
530 MFloat KR = 0.0;
531 KR = F1B2 * (UR * UR + VR * VR);
532 IF_CONSTEXPR(nDim == 3) { KR = F1B2 * (UR * UR + VR * VR + WR * WR); }
533 MFloat HR = (m_gamma * PR) / (m_gammaMinusOne * RR) + KR;
534
535 MFloat ML = ql / AL;
536 MFloat MR = qr / AR;
537
538 MFloat MLP = (fabs(ML) > F1) ? F1B2 * (ML + fabs(ML)) : F1B4 * POW2(ML + F1);
539 MFloat MRM = (fabs(MR) > F1) ? F1B2 * (MR - fabs(MR)) : -F1B4 * POW2(MR - F1);
540 MFloat M = MLP + MRM;
541 MFloat P = F1B2 * (PL + PR) + upwindCoefficient * (ML * PL - MR * PR);
542
543 flux[FV->RHO] = F1B2 * (M * (RL * AL + RR * AR) + fabs(M) * (RL * AL - RR * AR)) * A;
544 flux[FV->RHO_U] =
545 (F1B2 * (M * (RL * AL * UL + RR * AR * UR) + fabs(M) * (RL * AL * UL - RR * AR * UR)) + P * pFactor[0]) * A;
546 flux[FV->RHO_V] =
547 (F1B2 * (M * (RL * AL * VL + RR * AR * VR) + fabs(M) * (RL * AL * VL - RR * AR * VR)) + P * pFactor[1]) * A;
548 IF_CONSTEXPR(nDim == 3) {
549 flux[FV->RHO_W] =
550 (F1B2 * (M * (RL * AL * WL + RR * AR * WR) + fabs(M) * (RL * AL * WL - RR * AR * WR)) + P * pFactor[2]) * A;
551 }
552 flux[FV->RHO_E] = F1B2 * (M * (RL * AL * HL + RR * AR * HR) + fabs(M) * (RL * AL * HL - RR * AR * HR)) * A;
553}
mTerm
void mTerm(const MInt errorCode, const MString &location, const MString &message)
Definition: functions.cpp:29
POW2
constexpr Real POW2(const Real x)
Definition: functions.h:119

◆ centralizeSurfaceVariables()

template<MInt nDim>
template<MInt centralizeScheme>
void FvSysEqnNS< nDim >::centralizeSurfaceVariables ( MFloat *const  varL,
MFloat *const  varR,
const MInt  orientation,
const MFloat  levelFac 
)
inline

Definition at line 665 of file fvcartesiansyseqnns.h.

668 {
669 static_assert(centralizeScheme > 0 && centralizeScheme < 6, "Unintended/unimplemented function-call!");
670
671 IF_CONSTEXPR(centralizeScheme == 1) {
672 const MFloat z = mMin(F1, mMax(fabs(varL[orientation]) / sqrt(m_gamma * varL[PV->P] / varL[PV->RHO]),
673 fabs(varR[orientation]) / sqrt(m_gamma * varR[PV->P] / varR[PV->RHO])));
674 for(MInt k = 0; k < nDim; k++) {
675 const MInt velId = PV->VV[k];
676 const MFloat ML = varL[velId];
677 const MFloat MR = varR[velId];
678 varL[velId] = F1B2 * ((F1 + z) * ML + (F1 - z) * MR);
679 varR[velId] = F1B2 * ((F1 + z) * MR + (F1 - z) * ML);
680 }
681 }
682 else IF_CONSTEXPR(centralizeScheme == 2) {
683 const MFloat z = mMin(F1, (fabs(varL[orientation]) / sqrt(m_gamma * varL[PV->P] / varL[PV->RHO]))
684 * (fabs(varR[orientation]) / sqrt(m_gamma * varR[PV->P] / varR[PV->RHO])));
685 for(MInt k = 0; k < nDim; k++) {
686 const MInt velId = PV->VV[k];
687 const MFloat ML = varL[velId];
688 const MFloat MR = varR[velId];
689 varL[velId] = F1B2 * ((F1 + z) * ML + (F1 - z) * MR);
690 varR[velId] = F1B2 * ((F1 + z) * MR + (F1 - z) * ML);
691 }
692 }
693 else IF_CONSTEXPR(centralizeScheme == 3) {
694 for(MInt v = 0; v < PV->noVariables; v++) {
695 const MFloat Vmean = F1B2 * (varL[v] + varR[v]);
696 varL[v] = Vmean;
697 varR[v] = Vmean;
698 }
699 }
700 else IF_CONSTEXPR(centralizeScheme == 4) {
701 const MFloat z = pow(mMin(F1, (fabs(varL[orientation]) / sqrt(m_gamma * varL[PV->P] / varL[PV->RHO]))
702 * (fabs(varR[orientation]) / sqrt(m_gamma * varR[PV->P] / varR[PV->RHO]))),
703 levelFac);
704 for(MInt k = 0; k < nDim; k++) {
705 const MInt velId = PV->VV[k];
706 const MFloat ML = varL[velId];
707 const MFloat MR = varR[velId];
708 varL[velId] = F1B2 * ((F1 + z) * ML + (F1 - z) * MR);
709 varR[velId] = F1B2 * ((F1 + z) * MR + (F1 - z) * ML);
710 }
711 }
712 else {
713 const MFloat z = mMin(F1, m_centralizeSurfaceVariablesFactor
714 * mMax((fabs(varL[orientation]) / sqrt(m_gamma * varL[PV->P] / varL[PV->RHO])),
715 (fabs(varR[orientation]) / sqrt(m_gamma * varR[PV->P] / varR[PV->RHO]))));
716 for(MInt k = 0; k < nDim; k++) {
717 const MInt velId = PV->VV[k];
718 const MFloat ML = varL[velId];
719 const MFloat MR = varR[velId];
720 varL[velId] = F1B2 * ((F1 + z) * ML + (F1 - z) * MR);
721 varR[velId] = F1B2 * ((F1 + z) * MR + (F1 - z) * ML);
722 }
723 }
724}
FvSysEqnNS::m_centralizeSurfaceVariablesFactor
MFloat m_centralizeSurfaceVariablesFactor
Definition: fvcartesiansyseqnns.h:311
mMin
constexpr T mMin(const T &x, const T &y)
Definition: functions.h:90

◆ computeConservativeVariables()

template<MInt nDim>
void FvSysEqnNS< nDim >::computeConservativeVariables ( const MFloat *const  pvarsCell,
MFloat *const  cvarsCell,
const MFloat *const   NotUsedavarsCell 
)
inline

Definition at line 1130 of file fvcartesiansyseqnns.h.

1131 {
1132 // compute rho v
1133 MFloat velPOW2 = F0;
1134 for(MInt vel = 0; vel < nDim; ++vel) {
1135 cvarsCell[vel] = pvarsCell[vel] * pvarsCell[PV->RHO];
1136 velPOW2 += POW2(pvarsCell[vel]);
1137 }
1138
1139 // compute rho e
1140 cvarsCell[CV->RHO_E] = pvarsCell[PV->P] * m_F1BGammaMinusOne + F1B2 * pvarsCell[PV->RHO] * velPOW2;
1141
1142 // copy the density
1143 cvarsCell[CV->RHO] = pvarsCell[PV->RHO];
1144
1145 // compute rho Yi
1146 for(MUint s = 0; s < PV->m_noSpecies; ++s) {
1147 cvarsCell[CV->RHO_Y[s]] = pvarsCell[PV->Y[s]] * pvarsCell[PV->RHO];
1148 }
1149}

◆ computePrimitiveVariables()

template<MInt nDim>
void FvSysEqnNS< nDim >::computePrimitiveVariables ( const MFloat *const  cvarsCell,
MFloat *const  pvarsCell,
const MFloat *const   NotUsedavarsCell 
)
inline

Definition at line 1110 of file fvcartesiansyseqnns.h.

1111 {
1112 const MFloat fRho = F1 / cvarsCell[CV->RHO];
1113 MFloat velPOW2 = F0;
1114 for(MInt n = 0; n < nDim; ++n) { // compute velocity
1115 pvarsCell[PV->VV[n]] = cvarsCell[CV->RHO_VV[n]] * fRho;
1116 velPOW2 += POW2(pvarsCell[PV->VV[n]]);
1117 }
1118
1119 // density and pressure:
1120 pvarsCell[PV->RHO] = cvarsCell[CV->RHO]; // density
1121 pvarsCell[PV->P] = m_gammaMinusOne * (cvarsCell[CV->RHO_E] - F1B2 * pvarsCell[PV->RHO] * velPOW2);
1122
1123 // compute the species
1124 for(MUint s = 0; s < PV->m_noSpecies; ++s) {
1125 pvarsCell[PV->Y[s]] = cvarsCell[CV->RHO_Y[s]] * fRho;
1126 }
1127}

◆ computeTimeStepDiffusion()

template<MInt nDim>
constexpr MFloat FvSysEqnNS< nDim >::computeTimeStepDiffusion ( const MFloat  diffusion_coefficient,
const MFloat  C,
const MFloat  dx 
)
inlineconstexpr

Computes the time-step from the stability condition for the Diffusion Eqt.

dt = C * dx^2 / diffusion_coefficient where C = (0, 1/4]

Definition at line 279 of file fvcartesiansyseqnns.h.

280 {
281 return C * POW2(dx) / diffusion_coefficient;
282 };

◆ computeTimeStepEulerMagnitude()

template<MInt nDim>
MFloat FvSysEqnNS< nDim >::computeTimeStepEulerMagnitude ( const MFloat  rho,
const std::array< MFloat, nDim >  u,
const MFloat  p,
const MFloat  C,
const MFloat  dx 
)
inline

Computes the time-step from the CFL condition for the Euler-eqts as follows:

dt = C * dx / (||u|| + a)

Definition at line 253 of file fvcartesiansyseqnns.h.

254 {
255 const MFloat a = speedOfSound(rho, p);
256 const MFloat u_mag = std::sqrt(std::inner_product(&u[0], &u[nDim], &u[0], 0.0));
257 return C * dx / (u_mag + a);
258 };
FvSysEqnNS::speedOfSound
constexpr MFloat speedOfSound(const MFloat density, const MFloat pressure)
Speed of sound: a = sqrt(gamma * pressure / density)
Definition: fvcartesiansyseqnns.h:157
a
Definition: contexttypes.h:19

◆ computeVolumeForces()

template<MInt nDim>
void FvSysEqnNS< nDim >::computeVolumeForces ( const  MInt,
MFloat *  ,
MFloat *  ,
const  MFloat,
const MFloat * const  ,
const  MInt,
const MInt * const  ,
const MFloat * const  ,
const  MInt,
MFloat   
)
inline

Definition at line 153 of file fvcartesiansyseqnns.h.

154 {};

◆ conservativeSlopes()

template<MInt nDim>
std::vector< std::vector< MFloat > > FvSysEqnNS< nDim >::conservativeSlopes ( const MFloat *const  pvarsCell,
const MFloat *const  cvarsCell,
const MFloat *const  avarsCell,
const MFloat *const  slopesCell 
)
inline

Definition at line 1153 of file fvcartesiansyseqnns.h.

1154 {
1155 MFloat U2 = F0;
1156 for(MInt i = 0; i < nDim; i++) {
1157 U2 += POW2(pvarsCell[PV->VV[i]]);
1158 }
1159
1160 std::vector<std::vector<MFloat>> dQ(CV->noVariables, std::vector<MFloat>(nDim));
1161
1162 for(MInt d = 0; d < nDim; d++) {
1163 dQ[CV->RHO][d] = slopesCell[PV->RHO * nDim + d];
1164 dQ[CV->RHO_E][d] = slopesCell[PV->P * nDim + d] / (m_gamma - F1) + F1B2 * U2 * slopesCell[PV->RHO * nDim + d];
1165 for(MInt j = 0; j < nDim; j++) {
1166 dQ[CV->RHO_VV[j]][d] =
1167 pvarsCell[PV->VV[j]] * slopesCell[PV->RHO * nDim + d] + pvarsCell[PV->RHO] * slopesCell[PV->VV[j] * nDim + d];
1168 dQ[CV->RHO_E][d] += pvarsCell[PV->RHO] * pvarsCell[PV->VV[j]] * slopesCell[PV->VV[j] * nDim + d];
1169 }
1170 for(MUint s = 0; s < CV->m_noSpecies; ++s) {
1171 dQ[CV->RHO_Y[s]][d] =
1172 pvarsCell[PV->Y[s]] * slopesCell[PV->RHO * nDim + d] + pvarsCell[PV->RHO] * slopesCell[PV->Y[s] * nDim + d];
1173 }
1174 }
1175
1176 return dQ;
1177}

◆ cp_Ref()

template<MInt nDim>
constexpr MFloat FvSysEqnNS< nDim >::cp_Ref ( )
inlineconstexpr

reference heat capacity at const. pressure as used in the non-dimensioanlization (i.e. at the reference condition with reference mixture/state/material)

Definition at line 266 of file fvcartesiansyseqnns.h.

266{ return m_F1BGammaMinusOne; }

◆ CroccoBusemann()

template<MInt nDim>
constexpr MFloat FvSysEqnNS< nDim >::CroccoBusemann ( const MFloat  Ma,
const MFloat  x 
)
inlineconstexpr

Definition at line 233 of file fvcartesiansyseqnns.h.

233 {
234 return (1 + 0.5 * m_gammaMinusOne * POW2(Ma) * x * (1.0 - x));
235 }

◆ cv_Ref()

template<MInt nDim>
constexpr MFloat FvSysEqnNS< nDim >::cv_Ref ( )
inlineconstexpr

reference heat capacity at const. volume as used in the non-dimensioanlization (i.e. at the reference condition with reference mixture/state/material)

Definition at line 270 of file fvcartesiansyseqnns.h.

270{ return m_F1BGamma * m_F1BGammaMinusOne; }

◆ density_ES()

template<MInt nDim>
constexpr MFloat FvSysEqnNS< nDim >::density_ES ( const MFloat  pressure,
const MFloat  temperature 
)
inlineconstexpr

Definition at line 179 of file fvcartesiansyseqnns.h.

179 {
180 return m_gamma * pressure / temperature;
181 }
FvSysEqnNS::pressure
constexpr MFloat pressure(const MFloat density, const MFloat momentumDensitySquared, const MFloat energyDensity)
Definition: fvcartesiansyseqnns.h:207

◆ density_IR()

template<MInt nDim>
constexpr MFloat FvSysEqnNS< nDim >::density_IR ( const MFloat  temperature)
inlineconstexpr

Definition at line 200 of file fvcartesiansyseqnns.h.

200{ return pow(temperature, m_F1BGammaMinusOne); }

◆ density_IR_P()

template<MInt nDim>
constexpr MFloat FvSysEqnNS< nDim >::density_IR_P ( const MFloat  pressure)
inlineconstexpr

Definition at line 203 of file fvcartesiansyseqnns.h.

203{ return pow(pressure * m_gamma, m_F1BGamma); }

◆ enthalpy()

template<MInt nDim>
constexpr MFloat FvSysEqnNS< nDim >::enthalpy ( const MFloat  pressure,
const MFloat  density 
)
inlineconstexpr

Definition at line 223 of file fvcartesiansyseqnns.h.

223 {
224 return pressure / density * m_FGammaBGammaMinusOne;
225 }
FvSysEqnNS::m_FGammaBGammaMinusOne
MFloat m_FGammaBGammaMinusOne
Definition: fvcartesiansyseqnns.h:297

◆ entropy()

template<MInt nDim>
constexpr MFloat FvSysEqnNS< nDim >::entropy ( const MFloat  pressure,
const MFloat  density 
)
inlineconstexpr

Definition at line 228 of file fvcartesiansyseqnns.h.

228 {
229 return pressure / pow(density, m_gamma);
230 }

◆ gamma_Ref()

template<MInt nDim>
constexpr MFloat FvSysEqnNS< nDim >::gamma_Ref ( )
inlineconstexpr

reference heat capacity ratio used in the non-dimensioanlization (i.e. at the reference condition with reference mixture/state/material)

Definition at line 262 of file fvcartesiansyseqnns.h.

262{ return m_gamma; }

◆ getArray012()

template<MInt nDim>
static constexpr std::array< MInt, nDim > FvSysEqnNS< nDim >::getArray012 ( )
inlinestaticconstexprprotected

Definition at line 316 of file fvcartesiansyseqnns.h.

316 {
317 IF_CONSTEXPR(nDim == 2) {
318 std::array<MInt, 2> a = {0, 1};
319 return a;
320 }
321 else {
322 std::array<MInt, 3> a = {0, 1, 2};
323 return a;
324 }
325 }

◆ internalEnergy()

template<MInt nDim>
constexpr MFloat FvSysEqnNS< nDim >::internalEnergy ( const MFloat  pressure,
const MFloat  density,
const MFloat  velocitySquared 
)
inlineconstexpr

energy from primitive variables: pv = (p, rho, u) iE = p / (gamma -1 ) + 0.5 * rho * ||u||^2

Definition at line 214 of file fvcartesiansyseqnns.h.

214 {
215 return pressure * m_F1BGammaMinusOne + 0.5 * density * velocitySquared;
216 }

◆ p_Ref()

template<MInt nDim>
constexpr MFloat FvSysEqnNS< nDim >::p_Ref ( )
inlineconstexpr

reference pressure as used in the non-dimensioanlization (i.e. at the reference condition with reference mixture/state/material)

Definition at line 274 of file fvcartesiansyseqnns.h.

274{ return m_F1BGamma; }

◆ pressure()

template<MInt nDim>
constexpr MFloat FvSysEqnNS< nDim >::pressure ( const MFloat  density,
const MFloat  momentumDensitySquared,
const MFloat  energyDensity 
)
inlineconstexpr

pressure from conservative variables: cv = (rho, ||rho_u||^2, rhoE) p = (gamma - 1) * (rhoE - 0.5 ||rho_u||^2 / rho )

Definition at line 207 of file fvcartesiansyseqnns.h.

208 {
209 return m_gammaMinusOne * (energyDensity - 0.5 / density * momentumDensitySquared);
210 };

◆ pressure_ES()

template<MInt nDim>
constexpr MFloat FvSysEqnNS< nDim >::pressure_ES ( const MFloat  temperture,
const MFloat  density 
)
inlineconstexpr

Definition at line 174 of file fvcartesiansyseqnns.h.

174 {
175 return density * temperture / m_gamma;
176 }

◆ pressure_IR()

template<MInt nDim>
constexpr MFloat FvSysEqnNS< nDim >::pressure_IR ( const MFloat  temperature)
inlineconstexpr

pressure: p = ( T ^(gamma/(gamma -1 ))) / gamma (isentropic relationship) NOTE: this is under consideration of the selected pressure non-dimensionalization!

Definition at line 188 of file fvcartesiansyseqnns.h.

188 {
189 return pow(temperature, m_FGammaBGammaMinusOne) / m_gamma;
190 }

◆ pressure_IRit()

template<MInt nDim>
constexpr MFloat FvSysEqnNS< nDim >::pressure_IRit ( const MFloat  pressure,
const MFloat  massFlux 
)
inlineconstexpr

pressure/density iteration based on mass-flux and p_old NOTE: see thesis of Ingolf Hoerschler

Definition at line 194 of file fvcartesiansyseqnns.h.

194 {
195 return pow(1.0 - m_gammaMinusOne * F1B2 * pow(pressure, -2.0 * m_F1BGamma) * POW2(massFlux),
196 m_FGammaBGammaMinusOne);
197 }

◆ pressureEnergy()

template<MInt nDim>
constexpr MFloat FvSysEqnNS< nDim >::pressureEnergy ( const MFloat  pressure)
inlineconstexpr

energy from primitive pressure variable (or delta p) pE = p / (gamma -1 )

Definition at line 220 of file fvcartesiansyseqnns.h.

220{ return pressure * m_F1BGammaMinusOne; }

◆ readProperties()

template<MInt nDim>
void FvSysEqnNS< nDim >::readProperties ( )
protected

◆ sgn()

template<MInt nDim>
static MFloat FvSysEqnNS< nDim >::sgn ( MFloat  val)
inlinestaticprotected

Definition at line 314 of file fvcartesiansyseqnns.h.

314{ return (val < F0) ? -F1 : F1; }

◆ Slau_()

template<MInt nDim>
void FvSysEqnNS< nDim >::Slau_ ( const MInt  orientation,
const MFloat   NotUsedupwindCoefficient,
const MFloat  A,
const MFloat *const  leftVars,
const MFloat *const  rightVars,
const MFloat *const   NotUsedsrfcCoeff,
MFloat *const  flux 
)
inline

Definition at line 557 of file fvcartesiansyseqnns.h.

559 {
560 if(PV->m_noSpecies > 0) {
561 mTerm(1, "Not yet implemented for multiple-species!");
562 }
563
564 std::array<MFloat, nDim> pFactor = {};
565 pFactor[orientation] = F1;
566
567 const MFloat UL = leftVars[PV->U];
568 const MFloat VL = leftVars[PV->V];
569 MFloat WL = 0.0;
570 IF_CONSTEXPR(nDim == 3) { WL = leftVars[PV->W]; }
571 const MFloat RL = leftVars[PV->RHO];
572 const MFloat PL = leftVars[PV->P];
573
574 const MFloat UR = rightVars[PV->U];
575 const MFloat VR = rightVars[PV->V];
576 MFloat WR = 0.0;
577 IF_CONSTEXPR(nDim == 3) { WR = rightVars[PV->W]; }
578 const MFloat RR = rightVars[PV->RHO];
579 const MFloat PR = rightVars[PV->P];
580
581 const MFloat ql = leftVars[orientation];
582 const MFloat AL = sqrt(m_gamma * PL / RL);
583 MFloat KL = 0.0;
584 IF_CONSTEXPR(nDim == 2) { KL = F1B2 * (UL * UL + VL * VL); }
585 IF_CONSTEXPR(nDim == 3) { KL = F1B2 * (UL * UL + VL * VL + WL * WL); }
586
587 const MFloat HL = (m_gamma * PL) / (m_gammaMinusOne * RL) + KL;
588
589 const MFloat qr = rightVars[orientation];
590 const MFloat AR = sqrt(m_gamma * PR / RR);
591 MFloat KR = 0.0;
592 IF_CONSTEXPR(nDim == 2) { KR = F1B2 * (UR * UR + VR * VR); }
593 IF_CONSTEXPR(nDim == 3) { KR = F1B2 * (UR * UR + VR * VR + WR * WR); }
594
595 const MFloat HR = (m_gamma * PR) / (m_gammaMinusOne * RR) + KR;
596
597 const MFloat ALR = F1B2 * (AL + AR);
598 const MFloat ML = ql / ALR;
599 const MFloat MR = qr / ALR;
600
601 const MFloat BL = (fabs(ML) > F1) ? F1B2 * (F1 + sgn(ML)) : F1B4 * POW2(ML + F1) * (F2 - ML);
602 const MFloat BR = (fabs(MR) > F1) ? F1B2 * (F1 - sgn(MR)) : F1B4 * POW2(MR - F1) * (F2 + MR);
603
604 const MFloat MH = mMin(F1, sqrt(KL + KR) / ALR);
605 const MFloat XI = POW2(F1 - MH);
606 // const MFloat P = F1B2*( PL+PR + (BL-BR)*(PL-PR) + (F1-XI)*(BL+BR-F1)*(PL+PR) ); //SLAU
607 const MFloat P = F1B2 * (PL + PR + (BL - BR) * (PL - PR) + (BL + BR - F1) * sqrt(KL + KR) * (RL + RR) * ALR); // SLAU2
608 const MFloat g = -mMax(mMin(ML, F0), -F1) * mMin(mMax(MR, F0), F1);
609 const MFloat Q = (RL * fabs(ql) + RR * fabs(qr)) / (RL + RR);
610 const MFloat QL = (F1 - g) * Q + g * fabs(ql);
611 const MFloat QR = (F1 - g) * Q + g * fabs(qr);
612 const MFloat M = F1B2 * (RL * (ql + fabs(QL)) + RR * (qr - fabs(QR)) - XI * (PR - PL) / ALR);
613
614 flux[FV->RHO] = M * A;
615 flux[FV->RHO_U] = (F1B2 * ((M + fabs(M)) * UL + (M - fabs(M)) * UR) + P * pFactor[0]) * A;
616 flux[FV->RHO_V] = (F1B2 * ((M + fabs(M)) * VL + (M - fabs(M)) * VR) + P * pFactor[1]) * A;
617 IF_CONSTEXPR(nDim == 3) { flux[FV->RHO_W] = (F1B2 * ((M + fabs(M)) * WL + (M - fabs(M)) * WR) + P * pFactor[2]) * A; }
618 flux[FV->RHO_E] = F1B2 * ((M + fabs(M)) * HL + (M - fabs(M)) * HR) * A;
619}
FvSysEqnNS::sgn
static MFloat sgn(MFloat val)
Definition: fvcartesiansyseqnns.h:314

◆ speedOfSound() [1/2]

template<MInt nDim>
constexpr MFloat FvSysEqnNS< nDim >::speedOfSound ( const MFloat  density,
const MFloat  pressure 
)
inlineconstexpr

Definition at line 157 of file fvcartesiansyseqnns.h.

157 {
158 return std::sqrt(m_gamma * pressure / density);
159 };

◆ speedOfSound() [2/2]

template<MInt nDim>
constexpr MFloat FvSysEqnNS< nDim >::speedOfSound ( const MFloat  temperature)
inlineconstexpr

Definition at line 167 of file fvcartesiansyseqnns.h.

167{ return std::sqrt(temperature); };

◆ speedOfSoundSquared()

template<MInt nDim>
constexpr MFloat FvSysEqnNS< nDim >::speedOfSoundSquared ( const MFloat  density,
const MFloat  pressure 
)
inlineconstexpr

Definition at line 162 of file fvcartesiansyseqnns.h.

162 {
163 return m_gamma * pressure / density;
164 };

◆ sutherlandLaw()

template<MInt nDim>
constexpr MFloat FvSysEqnNS< nDim >::sutherlandLaw ( const MFloat  T)
inlineconstexpr

Sutherland-law of viscosity mue = T^3/2 * (1+S/T_0)(T + S/T_0) with the default values S=110.4 k and T_0 = 273.15 K

Definition at line 246 of file fvcartesiansyseqnns.h.

246 {
247 return (T * sqrt(T) * m_sutherlandPlusOne) / (T + m_sutherlandConstant);
248 }
FvSysEqnNS::m_sutherlandConstant
MFloat m_sutherlandConstant
Definition: fvcartesiansyseqnns.h:303
FvSysEqnNS::m_sutherlandPlusOne
MFloat m_sutherlandPlusOne
Definition: fvcartesiansyseqnns.h:302

◆ temperature_ES()

template<MInt nDim>
constexpr MFloat FvSysEqnNS< nDim >::temperature_ES ( const MFloat  density,
const MFloat  pressure 
)
inlineconstexpr

Definition at line 170 of file fvcartesiansyseqnns.h.

170 {
171 return m_gamma * pressure / density;
172 };

◆ temperature_IR()

template<MInt nDim>
constexpr MFloat FvSysEqnNS< nDim >::temperature_IR ( const MFloat  Ma)
inlineconstexpr

Definition at line 184 of file fvcartesiansyseqnns.h.

184{ return 1 / (1.0 + 0.5 * m_gammaMinusOne * POW2(Ma)); }

◆ vanDriest()

template<MInt nDim>
constexpr MFloat FvSysEqnNS< nDim >::vanDriest ( const MFloat  Ma)
inlineconstexpr

Definition at line 238 of file fvcartesiansyseqnns.h.

238 {
239 return (sqrt((m_gammaMinusOne / 2.0 * POW2(Ma) * pow(m_Pr, F1B3))
240 / (1.0 + m_gammaMinusOne / 2.0 * POW2(Ma) * pow(m_Pr, F1B3))));
241 }

◆ viscousFlux() [1/2]

template<MInt nDim>
template<MInt stencil>
void FvSysEqnNS< nDim >::viscousFlux ( const MInt  orientation,
const MFloat  A,
const MBool  isBndry,
const MFloat *const  surfaceCoords,
const MFloat *const  coord0,
const MFloat *const  coord1,
const MFloat *const  cellVars0,
const MFloat *const  cellVars1,
const MFloat *const  vars0,
const MFloat *const  vars1,
const MFloat *const  slope0,
const MFloat *const  slope1,
const MFloat  f0,
const MFloat  f1,
MFloat *const  flux 
)
inline

Definition at line 86 of file fvcartesiansyseqnns.h.

90 {
91 IF_CONSTEXPR(stencil == THREE_POINT) {
92 viscousFluxThreePoint(orientation, A, isBndry, surfaceCoords, coord0, coord1, cellVars0, cellVars1, vars0, vars1,
93 slope0, slope1, f0, f1, flux);
94 }
95 else IF_CONSTEXPR(stencil == FIVE_POINT_STABILIZED) {
96 viscousFluxStabilized(orientation, A, isBndry, surfaceCoords, coord0, coord1, cellVars0, cellVars1, vars0, vars1,
97 slope0, slope1, f0, f1, flux);
98 }
99 else {
100 TERMM(1, "Viscous Flux Scheme not implemented.");
101 }
102 }
FvSysEqnNS::viscousFluxStabilized
void viscousFluxStabilized(const MInt orientation, const MFloat A, const MBool isBndry, const MFloat *const surfaceCoords, const MFloat *const coord0, const MFloat *const coord1, const MFloat *const cellVars0, const MFloat *const cellVars1, const MFloat *const vars0, const MFloat *const vars1, const MFloat *const slope0, const MFloat *const slope1, const MFloat f0, const MFloat f1, MFloat *const flux)
Computes the viscous fluxes using a five-point stencil (less dissipative) blended with a compact sten...
Definition: fvcartesiansyseqnns.h:988
FvSysEqnNS::viscousFluxThreePoint
void viscousFluxThreePoint(const MInt orientation, const MFloat A, const MBool isBndry, const MFloat *const surfaceCoords, const MFloat *const coord0, const MFloat *const coord1, const MFloat *const cellVars0, const MFloat *const cellVars1, const MFloat *const vars0, const MFloat *const vars1, const MFloat *const slope0, const MFloat *const slope1, const MFloat f0, const MFloat f1, MFloat *const flux)
Definition: fvcartesiansyseqnns.h:863
FIVE_POINT_STABILIZED
@ FIVE_POINT_STABILIZED
Definition: enums.h:184
THREE_POINT
@ THREE_POINT
Definition: enums.h:184

◆ viscousFlux() [2/2]

template<MInt nDim>
template<MInt stencil>
void FvSysEqnNS< nDim >::viscousFlux ( const MInt  orientation,
const MFloat  A,
const MFloat *const  vars0,
const MFloat *const  vars1,
const MFloat *const  slope0,
const MFloat *const  slope1,
const MFloat *const  srfcCoeff,
const MFloat  f0,
const MFloat  f1,
MFloat *const  flux 
)
inline

Definition at line 73 of file fvcartesiansyseqnns.h.

75 {
76 IF_CONSTEXPR(stencil == FIVE_POINT) {
77 viscousFluxFivePoint(orientation, A, vars0, vars1, slope0, slope1, srfcCoeff, f0, f1, flux);
78 }
79 else {
80 TERMM(1, "Viscous Flux Scheme not implemented.");
81 }
82 }
FvSysEqnNS::viscousFluxFivePoint
void viscousFluxFivePoint(const MInt orientation, const MFloat A, const MFloat *const vars0, const MFloat *const vars1, const MFloat *const slope0, const MFloat *const slope1, const MFloat *const NotUsed(srfcCoeff), const MFloat f0, const MFloat f1, MFloat *const flux)
Definition: fvcartesiansyseqnns.h:727
FIVE_POINT
@ FIVE_POINT
Definition: enums.h:184

◆ viscousFluxFivePoint()

template<MInt nDim>
void FvSysEqnNS< nDim >::viscousFluxFivePoint ( const MInt  orientation,
const MFloat  A,
const MFloat *const  vars0,
const MFloat *const  vars1,
const MFloat *const  slope0,
const MFloat *const  slope1,
const MFloat *const   NotUsedsrfcCoeff,
const MFloat  f0,
const MFloat  f1,
MFloat *const  flux 
)
inline

Definition at line 727 of file fvcartesiansyseqnns.h.

730 {
731 static const MFloat rhoUDth = m_muInfinity * m_F1BPr;
732 static const MFloat F1BRe0 = F1 / m_Re0;
733
734 // calculate the primitve variables on the surface u,v,rho,p
735 const std::array<MFloat, nDim> velocity = [&] {
736 std::array<MFloat, nDim> tmp{};
737 for(MUint n = 0; n < nDim; n++) {
738 tmp[n] = F1B2 * (vars0[PV->VV[n]] + vars1[PV->VV[n]]);
739 }
740 return tmp;
741 }();
742
743 const MFloat rho = F1B2 * (vars0[PV->RHO] + vars1[PV->RHO]);
744 const MFloat Frho = F1 / rho;
745 const MFloat p = F1B2 * (vars0[PV->P] + vars1[PV->P]);
746
747 // Temperature on the surface T = gamma * p / rho
748 const MFloat T = m_gamma * p * Frho;
749
750 // Indices for the orientations
751 const MUint id0 = orientation;
752 const MUint id1 = index0[orientation];
753 const MUint id2 = index1[orientation];
754
755 // Compute A / Re
756 const MFloat dAOverRe = A * F1BRe0;
757
758 // calculate the viscosity with the sutherland law mue = T^3/2 * (1+S/T_0)(T + S/T_0)
759 const MFloat mue = (T * sqrt(T) * m_sutherlandPlusOne) / (T + m_sutherlandConstant);
760
761 // calculate the heat flux (T_x = gamma*(p_x/rho - p/rho^2 * rho_x))
762
763 const MFloat lambda = (T * sqrt(T) * m_sutherlandPlusOneThermal) / (T + m_sutherlandConstantThermal);
764
765 const MUint sq0 = PV->P * nDim + id0;
766 const MUint sq1 = PV->RHO * nDim + id0;
767 const MFloat q = (lambda)*m_gFGMOrPr * Frho
768 * ((f0 * slope0[sq0] + f1 * slope1[sq0]) - p * Frho * (f0 * slope0[sq1] + f1 * slope1[sq1]));
769
770 // Compute the stress terms
771 const MUint s00 = id0 * nDim + id0;
772 const MUint s01 = id0 * nDim + id1;
773 const MUint s10 = id1 * nDim + id0;
774 const MUint s11 = id1 * nDim + id1;
775
776 std::array<MFloat, nDim> tau{};
777 IF_CONSTEXPR(nDim == 2) {
778 tau[id0] = mue * (f0 * (F4B3 * slope0[s00] - F2B3 * slope0[s11]) + f1 * (F4B3 * slope1[s00] - F2B3 * slope1[s11]));
779 tau[id1] = mue * (f0 * (slope0[s01] + slope0[s10]) + f1 * (slope1[s01] + slope1[s10]));
780 }
781 else IF_CONSTEXPR(nDim == 3) {
782 const MUint s22 = id2 * nDim + id2;
783 const MUint s02 = id0 * nDim + id2;
784 const MUint s20 = id2 * nDim + id0;
785 tau[id0] = mue
786 * (f0 * (F4B3 * slope0[s00] - F2B3 * (slope0[s11] + slope0[s22]))
787 + f1 * (F4B3 * slope1[s00] - F2B3 * (slope1[s11] + slope1[s22])));
788 tau[id1] = mue * (f0 * (slope0[s01] + slope0[s10]) + f1 * (slope1[s01] + slope1[s10]));
789 tau[id2] = mue * (f0 * (slope0[s02] + slope0[s20]) + f1 * (slope1[s02] + slope1[s20]));
790 }
791
792 // Compute the flux
793 for(MUint n = 0; n < nDim; n++) {
794 flux[FV->RHO_VV[n]] -= dAOverRe * tau[n];
795 }
796 flux[FV->RHO_E] -= dAOverRe * (std::inner_product(velocity.begin(), velocity.end(), tau.begin(), 0.0) + q);
797
798 // progress variable
799 const MFloat c = dAOverRe * rhoUDth;
800 for(MUint s = 0; s < PV->m_noSpecies; ++s) {
801 const MUint i = PV->Y[s] * nDim + id0;
802 flux[FV->RHO_Y[s]] -= c * (f0 * slope0[i] + f1 * slope1[i]);
803 }
804}
FvSysEqnNS::m_sutherlandPlusOneThermal
MFloat m_sutherlandPlusOneThermal
Definition: fvcartesiansyseqnns.h:304
FvSysEqnNS::index1
static const MUint index1[nDim]
Definition: fvcartesiansyseqnns.h:353
FvSysEqnNS::index0
static const MUint index0[nDim]
Definition: fvcartesiansyseqnns.h:350
FvSysEqnNS::m_sutherlandConstantThermal
MFloat m_sutherlandConstantThermal
Definition: fvcartesiansyseqnns.h:305
maia::fc::cell::p
constexpr std::underlying_type< FcCell >::type p(const FcCell property)
Converts property name to underlying integer value.
Definition: fccellproperties.h:32

◆ viscousFluxStabilized()

template<MInt nDim>
void FvSysEqnNS< nDim >::viscousFluxStabilized ( const MInt  orientation,
const MFloat  A,
const MBool  isBndry,
const MFloat *const  surfaceCoords,
const MFloat *const  coord0,
const MFloat *const  coord1,
const MFloat *const  cellVars0,
const MFloat *const  cellVars1,
const MFloat *const  vars0,
const MFloat *const  vars1,
const MFloat *const  slope0,
const MFloat *const  slope1,
const MFloat  f0,
const MFloat  f1,
MFloat *const  flux 
)
inline
Author
Lennart Schneiders, Konstantin Froehlich, refactored and moved here: Julian Vorspohl

Definition at line 988 of file fvcartesiansyseqnns.h.

994 {
995 static const MFloat rhoUDth = m_muInfinity * m_F1BPr;
996 static const MFloat F1BRe0 = F1 / m_Re0;
997 const MFloat fac = m_enhanceThreePointViscFluxFactor; // increased stability
998
999 // calculate the primitve variables on the surface u,v,rho,p
1000 const std::array<MFloat, nDim> velocity = [&] {
1001 std::array<MFloat, nDim> tmp{};
1002 for(MUint n = 0; n < nDim; n++) {
1003 tmp[n] = F1B2 * (vars0[PV->VV[n]] + vars1[PV->VV[n]]);
1004 }
1005 return tmp;
1006 }();
1007
1008 const MFloat rho = F1B2 * (vars0[PV->RHO] + vars1[PV->RHO]);
1009 const MFloat Frho = F1 / rho;
1010 const MFloat p = F1B2 * (vars0[PV->P] + vars1[PV->P]);
1011
1012 // Temperature on the surface T = gamma * p / rho
1013 const MFloat T = m_gamma * p * Frho;
1014
1015 // Indices for the orientations
1016 const MUint id0 = orientation;
1017 const MUint id1 = index0[orientation];
1018 const MUint id2 = index1[orientation];
1019
1020 // Compute A / Re
1021 const MFloat dAOverRe = A * F1BRe0;
1022
1023 // calculate the viscosity with the sutherland law mue = T^3/2 * (1+S/T_0)(T + S/T_0)
1024 const MFloat mue = (T * sqrt(T) * m_sutherlandPlusOne) / (T + m_sutherlandConstant);
1025
1026 const MFloat lambda = (T * sqrt(T) * m_sutherlandPlusOneThermal) / (T + m_sutherlandConstantThermal);
1027
1028 // TODO labels:FV @Julian, change to stack alloc
1029 std::vector<MFloat> slopes(PV->noVariables * nDim);
1030
1031 /*#ifdef _VISCOUS_SLOPES_COMPACT_VARIANT_
1032 const MFloat dx = F1B2 * (coord1[id0] - coord0[id0]);
1033 #endif*/
1034 for(MInt var = 0; var < PV->noVariables; var++) {
1035 slopes[nDim * var + id0] =
1036 cellVars1[var]
1037 - cellVars0[var]
1038 /*#ifdef _VISCOUS_SLOPES_COMPACT_VARIANT_
1039 + (surfaceCoords[id0] - coord1[id0] + dx) * slope1[var * nDim + id0]
1040 - (surfaceCoords[id0] - coord0[id0] - dx) * slope0[var * nDim + id0]
1041 #endif*/
1042 + (surfaceCoords[id1] - coord1[id1]) * slope1[var * nDim + id1]
1043 - (surfaceCoords[id1] - coord0[id1]) * slope0[var * nDim + id1];
1044 IF_CONSTEXPR(nDim == 3) {
1045 slopes[nDim * var + id0] += (surfaceCoords[id2] - coord1[id2]) * slope1[var * nDim + id2]
1046 - (surfaceCoords[id2] - coord0[id2]) * slope0[var * nDim + id2];
1047 }
1048 /*#ifdef _VISCOUS_SLOPES_COMPACT_VARIANT_
1049 )
1050 / (F2 * dx);
1051 #else*/
1052 // )
1053 slopes[nDim * var + id0] /= (coord1[id0] - coord0[id0]);
1054
1055
1056 //#endif
1057 slopes[nDim * var + id1] = f0 * slope0[var * nDim + id1] + f1 * slope1[var * nDim + id1];
1058 IF_CONSTEXPR(nDim == 3) {
1059 slopes[nDim * var + id2] = f0 * slope0[var * nDim + id2] + f1 * slope1[var * nDim + id2];
1060 }
1061
1062 slopes[nDim * var + id0] =
1063 fac * slopes[nDim * var + id0] + (1.0 - fac) * (f0 * slope0[var * nDim + id0] + f1 * slope1[var * nDim + id0]);
1064
1065 if(isBndry) {
1066 slopes[nDim * var + id0] = f0 * slope0[var * nDim + id0] + f1 * slope1[var * nDim + id0];
1067 }
1068 }
1069
1070 const MUint sq0 = PV->P * nDim + id0;
1071 const MUint sq1 = PV->RHO * nDim + id0;
1072
1073 const MFloat q = lambda * m_gFGMOrPr * Frho * (slopes[sq0] - p * Frho * slopes[sq1]);
1074
1075 // Compute the stress terms
1076 const MUint s00 = id0 * nDim + id0;
1077 const MUint s01 = id0 * nDim + id1;
1078 const MUint s10 = id1 * nDim + id0;
1079 const MUint s11 = id1 * nDim + id1;
1080
1081 std::array<MFloat, nDim> tau{};
1082 IF_CONSTEXPR(nDim == 2) {
1083 tau[id0] = mue * (F4B3 * slopes[s00] - F2B3 * slopes[s11]);
1084 tau[id1] = mue * (slopes[s01] + slopes[s10]);
1085 }
1086 else IF_CONSTEXPR(nDim == 3) {
1087 const MUint s22 = id2 * nDim + id2;
1088 const MUint s02 = id0 * nDim + id2;
1089 const MUint s20 = id2 * nDim + id0;
1090 tau[id0] = mue * (F4B3 * slopes[s00] - F2B3 * (slopes[s11] + slopes[s22]));
1091 tau[id1] = mue * (slopes[s01] + slopes[s10]);
1092 tau[id2] = mue * (slopes[s02] + slopes[s20]);
1093 }
1094
1095 // Compute the flux
1096 for(MUint n = 0; n < nDim; n++) {
1097 flux[FV->RHO_VV[n]] -= dAOverRe * tau[n];
1098 }
1099 flux[FV->RHO_E] -= dAOverRe * (std::inner_product(velocity.begin(), velocity.end(), tau.begin(), 0.0) + q);
1100
1101 // progress variable
1102 const MFloat c = dAOverRe * rhoUDth;
1103 for(MUint s = 0; s < PV->m_noSpecies; ++s) {
1104 const MUint i = PV->Y[s] * nDim + id0;
1105 flux[FV->RHO_Y[s]] -= c * (f0 * slope0[i] + f1 * slope1[i]);
1106 }
1107}
FvSysEqnNS::m_enhanceThreePointViscFluxFactor
MFloat m_enhanceThreePointViscFluxFactor
Definition: fvcartesiansyseqnns.h:309

◆ viscousFluxThreePoint()

template<MInt nDim>
void FvSysEqnNS< nDim >::viscousFluxThreePoint ( const MInt  orientation,
const MFloat  A,
const MBool  isBndry,
const MFloat *const  surfaceCoords,
const MFloat *const  coord0,
const MFloat *const  coord1,
const MFloat *const  cellVars0,
const MFloat *const  cellVars1,
const MFloat *const  vars0,
const MFloat *const  vars1,
const MFloat *const  slope0,
const MFloat *const  slope1,
const MFloat  f0,
const MFloat  f1,
MFloat *const  flux 
)
inline

Definition at line 863 of file fvcartesiansyseqnns.h.

869 {
870 static const MFloat rhoUDth = m_muInfinity * m_F1BPr;
871 static const MFloat F1BRe0 = F1 / m_Re0;
872
873 // calculate the primitve variables on the surface u,v,rho,p
874 const std::array<MFloat, nDim> velocity = [&] {
875 std::array<MFloat, nDim> tmp{};
876 for(MUint n = 0; n < nDim; n++) {
877 tmp[n] = F1B2 * (vars0[PV->VV[n]] + vars1[PV->VV[n]]);
878 }
879 return tmp;
880 }();
881
882 const MFloat rho = F1B2 * (vars0[PV->RHO] + vars1[PV->RHO]);
883 const MFloat Frho = F1 / rho;
884 const MFloat p = F1B2 * (vars0[PV->P] + vars1[PV->P]);
885
886 // Temperature on the surface T = gamma * p / rho
887 const MFloat T = m_gamma * p * Frho;
888
889 // Indices for the orientations
890 const MUint id0 = orientation;
891 const MUint id1 = index0[orientation];
892 const MUint id2 = index1[orientation];
893
894 // Compute A / Re
895 const MFloat dAOverRe = A * F1BRe0;
896
897 // calculate the viscosity with the sutherland law mue = T^3/2 * (1+S/T_0)(T + S/T_0)
898 const MFloat mue = (T * sqrt(T) * m_sutherlandPlusOne) / (T + m_sutherlandConstant);
899
900 const MFloat lambda = (T * sqrt(T) * m_sutherlandPlusOneThermal) / (T + m_sutherlandConstantThermal);
901
902 // TODO labels:FV @Julian, change to stack alloc
903 std::vector<MFloat> slopes(PV->noVariables * nDim);
904
905 /*#ifdef _VISCOUS_SLOPES_COMPACT_VARIANT_
906 const MFloat dx = F1B2 * (coord1[id0] - coord0[id0]);
907 #endif*/
908 for(MInt var = 0; var < PV->noVariables; var++) {
909 slopes[nDim * var + id0] =
910 cellVars1[var]
911 - cellVars0[var]
912 /*#ifdef _VISCOUS_SLOPES_COMPACT_VARIANT_
913 + (surfaceCoords[id0] - coord1[id0] + dx) * slope1[var * nDim + id0]
914 - (surfaceCoords[id0] - coord0[id0] - dx) * slope0[var * nDim + id0]
915 #endif*/
916 + (surfaceCoords[id1] - coord1[id1]) * slope1[var * nDim + id1]
917 - (surfaceCoords[id1] - coord0[id1]) * slope0[var * nDim + id1];
918 IF_CONSTEXPR(nDim == 3) {
919 slopes[nDim * var + id0] += (surfaceCoords[id2] - coord1[id2]) * slope1[var * nDim + id2]
920 - (surfaceCoords[id2] - coord0[id2]) * slope0[var * nDim + id2];
921 }
922 /*#ifdef _VISCOUS_SLOPES_COMPACT_VARIANT_
923 )
924 / (F2 * dx);
925 #else*/
926 // )
927 slopes[nDim * var + id0] /= (coord1[id0] - coord0[id0]);
928
929
930 //#endif
931 slopes[nDim * var + id1] = f0 * slope0[var * nDim + id1] + f1 * slope1[var * nDim + id1];
932 IF_CONSTEXPR(nDim == 3) {
933 slopes[nDim * var + id2] = f0 * slope0[var * nDim + id2] + f1 * slope1[var * nDim + id2];
934 }
935 if(isBndry) {
936 slopes[nDim * var + id0] = f0 * slope0[var * nDim + id0] + f1 * slope1[var * nDim + id0];
937 }
938 }
939
940 const MUint sq0 = PV->P * nDim + id0;
941 const MUint sq1 = PV->RHO * nDim + id0;
942
943 const MFloat q = lambda * m_gFGMOrPr * Frho * (slopes[sq0] - p * Frho * slopes[sq1]);
944
945 // Compute the stress terms
946 const MUint s00 = id0 * nDim + id0;
947 const MUint s01 = id0 * nDim + id1;
948 const MUint s10 = id1 * nDim + id0;
949 const MUint s11 = id1 * nDim + id1;
950
951 std::array<MFloat, nDim> tau{};
952 IF_CONSTEXPR(nDim == 2) {
953 tau[id0] = mue * (F4B3 * slopes[s00] - F2B3 * slopes[s11]);
954 tau[id1] = mue * (slopes[s01] + slopes[s10]);
955 }
956 else IF_CONSTEXPR(nDim == 3) {
957 const MUint s22 = id2 * nDim + id2;
958 const MUint s02 = id0 * nDim + id2;
959 const MUint s20 = id2 * nDim + id0;
960 tau[id0] = mue * (F4B3 * slopes[s00] - F2B3 * (slopes[s11] + slopes[s22]));
961 tau[id1] = mue * (slopes[s01] + slopes[s10]);
962 tau[id2] = mue * (slopes[s02] + slopes[s20]);
963 }
964
965 // Compute the flux
966 for(MUint n = 0; n < nDim; n++) {
967 flux[FV->RHO_VV[n]] -= dAOverRe * tau[n];
968 }
969 flux[FV->RHO_E] -= dAOverRe * (std::inner_product(velocity.begin(), velocity.end(), tau.begin(), 0.0) + q);
970
971 // progress variable
972 const MFloat c = dAOverRe * rhoUDth;
973 for(MUint s = 0; s < PV->m_noSpecies; ++s) {
974 const MUint i = PV->Y[s] * nDim + id0;
975 flux[FV->RHO_Y[s]] -= c * (f0 * slope0[i] + f1 * slope1[i]);
976 }
977}

◆ wmViscousFluxCorrection()

template<MInt nDim>
template<MInt stencil>
void FvSysEqnNS< nDim >::wmViscousFluxCorrection ( const MInt  orientation,
const MFloat  A,
const MFloat *const  vars0,
const MFloat *const  vars1,
const MFloat *const  slope0,
const MFloat *const  slope1,
const MFloat  f0,
const MFloat  f1,
MFloat *const  flux,
MFloat const  mue_wm 
)
inline

Definition at line 125 of file fvcartesiansyseqnns.h.

127 {
128 IF_CONSTEXPR(stencil == FIVE_POINT) {
129 wmViscousFluxCorrectionFivePoint(orientation, A, vars0, vars1, slope0, slope1, f0, f1, flux, mue_wm);
130 }
131 else {
132 TERMM(1, "Viscous Flux Scheme not implemented.");
133 }
134 }
FvSysEqnNS::wmViscousFluxCorrectionFivePoint
void wmViscousFluxCorrectionFivePoint(const MInt orientation, const MFloat A, const MFloat *const vars0, const MFloat *const vars1, const MFloat *const slope0, const MFloat *const slope1, const MFloat f0, const MFloat f1, MFloat *const flux, MFloat const mue_wm)
Definition: fvcartesiansyseqnns.h:807

◆ wmViscousFluxCorrectionFivePoint()

template<MInt nDim>
void FvSysEqnNS< nDim >::wmViscousFluxCorrectionFivePoint ( const MInt  orientation,
const MFloat  A,
const MFloat *const  vars0,
const MFloat *const  vars1,
const MFloat *const  slope0,
const MFloat *const  slope1,
const MFloat  f0,
const MFloat  f1,
MFloat *const  flux,
MFloat const  mue_wm 
)
inline

Definition at line 807 of file fvcartesiansyseqnns.h.

811 {
812 static const MFloat F1BRe0 = F1 / m_Re0;
813
814
815 // calculate the primitve variables on the surface u,v,rho,p
816 const std::array<MFloat, nDim> velocity = [&] {
817 std::array<MFloat, nDim> tmp{};
818 for(MUint n = 0; n < nDim; n++) {
819 tmp[n] = F1B2 * (vars0[PV->VV[n]] + vars1[PV->VV[n]]);
820 }
821 return tmp;
822 }();
823
824 // Indices for the orientations
825 const MUint id0 = orientation;
826 const MUint id1 = index0[orientation];
827 const MUint id2 = index1[orientation];
828
829 // Compute A / Re
830 const MFloat dAOverRe = A * F1BRe0;
831
832 // Compute the stress terms
833 const MUint s00 = id0 * nDim + id0;
834 const MUint s01 = id0 * nDim + id1;
835 const MUint s10 = id1 * nDim + id0;
836 const MUint s11 = id1 * nDim + id1;
837
838 std::array<MFloat, nDim> tau{};
839 IF_CONSTEXPR(nDim == 2) {
840 tau[id0] =
841 mue_wm * (f0 * (F4B3 * slope0[s00] - F2B3 * slope0[s11]) + f1 * (F4B3 * slope1[s00] - F2B3 * slope1[s11]));
842 tau[id1] = mue_wm * (f0 * (slope0[s01] + slope0[s10]) + f1 * (slope1[s01] + slope1[s10]));
843 }
844 else IF_CONSTEXPR(nDim == 3) {
845 const MUint s22 = id2 * nDim + id2;
846 const MUint s02 = id0 * nDim + id2;
847 const MUint s20 = id2 * nDim + id0;
848 tau[id0] = mue_wm
849 * (f0 * (F4B3 * slope0[s00] - F2B3 * (slope0[s11] + slope0[s22]))
850 + f1 * (F4B3 * slope1[s00] - F2B3 * (slope1[s11] + slope1[s22])));
851 tau[id1] = mue_wm * (f0 * (slope0[s01] + slope0[s10]) + f1 * (slope1[s01] + slope1[s10]));
852 tau[id2] = mue_wm * (f0 * (slope0[s02] + slope0[s20]) + f1 * (slope1[s02] + slope1[s20]));
853 }
854
855 // Correct the fluxes
856 for(MUint n = 0; n < nDim; n++) {
857 flux[CV->RHO_VV[n]] -= dAOverRe * tau[n];
858 }
859 flux[CV->RHO_E] -= dAOverRe * (std::inner_product(velocity.begin(), velocity.end(), tau.begin(), 0.0));
860}

Member Data Documentation

◆ AV

template<MInt nDim>
AdditionalVariables* FvSysEqnNS< nDim >::AV = nullptr

Definition at line 345 of file fvcartesiansyseqnns.h.

◆ CV

template<MInt nDim>
ConservativeVariables* FvSysEqnNS< nDim >::CV = nullptr

Definition at line 342 of file fvcartesiansyseqnns.h.

◆ FV

template<MInt nDim>
FluxVariables* FvSysEqnNS< nDim >::FV = nullptr

Definition at line 343 of file fvcartesiansyseqnns.h.

◆ hasAV

template<MInt nDim>
constexpr MBool FvSysEqnNS< nDim >::hasAV = false
staticconstexpr

Definition at line 340 of file fvcartesiansyseqnns.h.

◆ hasSC

template<MInt nDim>
constexpr MBool FvSysEqnNS< nDim >::hasSC = false
staticconstexpr

Definition at line 341 of file fvcartesiansyseqnns.h.

◆ index0

template<MInt nDim>
const MUint FvSysEqnNS< nDim >::index0[nDim]
static

Definition at line 350 of file fvcartesiansyseqnns.h.

◆ index1

template<MInt nDim>
const MUint FvSysEqnNS< nDim >::index1[nDim]
static

Definition at line 353 of file fvcartesiansyseqnns.h.

◆ m_centralizeSurfaceVariablesFactor

template<MInt nDim>
MFloat FvSysEqnNS< nDim >::m_centralizeSurfaceVariablesFactor = 0.0
protected

Definition at line 311 of file fvcartesiansyseqnns.h.

◆ m_enhanceThreePointViscFluxFactor

template<MInt nDim>
MFloat FvSysEqnNS< nDim >::m_enhanceThreePointViscFluxFactor {}
protected

Definition at line 309 of file fvcartesiansyseqnns.h.

◆ m_F1BGamma

template<MInt nDim>
MFloat FvSysEqnNS< nDim >::m_F1BGamma = 1 / m_gamma
protected

Definition at line 298 of file fvcartesiansyseqnns.h.

◆ m_F1BGammaMinusOne

template<MInt nDim>
MFloat FvSysEqnNS< nDim >::m_F1BGammaMinusOne = 1 / m_gammaMinusOne
protected

Definition at line 296 of file fvcartesiansyseqnns.h.

◆ m_F1BPr

template<MInt nDim>
MFloat FvSysEqnNS< nDim >::m_F1BPr = 1 / m_Pr
protected

Definition at line 300 of file fvcartesiansyseqnns.h.

◆ m_FGammaBGammaMinusOne

template<MInt nDim>
MFloat FvSysEqnNS< nDim >::m_FGammaBGammaMinusOne = m_gamma / m_gammaMinusOne
protected

Definition at line 297 of file fvcartesiansyseqnns.h.

◆ m_gamma

template<MInt nDim>
MFloat FvSysEqnNS< nDim >::m_gamma = 1.4
protected

Definition at line 294 of file fvcartesiansyseqnns.h.

◆ m_gammaMinusOne

template<MInt nDim>
MFloat FvSysEqnNS< nDim >::m_gammaMinusOne = m_gamma - 1
protected

Definition at line 295 of file fvcartesiansyseqnns.h.

◆ m_gFGMOrPr

template<MInt nDim>
MFloat FvSysEqnNS< nDim >::m_gFGMOrPr = {}
protected

Definition at line 306 of file fvcartesiansyseqnns.h.

◆ m_muInfinity

template<MInt nDim>
MFloat FvSysEqnNS< nDim >::m_muInfinity = {}

Definition at line 330 of file fvcartesiansyseqnns.h.

◆ m_noRansEquations

template<MInt nDim>
constexpr MInt FvSysEqnNS< nDim >::m_noRansEquations = 0
staticconstexpr

Definition at line 285 of file fvcartesiansyseqnns.h.

◆ m_noSpecies

template<MInt nDim>
MUint FvSysEqnNS< nDim >::m_noSpecies
protected

Definition at line 289 of file fvcartesiansyseqnns.h.

◆ m_Pr

template<MInt nDim>
MFloat FvSysEqnNS< nDim >::m_Pr = 0.72
protected

Definition at line 299 of file fvcartesiansyseqnns.h.

◆ m_ransModel

template<MInt nDim>
constexpr MInt FvSysEqnNS< nDim >::m_ransModel = NORANS
staticconstexpr

Definition at line 286 of file fvcartesiansyseqnns.h.

◆ m_Re0

template<MInt nDim>
MFloat FvSysEqnNS< nDim >::m_Re0 = {}

Definition at line 329 of file fvcartesiansyseqnns.h.

◆ m_referenceTemperature

template<MInt nDim>
MFloat FvSysEqnNS< nDim >::m_referenceTemperature = {}
protected

Definition at line 301 of file fvcartesiansyseqnns.h.

◆ m_solverId

template<MInt nDim>
MInt FvSysEqnNS< nDim >::m_solverId
protected

Definition at line 291 of file fvcartesiansyseqnns.h.

◆ m_sutherlandConstant

template<MInt nDim>
MFloat FvSysEqnNS< nDim >::m_sutherlandConstant = {}
protected

Definition at line 303 of file fvcartesiansyseqnns.h.

◆ m_sutherlandConstantThermal

template<MInt nDim>
MFloat FvSysEqnNS< nDim >::m_sutherlandConstantThermal = {}
protected

Definition at line 305 of file fvcartesiansyseqnns.h.

◆ m_sutherlandPlusOne

template<MInt nDim>
MFloat FvSysEqnNS< nDim >::m_sutherlandPlusOne = {}
protected

Definition at line 302 of file fvcartesiansyseqnns.h.

◆ m_sutherlandPlusOneThermal

template<MInt nDim>
MFloat FvSysEqnNS< nDim >::m_sutherlandPlusOneThermal = {}
protected

Definition at line 304 of file fvcartesiansyseqnns.h.

◆ PV

template<MInt nDim>
PrimitiveVariables* FvSysEqnNS< nDim >::PV = nullptr

Definition at line 344 of file fvcartesiansyseqnns.h.

◆ SC

template<MInt nDim>
SurfaceCoefficients* FvSysEqnNS< nDim >::SC = nullptr

Definition at line 346 of file fvcartesiansyseqnns.h.

The documentation for this class was generated from the following files: