Class containing the special methods of the detailed chemistry formulation. Inherits from the Navier-Stokes equation class. More...

#include <fvcartesiansyseqndetchem.h>

Inheritance diagram for FvSysEqnDetChem< nDim >:

[legend]

Collaboration diagram for FvSysEqnDetChem< nDim >:

[legend]

Classes
struct	AdditionalVariables
	Static indices for accessing additional variables. 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	NASACoefficients
	Stores all NASA coefficients. NASA coefficients are used to compute the cp and cv values. Additional, modified NASA coefficients are stored, which are used to compute the sensible energy. For now only valid for NASA-7 coefficients, which have low temperature and high temperature regions, each one described by a different polynomial. More...

struct	PrimitiveVariables
	Static indices for accessing primitive variables in nDim spatial dimensions. More...

struct	SpeciesProperties
	Struct for storing all relevant species information, which is read from a given mechanism file. More...

struct	SurfaceCoefficients
	Static indices for accessing surface coefficients. More...

Public Member Functions
	FvSysEqnDetChem (const MInt solverId, const MInt noSpecies)
	Construct a new FvSysEqnDetChem<nDim>::FvSysEqnDetChem object. More...

template<MInt stencil = 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	AusmBndryCorrection (const MInt orientation, const MFloat A, const MFloat const leftVars, const MFloat const rightVars, MFloat *const flux)

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, const MFloat, const MBool, const MFloat const, const MFloat const, const MFloat const, const MFloat const, const MFloat const, const MFloat const, const MFloat const, const MFloat const, const MFloat const, const MFloat, const MFloat, MFloat const)

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 srfcCoeff, const MFloat f0, const MFloat f1, MFloat const flux)

void	getSpeciesDiffusionMassFluxes (const MInt orientation, 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, std::vector< MFloat > &J, std::vector< MFloat > &dXdn, MFloat &dTdn, const MBool soretEffect)

void	computeSurfaceCoefficients (const MInt RKStep, const MFloat const vars0, const MFloat const vars1, MFloat *const srfcCoeff, std::shared_ptr< Cantera::ThermoPhase > gas, std::shared_ptr< Cantera::Transport > trans)
	Computes the transport coefficients at the surface. These are then used in the computation of the surface diffusion fluxes. More...

void	computeSpeciesReactionRates (const MFloat &m_timeStep, const MFloat &cellVolume, const MFloat const pvarsCell, const MFloat const avarsCell, MFloat const reactionRatesCell, Cantera::IdealGasReactor zeroD_reactor, Cantera::ReactorNet *zeroD_reactorNet, std::shared_ptr< Cantera::Solution > sol, std::shared_ptr< Cantera::ThermoPhase > gas)
	Computes the species reaction rates. A reactor is constructed at each cell, with equal thermodynamic state. The reactor content is then integrated in time and advanced by the same amount as the flow simulation. From the initial and final concentrations of species, a time averaged species reaction rate is computed, which can then be used in the species equations in the flow solver. More...

void	computePrimitiveVariables (const MFloat const cvarsCell, MFloat const pvarsCell, const MFloat *const avarsCell)

void	computeConservativeVariables (const MFloat const pvarsCell, MFloat const cvarsCell, const MFloat *const avarsCell)

void	evaluateSensibleEnergy (MFloat &sensibleEnergy, const MFloat *const pvarsCell, const MFloat &meanMolarMass)
	Computes the sensible energy. Species sensible energy is computed as: e_s = Int(cv(T)dT) - R*T_ref/W_mean. More...

void	iterateTemperature (MFloat &T, const MFloat const cvarsCell, const MFloat const pvarsCell, const MFloat *const avarsCell, const MFloat &velPOW2)
	Iterates the temperature from the sensible energy. Iteration is necessary, since the heat capacities are a function of temperature. The iteration is performed with a Newton iterative Method. More...

void	computeMeanMolarWeight_PV (const MFloat const pvarsCell, MFloat const avarsCell)
	Computes the mean molar weight from the primitive variables at the cell. More...

void	computeMeanMolarWeight_CV (const MFloat const pvarsCell, MFloat const avarsCell)
	Computes the mean molar weight from the conservative variables at the cell. More...

void	computeGamma (const MFloat const pvarsCell, MFloat const avarsCell, std::shared_ptr< Cantera::ThermoPhase > gas)
	Computes gamma at the cell. Used for the computation of the time step. More...

MFloat	computePhi (const MFloat *const Y)

std::vector< std::vector< MFloat > >	conservativeSlopes (const MFloat const pvarsCell, const MFloat const cvarsCell, const MFloat const avarsCell, const MFloat const slopesCell)
	Reconstructs the conservative slopes from the primitive variables and primitive slopes at the cell. Used in the interpolation of the conservative variables unto the newly created leaf cells during the grid refinement step. More...

	FvSysEqnDetChem (const MInt solverId, const MInt noSpecies)

void	evaluateSensibleEnergy (MFloat &, const MFloat *const, const MFloat &)

void	computeMeanMolarWeight_PV (const MFloat const, MFloat const)

void	computeMeanMolarWeight_CV (const MFloat const, MFloat const)

Public Member Functions inherited from FvSysEqnNS< nDim >
	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 + enhanceThreePointViscFluxFactorTHREE_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
SpeciesProperties *	m_species = nullptr

NASACoefficients *	m_NASA = nullptr

ConservativeVariables *	CV = nullptr

FluxVariables *	FV = nullptr

PrimitiveVariables *	PV = nullptr

AdditionalVariables *	AV = nullptr

SurfaceCoefficients *	SC = nullptr

MBool	m_soretEffect

MString	m_oxidizer

MString	m_fuel

MFloat	m_fuelOxidizerStochiometricRatio

MFloat	m_muInfinity

MFloat	m_Re0

Public Attributes inherited from FvSysEqnNS< nDim >
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 MBool	hasAV = true

static constexpr MBool	hasSC = true

Static Public Attributes inherited from FvSysEqnNS< nDim >
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]

Private Types
using	Base = FvSysEqnNS< nDim >

Private Member Functions
void	readProperties ()
	Reads important variable values from the properties.toml file. More...

void	allocateNoDiffusionCoefficients (const MInt)
	Allocates the correct number of diffusion coefficients depending on the chosen diffusion model. Valid entries are "Multi" for multicomponent diffusion model and "Mix" for mixture-averaged model. More...

Static Private Member Functions
static constexpr std::array< MInt, nDim >	getArray012 ()

Static Private Attributes
static const MUint	index0 [nDim]

static const MUint	index1 [nDim]

Additional Inherited Members
Protected Member Functions inherited from FvSysEqnNS< nDim >
void	readProperties ()

Static Protected Member Functions inherited from FvSysEqnNS< nDim >
static MFloat	sgn (MFloat val)

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

Protected Attributes inherited from FvSysEqnNS< nDim >
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 FvSysEqnDetChem< nDim >

Template Parameters

nDim	Number of dimensions

Definition at line 42 of file fvcartesiansyseqndetchem.h.

Member Typedef Documentation

◆ Base

template<MInt nDim>

using FvSysEqnDetChem< nDim >::Base = FvSysEqnNS<nDim>

private

Definition at line 128 of file fvcartesiansyseqndetchem.h.

Constructor & Destructor Documentation

◆ FvSysEqnDetChem() [1/2]

template<MInt nDim>

FvSysEqnDetChem< nDim >::FvSysEqnDetChem	(	const MInt	solverId,
		const MInt	noSpecies
	)

Template Parameters

nDim	Number of dimensions

Parameters

solverId	Id of the solver
noSpecies	Number of species

Definition at line 20 of file fvcartesiansyseqndetchem.cpp.

  : FvSysEqnNS<nDim>(solverId, noSpecies) {
  Cantera::addDirectory("/aia/opt/cantera/build/data");
 
  CV = new ConservativeVariables(noSpecies);
  PV = new PrimitiveVariables(noSpecies);
  FV = new FluxVariables(noSpecies);
 
  readProperties();
 
  allocateNoDiffusionCoefficients(noSpecies);
 
  SC = new SurfaceCoefficients(noSpecies, m_noDiffusionCoefficients, m_noThermalDiffusionCoefficients);
 
  m_species = new SpeciesProperties(noSpecies, *this);
  m_NASA = new NASACoefficients(noSpecies, *this);
 
  MFloat m_eps = 1.0e-10;
  ASSERT(m_species->referenceTemp - m_NASA->referenceTemp < m_eps,
         "Unequal reference temperature values in NASA coefficients and species standard enthalpy of formation");
}

◆ FvSysEqnDetChem() [2/2]

template<MInt nDim>

FvSysEqnDetChem< nDim >::FvSysEqnDetChem	(	const MInt	solverId,
		const MInt	noSpecies
	)

Member Function Documentation

◆ allocateNoDiffusionCoefficients()

template<MInt nDim>

void FvSysEqnDetChem< nDim >::allocateNoDiffusionCoefficients ( const MInt noSpecies )

private

Template Parameters

nDim	Number of dimensions

Parameters

noSpecies Number of species

Definition at line 113 of file fvcartesiansyseqndetchem.cpp.

                                                                                {
  switch(string2enum(m_transportModel)) {
    case Multi: {
      m_multiDiffusion = true;
      m_noDiffusionCoefficients = noSpecies * noSpecies;
      m_noThermalDiffusionCoefficients = noSpecies;
      m_noSurfaceCoefficients = 4 + m_noDiffusionCoefficients + m_noThermalDiffusionCoefficients;
    } break;
    case Mix: {
      m_multiDiffusion = false;
      m_noDiffusionCoefficients = noSpecies;
      m_noThermalDiffusionCoefficients = 0;
      m_noSurfaceCoefficients = 4 + m_noDiffusionCoefficients + m_noThermalDiffusionCoefficients;
    } break;
    default: {
      mTerm(1, AT_, "Diffusion model in properties file does not match any implemented model. Terminating.");
    } break;
  }
}

◆ Ausm()

template<MInt nDim>

template<MInt stencil>

void FvSysEqnDetChem< 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

\TODO labels:FV,totest check sensible energy vs sensible enthalpy

Definition at line 376 of file fvcartesiansyseqndetchem.h.

                                                                                           {
  // Multispecies specific variables and coefficients
  const MFloat CP = srfcCoeff[SC->CP];
 
  // compute detailed chemistry additional variables
  MFloat fMeanMolarWeightL = 0.0;
  MFloat fMeanMolarWeightR = 0.0;
 
  for(MUint s = 0; s < PV->m_noSpecies; ++s) {
    fMeanMolarWeightL += leftVars[PV->Y[s]] * m_species->fMolarMass[s];
    fMeanMolarWeightR += rightVars[PV->Y[s]] * m_species->fMolarMass[s];
  }
 
  const MFloat meanMolarWeightL = F1 / fMeanMolarWeightL;
  const MFloat meanMolarWeightR = F1 / fMeanMolarWeightR;
  const MFloat specificGasConstantL = m_gasConstant * fMeanMolarWeightL;
  const MFloat specificGasConstantR = m_gasConstant * fMeanMolarWeightR;
  const MFloat CVL = CP - specificGasConstantL;
  const MFloat CVR = CP - specificGasConstantR;
  const MFloat gammaL = CP / CVL;
  const MFloat gammaR = CP / CVR;
 
  // catch the primitive variables rho and p,
  // compute speed of sound, and interface mach number
  const MFloat RHOL = leftVars[PV->RHO];
  const MFloat PL = leftVars[PV->P];
  const MFloat AL = sqrt(gammaL * mMax(MFloatEps, PL / mMax(MFloatEps, RHOL)));
  const MFloat ML = leftVars[orientation] / AL;
 
  const MFloat RHOR = rightVars[PV->RHO];
  const MFloat PR = rightVars[PV->P];
  const MFloat AR = sqrt(gammaR * mMax(MFloatEps, PR / mMax(MFloatEps, RHOR)));
  const MFloat MR = rightVars[orientation] / AR;
 
  // calculation of the resulting pressure and mach number on the surface
  const MFloat MLR = 0.5 * (ML + MR);
  const MFloat PLR = PL * (0.5 + upwindCoefficient * ML) + PR * (0.5 - upwindCoefficient * MR);
 
  // calculation of the left and right rho*a
  const MFloat RHO_AL = RHOL * AL;
  const MFloat RHO_AR = RHOR * AR;
 
  // calculation of the resulting mass flux through the surface
  const MFloat RHO_U2 = 0.25 * (MLR * (RHO_AL + RHO_AR) + fabs(MLR) * (RHO_AL - RHO_AR));
  const MFloat AbsRHO_U2 = fabs(RHO_U2);
 
  // velocity magnitudes
  const MFloat U2L = std::inner_product(&leftVars[PV->U], &leftVars[PV->U] + nDim, &leftVars[PV->U], 0.0);
  const MFloat U2R = std::inner_product(&rightVars[PV->U], &rightVars[PV->U] + nDim, &rightVars[PV->U], 0.0);
 
  // Compute left sensible energy value
  MFloat sensibleEnergyL = F0;
  this->evaluateSensibleEnergy(sensibleEnergyL, leftVars, meanMolarWeightL);
 
  // Compute right sensible energy value
  MFloat sensibleEnergyR = F0;
  this->evaluateSensibleEnergy(sensibleEnergyR, rightVars, meanMolarWeightR);
 
  const MFloat PLfRHOL = PL / RHOL;
  const MFloat PRfRHOR = PR / RHOR;
 
  const MFloat e0 = sensibleEnergyL + 0.5 * U2L + PLfRHOL;
  const MFloat e1 = sensibleEnergyR + 0.5 * U2R + PRfRHOR;
 
  std::array<MFloat, nDim> pFactor{};
  pFactor[orientation] = 1.0;
 
  for(MUint n = 0; n < nDim; n++) {
    flux[FV->RHO_VV[n]] = (RHO_U2 * (leftVars[PV->VV[n]] + rightVars[PV->VV[n]])
                           + AbsRHO_U2 * (leftVars[PV->VV[n]] - rightVars[PV->VV[n]]) + PLR * pFactor[n])
                          * A;
  }
 
  flux[FV->RHO_E] = (RHO_U2 * (e0 + e1) + AbsRHO_U2 * (e0 - e1)) * A;
  flux[FV->RHO] = 2.0 * RHO_U2 * A;
 
  for(MUint s = 0; s < PV->m_noSpecies; ++s) {
    const MFloat YsL = leftVars[PV->Y[s]];
    const MFloat YsR = rightVars[PV->Y[s]];
    flux[FV->RHO_Y[s]] = (RHO_U2 * (YsL + YsR) + AbsRHO_U2 * (YsL - YsR)) * A;
  }
}

◆ AusmBndryCorrection()

template<MInt nDim>

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

inline

Definition at line 463 of file fvcartesiansyseqndetchem.h.

                                                                           {
  const MFloat PL = leftVars[PV->P];
  const MFloat PR = rightVars[PV->P];
  const MFloat PLR = 0.5 * (PR + PL);
 
  std::array<MFloat, nDim> pFactor{};
  pFactor[orientation] = 1.0;
 
  for(MUint n = 0; n < nDim; n++) {
    flux[FV->RHO_VV[n]] = PLR * pFactor[n] * A;
  }
 
  flux[FV->RHO_E] = 0.0;
  flux[FV->RHO] = 0.0;
 
  // Flux calculation for species transport
  // TODO labels:FV @Julian, Make noSpecies constexpr
  for(MUint s = 0; s < PV->m_noSpecies; ++s) {
    flux[FV->RHO_Y[s]] = 0.0;
  }
}

◆ computeConservativeVariables()

template<MInt nDim>

void FvSysEqnDetChem< nDim >::computeConservativeVariables	(	const MFloat *const	pvarsCell,
		MFloat *const	cvarsCell,
		const MFloat *const	avarsCell
	)

inline

Definition at line 816 of file fvcartesiansyseqndetchem.h.

                                                                                               {
  // Compute rho v
  MFloat velPOW2 = F0;
  for(MInt vel = 0; vel < nDim; ++vel) {
    const MFloat v = pvarsCell[vel];
    cvarsCell[vel] = v * pvarsCell[PV->RHO];
    velPOW2 += POW2(v);
  }
 
  // Copy the density
  cvarsCell[CV->RHO] = pvarsCell[PV->RHO];
 
  MFloat sensibleEnergy = F0;
  evaluateSensibleEnergy(sensibleEnergy, pvarsCell, avarsCell[AV->W_MEAN]);
 
  cvarsCell[CV->RHO_E] = pvarsCell[PV->RHO] * sensibleEnergy + F1B2 * pvarsCell[PV->RHO] * velPOW2;
 
  // compute rho Yi
  for(MUint s = 0; s < PV->m_noSpecies; ++s) {
    cvarsCell[CV->RHO_Y[s]] = pvarsCell[PV->Y[s]] * pvarsCell[PV->RHO];
  }
}

◆ computeGamma()

template<MInt nDim>

void FvSysEqnDetChem< nDim >::computeGamma	(	const MFloat *const	pvarsCell,
		MFloat *const	avarsCell,
		std::shared_ptr< Cantera::ThermoPhase >	gas
	)

inline

Template Parameters

nDim	Number of dimensions

Parameters

pvarsCell	Pointer to the primitive variables at the cell
avarsCell	Pointer to the additional variables at the cell
gas	Pointer to the Cantera::ThermoPhase object

Definition at line 950 of file fvcartesiansyseqndetchem.h.

                                                                                       {
  const MFloat T = pvarsCell[PV->P] / pvarsCell[PV->RHO] * avarsCell[AV->W_MEAN] * m_fGasConstant;
 
  gas->setState_TPY(T, pvarsCell[PV->P], &pvarsCell[PV->Y[0]]);
 
  const MFloat Cp = gas->cp_mass();
  const MFloat Cv = Cp - m_gasConstant / avarsCell[AV->W_MEAN];
 
  avarsCell[AV->GAMMA] = Cp / Cv;
}

◆ computeMeanMolarWeight_CV() [1/2]

template<MInt nDim>

void FvSysEqnDetChem< nDim >::computeMeanMolarWeight_CV	(	const MFloat *const	cvarsCell,
		MFloat *const	avarsCell
	)

inline

Template Parameters

nDim	Number of dimensions

Parameters

cvarsCell	Pointer to the conservative variables at the cell
avarsCell	Pointer to the additional variables at the cell

Definition at line 1120 of file fvcartesiansyseqndetchem.h.

                                                                                                                   {
  MFloat fMeanMolarWeight = F0;
  for(MUint s = 0; s < PV->m_noSpecies; ++s) {
    MFloat fRho = F1 / cvarsCell[CV->RHO];
    const MFloat Y_s = fRho * cvarsCell[CV->RHO_Y[s]];
    fMeanMolarWeight += Y_s * m_species->fMolarMass[s];
  }
  avarsCell[AV->W_MEAN] = (F1 / fMeanMolarWeight);
}

◆ computeMeanMolarWeight_CV() [2/2]

template<MInt nDim>

void FvSysEqnDetChem< nDim >::computeMeanMolarWeight_CV	(	const MFloat * const	,
		MFloat * const
	)

◆ computeMeanMolarWeight_PV() [1/2]

template<MInt nDim>

void FvSysEqnDetChem< nDim >::computeMeanMolarWeight_PV	(	const MFloat *const	pvarsCell,
		MFloat *const	avarsCell
	)

inline

Template Parameters

nDim	Number of dimensions

Parameters

pvarsCell	Pointer to the primitive variables at the cell
avarsCell	Pointer to the additional variables at the cell

Definition at line 1138 of file fvcartesiansyseqndetchem.h.

                                                                                                                   {
  MFloat fMeanMolarWeight = F0;
  for(MUint s = 0; s < PV->m_noSpecies; ++s) {
    fMeanMolarWeight += pvarsCell[PV->Y[s]] * m_species->fMolarMass[s];
  }
  avarsCell[AV->W_MEAN] = (F1 / fMeanMolarWeight);
}

◆ computeMeanMolarWeight_PV() [2/2]

template<MInt nDim>

void FvSysEqnDetChem< nDim >::computeMeanMolarWeight_PV	(	const MFloat * const	,
		MFloat * const
	)

◆ computePhi()

template<MInt nDim>

MFloat FvSysEqnDetChem< nDim >::computePhi ( const MFloat *const Y )

inline

Definition at line 1147 of file fvcartesiansyseqndetchem.h.

                                                              {
  MInt indexOxidizer = m_species->speciesMap[m_oxidizer];
  MInt indexFuel = m_species->speciesMap[m_fuel];
 
  MFloat stochiometricMolarMassRatio = m_species->molarMass[indexFuel] / m_species->molarMass[indexOxidizer];
 
  MFloat phi = (Y[indexFuel] / Y[indexOxidizer]) / (m_fuelOxidizerStochiometricRatio * stochiometricMolarMassRatio);
 
  return phi;
}

◆ computePrimitiveVariables()

template<MInt nDim>

void FvSysEqnDetChem< nDim >::computePrimitiveVariables	(	const MFloat *const	cvarsCell,
		MFloat *const	pvarsCell,
		const MFloat *const	avarsCell
	)

inline

Definition at line 676 of file fvcartesiansyseqndetchem.h.

                                                                                            {
  const MFloat fRho = F1 / cvarsCell[CV->RHO];
 
  MFloat velPOW2 = F0;
  for(MInt n = 0; n < nDim; ++n) { // compute velocity
    pvarsCell[PV->VV[n]] = cvarsCell[CV->RHO_VV[n]] * fRho;
    velPOW2 += POW2(pvarsCell[PV->VV[n]]);
  }
 
  // Density
  pvarsCell[PV->RHO] = cvarsCell[CV->RHO];
 
  // Compute the species
  for(MUint s = 0; s < PV->m_noSpecies; ++s) {
    pvarsCell[PV->Y[s]] = mMax(F0, mMin(F1, cvarsCell[CV->RHO_Y[s]] * fRho));
  }
 
  MFloat T = F0;
  iterateTemperature(T, cvarsCell, pvarsCell, avarsCell, velPOW2);
 
  pvarsCell[PV->P] = pvarsCell[PV->RHO] * T * m_gasConstant / avarsCell[AV->W_MEAN];
 
#ifndef NDEBUG
  if(isnan(pvarsCell[PV->P]) || isnan(pvarsCell[PV->RHO]) || isnan(T)) {
    std::cout << "FvSysEqnDetChem<nDim>::computePrimitiveVariables has NaN value. T: " << T
              << ", rho: " << pvarsCell[PV->RHO] << ", p: " << pvarsCell[PV->P] << std::endl;
  }
 
  if(pvarsCell[PV->P] < 0 || pvarsCell[PV->RHO] < 0 || T < 0) {
    std::cout << "FvSysEqnDetChem<nDim>::computePrimitiveVariables has negative value. T: " << T
              << ", rho: " << pvarsCell[PV->RHO] << ", p: " << pvarsCell[PV->P] << std::endl;
  }
#endif
}

◆ computeSpeciesReactionRates()

template<MInt nDim>

void FvSysEqnDetChem< nDim >::computeSpeciesReactionRates	(	const MFloat &	m_timeStep,
		const MFloat &	cellVolume,
		const MFloat *const	pvarsCell,
		const MFloat *const	avarsCell,
		MFloat *const	reactionRatesCell,
		Cantera::IdealGasReactor *	zeroD_reactor,
		Cantera::ReactorNet *	zeroD_reactorNet,
		std::shared_ptr< Cantera::Solution >	sol,
		std::shared_ptr< Cantera::ThermoPhase >	gas
	)

inline

Template Parameters

nDim

Parameters

m_timeStep	Current time step of the flow solver
cellVolume	Volume of the computational cell
pvarsCell	Pointer to the primitive variables at the cell
avarsCell	Pointer to the additional variables at the cell
reactionRatesCell	Pointer to the reaction rates at the cell
zeroD_reactor	Pointer to the Cantera::Reactor object
zeroD_reactorNet	Pointer to the Cantera::ReactorNet object
sol	Pointer to the Cantera::Solution object
gas	Pointer to the Cantera::ThermoPhase object

Definition at line 859 of file fvcartesiansyseqndetchem.h.

                                           {
  const MFloat p = pvarsCell[PV->P];
  const MFloat rho = pvarsCell[PV->RHO];
  const MFloat meanMolarMass = avarsCell[AV->W_MEAN];
  const MFloat T = p / rho * meanMolarMass * m_fGasConstant;
 
  gas->setState_TPY(T, p, &pvarsCell[PV->Y[0]]);
 
  zeroD_reactor->insert(sol);
  zeroD_reactorNet->setInitialTime(0.0);
 
  const MFloat timeStep = m_timeStep;
  const MFloat reactorDensity_t0 = zeroD_reactor->density();
 
  zeroD_reactorNet->advance(timeStep);
 
  auto reactorMassFractions = zeroD_reactor->massFractions();
  const MFloat reactorDensity = zeroD_reactor->density();
 
  MFloat C_k_t_0, C_k_deltaT;
  for(MUint s = 0; s < PV->m_noSpecies; s++) {
    C_k_t_0 = pvarsCell[PV->Y[s]] * reactorDensity_t0 * m_species->fMolarMass[s];
    C_k_deltaT = reactorMassFractions[s] * reactorDensity * m_species->fMolarMass[s];
    reactionRatesCell[s] = ((C_k_deltaT - C_k_t_0) / (timeStep)) * m_species->molarMass[s];
  }
}

◆ computeSurfaceCoefficients()

template<MInt nDim>

void FvSysEqnDetChem< nDim >::computeSurfaceCoefficients	(	const MInt	RKStep,
		const MFloat *const	vars0,
		const MFloat *const	vars1,
		MFloat *const	srfcCoeff,
		std::shared_ptr< Cantera::ThermoPhase >	gas,
		std::shared_ptr< Cantera::Transport >	trans
	)

inline

Template Parameters

nDim	Number of dimensions

Parameters

RKStep	Current Runge-Kutta step
vars0	Pointer to the primitive variables at one side of the surface
vars1	Pointer to the primitive variables at the other side of the surface
srfcCoeff	Pointer to the surface coefficients at the surface
gas	Pointer to the Cantera::ThermoPhase object
trans	Pointer to the Cantera::Transport object

Definition at line 903 of file fvcartesiansyseqndetchem.h.

                                                                                                     {
  // Compute mean molar mass and store species vector
  std::vector<MFloat> Y_k(PV->m_noSpecies, F0);
  MFloat fMeanMolarMass = F0;
  for(MUint s = 0; s < PV->m_noSpecies; ++s) {
    Y_k[s] = F1B2 * (vars0[PV->Y[s]] + vars1[PV->Y[s]]);
    fMeanMolarMass += Y_k[s] * m_species->fMolarMass[s];
  }
 
  srfcCoeff[SC->W_MEAN] = F1 / fMeanMolarMass;
 
  // Compute the rest of surface coefficients only at RKStep 0
  if(RKStep == 0 || m_computeSrfcCoeffsEveryRKStep) {
    const MFloat p = F1B2 * (vars0[PV->P] + vars1[PV->P]);
    const MFloat rho = F1B2 * (vars0[PV->RHO] + vars1[PV->RHO]);
    const MFloat T = p / rho * srfcCoeff[SC->W_MEAN] * m_fGasConstant;
 
    // Set thermodynamic state of the gas
    gas->setState_TPY(T, p, &Y_k[0]);
 
    srfcCoeff[SC->CP] = gas->cp_mass();
 
    srfcCoeff[SC->MU] = trans->viscosity();
    srfcCoeff[SC->LAMBDA] = trans->thermalConductivity();
 
    if(m_multiDiffusion) {
      // fortran ordering for multicomponent coefficients!
      trans->getMultiDiffCoeffs(PV->m_noSpecies, &srfcCoeff[SC->D[0]]);
      trans->getThermalDiffCoeffs(&srfcCoeff[SC->DT[0]]);
    } else {
      trans->getMixDiffCoeffs(&srfcCoeff[SC->D[0]]);
    }
  }
}

◆ conservativeSlopes()

template<MInt nDim>

std::vector< std::vector< MFloat > > FvSysEqnDetChem< nDim >::conservativeSlopes	(	const MFloat *const	pvarsCell,
		const MFloat *const	cvarsCell,
		const MFloat *const	avarsCell,
		const MFloat *const	slopesCell
	)

inline

Template Parameters

nDim	Number of dimensions

Parameters

pvarsCell	Pointer to the primitive variables at the cell
cvarsCell	Pointer to the conservative variables at the cell
avarsCell	Pointer to the additional variables at the cell
slopesCell	Pointer to the primitive slopes at the cell

Returns: std::vector<std::vector<MFloat>> Returns a vector of vectors with dimensions noVariables * nDim

Definition at line 975 of file fvcartesiansyseqndetchem.h.

                                                                                                         {
  MFloat U2 = F0;
  for(MInt i = 0; i < nDim; i++) {
    U2 += POW2(pvarsCell[PV->VV[i]]);
  }
 
  std::vector<std::vector<MFloat>> dQ(PV->noVariables, std::vector<MFloat>(nDim));
  for(MInt d = 0; d < nDim; d++) {
    MFloat term1 = F0, term2 = F0, term3 = F0;
    const MFloat meanMolarMass = avarsCell[AV->W_MEAN];
    const MFloat T = pvarsCell[PV->P] / pvarsCell[PV->RHO] * meanMolarMass * m_fGasConstant;
    const MBool isLowTempRegion = (T < m_NASA->transitionTemp);
 
    const MFloat* const NASACoeffs = isLowTempRegion ? ALIGNED_F(m_NASA->lowTemp) : ALIGNED_F(m_NASA->highTemp);
    const MFloat* const NASAIntegralCoeffs =
        isLowTempRegion ? ALIGNED_F(m_NASA->integralLowTemp) : ALIGNED_F(m_NASA->integralHighTemp);
    const MFloat* const NASAIntegralConstants = isLowTempRegion ? ALIGNED_F(m_NASA->lowTempIntegrationConstantsEnergy)
                                                                : ALIGNED_F(m_NASA->highTempIntegrationConstantsEnergy);
 
 
    MFloat dT0Term = F0;
    MFloat sensibleEnergy = F0;
    dT0Term += slopesCell[PV->RHO * nDim + d] * m_gasConstant * m_NASA->referenceTemp / meanMolarMass;
    for(MUint s = 0; s < PV->m_noSpecies; s++) {
      dT0Term += pvarsCell[PV->RHO] * m_gasConstant * m_NASA->referenceTemp * slopesCell[PV->Y[s] * nDim + d]
                 * m_species->fMolarMass[s];
    }
 
    MFloat summ_YIntCvdT = F0;
    MFloat summ_dYIntCvdT = F0;
    for(MUint s = 0; s < PV->m_noSpecies; s++) {
      const MInt offsetIntegralCoeffs = m_NASA->noNASACoefficientsCpPolynomial * s;
 
      // Calculate NASA polynomial for species s
      MFloat IntCvdT = F0;
      MFloat NASAIntegralPolynomial = F0;
 
      // Horner's rule for polynomials
      for(MInt i = 4; i >= 0; --i) {
        NASAIntegralPolynomial = NASAIntegralPolynomial * T + NASAIntegralCoeffs[offsetIntegralCoeffs + i];
      }
 
      NASAIntegralPolynomial *= m_species->specificGasConstant[s];
      NASAIntegralPolynomial = (NASAIntegralPolynomial - m_species->specificGasConstant[s]) * T;
      IntCvdT = NASAIntegralPolynomial - NASAIntegralConstants[s];
      sensibleEnergy += pvarsCell[PV->Y[s]] * IntCvdT;
      summ_YIntCvdT += IntCvdT * pvarsCell[PV->Y[s]];
      summ_dYIntCvdT += IntCvdT * slopesCell[PV->Y[s] * nDim + d];
    }
 
    term1 = slopesCell[PV->RHO * nDim + d] * summ_YIntCvdT;
    term2 = pvarsCell[PV->RHO] * summ_dYIntCvdT;
 
    //#####################################
    MFloat summSpeciesGradients = F0;
    for(MUint s = 0; s < PV->m_noSpecies; s++) {
      summSpeciesGradients += m_species->fMolarMass[s] * slopesCell[PV->Y[s] * nDim + d];
    }
 
    const MFloat dW_dx = -(POW2(avarsCell[AV->W_MEAN])) * summSpeciesGradients;
 
    const MFloat dT_dx = m_fGasConstant
                         * (pvarsCell[PV->P] / pvarsCell[PV->RHO] * dW_dx
                            + F1 / pvarsCell[PV->RHO] * meanMolarMass
                                  * (slopesCell[PV->P * nDim + d]
                                     - pvarsCell[PV->P] / pvarsCell[PV->RHO] * slopesCell[PV->RHO * nDim + d]));
 
    // MFloat term3sub1 = F0, term3sub2 = F0;
    MFloat term3sub2 = F0;
    for(MUint s = 0; s < PV->m_noSpecies; s++) {
      // const MInt offsetIntegralCoeffs = m_NASA->noNASACoefficientsCpPolynomial * s;
      const MInt offsetNASAPolynomial = m_NASA->noNASACoefficients * s;
      /*
      MFloat intdCvdT = F0;
      MFloat integrationConstant = F0;
      //Cp = F0;
      MFloat t2 = F0, t1 = F0;
      for(MInt i = 1; i < m_NASA->noNASACoefficientsCpPolynomial; ++i) {
        if (isLowTempRegion) {
        //intdCvdT = intdCvdT * T + NASACoeffs[offsetNASAPolynomial + i];
        //integrationConstant = integrationConstant * m_NASA->referenceTemp + NASACoeffs[offsetNASAPolynomial + i];
        intdCvdT += m_species->specificGasConstant[s] * NASACoeffs[offsetNASAPolynomial + i] * std::pow(T, MFloat(i));
        integrationConstant += m_species->specificGasConstant[s] * NASACoeffs[offsetNASAPolynomial + i] *
      std::pow(m_NASA->referenceTemp, MFloat(i)); } else { intdCvdT += m_species->specificGasConstant[s] *
      NASACoeffs[offsetNASAPolynomial + i] * std::pow(T, MFloat(i)); integrationConstant +=
      m_species->specificGasConstant[s] * NASACoeffs[offsetNASAPolynomial + i] * std::pow(m_NASA->transitionTemp,
      MFloat(i)); t2 += m_species->specificGasConstant[s] * m_NASA->lowTemp[offsetNASAPolynomial + i] *
      std::pow(m_NASA->transitionTemp, MFloat(i)); t1 += m_species->specificGasConstant[s] *
      m_NASA->lowTemp[offsetNASAPolynomial + i] * std::pow(m_NASA->referenceTemp, MFloat(i)); integrationConstant += t1
      - t2;
        }
      }
 
      term3sub1 += pvarsCell[PV->RHO] * pvarsCell[PV->Y[s]] * dT_dx * (intdCvdT - integrationConstant);*/
 
      MFloat Cv = F0;
      for(MInt i = 4; i >= 0; --i) {
        Cv = Cv * T + NASACoeffs[offsetNASAPolynomial + i];
      }
 
      // this computes heat capacity an constant pressure (cp)
      Cv *= m_species->specificGasConstant[s];
 
      // this corrects the value to heat capacity at constant volume (cv = cp - R_k)
      Cv -= m_species->specificGasConstant[s];
 
      term3sub2 += pvarsCell[PV->RHO] * pvarsCell[PV->Y[s]] * Cv * dT_dx;
    }
 
    term3 = term3sub2;
 
    MFloat sensibleEnergyTerm = term1 + term2 + term3 - dT0Term;
 
    MFloat velocityTerm = F1B2 * U2 * slopesCell[PV->RHO * nDim + d];
 
    for(MInt j = 0; j < nDim; j++) {
      velocityTerm += pvarsCell[PV->RHO] * pvarsCell[PV->VV[j]] * slopesCell[PV->VV[j] * nDim + d]; // to change
    }
 
    dQ[CV->RHO_E][d] = sensibleEnergyTerm + velocityTerm;
 
    dQ[CV->RHO][d] = slopesCell[PV->RHO * nDim + d];
 
    for(MInt j = 0; j < nDim; j++) {
      dQ[CV->RHO_VV[j]][d] =
          pvarsCell[PV->VV[j]] * slopesCell[PV->RHO * nDim + d] + pvarsCell[PV->RHO] * slopesCell[PV->VV[j] * nDim + d];
    }
    for(MUint s = 0; s < PV->m_noSpecies; ++s) {
      dQ[CV->RHO_Y[s]][d] =
          pvarsCell[PV->Y[s]] * slopesCell[PV->RHO * nDim + d] + pvarsCell[PV->RHO] * slopesCell[PV->Y[s] * nDim + d];
    }
  }
 
  return dQ;
}

◆ evaluateSensibleEnergy() [1/2]

template<MInt nDim>

void FvSysEqnDetChem< nDim >::evaluateSensibleEnergy	(	MFloat &	,
		const MFloat * const	,
		const MFloat &
	)

◆ evaluateSensibleEnergy() [2/2]

template<MInt nDim>

void FvSysEqnDetChem< nDim >::evaluateSensibleEnergy	(	MFloat &	sensibleEnergy,
		const MFloat *const	pvarsCell,
		const MFloat &	meanMolarMass
	)

inline

Template Parameters

nDim	Number of dimensions

Parameters

sensibleEnergy	Sensible energy
pvarsCell	Pointer to the primitive variables at the cell
meanMolarMass	Mean molar mass at the cell

Definition at line 786 of file fvcartesiansyseqndetchem.h.

                                                                                       {
  const MFloat T = pvarsCell[PV->P] / pvarsCell[PV->RHO] * meanMolarMass * m_fGasConstant;
  const MBool isLowTempRegion = (T < m_NASA->transitionTemp);
 
  const MFloat* const NASAIntegralCoeffs =
      isLowTempRegion ? ALIGNED_F(m_NASA->integralLowTemp) : ALIGNED_F(m_NASA->integralHighTemp);
  const MFloat* const NASAIntegralConstants = isLowTempRegion ? ALIGNED_F(m_NASA->lowTempIntegrationConstantsEnergy)
                                                              : ALIGNED_F(m_NASA->highTempIntegrationConstantsEnergy);
 
  for(MUint s = 0; s < PV->m_noSpecies; s++) {
    MInt offsetIntegralCoeffs = m_NASA->noNASACoefficientsCpPolynomial * s;
 
    // Calculate NASA polynomial for species s with the Horner's rule
    MFloat sensibleEnergySpecies = F0, NASAIntegralPolynomial = F0;
    for(MInt i = 4; (i < 5) && (i >= 0); --i) {
      NASAIntegralPolynomial = NASAIntegralPolynomial * T + NASAIntegralCoeffs[offsetIntegralCoeffs + i];
    }
 
    NASAIntegralPolynomial *= m_species->specificGasConstant[s];
    NASAIntegralPolynomial = (NASAIntegralPolynomial - m_species->specificGasConstant[s]) * T;
    sensibleEnergySpecies = NASAIntegralPolynomial - NASAIntegralConstants[s];
    sensibleEnergy += sensibleEnergySpecies * pvarsCell[PV->Y[s]];
  }
 
  // Substract zero level sensible energy
  sensibleEnergy -= m_gasConstant * m_NASA->referenceTemp / meanMolarMass;
}

◆ getArray012()

template<MInt nDim>

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

inlinestaticconstexprprivate

Definition at line 316 of file fvcartesiansyseqnns.h.

                                                      {
    IF_CONSTEXPR(nDim == 2) {
      std::array<MInt, 2> a = {0, 1};
      return a;
    }
    else {
      std::array<MInt, 3> a = {0, 1, 2};
      return a;
    }
  }

◆ getSpeciesDiffusionMassFluxes()

template<MInt nDim>

void FvSysEqnDetChem< nDim >::getSpeciesDiffusionMassFluxes	(	const MInt	orientation,
		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,
		std::vector< MFloat > &	J,
		std::vector< MFloat > &	dXdn,
		MFloat &	dTdn,
		const MBool	soretEffect
	)

inline

Definition at line 602 of file fvcartesiansyseqndetchem.h.

                                                                    {
  std::vector<MFloat> speciesDiffusionMassFlux(PV->m_noSpecies, F0); // j_k
  std::vector<MFloat> d(PV->m_noSpecies, F0);
  std::vector<MFloat> VX(PV->m_noSpecies, F0);
 
  const MFloat rho = F1B2 * (vars0[PV->RHO] + vars1[PV->RHO]);
  const MFloat Frho = F1 / rho;
  const MFloat p = F1B2 * (vars0[PV->P] + vars1[PV->P]);
  const MFloat Fp = F1 / p;
 
  const MFloat meanMolarMass = srfcCoeff[SC->W_MEAN];
  const MFloat fMeanMolarMass = F1 / meanMolarMass;
 
  // Compute the temperature through equation of state (ideal gas)
  const MFloat T = p * Frho * meanMolarMass * m_fGasConstant;
  const MFloat FT = F1 / T;
 
  // Indices for the orientations
  const MUint id0 = orientation;
 
  const MUint sq0 = PV->P * nDim + id0;
  const MUint sq1 = PV->RHO * nDim + id0;
 
  const MFloat dPdn = f0 * slope0[sq0] + f1 * slope1[sq0];
  const MFloat dRhodn = f0 * slope0[sq1] + f1 * slope1[sq1];
 
  MFloat summSpeciesGradients = F0;
  for(MUint s = 0; s < PV->m_noSpecies; s++) {
    const MUint sqs = PV->Y[s] * nDim + id0;
    summSpeciesGradients += m_species->fMolarMass[s] * (f0 * slope0[sqs] + f1 * slope1[sqs]);
  }
 
  const MFloat dWdn = -POW2(srfcCoeff[SC->W_MEAN]) * summSpeciesGradients;
 
  for(MUint s = 0; s < PV->m_noSpecies; s++) {
    const MUint sqs = PV->Y[s] * nDim + id0;
    const MFloat Ys = F1B2 * (vars0[PV->Y[s]] + vars1[PV->Y[s]]);
    dXdn[s] = m_species->fMolarMass[s] * (meanMolarMass * (f0 * slope0[sqs] + f1 * slope1[sqs]) + dWdn * Ys);
  }
 
  dTdn = m_fGasConstant * (p * Frho * dWdn + (Frho * meanMolarMass * (dPdn - p * Frho * dRhodn)));
 
  for(MUint s = 0; s < PV->m_noSpecies; ++s) {
    const MFloat Ys = F1B2 * (vars0[PV->Y[s]] + vars1[PV->Y[s]]);
    d[s] = dXdn[s] + (meanMolarMass * m_species->fMolarMass[s] * Ys - Ys) * Fp * dPdn;
  }
 
  if(m_multiDiffusion) {
    for(MUint s = 0; s < PV->m_noSpecies; ++s) {
      for(MUint j = 0; j < PV->m_noSpecies; ++j) {
        if(j == s) continue;
        VX[s] += m_species->molarMass[j] * srfcCoeff[SC->D[PV->m_noSpecies * j + s]] * d[j];
      }
 
      VX[s] *= fMeanMolarMass;
 
      if(soretEffect) VX[s] -= srfcCoeff[SC->DT[s]] * meanMolarMass * Frho * m_species->fMolarMass[s] * FT * dTdn;
 
      J[s] = rho * m_species->molarMass[s] * fMeanMolarMass * VX[s];
    }
  } else {
    for(MUint s = 0; s < PV->m_noSpecies; ++s) {
      // TODO labels:FV check
      VX[s] = -srfcCoeff[SC->D[s]] * dXdn[s];
 
      J[s] = rho * m_species->molarMass[s] * fMeanMolarMass * VX[s];
    }
  }
}

◆ iterateTemperature()

template<MInt nDim>

void FvSysEqnDetChem< nDim >::iterateTemperature	(	MFloat &	T,
		const MFloat *const	cvarsCell,
		const MFloat *const	pvarsCell,
		const MFloat *const	avarsCell,
		const MFloat &	velPOW2
	)

inline

Template Parameters

nDim	Number of dimensions

Parameters

T	Temperature, is given as
cvarsCell	Pointer to the conservative variables at the cell
pvarsCell	Pointer to the primitive variables at the cell
avarsCell	Pointer to the additional variables at the cell
velPOW2	Absolute value of the velocity squared

Definition at line 724 of file fvcartesiansyseqndetchem.h.

                                                                                                            {
  const MFloat energyZeroLevel = m_gasConstant * m_species->referenceTemp / avarsCell[AV->W_MEAN];
 
  MFloat LHS = cvarsCell[CV->RHO_E] / cvarsCell[CV->RHO] - F1B2 * velPOW2 + energyZeroLevel;
 
  // TODO labels:FV Change to old variables and convergence check
  // Supply initial temperature value to start iteration
  MFloat T_n = 300.0;
 
  for(MInt it = 0; it < 10; ++it) {
    const MBool isLowTempRegion = (T_n < m_NASA->transitionTemp);
    // Assigns relevant low or high temperature coefficients and integration constants
    const MFloat* const NASACoeffs = isLowTempRegion ? ALIGNED_F(m_NASA->lowTemp) : ALIGNED_F(m_NASA->highTemp);
    const MFloat* const NASAIntegralCoeffs =
        isLowTempRegion ? ALIGNED_F(m_NASA->integralLowTemp) : ALIGNED_F(m_NASA->integralHighTemp);
    const MFloat* const NASAIntegralConstants = isLowTempRegion ? ALIGNED_F(m_NASA->lowTempIntegrationConstantsEnergy)
                                                                : ALIGNED_F(m_NASA->highTempIntegrationConstantsEnergy);
 
    MFloat T_nPlus1 = F0, f_xi = F0, fS_xi = F0;
    for(MUint s = 0; s < PV->m_noSpecies; s++) {
      const MInt offsetIntegralCoeffs = m_NASA->noNASACoefficientsCpPolynomial * s;
      const MInt offsetNASAPolynomial = m_NASA->noNASACoefficients * s;
      const MFloat Y_s = cvarsCell[CV->RHO_Y[s]] / cvarsCell[CV->RHO];
      const MFloat specificGasConstant = m_species->specificGasConstant[s];
 
      // Calculate NASA polynomial for species s with the Horner's rule
      MFloat NASAIntegralPolynomial = F0, NASAPolynomial = F0;
      for(MInt i = 4; (i < 5) && (i >= 0); i--) {
        NASAIntegralPolynomial = NASAIntegralPolynomial * T_n + NASAIntegralCoeffs[offsetIntegralCoeffs + i];
        NASAPolynomial = NASAPolynomial * T_n + NASACoeffs[offsetNASAPolynomial + i];
      }
 
      NASAIntegralPolynomial *= specificGasConstant;
      NASAPolynomial *= specificGasConstant;
 
      NASAIntegralPolynomial = (NASAIntegralPolynomial - specificGasConstant) * T_n;
      NASAPolynomial -= specificGasConstant;
 
      f_xi += NASAIntegralPolynomial * Y_s;
      f_xi -= NASAIntegralConstants[s] * Y_s;
      fS_xi += NASAPolynomial * Y_s;
    }
 
    f_xi -= LHS;
    T_nPlus1 = T_n - (f_xi / fS_xi);
    T_n = T_nPlus1;
  }
 
  T = T_n;
}

◆ readProperties()

template<MInt nDim>

void FvSysEqnDetChem< nDim >::readProperties

private

Template Parameters

nDim	Number of dimensions

Definition at line 476 of file fvcartesiansyseqndetchem.cpp.

                                           {
  m_gasConstant = 8.314472;
  m_gasConstant = Context::getSolverProperty<MFloat>("gasConstant", m_solverId, AT_, &m_gasConstant);
 
  m_fGasConstant = F1 / m_gasConstant;
 
  m_reactionMechanism = Context::getSolverProperty<MString>("reactionMechanism", m_solverId, AT_, &m_reactionMechanism);
 
  m_transportModel = "Multi";
  m_transportModel = Context::getSolverProperty<MString>("transportModel", m_solverId, AT_, &m_transportModel);
 
  m_phaseName = Context::getSolverProperty<MString>("phaseName", m_solverId, AT_, &m_phaseName);
 
  m_computeSrfcCoeffsEveryRKStep = false;
  m_computeSrfcCoeffsEveryRKStep = Context::getSolverProperty<MBool>("computeSrfcCoeffsEveryRKStep", m_solverId, AT_,
                                                                     &m_computeSrfcCoeffsEveryRKStep);
 
  m_soretEffect = true;
  m_soretEffect = Context::getSolverProperty<MBool>("soretEffect", m_solverId, AT_, &m_soretEffect);
 
  m_fuelOxidizerStochiometricRatio = 2.0; // default for hydrogen + oxygen
  m_fuelOxidizerStochiometricRatio = Context::getSolverProperty<MFloat>("fuelOxidizerStochiometricRatio", m_solverId,
                                                                        AT_, &m_fuelOxidizerStochiometricRatio);
 
  m_oxidizer = "O2";
  m_oxidizer = Context::getSolverProperty<MString>("oxidizer", m_solverId, AT_, &m_oxidizer);
 
  m_fuel = "H2";
  m_fuel = Context::getSolverProperty<MString>("fuel", m_solverId, AT_, &m_fuel);
}

◆ viscousFlux() [1/2]

template<MInt nDim>

template<MInt stencil>

void FvSysEqnDetChem< 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 58 of file fvcartesiansyseqndetchem.h.

                                                                                {
    if(stencil == FIVE_POINT) {
      viscousFluxFivePoint(orientation, A, vars0, vars1, slope0, slope1, srfcCoeff, f0, f1, flux);
    } else {
      TERMM(1, "Viscous Flux Scheme not implemented.");
    }
  }

◆ viscousFlux() [2/2]

template<MInt nDim>

template<MInt stencil>

void FvSysEqnDetChem< nDim >::viscousFlux	(	const	MInt,
		const	MFloat,
		const	MBool,
		const MFloat * const	,
		const MFloat * const	,
		const MFloat * const	,
		const MFloat * const	,
		const MFloat * const	,
		const MFloat * const	,
		const MFloat * const	,
		const MFloat * const	,
		const MFloat * const	,
		const	MFloat,
		const	MFloat,
		MFloat * const
	)

inline

Definition at line 70 of file fvcartesiansyseqndetchem.h.

                                         {
    if(stencil == THREE_POINT) {
      TERMM(1, "Three point viscous Flux Scheme not implemented for SysEqnDetChem.");
    } else {
      TERMM(1, "Viscous Flux Scheme not implemented.");
    }
  }

◆ viscousFluxFivePoint()

template<MInt nDim>

void FvSysEqnDetChem< 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	srfcCoeff,
		const MFloat	f0,
		const MFloat	f1,
		MFloat *const	flux
	)

inline

\TODO labels:FV,totest check if negativ expression is correct

Definition at line 488 of file fvcartesiansyseqndetchem.h.

                                                                            {
  std::vector<MFloat> dXdn(PV->m_noSpecies, F0);
  std::vector<MFloat> J(PV->m_noSpecies, F0);
  std::vector<MFloat> speciesSensibleEnthalpy(PV->m_noSpecies, F0);
 
 
  // Constant coefficients defined at the surface from left and right values
  const MFloat mue = srfcCoeff[SC->MU];
  const MFloat lambda = srfcCoeff[SC->LAMBDA];
  const MFloat meanMolarMass = srfcCoeff[SC->W_MEAN];
 
  MFloat mue_wm = 0.0;
 
  const std::array<MFloat, nDim> velocity = [&] {
    std::array<MFloat, nDim> tmp{};
    for(MUint n = 0; n < nDim; n++) {
      tmp[n] = F1B2 * (vars0[PV->VV[n]] + vars1[PV->VV[n]]);
    }
    return tmp;
  }();
 
  const MFloat rho = F1B2 * (vars0[PV->RHO] + vars1[PV->RHO]);
  const MFloat Frho = F1 / rho;
  const MFloat p = F1B2 * (vars0[PV->P] + vars1[PV->P]);
 
  // Compute the temperature  through equation of state (ideal gas)
  const MFloat T = p * Frho * meanMolarMass * m_fGasConstant;
 
  // Indices for the orientations
  const MUint id0 = orientation;
  const MUint id1 = index0[orientation];
  const MUint id2 = index1[orientation];
 
  const MBool isLowTempRegion = (T < m_NASA->transitionTemp);
  const MFloat* const NASAIntegralCoeffs =
      isLowTempRegion ? ALIGNED_F(m_NASA->integralLowTemp) : ALIGNED_F(m_NASA->integralHighTemp);
  const MFloat* const NASAIntegralConstants = isLowTempRegion ? ALIGNED_F(m_NASA->lowTempIntegrationConstantsEnthalpy)
                                                              : ALIGNED_F(m_NASA->highTempIntegrationConstantsEnthalpy);
 
  // Compute species sensible enthalpy
  for(MUint s = 0; s < PV->m_noSpecies; ++s) {
    const MFloat speciesSpecificGasConstant = m_species->specificGasConstant[s];
 
    MFloat sensibleEnthalpy = F0;
    MInt offsetIntegralCoeffs = m_NASA->noNASACoefficientsCpPolynomial * s;
 
    for(MInt i = 4; (i < 5) && (i >= 0); --i) {
      sensibleEnthalpy = sensibleEnthalpy * T + NASAIntegralCoeffs[offsetIntegralCoeffs + i];
    }
 
    sensibleEnthalpy *= speciesSpecificGasConstant * T;
    sensibleEnthalpy -= NASAIntegralConstants[s];
 
    speciesSensibleEnthalpy[s] = sensibleEnthalpy;
  }
 
 
  MFloat dTdn = F0;
  MFloat diffEnthalpyFlux = F0;
 
  std::fill(J.begin(), J.end(), F0);
  std::fill(dXdn.begin(), dXdn.end(), F0);
 
  getSpeciesDiffusionMassFluxes(orientation, vars0, vars1, slope0, slope1, srfcCoeff, f0, f1, J, dXdn, dTdn,
                                m_soretEffect);
 
 
  for(MUint s = 0; s < PV->m_noSpecies; ++s) {
    diffEnthalpyFlux += speciesSensibleEnthalpy[s] * J[s];
  }
 
  const MFloat q = lambda * dTdn - diffEnthalpyFlux;
 
  // Compute the stress terms
  const MUint s00 = id0 * nDim + id0;
  const MUint s01 = id0 * nDim + id1;
  const MUint s10 = id1 * nDim + id0;
  const MUint s11 = id1 * nDim + id1;
 
  std::array<MFloat, nDim> tau{};
  IF_CONSTEXPR(nDim == 2) {
    tau[id0] = (mue + mue_wm)
               * (f0 * (F4B3 * slope0[s00] - F2B3 * slope0[s11]) + f1 * (F4B3 * slope1[s00] - F2B3 * slope1[s11]));
    tau[id1] = (mue + mue_wm) * (f0 * (slope0[s01] + slope0[s10]) + f1 * (slope1[s01] + slope1[s10]));
  }
  else IF_CONSTEXPR(nDim == 3) {
    const MUint s22 = id2 * nDim + id2;
    const MUint s02 = id0 * nDim + id2;
    const MUint s20 = id2 * nDim + id0;
    tau[id0] = (mue + mue_wm)
               * (f0 * (F4B3 * slope0[s00] - F2B3 * (slope0[s11] + slope0[s22]))
                  + f1 * (F4B3 * slope1[s00] - F2B3 * (slope1[s11] + slope1[s22])));
    tau[id1] = (mue + mue_wm) * (f0 * (slope0[s01] + slope0[s10]) + f1 * (slope1[s01] + slope1[s10]));
    tau[id2] = (mue + mue_wm) * (f0 * (slope0[s02] + slope0[s20]) + f1 * (slope1[s02] + slope1[s20]));
  }
 
  // Compute the flux
  for(MUint n = 0; n < nDim; n++) {
    flux[FV->RHO_VV[n]] -= A * tau[n];
  }
  flux[FV->RHO_E] -= A * (std::inner_product(velocity.begin(), velocity.end(), tau.begin(), 0.0) + q);
 
  // Species transport equations
  for(MUint s = 0; s < PV->m_noSpecies; ++s) {
    flux[FV->RHO_Y[s]] -= -A * J[s]; // remove
  }
}

Member Data Documentation

◆ AV

template<MInt nDim>

AdditionalVariables * FvSysEqnDetChem< nDim >::AV = nullptr

Definition at line 187 of file fvcartesiansyseqndetchem.h.

◆ CV

template<MInt nDim>

ConservativeVariables* FvSysEqnDetChem< nDim >::CV = nullptr

Definition at line 184 of file fvcartesiansyseqndetchem.h.

◆ FV

template<MInt nDim>

FluxVariables* FvSysEqnDetChem< nDim >::FV = nullptr

Definition at line 185 of file fvcartesiansyseqndetchem.h.

◆ hasAV

template<MInt nDim>

static constexpr MBool FvSysEqnDetChem< nDim >::hasAV = true

staticconstexpr

Definition at line 182 of file fvcartesiansyseqndetchem.h.

◆ hasSC

template<MInt nDim>

static constexpr MBool FvSysEqnDetChem< nDim >::hasSC = true

staticconstexpr

Definition at line 183 of file fvcartesiansyseqndetchem.h.

◆ index0

template<MInt nDim>

const MUint FvSysEqnNS< nDim >::index0[nDim]

staticprivate

Definition at line 350 of file fvcartesiansyseqnns.h.

◆ index1

template<MInt nDim>

const MUint FvSysEqnNS< nDim >::index1[nDim]

staticprivate

Definition at line 353 of file fvcartesiansyseqnns.h.

◆ m_computeSrfcCoeffsEveryRKStep

template<MInt nDim>

MBool FvSysEqnDetChem< nDim >::m_computeSrfcCoeffsEveryRKStep

private

Definition at line 164 of file fvcartesiansyseqndetchem.h.

◆ m_F1BGammaMinusOne

template<MInt nDim>

MFloat FvSysEqnNS< nDim >::m_F1BGammaMinusOne

private

Definition at line 296 of file fvcartesiansyseqnns.h.

◆ m_fGasConstant

template<MInt nDim>

MFloat FvSysEqnDetChem< nDim >::m_fGasConstant

private

Definition at line 148 of file fvcartesiansyseqndetchem.h.

◆ m_fuel

template<MInt nDim>

MString FvSysEqnDetChem< nDim >::m_fuel

Definition at line 192 of file fvcartesiansyseqndetchem.h.

◆ m_fuelOxidizerStochiometricRatio

template<MInt nDim>

MFloat FvSysEqnDetChem< nDim >::m_fuelOxidizerStochiometricRatio

Definition at line 193 of file fvcartesiansyseqndetchem.h.

◆ m_gamma

template<MInt nDim>

MFloat FvSysEqnNS< nDim >::m_gamma

private

Definition at line 294 of file fvcartesiansyseqnns.h.

◆ m_gammaMinusOne

template<MInt nDim>

MFloat FvSysEqnNS< nDim >::m_gammaMinusOne

private

Definition at line 295 of file fvcartesiansyseqnns.h.

◆ m_gasConstant

template<MInt nDim>

MFloat FvSysEqnDetChem< nDim >::m_gasConstant

private

Definition at line 147 of file fvcartesiansyseqndetchem.h.

◆ m_gFGMOrPr

template<MInt nDim>

MFloat FvSysEqnNS< nDim >::m_gFGMOrPr

private

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_multiDiffusion

template<MInt nDim>

MBool FvSysEqnDetChem< nDim >::m_multiDiffusion

private

Definition at line 163 of file fvcartesiansyseqndetchem.h.

◆ m_NASA

template<MInt nDim>

NASACoefficients * FvSysEqnDetChem< nDim >::m_NASA = nullptr

Definition at line 175 of file fvcartesiansyseqndetchem.h.

◆ m_noDiffusionCoefficients

template<MInt nDim>

MInt FvSysEqnDetChem< nDim >::m_noDiffusionCoefficients

private

Definition at line 161 of file fvcartesiansyseqndetchem.h.

◆ m_noSpecies

template<MInt nDim>

MUint FvSysEqnNS< nDim >::m_noSpecies

private

Definition at line 289 of file fvcartesiansyseqnns.h.

◆ m_noSurfaceCoefficients

template<MInt nDim>

MInt FvSysEqnDetChem< nDim >::m_noSurfaceCoefficients

private

Definition at line 160 of file fvcartesiansyseqndetchem.h.

◆ m_noThermalDiffusionCoefficients

template<MInt nDim>

MInt FvSysEqnDetChem< nDim >::m_noThermalDiffusionCoefficients

private

Definition at line 162 of file fvcartesiansyseqndetchem.h.

◆ m_oxidizer

template<MInt nDim>

MString FvSysEqnDetChem< nDim >::m_oxidizer

Definition at line 191 of file fvcartesiansyseqndetchem.h.

◆ m_phaseName

template<MInt nDim>

MString FvSysEqnDetChem< nDim >::m_phaseName

private

Definition at line 157 of file fvcartesiansyseqndetchem.h.

◆ m_Re0

template<MInt nDim>

MFloat FvSysEqnNS< nDim >::m_Re0

Definition at line 329 of file fvcartesiansyseqnns.h.

◆ m_reactionMechanism

template<MInt nDim>

MString FvSysEqnDetChem< nDim >::m_reactionMechanism

private

Definition at line 155 of file fvcartesiansyseqndetchem.h.

◆ m_referenceTemperature

template<MInt nDim>

MFloat FvSysEqnNS< nDim >::m_referenceTemperature

private

Definition at line 301 of file fvcartesiansyseqnns.h.

◆ m_solverId

template<MInt nDim>

MInt FvSysEqnNS< nDim >::m_solverId

private

Definition at line 291 of file fvcartesiansyseqnns.h.

◆ m_soretEffect

template<MInt nDim>

MBool FvSysEqnDetChem< nDim >::m_soretEffect

Definition at line 189 of file fvcartesiansyseqndetchem.h.

◆ m_species

template<MInt nDim>

SpeciesProperties * FvSysEqnDetChem< nDim >::m_species = nullptr

Definition at line 174 of file fvcartesiansyseqndetchem.h.

◆ m_sutherlandConstant

template<MInt nDim>

MFloat FvSysEqnNS< nDim >::m_sutherlandConstant

private

Definition at line 303 of file fvcartesiansyseqnns.h.

◆ m_sutherlandConstantThermal

template<MInt nDim>

MFloat FvSysEqnNS< nDim >::m_sutherlandConstantThermal

private

Definition at line 305 of file fvcartesiansyseqnns.h.

◆ m_sutherlandPlusOne

template<MInt nDim>

MFloat FvSysEqnNS< nDim >::m_sutherlandPlusOne

private

Definition at line 302 of file fvcartesiansyseqnns.h.

◆ m_sutherlandPlusOneThermal

template<MInt nDim>

MFloat FvSysEqnNS< nDim >::m_sutherlandPlusOneThermal

private

Definition at line 304 of file fvcartesiansyseqnns.h.

◆ m_transportModel

template<MInt nDim>

MString FvSysEqnDetChem< nDim >::m_transportModel

private

Definition at line 156 of file fvcartesiansyseqndetchem.h.

◆ PV

template<MInt nDim>

PrimitiveVariables* FvSysEqnDetChem< nDim >::PV = nullptr

Definition at line 186 of file fvcartesiansyseqndetchem.h.

◆ SC

template<MInt nDim>

SurfaceCoefficients * FvSysEqnDetChem< nDim >::SC = nullptr

Definition at line 188 of file fvcartesiansyseqndetchem.h.

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

/home/gitlab-runner/scratch/builds/oxpnswJ6/1/aia/m-AIA/m-AIA/src/FV/fvcartesiansyseqndetchem.h
/home/gitlab-runner/scratch/builds/oxpnswJ6/1/aia/m-AIA/m-AIA/src/FV/fvcartesiansyseqndetchem.cpp

Private Attributes
MFloat	m_gasConstant

MFloat	m_fGasConstant

MString	m_reactionMechanism

MString	m_transportModel

MString	m_phaseName

MInt	m_noSurfaceCoefficients

MInt	m_noDiffusionCoefficients

MInt	m_noThermalDiffusionCoefficients

MBool	m_multiDiffusion

MBool	m_computeSrfcCoeffsEveryRKStep

MUint	m_noSpecies

MInt	m_solverId

MFloat	m_F1BGammaMinusOne

MFloat	m_gamma

MFloat	m_gammaMinusOne

MFloat	m_gFGMOrPr

MFloat	m_referenceTemperature

MFloat	m_sutherlandConstant

MFloat	m_sutherlandConstantThermal

MFloat	m_sutherlandPlusOne

MFloat	m_sutherlandPlusOneThermal

Classes

Public Member Functions

Public Attributes

Static Public Attributes

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ Base

Constructor & Destructor Documentation

◆ FvSysEqnDetChem() [1/2]

◆ FvSysEqnDetChem() [2/2]

Member Function Documentation

◆ allocateNoDiffusionCoefficients()

◆ Ausm()

◆ AusmBndryCorrection()

◆ computeConservativeVariables()

◆ computeGamma()

◆ computeMeanMolarWeight_CV() [1/2]

◆ computeMeanMolarWeight_CV() [2/2]

◆ computeMeanMolarWeight_PV() [1/2]

◆ computeMeanMolarWeight_PV() [2/2]

◆ computePhi()

◆ computePrimitiveVariables()

◆ computeSpeciesReactionRates()

◆ computeSurfaceCoefficients()

◆ conservativeSlopes()

◆ evaluateSensibleEnergy() [1/2]

◆ evaluateSensibleEnergy() [2/2]

◆ getArray012()

◆ getSpeciesDiffusionMassFluxes()

◆ iterateTemperature()

◆ readProperties()

◆ viscousFlux() [1/2]

◆ viscousFlux() [2/2]

◆ viscousFluxFivePoint()

Member Data Documentation

◆ AV

◆ CV

◆ FV

◆ hasAV

◆ hasSC

◆ index0

◆ index1

◆ m_computeSrfcCoeffsEveryRKStep

◆ m_F1BGammaMinusOne

◆ m_fGasConstant

◆ m_fuel

◆ m_fuelOxidizerStochiometricRatio

◆ m_gamma

◆ m_gammaMinusOne

◆ m_gasConstant

◆ m_gFGMOrPr

◆ m_muInfinity

◆ m_multiDiffusion

◆ m_NASA

◆ m_noDiffusionCoefficients

◆ m_noSpecies

◆ m_noSurfaceCoefficients

◆ m_noThermalDiffusionCoefficients

◆ m_oxidizer

◆ m_phaseName

◆ m_Re0

◆ m_reactionMechanism

◆ m_referenceTemperature

◆ m_solverId

◆ m_soretEffect

◆ m_species

◆ m_sutherlandConstant

◆ m_sutherlandConstantThermal

◆ m_sutherlandPlusOne

◆ m_sutherlandPlusOneThermal

◆ m_transportModel

◆ PV

◆ SC