MSTG< nDim, SolverTypeR, SolverTypeL > Class Template Reference

#include <fvstg.h>

Inheritance diagram for MSTG< nDim, SolverTypeR, SolverTypeL >:

Collaboration diagram for MSTG< nDim, SolverTypeR, SolverTypeL >:

Classes
struct	STG

Public Types
using	SolverTypeL_ = typename SolverTraits< nDim, SolverTypeL >::SolverType
using	Accessor = typename AccessorTrait< nDim, SolverTypeL >::AccessorType
using	self = MSTG< nDim, SolverTypeR, SolverTypeL >

Public Member Functions
	MSTG (FvCartesianSolverXD< nDim, FvSysEqnNS< nDim > > *solver, MInt bcId, const MPI_Comm commStg, MInt *sortedBndryCellIds, MInt noStgLCells, MInt stgFaceNormalDir, MInt stgDir, MInt stgWallNormalDir, MInt wallDir, MBool cutOff)
void	bc7909 ()
	Reformulated Synthetic Turbulence Generation Synthetic Turbulence Generation Method Computes fluctuations from a given averaged velocity and nu_t profile and adds them at the inflow of the domain. Same computations as STG in TFS by Benedikt Roidl /author Jannik Borgelt. More...
void	init (MInt commStgRoot)
std::mt19937_64 &	randomEddyPosGenerator ()

Public Attributes
std::mt19937_64	m_PRNGEddy
MInt	m_randomEddySeed

Protected Member Functions
void	saveStg ()
void	loadStg ()

Private Member Functions
void	setSTGProperties ()
void	calcReynoldsStressConvVelLengthScale ()
void	generateNewEddies (MFloat *, MFloat *)
void	advanceEddies ()
void	printSTGSummary ()
void	calcTotalFluctuationCholesky ()
void	calcEddieCoverage ()
void	determinePeriodicCells ()
void	setVb (MFloat *, MFloat *)
template<class _ = void, std::enable_if_t< SolverTypeL==MAIA_STRUCTURED, _ * > = nullptr>
void	getBoundaryLayerThickness ()
template<class _ = void, std::enable_if_t< SolverTypeL==MAIA_FINITE_VOLUME, _ * > = nullptr>
void	getBoundaryLayerThickness ()
template<class _ = void, std::enable_if_t< SolverTypeL==MAIA_STRUCTURED, _ * > = nullptr>
void	apply ()
template<class _ = void, std::enable_if_t< SolverTypeL==MAIA_FINITE_VOLUME, _ * > = nullptr>
void	apply ()
template<class _ = void, std::enable_if_t< SolverTypeL==MAIA_STRUCTURED, _ * > = nullptr>
void	extrapolateToGX (typename Accessor::nDim_citerator)
template<class _ = void, std::enable_if_t< SolverTypeL==MAIA_STRUCTURED, _ * > = nullptr>
void	extrapolateToBoundary (typename Accessor::nDim_citerator)
template<class _ = void, std::enable_if_t< SolverTypeL==MAIA_FINITE_VOLUME, _ * > = nullptr>
void	extrapolateToBoundary (typename Accessor::nDim_citerator)
template<class _ = void, std::enable_if_t< SolverTypeL==MAIA_STRUCTURED, _ * > = nullptr>
void	calcStrainRate ()
template<class _ = void, std::enable_if_t< SolverTypeL==MAIA_FINITE_VOLUME, _ * > = nullptr>
void	calcStrainRate ()
template<class _ = void, std::enable_if_t< SolverTypeL==MAIA_STRUCTURED, _ * > = nullptr>
void	getInflowStartEnd (MFloat *, MFloat *)
template<class _ = void, std::enable_if_t< SolverTypeL==MAIA_FINITE_VOLUME, _ * > = nullptr>
void	getInflowStartEnd (MFloat *, MFloat *)
template<class _ = void, std::enable_if_t< SolverTypeL==MAIA_STRUCTURED, _ * > = nullptr>
MFloat	getCellSize (typename Accessor::nDim_citerator it)
template<class _ = void, std::enable_if_t< SolverTypeL==MAIA_FINITE_VOLUME, _ * > = nullptr>
MFloat	getCellSize (typename Accessor::nDim_citerator it)
template<class _ = void, std::enable_if_t< SolverTypeR==MAIA_STRUCTURED, _ * > = nullptr, std::enable_if_t< SolverTypeL==MAIA_FINITE_VOLUME, _ * > = nullptr>
void	readRANSProfileStg ()
	write RANSValues from solver to stgLVariables (fully coupled) /author Jannik Borgelt More...
template<class _ = void, std::enable_if_t< SolverTypeR==MAIA_FINITE_VOLUME, _ * > = nullptr, std::enable_if_t< SolverTypeL==MAIA_FINITE_VOLUME, _ * > = nullptr>
void	readRANSProfileStg ()
void	loadStg (SolverTraits< nDim, MAIA_FINITE_VOLUME > *)
SolverTypeL_ *	solver () const
MFloat	generate_rand ()
MFloat	generate_rand_weighted ()
MFloat	generate_rand_normalDist ()
MFloat	get_angle (MFloat y, MFloat z)

Private Attributes
SolverTypeL_ *	m_solver
MInt	m_solverId
const MInt	m_bcId
FvSysEqnRANS< nDim, RANSModelConstants< RANS_SA_DV > >::PrimitiveVariables *	PV
MFloat	m_sutherlandConstant
MFloat	m_sutherlandPlusOne
MBool	m_zonal
MFloat *	m_inflowStart = nullptr
MFloat *	m_inflowEnd = nullptr
MBool	m_initialRange = false
MPI_Comm	m_commStg
MInt	m_commStgRoot
MInt	m_commStgMyRank
MBool	m_stgRootRank
MFloat	m_stgBLT1
MFloat	m_stgBLT2
MFloat	m_stgBLT3
MFloat	m_stgDelta99Inflow
MBool	m_stgInitialStartup
MInt	m_stgNoEddieProperties
MFloat **	m_stgEddies = nullptr
MFloat *	m_stgEddyStrength = nullptr
MInt	m_stgMaxNoEddies
MFloat	m_stgExple
MFloat	m_stgEddieDistribution
MInt	m_noStgLCells
MBool	m_stgLocal = false
MBool	m_stgCreateNewEddies
MInt	m_stgShapeFunction
MBool	m_stgEddieLengthScales = false
MBool	m_stgSubSup
MBool	m_stgSupersonic
MInt	m_stgFaceNormalDir
MInt	m_stgWallNormalDir = 1
MInt	m_stgDir = 0
MInt	m_wallDir = 1
MInt	m_periodicDir = 2
MFloat *	m_stgLengthFactors = nullptr
MFloat *	m_stgRSTFactors = nullptr
MInt	m_stgMyRank
MFloat *	m_stgVbStart = nullptr
MFloat *	m_stgVbEnd = nullptr
MFloat *	m_stgVbStartFS = nullptr
MFloat	m_stgWallEnd
MFloat *	m_stgMaxVel = nullptr
MFloat **	m_stgLVariables = nullptr
MBool	m_freeStreamTurbulence = false
MFloat	m_uuFS
MFloat	m_vvFS
MFloat	m_wwFS
MFloat	m_SijSijFS
MFloat	m_BLEddieFraction
MBool	m_isotropicTurbulence = false
MBool	m_preliminary = false
MBool	m_preliminaryRans2D = false
MBool	m_newStgMethod = false
MFloat	m_maxStreamwiseLengthscale
MFloat **	m_stgEddieCoverage = nullptr
std::vector< MInt > *	m_stgPeriodicCellId = nullptr
std::vector< MFloat >	m_stgWallNormalLocations
std::vector< MFloat >	m_stgGlobalWallNormalLocations
MInt	m_stgGlobalNoWallNormalLocations = F0
MInt *	m_stgGlobalNoPeriodicLocations = nullptr
MInt *	m_stgPeriodicIndex = nullptr
MBool	m_cylinderTransformation = false
MBool	m_cutOff
const MFloat	epss = 1e-34
const MFloat	eps = 1e-16
const MFloat	epsl = 1e-13
const MFloat	c_mu = 0.09
const MFloat	a1 = 1 / sqrt(c_mu)
const MFloat	timsm = 0.3
const MFloat	aniso = 1.0
Accessor *	a
Accessor *	LES = a

Static Private Attributes
static constexpr const MInt	m_nDim = nDim

Friends
class	FvBndryCndXD< nDim, FvSysEqnNS< nDim > >
void	saveStg (std::map< MInt, self * >, SolverTypeL_ *)

Detailed Description

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>
class MSTG< nDim, SolverTypeR, SolverTypeL >

Definition at line 609 of file fvstg.h.

Member Typedef Documentation

Accessor

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

using MSTG< nDim, SolverTypeR, SolverTypeL >::Accessor = typename AccessorTrait<nDim, SolverTypeL>::AccessorType

Definition at line 613 of file fvstg.h.

self

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

using MSTG< nDim, SolverTypeR, SolverTypeL >::self = MSTG<nDim, SolverTypeR, SolverTypeL>

Definition at line 615 of file fvstg.h.

SolverTypeL_

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

using MSTG< nDim, SolverTypeR, SolverTypeL >::SolverTypeL_ = typename SolverTraits<nDim, SolverTypeL>::SolverType

Definition at line 611 of file fvstg.h.

Constructor & Destructor Documentation

MSTG()

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MSTG< nDim, SolverTypeR, SolverTypeL >::MSTG	(	FvCartesianSolverXD< nDim, FvSysEqnNS< nDim > > *	solver,
		MInt	bcId,
		const MPI_Comm	commStg,
		MInt *	sortedBndryCellIds,
		MInt	noStgLCells,
		MInt	stgFaceNormalDir,
		MInt	stgDir,
		MInt	stgWallNormalDir,
		MInt	wallDir,
		MBool	cutOff
	)

Definition at line 26 of file fvstg.cpp.

  : m_solver(solver),
    m_solverId(solver->m_solverId),
    m_bcId(bcId),
    m_sutherlandConstant(solver->m_sutherlandConstant),
    m_sutherlandPlusOne(solver->m_sutherlandPlusOne),
    m_commStg(commStg),
    m_noStgLCells(noStgLCells),
    m_stgFaceNormalDir(stgFaceNormalDir),
    m_stgWallNormalDir(stgWallNormalDir),
    m_stgDir(stgDir),
    m_wallDir(wallDir),
    m_cutOff(cutOff),
    a(new Accessor(sortedBndryCellIds, noStgLCells, m_solver, commStg, cutOff)) {
  TRACE();
 
  IF_CONSTEXPR(nDim == 2) mTerm(1, AT_, "Only implemented for 3D!");
 
  for(MInt i = 0; i < nDim; i++) {
    if(i != m_stgDir && i != m_wallDir) {
      m_periodicDir = i;
    }
  }
 
  m_stgLocal = (noStgLCells > 0);
 
  setSTGProperties();
 
  // Allocate m_stgVariables
  mAlloc(m_stgLVariables, STG::noStgVars, a->sizeStg(), "m_stgLVariables", F0, AT_);
 
  if(m_newStgMethod) {
    mAlloc(m_stgEddieCoverage, 2, a->sizeStg(), "m_stgEddieCoverage", F0, AT_);
  }
}

Member Function Documentation

advanceEddies()

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

void MSTG< nDim, SolverTypeR, SolverTypeL >::advanceEddies

private

Definition at line 1964 of file fvstg.cpp.

                                                         {
  // Array for MPI operation
  MFloatScratchSpace eddyBcastBuffer(m_stgMaxNoEddies * m_stgNoEddieProperties, AT_, "eddyBcastBuffer");
  eddyBcastBuffer.fill(F0);
 
  MFloatScratchSpace eddyBcastStrength(m_stgMaxNoEddies, AT_, "eddyBcastStrength");
  eddyBcastStrength.fill(F0);
 
 
  MFloat xk[3];
  MFloat epsi[3];
  if(m_stgMyRank == m_commStgRoot) {
    for(MInt n = 0; n < m_stgMaxNoEddies; n++) {
      xk[0] = m_stgEddies[n][0];
      xk[1] = m_stgEddies[n][1];
      xk[2] = m_stgEddies[n][2];
 
      eddyBcastStrength[n] = m_stgEddyStrength[n];
 
      // Check if the eddie has left the Virtual Box
      if(xk[0] > m_stgVbEnd[0] || xk[0] < m_stgVbStart[0] || xk[1] > m_stgVbEnd[1] || xk[1] < m_stgVbStart[1]
         || xk[2] > m_stgVbEnd[2] || xk[2] < m_stgVbStart[2]) {
        generateNewEddies(xk, epsi);
 
        eddyBcastStrength[n] = F1;
        if(m_newStgMethod) {
          eddyBcastStrength[n] = generate_rand_normalDist();
        }
 
      } else {
        xk[0] = m_stgMaxVel[0] * m_solver->m_timeStep + m_stgEddies[n][0];
        xk[1] = m_stgMaxVel[1] * m_solver->m_timeStep + m_stgEddies[n][1];
        xk[2] = m_stgMaxVel[2] * m_solver->m_timeStep + m_stgEddies[n][2];
 
        epsi[0] = m_stgEddies[n][3];
        epsi[1] = m_stgEddies[n][4];
        epsi[2] = m_stgEddies[n][5];
      }
 
      eddyBcastBuffer[n + m_stgMaxNoEddies * 0] = xk[0];
      eddyBcastBuffer[n + m_stgMaxNoEddies * 1] = xk[1];
      eddyBcastBuffer[n + m_stgMaxNoEddies * 2] = xk[2];
      eddyBcastBuffer[n + m_stgMaxNoEddies * 3] = epsi[0];
      eddyBcastBuffer[n + m_stgMaxNoEddies * 4] = epsi[1];
      eddyBcastBuffer[n + m_stgMaxNoEddies * 5] = epsi[2];
    }
  }
 
  // Broadcast the new/updated eddies to all relevant processes
  MPI_Bcast(eddyBcastBuffer.begin(), m_stgMaxNoEddies * m_stgNoEddieProperties, MPI_DOUBLE, m_commStgRoot, m_commStg,
            AT_, "eddyBcastBuffer.begin()");
 
  MPI_Bcast(eddyBcastStrength.begin(), m_stgMaxNoEddies, MPI_DOUBLE, m_commStgRoot, m_commStg, AT_,
            "eddyBcastStrength.begin()");
 
  // Copy data into m_FQeddie vector
  for(MInt n = 0; n < m_stgMaxNoEddies; n++) {
    for(MInt p = 0; p < m_stgNoEddieProperties; p++) {
      m_stgEddies[n][p] = eddyBcastBuffer[n + m_stgMaxNoEddies * p];
    }
    m_stgEddyStrength[n] = eddyBcastStrength[n];
  }
}

apply() [1/2]

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

template<class _ , std::enable_if_t< SolverTypeL==MAIA_STRUCTURED, _ * > >

void MSTG< nDim, SolverTypeR, SolverTypeL >::apply

private

This is where the fluctuations should be added to velocity!

Definition at line 2287 of file fvstg.cpp.

                                                 {
  TRACE();
 
  const MFloat gamma = m_solver->m_gamma;
  const MFloat gammaMinusOne = gamma - 1.0;
 
  if(m_initialRange || globalTimeStep < m_solver->m_stgStartTimeStep) {
    for(typename Accessor::nDim_citerator it = a->iterateB1(); it != a->iterateB1_nDim_citerator_end(); ++it) {
      const MInt cellIdG1 = a->getCellId(it);
      const MInt IBC = a->getStgId(it);
 
      if(m_cutOff) {
        LES->a_pvariable(cellIdG1, PV->RHO) = m_stgLVariables[STG::AVG_RHO][IBC];
        LES->a_pvariable(cellIdG1, PV->U) = m_stgLVariables[STG::AVG_U][IBC];
        LES->a_pvariable(cellIdG1, PV->V) = m_stgLVariables[STG::AVG_V][IBC];
        LES->a_pvariable(cellIdG1, PV->W) = m_stgLVariables[STG::AVG_W][IBC];
      } else {
        const MInt ghostCellId = a->getGhostIdFromStgId(IBC);
        // Density
        LES->a_pvariable(ghostCellId, PV->RHO) =
            2.0 * m_stgLVariables[STG::AVG_RHO][IBC] - LES->a_pvariable(cellIdG1, PV->RHO);
        // Velocitiy
        LES->a_pvariable(ghostCellId, PV->U) =
            2.0 * m_stgLVariables[STG::AVG_U][IBC] - LES->a_pvariable(cellIdG1, PV->U);
        LES->a_pvariable(ghostCellId, PV->V) =
            2.0 * m_stgLVariables[STG::AVG_V][IBC] - LES->a_pvariable(cellIdG1, PV->V);
        LES->a_pvariable(ghostCellId, PV->W) =
            2.0 * m_stgLVariables[STG::AVG_W][IBC] - LES->a_pvariable(cellIdG1, PV->W);
        // Pressure
        LES->a_pvariable(ghostCellId, PV->P) =
            2.0 * m_stgLVariables[STG::AVG_P][IBC] - LES->a_pvariable(cellIdG1, PV->P);
      }
    }
 
  } else {
    for(typename Accessor::nDim_citerator it = a->iterateB1(); it != a->iterateB1_nDim_citerator_end(); ++it) {
      const MInt cellIdG1 = a->getCellId(it);
      const MInt IBC = a->getStgId(it);
      // TODO: CHECK THIS LATER
      const MInt cellIdA1 = cellIdG1;
      // if(m_cutOff) {
      //   const MInt cellIdA1 = a->getNghbr(it, 1); // cellIdG1; // a->getNghbr(it, 1); //express this by means of face
      // }
 
      // TODO: especially check if this is true if stg is applied at +x
      MFloat dxidx = 1;
      MFloat dxidy = 0;
      MFloat dxidz = 0;
 
      MFloat gradxi = -F1 / sqrt(dxidx * dxidx + dxidy * dxidy + dxidz * dxidz);
 
      MFloat dxHelp = dxidx * gradxi;
      MFloat dyHelp = dxidy * gradxi;
      MFloat dzHelp = dxidz * gradxi;
 
      // compute Mach number perpendicular to inlet
      const MFloat rhoBC = LES->a_pvariable(cellIdG1, PV->RHO);
      const MFloat pBC = LES->a_pvariable(cellIdG1, PV->P);
      const MFloat fRhoBC = F1 / rhoBC;
      const MFloat aBC = sqrt(gamma * pBC * fRhoBC);
      const MFloat uBC = LES->a_pvariable(cellIdG1, PV->U);
      const MFloat vBC = LES->a_pvariable(cellIdG1, PV->V);
      const MFloat wBC = LES->a_pvariable(cellIdG1, PV->W);
 
      const MFloat maBC = (dxHelp * uBC + dyHelp * vBC + dzHelp * wBC) / aBC;
 
      // get mean values from the rans
      const MFloat rhoRANS = m_stgLVariables[STG::AVG_RHO][IBC];
      const MFloat uRANS = m_stgLVariables[STG::AVG_U][IBC];
      const MFloat vRANS = m_stgLVariables[STG::AVG_V][IBC];
      const MFloat wRANS = m_stgLVariables[STG::AVG_W][IBC];
      const MFloat pRANS = m_stgLVariables[STG::AVG_P][IBC];
 
      // fluctuation values from the STG
      const MFloat u_prime = m_stgLVariables[STG::FLUC_U][IBC];
      const MFloat v_prime = m_stgLVariables[STG::FLUC_V][IBC];
      const MFloat w_prime = m_stgLVariables[STG::FLUC_W][IBC];
 
      // superpose onto mean RANS variables
      const MFloat uSTG = std::max(uRANS + u_prime, epsl);
      const MFloat vSTG = vRANS + v_prime;
      const MFloat wSTG = wRANS + w_prime;
 
      // compute correct density
      const MFloat u9a = LES->UInfinity();
      const MFloat u9ff = u_prime;
      const MFloat alok = sqrt(gamma * LES->PInfinity() / LES->rhoInfinity());
      const MFloat flucc =
          u9ff / u9a * POW2((LES->UInfinity() / alok)) * gammaMinusOne * m_stgLVariables[STG::AVG_RHO][IBC];
      const MFloat zdir = flucc / std::max(fabs(flucc), 0.0000001);
      const MFloat rhoSTG = rhoRANS + zdir * std::min(fabs(flucc), 0.1 * rhoRANS);
 
      // get field values inside the integration domain
      const MFloat pField = LES->a_pvariable(cellIdA1, PV->P);
      const MFloat rhoField = LES->a_pvariable(cellIdA1, PV->RHO);
      const MFloat uField = LES->a_pvariable(cellIdA1, PV->U);
      const MFloat vField = LES->a_pvariable(cellIdA1, PV->V);
      const MFloat wField = LES->a_pvariable(cellIdA1, PV->W);
      const MFloat aField = sqrt(gamma * pField / rhoField);
 
      const MFloat pSub =
          F1B2
          * (pField + pRANS
             + rhoField * aField * (+dxHelp * (uField - uSTG) + dyHelp * (vField - vSTG) + dzHelp * (wField - wSTG)));
      const MFloat rhoSub = rhoSTG + (pSub - pRANS) / (POW2(aField));
      const MFloat rhoSubHelp = (pSub - pRANS) / (rhoField * aField);
 
      // Multiply velocities with density
      const MFloat uSub = uSTG + dxHelp * rhoSubHelp;
      const MFloat vSub = vSTG + dyHelp * rhoSubHelp;
      const MFloat wSub = wSTG + dzHelp * rhoSubHelp;
 
      const MFloat rhoSup = rhoSTG;
      const MFloat uSup = uSTG;
      const MFloat vSup = vSTG;
      const MFloat wSup = wSTG;
      const MFloat pSup = pRANS;
 
 
      // by default the subsonic formulation is used
      // switch on "stgSubSup" to get the mixed formulation
      // or "stgSupersonic" to use the pure supersonic formulation
      MFloat xSub = F1;
      MFloat xSup = F0;
 
      if(m_stgSubSup) {
        const MFloat maBCAbs = fabs(maBC);
        const MFloat alpha = 14.0;
        const MFloat b = 0.95;
        const MFloat count = alpha * (maBCAbs - b);
        const MFloat denom = (F1 - 0.99 * b) * maBCAbs + b;
        const MFloat ratio = count / denom;
        const MFloat wfun = F1B2 * (F1 + tanh(ratio) / tanh(alpha));
 
        xSub = fabs(wfun - F1);
        xSup = fabs(wfun);
      } else if(m_stgSupersonic) {
        xSub = F0;
        xSup = F1;
      }
 
      const MFloat rho_target = rhoSub * xSub + rhoSup * xSup;
      const MFloat u_target = uSub * xSub + uSup * xSup;
      const MFloat v_target = vSub * xSub + vSup * xSup;
      const MFloat w_target = wSub * xSub + wSup * xSup;
      const MFloat p_target = pSub * xSub + pSup * xSup;
 
      if(m_cutOff) {
        LES->a_pvariable(cellIdG1, PV->RHO) = rho_target;
        LES->a_pvariable(cellIdG1, PV->U) = u_target;
        LES->a_pvariable(cellIdG1, PV->V) = v_target;
        LES->a_pvariable(cellIdG1, PV->W) = w_target;
      } else {
        const MInt ghostCellId = a->getGhostIdFromStgId(IBC);
        LES->a_pvariable(ghostCellId, PV->RHO) = 2.0 * rho_target - LES->a_pvariable(cellIdG1, PV->RHO);
        LES->a_pvariable(ghostCellId, PV->U) = 2.0 * u_target - LES->a_pvariable(cellIdG1, PV->U);
        LES->a_pvariable(ghostCellId, PV->V) = 2.0 * v_target - LES->a_pvariable(cellIdG1, PV->V);
        LES->a_pvariable(ghostCellId, PV->W) = 2.0 * w_target - LES->a_pvariable(cellIdG1, PV->W);
        LES->a_pvariable(ghostCellId, PV->P) = 2.0 * p_target - LES->a_pvariable(cellIdG1, PV->P);
      }
    }
  }
}

apply() [2/2]

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

template<class _ = void, std::enable_if_t< SolverTypeL==MAIA_FINITE_VOLUME, _ * > = nullptr>

void MSTG< nDim, SolverTypeR, SolverTypeL >::apply ( )

private

bc7909()

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

void MSTG< nDim, SolverTypeR, SolverTypeL >::bc7909

Definition at line 788 of file fvstg.cpp.

                                                  {
  if((globalTimeStep != m_solver->m_restartTimeStep) && !m_solver->m_wasAdapted
     && globalTimeStep % m_solver->m_restartInterval == 0 && m_solver->m_RKStep == 0) {
    saveStg();
  }
 
  if(m_solver->m_RKStep == 0) {
    if(m_zonal
       && (globalTimeStep % m_solver->m_zonalTransferInterval == 0 || globalTimeStep == m_solver->m_restartTimeStep
           || m_solver->m_wasAdapted)) {
      readRANSProfileStg();
 
      getBoundaryLayerThickness();
      getInflowStartEnd(m_inflowStart, m_inflowEnd);
      setVb(m_inflowStart, m_inflowEnd);
 
      calcStrainRate();
      calcReynoldsStressConvVelLengthScale();
    }
 
    if(!m_zonal && (globalTimeStep == m_solver->m_restartTimeStep || globalTimeStep <= 1)) {
      calcStrainRate();
      calcReynoldsStressConvVelLengthScale();
    }
 
    /*********************** J *****************/
    // The virtual box part - executed by Master Solver at the inflow
    /*********************** J *****************/
 
    if(!m_solver->m_wasAdapted) {
      advanceEddies();
    }
 
#ifndef NDEBUG
    // Summary of synth turb parameters
    // printSTGSummary();
#endif
    /*********************** L *****************/
    // Calculation of the fluctuation induced by all eddies on each cell
    /*********************** L *****************/
    calcTotalFluctuationCholesky();
 
    if(m_newStgMethod) {
      // calcEddieCoverage();
    }
 
  } // RKStep end if
 
  // Now comes the BC stuff that we need to do every RK step
  apply();
}

calcEddieCoverage()

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

void MSTG< nDim, SolverTypeR, SolverTypeL >::calcEddieCoverage

private

Definition at line 2206 of file fvstg.cpp.

                                                             {
  TRACE();
 
  for(typename Accessor::nDim_citerator it = a->iterateB1(); it != a->iterateB1_nDim_citerator_end(); ++it) {
    const MInt IBC = a->getStgId(it);
 
    m_stgEddieCoverage[1][IBC] = F0;
  }
 
  std::vector<MFloat> eddieCoverage(m_stgGlobalNoWallNormalLocations, F0);
 
  for(MInt i = 0; i < m_stgGlobalNoWallNormalLocations; i++) {
    for(MInt p = 0; p < (MInt)m_stgPeriodicCellId[i].size(); p++) {
      MInt id = m_stgPeriodicCellId[i][p];
      eddieCoverage[i] += m_stgEddieCoverage[0][id] / m_stgGlobalNoPeriodicLocations[i];
    }
  }
 
  MPI_Allreduce(MPI_IN_PLACE, &eddieCoverage[0], m_stgGlobalNoWallNormalLocations, MPI_DOUBLE, MPI_SUM, m_commStg, AT_,
                "MPI_IN_PLACE", "m_LESPeriodicAverage");
 
  for(typename Accessor::nDim_citerator it = a->iterateB1(); it != a->iterateB1_nDim_citerator_end(); ++it) {
    const MInt IBC = a->getStgId(it);
    const MInt cellId = a->getCellId(it);
 
    MFloat index = m_stgPeriodicIndex[IBC];
    m_stgEddieCoverage[1][IBC] = eddieCoverage[index];
 
    m_solver->m_stgEddieCoverage[1][cellId] = m_stgEddieCoverage[1][IBC];
    m_solver->m_stgEddieCoverage[2][cellId] = m_stgEddieCoverage[1][IBC] - m_stgEddieCoverage[0][IBC];
  }
}

calcReynoldsStressConvVelLengthScale()

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

void MSTG< nDim, SolverTypeR, SolverTypeL >::calcReynoldsStressConvVelLengthScale

private

m_preliminary

Definition at line 1682 of file fvstg.cpp.

                                                                                {
  // Arrays for MPI operations
  MFloatScratchSpace maxValsLocal(3, AT_, "maxValsLocal");
  MInt size;
  MPI_Comm_size(m_commStg, &size);
  MFloatScratchSpace maxValsGlobal(3 * size, AT_, "maxValsGlobal");
  maxValsLocal.fill(F0);
  maxValsGlobal.fill(F0);
 
  const MFloat fre = 1.0 / m_solver->sysEqn().m_Re0;
 
  const MFloat delta_in = m_stgDelta99Inflow;
 
  // Initialize max values
  MFloat utaumax = F0, umax = F0, vmax = F0, wmax = F0, minLengthLocal = F0;
 
  for(typename Accessor::nDim_citerator it = a->iterateSlopes(); it != a->iterateSlopes_nDim_citerator_end(); ++it) {
    const MInt id = a->getStgId(it);
    const MInt cellId = a->getCellId(it);
 
    const MFloat frho = 1.0 / m_stgLVariables[STG::AVG_RHO][id];
 
    MFloat SijSij = m_stgLVariables[STG::SIJSIJ][id];
 
    if(!m_preliminary || m_preliminaryRans2D) {
      // Strain tensor
      // const MFloat s11 = m_stgLVariables[STG::S11][id];
      // const MFloat s22 = m_stgLVariables[STG::S22][id];
      // const MFloat s33 = m_stgLVariables[STG::S33][id];
      const MFloat s12 = m_stgLVariables[STG::S12][id];
      const MFloat s23 = m_stgLVariables[STG::S23][id];
      const MFloat s13 = m_stgLVariables[STG::S13][id];
      const MFloat s21 = s12;
      const MFloat s32 = s23;
      const MFloat s31 = s13;
 
      if(m_freeStreamTurbulence) {
        MFloat SijSij_ = SijSij;
        MFloat tmp = LES->a_coordinate(cellId, m_wallDir);
        if(m_cylinderTransformation) {
          MFloat y = LES->a_coordinate(cellId, m_wallDir);
          MFloat z = LES->a_coordinate(cellId, m_periodicDir);
          tmp = sqrt(y * y + z * z);
        }
        if(tmp > m_stgWallEnd) {
          SijSij_ = m_SijSijFS;
        }
        SijSij = SijSij_;
        m_stgLVariables[STG::SIJSIJ][id] = SijSij;
      }
 
      //>marian: in TFS code this isn't SQRT
      // m_stgLVariables[STG::SIJSIJ][id] = SijSij;
 
      // Assume a one-, or two equation turbulence model
      // Assume a simplified directivity:
      // Read from RANS profile
 
      MFloat nu_t = m_stgLVariables[STG::NU_T][id];
 
      const MFloat sr1 = (s12 + s21) * (s12 + s21);
      const MFloat sr2 = (s23 + s32) * (s23 + s32);
      const MFloat sr3 = (s13 + s31) * (s13 + s31);
      const MFloat srt = std::max(sqrt(sr1 + sr2 + sr3), epsl);
 
      const MFloat rr1 = sqrt(sr1) / srt;
      const MFloat rr2 = sqrt(sr2) / srt;
      const MFloat rr3 = sqrt(sr3) / srt;
 
      const MFloat uv = -sqrt(2.0 * SijSij) * rr1 * nu_t * fre;
      const MFloat vw = -sqrt(2.0 * SijSij) * rr2 * nu_t * fre;
      const MFloat uw = -sqrt(2.0 * SijSij) * rr3 * nu_t * fre;
      const MFloat uu = a1 * std::abs(uv) * m_stgRSTFactors[0];
      const MFloat vv = a1 * std::abs(uv) * m_stgRSTFactors[1];
      const MFloat ww = a1 * std::abs(uv) * m_stgRSTFactors[2];
 
      m_stgLVariables[STG::FLUC_UU][id] = uu;
      m_stgLVariables[STG::FLUC_UV][id] = uv;
      m_stgLVariables[STG::FLUC_VV][id] = vv;
      m_stgLVariables[STG::FLUC_WW][id] = ww;
      m_stgLVariables[STG::FLUC_VW][id] = vw;
      m_stgLVariables[STG::FLUC_UW][id] = uw;
    } 
    else {
      MFloat uv = m_stgLVariables[STG::FLUC_UV][id];
      m_stgLVariables[STG::FLUC_UU][id] = a1 * std::abs(uv) * m_stgRSTFactors[0];
      m_stgLVariables[STG::FLUC_VV][id] = a1 * std::abs(uv) * m_stgRSTFactors[1];
      m_stgLVariables[STG::FLUC_WW][id] = a1 * std::abs(uv) * m_stgRSTFactors[2];
      m_stgLVariables[STG::FLUC_VW][id] = 0;
      m_stgLVariables[STG::FLUC_UW][id] = 0;
    }
 
    if(m_freeStreamTurbulence) {
      m_stgLVariables[STG::FLUC_UU][id] = m_uuFS;
      m_stgLVariables[STG::FLUC_UV][id] = 0;
      m_stgLVariables[STG::FLUC_VV][id] = m_vvFS;
      m_stgLVariables[STG::FLUC_WW][id] = m_wwFS;
      m_stgLVariables[STG::FLUC_VW][id] = 0;
      m_stgLVariables[STG::FLUC_UW][id] = 0;
    }
 
    // TODO: this is different from the implementation in the Structured solver
    MFloat rhoRANSI1 = m_stgLVariables[PV->RHO][id];
    MFloat pressure1 = m_stgLVariables[PV->P][id];
 
    const MFloat temp = m_solver->m_gamma * pressure1 / rhoRANSI1;
    const MFloat xmu = SUTHERLANDLAW(temp);
 
    // Get utau using laminar viscosity
    MFloat utau2_ = sqrt(fre * sqrt(2.0 * SijSij) * xmu * frho);
 
    const MFloat utau2 = utau2_;
 
    // TODO: check the following
    const MFloat dV = getCellSize(it);
 
    // Save values if they are the new maximum
    if(utau2 >= utaumax) {
      minLengthLocal = pow(dV, 0.33);
      utaumax = std::max(utau2, utaumax);
    }
 
    // In which direction aims the maximum averaged velocity?
    // TODO: think if RANS or LES velocity?
    const MFloat u = m_stgLVariables[STG::AVG_U][id];
    const MFloat v = m_stgLVariables[STG::AVG_V][id];
    const MFloat w = m_stgLVariables[STG::AVG_W][id];
 
    // TODO: check the following
    umax = (fabs(u) > fabs(umax)) ? u : umax; // std::max(u, umax);
    vmax = (fabs(v) > fabs(vmax)) ? v : vmax; // std::max(v, vmax);
    wmax = (fabs(w) > fabs(wmax)) ? w : wmax; // std::max(w, wmax);
 
    // We need a global length scale to compare
    m_stgLVariables[STG::LENGTH_SCALE][id] = pow(sqrt(std::max(2.0 * SijSij, epss)), -m_stgExple);
 
    // TODO: next section only for Structured:
    // Zero gradient extrapolation of boundary values
    // extrapolateToBoundary(it);
 
    // Save max direction vector and max tau
    maxValsLocal[0] = umax;
    maxValsLocal[1] = vmax;
    maxValsLocal[2] = wmax;
 
    if(std::isnan(utaumax) || std::isinf(utaumax)) utaumax = F0;
  }
 
  // Communication: Exchange min and max values
  MFloat minLengthGlobal = 0.0;
  MFloat utaux;
  MPI_Allgather(maxValsLocal.begin(), 3, MPI_DOUBLE, maxValsGlobal.begin(), 3, MPI_DOUBLE, m_commStg, AT_,
                "maxValsLocal.begin()", "maxValsGlobal.begin()");
  MPI_Allreduce(&utaumax, &utaux, 1, MPI_DOUBLE, MPI_MAX, m_commStg, AT_, "utaumax", "utaux");
 
  MPI_Allreduce(&minLengthLocal, &minLengthGlobal, 1, MPI_DOUBLE, MPI_MIN, m_commStg, AT_, "minLengthLocal",
                "minLengthGlobal");
 
  // Maximum convection velocities at inflow
  std::fill_n(&m_stgMaxVel[0], 3, 0.0);
  for(MInt d = 0; d < size; ++d) {
    m_stgMaxVel[0] = (fabs(m_stgMaxVel[0]) > fabs(maxValsGlobal[3 * d])) ? m_stgMaxVel[0] : maxValsGlobal[3 * d];
    m_stgMaxVel[1] =
        (fabs(m_stgMaxVel[1]) > fabs(maxValsGlobal[3 * d + 1])) ? m_stgMaxVel[1] : maxValsGlobal[3 * d + 1];
    m_stgMaxVel[2] =
        (fabs(m_stgMaxVel[2]) > fabs(maxValsGlobal[3 * d + 2])) ? m_stgMaxVel[2] : maxValsGlobal[3 * d + 2];
  }
 
#ifndef NDEBUG
  if(m_stgMyRank == m_commStgRoot) {
    cerr << "m_stgMaxVel: " << utaux << " " << m_stgMaxVel[0] << " " << m_stgMaxVel[1] << " " << m_stgMaxVel[2] << endl;
  }
#endif
 
  for(typename Accessor::nDim_citerator it = a->iterateB1(); it != a->iterateB1_nDim_citerator_end(); ++it) {
    const MInt IBC = it.getStgId();
    // const MInt cellId = a->getCellId(it);
 
    MFloat maxLength = delta_in;
 
    // Length scale in main flow direction
    const MFloat xlength = std::max(
        std::min(
            m_stgLengthFactors[0]
                * std::max(m_stgLVariables[STG::LENGTH_SCALE][IBC] * delta_in * pow(utaux / delta_in, m_stgExple), eps),
            maxLength * 1.0),
        minLengthGlobal);
 
    // Length scale in the direction of main shear
    const MFloat ylength = std::max(
        std::min(
            m_stgLengthFactors[1]
                * std::max(m_stgLVariables[STG::LENGTH_SCALE][IBC] * delta_in * pow(utaux / delta_in, m_stgExple), eps),
            maxLength * 0.66),
        minLengthGlobal);
 
    // Length scale in the direction perpendicular of x and y
    const MFloat zlength = std::max(
        std::min(
            m_stgLengthFactors[2]
                * std::max(m_stgLVariables[STG::LENGTH_SCALE][IBC] * delta_in * pow(utaux / delta_in, m_stgExple), eps),
            maxLength * 1.0),
        minLengthGlobal);
 
    m_stgLVariables[STG::LENGTH_X][IBC] = xlength;
    m_stgLVariables[STG::LENGTH_Y][IBC] = ylength;
    m_stgLVariables[STG::LENGTH_Z][IBC] = zlength;
  }
}

calcStrainRate() [1/2]

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

template<class _ , std::enable_if_t< SolverTypeL==MAIA_STRUCTURED, _ * > >

void MSTG< nDim, SolverTypeR, SolverTypeL >::calcStrainRate

private

Definition at line 1472 of file fvstg.cpp.

                                                          {
  TRACE();
 
  if(!m_preliminary) {
    for(typename Accessor::nDim_citerator it = a->iterateB1(); it != a->iterateB1_nDim_citerator_end(); ++it) {
      const MInt cellId = a->getCellId(it);
      const MInt recData = m_solver->a_reconstructionData(cellId);
      MFloat du[nDim][nDim]{{F0, F0, F0}, {F0, F0, F0}, {F0, F0, F0}};
      const MFloat u[nDim] = {m_stgLVariables[STG::AVG_U][a->getStgId(it)],
                              m_stgLVariables[STG::AVG_V][a->getStgId(it)],
                              m_stgLVariables[STG::AVG_W][a->getStgId(it)]};
 
      for(MInt nghbr = 0; nghbr < m_solver->a_noReconstructionNeighbors(cellId); nghbr++) {
        const MInt recNghbrId = m_solver->a_reconstructionNeighborId(cellId, nghbr);
        const MInt nghbrStgId = a->getNghbrMapping(a->getStgId(it), nghbr);
 
        const MFloat recConst_x = m_solver->m_reconstructionConstants[nDim * (recData + nghbr) + 0];
        const MFloat recConst_y = m_solver->m_reconstructionConstants[nDim * (recData + nghbr) + 1];
        const MFloat recConst_z = m_solver->m_reconstructionConstants[nDim * (recData + nghbr) + 2];
 
        MFloat delta_u = F0;
        for(MInt d = 0; d < nDim; ++d) {
          if(m_cutOff) {
            if(recNghbrId > 0 && recNghbrId < m_solver->c_noCells()) {
              delta_u = m_solver->m_RANSValues[d][recNghbrId] - u[d];
            }
          } else {
            if(nghbrStgId > 0) delta_u = m_stgLVariables[STG::AVG_UU[d]][nghbrStgId] - u[d];
          }
          du[d][0] += recConst_x * delta_u;
          du[d][1] += recConst_y * delta_u;
          du[d][2] += recConst_z * delta_u;
        }
      }
      if(m_solver->m_reConstSVDWeightMode == 3) {
        if(!m_solver->a_hasProperty(cellId, /*SolverCell*/ FvCell::HasCoarseNghbr)) {
          continue;
        }
        std::array<MBool, nDim> dirsJmp = {};
        for(MInt d = 0; d < nDim; ++d) {
          if(m_solver->m_cells.nghbrInterface(cellId, 2 * d) == 3
             || m_solver->m_cells.nghbrInterface(cellId, 2 * d + 1) == 3) {
            dirsJmp[d] = true;
          } else {
            dirsJmp[d] = false;
          }
        }
 
        for(MUint d = 0; d < nDim; ++d) {
          for(MInt dd = 0; dd < nDim; ++dd) {
            if(dirsJmp[dd]) {
              du[d][dd] = 0.0;
            }
          }
        }
 
        for(MInt nghbr = 0; nghbr < m_solver->a_noReconstructionNeighbors(cellId); nghbr++) {
          const MInt nghbrStgId = a->getNghbrMapping(a->getStgId(it), nghbr);
          const MInt nghbrId = m_solver->a_reconstructionNeighborId(cellId, nghbr);
 
          for(MUint d = 0; d < nDim; ++d) {
            MFloat tmp = m_stgLVariables[STG::AVG_UU[d]][nghbrStgId] - u[d];
            for(MInt dd = 0; dd < nDim; ++dd) {
              if(!dirsJmp[dd]) {
                const MFloat dx = LES->a_coordinate(nghbrId, dd) - LES->a_coordinate(cellId, dd);
                tmp -= du[d][dd] * dx;
              }
            }
            for(MInt dd = 0; dd < nDim; ++dd) {
              if(dirsJmp[dd]) {
                du[d][dd] += m_solver->m_reconstructionConstants[nDim * (recData + nghbr) + dd] * tmp;
              }
            }
          }
        }
      }
 
      const MFloat s11 = 2.0 * du[0][0];
      const MFloat s22 = 2.0 * du[1][1];
      const MFloat s33 = 2.0 * du[2][2];
 
      const MFloat s12 = du[1][0] + du[0][1];
      const MFloat s13 = du[2][0] + du[0][2];
      const MFloat s23 = du[2][1] + du[1][2];
 
      const MFloat s21 = s12;
      const MFloat s31 = s13;
      const MFloat s32 = s23;
 
      // Strain tensor
      const MFloat SijSij =
          F1B4
          * (s11 * s11 + s12 * s12 + s13 * s13 + s21 * s21 + s22 * s22 + s23 * s23 + s31 * s31 + s32 * s32 + s33 * s33);
 
      m_stgLVariables[STG::S11][a->getStgId(it)] = s11;
      m_stgLVariables[STG::S22][a->getStgId(it)] = s22;
      m_stgLVariables[STG::S33][a->getStgId(it)] = s33;
 
      m_stgLVariables[STG::S12][a->getStgId(it)] = s12;
      m_stgLVariables[STG::S13][a->getStgId(it)] = s13;
      m_stgLVariables[STG::S23][a->getStgId(it)] = s23;
 
      m_stgLVariables[STG::SIJSIJ][a->getStgId(it)] = SijSij;
    }
  }
}

calcStrainRate() [2/2]

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

template<class _ = void, std::enable_if_t< SolverTypeL==MAIA_FINITE_VOLUME, _ * > = nullptr>

void MSTG< nDim, SolverTypeR, SolverTypeL >::calcStrainRate ( )

private

calcTotalFluctuationCholesky()

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

void MSTG< nDim, SolverTypeR, SolverTypeL >::calcTotalFluctuationCholesky

private

Definition at line 2053 of file fvstg.cpp.

                                                                        {
  TRACE();
 
  const MFloat BLT3 = std::abs(m_stgVbEnd[m_periodicDir] - m_stgVbStart[m_periodicDir]);
  MFloat Vb = m_stgBLT1 * m_stgBLT2 * POW2(m_stgDelta99Inflow) * BLT3;
  if(m_freeStreamTurbulence || m_isotropicTurbulence) {
    const MFloat BLT2 = std::abs(m_stgVbEnd[m_wallDir] - m_stgVbStart[m_wallDir]);
    Vb = m_stgBLT1 * m_stgDelta99Inflow * BLT2 * BLT3;
  }
  // const MFloat Vb = m_stgBLT1 * m_stgBLT2 * POW2(m_stgDelta99Inflow) * BLT3;
  const MFloat vbFactor = sqrt(Vb / m_stgMaxNoEddies);
 
  const MFloat umax = m_stgMaxVel[0];
  const MFloat vmax = m_stgMaxVel[1];
  const MFloat wmax = m_stgMaxVel[2];
 
  for(typename Accessor::nDim_citerator it = a->iterateB1(); it != a->iterateB1_nDim_citerator_end(); ++it) {
    const MInt cellIdBC = a->getStgId(it);
    const MInt cellIdBCFirst = cellIdBC;
    const MInt cellId = a->getCellId(it);
 
    MFloat help1 = F0, help2 = F0, help3 = F0, help4 = F0, help5 = F0, help6 = F0;
 
    const MFloat uu = m_stgLVariables[STG::FLUC_UU][cellIdBCFirst];
    const MFloat vv = m_stgLVariables[STG::FLUC_VV][cellIdBCFirst];
    const MFloat ww = m_stgLVariables[STG::FLUC_WW][cellIdBCFirst];
    const MFloat uv = m_stgLVariables[STG::FLUC_UV][cellIdBCFirst];
    const MFloat vw = m_stgLVariables[STG::FLUC_VW][cellIdBCFirst];
    const MFloat uw = m_stgLVariables[STG::FLUC_UW][cellIdBCFirst];
 
    // Cholesky decomposition of the Reynolds stress tensor
    const MFloat a11 = sqrt(std::max(uu, epsl));
    const MFloat a21 = uv / a11;
    const MFloat a31 = uw / a11;
    const MFloat a22 = sqrt(std::max((vv - a21 * a21), epsl));
    const MFloat a32 = (vw - a21 * a31) / a22;
    const MFloat a33 = sqrt(std::max((ww - a31 * a31 - a32 * a32), epsl));
 
    for(MInt n = 0; n < m_stgMaxNoEddies; n++) {
      // Tent function to determine the symmetric function to model the
      // decay of the fluctuations
      const MFloat xk1t = m_stgEddies[n][0];
      const MFloat xk2t = m_stgEddies[n][1];
      const MFloat xk3t = m_stgEddies[n][2];
 
      MFloat distX = LES->a_coordinate(cellId, 0) - xk1t;
      MFloat distY = LES->a_coordinate(cellId, 1) - xk2t;
      MFloat distZ = LES->a_coordinate(cellId, 2) - xk3t;
 
      if(m_cylinderTransformation) {
        MFloat y = LES->a_coordinate(cellId, m_wallDir);
        MFloat z = LES->a_coordinate(cellId, m_periodicDir);
        MFloat r = sqrt(y * y + z * z);
        MFloat alpha = get_angle(y, z);
        distY = r - xk2t;
        distZ = std::fmod(r * (alpha - xk3t), 2 * r * PI); // Distance of 2*PI means zero distance
      }
 
      // if(m_newStgMethod){
      const MFloat xLb1 = m_stgLVariables[STG::LENGTH_X][cellIdBCFirst] * m_stgEddyStrength[n];
      const MFloat xLb2 = m_stgLVariables[STG::LENGTH_Y][cellIdBCFirst] * m_stgEddyStrength[n];
      const MFloat xLb3 = m_stgLVariables[STG::LENGTH_Z][cellIdBCFirst] * m_stgEddyStrength[n];
      //}
 
      const MFloat fxLb1 = 1.0 / xLb1;
      const MFloat fxLb2 = 1.0 / xLb2;
      const MFloat fxLb3 = 1.0 / xLb3;
 
      const MFloat fsqrtxLb1 = 1.0 / sqrt(xLb1);
      const MFloat fsqrtxLb2 = 1.0 / sqrt(xLb2);
      const MFloat fsqrtxLb3 = 1.0 / sqrt(xLb3);
 
      const MFloat fsqrtPixLb1 = 1.0 / sqrt(3.141 * xLb1);
      const MFloat fsqrtPixLb2 = 1.0 / sqrt(3.141 * xLb2);
      const MFloat fsqrtPixLb3 = 1.0 / sqrt(3.141 * xLb3);
 
      const MFloat aDistX = fabs(distX);
      const MFloat aDistY = fabs(distY);
      const MFloat aDistZ = fabs(distZ);
 
      // only compute contribution if eddie is in vicinity, i.e.,
      // if it is within 4 eddy lengthscales
      if(aDistX < 4.0 * xLb1 && aDistY < 4.0 * xLb2 && aDistZ < 4.0 * xLb3) {
        const MFloat zacfq1 = distX / aDistX;
        const MFloat rol1H = zacfq1 * std::min(aDistX * fxLb1, 1.0);
 
        const MFloat zacfq2 = distY / aDistY;
        const MFloat rol2H = zacfq2 * std::min(aDistY * fxLb2, 1.0);
 
        const MFloat zacfq3 = distZ / aDistZ;
        const MFloat rol3H = zacfq3 * std::min(aDistZ * fxLb3, 1.0);
 
        const MFloat fl1 = 2.0 * fsqrtPixLb1 * exp(-((distX)*2 * fxLb1) * ((distX)*2 * fxLb1));
        const MFloat fl2 = 2.0 * fsqrtPixLb2 * exp(-((distY)*2 * fxLb2) * ((distY)*2 * fxLb2));
        const MFloat fl3 = 2.0 * fsqrtPixLb3 * exp(-((distZ)*2 * fxLb3) * ((distZ)*2 * fxLb3));
 
        // Normalization factor cannot be chosen as Pamies did... or we...
        MFloat fH1 = (F1 - cos(2.0 * 3.141 * rol1H)) / (2.0 * 3.141 * rol1H * 0.44);
        MFloat fH2 = (F1 - cos(2.0 * 3.141 * rol2H)) / (2.0 * 3.141 * rol2H * 0.44);
        MFloat fH3 = (F1 - cos(2.0 * 3.141 * rol3H)) / (2.0 * 3.141 * rol3H * 0.44);
 
        fH1 = aniso * fH1 * fsqrtxLb1 + fabs(aniso - 1.0) * fl1;
        fH2 = aniso * fH2 * fsqrtxLb2 + fabs(aniso - 1.0) * fl2;
        fH3 = aniso * fH3 * fsqrtxLb3 + fabs(aniso - 1.0) * fl3;
 
        const MFloat epsik1 = m_stgEddies[n][3];
        const MFloat epsik2 = m_stgEddies[n][4];
        const MFloat epsik3 = m_stgEddies[n][5];
 
        help4 += vbFactor * epsik1 * fl1 * fl2 * fH3;
        help5 += vbFactor * epsik2 * fl1 * fl2 * fH3;
        help6 += vbFactor * epsik3 * fl1 * fH2 * fl3;
 
        // if(m_newStgMethod){
        //   MFloat coverage = POW2(fl1 * fl2 * fH3);
        //   MFloat T = 2 * m_stgLVariables[STG::LENGTH_X][cellIdBC] / m_stgMaxVel[m_stgDir];
        //   MFloat alpha = m_solver->timeStep() / T;
        //   m_stgEddieCoverage[0][cellIdBC] = alpha * coverage + (1 - alpha) * m_stgEddieCoverage[0][cellIdBC];
 
        //   //transfer
        //   m_solver->m_stgEddieCoverage[0][cellId] = m_stgEddieCoverage[0][cellIdBC];
        // }
      }
    }
 
    help1 = help4 * a11;                             // Fluctuation u'
    help2 = help4 * a21 + help5 * a22;               // Fluctuation v'
    help3 = help4 * a31 + help5 * a32 + help6 * a33; // Fluctuation w'
 
    const MFloat velmax = sqrt(umax * umax + vmax * vmax + wmax * wmax);
 
    MFloat ufluc = std::min(std::max(help1, -0.3 * velmax), 0.3 * velmax);
    MFloat vfluc = std::min(std::max(help2, -0.3 * velmax), 0.3 * velmax);
    MFloat wfluc = std::min(std::max(help3, -0.3 * velmax), 0.3 * velmax);
 
    if(m_cylinderTransformation) {
      MFloat y = m_solver->a_coordinate(cellId, m_wallDir);
      MFloat z = m_solver->a_coordinate(cellId, m_periodicDir);
      MFloat alpha = get_angle(y, z);
      MFloat vtemp = vfluc;
      MFloat wtemp = wfluc;
      vfluc = vtemp * cos(alpha) + wtemp * sin(alpha);
      wfluc = vtemp * sin(alpha) - wtemp * cos(alpha);
    }
 
    m_stgLVariables[STG::FLUC_U][cellIdBC] += timsm * (ufluc - m_stgLVariables[STG::FLUC_U][cellIdBC]);
    m_stgLVariables[STG::FLUC_V][cellIdBC] += timsm * (vfluc - m_stgLVariables[STG::FLUC_V][cellIdBC]);
    m_stgLVariables[STG::FLUC_W][cellIdBC] += timsm * (wfluc - m_stgLVariables[STG::FLUC_W][cellIdBC]);
  }
}

determinePeriodicCells()

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

void MSTG< nDim, SolverTypeR, SolverTypeL >::determinePeriodicCells

private

Definition at line 594 of file fvstg.cpp.

                                                                  {
  TRACE();
 
  MInt noStgBcCells = 0;
  MInt noBcStgLocations = 0;
  MFloat periodicL = 0;
  MBool first = true;
  m_stgWallNormalLocations.clear();
 
  // ======================================================
  // 1) Determine local locations in wall-normal direction for spanwise average
  // ======================================================
  for(typename Accessor::nDim_citerator it = a->iterateB1(); it != a->iterateB1_nDim_citerator_end(); ++it) {
    const MInt cellId = a->getCellId(it);
 
    MFloat halfCellLength = m_solver->grid().halfCellLength(cellId);
    if(first) {
      periodicL = m_solver->a_coordinate(cellId, m_periodicDir) - F1B3 * halfCellLength;
      first = false;
    }
    if(abs(m_solver->a_coordinate(cellId, m_periodicDir) + halfCellLength - eps - periodicL) < halfCellLength) {
      m_stgWallNormalLocations.push_back(m_solver->a_coordinate(cellId, m_wallDir));
      noBcStgLocations++;
    }
    noStgBcCells++;
  }
 
  // ======================================================
  // 2) Create communicator
  // ======================================================
  MInt comm_size;
  MPI_Comm_size(m_commStg, &comm_size);
 
  // ======================================================
  // 3) Determine global locations in wall-normal direction for spanwise average
  // ======================================================
  MInt globalNoBcStgLocations = 0;
  MPI_Allreduce(&noBcStgLocations, &globalNoBcStgLocations, 1, MPI_INT, MPI_SUM, m_commStg, AT_, "noBcStgLocations",
                "globalNoBcStgLocations");
 
  ScratchSpace<MFloat> globalBcStgLocations(globalNoBcStgLocations, "globalBcStgLocations", FUN_);
  ScratchSpace<MInt> recvbuf(comm_size, "recvbuf", FUN_);
  ScratchSpace<MInt> displs(comm_size, "displspos", FUN_);
 
  recvbuf.fill(0);
 
  MPI_Gather(&noBcStgLocations, 1, MPI_INT, &recvbuf[0], 1, MPI_INT, 0, m_commStg, AT_, "noBcStgLocations", "recvbuf");
 
  if(m_stgMyRank == m_commStgRoot) {
    MInt offset = 0;
    for(MInt dom = 0; dom < comm_size; dom++) {
      displs[dom] = offset;
      offset += recvbuf[dom];
    }
  }
 
  MPI_Gatherv(&m_stgWallNormalLocations[0], noBcStgLocations, MPI_DOUBLE, &globalBcStgLocations[0],
              &recvbuf[m_stgMyRank], &displs[m_stgMyRank], MPI_DOUBLE, 0, m_commStg, AT_, "m_StgwallNormalLocations",
              "globalBcStgLocations");
 
  MPI_Bcast(&globalBcStgLocations[0], globalNoBcStgLocations, MPI_DOUBLE, 0, m_commStg, AT_, "globalBcStgLocations");
 
  m_stgGlobalWallNormalLocations.clear();
 
  for(MInt i = 0; i < globalNoBcStgLocations; i++) {
    MFloat L = globalBcStgLocations[i];
    if(std::find(m_stgGlobalWallNormalLocations.begin(), m_stgGlobalWallNormalLocations.end(), L)
       == m_stgGlobalWallNormalLocations.end()) {
      m_stgGlobalWallNormalLocations.push_back(L);
    }
  }
 
 
  m_stgGlobalNoWallNormalLocations = (MInt)m_stgGlobalWallNormalLocations.size();
 
  std::sort(m_stgGlobalWallNormalLocations.begin(), m_stgGlobalWallNormalLocations.end());
 
  // ======================================================
  // 4) Determine local cells in periodic locations of global wall-normal locations
  // ======================================================
  mAlloc(m_stgPeriodicCellId, m_stgGlobalNoWallNormalLocations, "m_stgPeriodicCellIndex", FUN_);
  mAlloc(m_stgGlobalNoPeriodicLocations, m_stgGlobalNoWallNormalLocations, "m_stgGlobalNoPeriodicLocations", 0, FUN_);
 
  for(MInt i = 0; i < m_stgGlobalNoWallNormalLocations; i++) {
    m_stgPeriodicCellId[i].clear();
  }
 
  mAlloc(m_stgPeriodicIndex, noStgBcCells, "m_stgPeriodicIndex", -1, FUN_);
 
  vector<MInt> noPeriodicLocations(m_stgGlobalNoWallNormalLocations, F0);
 
  for(MInt i = 0; i < m_stgGlobalNoWallNormalLocations; i++) {
    for(typename Accessor::nDim_citerator it = a->iterateB1(); it != a->iterateB1_nDim_citerator_end(); ++it) {
      const MInt cellId = a->getCellId(it);
      const MInt IBC = a->getStgId(it);
      if(abs(m_solver->a_coordinate(cellId, m_wallDir) - m_stgGlobalWallNormalLocations[i]) < eps) {
        m_stgPeriodicIndex[IBC] = i;
        if(!m_solver->a_isHalo(cellId)) {
          m_stgPeriodicCellId[i].push_back(IBC);
          ++noPeriodicLocations[i];
        }
      }
    }
  }
 
  MPI_Allreduce(&noPeriodicLocations[0], &m_stgGlobalNoPeriodicLocations[0], m_stgGlobalNoWallNormalLocations, MPI_INT,
                MPI_SUM, m_commStg, AT_, "noPeriodicLocations", "m_stgGlobalNoPeriodicLocations");
}

extrapolateToBoundary() [1/2]

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

template<class _ , std::enable_if_t< SolverTypeL==MAIA_STRUCTURED, _ * > >

void MSTG< nDim, SolverTypeR, SolverTypeL >::extrapolateToBoundary ( typename Accessor::nDim_citerator  it )

private

Definition at line 2242 of file fvstg.cpp.

                                                                                                   {
  const MInt noSTGVariables = STG::noSTGVars - PV->noVariables;
 
  const MInt k = it.getijk(2);
  if(k == a->start(2) + 1) {
    // 1st layer
    for(MInt var = PV->noVariables; var < noSTGVariables; ++var) {
      m_stgLVariables[var][it.getNghbrStg(4)] = m_stgLVariables[var][it.getStgId()];
    }
  } else if(k == a->end(2) - a->m_noGhostLayers) {
    // 1st layer
    for(MInt var = PV->noVariables; var < noSTGVariables; ++var) {
      m_stgLVariables[var][it.getNghbrStg(5)] = m_stgLVariables[var][it.getStgId()];
    }
  }
 
  const MInt j = it.getijk(1);
  if(j == a->start(1) + 1) {
    for(MInt var = PV->noVariables; var < noSTGVariables; ++var) {
      m_stgLVariables[var][it.getNghbrStg(2)] = m_stgLVariables[var][it.getStgId()];
    }
  } else if(j == a->end(1) - a->m_noGhostLayers) {
    for(MInt var = PV->noVariables; var < noSTGVariables; ++var) {
      m_stgLVariables[var][it.getNghbrStg(3)] = m_stgLVariables[var][it.getStgId()];
    }
  }
}

extrapolateToBoundary() [2/2]

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

template<class _ = void, std::enable_if_t< SolverTypeL==MAIA_FINITE_VOLUME, _ * > = nullptr>

void MSTG< nDim, SolverTypeR, SolverTypeL >::extrapolateToBoundary ( typename Accessor::nDim_citerator  )

inlineprivate

Definition at line 663 of file fvstg.h.

{}

extrapolateToGX()

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

template<class _ , std::enable_if_t< SolverTypeL==MAIA_STRUCTURED, _ * > >

void MSTG< nDim, SolverTypeR, SolverTypeL >::extrapolateToGX ( typename Accessor::nDim_citerator  it )

private

Definition at line 2273 of file fvstg.cpp.

                                                                                             {
  const MInt cellIdG1 = a->getCellId(it);
  const MInt cellIdA1 = a->getNghbr(it, 1); // express this by means of face
  const MInt cellIdG2 = a->getNghbr(it, 0);
  //  const MInt cellIdG2 = cellIndex(0,j,k);
  // extrapolate into second ghost cell
  for(MInt var = 0; var < PV->noVariables; var++) {
    LES->a_pvariable(cellIdG2, var) = F2 * LES->a_pvariable(cellIdG1, var) - LES->a_pvariable(cellIdA1, var);
  }
}

generate_rand()

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MFloat MSTG< nDim, SolverTypeR, SolverTypeL >::generate_rand

private

Definition at line 80 of file fvstg.cpp.

                                                           {
  std::uniform_real_distribution<MFloat> randRealDistNumber(0, 1);
  return randRealDistNumber(randomEddyPosGenerator());
  //  return rand() / double(RAND_MAX);
}

generate_rand_normalDist()

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MFloat MSTG< nDim, SolverTypeR, SolverTypeL >::generate_rand_normalDist

private

Definition at line 103 of file fvstg.cpp.

                                                                      {
  return 15.0 * pow((rand() / double(RAND_MAX)) - 0.35, F3) + F1;
}

generate_rand_weighted()

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MFloat MSTG< nDim, SolverTypeR, SolverTypeL >::generate_rand_weighted

private

Generate weighted random numbers, for a distribution with a higher probability towards the higher bound pass a number < 1.0 for a higher probability towards lower bound pass a number > 1.0 (see tfs)

Author

Marian Albers

Date

01.01.1010

Definition at line 96 of file fvstg.cpp.

                                                                    {
  std::uniform_real_distribution<MFloat> randRealDistNumber(0, 1);
  return pow(randRealDistNumber(randomEddyPosGenerator()), m_stgEddieDistribution);
  // return pow((rand() / double(RAND_MAX)), m_stgEddieDistribution);
}

generateNewEddies()

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

void MSTG< nDim, SolverTypeR, SolverTypeL >::generateNewEddies ( MFloat *  xk, MFloat *  epsi  )

private

Definition at line 1929 of file fvstg.cpp.

                                                                                     {
  xk[m_stgDir] = m_stgVbStart[m_stgDir] + generate_rand() * (m_stgVbEnd[m_stgDir] - m_stgVbStart[m_stgDir]);
  xk[m_periodicDir] =
      m_stgVbStart[m_periodicDir] + generate_rand() * (m_stgVbEnd[m_periodicDir] - m_stgVbStart[m_periodicDir]);
  xk[m_wallDir] =
      m_stgVbStart[m_wallDir] + generate_rand_weighted() * (m_stgVbEnd[m_wallDir] - m_stgVbStart[m_wallDir]);
 
  if(m_isotropicTurbulence) {
    xk[m_wallDir] = m_stgVbStart[m_wallDir] + generate_rand() * (m_stgVbEnd[m_wallDir] - m_stgVbStart[m_wallDir]);
  }
 
  if(m_cylinderTransformation) {
    xk[m_wallDir] = m_stgVbStart[m_wallDir] + generate_rand() * (m_stgVbEnd[m_wallDir] - m_stgVbStart[m_wallDir]);
  }
 
  if(m_freeStreamTurbulence) {
    if(generate_rand() < m_BLEddieFraction) {
      // generate new eddie in BL
      xk[m_wallDir] = m_stgVbStart[m_wallDir] + generate_rand_weighted() * (m_stgWallEnd - m_stgVbStart[m_wallDir]);
    } else {
      // generate new eddie in FS
      xk[m_wallDir] = m_stgWallEnd + generate_rand() * (m_stgVbEnd[m_wallDir] - m_stgWallEnd);
    }
  }
 
  epsi[m_stgDir] = 2.0 * generate_rand() - 1.0;
  epsi[m_stgDir] = epsi[m_stgDir] / std::max(std::abs(epsi[m_stgDir]), eps);
  epsi[m_wallDir] = 2.0 * generate_rand() - 1.0;
  epsi[m_wallDir] = epsi[m_wallDir] / std::max(std::abs(epsi[m_wallDir]), eps);
  epsi[m_periodicDir] = 2.0 * generate_rand() - 1.0;
  epsi[m_periodicDir] = epsi[m_periodicDir] / std::max(std::abs(epsi[m_periodicDir]), eps);
}

get_angle()

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MFloat MSTG< nDim, SolverTypeR, SolverTypeL >::get_angle ( MFloat  y, MFloat  z  )

private

Definition at line 109 of file fvstg.cpp.

                                                                         {
  MFloat angle = atan(z / y);
  if(y < 0) {
    if(z >= 0) {
      angle += PI;
    } else {
      angle -= PI;
    }
  }
  return angle;
}

getBoundaryLayerThickness() [1/2]

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

template<class _ , std::enable_if_t< SolverTypeL==MAIA_STRUCTURED, _ * > >

void MSTG< nDim, SolverTypeR, SolverTypeL >::getBoundaryLayerThickness

private

Definition at line 846 of file fvstg.cpp.

                                                                     {
  TRACE();
 
  std::stringstream errorMsg;
  std::string prop_name;
  errorMsg << ": This property is not allowed to exist without an assignment to a BC" << std::endl;
 
  m_stgDelta99Inflow = -1.0;
 
  MInt factor = (m_stgWallNormalDir % 2 == 0) ? -1 : 1;
 
  if(!m_zonal) {
    prop_name = "bc" + std::to_string(m_bcId) + "deltaIn";
    if(!Context::propertyExists(prop_name, m_solverId)) {
      mTerm(1, AT_, "deltaIn" + errorMsg.str());
    }
    m_stgDelta99Inflow = Context::getSolverProperty<MFloat>(prop_name, m_solverId, AT_, &m_stgDelta99Inflow);
  } else {
    MFloat maxVel = F0;
    MFloat maxVelPos = std::numeric_limits<MFloat>::max();
    MFloat minPos = std::numeric_limits<MFloat>::max();
    MFloat maxPos = std::numeric_limits<MFloat>::lowest();
    MFloat halfCellLength = F0;
    for(typename Accessor::nDim_citerator it = a->iterateB1(); it != a->iterateB1_nDim_citerator_end(); ++it) {
      const MInt IBC = a->getStgId(it);
      const MInt cellId = a->getCellId(it);
      MFloat y = LES->a_coordinate(cellId, m_wallDir);
      MFloat z = LES->a_coordinate(cellId, m_periodicDir);
      MFloat r = sqrt(y * y + z * z);
      if(m_stgLVariables[m_stgDir][IBC] >= maxVel) {
        maxVel = m_stgLVariables[m_stgDir][IBC];
        if(m_cylinderTransformation) {
          maxVelPos = r;
        } else {
          maxVelPos = m_solver->a_coordinate(cellId, m_wallDir);
        }
      }
      if(m_cylinderTransformation) {
        if(r < minPos) {
          minPos = r;
        }
        if(r > maxPos) {
          maxPos = r;
        }
      } else {
        if(m_solver->a_coordinate(cellId, m_wallDir) < minPos) {
          minPos = m_solver->a_coordinate(cellId, m_wallDir);
          halfCellLength = m_solver->grid().halfCellLength(cellId);
        }
        if(m_solver->a_coordinate(cellId, m_wallDir) > maxPos) {
          maxPos = m_solver->a_coordinate(cellId, m_wallDir);
        }
      }
    }
 
    MPI_Allreduce(MPI_IN_PLACE, &maxVel, 1, MPI_DOUBLE, MPI_MAX, m_commStg, AT_, "maxVel", "1");
    MPI_Allreduce(MPI_IN_PLACE, &maxVelPos, 1, MPI_DOUBLE, MPI_MIN, m_commStg, AT_, "maxVelPos", "1");
    MPI_Allreduce(MPI_IN_PLACE, &minPos, 1, MPI_DOUBLE, MPI_MIN, m_commStg, AT_, "minPos", "1");
    MPI_Allreduce(MPI_IN_PLACE, &maxPos, 1, MPI_DOUBLE, MPI_MAX, m_commStg, AT_, "maxPos", "1");
 
    if(maxVel < 0.9 * m_solver->m_UInfinity) {
      m_initialRange = true;
      m_stgDelta99Inflow = 2 * halfCellLength;
    }
 
    if(!m_initialRange) {
      MFloat delta0 = std::numeric_limits<MFloat>::max();
      MFloat delta0_1 = minPos;
      MFloat delta0_2 = maxPos;
      MFloat delta0_u1 = std::numeric_limits<MFloat>::max();
      MFloat delta0_u2 = std::numeric_limits<MFloat>::lowest();
      for(typename Accessor::nDim_citerator it = a->iterateB1(); it != a->iterateB1_nDim_citerator_end(); ++it) {
        const MInt cellId = a->getCellId(it);
        const MInt IBC = a->getStgId(it);
        MFloat pos = m_solver->a_coordinate(cellId, m_wallDir);
        if(m_cylinderTransformation) {
          MFloat y = LES->a_coordinate(cellId, m_wallDir);
          MFloat z = LES->a_coordinate(cellId, m_periodicDir);
          pos = sqrt(y * y + z * z);
        }
 
        if(m_solver->a_isHalo(cellId)) continue;
 
        if(factor * m_stgLVariables[m_stgDir][IBC] > factor * 0.99 * maxVel && pos < delta0_2 && pos < maxVelPos) {
          delta0_2 = pos;
          delta0_u2 = m_stgLVariables[m_stgDir][IBC];
        }
 
        if(factor * m_stgLVariables[m_stgDir][IBC] < factor * 0.99 * maxVel && pos > delta0_1 && pos < maxVelPos) {
          delta0_1 = pos;
          delta0_u1 = m_stgLVariables[m_stgDir][IBC];
        }
      }
 
      MFloat deltaOffset = (factor == 1) ? minPos : maxPos;
      delta0 =
          factor
          * (delta0_1 + (delta0_2 - delta0_1) / (delta0_u2 - delta0_u1) * (0.99 * maxVel - delta0_u1) - deltaOffset);
 
      if(delta0 < 1e-16) delta0 = std::numeric_limits<MFloat>::max();
 
      MPI_Allreduce(&delta0, &m_stgDelta99Inflow, 1, MPI_DOUBLE, MPI_MIN, m_commStg, AT_, "m_stgDelta99Inflow",
                    "delta0");
    }
  }
 
#ifndef NDEBUG
  if(m_stgMyRank == m_commStgRoot) {
    std::cerr << "---------- Boundary layer thickness (" << globalTimeStep << "," << m_bcId << "): ----------"
              << std::endl;
    std::cerr << m_stgDelta99Inflow << std::endl;
  }
#endif
}

getBoundaryLayerThickness() [2/2]

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

template<class _ = void, std::enable_if_t< SolverTypeL==MAIA_FINITE_VOLUME, _ * > = nullptr>

void MSTG< nDim, SolverTypeR, SolverTypeL >::getBoundaryLayerThickness ( )

private

getCellSize() [1/2]

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

template<class _ , std::enable_if_t< SolverTypeL==MAIA_STRUCTURED, _ * > >

MFloat MSTG< nDim, SolverTypeR, SolverTypeL >::getCellSize ( typename Accessor::nDim_citerator  it )

private

Definition at line 1895 of file fvstg.cpp.

                                                                                           {
  return m_solver->a_cellVolume(a->getCellId(it));
}

getCellSize() [2/2]

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

template<class _ = void, std::enable_if_t< SolverTypeL==MAIA_FINITE_VOLUME, _ * > = nullptr>

MFloat MSTG< nDim, SolverTypeR, SolverTypeL >::getCellSize ( typename Accessor::nDim_citerator  it )

private

getInflowStartEnd() [1/2]

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

template<class _ , std::enable_if_t< SolverTypeL==MAIA_STRUCTURED, _ * > >

void MSTG< nDim, SolverTypeR, SolverTypeL >::getInflowStartEnd ( MFloat *  inflowStart, MFloat *  inflowEnd  )

private

Definition at line 1000 of file fvstg.cpp.

                                                                                                   {
  TRACE();
 
  MFloat inflowStartLocal[] = {std::numeric_limits<MFloat>::max(), std::numeric_limits<MFloat>::max(),
                               std::numeric_limits<MFloat>::max()};
  MFloat inflowEndlocal[] = {-std::numeric_limits<MFloat>::max(), -std::numeric_limits<MFloat>::max(),
                             -std::numeric_limits<MFloat>::max()};
  for(typename Accessor::nDim_citerator it = a->iterateB1(); it != a->iterateB1_nDim_citerator_end(); ++it) {
    MInt cellId = a->getCellId(it);
    if(m_solver->a_isHalo(cellId)) continue;
 
    if(m_cylinderTransformation) {
      MFloat y = LES->a_coordinate(cellId, m_wallDir);
      MFloat z = LES->a_coordinate(cellId, m_periodicDir);
      MFloat alpha = get_angle(y, z);
      MFloat r = sqrt(y * y + z * z);
      if(inflowStartLocal[0] > LES->a_coordinate(cellId, 0)) inflowStartLocal[0] = LES->a_coordinate(cellId, 0);
      if(inflowEndlocal[0] < LES->a_coordinate(cellId, 0)) inflowEndlocal[0] = LES->a_coordinate(cellId, 0);
      if(inflowStartLocal[1] > r) inflowStartLocal[1] = r;
      if(inflowEndlocal[1] < r) inflowEndlocal[1] = r;
      if(inflowStartLocal[2] > alpha) inflowStartLocal[2] = alpha;
      if(inflowEndlocal[2] < alpha) inflowEndlocal[2] = alpha;
 
    } else {
      for(MInt d = 0; d < nDim; ++d) {
        if(inflowStartLocal[d] > LES->a_coordinate(cellId, d)) inflowStartLocal[d] = LES->a_coordinate(cellId, d);
        if(inflowEndlocal[d] < LES->a_coordinate(cellId, d)) inflowEndlocal[d] = LES->a_coordinate(cellId, d);
      }
    }
  }
 
  std::fill(inflowStart, inflowStart + nDim, 9999999);
  std::fill(inflowEnd, inflowEnd + nDim, -9999999);
  MPI_Allreduce(inflowStartLocal, inflowStart, nDim, MPI_DOUBLE, MPI_MIN, m_commStg, AT_, "inflowStartLocal",
                "inflowStart");
  MPI_Allreduce(inflowEndlocal, inflowEnd, nDim, MPI_DOUBLE, MPI_MAX, m_commStg, AT_, "inflowEndlocal", "inflowEnd");
 
  if(m_stgWallNormalDir % 2 == 0) {
    MFloat temp = inflowStart[m_wallDir];
    inflowStart[m_wallDir] = inflowEnd[m_wallDir];
    inflowEnd[m_wallDir] = temp;
  }
 
#ifndef NDEBUG
  if(m_stgMyRank == m_commStgRoot) {
    std::cerr << "inflowStartEnd(" << m_bcId << "): " << inflowStart[0] << " " << inflowStart[1] << " "
              << inflowStart[2] << " " << inflowEnd[0] << " " << inflowEnd[1] << " " << inflowEnd[2] << std::endl;
  }
#endif
}

getInflowStartEnd() [2/2]

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

template<class _ = void, std::enable_if_t< SolverTypeL==MAIA_FINITE_VOLUME, _ * > = nullptr>

void MSTG< nDim, SolverTypeR, SolverTypeL >::getInflowStartEnd ( MFloat *  , MFloat *    )

private

init()

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

void MSTG< nDim, SolverTypeR, SolverTypeL >::init

(

MInt

commStgRoot

)

Synthetic Turbulence Generation

Definition at line 505 of file fvstg.cpp.

                                                                {
  TRACE();
 
  MPI_Comm_rank(m_commStg, &m_stgMyRank);
  m_commStgRoot = commStgRoot;
 
  mAlloc(m_stgMaxVel, m_nDim, "m_stgMaxVel", 0.0, AT_);
  mAlloc(m_stgVbStart, m_nDim, "m_stgVbStart", 0.0, AT_);
  mAlloc(m_stgVbEnd, m_nDim, "m_stgVbEnd", 0.0, AT_);
 
#ifndef NDEBUG
  if(m_stgMyRank == m_commStgRoot) {
    std::cout << globalTimeStep << " Initializing BC " + std::to_string(m_bcId) << std::endl;
  }
#endif
 
  readRANSProfileStg();
 
  if(m_solver->m_resetInitialCondition) {
    m_stgDelta99Inflow = 0.0;
    m_initialRange = true;
  } else {
    getBoundaryLayerThickness();
  }
 
  // Compute size of the Box, take inflow as middle x-coordinate
  mAlloc(m_inflowStart, m_nDim, "m_inflowStart", AT_);
  mAlloc(m_inflowEnd, m_nDim, "m_inflowEnd", AT_);
  getInflowStartEnd(m_inflowStart, m_inflowEnd);
  setVb(m_inflowStart, m_inflowEnd);
 
  if(m_newStgMethod) {
    // determinePeriodicCells();
  }
 
  // TODO: check if this is the right place
  if((globalTimeStep == m_solver->m_restartTimeStep && globalTimeStep > m_solver->m_stgStartTimeStep
      && !m_stgCreateNewEddies)
     || (m_solver->m_wasAdapted) || (m_solver->m_wasBalancedZonal)) {
    loadStg();
  } else {
    // // create new eddies if it's an initial start or the createNewEddie flag is set
    MFloatScratchSpace bcast_eddies(m_stgMaxNoEddies * 6, AT_, "bcast_eddies");
    MFloatScratchSpace bcast_eddyStrength(m_stgMaxNoEddies, AT_, "bcast_eddyStrength");
 
    if(m_stgMyRank == m_commStgRoot) {
#ifndef NDEBUG
      std::cerr << "-------Creating new Eddies inside Virtual Box------" << std::endl;
#endif
      MFloat xk[m_nDim];
      MFloat epsi[m_nDim];
      for(MInt n = 0; n < m_stgMaxNoEddies; n++) {
        generateNewEddies(xk, epsi);
 
        bcast_eddies[n + m_stgMaxNoEddies * 0] = xk[0];
        bcast_eddies[n + m_stgMaxNoEddies * 1] = xk[1];
        bcast_eddies[n + m_stgMaxNoEddies * 2] = xk[2];
        bcast_eddies[n + m_stgMaxNoEddies * 3] = epsi[0];
        bcast_eddies[n + m_stgMaxNoEddies * 4] = epsi[1];
        bcast_eddies[n + m_stgMaxNoEddies * 5] = epsi[2];
 
        bcast_eddyStrength[n] = F1;
        if(m_newStgMethod) {
          bcast_eddyStrength[n] = generate_rand_normalDist();
        }
      }
    }
 
    // Broadcast the new/updated eddies to all relevant processes
    MPI_Bcast(bcast_eddies.begin(), 6 * m_stgMaxNoEddies, MPI_DOUBLE, m_commStgRoot, m_commStg, AT_,
              "bcast_eddies.begin()");
    MPI_Bcast(bcast_eddyStrength.begin(), m_stgMaxNoEddies, MPI_DOUBLE, m_commStgRoot, m_commStg, AT_,
              "bcast_eddyStrength.begin()");
    // Copy data into m_FQeddie vector
    for(MInt n = 0; n < m_stgMaxNoEddies; n++) {
      m_stgEddies[n][0] = bcast_eddies[n + m_stgMaxNoEddies * 0];
      m_stgEddies[n][1] = bcast_eddies[n + m_stgMaxNoEddies * 1];
      m_stgEddies[n][2] = bcast_eddies[n + m_stgMaxNoEddies * 2];
      m_stgEddies[n][3] = bcast_eddies[n + m_stgMaxNoEddies * 3];
      m_stgEddies[n][4] = bcast_eddies[n + m_stgMaxNoEddies * 4];
      m_stgEddies[n][5] = bcast_eddies[n + m_stgMaxNoEddies * 5];
 
      m_stgEddyStrength[n] = bcast_eddyStrength[n];
    }
  }
}

loadStg() [1/2]

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

void MSTG< nDim, SolverTypeR, SolverTypeL >::loadStg

protected

Definition at line 740 of file fvstg.cpp.

                                                   {
  TRACE();
 
  using namespace maia::parallel_io;
  std::stringstream filename;
  filename << m_solver->restartDir() << "stg" << std::to_string(m_bcId) << "RestartNew_" << globalTimeStep
           << ParallelIo::fileExt();
 
  m_log << "Loading restart file " << filename.str() << " ..." << std::endl;
#ifndef NDEBUG
  if(m_stgMyRank == m_commStgRoot) {
    cerr << "Loading restart file " << filename.str() << " ..." << std::endl;
  }
#endif
 
  std::stringstream stgPrefix_;
  stgPrefix_ << "stgVar" << m_bcId << "_";
  MString stgPrefix = stgPrefix_.str();
 
  // All stg ranks read m_stgMaxNoEddies & m_stgEddies
  {
    ParallelIo parallelIo((filename.str()).c_str(), PIO_READ, m_commStg);
    MInt stgMaxNoEddies;
    parallelIo.getAttribute(&stgMaxNoEddies, (stgPrefix + "stgMaxNoEddies").c_str());
    if(stgMaxNoEddies != m_stgMaxNoEddies && !m_stgCreateNewEddies)
      TERMM(-1, "bc" + std::to_string(m_bcId) + ": Number of eddies has changed!");
    ParallelIo::size_type stgEddies_ = parallelIo.getArraySize((stgPrefix + "FQeddies").c_str());
    if(stgEddies_ != stgMaxNoEddies * m_stgNoEddieProperties) TERMM(-1, "");
    ParallelIo::size_type stgEddyStrength_ = parallelIo.getArraySize((stgPrefix + "FQeddyStrength").c_str());
    if(stgEddyStrength_ != stgMaxNoEddies) TERMM(-1, "");
 
    parallelIo.setOffset(stgEddies_, 0);
    parallelIo.readArray(&(m_stgEddies[0][0]), (stgPrefix + "FQeddies").c_str()); // TODO: check this
 
    parallelIo.setOffset(stgEddyStrength_, 0);
    parallelIo.readArray(&(m_stgEddyStrength[0]), (stgPrefix + "FQeddyStrength").c_str()); // TODO: check this
  }
}

loadStg() [2/2]

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

void MSTG< nDim, SolverTypeR, SolverTypeL >::loadStg ( SolverTraits< nDim, MAIA_FINITE_VOLUME > *  )

private

printSTGSummary()

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

void MSTG< nDim, SolverTypeR, SolverTypeL >::printSTGSummary

private

Definition at line 2029 of file fvstg.cpp.

                                                           {
  const MFloat BLT3 = std::abs(m_stgVbEnd[m_periodicDir] - m_stgVbStart[m_periodicDir]);
  const MFloat Vb = m_stgBLT2 * BLT3 * m_stgBLT1 * POW2(m_stgDelta99Inflow);
 
  // Summary of synth turb parameters
  if(m_stgMyRank == m_commStgRoot && globalTimeStep == m_solver->m_restartTimeStep) {
    std::cout << "**************************" << std::endl
              << "Synthetic turbulence (bcId=" << m_bcId << "):" << std::endl
              << "zones: 1" << std::endl
              << "Dir: " << m_stgFaceNormalDir << " / " << m_stgWallNormalDir << " / " << m_stgDir << " / " << m_wallDir
              << std::endl
              << "nr. eddies: " << m_stgMaxNoEddies << std::endl
              << "conv. vel: " << sqrt(POW2(m_stgMaxVel[0]) + POW2(m_stgMaxVel[1]) + POW2(m_stgMaxVel[2])) << std::endl
              << "umax = " << m_stgMaxVel[0] << std::endl
              << "vmax = " << m_stgMaxVel[1] << std::endl
              << "wmax = " << m_stgMaxVel[2] << std::endl
              << "virtual box volume: " << Vb << std::endl
              << "Vb/stgMaxNoEddies = " << Vb / m_stgMaxNoEddies << std::endl
              << "**************************" << std::endl;
  }
}

randomEddyPosGenerator()

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

std::mt19937_64 & MSTG< nDim, SolverTypeR, SolverTypeL >::randomEddyPosGenerator ( )

inline

Definition at line 801 of file fvstg.h.

{ return m_PRNGEddy; }

readRANSProfileStg() [1/2]

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

template<class _ , std::enable_if_t< SolverTypeR==MAIA_STRUCTURED, _ * > , std::enable_if_t< SolverTypeL==MAIA_FINITE_VOLUME, _ * > >

void MSTG< nDim, SolverTypeR, SolverTypeL >::readRANSProfileStg

private

write RANSValues from solver to stgLVariables (fully coupled zonal) /author Sutharsan

Definition at line 1140 of file fvstg.cpp.

                                                              {
  TRACE();
 
  if(m_zonal && !m_preliminary) {
    for(typename Accessor::nDim_citerator it = a->iterateB1(); it != a->iterateB1_nDim_citerator_end(); ++it) {
      const MInt IBC = a->getStgId(it);
      const MInt cellId = a->m_stgToCellId[IBC];
 
      // Debugging
      for(MInt varId = 0; varId < (MInt)m_solver->m_noRANSVariables; varId++) {
        ASSERT(cellId < (MInt)m_solver->m_RANSValues[varId].size(),
               "Trying to access data [" + std::to_string(cellId) + "] in RANSValues with length "
                   + std::to_string(m_solver->m_RANSValues[varId].size())
                   + ", domainId: " + std::to_string(m_solver->domainId()));
      }
 
      m_stgLVariables[STG::AVG_RHO][IBC] = m_solver->m_RANSValues[PV->RHO][cellId];
      m_stgLVariables[STG::AVG_U][IBC] = m_solver->m_RANSValues[PV->U][cellId];
      m_stgLVariables[STG::AVG_V][IBC] = m_solver->m_RANSValues[PV->V][cellId];
      m_stgLVariables[STG::AVG_W][IBC] = m_solver->m_RANSValues[PV->W][cellId];
      m_stgLVariables[STG::AVG_P][IBC] = m_solver->m_RANSValues[PV->P][cellId];
      // JANNIK: generalize this for other RANS models
      m_stgLVariables[STG::NU_T][IBC] = m_solver->m_RANSValues[PV->N][cellId];
 
      for(MInt d = 0; d < m_nDim; d++) {
        m_stgLVariables[STG::AVG_UU[d]][IBC] = m_solver->m_RANSValues[PV->VV[d]][cellId];
      }
 
      // reconstruct fluc values since not saved anymore
      // (for timsm function in calcTotalFluctuationCholesky)
      if(globalTimeStep == m_solver->m_restartTimeStep) {
        m_stgLVariables[STG::FLUC_U][IBC] =
            m_solver->a_pvariable(cellId, PV->U) - m_solver->m_RANSValues[PV->U][cellId];
        m_stgLVariables[STG::FLUC_V][IBC] =
            m_solver->a_pvariable(cellId, PV->V) - m_solver->m_RANSValues[PV->V][cellId];
        m_stgLVariables[STG::FLUC_W][IBC] =
            m_solver->a_pvariable(cellId, PV->W) - m_solver->m_RANSValues[PV->W][cellId];
      }
    }
  } else {
    // read in text-file with
    if(m_preliminaryRans2D) {
      stringstream fn;
      fn.clear();
      MString prop_name = "bc" + std::to_string(m_bcId);
      fn << prop_name << "preliminaryDataRans2D.txt";
      MString fname = fn.str();
      if(m_stgMyRank == m_commStgRoot) cerr << "loading STG preliminary data from " << fname << "...";
 
      ifstream preliminaryData;
      preliminaryData.open(fname);
 
      vector<MFloat> data;
      MFloat num;
      string line;
 
      while(preliminaryData >> num) {
        data.push_back(num);
      }
 
      // MInt count = 0;
      prop_name = "bc" + std::to_string(m_bcId) + "preliminaryRansDataCount";
      MInt preliminaryDataVarCount =
          Context::getSolverProperty<MInt>(prop_name, m_solverId, AT_, &preliminaryDataVarCount);
 
      MInt dataCount = data.size() / preliminaryDataVarCount;
 
      vector<vector<MFloat>> preData(dataCount, vector<MFloat>(preliminaryDataVarCount, 0));
 
      MInt index = 0;
      for(MInt d = 0; d < dataCount; d++) {
        for(MInt dd = 0; dd < preliminaryDataVarCount; dd++) {
          index = preliminaryDataVarCount * d + dd;
          preData[d][dd] = data[index];
        }
      }
 
      preliminaryData.close();
 
      for(typename Accessor::nDim_citerator it = a->iterateB1(); it != a->iterateB1_nDim_citerator_end(); ++it) {
        const MInt IBC = a->getStgId(it);
        const MInt cellId = a->m_stgToCellId[IBC];
        MFloat pos = m_solver->a_coordinate(cellId, m_wallDir);
        // interpolate data
        for(MInt d = 0; d < dataCount - 1; d++) {
          if(pos >= preData[d][0] && pos < preData[d + 1][0]) {
            MInt var = 1;
            m_stgLVariables[STG::AVG_U][IBC] =
                preData[d][var]
                + (preData[d + 1][var] - preData[d][var]) * (pos - preData[d][0]) / (preData[d + 1][0] - preData[d][0]);
            var = 2;
            m_stgLVariables[STG::AVG_V][IBC] =
                preData[d][var]
                + (preData[d + 1][var] - preData[d][var]) * (pos - preData[d][0]) / (preData[d + 1][0] - preData[d][0]);
            var = 3;
            m_stgLVariables[STG::AVG_RHO][IBC] =
                preData[d][var]
                + (preData[d + 1][var] - preData[d][var]) * (pos - preData[d][0]) / (preData[d + 1][0] - preData[d][0]);
            var = 4;
            m_stgLVariables[STG::AVG_P][IBC] =
                preData[d][var]
                + (preData[d + 1][var] - preData[d][var]) * (pos - preData[d][0]) / (preData[d + 1][0] - preData[d][0]);
            var = 5;
            m_stgLVariables[STG::NU_T][IBC] =
                preData[d][var]
                + (preData[d + 1][var] - preData[d][var]) * (pos - preData[d][0]) / (preData[d + 1][0] - preData[d][0]);
            var = 6;
            m_stgLVariables[STG::S11][IBC] =
                preData[d][var]
                + (preData[d + 1][var] - preData[d][var]) * (pos - preData[d][0]) / (preData[d + 1][0] - preData[d][0]);
            var = 7;
            m_stgLVariables[STG::S12][IBC] =
                preData[d][var]
                + (preData[d + 1][var] - preData[d][var]) * (pos - preData[d][0]) / (preData[d + 1][0] - preData[d][0]);
            var = 8;
            m_stgLVariables[STG::S22][IBC] =
                preData[d][var]
                + (preData[d + 1][var] - preData[d][var]) * (pos - preData[d][0]) / (preData[d + 1][0] - preData[d][0]);
            var = 9;
            m_stgLVariables[STG::SIJSIJ][IBC] =
                preData[d][var]
                + (preData[d + 1][var] - preData[d][var]) * (pos - preData[d][0]) / (preData[d + 1][0] - preData[d][0]);
            m_stgLVariables[STG::AVG_W][IBC] = F0;
            m_stgLVariables[STG::S13][IBC] = F0;
            m_stgLVariables[STG::S23][IBC] = F0;
            m_stgLVariables[STG::S33][IBC] = F0;
          }
        }
      }
    }
 
    if(m_preliminary && !m_preliminaryRans2D) {
      stringstream fn;
      fn.clear();
      MString prop_name = "bc" + std::to_string(m_bcId);
      fn << prop_name << "preliminaryData.txt";
 
      MString fname = fn.str();
 
      if(m_stgMyRank == m_commStgRoot) cerr << "loading STG preliminary data from " << fname << "...";
 
      ifstream preliminaryData;
      preliminaryData.open(fname);
 
      vector<MFloat> data;
      MFloat num;
 
      while(preliminaryData >> num) {
        data.push_back(num);
      }
 
      // MInt count = 0;
      MInt preliminaryDataVarCount = 1 + m_solver->noVariables() + 8; // y + primVars + rms + p'p' + SijSij
      MInt dataCount = data.size() / preliminaryDataVarCount;
 
      vector<vector<MFloat>> preData(dataCount, vector<MFloat>(preliminaryDataVarCount, 0));
 
      MInt index = 0;
      for(MInt d = 0; d < dataCount; d++) {
        for(MInt dd = 0; dd < preliminaryDataVarCount; dd++) {
          index = preliminaryDataVarCount * d + dd;
          preData[d][dd] = data[index];
        }
      }
 
      preliminaryData.close();
 
      if(m_stgMyRank == m_commStgRoot) cerr << "ok" << endl;
 
      for(typename Accessor::nDim_citerator it = a->iterateB1(); it != a->iterateB1_nDim_citerator_end(); ++it) {
        const MInt IBC = a->getStgId(it);
        const MInt cellId = a->m_stgToCellId[IBC];
 
        MFloat pos = m_solver->a_coordinate(cellId, m_wallDir);
        if(m_cylinderTransformation) {
          MFloat y = m_solver->a_coordinate(cellId, m_wallDir);
          MFloat z = m_solver->a_coordinate(cellId, m_periodicDir);
          pos = sqrt(y * y + z * z);
        }
 
        for(MInt d = 0; d < dataCount; d++) {
          if(abs(pos - preData[d][0]) / pos < 0.001) {
            // no interpolation needed
            for(MInt var = 0; var < nDim + 2; var++) {
              m_stgLVariables[var][IBC] = preData[d][var + 1];
              if(var < nDim) {
                m_stgLVariables[STG::AVG_UU[var]][IBC] = m_stgLVariables[var][IBC];
              }
            }
            MInt v = 6;
            for(MInt fluc = STG::FLUC_UU; fluc < STG::FLUC_WW + 1; fluc++) {
              m_stgLVariables[fluc][IBC] = preData[d][v];
              v++;
            }
            MInt index_ = preliminaryDataVarCount - 1;
            m_stgLVariables[STG::SIJSIJ][IBC] = preData[d][index_];
          } else {
            if(d == dataCount - 1) continue; // this is necessary for interpolation
            // interpolation
            if(pos >= preData[d][0] && pos < preData[d + 1][0]) {
              for(MInt var = 0; var < nDim + 2; var++) {
                m_stgLVariables[var][IBC] = preData[d][var + 1]
                                            + (preData[d + 1][var + 1] - preData[d][var + 1]) * (pos - preData[d][0])
                                                  / (preData[d + 1][0] - preData[d][0]);
 
                if(var < nDim) {
                  m_stgLVariables[STG::AVG_UU[var]][IBC] = m_stgLVariables[var][IBC];
                }
              }
              MInt v = 6;
              for(MInt fluc = STG::FLUC_UU; fluc < STG::FLUC_WW + 1; fluc++) {
                m_stgLVariables[fluc][IBC] =
                    preData[d][v]
                    + (preData[d + 1][v] - preData[d][v]) * (pos - preData[d][0]) / (preData[d + 1][0] - preData[d][0]);
 
                v++;
              }
 
              MInt index_ = preliminaryDataVarCount - 1;
              m_stgLVariables[STG::SIJSIJ][IBC] = preData[d][index_]
                                                  + (preData[d + 1][index_] - preData[d][index_])
                                                        * (pos - preData[d][0]) / (preData[d + 1][0] - preData[d][0]);
            }
          }
        }
      }
    }
  }
}

readRANSProfileStg() [2/2]

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

template<class _ = void, std::enable_if_t< SolverTypeR==MAIA_FINITE_VOLUME, _ * > = nullptr, std::enable_if_t< SolverTypeL==MAIA_FINITE_VOLUME, _ * > = nullptr>

void MSTG< nDim, SolverTypeR, SolverTypeL >::readRANSProfileStg ( )

private

saveStg()

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

void MSTG< nDim, SolverTypeR, SolverTypeL >::saveStg

protected

Definition at line 704 of file fvstg.cpp.

                                                   {
  TRACE();
 
  using namespace maia::parallel_io;
  std::stringstream filename;
  filename << m_solver->outputDir() << "stg" << std::to_string(m_bcId) << "RestartNew_" << globalTimeStep
           << ParallelIo::fileExt();
 
  m_log << "Writing restart file " << filename.str() << " ..." << std::endl;
#ifndef NDEBUG
  if(m_stgMyRank == m_commStgRoot) {
    cerr << "Writing restart file " << filename.str() << " ..." << std::endl;
  }
#endif
 
  std::stringstream stgPrefix_;
  stgPrefix_ << "stgVar" << m_bcId << "_";
  MString stgPrefix = stgPrefix_.str();
 
  ParallelIo parallelIo((filename.str()).c_str(), PIO_REPLACE, m_commStg);
  parallelIo.setAttributes(&(m_stgMaxNoEddies), (stgPrefix + "stgMaxNoEddies").c_str(), 1);
 
  parallelIo.defineArray(PIO_FLOAT, (stgPrefix + "FQeddies").c_str(), m_stgMaxNoEddies * m_stgNoEddieProperties);
 
  parallelIo.defineArray(PIO_FLOAT, (stgPrefix + "FQeddyStrength").c_str(), m_stgMaxNoEddies);
 
  parallelIo.setAttribute("FQeddies", "name", (stgPrefix + "FQeddies").c_str());
  parallelIo.setOffset(m_stgMaxNoEddies * m_stgNoEddieProperties, 0);
  parallelIo.writeArray(&(m_stgEddies[0][0]), (stgPrefix + "FQeddies").c_str());
 
  parallelIo.setAttribute("FQeddyStrength", "name", (stgPrefix + "FQeddyStrength").c_str());
  parallelIo.setOffset(m_stgMaxNoEddies, 0);
  parallelIo.writeArray(&(m_stgEddyStrength[0]), (stgPrefix + "FQeddyStrength").c_str());
}

setSTGProperties()

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

void MSTG< nDim, SolverTypeR, SolverTypeL >::setSTGProperties ( )

private

setVb()

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

void MSTG< nDim, SolverTypeR, SolverTypeL >::setVb ( MFloat *  inflowStart, MFloat *  inflowEnd  )

private

Definition at line 1071 of file fvstg.cpp.

                                                                                       {
  MFloatScratchSpace bcast_vb(6, AT_, "bcast_vb");
 
 
  const MFloat vbDepth = (inflowEnd[m_periodicDir] - inflowStart[m_periodicDir]) * m_stgBLT3;
  const MFloat offset = F1B2 * (inflowEnd[m_periodicDir] - inflowStart[m_periodicDir]) * (m_stgBLT3 - F1);
 
  if(m_stgMyRank == m_commStgRoot) {
    m_stgRootRank = true;
 
    // Get the coordinate of the inflow
    // Points in stgDir
    MInt factor = (m_stgFaceNormalDir % 2 == 0) ? 1 : -1;
    bcast_vb[m_stgDir] = inflowStart[m_stgDir] - factor * m_stgBLT1 * m_stgDelta99Inflow * F1B2;
    bcast_vb[m_stgDir + 3] = inflowStart[m_stgDir] + factor * m_stgBLT1 * m_stgDelta99Inflow * F1B2;
 
    // Points in wallDir
    factor = (m_stgWallNormalDir % 2 != 0) ? 1 : -1;
    bcast_vb[m_wallDir] = inflowStart[m_wallDir];
    bcast_vb[m_wallDir + 3] = inflowStart[m_wallDir] + factor * m_stgBLT2 * m_stgDelta99Inflow;
 
    if(m_freeStreamTurbulence) {
      m_stgWallEnd = inflowStart[m_wallDir] + factor * m_stgBLT2 * m_stgDelta99Inflow;
      bcast_vb[m_wallDir + 3] = inflowEnd[m_wallDir];
    }
 
    if(m_isotropicTurbulence) {
      m_stgWallEnd = inflowStart[m_wallDir];
      bcast_vb[m_wallDir + 3] = inflowEnd[m_wallDir];
    }
 
    // Points in periodicDir
    bcast_vb[m_periodicDir] = inflowStart[m_periodicDir] - offset;
    bcast_vb[m_periodicDir + 3] = inflowStart[m_periodicDir] - offset + vbDepth;
  }
 
  MPI_Bcast(bcast_vb.begin(), 6, MPI_DOUBLE, m_commStgRoot, m_commStg, AT_, "bcast_vb.begin()");
 
  if(m_freeStreamTurbulence) {
    MPI_Bcast(&m_stgWallEnd, 1, MPI_DOUBLE, m_commStgRoot, m_commStg, AT_, "m_stgWallEnd");
  }
 
  m_stgVbStart[0] = bcast_vb[0];
  m_stgVbStart[1] = bcast_vb[1];
  m_stgVbStart[2] = bcast_vb[2];
  m_stgVbEnd[0] = bcast_vb[3];
  m_stgVbEnd[1] = bcast_vb[4];
  m_stgVbEnd[2] = bcast_vb[5];
 
#ifndef NDEBUG
  if(m_stgMyRank == m_commStgRoot) {
    std::cout << "setVbStart(" << m_bcId << "): " << m_stgVbStart[0] << " " << m_stgVbStart[1] << " " << m_stgVbStart[2]
              << std::endl;
    std::cout << "setVbEnd(" << m_bcId << "): " << m_stgVbEnd[0] << " " << m_stgVbEnd[1] << " " << m_stgVbEnd[2]
              << std::endl;
    if(m_freeStreamTurbulence) {
      std::cout << "setVbEndFS(" << m_bcId << "): " << m_stgWallEnd << endl;
    }
  }
#endif
}

solver()

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

SolverTypeL_ * MSTG< nDim, SolverTypeR, SolverTypeL >::solver ( ) const

inlineprivate

Definition at line 685 of file fvstg.h.

{ return m_solver; }

Friends And Related Function Documentation

FvBndryCndXD< nDim, FvSysEqnNS< nDim > >

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

friend class FvBndryCndXD< nDim, FvSysEqnNS< nDim > >

friend

Definition at line 616 of file fvstg.h.

saveStg

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

void saveStg ( std::map< MInt, self * >  , SolverTypeL_ *    )

friend

Member Data Documentation

a

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

Accessor* MSTG< nDim, SolverTypeR, SolverTypeL >::a

private

Definition at line 792 of file fvstg.h.

a1

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

const MFloat MSTG< nDim, SolverTypeR, SolverTypeL >::a1 = 1 / sqrt(c_mu)

private

Definition at line 787 of file fvstg.h.

aniso

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

const MFloat MSTG< nDim, SolverTypeR, SolverTypeL >::aniso = 1.0

private

Definition at line 790 of file fvstg.h.

c_mu

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

const MFloat MSTG< nDim, SolverTypeR, SolverTypeL >::c_mu = 0.09

private

Definition at line 786 of file fvstg.h.

eps

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

const MFloat MSTG< nDim, SolverTypeR, SolverTypeL >::eps = 1e-16

private

Definition at line 782 of file fvstg.h.

epsl

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

const MFloat MSTG< nDim, SolverTypeR, SolverTypeL >::epsl = 1e-13

private

Definition at line 783 of file fvstg.h.

epss

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

const MFloat MSTG< nDim, SolverTypeR, SolverTypeL >::epss = 1e-34

private

Definition at line 781 of file fvstg.h.

LES

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

Accessor* MSTG< nDim, SolverTypeR, SolverTypeL >::LES = a

private

Definition at line 793 of file fvstg.h.

m_bcId

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

const MInt MSTG< nDim, SolverTypeR, SolverTypeL >::m_bcId

private

Definition at line 703 of file fvstg.h.

m_BLEddieFraction

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MFloat MSTG< nDim, SolverTypeR, SolverTypeL >::m_BLEddieFraction

private

Definition at line 761 of file fvstg.h.

m_commStg

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MPI_Comm MSTG< nDim, SolverTypeR, SolverTypeL >::m_commStg

private

Definition at line 718 of file fvstg.h.

m_commStgMyRank

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MInt MSTG< nDim, SolverTypeR, SolverTypeL >::m_commStgMyRank

private

Definition at line 720 of file fvstg.h.

m_commStgRoot

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MInt MSTG< nDim, SolverTypeR, SolverTypeL >::m_commStgRoot

private

Definition at line 719 of file fvstg.h.

m_cutOff

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MBool MSTG< nDim, SolverTypeR, SolverTypeL >::m_cutOff

private

Definition at line 778 of file fvstg.h.

m_cylinderTransformation

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MBool MSTG< nDim, SolverTypeR, SolverTypeL >::m_cylinderTransformation = false

private

Definition at line 776 of file fvstg.h.

m_freeStreamTurbulence

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MBool MSTG< nDim, SolverTypeR, SolverTypeL >::m_freeStreamTurbulence = false

private

Definition at line 756 of file fvstg.h.

m_inflowEnd

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MFloat* MSTG< nDim, SolverTypeR, SolverTypeL >::m_inflowEnd = nullptr

private

Definition at line 714 of file fvstg.h.

m_inflowStart

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MFloat* MSTG< nDim, SolverTypeR, SolverTypeL >::m_inflowStart = nullptr

private

Definition at line 713 of file fvstg.h.

m_initialRange

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MBool MSTG< nDim, SolverTypeR, SolverTypeL >::m_initialRange = false

private

Definition at line 716 of file fvstg.h.

m_isotropicTurbulence

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MBool MSTG< nDim, SolverTypeR, SolverTypeL >::m_isotropicTurbulence = false

private

Definition at line 763 of file fvstg.h.

m_maxStreamwiseLengthscale

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MFloat MSTG< nDim, SolverTypeR, SolverTypeL >::m_maxStreamwiseLengthscale

private

Definition at line 767 of file fvstg.h.

m_nDim

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

constexpr const MInt MSTG< nDim, SolverTypeR, SolverTypeL >::m_nDim = nDim

staticconstexprprivate

Definition at line 700 of file fvstg.h.

m_newStgMethod

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MBool MSTG< nDim, SolverTypeR, SolverTypeL >::m_newStgMethod = false

private

Definition at line 766 of file fvstg.h.

m_noStgLCells

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MInt MSTG< nDim, SolverTypeR, SolverTypeL >::m_noStgLCells

private

Definition at line 733 of file fvstg.h.

m_periodicDir

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MInt MSTG< nDim, SolverTypeR, SolverTypeL >::m_periodicDir = 2

private

Definition at line 744 of file fvstg.h.

m_preliminary

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MBool MSTG< nDim, SolverTypeR, SolverTypeL >::m_preliminary = false

private

Definition at line 764 of file fvstg.h.

m_preliminaryRans2D

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MBool MSTG< nDim, SolverTypeR, SolverTypeL >::m_preliminaryRans2D = false

private

Definition at line 765 of file fvstg.h.

m_PRNGEddy

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

std::mt19937_64 MSTG< nDim, SolverTypeR, SolverTypeL >::m_PRNGEddy

Definition at line 799 of file fvstg.h.

m_randomEddySeed

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MInt MSTG< nDim, SolverTypeR, SolverTypeL >::m_randomEddySeed

Definition at line 800 of file fvstg.h.

m_SijSijFS

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MFloat MSTG< nDim, SolverTypeR, SolverTypeL >::m_SijSijFS

private

Definition at line 760 of file fvstg.h.

m_solver

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

SolverTypeL_* MSTG< nDim, SolverTypeR, SolverTypeL >::m_solver

private

Definition at line 701 of file fvstg.h.

m_solverId

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MInt MSTG< nDim, SolverTypeR, SolverTypeL >::m_solverId

private

Definition at line 702 of file fvstg.h.

m_stgBLT1

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MFloat MSTG< nDim, SolverTypeR, SolverTypeL >::m_stgBLT1

private

Definition at line 722 of file fvstg.h.

m_stgBLT2

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MFloat MSTG< nDim, SolverTypeR, SolverTypeL >::m_stgBLT2

private

Definition at line 723 of file fvstg.h.

m_stgBLT3

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MFloat MSTG< nDim, SolverTypeR, SolverTypeL >::m_stgBLT3

private

Definition at line 724 of file fvstg.h.

m_stgCreateNewEddies

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MBool MSTG< nDim, SolverTypeR, SolverTypeL >::m_stgCreateNewEddies

private

Definition at line 735 of file fvstg.h.

m_stgDelta99Inflow

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MFloat MSTG< nDim, SolverTypeR, SolverTypeL >::m_stgDelta99Inflow

private

Definition at line 725 of file fvstg.h.

m_stgDir

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MInt MSTG< nDim, SolverTypeR, SolverTypeL >::m_stgDir = 0

private

Definition at line 742 of file fvstg.h.

m_stgEddieCoverage

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MFloat** MSTG< nDim, SolverTypeR, SolverTypeL >::m_stgEddieCoverage = nullptr

private

Definition at line 768 of file fvstg.h.

m_stgEddieDistribution

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MFloat MSTG< nDim, SolverTypeR, SolverTypeL >::m_stgEddieDistribution

private

Definition at line 732 of file fvstg.h.

m_stgEddieLengthScales

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MBool MSTG< nDim, SolverTypeR, SolverTypeL >::m_stgEddieLengthScales = false

private

Definition at line 737 of file fvstg.h.

m_stgEddies

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MFloat** MSTG< nDim, SolverTypeR, SolverTypeL >::m_stgEddies = nullptr

private

Definition at line 728 of file fvstg.h.

m_stgEddyStrength

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MFloat* MSTG< nDim, SolverTypeR, SolverTypeL >::m_stgEddyStrength = nullptr

private

Definition at line 729 of file fvstg.h.

m_stgExple

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MFloat MSTG< nDim, SolverTypeR, SolverTypeL >::m_stgExple

private

Definition at line 731 of file fvstg.h.

m_stgFaceNormalDir

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MInt MSTG< nDim, SolverTypeR, SolverTypeL >::m_stgFaceNormalDir

private

Definition at line 740 of file fvstg.h.

m_stgGlobalNoPeriodicLocations

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MInt* MSTG< nDim, SolverTypeR, SolverTypeL >::m_stgGlobalNoPeriodicLocations = nullptr

private

Definition at line 773 of file fvstg.h.

m_stgGlobalNoWallNormalLocations

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MInt MSTG< nDim, SolverTypeR, SolverTypeL >::m_stgGlobalNoWallNormalLocations = F0

private

Definition at line 772 of file fvstg.h.

m_stgGlobalWallNormalLocations

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

std::vector<MFloat> MSTG< nDim, SolverTypeR, SolverTypeL >::m_stgGlobalWallNormalLocations

private

Definition at line 771 of file fvstg.h.

m_stgInitialStartup

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MBool MSTG< nDim, SolverTypeR, SolverTypeL >::m_stgInitialStartup

private

Definition at line 726 of file fvstg.h.

m_stgLengthFactors

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MFloat* MSTG< nDim, SolverTypeR, SolverTypeL >::m_stgLengthFactors = nullptr

private

Definition at line 745 of file fvstg.h.

m_stgLocal

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MBool MSTG< nDim, SolverTypeR, SolverTypeL >::m_stgLocal = false

private

Definition at line 734 of file fvstg.h.

m_stgLVariables

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MFloat** MSTG< nDim, SolverTypeR, SolverTypeL >::m_stgLVariables = nullptr

private

Definition at line 753 of file fvstg.h.

m_stgMaxNoEddies

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MInt MSTG< nDim, SolverTypeR, SolverTypeL >::m_stgMaxNoEddies

private

Definition at line 730 of file fvstg.h.

m_stgMaxVel

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MFloat* MSTG< nDim, SolverTypeR, SolverTypeL >::m_stgMaxVel = nullptr

private

Definition at line 752 of file fvstg.h.

m_stgMyRank

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MInt MSTG< nDim, SolverTypeR, SolverTypeL >::m_stgMyRank

private

Definition at line 747 of file fvstg.h.

m_stgNoEddieProperties

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MInt MSTG< nDim, SolverTypeR, SolverTypeL >::m_stgNoEddieProperties

private

Definition at line 727 of file fvstg.h.

m_stgPeriodicCellId

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

std::vector<MInt>* MSTG< nDim, SolverTypeR, SolverTypeL >::m_stgPeriodicCellId = nullptr

private

Definition at line 769 of file fvstg.h.

m_stgPeriodicIndex

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MInt* MSTG< nDim, SolverTypeR, SolverTypeL >::m_stgPeriodicIndex = nullptr

private

Definition at line 774 of file fvstg.h.

m_stgRootRank

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MBool MSTG< nDim, SolverTypeR, SolverTypeL >::m_stgRootRank

private

Definition at line 721 of file fvstg.h.

m_stgRSTFactors

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MFloat* MSTG< nDim, SolverTypeR, SolverTypeL >::m_stgRSTFactors = nullptr

private

Definition at line 746 of file fvstg.h.

m_stgShapeFunction

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MInt MSTG< nDim, SolverTypeR, SolverTypeL >::m_stgShapeFunction

private

Definition at line 736 of file fvstg.h.

m_stgSubSup

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MBool MSTG< nDim, SolverTypeR, SolverTypeL >::m_stgSubSup

private

Definition at line 738 of file fvstg.h.

m_stgSupersonic

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MBool MSTG< nDim, SolverTypeR, SolverTypeL >::m_stgSupersonic

private

Definition at line 739 of file fvstg.h.

m_stgVbEnd

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MFloat* MSTG< nDim, SolverTypeR, SolverTypeL >::m_stgVbEnd = nullptr

private

Definition at line 749 of file fvstg.h.

m_stgVbStart

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MFloat* MSTG< nDim, SolverTypeR, SolverTypeL >::m_stgVbStart = nullptr

private

Definition at line 748 of file fvstg.h.

m_stgVbStartFS

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MFloat* MSTG< nDim, SolverTypeR, SolverTypeL >::m_stgVbStartFS = nullptr

private

Definition at line 750 of file fvstg.h.

m_stgWallEnd

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MFloat MSTG< nDim, SolverTypeR, SolverTypeL >::m_stgWallEnd

private

Definition at line 751 of file fvstg.h.

m_stgWallNormalDir

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MInt MSTG< nDim, SolverTypeR, SolverTypeL >::m_stgWallNormalDir = 1

private

Definition at line 741 of file fvstg.h.

m_stgWallNormalLocations

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

std::vector<MFloat> MSTG< nDim, SolverTypeR, SolverTypeL >::m_stgWallNormalLocations

private

Definition at line 770 of file fvstg.h.

m_sutherlandConstant

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MFloat MSTG< nDim, SolverTypeR, SolverTypeL >::m_sutherlandConstant

private

Definition at line 708 of file fvstg.h.

m_sutherlandPlusOne

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MFloat MSTG< nDim, SolverTypeR, SolverTypeL >::m_sutherlandPlusOne

private

Definition at line 709 of file fvstg.h.

m_uuFS

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MFloat MSTG< nDim, SolverTypeR, SolverTypeL >::m_uuFS

private

Definition at line 757 of file fvstg.h.

m_vvFS

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MFloat MSTG< nDim, SolverTypeR, SolverTypeL >::m_vvFS

private

Definition at line 758 of file fvstg.h.

m_wallDir

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MInt MSTG< nDim, SolverTypeR, SolverTypeL >::m_wallDir = 1

private

Definition at line 743 of file fvstg.h.

m_wwFS

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MFloat MSTG< nDim, SolverTypeR, SolverTypeL >::m_wwFS

private

Definition at line 759 of file fvstg.h.

m_zonal

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

MBool MSTG< nDim, SolverTypeR, SolverTypeL >::m_zonal

private

Definition at line 711 of file fvstg.h.

PV

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

FvSysEqnRANS<nDim,RANSModelConstants<RANS_SA_DV>>::PrimitiveVariables* MSTG< nDim, SolverTypeR, SolverTypeL >::PV

private

Definition at line 706 of file fvstg.h.

timsm

template<MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

const MFloat MSTG< nDim, SolverTypeR, SolverTypeL >::timsm = 0.3

private

Definition at line 789 of file fvstg.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/fvcartesianbndrycndxd.h
• /home/gitlab-runner/scratch/builds/oxpnswJ6/1/aia/m-AIA/m-AIA/src/FV/fvstg.h
• /home/gitlab-runner/scratch/builds/oxpnswJ6/1/aia/m-AIA/m-AIA/src/FV/fvstg.cpp