FvZonalRTV< nDim, SysEqn > Class Template Reference

#include <fvzonalrtv.h>

Inheritance diagram for FvZonalRTV< nDim, SysEqn >:

Collaboration diagram for FvZonalRTV< nDim, SysEqn >:

Classes
struct	LESVarAverageData

Public Types
using	RANS = FvCartesianSolverXD< nDim, SysEqn >
using	LES = FvCartesianSolverXD< nDim, FvSysEqnNS< nDim > >
using	Base = FvZonal< nDim, SysEqn >
Public Types inherited from FvZonal< nDim, SysEqn >
using	RANS = FvCartesianSolverXD< nDim, SysEqn >
using	LES = FvCartesianSolverXD< nDim, FvSysEqnNS< nDim > >
Public Types inherited from CouplingFv< nDim, SysEqn >
using	solverType = FvCartesianSolverXD< nDim, SysEqn >
Public Types inherited from CouplingFv< nDim, FvSysEqnNS< nDim > >
using	solverType = FvCartesianSolverXD< nDim, FvSysEqnNS< nDim > >

Public Member Functions
	FvZonalRTV (const MInt couplingId, RANS *R, LES *L)
void	init ()
void	finalizeCouplerInit ()
void	preCouple (MInt)
void	postAdaptation ()
MInt	a_noFvCellsLES () const
MInt	a_noFvCellsRANS () const
MInt	a_noFvGridCellsLES () const
MInt	a_noFvGridCellsRANS () const
MFloat	getAveragingFactor ()
void	initLESValues ()
	Initialize LESValues for RANS Solver. More...
void	initRANSValues ()
	Initialize RANSValues for LES Solver. More...
LES &	LESSolver () const
MInt	noExchangeVariables ()
MInt	noLESVariables ()
MInt	noRANSVariables ()
RANS &	RANSSolver () const
Public Member Functions inherited from FvZonal< nDim, SysEqn >
	FvZonal (const MInt couplingId, RANS *R, LES *L)
virtual	~FvZonal ()=default
void	init () override
void	finalizeSubCoupleInit (MInt)
void	postCouple (MInt) override
void	cleanUp ()
void	checkProperties () override
Public Member Functions inherited from CouplingFv< nDim, SysEqn >
	CouplingFv (const MInt couplingId, std::vector< FvCartesianSolverXD< nDim, SysEqn > * > fvSolvers, const MInt noSolvers)
	CouplingFv (const MInt couplingId, Solver *solvers)
	~CouplingFv () override=default
	CouplingFv (const CouplingFv &)=delete
CouplingFv &	operator= (const CouplingFv &)=delete
Public Member Functions inherited from Coupling
	Coupling (const MInt couplingId)
virtual	~Coupling ()=default
	Coupling (const Coupling &)=delete
Coupling &	operator= (const Coupling &)=delete
MInt	couplerId () const
virtual void	init ()=0
virtual void	finalizeSubCoupleInit (MInt solverId)=0
virtual void	finalizeCouplerInit ()=0
virtual void	preCouple (MInt recipeStep)=0
virtual void	subCouple (MInt recipeStep, MInt solverId, std::vector< MBool > &solverCompleted)=0
virtual void	postCouple (MInt recipeStep)=0
virtual void	cleanUp ()=0
virtual void	balancePre ()
	Load balancing. More...
virtual void	balancePost ()
virtual void	reinitAfterBalance ()
virtual void	prepareAdaptation ()
virtual void	postAdaptation ()
virtual void	finalizeAdaptation (const MInt)
virtual void	writeRestartFile (const MInt)
virtual MInt	noCellDataDlb () const
	Methods to inquire coupler data during balancing. More...
virtual MInt	cellDataTypeDlb (const MInt NotUsed(dataId)) const
virtual MInt	cellDataSizeDlb (const MInt NotUsed(dataId), const MInt NotUsed(cellId))
virtual void	getCellDataDlb (const MInt NotUsed(dataId), const MInt NotUsed(oldNoCells), const MInt *const NotUsed(bufferIdToCellId), MInt *const NotUsed(data))
virtual void	getCellDataDlb (const MInt NotUsed(dataId), const MInt NotUsed(oldNoCells), const MInt *const NotUsed(bufferIdToCellId), MLong *const NotUsed(data))
virtual void	getCellDataDlb (const MInt NotUsed(dataId), const MInt NotUsed(oldNoCells), const MInt *const NotUsed(bufferIdToCellId), MFloat *const NotUsed(data))
virtual void	setCellDataDlb (const MInt NotUsed(dataId), const MInt *const NotUsed(data))
virtual void	setCellDataDlb (const MInt NotUsed(dataId), const MLong *const NotUsed(data))
virtual void	setCellDataDlb (const MInt NotUsed(dataId), const MFloat *const NotUsed(data))
virtual void	finalizeBalance (const MInt)
virtual MInt	noCouplingTimers (const MBool NotUsed(allTimings)) const
	Number of coupling timers. More...
virtual void	getCouplingTimings (std::vector< std::pair< MString, MFloat > > &NotUsed(timings), const MBool NotUsed(allTimings))
	Return coupling timings. More...
virtual void	getDomainDecompositionInformation (std::vector< std::pair< MString, MInt > > &NotUsed(domainInfo))
	Return information on current domain decomposition (e.g. number of coupled cells/elements/...) More...
void	setDlbTimer (const MInt timerId)
void	startLoadTimer (const MString &name) const
	Start the load timer of the coupler. More...
void	stopLoadTimer (const MString &name) const
	Stop the load timer of the coupler. More...
Public Member Functions inherited from CouplingFv< nDim, FvSysEqnNS< nDim > >
	CouplingFv (const MInt couplingId, std::vector< FvCartesianSolverXD< nDim, FvSysEqnNS< nDim > > * > fvSolvers, const MInt noSolvers)
	CouplingFv (const MInt couplingId, Solver *solvers)
	CouplingFv (const CouplingFv &)=delete
	~CouplingFv () override=default
CouplingFv &	operator= (const CouplingFv &)=delete

Public Attributes
MInt	m_LESNoVarAverage
MInt	m_LESSolverId
const MInt	m_noReconstructNutVars
MInt	m_RANSSolverId
MBool	m_restartLESAverage
MInt	m_zonalAveragingTimeStep
MInt	m_zonalTransferInterval

Private Member Functions
void	postCouple (MInt)
void	finalizeSubCoupleInit (MInt)
void	finalizeAdaptation (const MInt)
void	prepareAdaptation ()
void	subCouple (MInt, MInt, std::vector< MBool > &)
void	cleanUp ()
void	initData ()
void	checkProperties ()
void	readProperties ()
void	determineNutReconstructionCells ()
void	determineZonalPositions ()
void	reconstructNutilde ()
void	transferSolverData ()
void	finalizeRANSSolverAfterReset ()
void	reconstructAverageFromNut ()

Private Attributes
MInt	m_rntStartTimeStep
MBool	m_reconstructNut = false
MBool	m_reconstructAverageFromNut = false
MFloat	m_nuTildeInfinity
MInt	m_averageTimeSteps
MFloat	m_turbulentIntensity
MFloat	m_tuLengthScaleCorrection
std::vector< MInt >	m_rntBcCells
MInt	m_noRntBcCells
MInt	m_bcId7902
MFloat	m_7902Position
MInt	m_7902faceNormalDir
MInt	m_7902wallDir
MInt	m_7902periodicDir
MFloat	m_averagePos
MInt	m_averageDir
MInt	m_averageFaceDir
const MFloat	eps = 1e-16
const MFloat	epss = 1e-8

Friends
class	FvZonal< nDim, SysEqn >

Additional Inherited Members
Protected Member Functions inherited from FvZonal< nDim, SysEqn >
RANS &	RANSSolver () const
LES &	LESSolver () const
MInt	noExchangeVariables ()
MInt	noLESVariables ()
MInt	noRANSVariables ()
MFloat	getAveragingFactor ()
MInt	a_noFvCellsLES () const
MInt	a_noFvGridCellsLES () const
MInt	a_noFvCellsRANS () const
MInt	a_noFvGridCellsRANS () const
void	initRANSValues ()
	Initialize RANSValues for LES Solver. More...
void	initLESValues ()
	Initialize LESValues for RANS Solver. More...
Protected Member Functions inherited from CouplingFv< nDim, SysEqn >
MInt	noSolvers () const
solverType &	fvSolver (const MInt solverId=0) const
MInt	a_noFvCells () const
MInt	a_noFvGridCells () const
Protected Member Functions inherited from Coupling
MFloat	returnLoadRecord () const
MFloat	returnIdleRecord () const
Protected Member Functions inherited from CouplingFv< nDim, FvSysEqnNS< nDim > >
MInt	noSolvers () const
solverType &	fvSolver (const MInt solverId=0) const
MInt	a_noFvCells () const
MInt	a_noFvGridCells () const
Protected Attributes inherited from FvZonal< nDim, SysEqn >
MInt	m_RANSSolverId
MInt	m_LESSolverId
const MInt	m_noReconstructNutVars = 6
MInt	m_zonalAveragingTimeStep
MInt	m_zonalTransferInterval
MInt	m_averageTimeSteps
MBool	m_restartLESAverage
MInt	m_LESNoVarAverage
MBool	m_cylindricCommunication
MFloat	m_azimuthalAngle
MBool	m_STGSponge = false
Protected Attributes inherited from CouplingFv< nDim, SysEqn >
std::vector< solverType * >	m_fvSolvers {}
Protected Attributes inherited from CouplingFv< nDim, FvSysEqnNS< nDim > >
std::vector< solverType * >	m_fvSolvers

Detailed Description

template<MInt nDim, class SysEqn>
class FvZonalRTV< nDim, SysEqn >

Definition at line 27 of file fvzonalrtv.h.

Member Typedef Documentation

Base

template<MInt nDim, class SysEqn >

using FvZonalRTV< nDim, SysEqn >::Base = FvZonal<nDim, SysEqn>

Definition at line 38 of file fvzonalrtv.h.

LES

template<MInt nDim, class SysEqn >

using FvZonalRTV< nDim, SysEqn >::LES = FvCartesianSolverXD<nDim, FvSysEqnNS<nDim> >

Definition at line 33 of file fvzonalrtv.h.

RANS

template<MInt nDim, class SysEqn >

using FvZonalRTV< nDim, SysEqn >::RANS = FvCartesianSolverXD<nDim, SysEqn>

Definition at line 32 of file fvzonalrtv.h.

Constructor & Destructor Documentation

FvZonalRTV()

template<MInt nDim, class SysEqn >

FvZonalRTV< nDim, SysEqn >::FvZonalRTV	(	const MInt	couplingId,
		RANS *	R,
		LES *	L
	)

Member Function Documentation

a_noFvCellsLES()

template<MInt nDim, class SysEqn >

MInt FvZonal< nDim, SysEqn >::a_noFvCellsLES ( ) const

inline

Definition at line 54 of file fvzonal.h.

{ return LESSolver().a_noCells(); }

a_noFvCellsRANS()

template<MInt nDim, class SysEqn >

MInt FvZonal< nDim, SysEqn >::a_noFvCellsRANS ( ) const

inline

Definition at line 56 of file fvzonal.h.

{ return RANSSolver().a_noCells(); }

a_noFvGridCellsLES()

template<MInt nDim, class SysEqn >

MInt FvZonal< nDim, SysEqn >::a_noFvGridCellsLES ( ) const

inline

Definition at line 55 of file fvzonal.h.

{ return LESSolver().c_noCells(); }

a_noFvGridCellsRANS()

template<MInt nDim, class SysEqn >

MInt FvZonal< nDim, SysEqn >::a_noFvGridCellsRANS ( ) const

inline

Definition at line 57 of file fvzonal.h.

{ return RANSSolver().c_noCells(); }

checkProperties()

template<MInt nDim, class SysEqn >

void FvZonalRTV< nDim, SysEqn >::checkProperties ( )

inlineprivatevirtual

Reimplemented from FvZonal< nDim, SysEqn >.

Definition at line 73 of file fvzonalrtv.h.

{};

cleanUp()

template<MInt nDim, class SysEqn >

void FvZonalRTV< nDim, SysEqn >::cleanUp ( )

inlineprivatevirtual

Reimplemented from FvZonal< nDim, SysEqn >.

Definition at line 71 of file fvzonalrtv.h.

{};

determineNutReconstructionCells()

template<MInt nDim, class SysEqn >

void FvZonalRTV< nDim, SysEqn >::determineNutReconstructionCells

private

Definition at line 213 of file fvzonalrtv.cpp.

                                                               {
  TRACE();
 
  if(LESSolver().grid().isActive()) {
    m_noRntBcCells = 0;
    for(MInt LESId = 0; LESId < a_noFvGridCellsLES(); LESId++) {
      if(LESSolver().a_isHalo(LESId)) continue;
 
      MFloat halfCellLength = LESSolver().grid().halfCellLength(LESId);
      MFloat pos = LESSolver().a_coordinate(LESId, m_averageDir);
 
      if(approx(m_averagePos, pos, halfCellLength)) {
        m_rntBcCells.push_back(LESId);
        m_noRntBcCells++;
      }
    }
  }
}

determineZonalPositions()

template<MInt nDim, class SysEqn >

void FvZonalRTV< nDim, SysEqn >::determineZonalPositions

private

Definition at line 109 of file fvzonalrtv.cpp.

                                                       {
  TRACE();
 
  m_7902faceNormalDir = -1;
  m_7902Position = std::numeric_limits<MFloat>::infinity();
 
  // read cutoff positions to determine average and sponge cells
  if(Context::propertyExists("cutOffBndryIds")) {
    MInt propertyLength = Context::propertyLength("cutOffBndryIds", m_RANSSolverId);
    for(MInt i = 0; i < propertyLength; i++) {
      MInt bcId = Context::getSolverProperty<MFloat>("cutOffBndryIds", m_RANSSolverId, AT_, i);
      if(bcId == 7902 || bcId == 7905) {
        m_7902faceNormalDir = Context::getSolverProperty<MFloat>("cutOffDirections", m_RANSSolverId, AT_, i);
      }
    }
  }
  if(m_7902faceNormalDir != -1) {
    m_7902faceNormalDir = (m_7902faceNormalDir % 2 == 0) ? m_7902faceNormalDir + 1 : m_7902faceNormalDir - 1;
  }
 
  m_bcId7902 = -1;
  m_7902wallDir = 1;
  m_7902periodicDir = 2;
 
  if(Context::propertyExists("bc7902wallDir")) {
    m_7902wallDir = Context::getSolverProperty<MInt>("bc7902wallDir", m_RANSSolverId, AT_);
  }
  if(Context::propertyExists("bc7902periodicDir")) {
    m_7902periodicDir = Context::getSolverProperty<MInt>("bc7902periodicDir", m_RANSSolverId, AT_);
  }
 
  for(MInt bcId = 0; bcId < RANSSolver().m_fvBndryCnd->m_noCutOffBndryCndIds; bcId++) {
    if(RANSSolver().m_fvBndryCnd->m_cutOffBndryCndIds[bcId] == 7902) {
      m_bcId7902 = bcId;
    }
  }
 
 
  // determine real m_7909Position based on cell centers
  MFloat tmpPos7902 = ((m_7902faceNormalDir + 1) % 2 > 0) ? -std::numeric_limits<MFloat>::infinity()
                                                          : std::numeric_limits<MFloat>::infinity();
  MFloat compFactor7902 = ((m_7902faceNormalDir + 1) % 2 > 0) ? F1 : -F1;
 
  if(LESSolver().grid().isActive()) {
    for(MInt cellId = 0; cellId < a_noFvGridCellsLES(); cellId++) {
      MInt RANSId = convertIdParent(LESSolver(), RANSSolver(), cellId);
      if(RANSId != -1) {
        MFloat pos = LESSolver().a_coordinate(cellId, 0);
        if(compFactor7902 * pos > compFactor7902 * tmpPos7902) {
          tmpPos7902 = pos;
        }
      }
    }
 
    if(compFactor7902 > 0) {
      MPI_Allreduce(MPI_IN_PLACE, &tmpPos7902, 1, MPI_DOUBLE, MPI_MAX, LESSolver().mpiComm(), AT_, "MPI_IN_PLACE",
                    "tmpPos7902");
    } else {
      MPI_Allreduce(MPI_IN_PLACE, &tmpPos7902, 1, MPI_DOUBLE, MPI_MIN, LESSolver().mpiComm(), AT_, "MPI_IN_PLACE",
                    "tmpPos7902");
    }
    m_7902Position = tmpPos7902;
  }
 
  if(RANSSolver().grid().isActive()) {
    if(compFactor7902 > 0) {
      MPI_Allreduce(MPI_IN_PLACE, &tmpPos7902, 1, MPI_DOUBLE, MPI_MAX, RANSSolver().mpiComm(), AT_, "MPI_IN_PLACE",
                    "tmpPos7902");
    } else {
      MPI_Allreduce(MPI_IN_PLACE, &tmpPos7902, 1, MPI_DOUBLE, MPI_MIN, RANSSolver().mpiComm(), AT_, "MPI_IN_PLACE",
                    "tmpPos7902");
    }
 
    if(m_7902faceNormalDir != -1) {
      m_7902Position = tmpPos7902;
    }
  }
 
  m_averagePos = m_7902Position;
  m_averageDir = abs(m_7902wallDir + m_7902periodicDir - nDim);
  m_averageFaceDir = m_7902faceNormalDir;
 
  LESSolver().m_averagePos.push_back(m_averagePos);
  LESSolver().m_averageDir.push_back(m_averageDir);
  LESSolver().m_averageReconstructNut.push_back(m_reconstructNut);
}

finalizeAdaptation()

template<MInt nDim, class SysEqn >

void FvZonalRTV< nDim, SysEqn >::finalizeAdaptation ( const  MInt )

inlineprivatevirtual

Reimplemented from Coupling.

Definition at line 68 of file fvzonalrtv.h.

{};

finalizeCouplerInit()

template<MInt nDim, class SysEqn >

void FvZonalRTV< nDim, SysEqn >::finalizeCouplerInit

virtual

Implements Coupling.

Definition at line 198 of file fvzonalrtv.cpp.

                                                   {
  TRACE();
 
  // finalizeLESAverage();
  determineNutReconstructionCells();
 
  if(globalTimeStep > m_rntStartTimeStep) {
    reconstructNutilde();
  }
 
  transferSolverData();
}

finalizeRANSSolverAfterReset()

template<MInt nDim, class SysEqn >

void FvZonalRTV< nDim, SysEqn >::finalizeRANSSolverAfterReset ( )

private

finalizeSubCoupleInit()

template<MInt nDim, class SysEqn >

void FvZonalRTV< nDim, SysEqn >::finalizeSubCoupleInit ( MInt  )

inlineprivatevirtual

Reimplemented from FvZonal< nDim, SysEqn >.

Definition at line 67 of file fvzonalrtv.h.

{};

getAveragingFactor()

template<MInt nDim, class SysEqn >

MFloat FvZonal< nDim, SysEqn >::getAveragingFactor ( )

inline

Definition at line 50 of file fvzonal.h.

                              {
    return F1B8 * LESSolver().m_Ma * sqrt(LESSolver().m_TInfinity) * LESSolver().timeStep();
  };

init()

template<MInt nDim, class SysEqn >

void FvZonalRTV< nDim, SysEqn >::init

virtual

Reimplemented from FvZonal< nDim, SysEqn >.

Definition at line 93 of file fvzonalrtv.cpp.

                                    {
  TRACE();
 
  m_RANSSolverId = RANSSolver().m_solverId;
  m_LESSolverId = LESSolver().m_solverId;
 
  LESSolver().m_LESNoVarAverage = LESVarAverageData::noAvgVars;
 
  initRANSValues();
  initLESValues();
 
  determineZonalPositions();
}

initData()

template<MInt nDim, class SysEqn >

void FvZonalRTV< nDim, SysEqn >::initData ( )

inlineprivate

Definition at line 72 of file fvzonalrtv.h.

{};

initLESValues()

template<MInt nDim, class SysEqn >

void FvZonal< nDim, SysEqn >::initLESValues

Author

Jannik Borgelt

Definition at line 60 of file fvzonal.cpp.

                                          {
  TRACE();
 
  // write RANS data to LES Solver
  if(RANSSolver().grid().isActive()) {
    for(MInt var = 0; var < noRANSVariables(); var++) {
      for(MInt cellId = 0; cellId < a_noFvGridCellsRANS(); cellId++) {
        MInt LESId = convertIdParent(RANSSolver(), LESSolver(), cellId);
 
        ASSERT(cellId < (MInt)RANSSolver().m_LESValues[var].size(),
               "Trying to access data [" + to_string(var) + "][" + to_string(cellId) + "] in m_RANSValues with length "
                   + to_string(RANSSolver().m_LESValues[var].size())
                   + ", domainId: " + to_string(RANSSolver().domainId()));
 
        if(LESId != -1) {
          RANSSolver().m_LESValues[var][cellId] = LESSolver().a_pvariable(LESId, var);
          // init nu_t
          if(var == RANSSolver().sysEqn().PV->N) {
            RANSSolver().m_LESValues[var][cellId] = RANSSolver().a_pvariable(cellId, var);
          }
        }
      }
    }
  }
}

initRANSValues()

template<MInt nDim, class SysEqn >

void FvZonal< nDim, SysEqn >::initRANSValues

Author

Jannik Borgelt

Definition at line 59 of file fvzonal.cpp.

                                           {
  TRACE();
 
  // write RANS data to LES Solver
  if(LESSolver().grid().isActive()) {
    for(MInt cellId = 0; cellId < a_noFvGridCellsLES(); cellId++) {
      MInt RANSId = convertIdParent(LESSolver(), RANSSolver(), cellId);
      if(RANSId > -1) {
        for(MInt var = 0; var < noRANSVariables(); var++) {
          ASSERT(cellId < (MInt)LESSolver().m_RANSValues[var].size(),
                 "Trying to access data [" + to_string(var) + "][" + to_string(cellId)
                     + "] in m_RANSValues with length " + to_string(LESSolver().m_RANSValues[var].size())
                     + ", domainId: " + to_string(LESSolver().domainId()));
 
          LESSolver().m_RANSValues[var][cellId] = RANSSolver().a_pvariable(RANSId, var);
        }
      } else {
        for(MInt var = 0; var < noRANSVariables(); var++) {
          if(m_cylindricCommunication) {
            if(var < noLESVariables()) {
              LESSolver().m_RANSValues[var][cellId] = LESSolver().a_pvariable(cellId, var);
            } else {
              LESSolver().m_RANSValues[var][cellId] = F0;
            }
          }
        }
      }
      if(m_STGSponge) {
        LESSolver().m_RANSValues[noRANSVariables()][cellId] = F0;
      }
    }
  }
}

LESSolver()

template<MInt nDim, class SysEqn >

LES & FvZonal< nDim, SysEqn >::LESSolver ( ) const

inline

Definition at line 45 of file fvzonal.h.

{ return *CouplingFv<nDim, FvSysEqnNS<nDim>>::m_fvSolvers[0]; }

noExchangeVariables()

template<MInt nDim, class SysEqn >

MInt FvZonal< nDim, SysEqn >::noExchangeVariables ( )

inline

Definition at line 47 of file fvzonal.h.

{ return nDim + 2; };

noLESVariables()

template<MInt nDim, class SysEqn >

MInt FvZonal< nDim, SysEqn >::noLESVariables ( )

inline

Definition at line 48 of file fvzonal.h.

{ return LESSolver().noVariables(); };

noRANSVariables()

template<MInt nDim, class SysEqn >

MInt FvZonal< nDim, SysEqn >::noRANSVariables ( )

inline

Definition at line 49 of file fvzonal.h.

{ return RANSSolver().noVariables(); };

postAdaptation()

template<MInt nDim, class SysEqn >

void FvZonalRTV< nDim, SysEqn >::postAdaptation

virtual

Reimplemented from Coupling.

Definition at line 234 of file fvzonalrtv.cpp.

                                              {
  TRACE();
 
  if(LESSolver().grid().isActive()) {
    // copy local vectors
    std::vector<MFloat> LESAverageCells_OLD_L;
    std::vector<std::vector<MFloat>> LESVarAverage_OLD;
    std::vector<MInt> rntBcCells_OLD;
    std::vector<MInt> LESAverageCells_OLD;
 
    for(MInt c = 0; c < (MInt)LESSolver().m_LESAverageCells.size(); c++) {
      LESAverageCells_OLD_L.push_back(LESSolver().m_LESAverageCells[c]);
    }
 
    for(MInt cc = 0; cc < m_noRntBcCells; cc++) {
      rntBcCells_OLD.push_back(m_rntBcCells[cc]);
    }
  }
 
  if(globalTimeStep > m_rntStartTimeStep) {
    reconstructNutilde();
  }
 
  transferSolverData();
}

postCouple()

template<MInt nDim, class SysEqn >

void FvZonalRTV< nDim, SysEqn >::postCouple ( MInt  )

inlineprivatevirtual

Reimplemented from FvZonal< nDim, SysEqn >.

Definition at line 66 of file fvzonalrtv.h.

{};

preCouple()

template<MInt nDim, class SysEqn >

void FvZonalRTV< nDim, SysEqn >::preCouple ( MInt  )

virtual

Implements Coupling.

Definition at line 262 of file fvzonalrtv.cpp.

                                               {
  TRACE();
 
  if(LESSolver().grid().isActive()) {
    if(LESSolver().noNeighborDomains() > 0) {
      LESSolver().exchangeData(&LESSolver().a_variable(0, 0), noLESVariables());
      LESSolver().exchangeData(&LESSolver().a_oldVariable(0, 0), noLESVariables());
      LESSolver().exchangeData(&LESSolver().a_pvariable(0, 0), noLESVariables());
    }
  }
 
  if(RANSSolver().grid().isActive()) {
    if(RANSSolver().noNeighborDomains() > 0) {
      RANSSolver().exchangeData(&RANSSolver().a_variable(0, 0), noRANSVariables());
      RANSSolver().exchangeData(&RANSSolver().a_oldVariable(0, 0), noRANSVariables());
      RANSSolver().exchangeData(&RANSSolver().a_pvariable(0, 0), noRANSVariables());
    }
  }
 
  if(globalTimeStep % m_zonalTransferInterval == 0) {
    if(globalTimeStep > m_rntStartTimeStep) {
      reconstructNutilde();
    }
    transferSolverData();
  }
}

prepareAdaptation()

template<MInt nDim, class SysEqn >

void FvZonalRTV< nDim, SysEqn >::prepareAdaptation ( )

inlineprivatevirtual

Reimplemented from Coupling.

Definition at line 69 of file fvzonalrtv.h.

{};

RANSSolver()

template<MInt nDim, class SysEqn >

RANS & FvZonal< nDim, SysEqn >::RANSSolver ( ) const

inline

Definition at line 44 of file fvzonal.h.

{ return *CouplingFv<nDim, SysEqn>::m_fvSolvers[0]; }

readProperties()

template<MInt nDim, class SysEqn >

void FvZonalRTV< nDim, SysEqn >::readProperties ( )

inlineprivatevirtual

Implements Coupling.

Definition at line 74 of file fvzonalrtv.h.

{};

reconstructAverageFromNut()

template<MInt nDim, class SysEqn >

void FvZonalRTV< nDim, SysEqn >::reconstructAverageFromNut

private

Definition at line 552 of file fvzonalrtv.cpp.

                                                         {
  TRACE();
 
  if(LESSolver().grid().isActive()) {
    for(MInt c = 0; c < (MInt)LESSolver().m_LESAverageCells.size(); c++) {
      MInt cellId = LESSolver().m_LESAverageCells[c];
 
      MInt RANSId = convertIdParent(LESSolver(), RANSSolver(), cellId);
      if(RANSId > -1) {
        MFloat nuTilde = RANSSolver().a_pvariable(RANSId, RANSSolver().m_sysEqn.PV->N);
        MFloat add = F0;
        for(MInt i = 0; i < nDim; i++) {
          add += F2B3 * RANSSolver().a_slope(RANSId, i, i);
        }
 
        MInt count = 0;
        MInt index = 0;
        for(MInt i = 0; i < nDim; i++) {
          for(MInt j = count; j < nDim; j++) {
            MInt indexAvg = index + noRANSVariables();
 
            ASSERT(c < (MInt)LESSolver().m_LESVarAverage[indexAvg].size(),
                   "Trying to access data [" + to_string(indexAvg) + "][" + to_string(c)
                       + "] in LESSolver().m_LESVarAverage with length "
                       + to_string(LESSolver().m_LESVarAverage[indexAvg].size()));
 
            if(i == j) {
              LESSolver().m_LESVarAverage[indexAvg][c] =
                  LESSolver().m_LESVarAverage[i][c] * LESSolver().m_LESVarAverage[j][c]
                  - nuTilde * (RANSSolver().a_slope(RANSId, i, j) + RANSSolver().a_slope(RANSId, j, i) - add);
            } else {
              LESSolver().m_LESVarAverage[indexAvg][c] =
                  LESSolver().m_LESVarAverage[i][c] * LESSolver().m_LESVarAverage[j][c]
                  - nuTilde * (RANSSolver().a_slope(RANSId, i, j) + RANSSolver().a_slope(RANSId, j, i));
            }
 
            index++;
          }
          count++;
        }
      }
    }
  }
}

reconstructNutilde()

template<MInt nDim, class SysEqn >

void FvZonalRTV< nDim, SysEqn >::reconstructNutilde

private

Definition at line 341 of file fvzonalrtv.cpp.

                                                  {
  TRACE();
 
  const MInt N = RANSSolver().m_sysEqn.PV->N;
 
  if(LESSolver().grid().isActive()) {
    // reconstruct nuTilde
    //---------------------------------------------
    const MFloat rRe = F1 / LESSolver().m_sysEqn.m_Re0;
 
    // Turbulent intensity is calculated and used as a limiter for the turbulent kinetic energy
    /*data taken from:
      Brandt, Luca & Schlatter, Philipp. (2004). Transition in boundary layers subject to free-stream turbulence.
      Journal of Fluid Mechanics. 517. 167 - 198. 10.1017/S0022112004000941.
      ------------
      used to determine the expected freestream turbulence intensity
    */
 
    MFloat tuFreeStream = 0.05;
 
    if(abs(m_turbulentIntensity + 1) < 1e-16) {
      std::vector<std::pair<MFloat, MFloat>> tuFreeStreamData = {
          std::make_pair(31171.1711712, 0.0451546391753), std::make_pair(34774.7747748, 0.0428865979381),
          std::make_pair(38378.3783784, 0.0407216494845), std::make_pair(42702.7027027, 0.0385567010309),
          std::make_pair(51711.7117117, 0.0349484536082), std::make_pair(58558.5585586, 0.0327835051546),
          std::make_pair(66846.8468468, 0.0305154639175), std::make_pair(78738.7387387, 0.0278350515464),
          std::make_pair(93513.5135135, 0.0250515463918), std::make_pair(111891.891892, 0.0223711340206),
          std::make_pair(132432.432432, 0.0198969072165), std::make_pair(158738.738739, 0.0175257731959),
          std::make_pair(186126.126126, 0.0154639175258), std::make_pair(215675.675676, 0.0137113402062),
          std::make_pair(243783.783784, 0.0124742268041), std::make_pair(273693.693694, 0.0113402061856),
          std::make_pair(301801.801802, 0.0105154639175)};
 
      // interpolant freestream turbulence intensity from data
      MInt length = (MInt)tuFreeStreamData.size();
      for(MInt i = 0; i < length; i++) {
        if(tuFreeStreamData[i].first > LESSolver().m_Re * m_tuLengthScaleCorrection) {
          tuFreeStream = tuFreeStreamData[i - 1].second
                         + (tuFreeStreamData[i].second - tuFreeStreamData[i - 1].second)
                               / (tuFreeStreamData[i].first - tuFreeStreamData[i - 1].first)
                               * (LESSolver().m_Re * m_tuLengthScaleCorrection - tuFreeStreamData[i - 1].first);
          break;
        }
      }
      // extrapolat freestream turbulence intensity from data
      if(LESSolver().m_Re * m_tuLengthScaleCorrection < tuFreeStreamData[0].first) {
        tuFreeStream = tuFreeStreamData[0].second
                       + (tuFreeStreamData[1].second - tuFreeStreamData[0].second)
                             / (tuFreeStreamData[1].first - tuFreeStreamData[0].first)
                             * (LESSolver().m_Re * m_tuLengthScaleCorrection - tuFreeStreamData[0].first);
      }
      if(LESSolver().m_Re * m_tuLengthScaleCorrection > tuFreeStreamData[length - 1].first) {
        tuFreeStream = tuFreeStreamData[length - 2].second
                       + (tuFreeStreamData[length - 1].second - tuFreeStreamData[length - 2].second)
                             / (tuFreeStreamData[length - 1].first - tuFreeStreamData[length - 2].first)
                             * (LESSolver().m_Re * m_tuLengthScaleCorrection - tuFreeStreamData[length - 2].first);
      }
 
      tuFreeStream *= 0.95;
 
      m_log << "interpolation of freestream turbulence intensity: " << tuFreeStream << endl;
 
    } else {
      tuFreeStream = m_turbulentIntensity;
    }
 
    for(MInt c = 0; c < m_noRntBcCells; c++) {
      MInt cellId = m_rntBcCells[c];
      vector<MInt>::iterator findLESId =
          find(LESSolver().m_LESAverageCells.begin(), LESSolver().m_LESAverageCells.end(), cellId);
      if(findLESId == LESSolver().m_LESAverageCells.end()) TERMM(1, "Something went wrong " + to_string(cellId));
      MInt LESAvgId = distance(LESSolver().m_LESAverageCells.begin(), findLESId);
 
      // calculating turbulent kinetic energy k = 0.5(ui'ui')
      MFloat tuarg = 0.0;
      MFloat k = F0;
      MInt count_ = 0;
      MInt index_ = 0;
      MInt index1 = 0;
      MInt index2 = 0;
      for(MInt i = 0; i < nDim; i++) {
        for(MInt j = count_; j < nDim; j++) {
          index1 = index_ + noRANSVariables();
          if(i == j) {
            ASSERT(c < (MInt)LESSolver().m_LESVarAverage[index1].size(),
                   "Trying to access data [" + to_string(index1) + "][" + to_string(LESAvgId)
                       + "] in LESSolver().m_LESVarAverage with length "
                       + to_string(LESSolver().m_LESVarAverage[index1].size()));
 
            k += 0.5
                 * (LESSolver().m_LESVarAverage[index1][LESAvgId]
                    - pow(LESSolver().m_LESVarAverage[index2][LESAvgId], F2));
            tuarg += (LESSolver().m_LESVarAverage[index1][LESAvgId]
                      - pow(LESSolver().m_LESVarAverage[index2][LESAvgId], F2));
            index2++;
          }
          index_++;
        }
        count_++;
      }
 
      tuarg = max(tuarg, epss);
 
      MFloat tu = sqrt(tuarg / 3.0) / LESSolver().m_Ma;
      MFloat tufac = tanh((tu - tuFreeStream) / tuFreeStream);
      MFloat tulim = max(tu, tuFreeStream);
      tulim = tu / tulim;
 
      k = k * tufac * tulim;
 
      // calculating strain rate tensor Sij = 0.5(dui/dxj + duj/dxi)
      MFloat du[3][3]{{F0, F0, F0}, {F0, F0, F0}, {F0, F0, F0}};
      const MInt recData = LESSolver().a_reconstructionData(cellId);
 
      const MFloat u[3] = {LESSolver().m_LESVarAverage[0][LESAvgId], LESSolver().m_LESVarAverage[1][LESAvgId],
                           LESSolver().m_LESVarAverage[2][LESAvgId]};
 
      for(MInt nghbr = 0; nghbr < LESSolver().a_noReconstructionNeighbors(cellId); nghbr++) {
        const MInt recNghbrId = LESSolver().a_reconstructionNeighborId(cellId, nghbr);
        const MFloat recConst_x = LESSolver().m_reconstructionConstants[nDim * (recData + nghbr) + 0];
        const MFloat recConst_y = LESSolver().m_reconstructionConstants[nDim * (recData + nghbr) + 1];
        const MFloat recConst_z = LESSolver().m_reconstructionConstants[nDim * (recData + nghbr) + 2];
 
        vector<MInt>::iterator findRecNghbrId =
            find(LESSolver().m_LESAverageCells.begin(), LESSolver().m_LESAverageCells.end(), recNghbrId);
 
        if(findRecNghbrId == LESSolver().m_LESAverageCells.end())
          TERMM(1, "Something went wrong in nghbr " + to_string(recNghbrId));
 
        MInt LESRecNghbrId = distance(LESSolver().m_LESAverageCells.begin(), findRecNghbrId);
 
        for(MInt dim = 0; dim < nDim; dim++) {
          ASSERT(c < (MInt)LESSolver().m_LESVarAverage[dim].size(),
                 "Trying to access data [" + to_string(dim) + "][" + to_string(LESRecNghbrId)
                     + "] in LESSolver().m_LESVarAverage with length "
                     + to_string(LESSolver().m_LESVarAverage[dim].size()));
 
          const MFloat delta_u = LESSolver().m_LESVarAverage[dim][LESRecNghbrId] - u[dim];
          if(abs(LESSolver().m_LESVarAverage[dim][LESRecNghbrId]) > epss
             || abs(u[dim] / LESSolver().m_LESVarAverage[dim][LESRecNghbrId]) > 100) {
            du[dim][0] += recConst_x * delta_u;
            du[dim][1] += recConst_y * delta_u;
            du[dim][2] += recConst_z * delta_u;
          }
        }
      }
 
      MFloat SijSij = F0;
      for(MInt d1 = 0; d1 < nDim; d1++) {
        for(MInt d2 = 0; d2 < nDim; d2++) {
          MFloat sij = 0.5 * (du[d1][d2] + du[d2][d1]);
          SijSij += sij * sij;
        }
      }
 
      const MFloat SijSijLim = (4.0 * pow(LESSolver().m_Ma, F2)) * 0.0001;
      SijSij = max(SijSij, SijSijLim);
      const MFloat c_mu = 0.09;
      MFloat omega = 1 / sqrt(c_mu) * sqrt(2 * SijSij);
      omega = max(omega, epss);
 
      // calculating nut
      MFloat nuTurb = max(k / (omega * rRe), LESSolver().m_nuTildeInfinity);
      MFloat nuTilde = LESSolver().m_nuTildeInfinity;
      if(std::isnan(omega) || tulim < 1) {
        nuTurb = LESSolver().m_nuTildeInfinity;
      }
 
      if(approx(tulim, F1, eps)) {
        const MFloat rho = LESSolver().a_pvariable(cellId, LESSolver().m_sysEqn.PV->RHO);
        const MFloat p = LESSolver().a_pvariable(cellId, LESSolver().m_sysEqn.PV->P);
        const MFloat T = LESSolver().m_gamma * p / rho;
        const MFloat mue = (T * sqrt(T) * LESSolver().m_sutherlandPlusOne) / (T + LESSolver().m_sutherlandConstant);
        const MFloat nuLaminar = mue / rho;
 
        // Iteration of nuTilde (using Newton, nu_(n+1) = nu_n - f(nu_n)/f'(nu_n))
        MInt NewtonIter = 50;
        MFloat nut = nuTurb;
        MFloat nu_new = nut;
        MFloat nu_old = 0;
        MFloat func_n = 0.0;
        MFloat derv_n = 0.0;
        MInt icount = 0;
 
        while(abs(nu_new - nu_old) > eps && icount < NewtonIter) {
          nu_old = nu_new;
 
          MFloat chi = nu_old / nuLaminar;
          MFloat chi3 = pow(chi, 3.0);
          MFloat cv13 = RM_SA_DV::cv1to3;
          MFloat fv1 = chi3 / (chi3 + cv13);
 
          // current function value
          func_n = nu_old * fv1 - nut;
          // derivative of function
          derv_n = fv1 + 3.0 * fv1 - 3.0 * fv1 * fv1;
          // newton iteration formula
          nu_new = nu_old - func_n / derv_n;
 
          icount++;
        }
 
        nuTilde = nu_new;
      }
 
      LESSolver().m_LESVarAverage[N][LESAvgId] = nuTilde;
    }
  }
}

subCouple()

template<MInt nDim, class SysEqn >

void FvZonalRTV< nDim, SysEqn >::subCouple ( MInt  , MInt  , std::vector< MBool > &    )

inlineprivatevirtual

Implements Coupling.

Definition at line 70 of file fvzonalrtv.h.

{};

transferSolverData()

template<MInt nDim, class SysEqn >

void FvZonalRTV< nDim, SysEqn >::transferSolverData

private

Definition at line 291 of file fvzonalrtv.cpp.

                                                  {
  TRACE();
 
  // write LES data to RANS Solver and RANS data to LES Solver
  if(RANSSolver().grid().isActive()) {
    for(MInt var = 0; var < noRANSVariables(); var++) {
      for(MInt cellId = 0; cellId < a_noFvGridCellsRANS(); cellId++) {
        MInt LESId = convertIdParent(RANSSolver(), LESSolver(), cellId);
 
        ASSERT(cellId < (MInt)RANSSolver().m_LESValues[var].size(),
               "Trying to access data [" + to_string(var) + "][" + to_string(cellId)
                   + "] in LESSolver().m_LESVarAverage(RANS) with length "
                   + to_string(RANSSolver().m_LESValues[var].size())
                   + ", domainId: " + to_string(RANSSolver().domainId()));
 
        if(LESId != -1) {
          vector<MInt>::iterator findAvgId =
              find(LESSolver().m_LESAverageCells.begin(), LESSolver().m_LESAverageCells.end(), LESId);
          if(findAvgId != LESSolver().m_LESAverageCells.end()) {
            MInt avgId = distance(LESSolver().m_LESAverageCells.begin(), findAvgId);
            MInt var_ = var;
            // if(var == nDim + 2) var_ = nDim + 2 + 1;
            RANSSolver().m_LESValues[var][cellId] = LESSolver().m_LESVarAverage[var_][avgId];
          }
        }
      }
    }
  }
 
  // write RANS data to LES Solver
  if(LESSolver().grid().isActive()) {
    for(MInt cellId = 0; cellId < a_noFvGridCellsLES(); cellId++) {
      MInt RANSId = convertIdParent(LESSolver(), RANSSolver(), cellId);
 
      if(RANSId != -1) {
        for(MInt var = 0; var < noRANSVariables(); var++) {
          ASSERT(cellId < (MInt)LESSolver().m_RANSValues[var].size(),
                 "Trying to access data [" + to_string(var) + "][" + to_string(cellId)
                     + "] in m_RANSValues with length " + to_string(LESSolver().m_RANSValues[var].size())
                     + ", domainId: " + to_string(LESSolver().domainId()));
 
          LESSolver().m_RANSValues[var][cellId] = RANSSolver().a_pvariable(RANSId, var);
        }
      }
    }
  }
}

Friends And Related Function Documentation

FvZonal< nDim, SysEqn >

template<MInt nDim, class SysEqn >

friend class FvZonal< nDim, SysEqn >

friend

Definition at line 1 of file fvzonalrtv.h.

Member Data Documentation

eps

template<MInt nDim, class SysEqn >

const MFloat FvZonalRTV< nDim, SysEqn >::eps = 1e-16

private

Definition at line 107 of file fvzonalrtv.h.

epss

template<MInt nDim, class SysEqn >

const MFloat FvZonalRTV< nDim, SysEqn >::epss = 1e-8

private

Definition at line 108 of file fvzonalrtv.h.

m_7902faceNormalDir

template<MInt nDim, class SysEqn >

MInt FvZonalRTV< nDim, SysEqn >::m_7902faceNormalDir

private

Definition at line 99 of file fvzonalrtv.h.

m_7902periodicDir

template<MInt nDim, class SysEqn >

MInt FvZonalRTV< nDim, SysEqn >::m_7902periodicDir

private

Definition at line 101 of file fvzonalrtv.h.

m_7902Position

template<MInt nDim, class SysEqn >

MFloat FvZonalRTV< nDim, SysEqn >::m_7902Position

private

Definition at line 98 of file fvzonalrtv.h.

m_7902wallDir

template<MInt nDim, class SysEqn >

MInt FvZonalRTV< nDim, SysEqn >::m_7902wallDir

private

Definition at line 100 of file fvzonalrtv.h.

m_averageDir

template<MInt nDim, class SysEqn >

MInt FvZonalRTV< nDim, SysEqn >::m_averageDir

private

Definition at line 104 of file fvzonalrtv.h.

m_averageFaceDir

template<MInt nDim, class SysEqn >

MInt FvZonalRTV< nDim, SysEqn >::m_averageFaceDir

private

Definition at line 105 of file fvzonalrtv.h.

m_averagePos

template<MInt nDim, class SysEqn >

MFloat FvZonalRTV< nDim, SysEqn >::m_averagePos

private

Definition at line 103 of file fvzonalrtv.h.

m_averageTimeSteps

template<MInt nDim, class SysEqn >

MInt FvZonalRTV< nDim, SysEqn >::m_averageTimeSteps

private

Definition at line 88 of file fvzonalrtv.h.

m_bcId7902

template<MInt nDim, class SysEqn >

MInt FvZonalRTV< nDim, SysEqn >::m_bcId7902

private

Definition at line 97 of file fvzonalrtv.h.

m_LESNoVarAverage

template<MInt nDim, class SysEqn >

MInt FvZonal< nDim, SysEqn >::m_LESNoVarAverage

Definition at line 72 of file fvzonal.h.

m_LESSolverId

template<MInt nDim, class SysEqn >

MInt FvZonal< nDim, SysEqn >::m_LESSolverId

Definition at line 63 of file fvzonal.h.

m_noReconstructNutVars

template<MInt nDim, class SysEqn >

const MInt FvZonal< nDim, SysEqn >::m_noReconstructNutVars

Definition at line 65 of file fvzonal.h.

m_noRntBcCells

template<MInt nDim, class SysEqn >

MInt FvZonalRTV< nDim, SysEqn >::m_noRntBcCells

private

Definition at line 95 of file fvzonalrtv.h.

m_nuTildeInfinity

template<MInt nDim, class SysEqn >

MFloat FvZonalRTV< nDim, SysEqn >::m_nuTildeInfinity

private

Definition at line 87 of file fvzonalrtv.h.

m_RANSSolverId

template<MInt nDim, class SysEqn >

MInt FvZonal< nDim, SysEqn >::m_RANSSolverId

Definition at line 62 of file fvzonal.h.

m_reconstructAverageFromNut

template<MInt nDim, class SysEqn >

MBool FvZonalRTV< nDim, SysEqn >::m_reconstructAverageFromNut = false

private

Definition at line 85 of file fvzonalrtv.h.

m_reconstructNut

template<MInt nDim, class SysEqn >

MBool FvZonalRTV< nDim, SysEqn >::m_reconstructNut = false

private

Definition at line 84 of file fvzonalrtv.h.

m_restartLESAverage

template<MInt nDim, class SysEqn >

MBool FvZonal< nDim, SysEqn >::m_restartLESAverage

Definition at line 70 of file fvzonal.h.

m_rntBcCells

template<MInt nDim, class SysEqn >

std::vector<MInt> FvZonalRTV< nDim, SysEqn >::m_rntBcCells

private

Definition at line 93 of file fvzonalrtv.h.

m_rntStartTimeStep

template<MInt nDim, class SysEqn >

MInt FvZonalRTV< nDim, SysEqn >::m_rntStartTimeStep

private

Definition at line 83 of file fvzonalrtv.h.

m_tuLengthScaleCorrection

template<MInt nDim, class SysEqn >

MFloat FvZonalRTV< nDim, SysEqn >::m_tuLengthScaleCorrection

private

Definition at line 91 of file fvzonalrtv.h.

m_turbulentIntensity

template<MInt nDim, class SysEqn >

MFloat FvZonalRTV< nDim, SysEqn >::m_turbulentIntensity

private

Definition at line 90 of file fvzonalrtv.h.

m_zonalAveragingTimeStep

template<MInt nDim, class SysEqn >

MInt FvZonal< nDim, SysEqn >::m_zonalAveragingTimeStep

Definition at line 67 of file fvzonal.h.

m_zonalTransferInterval

template<MInt nDim, class SysEqn >

MInt FvZonal< nDim, SysEqn >::m_zonalTransferInterval

Definition at line 68 of file fvzonal.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/COUPLER/fvzonalrtv.h
• /home/gitlab-runner/scratch/builds/oxpnswJ6/1/aia/m-AIA/m-AIA/src/COUPLER/fvzonalrtv.cpp