CouplerFvParticle< nDim, SysEqn > Class Template Reference

#include <fvparticle.h>

Inheritance diagram for CouplerFvParticle< nDim, SysEqn >:

Collaboration diagram for CouplerFvParticle< nDim, SysEqn >:

Public Member Functions
	CouplerFvParticle (const MInt couplingId, LPT< nDim > *particle, FvCartesianSolver *fv)
void	init () override
	performs the coupling after solver initialization More...
void	finalizeCouplerInit () override
void	finalizeSubCoupleInit (MInt) override
void	preCouple (MInt) override
	preCoupler: reset external source terms before the LPT timestep More...
void	postCouple (MInt) override
	postCouple: exchange source terms after the LPT timeStep More...
void	subCouple (MInt, MInt, std::vector< MBool > &) override
	transfer the FV velocity slopes to the LPT solver More...
void	postAdaptation () override
void	finalizeAdaptation (const MInt) override
	prepate adaptation More...
void	prepareAdaptation () override
	prepate adaptation More...
void	finalizeBalance (const MInt unused) override
	postCouple: exchange source terms after the LPT timeStep More...
void	balancePre () override
	Load balancing. More...
void	balancePost () override
void	cleanUp () override
void	writeRestartFile (const MInt) override
MInt	noCouplingTimers (const MBool NotUsed(allTimings)) const override
	Number of coupling timers. More...
void	getCouplingTimings (std::vector< std::pair< MString, MFloat > > &timings, const MBool NotUsed(allTimings)) override
Public Member Functions inherited from CouplingLpt< nDim, CouplingFv< nDim, SysEqn > >
	CouplingLpt (const MInt couplingId, Lpt *particle, FlowSolver *flowSolver)
virtual	~CouplingLpt ()=default
Public Member Functions inherited from CouplingParticle< nDim >
	CouplingParticle (const MInt couplingId, LPT< nDim > *solver)
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, 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

Protected Member Functions
LPT< nDim > &	lpt () const override
FvCartesianSolverXD< nDim, SysEqn > &	fvSolver () const
virtual LPT< nDim > &	lpt () const
Protected Member Functions inherited from Coupling
MFloat	returnLoadRecord () const
MFloat	returnIdleRecord () const
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

Private Types
using	FvCartesianSolver = FvCartesianSolverXD< nDim, SysEqn >
using	BaseFv = CouplingFv< nDim, SysEqn >
using	BaseLpt = CouplingParticle< nDim >
using	BaseLptX = CouplingLpt< nDim, BaseFv >

Private Member Functions
void	checkProperties () override
	Checks property-data which is read in by both lpt-and Fv-Solver. More...
void	readProperties ()
void	initData ()
	Initialize coupling-class-specific Data. More...
void	initConversion ()
	Calculates the conversion factor for different non-dimensionalisations in the FV and LPT solvers. More...
void	initParticleVelocity ()
	Sets the initial particle velocity based on the flow field velocity in that cell. NOTE: This can not be done in the LPT initialCondition, as the FV flow field has not been transfered before, its set in the FV initialCondition. More...
void	transferNoParticlesInCell ()
	set a_noPart in Fv based on a_noParticlesInCell and a_noEllipsoidsInCell in LPT solver NOTE: this is only necessary if the particle sensor is used during adaptation More...
void	writeParticleCellStats ()
	compute particle-cell binning and write to file More...
void	transferExternalSources ()
	set external sources in Fv solver based on values in the LPT solver More...
void	updateLPTBndry ()
	transfer all relevant bndryCell-data from FV to LPT solver before the LPT timeStep! More...
void	transferFlowField ()
	transfer flow data from FV to LPT More...
void	transferCellStatus ()
	set the isValid status for LPT cells based on the FV-solver cell properties More...
void	transferVelocitySlopes ()
	transfer the FV velocity slopes to the LPT solver More...
void	transferTimeStep ()
	transfer/enforce Fv timeStep onto LPT solver More...
void	setExternalSourceInCell (const MInt, const MInt, const MFloat)
	set external source in FV-solver from LPT fluxes More...
void	unifyTimeStep ()
	Find combinded maximum timeStep for Fv and LPT solvers only possible for interleafed execution assuming that both solvers have previously computed their independend timeSteps. More...
MInt	childLoop (MInt cellId)
	compute particle-cell binning and write to file More...
MInt	lpt2fvId (const MInt lptId)
MInt	lpt2fvIdParent (const MInt lptId)
MInt	fv2lptId (const MInt fvId)
MInt	fv2lptIdParent (const MInt fvId)
void	interpolateFVLPT (const MInt from, const MInt to)
	interpolate flow variables from the fv-grid to the LPT-cell position More...
void	interpolateVelocitySlopesFVLPT (const MInt from, const MInt to)
	Interpolates the velocity slopes from the fv-grid to the LPT-cell. More...
MFloat	interpolateVariable (MInt *, MFloat *, MInt)
	interpolates the fv-variable / More...
MFloat	interpolateSlope (MInt *, MFloat *, MInt, MInt)
	interpolate fv slope More...

Private Attributes
ConversionFactor &	conversionLptFv = BaseLptX::conversionLptFlow
ConversionFactor &	conversionFvLpt = BaseLptX::conversionFlowLpt
LPT< nDim > *	m_particle = nullptr
FvCartesianSolverXD< nDim, SysEqn > *	m_fvSolver = nullptr
MInt	m_lptSolverId {}
MInt	m_fvSolverId {}
MInt	m_lptSolverOrder {}
MInt	m_fvSolverOrder {}
MInt	m_noSolverSteps {}
MBool	m_lptFvInterpolation = false
MInt	m_fvLPTSpeciesId {}
SysEqn	m_sysEqn
MInt	m_solutionStep
MInt	m_noSolutionSteps
MBool	m_forceFvTimeStep
MBool	m_interLeafed

Friends
class	LPT< nDim >
class	FvCartesianSolverXD< nDim, SysEqn >

Additional Inherited Members
Public Types inherited from CouplingLpt< nDim, CouplingFv< nDim, SysEqn > >
using	FlowSolver = typename CouplingFlowSolver::solverType
using	Lpt = typename CouplingParticle< nDim >::solverType
Public Types inherited from CouplingParticle< nDim >
using	solverType = LPT< nDim >
Public Types inherited from CouplingFv< nDim, SysEqn >
using	solverType = FvCartesianSolverXD< nDim, SysEqn >
Public Attributes inherited from CouplingLpt< nDim, CouplingFv< nDim, SysEqn > >
ConversionFactor	conversionFlowLpt
ConversionFactor	conversionLptFlow
Protected Attributes inherited from CouplingFv< nDim, SysEqn >
std::vector< solverType * >	m_fvSolvers {}

Detailed Description

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

Definition at line 21 of file fvparticle.h.

Member Typedef Documentation

BaseFv

template<MInt nDim, class SysEqn >

using CouplerFvParticle< nDim, SysEqn >::BaseFv = CouplingFv<nDim, SysEqn>

private

Definition at line 28 of file fvparticle.h.

BaseLpt

template<MInt nDim, class SysEqn >

using CouplerFvParticle< nDim, SysEqn >::BaseLpt = CouplingParticle<nDim>

private

Definition at line 29 of file fvparticle.h.

BaseLptX

template<MInt nDim, class SysEqn >

using CouplerFvParticle< nDim, SysEqn >::BaseLptX = CouplingLpt<nDim, BaseFv>

private

Definition at line 30 of file fvparticle.h.

FvCartesianSolver

template<MInt nDim, class SysEqn >

using CouplerFvParticle< nDim, SysEqn >::FvCartesianSolver = FvCartesianSolverXD<nDim, SysEqn>

private

Definition at line 26 of file fvparticle.h.

Constructor & Destructor Documentation

CouplerFvParticle()

template<MInt nDim, class SysEqn >

CouplerFvParticle< nDim, SysEqn >::CouplerFvParticle	(	const MInt	couplingId,
		LPT< nDim > *	particle,
		FvCartesianSolver *	fv
	)

Definition at line 14 of file fvparticle.cpp.

  : Coupling(couplingId), CouplingLpt<nDim, CouplingFv<nDim, SysEqn>>(couplingId, particle, fv), m_sysEqn(1, 0) {
  TRACE();
 
  m_particle = particle;
  m_fvSolver = fv;
 
  // get LPT-solver order
  m_noSolverSteps = 1;
  m_noSolverSteps = Context::getBasicProperty<MInt>("recipeMaxNoSteps", AT_, &m_noSolverSteps);
 
  const MString propNameLpt = "solverOrder_" + std::to_string(lpt().solverId());
  const MString propNameFv = "solverOrder_" + std::to_string(fvSolver().solverId());
 
  for(MInt step = 0; step < m_noSolverSteps; step++) {
    if(Context::getBasicProperty<MInt>(propNameLpt, AT_, step) > 0) {
      m_lptSolverOrder = step;
    }
    if(Context::getBasicProperty<MInt>(propNameFv, AT_, step) > 0) {
      m_fvSolverOrder = step;
    }
  }
 
  m_interLeafed = false;
  m_noSolutionSteps = 1;
 
  if(m_lptSolverOrder == m_fvSolverOrder) {
    m_interLeafed = true;
    m_noSolutionSteps = 5;
    lpt().m_noSolutionSteps = 5;
    if(lpt().domainId() == 0) {
      cerr << "Interleafed Fv - LPT execution at step " << m_lptSolverOrder << endl;
    }
  }
 
  initData();
}

Member Function Documentation

balancePost()

template<MInt nDim, class SysEqn >

void CouplerFvParticle< nDim, SysEqn >::balancePost ( )

inlineoverridevirtual

Reimplemented from Coupling.

Definition at line 65 of file fvparticle.h.

{};

balancePre()

template<MInt nDim, class SysEqn >

void CouplerFvParticle< nDim, SysEqn >::balancePre ( )

inlineoverridevirtual

Reimplemented from Coupling.

Definition at line 64 of file fvparticle.h.

{};

checkProperties()

template<MInt nDim, class SysEqn >

void CouplerFvParticle< nDim, SysEqn >::checkProperties

overrideprivatevirtual

Author

Tim Wegmann

Reimplemented from CouplingParticle< nDim >.

Definition at line 338 of file fvparticle.cpp.

                                                      {
  TRACE();
 
  ASSERT(fabs(fvSolver().m_sutherlandConstant - lpt().m_sutherlandConstant) < MFloatEps, "");
  ASSERT(fabs(lpt().m_sutherlandPlusOne - fvSolver().m_sutherlandPlusOne) < MFloatEps, "");
  ASSERT(lpt().a_timeStepComputationInterval() == fvSolver().a_timeStepComputationInterval(), "");
}

childLoop()

template<MInt nDim, class SysEqn >

MInt CouplerFvParticle< nDim, SysEqn >::childLoop ( MInt  cellId )

private

Author

Tim Wegmann

Definition at line 1484 of file fvparticle.cpp.

                                                           {
  MInt sum = 0;
  if(fvSolver().c_noChildren(cellId) > 0) {
    for(MInt child = 0; child < fvSolver().c_noChildren(cellId); child++) {
      MInt childId = fvSolver().c_childId(cellId, child);
      if(childId < 0) {
        continue;
      }
      sum += childLoop(childId);
    }
  } else {
    sum += fvSolver().a_noPart(cellId);
  }
  return sum;
}

cleanUp()

template<MInt nDim, class SysEqn >

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

inlineoverridevirtual

Reimplemented from CouplingParticle< nDim >.

Definition at line 67 of file fvparticle.h.

{};

finalizeAdaptation()

template<MInt nDim, class SysEqn >

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

overridevirtual

Author

Tim Wegmann

Reimplemented from Coupling.

Definition at line 930 of file fvparticle.cpp.

                                                                            {
  TRACE();
 
  // Post FV solver
  if(solverId == fvSolver().solverId()) {
    transferCellStatus();
    transferFlowField();
    transferVelocitySlopes();
    if(lpt().isActive()) {
      lpt().receiveFlowField();
      lpt().receiveVelocitySlopes();
      lpt().waitForSendReqs();
    }
 
    updateLPTBndry();
 
  } else if(solverId == lpt().solverId()) {
    // set external sources in the FV-solver
    // as they are reset there in finalizeAdaptation
    if(fvSolver().m_hasExternalSource) {
      fvSolver().resetExternalSources();
      transferExternalSources();
    }
  }
}

finalizeBalance()

template<MInt nDim, class SysEqn >

void CouplerFvParticle< nDim, SysEqn >::finalizeBalance ( const MInt  unused )

overridevirtual

Author

Tim Wegmann

Reimplemented from Coupling.

Definition at line 418 of file fvparticle.cpp.

                                                             {
  // post LPT solver
  if(id == lpt().solverId()) {
    if(fvSolver().m_hasExternalSource) {
      fvSolver().resetExternalSources();
    }
    if(globalTimeStep < 0) {
      prepareAdaptation();
    } else {
      transferExternalSources();
      fvSolver().advanceExternalSource();
    }
 
  } else if(id == fvSolver().solverId()) {
    transferCellStatus();
    transferFlowField();
    transferVelocitySlopes();
    if(lpt().isActive()) {
      lpt().receiveFlowField();
      lpt().receiveVelocitySlopes();
      lpt().waitForSendReqs();
    }
 
    updateLPTBndry();
  }
}

finalizeCouplerInit()

template<MInt nDim, class SysEqn >

void CouplerFvParticle< nDim, SysEqn >::finalizeCouplerInit

overridevirtual

Reimplemented from CouplingParticle< nDim >.

Definition at line 255 of file fvparticle.cpp.

                                                          {
  TRACE();
 
  // Transfer the flow field after the intial condition for FV has been applied
  transferCellStatus();
  transferFlowField();
  transferVelocitySlopes();
  if(lpt().isActive()) {
    lpt().receiveFlowField();
    lpt().receiveVelocitySlopes();
    lpt().waitForSendReqs();
  }
 
  initParticleVelocity();
 
  if(!lpt().m_restartFile && fvSolver().m_restartFile) {
    if(lpt().domainId() == 0) {
      cerr << "Restart without LPT restartFile -> setting time from Fv-time!" << endl;
    }
    const MFloat conversionTime = conversionFvLpt.length / conversionFvLpt.velocity;
    const MFloat fvTime = fvSolver().m_levelSetMb ? fvSolver().m_physicalTime : fvSolver().m_time;
    lpt().m_time = fvTime * conversionTime;
  }
 
  // set the timeStep in the LPT solver
  if(m_forceFvTimeStep) {
    transferTimeStep();
  } else {
    unifyTimeStep();
  }
 
  MBool writeParticleStats = false;
  if(writeParticleStats) {
    writeParticleCellStats();
  }
}

finalizeSubCoupleInit()

template<MInt nDim, class SysEqn >

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

inlineoverridevirtual

Reimplemented from CouplingParticle< nDim >.

Definition at line 53 of file fvparticle.h.

{};

fv2lptId()

template<MInt nDim, class SysEqn >

MInt CouplerFvParticle< nDim, SysEqn >::fv2lptId ( const MInt  fvId )

inlineprivate

Definition at line 107 of file fvparticle.h.

{ return convertId(fvSolver(), lpt(), fvId); };

fv2lptIdParent()

template<MInt nDim, class SysEqn >

MInt CouplerFvParticle< nDim, SysEqn >::fv2lptIdParent ( const MInt  fvId )

inlineprivate

Definition at line 108 of file fvparticle.h.

{ return convertIdParent(fvSolver(), lpt(), fvId); };

fvSolver()

template<MInt nDim, class SysEqn >

FvCartesianSolverXD< nDim, SysEqn > & CouplerFvParticle< nDim, SysEqn >::fvSolver ( ) const

inlineprotected

Definition at line 48 of file fvparticle.h.

{ return *m_fvSolver; }

getCouplingTimings()

template<MInt nDim, class SysEqn >

void CouplerFvParticle< nDim, SysEqn >::getCouplingTimings ( std::vector< std::pair< MString, MFloat > > &  timings, const MBool   NotUsedallTimings  )

inlineoverride

Definition at line 73 of file fvparticle.h.

                                                                                                                  {
    const MString namePrefix = "c" + std::to_string(this->couplerId()) + "_";
 
    timings.emplace_back(namePrefix + "loadCouplerFvParticle", returnLoadRecord());
    timings.emplace_back(namePrefix + "idleCouplerFvParticle", returnIdleRecord());
  };

init()

template<MInt nDim, class SysEqn >

void CouplerFvParticle< nDim, SysEqn >::init

overridevirtual

Author

Tim Wegmann

Implements Coupling.

Definition at line 56 of file fvparticle.cpp.

                                           {
  TRACE();
 
  checkProperties();
 
  initConversion();
 
  // check for any in-active ranks
  MInt noInactiveFv = 0;
  MInt noInactiveLPT = 0;
  if(!fvSolver().isActive()) {
    noInactiveFv++;
  }
  if(!lpt().isActive()) {
    noInactiveLPT++;
  }
 
  MPI_Allreduce(MPI_IN_PLACE, &noInactiveFv, 1, MPI_INT, MPI_SUM, MPI_COMM_WORLD, AT_, "MPI_IN_PLACE", "noInactiveFv");
  MPI_Allreduce(MPI_IN_PLACE, &noInactiveLPT, 1, MPI_INT, MPI_SUM, MPI_COMM_WORLD, AT_, "MPI_IN_PLACE",
                "noInactiveLPT");
  if(noInactiveFv > 0) {
    cerr0 << "Fv solver has " << noInactiveFv << " inactive ranks!" << endl;
  }
  if(noInactiveLPT > 0) {
    cerr0 << "LPT solver has " << noInactiveLPT << " inactive ranks!" << endl;
  }
}

initConversion()

template<MInt nDim, class SysEqn >

void CouplerFvParticle< nDim, SysEqn >::initConversion ( )

private

Author

Tim Wegmann

initData()

template<MInt nDim, class SysEqn >

void CouplerFvParticle< nDim, SysEqn >::initData

private

Author

Tim Wegmann

Definition at line 244 of file fvparticle.cpp.

                                               {
  TRACE();
 
  m_fvSolverId = fvSolver().m_solverId;
  m_lptSolverId = lpt().m_solverId;
 
  readProperties();
}

initParticleVelocity()

template<MInt nDim, class SysEqn >

void CouplerFvParticle< nDim, SysEqn >::initParticleVelocity

private

Author

Tim Wegmann

Definition at line 227 of file fvparticle.cpp.

                                                           {
  if(!lpt().m_restart) {
    // init fluid density and velocity, after the values have been transferred to the LPT solver!
    for(MInt i = 0; i < lpt().a_noParticles(); i++) {
      lpt().m_partList[i].initVelocityAndDensity();
    }
    // init fluid density and velocity for ellipsoidal particles
    for(MInt i = 0; i < lpt().a_noEllipsoidalParticles(); i++) {
      lpt().m_partListEllipsoid[i].initVelocityAndDensity();
    }
  }
}

interpolateFVLPT()

template<MInt nDim, class SysEqn >

void CouplerFvParticle< nDim, SysEqn >::interpolateFVLPT ( const MInt  from, const MInt  to  )

private

Author

Tim Wegmann

Date

March 2020

Definition at line 962 of file fvparticle.cpp.

                                                                                     {
  TRACE();
 
  MInt interpolationCells[8] = {0, 0, 0, 0, 0, 0, 0, 0};
  MFloat point[3] = {lpt().c_coordinate(to, 0), lpt().c_coordinate(to, 1), lpt().c_coordinate(to, 2)};
 
  std::function<MBool(const MInt, const MInt)> neighborCheck = [&](const MInt cellId, const MInt id) {
    return static_cast<MBool>(fvSolver().checkNeighborActive(cellId, id));
  };
 
  const MInt position = fvSolver().setUpInterpolationStencil(from, interpolationCells, point, neighborCheck, true);
 
  if(position < 0) {
    for(MInt n = 0; n < nDim; n++) {
      lpt().a_fluidVelocity(to, n) =
          fvSolver().a_pvariable(from, fvSolver().m_sysEqn.PV->VV[n]) * conversionFvLpt.velocity;
    }
    lpt().a_fluidDensity(to) = fvSolver().a_pvariable(from, fvSolver().m_sysEqn.PV->RHO) * conversionFvLpt.density;
    lpt().a_fluidPressure(to) = fvSolver().a_pvariable(from, fvSolver().m_sysEqn.PV->P) * conversionFvLpt.pressure;
    lpt().a_fluidTemperature(to) =
        fvSolver().sysEqn().temperature_ES(fvSolver().a_pvariable(from, fvSolver().m_sysEqn.PV->RHO),
                                           fvSolver().a_pvariable(from, fvSolver().m_sysEqn.PV->P))
        * conversionFvLpt.temperature;
    if(lpt().m_evaporation && fvSolver().m_noSpecies > 0) {
      lpt().a_fluidSpecies(to) = fvSolver().a_pvariable(from, fvSolver().m_sysEqn.PV->Y[m_fvLPTSpeciesId]);
    }
 
  } else {
    for(MInt n = 0; n < nDim; n++) {
      lpt().a_fluidVelocity(to, n) =
          interpolateVariable(interpolationCells, point, fvSolver().m_sysEqn.PV->VV[n]) * conversionFvLpt.velocity;
    }
    const MFloat rho = interpolateVariable(interpolationCells, point, fvSolver().m_sysEqn.PV->RHO);
    const MFloat p = interpolateVariable(interpolationCells, point, fvSolver().m_sysEqn.PV->P);
    lpt().a_fluidDensity(to) = rho * conversionFvLpt.density;
    lpt().a_fluidPressure(to) = p * conversionFvLpt.pressure;
    lpt().a_fluidTemperature(to) = fvSolver().sysEqn().temperature_ES(rho, p) * conversionFvLpt.temperature;
    if(lpt().m_evaporation && fvSolver().m_noSpecies > 0) {
      lpt().a_fluidSpecies(to) =
          interpolateVariable(interpolationCells, point, fvSolver().m_sysEqn.PV->Y[m_fvLPTSpeciesId]);
    }
  }
}

interpolateSlope()

template<MInt nDim, class SysEqn >

MFloat CouplerFvParticle< nDim, SysEqn >::interpolateSlope ( MInt *  interpolationCells, MFloat *  point, MInt  v, MInt  dir  )

private

Author

Laurent Andre

Date

August 2022

Definition at line 1067 of file fvparticle.cpp.

                                                                                                                  {
  TRACE();
 
  std::function<MFloat(const MInt, const MInt)> scalarField = [&](const MInt cellId, const MInt varId) {
    return static_cast<MFloat>(*(&fvSolver().a_slope(cellId, 0, 0) + varId));
  };
 
  std::function<MFloat(const MInt, const MInt)> coordinate = [&](const MInt cellId, const MInt id) {
    return static_cast<MFloat>(fvSolver().a_coordinate(cellId, id));
  };
 
  MInt valIndex = v * nDim + dir;
  return fvSolver().template interpolateFieldData<false>(&interpolationCells[0], &point[0], valIndex, scalarField,
                                                         coordinate);
}

interpolateVariable()

template<MInt nDim, class SysEqn >

MFloat CouplerFvParticle< nDim, SysEqn >::interpolateVariable ( MInt *  interpolationCells, MFloat *  point, MInt  v  )

private

Author

Tim Wegmann /

Date

2020-04-01

Definition at line 1047 of file fvparticle.cpp.

                                                                                                           {
  TRACE();
 
  std::function<MFloat(const MInt, const MInt)> scalarField = [&](const MInt cellId, const MInt varId) {
    return static_cast<MFloat>(fvSolver().a_pvariable(cellId, varId));
  };
 
  std::function<MFloat(const MInt, const MInt)> coordinate = [&](const MInt cellId, const MInt id) {
    return static_cast<MFloat>(fvSolver().a_coordinate(cellId, id));
  };
 
  return fvSolver().template interpolateFieldData<false>(&interpolationCells[0], &point[0], v, scalarField, coordinate);
}

interpolateVelocitySlopesFVLPT()

template<MInt nDim, class SysEqn >

void CouplerFvParticle< nDim, SysEqn >::interpolateVelocitySlopesFVLPT ( const MInt  from, const MInt  to  )

private

Author

Laurent Andre

Date

August 2022

Definition at line 1012 of file fvparticle.cpp.

                                                                                                   {
  TRACE();
 
  MInt interpolationCells[8] = {0, 0, 0, 0, 0, 0, 0, 0};
  MFloat point[3] = {lpt().c_coordinate(to, 0), lpt().c_coordinate(to, 1), lpt().c_coordinate(to, 2)};
 
  std::function<MBool(const MInt, const MInt)> neighborCheck = [&](const MInt cellId, const MInt id) {
    return static_cast<MBool>(fvSolver().checkNeighborActive(cellId, id));
  };
 
  const MInt position = fvSolver().setUpInterpolationStencil(from, interpolationCells, point, neighborCheck, true);
 
  if(position < 0) {
    for(MInt varId = 0; varId < nDim; varId++) {
      for(MInt dir = 0; dir < nDim; dir++) {
        lpt().a_velocitySlope(to, varId, dir) =
            fvSolver().a_slope(from, fvSolver().m_sysEqn.PV->VV[varId], dir) * conversionFvLpt.velocitySlope;
      }
    }
  } else {
    for(MInt varId = 0; varId < nDim; varId++) {
      for(MInt dir = 0; dir < nDim; dir++) {
        lpt().a_velocitySlope(to, varId, dir) =
            interpolateSlope(interpolationCells, point, fvSolver().m_sysEqn.PV->VV[varId], dir)
            * conversionFvLpt.velocitySlope;
      }
    }
  }
}

lpt()

template<MInt nDim, class SysEqn >

LPT< nDim > & CouplerFvParticle< nDim, SysEqn >::lpt ( ) const

inlineoverrideprotectedvirtual

Reimplemented from CouplingParticle< nDim >.

Definition at line 47 of file fvparticle.h.

{ return *m_particle; }

lpt2fvId()

template<MInt nDim, class SysEqn >

MInt CouplerFvParticle< nDim, SysEqn >::lpt2fvId ( const MInt  lptId )

inlineprivate

Definition at line 105 of file fvparticle.h.

{ return convertId(lpt(), fvSolver(), lptId); };

lpt2fvIdParent()

template<MInt nDim, class SysEqn >

MInt CouplerFvParticle< nDim, SysEqn >::lpt2fvIdParent ( const MInt  lptId )

inlineprivate

Definition at line 106 of file fvparticle.h.

{ return convertIdParent(lpt(), fvSolver(), lptId); };

noCouplingTimers()

template<MInt nDim, class SysEqn >

MInt CouplerFvParticle< nDim, SysEqn >::noCouplingTimers ( const MBool   NotUsedallTimings ) const

inlineoverridevirtual

Reimplemented from Coupling.

Definition at line 71 of file fvparticle.h.

{ return 2; }

postAdaptation()

template<MInt nDim, class SysEqn >

void CouplerFvParticle< nDim, SysEqn >::postAdaptation ( )

inlineoverridevirtual

Reimplemented from Coupling.

Definition at line 59 of file fvparticle.h.

{};

postCouple()

template<MInt nDim, class SysEqn >

void CouplerFvParticle< nDim, SysEqn >::postCouple ( MInt  recipeStep )

overridevirtual

Author

Tim Wegmann

Reimplemented from CouplingParticle< nDim >.

Definition at line 382 of file fvparticle.cpp.

                                                                {
  // when using inter-leafed application, external sources and flow field are transfered in the subCouple!
  if(m_interLeafed) {
    if(recipeStep == m_fvSolverOrder) {
      transferVelocitySlopes(); // transfer only after postTimestep
    }
    return;
  }
 
  // Post LPT (as the LPT-solver is called before the Fv-solver!)
  if(recipeStep == m_lptSolverOrder) {
    // reset and transfer external Sources to FV-solver
    if(fvSolver().m_hasExternalSource) {
      fvSolver().applyExternalOldSource();
      fvSolver().resetExternalSources();
      transferExternalSources();
    }
  }
 
  // POST FV
  if(recipeStep == m_fvSolverOrder) {
    transferFlowField();
    transferVelocitySlopes();
    if(lpt().isActive()) {
      lpt().receiveFlowField();
      lpt().receiveVelocitySlopes();
      lpt().waitForSendReqs();
    }
    transferTimeStep();
  }
}

preCouple()

template<MInt nDim, class SysEqn >

void CouplerFvParticle< nDim, SysEqn >::preCouple ( MInt  recipeStep )

overridevirtual

Author

Tim Wegmann

Reimplemented from CouplingParticle< nDim >.

Definition at line 350 of file fvparticle.cpp.

                                                               {
  TRACE();
 
  // PRE LPT
  if(recipeStep == m_lptSolverOrder) {
    m_solutionStep = 0;
 
    // TODO-timw labels:COUPLER,FV,toenhance,totest check if this can be avoided when transfering variables at some
    // other stage!
    //           when removed, testcase results are changed slightly!
    if(!m_interLeafed) fvSolver().computeConservativeVariables();
 
    // update LPT bndryCells for wall-collision
    updateLPTBndry();
    transferCellStatus();
 
 
    if(m_interLeafed) {
      const MFloat conversionTime = conversionFvLpt.length / conversionFvLpt.velocity;
      const MFloat fvTime = fvSolver().m_levelSetMb ? fvSolver().m_physicalTime : fvSolver().m_time;
      if(lpt().isActive() && fabs(fvTime * conversionTime - lpt().m_time) > MFloatEps) {
        cerr << "LPT-time " << lpt().m_time << " Fv-time " << fvTime << endl;
        mTerm(1, AT_, "Miss-matching time!");
      }
    }
  }
}

prepareAdaptation()

template<MInt nDim, class SysEqn >

void CouplerFvParticle< nDim, SysEqn >::prepareAdaptation

overridevirtual

Author

Tim Wegmann

Reimplemented from Coupling.

Definition at line 871 of file fvparticle.cpp.

                                                        {
  TRACE();
 
  // transfer the number of particles for the particle limit sensor!
  transferNoParticlesInCell();
}

readProperties()

template<MInt nDim, class SysEqn >

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

privatevirtual

Reimplemented from CouplingParticle< nDim >.

setExternalSourceInCell()

template<MInt nDim, class SysEqn >

void CouplerFvParticle< nDim, SysEqn >::setExternalSourceInCell ( const MInt  fvCellId, const MInt  lptCell, const MFloat  factor  )

private

Author

Tim Wegmann

Definition at line 882 of file fvparticle.cpp.

                                                                                   {
  TRACE();
 
  if(factor < 0) {
    if(lpt().m_momentumCoupling) {
      for(MInt i = 0; i < nDim; i++) {
        fvSolver().a_externalSource(fvCellId, fvSolver().CV->RHO_VV[i]) +=
            lpt().a_momentumFlux(lptCell, i) / conversionFvLpt.momentum;
      }
      fvSolver().a_externalSource(fvCellId, fvSolver().CV->RHO_E) += lpt().a_workFlux(lptCell) / conversionFvLpt.energy;
    }
    if(lpt().m_heatCoupling) {
      fvSolver().a_externalSource(fvCellId, fvSolver().CV->RHO_E) += lpt().a_heatFlux(lptCell) / conversionFvLpt.energy;
    }
    if(lpt().m_massCoupling) {
      fvSolver().a_externalSource(fvCellId, fvSolver().CV->RHO) += lpt().a_massFlux(lptCell) / conversionFvLpt.mass;
      fvSolver().a_externalSource(fvCellId, fvSolver().CV->RHO_Y[m_fvLPTSpeciesId]) +=
          lpt().a_massFlux(lptCell) / conversionFvLpt.mass;
    }
  } else {
    if(lpt().m_momentumCoupling) {
      for(MInt i = 0; i < nDim; i++) {
        fvSolver().a_externalSource(fvCellId, fvSolver().CV->RHO_VV[i]) +=
            lpt().a_momentumFlux(lptCell, i) * factor / conversionFvLpt.momentum;
      }
      fvSolver().a_externalSource(fvCellId, fvSolver().CV->RHO_E) +=
          lpt().a_workFlux(lptCell) * factor / conversionFvLpt.energy;
    }
    if(lpt().m_heatCoupling) {
      fvSolver().a_externalSource(fvCellId, fvSolver().CV->RHO_E) +=
          lpt().a_heatFlux(lptCell) * factor / conversionFvLpt.energy;
    }
    if(lpt().m_massCoupling) {
      fvSolver().a_externalSource(fvCellId, fvSolver().CV->RHO) +=
          lpt().a_massFlux(lptCell) * factor / conversionFvLpt.mass;
 
      fvSolver().a_externalSource(fvCellId, fvSolver().CV->RHO_Y[m_fvLPTSpeciesId]) +=
          lpt().a_massFlux(lptCell) * factor / conversionFvLpt.mass;
    }
  }
}

subCouple()

template<MInt nDim, class SysEqn >

void CouplerFvParticle< nDim, SysEqn >::subCouple ( MInt  recipeStep, MInt  solverId, std::vector< MBool > &    )

overridevirtual

Author

Tim Wegmann

Reimplemented from CouplingParticle< nDim >.

Definition at line 1298 of file fvparticle.cpp.

                                                                     {
  if(!m_interLeafed) return;
 
  if(fvSolver().isActive() && lpt().isActive()) {
    if(globalTimeStep % lpt().a_timeStepComputationInterval() != 0
       && fabs(lpt().m_timeStep - fvSolver().timeStep()) > MFloatEps) {
      mTerm(1, AT_, "TimeSteps of FV and LPT differ at TS " + to_string(globalTimeStep));
    }
  }
 
  // only during FV-Lpt computation
  if(recipeStep == m_lptSolverOrder && (solverId == m_fvSolverId || solverId == m_lptSolverId)) {
    m_solutionStep++;
 
    // meaning after the 4th LPT solution step!
    if(m_solutionStep == 2 * m_noSolutionSteps - 3) {
      if(solverId == m_lptSolverId) {
        // set the source-terms before the last FV-Solution(=RK) Step
        // and before the 4th RK step for FvMb
 
        if(fvSolver().m_hasExternalSource && !lpt().m_skipLPT) {
          fvSolver().resetExternalSources();
          transferExternalSources();
        } else if(lpt().m_skipLPT) {
          vector<MFloat> tmp(2 + nDim);
          for(MInt j = 0; j < (2 + nDim); j++) {
            tmp[j] = 0.0;
          }
          fvSolver().m_vapourData.insert(make_pair(globalTimeStep, tmp));
        }
      }
    }
 
    if(m_solutionStep == 2 * m_noSolutionSteps - 2 && !lpt().m_skipLPT) {
      if(fvSolver().m_hasExternalSource) {
        fvSolver().applyExternalOldSource();
      }
    }
 
    // meaning after the last RK-step!
    if(m_solutionStep == 2 * m_noSolutionSteps) {
      if(solverId == m_fvSolverId && !lpt().m_skipLPT) {
        // after the last FV-solution step!
        transferFlowField();
      }
    }
 
    if(m_solutionStep == 2 * m_noSolutionSteps && (fvSolver().m_timeStepUpdated || lpt().m_timeStepUpdated)) {
      if(!m_forceFvTimeStep) {
        unifyTimeStep();
      } else {
        transferTimeStep();
      }
    }
  }
}

transferCellStatus()

template<MInt nDim, class SysEqn >

void CouplerFvParticle< nDim, SysEqn >::transferCellStatus

private

Author

Tim Wegmann

Definition at line 1087 of file fvparticle.cpp.

                                                         {
  for(MInt lptCellId = 0; lptCellId < lpt().a_noCells(); lptCellId++) {
    MInt fvCellId = lpt2fvIdParent(lptCellId);
    if(fvCellId < 0 || fvCellId > fvSolver().a_noCells()) {
      lpt().a_isValidCell(lptCellId) = false;
    } else if(fvSolver().a_hasProperty(fvCellId, FvCell::IsCutOff) && !lpt().grid().isPeriodic(lptCellId)) {
      lpt().a_isValidCell(lptCellId) = false;
    } else if(fvSolver().a_hasProperty(fvCellId, FvCell::IsInSpongeLayer)) {
      lpt().a_isValidCell(lptCellId) = false;
    } else if(fvSolver().a_isInactive(fvCellId)) {
      lpt().a_isValidCell(lptCellId) = false;
    } else {
      lpt().a_isValidCell(lptCellId) = true;
    }
  }
}

transferExternalSources()

template<MInt nDim, class SysEqn >

void CouplerFvParticle< nDim, SysEqn >::transferExternalSources

private

Author

Tim Wegmann

Definition at line 736 of file fvparticle.cpp.

                                                              {
  TRACE();
 
  if(!fvSolver().isActive()) return;
 
  if(!lpt().m_momentumCoupling && !lpt().m_heatCoupling && !lpt().m_massCoupling) return;
 
  if(lpt().isActive()) lpt().exchangeSourceTerms();
 
#ifndef NDEBUG
  // check that externalSource is set to zero!
  for(MInt cellId = 0; cellId < fvSolver().a_noCells(); cellId++) {
    for(MInt var = 0; var < fvSolver().CV->noVariables; var++) {
      // NOTE: only valid for single particle coupling!
      // ASSERT(abs(fvSolver().a_externalSource(cellId, var)) < MFloatEps, "");
      if(abs(fvSolver().a_externalSource(cellId, var)) > MFloatEps) {
        mTerm(1, AT_, "External Source not reset correctly!!");
      }
    }
  }
#endif
 
  for(MInt lptCell = 0; lptCell < lpt().noInternalCells(); lptCell++) {
    // the source term is only set on LPT leaf-cells
    if(!lpt().c_isLeafCell(lptCell)) continue;
    MInt fvCellId = lpt2fvId(lptCell);
    if(fvCellId > -1 && fvSolver().c_isLeafCell(fvCellId)) {
      // simple transfer
      setExternalSourceInCell(fvCellId, lptCell, -1);
 
    } else if(fvCellId > -1 && !fvSolver().c_isLeafCell(fvCellId)) {
      // fv-cell is refined further: volume average from LPT to FV
      // gather all fv-leaf-cell children for internal cells
      vector<MInt> leafChildIds;
      fvSolver().grid().getAllLeafChilds(fvCellId, leafChildIds);
      MFloat totalVol = 0;
      for(MUint i = 0; i < leafChildIds.size(); i++) {
        const MInt cellId = leafChildIds[i];
        totalVol += fvSolver().a_cellVolume(cellId);
      }
      for(MUint i = 0; i < leafChildIds.size(); i++) {
        const MInt cellId = leafChildIds[i];
        const MFloat vFrac = fvSolver().a_cellVolume(cellId) / totalVol;
        setExternalSourceInCell(cellId, lptCell, vFrac);
      }
    } else {
      // lpt-Cell is refined further
      fvCellId = lpt2fvIdParent(lptCell);
      if(fvCellId < 0) continue;
      setExternalSourceInCell(fvCellId, lptCell, -1);
    }
  }
 
  // count source-terms in the fv-solver:
  MInt numVars = 2 + nDim;
  MFloatScratchSpace conservativeSums(numVars, AT_, "conservativeSums");
  conservativeSums.fill(0.0);
  const MFloat dt = fvSolver().timeStep();
  for(MInt cellId = 0; cellId < fvSolver().noInternalCells(); cellId++) {
    if(!fvSolver().c_isLeafCell(cellId)) continue;
    if(fvSolver().a_isInactive(cellId)) continue;
 
    if(fvSolver().m_noSpecies > 0) {
      conservativeSums[0] -= dt * fvSolver().a_externalSource(cellId, fvSolver().CV->RHO_Y[m_fvLPTSpeciesId]);
    }
    conservativeSums[1] -= dt * fvSolver().a_externalSource(cellId, fvSolver().CV->RHO_E);
    for(MInt i = 0; i < nDim; i++) {
      conservativeSums[2 + i] -= dt * fvSolver().a_externalSource(cellId, fvSolver().CV->RHO_VV[i]);
    }
  }
 
  if(fvSolver().m_vapourData.size() > 0) {
    auto it = fvSolver().m_vapourData.find(globalTimeStep - 1);
    if(it != fvSolver().m_vapourData.end()) {
      for(MInt i = 0; i < numVars; i++) {
        MFloat lastSource = (it->second)[i];
        conservativeSums[i] += lastSource;
      }
    }
  }
 
  vector<MFloat> tmp(numVars);
  for(MInt j = 0; j < numVars; j++) {
    tmp[j] = conservativeSums[j];
  }
 
  fvSolver().m_vapourData.insert(make_pair(globalTimeStep, tmp));
}

transferFlowField()

template<MInt nDim, class SysEqn >

void CouplerFvParticle< nDim, SysEqn >::transferFlowField

private

NOTE: each LPT-cell must have at-least a matching FV-parent!

Author

Julian Vorspohl, Tim Wegmann

Definition at line 452 of file fvparticle.cpp.

                                                        {
  TRACE();
 
#ifndef NDEBUG
  MBool diverged = false;
#endif
 
  for(MInt lptCellId = 0; lptCellId < lpt().noInternalCells(); lptCellId++) {
    if(!lpt().c_isLeafCell(lptCellId)) continue;
    MInt fvCellId = lpt2fvId(lptCellId);
    if(fvCellId > -1 && fvSolver().c_isLeafCell(fvCellId)) {
      // simple transfer if both cells are leaf-cells
      for(MInt n = 0; n < nDim; n++) {
        lpt().a_fluidVelocity(lptCellId, n) =
            fvSolver().a_pvariable(fvCellId, fvSolver().m_sysEqn.PV->VV[n]) * conversionFvLpt.velocity;
      }
      lpt().a_fluidDensity(lptCellId) =
          fvSolver().a_pvariable(fvCellId, fvSolver().m_sysEqn.PV->RHO) * conversionFvLpt.density;
      lpt().a_fluidPressure(lptCellId) =
          fvSolver().a_pvariable(fvCellId, fvSolver().m_sysEqn.PV->P) * conversionFvLpt.pressure;
#ifndef NDEBUG
      if(std::isnan(lpt().a_fluidPressure(lptCellId)) && lpt().a_isValidCell(lptCellId)) {
        diverged = true;
        cerr << "Nan pressure " << lpt().a_fluidPressure(lptCellId) << " " << lpt().a_coordinate(lptCellId, 0) << " "
             << lpt().a_coordinate(lptCellId, 1) << " " << lpt().a_coordinate(lptCellId, nDim - 1) << endl;
        // mTerm(1, AT_, "Nan pressure detected!");
      }
#endif
      lpt().a_fluidTemperature(lptCellId) =
          fvSolver().sysEqn().temperature_ES(fvSolver().a_pvariable(fvCellId, fvSolver().m_sysEqn.PV->RHO),
                                             fvSolver().a_pvariable(fvCellId, fvSolver().m_sysEqn.PV->P))
          * conversionFvLpt.temperature;
      if(lpt().m_evaporation && fvSolver().m_noSpecies > 0) {
        lpt().a_fluidSpecies(lptCellId) =
            mMax(0.0, mMin(1.0, fvSolver().a_pvariable(fvCellId, fvSolver().m_sysEqn.PV->Y[m_fvLPTSpeciesId])));
      }
 
    } else if(fvCellId > -1 && !fvSolver().c_isLeafCell(fvCellId)) {
      // interpolate from FV-leaf childs if the matching fv-Cell is not a leaf cell
      if(lpt().a_isHalo(lptCellId)) continue;
      // gather all fv-leaf-cell childs for internal cells
      vector<MInt> leafChildIds;
      fvSolver().grid().getAllLeafChilds(fvCellId, leafChildIds);
      ASSERT(!leafChildIds.empty(), "");
 
      // reset variables
      for(MInt n = 0; n < nDim; n++) {
        lpt().a_fluidVelocity(lptCellId, n) = 0;
      }
      lpt().a_fluidDensity(lptCellId) = 0;
      lpt().a_fluidPressure(lptCellId) = 0;
      lpt().a_fluidTemperature(lptCellId) = 0;
      if(lpt().m_evaporation) {
        lpt().a_fluidSpecies(lptCellId) = 0;
      }
      // interpolate variables by volume
      MFloat volume = 0;
      for(MUint i = 0; i < leafChildIds.size(); i++) {
        const MInt cellId = leafChildIds[i];
        if(fvSolver().a_isInactive(cellId)) continue;
        const MFloat cellVolume = fvSolver().a_cellVolume(cellId);
        ASSERT(fvSolver().c_isLeafCell(cellId), "");
        // ASSERT(cellVolume > 0, "");
        if(cellVolume < 1e-16) {
          mTerm(1, AT_, "Invalid cell-volume!");
        }
        volume += cellVolume;
        for(MInt n = 0; n < nDim; n++) {
          lpt().a_fluidVelocity(lptCellId, n) +=
              cellVolume * fvSolver().a_pvariable(cellId, fvSolver().m_sysEqn.PV->VV[n]);
        }
        lpt().a_fluidDensity(lptCellId) += cellVolume * fvSolver().a_pvariable(cellId, fvSolver().m_sysEqn.PV->RHO);
        lpt().a_fluidPressure(lptCellId) += cellVolume * fvSolver().a_pvariable(cellId, fvSolver().m_sysEqn.PV->P);
        lpt().a_fluidTemperature(lptCellId) +=
            cellVolume
            * fvSolver().sysEqn().temperature_ES(fvSolver().a_pvariable(fvCellId, fvSolver().m_sysEqn.PV->RHO),
                                                 fvSolver().a_pvariable(fvCellId, fvSolver().m_sysEqn.PV->P));
        if(lpt().m_evaporation && fvSolver().m_noSpecies > 0) {
          lpt().a_fluidSpecies(lptCellId) += mMax(
              0.0,
              mMin(1.0, cellVolume * fvSolver().a_pvariable(fvCellId, fvSolver().m_sysEqn.PV->Y[m_fvLPTSpeciesId])));
        }
      }
 
      if(volume > 1e-16) {
        // meaning at least one child is active
        for(MInt n = 0; n < nDim; n++) {
          lpt().a_fluidVelocity(lptCellId, n) *= conversionFvLpt.velocity / volume;
        }
        lpt().a_fluidDensity(lptCellId) *= conversionFvLpt.density / volume;
        lpt().a_fluidPressure(lptCellId) *= conversionFvLpt.pressure / volume;
        lpt().a_fluidTemperature(lptCellId) *= conversionFvLpt.temperature / volume;
        if(lpt().m_evaporation && fvSolver().m_noSpecies > 0) {
          lpt().a_fluidSpecies(lptCellId) *= 1 / volume;
        }
      } else {
        // meaning completely outside
        for(MInt n = 0; n < nDim; n++) {
          lpt().a_fluidVelocity(lptCellId, n) = conversionFvLpt.velocity;
        }
        lpt().a_fluidDensity(lptCellId) = conversionFvLpt.density;
        lpt().a_fluidPressure(lptCellId) = conversionFvLpt.pressure;
        lpt().a_fluidTemperature(lptCellId) = conversionFvLpt.temperature;
        if(lpt().m_evaporation && fvSolver().m_noSpecies > 0) {
          lpt().a_fluidSpecies(lptCellId) = 1;
        }
      }
    } else if(fvCellId < 0) {
      if(lpt().a_isHalo(lptCellId)) continue;
      // interpolate linear from the FV parents to the LPT-child
      fvCellId = lpt2fvIdParent(lptCellId);
      // ASSERT(fvCellId > -1, "LPT-cell has no matching FV-cell!");
      if(fvCellId < 0) {
        cerr << "LPT-cell is missing fv-cell parent" << lptCellId << " " << fvCellId << " " << lpt().a_level(lptCellId)
             << endl;
      }
      interpolateFVLPT(fvCellId, lptCellId);
    }
  }
 
  // NOTE: exchange is necessary as particles on window-cells interpolate the flow variables to their
  //       position and will need values on halo-cells to do so!
  if(!lpt().m_nonBlockingComm) {
    lpt().exchangeData(&lpt().a_fluidVariable(0, 0), lpt().PV.noVars());
    if(lpt().m_evaporation) {
      lpt().exchangeData(&lpt().a_fluidSpecies(0), 1);
    }
#ifndef NDEBUG
    if(lpt().isActive()) {
      MPI_Allreduce(MPI_IN_PLACE, &diverged, 1, MPI_C_BOOL, MPI_LOR, lpt().mpiComm(), AT_, "MPI_IN_PLACE", "divCheck");
      if(diverged) {
        lpt().saveDebugRestartFile();
      }
    }
    if(fvSolver().isActive()) {
      MPI_Allreduce(MPI_IN_PLACE, &diverged, 1, MPI_C_BOOL, MPI_LOR, fvSolver().mpiComm(), AT_, "MPI_IN_PLACE",
                    "divCheck");
      if(diverged) {
        fvSolver().writeVtkXmlFiles("QOUT", "GEOM", false, true);
      }
    }
#endif
  } else {
    if(lpt().isActive()) {
      lpt().sendFlowField();
      // the flow field data is received in the time-step
    }
  }
}

transferNoParticlesInCell()

template<MInt nDim, class SysEqn >

void CouplerFvParticle< nDim, SysEqn >::transferNoParticlesInCell

private

Author

Tim Wegmann

Definition at line 692 of file fvparticle.cpp.

                                                                {
  TRACE();
 
  if(!fvSolver().m_sensorParticle) return;
 
  // reset
  for(MInt fvCell = 0; fvCell < fvSolver().c_noCells(); fvCell++) {
    fvSolver().a_noPart(fvCell) = 0;
  }
  for(MInt fvCell = fvSolver().c_noCells(); fvCell < fvSolver().a_noCells(); fvCell++) {
#ifndef NDEBUG
    if(fvSolver().a_noPart(fvCell) > 0) {
      cerr << " Particles in " << fvCell << " " << fvSolver().a_noCells() << " " << fvSolver().a_isHalo(fvCell)
           << fvSolver().a_isBndryGhostCell(fvCell) << endl;
    }
#endif
    fvSolver().a_noPart(fvCell) = 0;
  }
 
  // transfer
  for(MInt lptCell = 0; lptCell < lpt().noInternalCells(); lptCell++) {
    if(lpt().a_noParticlesInCell(lptCell) < 1 && lpt().a_noEllipsoidsInCell(lptCell) < 1) continue;
    MInt fvCellId = lpt2fvId(lptCell);
    if(fvCellId < 0) {
      ASSERT(m_lptFvInterpolation, "");
      fvCellId = lpt2fvIdParent(lptCell);
      if(fvCellId < 0) continue;
    }
 
    if(!fvSolver().c_isLeafCell(fvCellId)) {
      ASSERT(m_lptFvInterpolation, "");
    }
 
    fvSolver().a_noPart(fvCellId) = lpt().a_noParticlesInCell(lptCell) + lpt().a_noEllipsoidsInCell(lptCell);
  }
 
  fvSolver().exchangeData(&fvSolver().a_noPart(0));
}

transferTimeStep()

template<MInt nDim, class SysEqn >

void CouplerFvParticle< nDim, SysEqn >::transferTimeStep

private

Author

Tim Wegmann

Definition at line 830 of file fvparticle.cpp.

                                                       {
  TRACE();
 
  ASSERT(m_forceFvTimeStep, "");
 
  // set the timeStep in the LPT solver
  const MFloat conversionTime = conversionFvLpt.length / conversionFvLpt.velocity;
  lpt().forceTimeStep(fvSolver().timeStep(true) * conversionTime);
  const MFloat fvTime = fvSolver().m_levelSetMb ? fvSolver().m_physicalTime : fvSolver().m_time;
  if(lpt().isActive()) {
    if(fabs(fvTime * conversionTime - lpt().m_time) > MFloatEps) {
      cerr << "LPT-time " << lpt().m_time << " Fv-time " << fvTime << " " << conversionTime << " " << globalTimeStep
           << " " << lpt().isActive() << endl;
      mTerm(1, AT_, "Miss-matching time!");
    }
  } else {
    lpt().forceTimeStep(fvSolver().timeStep(true) * fvSolver().m_timeRef);
 
    cerr0 << "Fv-LPT time step set as " << fvSolver().timeStep(true) * fvSolver().m_timeRef << endl;
  }
 
  // increasing CFL number after the injection!
  if(lpt().m_sprayModel != nullptr && lpt().m_sprayModel->m_injectionCrankAngle > 0) {
    const MFloat cad = fvSolver().crankAngle(fvTime, 0);
    MFloat injDuration = 10;
    injDuration = Context::getSolverProperty<MFloat>("injectorInjectionTime", lpt().solverId(), AT_, &injDuration);
    MInt injCAD = 40;
    if(injDuration > 15) {
      injCAD = 55;
    }
    if(cad > lpt().m_sprayModel->m_injectionCrankAngle + injCAD && fvSolver().m_cfl < 0.7) {
      cerr0 << "Increasing FV CFL for next computation from " << fvSolver().m_cfl << " to 0.95!" << endl;
      fvSolver().m_cfl = 0.95;
    }
  }
}

transferVelocitySlopes()

template<MInt nDim, class SysEqn >

void CouplerFvParticle< nDim, SysEqn >::transferVelocitySlopes

private

NOTE: each LPT-cell must have at-least a matching FV-parent!

Author

Tim Wegmann, update Laurent Andre

Date

August 2022 (edit)

Definition at line 1112 of file fvparticle.cpp.

                                                             {
  if(!lpt().m_ellipsoids) return;
 
#ifndef NDEBUG
  MBool diverged = false;
#endif
 
  for(MInt lptCellId = 0; lptCellId < lpt().noInternalCells(); lptCellId++) {
    if(!lpt().c_isLeafCell(lptCellId)) continue;
    MInt fvCellId = lpt2fvId(lptCellId);
    if(fvCellId > -1 && fvSolver().c_isLeafCell(fvCellId)) {
      // simple transfer if both cells are leaf-cells
      for(MInt varId = 0; varId < nDim; varId++) {
        for(MInt dir = 0; dir < nDim; dir++) {
          lpt().a_velocitySlope(lptCellId, varId, dir) =
              fvSolver().a_slope(fvCellId, fvSolver().m_sysEqn.PV->VV[varId], dir) * conversionFvLpt.velocitySlope;
#ifndef NDEBUG
          if(std::isnan(lpt().a_velocitySlope(lptCellId, varId, dir)) && lpt().a_isValidCell(lptCellId)
             && globalTimeStep > 0) {
            diverged = true;
            cerr << "Nan velocity slope: " << lpt().a_velocitySlope(lptCellId, varId, dir) << " "
                 << lpt().a_coordinate(lptCellId, 0) << " " << lpt().a_coordinate(lptCellId, 1) << " "
                 << lpt().a_coordinate(lptCellId, nDim - 1) << endl;
            mTerm(1, AT_, "FVParticle: Transfer of slope that is NAN");
          }
#endif
        }
      }
    } else if(fvCellId > -1 && !fvSolver().c_isLeafCell(fvCellId)) {
      // interpolate from FV-leaf childs if the matching fv-Cell is not a leaf cell
      if(lpt().a_isHalo(lptCellId)) continue;
      // gather all fv-leaf-cell childs for internal cells
      vector<MInt> leafChildIds;
      fvSolver().grid().getAllLeafChilds(fvCellId, leafChildIds);
      ASSERT(!leafChildIds.empty(), "");
 
      // reset variables
      for(MInt varId = 0; varId < nDim; varId++) {
        for(MInt dir = 0; dir < nDim; dir++) {
          lpt().a_velocitySlope(lptCellId, varId, dir) = F0;
        }
      }
      // interpolate variables by volume
      MFloat volume = 0;
      for(MUint i = 0; i < leafChildIds.size(); i++) {
        const MInt cellId = leafChildIds[i];
        if(fvSolver().a_isInactive(cellId)) continue;
        const MFloat cellVolume = fvSolver().a_cellVolume(cellId);
        ASSERT(fvSolver().c_isLeafCell(cellId), "");
        if(cellVolume < 1e-16) mTerm(1, AT_, "Invalid cell-volume!");
        volume += cellVolume;
        for(MInt varId = 0; varId < nDim; varId++) {
          for(MInt dir = 0; dir < nDim; dir++) {
            lpt().a_velocitySlope(lptCellId, varId, dir) +=
                cellVolume * fvSolver().a_slope(fvCellId, fvSolver().m_sysEqn.PV->VV[varId], dir);
          }
        }
      }
      if(volume > 1e-16) {
        // meaning at least one child is active
        for(MInt varId = 0; varId < nDim; varId++) {
          for(MInt dir = 0; dir < nDim; dir++) {
            lpt().a_velocitySlope(lptCellId, varId, dir) *= conversionFvLpt.velocitySlope / volume;
          }
        }
      } else {
        // meaning completely outside
        for(MInt varId = 0; varId < nDim; varId++) {
          for(MInt dir = 0; dir < nDim; dir++) {
            lpt().a_velocitySlope(lptCellId, varId, dir) = conversionFvLpt.velocitySlope;
          }
        }
      }
    } else if(fvCellId < 0) {
      if(lpt().a_isHalo(lptCellId)) continue;
      // interpolate linear from the FV parents to the LPT-child
      fvCellId = lpt2fvIdParent(lptCellId);
      ASSERT(fvCellId > -1, "LPT-cell has no matching FV-cell!");
      interpolateVelocitySlopesFVLPT(fvCellId, lptCellId);
    }
  }
 
  // NOTE: exchange is necessary as particles on window-cells interpolate the flow variables to their
  //       position and will need values on halo-cells to do so!
  if(!lpt().m_nonBlockingComm) {
    lpt().exchangeData(&lpt().a_velocitySlope(0, 0, 0), nDim * nDim);
#ifndef NDEBUG
    if(lpt().isActive()) {
      MPI_Allreduce(MPI_IN_PLACE, &diverged, 1, MPI_C_BOOL, MPI_LOR, lpt().mpiComm(), AT_, "MPI_IN_PLACE", "divCheck");
      if(diverged) {
        lpt().saveDebugRestartFile();
      }
    }
    if(fvSolver().isActive()) {
      MPI_Allreduce(MPI_IN_PLACE, &diverged, 1, MPI_C_BOOL, MPI_LOR, fvSolver().mpiComm(), AT_, "MPI_IN_PLACE",
                    "divCheck");
      if(diverged) {
        fvSolver().writeVtkXmlFiles("QOUT", "GEOM", false, true);
      }
    }
#endif
  } else {
    if(lpt().isActive()) {
      lpt().sendVelocitySlopes(); // the velocity slopes are received in the time-step
    }
  }
}

unifyTimeStep()

template<MInt nDim, class SysEqn >

void CouplerFvParticle< nDim, SysEqn >::unifyTimeStep

private

Author

Tim Wegmann

Definition at line 1226 of file fvparticle.cpp.

                                                    {
  TRACE();
 
  ASSERT(m_interLeafed, "");
 
  cerr0 << "Unifying time-step LPT: " << lpt().m_timeStep << " FV: " << fvSolver().timeStep() << endl;
 
  const MFloat invalidTimeStep = std::numeric_limits<MFloat>::max();
  const MFloat conversionTime = conversionFvLpt.length / conversionFvLpt.velocity;
  MFloat timeFv = invalidTimeStep;
  MFloat timeLpt = invalidTimeStep;
  MInt maxLevelFv = -1;
  MInt maxLevelLpt = -1;
  MFloat newTimeFv = invalidTimeStep;
  MFloat newTimeLpt = invalidTimeStep;
 
  // determine the new/combined timeStep on ranks which have both Fv and Lpt solvers!
  if(fvSolver().isActive() && lpt().isActive()) {
    timeFv = fvSolver().timeStep(true);
    maxLevelFv = fvSolver().maxLevel();
    timeLpt = lpt().timeStep() / conversionTime;
    maxLevelLpt = lpt().maxLevel();
 
    MInt levelDiff = maxLevelLpt - maxLevelFv;
    if(levelDiff == 0) {
      newTimeFv = mMin(timeFv, timeLpt);
      newTimeLpt = newTimeFv * conversionTime;
    } else {
      if(levelDiff == 1) {
        // LPT has higher level => lower timeStep!
        newTimeLpt = mMin(newTimeLpt, newTimeFv / 2.0);
        newTimeFv = 2.0 * newTimeLpt;
      } else if(levelDiff == -1) {
        // Fv has the higher level => lower timeStep!
        newTimeFv = mMin(newTimeFv, newTimeLpt / 2.0);
        newTimeLpt = 2.0 * newTimeFv;
      } else {
        mTerm(1, AT_, "TimeStepping currently only implemented for 1 level difference!");
      }
    }
  }
 
  if(lpt().isActive()) {
    MPI_Allreduce(MPI_IN_PLACE, &newTimeLpt, 1, MPI_DOUBLE, MPI_MIN, lpt().mpiComm(), AT_, "MPI_IN_PLACE",
                  "newTimeLpt");
  }
  if(fvSolver().isActive()) {
    MPI_Allreduce(MPI_IN_PLACE, &newTimeFv, 1, MPI_DOUBLE, MPI_MIN, fvSolver().mpiComm(), AT_, "MPI_IN_PLACE",
                  "newTimeFv");
  }
 
  if(fvSolver().domainId() == 0) {
    cerr << "Fv timestep was " << timeFv << " combined TS is " << newTimeFv << endl;
  }
 
  if(lpt().domainId() == 0) {
    cerr << "LPT timestep was " << timeLpt << " combined TS is " << newTimeLpt << endl;
  }
 
 
  if(fvSolver().isActive()) {
    fvSolver().forceTimeStep(newTimeFv);
  }
  if(lpt().isActive()) {
    lpt().forceTimeStep(newTimeLpt);
  }
}

updateLPTBndry()

template<MInt nDim, class SysEqn >

void CouplerFvParticle< nDim, SysEqn >::updateLPTBndry

private

Author

Tim Wegmann

Definition at line 607 of file fvparticle.cpp.

                                                     {
  TRACE();
 
  if(!lpt().m_wallCollisions) return;
 
  if(!lpt().isActive()) return;
 
  // reset all moving bndry-Cells
  for(MInt lptCell = 0; lptCell < lpt().a_noCells(); lptCell++) {
    if(lpt().a_bndryCellId(lptCell) >= lpt().m_noOuterBndryCells) {
      lpt().a_bndryCellId(lptCell) = -1;
    }
  }
 
  // reset size to stationary outer bndryCells
  lpt().m_bndryCells->resetSize(lpt().m_noOuterBndryCells);
 
  MFloatScratchSpace surfaceC(nDim, nDim + 1, AT_, "surfaceC");
  MFloatScratchSpace surfaceN(nDim, AT_, "surfaceN");
  MFloatScratchSpace surfaceV(nDim, AT_, "surfaceV");
  MFloatScratchSpace bndryData(nDim + 1, AT_, "surfaceV");
 
  // update moving bndryCells from FV
  for(MInt bndryId = fvSolver().m_noOuterBndryCells; bndryId < fvSolver().m_fvBndryCnd->m_bndryCells->size();
      bndryId++) {
    const MInt fvCellId = fvSolver().m_bndryCells->a[bndryId].m_cellId;
    // TODO: use splitChildToSplitcell for bndry-cells of sliptchilds!
    if(fvCellId < 0 || fvCellId >= fvSolver().c_noCells()) continue;
    if(!fvSolver().c_isLeafCell(fvCellId)) continue;
    MInt lptCellId = fv2lptId(fvCellId);
    if(lptCellId < 0) {
      lptCellId = fv2lptIdParent(fvCellId);
      if(lptCellId < 0) continue;
      if(lpt().c_level(lptCellId) < lpt().maxRefinementLevel()) continue;
      ASSERT(m_lptFvInterpolation, "");
    }
 
    if(!lpt().c_isLeafCell(lptCellId)) {
      ASSERT(m_lptFvInterpolation, "");
    }
 
    MInt noSurf = fvSolver().m_bndryCells->a[bndryId].m_noSrfcs;
 
    // bndryCell without a bndrySurface, how is that even possible?
    // if(noSurf < 1 ) continue;
 
    // ASSERT(noSurf == 1, "Only for single bndry-surfaces!");
    if(noSurf > 1) noSurf = 1;
 
    bndryData[0] = fvSolver().m_fvBndryCnd->m_bndryCells->a[bndryId].m_volume;
    for(MInt i = 0; i < nDim; i++) {
      bndryData[1 + i] = fvSolver().m_fvBndryCnd->m_bndryCells->a[bndryId].m_coordinates[i];
    }
 
    for(MInt s = 0; s < noSurf; s++) {
      MInt bodyId = fvSolver().m_levelSetMb ? fvSolver().m_bndryCells->a[bndryId].m_srfcs[s]->m_bodyId[0] : -1;
      for(MInt n = 0; n < nDim; n++) {
        surfaceC(noSurf * s + n, 0) = fvSolver().m_fvBndryCnd->m_bndryCells->a[bndryId].m_srfcs[s]->m_coordinates[n];
        for(MInt i = 0; i < nDim; i++) {
          surfaceC(noSurf * s + n, i + 1) =
              fvSolver().m_fvBndryCnd->m_bndryCells->a[bndryId].m_srfcs[s]->m_cutCoordinates[i][n];
        }
        // surfaceV[noSurf * s + n] = fvSolver()
        //                               .m_fvBndryCnd->m_bndryCells->a[bndryId]
        //                               .m_srfcVariables[s]
        //                               ->m_primVars[fvSolver().m_sysEqn.PV->VV[n]];
        if(bodyId > 0) {
          surfaceV[noSurf * s + n] = fvSolver().m_bodyVelocity[bodyId * nDim + n];
        } else {
          surfaceV[noSurf * s + n] = 0.0;
        }
        surfaceN[noSurf * s + n] = fvSolver().m_fvBndryCnd->m_bndryCells->a[bndryId].m_srfcs[s]->m_normalVector[n];
      }
    }
 
    // append new LPT bndryCell based on FV data
    lpt().addBndryCell(lptCellId, &bndryData[0], &surfaceN[0], surfaceC, &surfaceV[0]);
  }
}

writeParticleCellStats()

template<MInt nDim, class SysEqn >

void CouplerFvParticle< nDim, SysEqn >::writeParticleCellStats

private

Author

Tim Wegmann

Definition at line 1360 of file fvparticle.cpp.

                                                             {
  TRACE();
 
  // count particles in cells
  lpt().countParticlesInCells();
 
  if(!fvSolver().isActive()) {
    return;
  }
 
  // transfer to FV-grid
  transferNoParticlesInCell();
 
  // determine max. No Particles in a FV-cell
  MInt maxNoParticles = 0;
  MInt maxParticlesSum = 0;
  for(MInt cellId = 0; cellId < fvSolver().noInternalCells(); cellId++) {
    if(fvSolver().a_noPart(cellId) > maxNoParticles) {
      maxNoParticles = fvSolver().a_noPart(cellId);
    }
    maxParticlesSum += fvSolver().a_noPart(cellId);
  }
  // create binning ranges
  MPI_Allreduce(MPI_IN_PLACE, &maxNoParticles, 1, MPI_INT, MPI_MAX, fvSolver().mpiComm(), AT_, "MPI_IN_PLACE",
                "maxParticles");
 
  MPI_Allreduce(MPI_IN_PLACE, &maxParticlesSum, 1, MPI_INT, MPI_MAX, fvSolver().mpiComm(), AT_, "MPI_IN_PLACE",
                "maxParticlesSum");
 
  {
    MFloatScratchSpace noCells(maxNoParticles + 1, AT_, "noCells");
    noCells.fill(0);
 
    // perform cell-binning
    for(MInt cellId = 0; cellId < fvSolver().noInternalCells(); cellId++) {
      if(!fvSolver().c_isLeafCell(cellId)) {
        continue;
      }
      if(!fvSolver().a_isActive(cellId)) {
        continue;
      }
 
      const MInt pos = fvSolver().a_noPart(cellId);
      noCells(pos)++;
    }
 
    // communicate results
    MPI_Allreduce(MPI_IN_PLACE, &noCells(0), maxNoParticles + 1, MPI_DOUBLE, MPI_SUM, fvSolver().mpiComm(), AT_,
                  "MPI_IN_PLACE", "noCells");
 
    // write to file
    if(fvSolver().domainId() == 0) {
      struct stat buffer {};
      MString name = "noParticlesInCells_" + to_string(fvSolver().solverId()) + "_" + to_string(globalTimeStep);
      const char* cstr = name.c_str();
      if(stat(cstr, &buffer) == 0) {
        rename(cstr, "noParticlesInCells_BAK");
      }
      ofstream ofl;
      ofl.open(name, ios_base::out | ios_base::app);
      ofl << "# 1:noParticles 2:noCells " << endl;
      for(MInt i = 0; i < maxNoParticles + 1; i++) {
        ofl << i << " " << noCells(i) << endl;
      }
      ofl.close();
    }
  }
 
  // perform min-cell binning
  MIntScratchSpace noMinCells(maxParticlesSum + 1, AT_, "noMinCells");
  noMinCells.fill(0);
 
  // reset particles to zero on halo-cells
  for(MInt cellId = fvSolver().noInternalCells(); cellId < fvSolver().a_noCells(); cellId++) {
    fvSolver().a_noPart(cellId) = 0;
  }
 
  MFloat minCellVolume = -1;
  for(MInt id = 0; id < fvSolver().grid().noMinCells(); id++) {
    const MInt cellId = fvSolver().grid().minCell(id);
    if(cellId < 0) {
      continue;
    }
    minCellVolume = fvSolver().c_cellVolumeAtLevel(fvSolver().a_level(cellId));
 
    // loop over all children and sum particles
    MInt curCount = childLoop(cellId);
 
    if(curCount > maxParticlesSum || curCount < 0) {
      cerr << "Strange particle count!" << curCount << endl;
    }
 
    noMinCells(curCount)++;
  }
 
  // communicate results
  MPI_Allreduce(MPI_IN_PLACE, &noMinCells(0), maxParticlesSum + 1, MPI_INT, MPI_SUM, fvSolver().mpiComm(), AT_,
                "MPI_IN_PLACE", "noMinCells");
 
  // write to file
  if(fvSolver().domainId() == 0) {
    struct stat buffer {};
    MString name = "noParticlesInMinCells_" + to_string(fvSolver().solverId()) + "_" + to_string(globalTimeStep);
    const char* cstr = name.c_str();
    if(stat(cstr, &buffer) == 0) {
      rename(cstr, "noParticlesInMinCells_BAK");
    }
 
    MString header = "# Min-cell volume : " + to_string(minCellVolume) + " \n";
    ofstream ofl;
    ofl.open(name, ios_base::out | ios_base::trunc);
    ofl << header << endl;
 
    for(MInt i = 0; i < maxParticlesSum + 1; i++) {
      ofl << i << " " << noMinCells(i) << endl;
    }
    ofl.close();
  }
}

writeRestartFile()

template<MInt nDim, class SysEqn >

void CouplerFvParticle< nDim, SysEqn >::writeRestartFile ( const  MInt )

inlineoverridevirtual

Reimplemented from Coupling.

Definition at line 69 of file fvparticle.h.

{};

Friends And Related Function Documentation

FvCartesianSolverXD< nDim, SysEqn >

template<MInt nDim, class SysEqn >

friend class FvCartesianSolverXD< nDim, SysEqn >

friend

Definition at line 1 of file fvparticle.h.

LPT< nDim >

template<MInt nDim, class SysEqn >

friend class LPT< nDim >

friend

Definition at line 1 of file fvparticle.h.

Member Data Documentation

conversionFvLpt

template<MInt nDim, class SysEqn >

ConversionFactor& CouplerFvParticle< nDim, SysEqn >::conversionFvLpt = BaseLptX::conversionFlowLpt

private

Definition at line 40 of file fvparticle.h.

conversionLptFv

template<MInt nDim, class SysEqn >

ConversionFactor& CouplerFvParticle< nDim, SysEqn >::conversionLptFv = BaseLptX::conversionLptFlow

private

Definition at line 39 of file fvparticle.h.

m_forceFvTimeStep

template<MInt nDim, class SysEqn >

MBool CouplerFvParticle< nDim, SysEqn >::m_forceFvTimeStep

private

Definition at line 132 of file fvparticle.h.

m_fvLPTSpeciesId

template<MInt nDim, class SysEqn >

MInt CouplerFvParticle< nDim, SysEqn >::m_fvLPTSpeciesId {}

private

Definition at line 126 of file fvparticle.h.

m_fvSolver

template<MInt nDim, class SysEqn >

FvCartesianSolverXD<nDim, SysEqn>* CouplerFvParticle< nDim, SysEqn >::m_fvSolver = nullptr

private

Definition at line 117 of file fvparticle.h.

m_fvSolverId

template<MInt nDim, class SysEqn >

MInt CouplerFvParticle< nDim, SysEqn >::m_fvSolverId {}

private

Definition at line 120 of file fvparticle.h.

m_fvSolverOrder

template<MInt nDim, class SysEqn >

MInt CouplerFvParticle< nDim, SysEqn >::m_fvSolverOrder {}

private

Definition at line 122 of file fvparticle.h.

m_interLeafed

template<MInt nDim, class SysEqn >

MBool CouplerFvParticle< nDim, SysEqn >::m_interLeafed

private

Definition at line 133 of file fvparticle.h.

m_lptFvInterpolation

template<MInt nDim, class SysEqn >

MBool CouplerFvParticle< nDim, SysEqn >::m_lptFvInterpolation = false

private

Definition at line 125 of file fvparticle.h.

m_lptSolverId

template<MInt nDim, class SysEqn >

MInt CouplerFvParticle< nDim, SysEqn >::m_lptSolverId {}

private

Definition at line 119 of file fvparticle.h.

m_lptSolverOrder

template<MInt nDim, class SysEqn >

MInt CouplerFvParticle< nDim, SysEqn >::m_lptSolverOrder {}

private

Definition at line 121 of file fvparticle.h.

m_noSolutionSteps

template<MInt nDim, class SysEqn >

MInt CouplerFvParticle< nDim, SysEqn >::m_noSolutionSteps

private

Definition at line 131 of file fvparticle.h.

m_noSolverSteps

template<MInt nDim, class SysEqn >

MInt CouplerFvParticle< nDim, SysEqn >::m_noSolverSteps {}

private

Definition at line 123 of file fvparticle.h.

m_particle

template<MInt nDim, class SysEqn >

LPT<nDim>* CouplerFvParticle< nDim, SysEqn >::m_particle = nullptr

private

Definition at line 116 of file fvparticle.h.

m_solutionStep

template<MInt nDim, class SysEqn >

MInt CouplerFvParticle< nDim, SysEqn >::m_solutionStep

private

Definition at line 130 of file fvparticle.h.

m_sysEqn

template<MInt nDim, class SysEqn >

SysEqn CouplerFvParticle< nDim, SysEqn >::m_sysEqn

private

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