#include <lblpt.h>

Inheritance diagram for LbLpt< nDim, nDist, SysEqn >:

Collaboration diagram for LbLpt< nDim, nDist, SysEqn >:

Public Types
using	BaseLb = CouplingLB< nDim, nDist, SysEqn >

using	LbSolver = typename BaseLb::solverType

using	BaseLpt = CouplingParticle< nDim >

using	BaseLptX = CouplingLpt< nDim, CouplingLB< nDim, nDist, SysEqn > >

using	LptSolver = typename BaseLpt::solverType

Public Types inherited from CouplingLpt< nDim, CouplingLB< nDim, nDist, 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 CouplingLB< nDim, nDist, SysEqn >
using	solverType = LbSolverDxQy< nDim, nDist, SysEqn >

using	LbBndCnd = LbBndCndDxQy< nDim, nDist, SysEqn >

using	MbCellCollector = maia::lb::collector::LbMbCellCollector< nDim >

Public Member Functions
	LbLpt (const MInt couplingId, LPT< nDim > particle, LbSolver lb)

void	init () override
	Init coupling class. More...

void	finalizeCouplerInit () override
	Finalize coupler initialization, coupler is ready after this. More...

void	finalizeSubCoupleInit (MInt) override

void	preCouple (MInt) override
	Coupling before each solver. More...

void	postCouple (MInt) override
	Coupling after each solver. More...

void	finalizeBalance (const MInt) override
	postCouple: exchange source terms after the LPT timeStep More...

void	balancePre () override
	Load balancing. More...

void	cleanUp () override

MFloat	a_lbVariable (const MInt lptCellId, const MInt varId, const MInt mode)

MFloat	a_lbCellCoordinate (const MInt lptCellId, const MInt dir)

Public Member Functions inherited from CouplingLpt< nDim, CouplingLB< nDim, nDist, 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 CouplingLB< nDim, nDist, SysEqn >
	CouplingLB (const MInt couplingId, Solver *solvers, const MInt noSolvers=1)

	CouplingLB (const MInt couplingId, std::vector< solverType * > solvers)

MFloat	a_physicalTime () const

MFloat	lsTimeStep () const

MInt	a_RKStep () const

MInt	a_noLbCells (const MInt id=0) const

MInt	a_noLevelSetsMb (const MInt id=0) const

MFloat	a_Ma (const MInt id=0) const

MFloat	a_Re (const MInt id=0) const

MInt	a_pvu (const MInt id=0) const

MInt	a_pvv (const MInt id=0) const

MInt	a_pvw (const MInt id=0) const

MInt	a_pvrho (const MInt id=0) const

MInt	a_pvt (const MInt id=0) const

MInt	a_isThermal (const MInt id=0) const

MInt	a_noDistributions (const MInt id=0) const

MFloat	a_initTemperatureKelvin (const MInt id=0) const

MFloat	a_time () const

MbCellCollector &	a_mbCell (const MInt id=0)

MInt	a_boundaryCellMb (const MInt cellId, const MInt id=0)

MFloat &	a_levelSetFunctionMb (const MInt cellId, const MInt set, const MInt id=0)

MFloat	a_levelSetFunctionMb (const MInt cellId, const MInt set, const MInt id=0) const

MInt &	a_associatedBodyIdsMb (const MInt cellId, const MInt set, const MInt id=0)

MInt	a_associatedBodyIdsMb (const MInt cellId, const MInt set, const MInt id=0) const

MInt	a_parentId (const MInt cellId, const MInt id=0)

MInt	a_childId (const MInt cellId, const MInt child, const MInt id=0)

MInt	minCell (const MInt index, const MInt id=0) const

MInt	noMinCells (const MInt id=0) const

MInt	a_noCells (const MInt id=0) const

MFloat	a_cellLengthAtLevel (MInt level, const MInt id=0)

MInt	a_noEmbeddedBodiesLB (const MInt id=0) const

MBool	a_isActive (const MInt cellId, const MInt id=0) const

MBool	a_wasActive (const MInt cellId, const MInt id=0) const

MInt	a_noVariables (const MInt id=0) const

MFloat &	a_variable (const MInt cellId, const MInt varId, const MInt id=0)

MFloat &	a_oldVariable (const MInt cellId, const MInt varId, const MInt id=0)

MInt	a_bndCellId (const MInt bndCell, const MInt id=0)

MInt	a_noBndCells (const MInt id=0)

Protected Member Functions
LPT< nDim > &	lpt () const override

MInt	a_bndCellId (const MInt bndCell, const MInt id=0)

MFloat	a_cellLengthAtLevel (MInt level, const MInt id=0)

MFloat	a_Ma (const MInt id=0) const

MInt	a_noBndCells (const MInt id=0)

MInt	a_noCells (const MInt id=0) const

LbBndCnd &	lbBndCnd (const MInt id=0)

solverType &	lbSolver (const MInt solverId=0) const

virtual LPT< nDim > &	lpt () const

Protected Member Functions inherited from Coupling
MFloat	returnLoadRecord () const

MFloat	returnIdleRecord () const

Protected Member Functions inherited from CouplingLB< nDim, nDist, SysEqn >
MInt	noSolvers () const

solverType &	lbSolver (const MInt solverId=0) const

LbBndCnd &	lbBndCnd (const MInt id=0)

Protected Attributes
ConversionFactor &	conversionLbLpt = BaseLptX::conversionFlowLpt

ConversionFactor &	conversionLptLb = BaseLptX::conversionLptFlow

Private Member Functions
void	checkProperties () override
	Check coupler properties for validity. More...

void	readProperties ()

void	initData ()

void	initConversion ()

void	calculateGridBoundaries ()
	calculate Boundaries of box-shaped Grid for calculation of boundaryCellData 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 Lb initialCondition. More...

void	updateLbSolver ()
	Transfer all relevant data from LPT to LB solver. More...

void	updateLPTBndry ()
	Transfer all relevant bndryCell-data from LB to LPT. More...

void	transferFlowField ()
	Transfer the momentum source (forcing) from LPT to LB. More...

void	transferCellStatus ()
	set the isValid status for LPT cells based on the FV-solver cell properties More...

void	transferTimeStep ()
	transfer/enforce Fv timeStep onto LPT solver More...

void	computeParticleInterphaseExchangeRate ()

MInt	lpt2lbId (const MInt lptId)

MInt	lpt2lbIdParent (const MInt lptId)

MInt	lb2lptId (const MInt lbId)

MInt	lb2lptIdParent (const MInt lbId)

Private Attributes
LPT< nDim > *	m_particle = nullptr

LbSolver *	m_lbSolver = nullptr

MInt	m_lptSolverId {}

MInt	m_lbSolverId {}

MInt	m_lptSolverOrder {}

MInt	m_noSolverSteps {}

std::array< MFloat, 2 *nDim >	m_gridBoundaries {}

MBool	m_lptlbInterpolation = false

MBool	m_forceLbTimeStep = true

MBool	m_CalcSurface = false

Additional Inherited Members
Public Attributes inherited from CouplingLpt< nDim, CouplingLB< nDim, nDist, SysEqn > >
ConversionFactor	conversionFlowLpt

ConversionFactor	conversionLptFlow

Detailed Description

template<MInt nDim, MInt nDist, class SysEqn>
class LbLpt< nDim, nDist, SysEqn >

Definition at line 30 of file lblpt.h.

Member Typedef Documentation

◆ BaseLb

template<MInt nDim, MInt nDist, class SysEqn >

using LbLpt< nDim, nDist, SysEqn >::BaseLb = CouplingLB<nDim, nDist, SysEqn>

Definition at line 32 of file lblpt.h.

◆ BaseLpt

template<MInt nDim, MInt nDist, class SysEqn >

using LbLpt< nDim, nDist, SysEqn >::BaseLpt = CouplingParticle<nDim>

Definition at line 35 of file lblpt.h.

◆ BaseLptX

template<MInt nDim, MInt nDist, class SysEqn >

using LbLpt< nDim, nDist, SysEqn >::BaseLptX = CouplingLpt<nDim, CouplingLB<nDim, nDist, SysEqn> >

Definition at line 36 of file lblpt.h.

◆ LbSolver

template<MInt nDim, MInt nDist, class SysEqn >

using LbLpt< nDim, nDist, SysEqn >::LbSolver = typename BaseLb::solverType

Definition at line 33 of file lblpt.h.

◆ LptSolver

template<MInt nDim, MInt nDist, class SysEqn >

using LbLpt< nDim, nDist, SysEqn >::LptSolver = typename BaseLpt::solverType

Definition at line 37 of file lblpt.h.

Constructor & Destructor Documentation

◆ LbLpt()

template<MInt nDim, MInt nDist, class SysEqn >

LbLpt< nDim, nDist, SysEqn >::LbLpt	(	const MInt	couplingId,
		LPT< nDim > *	particle,
		LbSolver *	lb
	)

Definition at line 15 of file lblpt.cpp.

  : Coupling(couplingId), CouplingLpt<nDim, CouplingLB<nDim, nDist, SysEqn>>(couplingId, particle, lb) {
  TRACE();
 
  m_particle = particle;
  m_lbSolver = lb;
 
  // get LPT-solver order
  m_noSolverSteps = 1;
  m_noSolverSteps = Context::getBasicProperty<MInt>("recipeMaxNoSteps", AT_, &m_noSolverSteps);
  const MString propName = "solverOrder_" + std::to_string(lpt().solverId());
  for(MInt step = 0; step < m_noSolverSteps; step++) {
    if(Context::getBasicProperty<MInt>(propName, AT_, step) > 0) {
      m_lptSolverOrder = step;
      break;
    }
  }
}

Member Function Documentation

◆ a_bndCellId()

template<MInt nDim, MInt nDist, class SysEqn >

MInt CouplingLB< nDim, nDist, SysEqn >::a_bndCellId	(	const MInt	bndCell,
		const MInt	id = `0`
	)

inlineprotected

Definition at line 537 of file coupling.h.

537{ return lbBndCnd(id).m_bndCells[bndCell].m_cellId; }

LbBndCnd::m_bndCells

std::vector< LbGridBoundaryCell< nDim > > m_bndCells

Definition: lbbndcnd.h:130

LbLpt::lbBndCnd

LbBndCnd & lbBndCnd(const MInt id=0)

Definition: coupling.h:461

◆ a_cellLengthAtLevel()

template<MInt nDim, MInt nDist, class SysEqn >

MFloat CouplingLB< nDim, nDist, SysEqn >::a_cellLengthAtLevel	(	MInt	level,
		const MInt	id = `0`
	)

inlineprotected

Definition at line 518 of file coupling.h.

518{ return lbSolver(id).grid().cellLengthAtLevel(level); }

LbLpt::lbSolver

solverType & lbSolver(const MInt solverId=0) const

Definition: coupling.h:454

◆ a_lbCellCoordinate()

template<MInt nDim, MInt nDist, class SysEqn >

MFloat LbLpt< nDim, nDist, SysEqn >::a_lbCellCoordinate	(	const MInt	lptCellId,
		const MInt	dir
	)

inline

Definition at line 83 of file lblpt.h.

                                                                  {
    MInt lbCellId = lpt2lbIdParent(lptCellId);
    if(lbCellId < 0 || lbCellId > lbSolver().a_noCells()) return -99;
    return lbSolver().a_coordinate(lbCellId, dir);
  }

◆ a_lbVariable()

template<MInt nDim, MInt nDist, class SysEqn >

MFloat LbLpt< nDim, nDist, SysEqn >::a_lbVariable	(	const MInt	lptCellId,
		const MInt	varId,
		const MInt	mode
	)

inline

Definition at line 73 of file lblpt.h.

                                                                               {
    MInt lbCellId = lpt2lbIdParent(lptCellId);
    if(lbCellId < 0 || lbCellId > lbSolver().a_noCells()) return -99;
    if(mode == 0) {
      return lbSolver().a_variable(lbCellId, varId);
    } else {
      return lbSolver().a_oldVariable(lbCellId, varId);
    }
  }

◆ a_Ma()

template<MInt nDim, MInt nDist, class SysEqn >

MFloat CouplingLB< nDim, nDist, SysEqn >::a_Ma ( const MInt id = 0 ) const

inlineprotected

Definition at line 472 of file coupling.h.

472{ return lbSolver(id).m_Ma; }

◆ a_noBndCells()

template<MInt nDim, MInt nDist, class SysEqn >

MInt CouplingLB< nDim, nDist, SysEqn >::a_noBndCells ( const MInt id = 0 )

inlineprotected

Definition at line 539 of file coupling.h.

539{ return lbBndCnd(id).m_bndCells.size(); }

◆ a_noCells()

template<MInt nDim, MInt nDist, class SysEqn >

MInt CouplingLB< nDim, nDist, SysEqn >::a_noCells ( const MInt id = 0 ) const

inlineprotected

Definition at line 516 of file coupling.h.

516{ return lbSolver(id).grid().noCells(); }

◆ balancePre()

template<MInt nDim, MInt nDist, class SysEqn >

void LbLpt< nDim, nDist, SysEqn >::balancePre ( )

inlineoverridevirtual

Reimplemented from Coupling.

Definition at line 67 of file lblpt.h.

67{};

◆ calculateGridBoundaries()

template<MInt nDim, MInt nDist, class SysEqn >

void LbLpt< nDim, nDist, SysEqn >::calculateGridBoundaries

private

Author: Johannes

Definition at line 158 of file lblpt.cpp.

                                                         {
  TRACE();
 
  MFloat halfCellWidth = 0.0;
  for(MInt cellId = 0; cellId < a_noCells(); cellId++) {
    if(!lbSolver().c_isLeafCell(cellId)) continue;
    halfCellWidth = F1B2 * lbSolver().grid().cellLengthAtCell(cellId);
    for(MInt i = 0; i < nDim; i++) {
      m_gridBoundaries[2 * i] = mMin(m_gridBoundaries[2 * i], lbSolver().a_coordinate(cellId, i) - halfCellWidth);
      m_gridBoundaries[2 * i + 1] =
          mMax(m_gridBoundaries[2 * i + 1], lbSolver().a_coordinate(cellId, i) + halfCellWidth);
    }
  }
 
  for(MInt i = 0; i < nDim; i++) {
    MPI_Allreduce(MPI_IN_PLACE, &m_gridBoundaries[2 * i], 1, maia::type_traits<MFloat>::mpiType(), MPI_MIN,
                  lbSolver().mpiComm(), AT_, "MPI_IN_PLACE", "m_domainBoundaryMin");
    MPI_Allreduce(MPI_IN_PLACE, &m_gridBoundaries[2 * i + 1], 1, maia::type_traits<MFloat>::mpiType(), MPI_MAX,
                  lbSolver().mpiComm(), AT_, "MPI_IN_PLACE", "m_domainBoundaryMax");
  }
}

◆ checkProperties()

template<MInt nDim, MInt nDist, class SysEqn >

void LbLpt< nDim, nDist, SysEqn >::checkProperties

overrideprivatevirtual

Author: Julian Vorspohl j.vor.nosp@m.spoh.nosp@m.l@aia.nosp@m..rwt.nosp@m.h-aac.nosp@m.hen..nosp@m.de

Date: May 2021

Reimplemented from CouplingParticle< nDim >.

Definition at line 275 of file lblpt.cpp.

                                                 {
  TRACE();
 
  cout << "in lblpt.cpp: m_Re = " << lpt().m_Re << " m_Re= " << lpt().m_Re << " m_Ma = " << lpt().m_Ma << "\n";
  const MFloat lptRe = Context::getSolverProperty<MFloat>("Re", lpt().solverId(), AT_);
 
  cout << "in lblpt.cpp lptRe = " << lptRe << "\n";
 
  // ASSERT(fabs(lptRe - lbSolver().m_Re) < MFloatEps, "LPT: " << lptRe << " LB " << lbSolver().m_Re);
  if(fabs(lptRe - lbSolver().m_Re) > MFloatEps) {
    cerr << "Warning: Re0 differs between lb- and LPT-solver!"
         << " lb " << lbSolver().m_Re << " LPT " << lptRe << endl;
  }
 
  // TODO:
  // ASSERT(lpt().a_timeStepComputationInterval() == fvSolver().a_timeStepComputationInterval(), "");
}

◆ cleanUp()

template<MInt nDim, MInt nDist, class SysEqn >

void LbLpt< nDim, nDist, SysEqn >::cleanUp ( )

inlineoverridevirtual

Reimplemented from CouplingParticle< nDim >.

Definition at line 69 of file lblpt.h.

69{};

◆ computeParticleInterphaseExchangeRate()

template<MInt nDim, MInt nDist, class SysEqn >

void LbLpt< nDim, nDist, SysEqn >::computeParticleInterphaseExchangeRate ( )

private

◆ finalizeBalance()

template<MInt nDim, MInt nDist, class SysEqn >

void LbLpt< nDim, nDist, SysEqn >::finalizeBalance ( const MInt id )

overridevirtual

Author: Tim Wegmann

Reimplemented from Coupling.

Definition at line 381 of file lblpt.cpp.

                                                              {
  TRACE();
 
  std::cout << "in finalize Balance" << std::endl;
  // post LPT solver
  if(id == lpt().solverId()) {
    lbSolver().resetExternalSources();
    if(globalTimeStep < 0) {
      // prepareAdaptation();
    }
 
  } else if(id == lbSolver().solverId()) {
    transferFlowField();
    transferCellStatus();
 
    updateLPTBndry();
  }
}

◆ finalizeCouplerInit()

template<MInt nDim, MInt nDist, class SysEqn >

void LbLpt< nDim, nDist, SysEqn >::finalizeCouplerInit

overridevirtual

Author: Julian Vorspohl j.vor.nosp@m.spoh.nosp@m.l@aia.nosp@m..rwt.nosp@m.h-aac.nosp@m.hen..nosp@m.de

Date: May 2021

Reimplemented from CouplingParticle< nDim >.

Definition at line 212 of file lblpt.cpp.

                                                     {
  TRACE();
 
  // Transfer the flow field after the intial condition for LB has been applied
  transferFlowField();
  transferCellStatus();
 
  initParticleVelocity();
 
  // TODO: check
  if(!lpt().m_restartFile && lbSolver().m_restartFile) {
    if(lpt().domainId() == 0) {
      cerr << "Restart without LPT restartFile -> setting time from Lb-time!" << endl;
    }
    const MFloat conversionTime = conversionLbLpt.length / conversionLbLpt.velocity;
    const MFloat LbTime = lbSolver().m_time;
    lpt().m_time = LbTime * conversionTime;
  }
 
  // set the timeStep in the LPT solver
  // at this point the timeStep must be enforced by the lb-solver
  transferTimeStep();
}

◆ finalizeSubCoupleInit()

template<MInt nDim, MInt nDist, class SysEqn >

void LbLpt< nDim, nDist, SysEqn >::finalizeSubCoupleInit ( MInt )

inlineoverridevirtual

Reimplemented from CouplingParticle< nDim >.

Definition at line 61 of file lblpt.h.

61{};

◆ init()

template<MInt nDim, MInt nDist, class SysEqn >

void LbLpt< nDim, nDist, SysEqn >::init

overridevirtual

Author: Julian Vorspohl j.vor.nosp@m.spoh.nosp@m.l@aia.nosp@m..rwt.nosp@m.h-aac.nosp@m.hen..nosp@m.de

Date: May 2021

Implements Coupling.

Definition at line 40 of file lblpt.cpp.

                                      {
  TRACE();
 
  m_lbSolverId = lbSolver().solverId();
  m_lptSolverId = lpt().solverId();
 
  readProperties();
 
  checkProperties();
 
  initConversion();
 
  calculateGridBoundaries();
}

◆ initConversion()

template<MInt nDim, MInt nDist, class SysEqn >

void LbLpt< nDim, nDist, SysEqn >::initConversion ( )

private

◆ initData()

template<MInt nDim, MInt nDist, class SysEqn >

void LbLpt< nDim, nDist, SysEqn >::initData ( )

private

◆ initParticleVelocity()

template<MInt nDim, MInt nDist, class SysEqn >

void LbLpt< nDim, nDist, SysEqn >::initParticleVelocity

private

Author: Tim Wegmann

Definition at line 186 of file lblpt.cpp.

                                                      {
  TRACE();
 
  // TODO: inital velocity for ellipsoids
  /* if(!lpt().m_restart) {
    for(MInt i = 0; i < (MInt)lpt().m_partListEllipsoid.size(); i++) {
      const MInt lptCellId = lpt().m_partListEllipsoid[i].m_cellId;
      const MInt fvCellId = lpt2fvIdParent(lptCellId);
      for(MInt j = 0; j < nDim; j++) {
        lpt().m_partListEllipsoid[i].m_velocity[j] =
            lpt().m_partListEllipsoid[i].m_velocity[j] + fvSolver().a_pvariable(fvCellId, j);
      }
    } */
 
  // 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();
  }
}

◆ lb2lptId()

template<MInt nDim, MInt nDist, class SysEqn >

MInt LbLpt< nDim, nDist, SysEqn >::lb2lptId ( const MInt lbId )

inlineprivate

Definition at line 110 of file lblpt.h.

110{ return convertId(lbSolver(), lpt(), lbId); };

convertId

MInt convertId(SolverA &solverA, SolverB &solverB, const MInt solverAId)

Conversion from solverA id to the solverB id on the same-level only!

Definition: couplingutils.h:21

◆ lb2lptIdParent()

template<MInt nDim, MInt nDist, class SysEqn >

MInt LbLpt< nDim, nDist, SysEqn >::lb2lptIdParent ( const MInt lbId )

inlineprivate

Definition at line 111 of file lblpt.h.

111{ return convertIdParent(lbSolver(), lpt(), lbId); };

convertIdParent

MInt convertIdParent(SolverA &solverA, SolverB &solverB, const MInt solverAId)

Conversion from solverA id to the solverB id If no cell on the same level is found,...

Definition: couplingutils.h:46

◆ lbBndCnd()

template<MInt nDim, MInt nDist, class SysEqn >

LbBndCnd & CouplingLB< nDim, nDist, SysEqn >::lbBndCnd ( const MInt id = 0 )

inlineprotected

Definition at line 461 of file coupling.h.

461{ return *lbSolver(id).m_bndCnd; }

LbSolverDxQy::m_bndCnd

LbBndCnd * m_bndCnd

Pointers for the Boundary Conditions, for flow solving.

Definition: lbsolverdxqy.h:332

◆ lbSolver()

template<MInt nDim, MInt nDist, class SysEqn >

solverType & CouplingLB< nDim, nDist, SysEqn >::lbSolver ( const MInt solverId = 0 ) const

inlineprotected

Definition at line 454 of file coupling.h.

                                                      {
    ASSERT(solverId < noSolvers(), "Invalid solverId " + std::to_string(solverId) + "/" + std::to_string(noSolvers()));
    return *m_lbSolvers[solverId];
  }

◆ lpt()

template<MInt nDim, MInt nDist, class SysEqn >

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

inlineoverrideprotectedvirtual

Reimplemented from CouplingParticle< nDim >.

Definition at line 43 of file lblpt.h.

43{ return *m_particle; }

◆ lpt2lbId()

template<MInt nDim, MInt nDist, class SysEqn >

MInt LbLpt< nDim, nDist, SysEqn >::lpt2lbId ( const MInt lptId )

inlineprivate

Definition at line 108 of file lblpt.h.

108{ return convertId(lpt(), lbSolver(), lptId); };

◆ lpt2lbIdParent()

template<MInt nDim, MInt nDist, class SysEqn >

MInt LbLpt< nDim, nDist, SysEqn >::lpt2lbIdParent ( const MInt lptId )

inlineprivate

Definition at line 109 of file lblpt.h.

109{ return convertIdParent(lpt(), lbSolver(), lptId); };

◆ postCouple()

template<MInt nDim, MInt nDist, class SysEqn >

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

overridevirtual

Author: Julian Vorspohl j.vor.nosp@m.spoh.nosp@m.l@aia.nosp@m..rwt.nosp@m.h-aac.nosp@m.hen..nosp@m.de, Johannes Grafen

Date: May 2021

Parameters

[in] recipeStep Current step in the execution recipe

POST LPT: Transfer coupling terms from LPT to LB POST LB : Transfer flow field from LB to LPT

Reimplemented from CouplingParticle< nDim >.

Definition at line 341 of file lblpt.cpp.

                                                           {
  TRACE();
 
  // recipe-order is switched for ellipsoids
  // if(lpt().m_ellipsoids) {
  //  recipeStep = recipeStep == 1 ? 0 : 1;
  //}
 
  // Post LPT (as the LPT-solver is called before the lb-solver!)
  if(recipeStep == m_lptSolverOrder) {
    updateLbSolver();
  }
 
  // POST LB
  MInt postLbStep = m_lptSolverOrder < m_noSolverSteps - 1 ? m_lptSolverOrder + 1 : m_lptSolverOrder - 1;
  if(recipeStep == postLbStep) {
    transferFlowField();
 
    transferCellStatus();
    transferTimeStep();
 
    // set particle velocity to fluid velocity in first timestep or in TimeStep in which desired velocitySkewness is
    // reached
    if((!(lpt().m_skewnessTimeStep == -1) && (globalTimeStep == 1 && lpt().m_skewnessTimeStep == 0))
       || (globalTimeStep == lpt().m_skewnessTimeStep)) {
      for(auto& part : lpt().m_partList) {
        for(MInt i = 0; i < nDim; i++) {
          MInt lbCellId = lpt2lbId(part.m_cellId);
          part.m_velocity[i] = part.m_oldVel[i] =
              lbSolver().a_variable(lbCellId, lbSolver().PV->VV[i]) * conversionLbLpt.velocity;
        }
      }
    }
  }
}

◆ preCouple()

template<MInt nDim, MInt nDist, class SysEqn >

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

overridevirtual

Author: Julian Vorspohl j.vor.nosp@m.spoh.nosp@m.l@aia.nosp@m..rwt.nosp@m.h-aac.nosp@m.hen..nosp@m.de

Date: May 2021

Parameters

[in] recipeStep

Reimplemented from CouplingParticle< nDim >.

Definition at line 302 of file lblpt.cpp.

                                                          {
  TRACE();
 
  // PRE LPT
  if(recipeStep == m_lptSolverOrder) {
    // TODO m_solutionStep = 0;
 
    // TODO:
    /* if(fvSolver().m_hasExternalSource) {
      if(!m_interLeafed) lbSolver().resetExternalSources();
    } */
    if(lbSolver().m_particleMomentumCoupling) lbSolver().resetExternalSources();
 
    // update LPT bndryCells for wall-collision
    updateLPTBndry();
  }
 
  // TODO: implement for interleaved
  /* if(m_interLeafed) {
      const MFloat conversionTime = conversionFvLpt.length / conversionFvLpt.velocity;
      const MFloat fvTime = fvSolver().m_levelSetMb ? fvSolver().m_physicalTime : fvSolver().m_time;
      if(fabs(fvTime * conversionTime - lpt().m_time) > MFloatEps) {
        cerr << "LPT-time " << lpt().m_time << " Fv-time " << fvTime << endl;
        mTerm(1, AT_, "Miss-matching time!");
      }
    } */
}

◆ readProperties()

template<MInt nDim, MInt nDist, class SysEqn >

void LbLpt< nDim, nDist, SysEqn >::readProperties ( )

privatevirtual

Reimplemented from CouplingParticle< nDim >.

◆ transferCellStatus()

template<MInt nDim, MInt nDist, class SysEqn >

void LbLpt< nDim, nDist, SysEqn >::transferCellStatus

private

Author: Tim Wegmann

Definition at line 828 of file lblpt.cpp.

                                                    {
  TRACE();
  for(MInt lptCellId = 0; lptCellId < lpt().a_noCells(); lptCellId++) {
    MInt lbCellId = lpt2lbIdParent(lptCellId);
    if(lbCellId < 0 || lbCellId > lbSolver().a_noCells()) {
      lpt().a_isValidCell(lptCellId) = false;
    } else if(!lbSolver().a_isActive(lbCellId)) {
      lpt().a_isValidCell(lptCellId) = false;
    } else {
      lpt().a_isValidCell(lptCellId) = true;
    }
  }
}

◆ transferFlowField()

template<MInt nDim, MInt nDist, class SysEqn >

void LbLpt< nDim, nDist, SysEqn >::transferFlowField

private

Author: Tim Wegmann, Daniel Lauwers

Transfer all flow variables from LB to LPT and apply the conversion

Author: Julian Vorspohl j.vor.nosp@m.spoh.nosp@m.l@aia.nosp@m..rwt.nosp@m.h-aac.nosp@m.hen..nosp@m.de

Date: May 2021

Definition at line 571 of file lblpt.cpp.

                                                   {
  TRACE();
#ifdef _OPENMP
#pragma omp parallel for
#endif
  for(MInt lbCellId = 0; lbCellId < lbSolver().noInternalCells(); lbCellId++) {
    if(!lbSolver().a_isActive(lbCellId)) {
      continue;
    }
 
    const MInt lptCellId = lb2lptId(lbCellId);
    if(lptCellId < 0) continue;
 
    for(MInt n = 0; n < nDim; n++) {
      lpt().a_fluidVelocity(lptCellId, n) =
          lbSolver().a_variable(lbCellId, lbSolver().PV->VV[n]) * conversionLbLpt.velocity;
    }
    lpt().a_fluidDensity(lptCellId) = conversionLbLpt.density * lbSolver().a_variable(lbCellId, lbSolver().PV->RHO);
 
    // Assume incompressible LB
    lpt().a_fluidPressure(lptCellId) =
        (lbSolver().a_variable(lbCellId, lbSolver().PV->RHO) - 1.0) * F1B3 * conversionLbLpt.pressure + 1.0;
    // TODO: @Julian reactivate for thermal
    /*lpt().a_fluidTemperature(lptCellId) = lbSolver().a_pvariable(lbCellId, lbSolver().PV->T)
     * conversionLbLpt.temperature;*/
  }
 
  // 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!
  lpt().exchangeData(&lpt().a_fluidVariable(0, 0), lpt().PV.noVars());
  if(lpt().m_evaporation) {
    lpt().exchangeData(&lpt().a_fluidSpecies(0), 1);
  }
 
  lpt().checkCells();
}

◆ transferTimeStep()

template<MInt nDim, MInt nDist, class SysEqn >

void LbLpt< nDim, nDist, SysEqn >::transferTimeStep

private

Author: Tim Wegmann

Definition at line 817 of file lblpt.cpp.

                                                  {
  TRACE();
 
  lpt().forceTimeStep(/*fvSolver().timeStep(true) */ conversionLbLpt.time);
}

◆ updateLbSolver()

template<MInt nDim, MInt nDist, class SysEqn >

void LbLpt< nDim, nDist, SysEqn >::updateLbSolver

private

Author: Tim Wegmann

Date: May 2021

Definition at line 406 of file lblpt.cpp.

                                                {
  TRACE();
 
  // transfer external Sources to LB-solver
  if(!lbSolver().isActive() || !lpt().m_momentumCoupling) return;
 
    // check if noInternalCells must be used
#ifdef _OPENMP
#pragma omp parallel for
#endif
  for(MInt lbCellId = 0; lbCellId < lbSolver().a_noCells(); lbCellId++) {
    if(!lbSolver().a_isActive(lbCellId)) continue;
    // check that externalForces is set to zeros
    for(MInt i = 0; i < nDim; i++)
      ASSERT(abs(lbSolver().a_externalForces(lbCellId, i)) < MFloatEps, "");
  }
 
  // TODO: interleaved
  /*
  const MInt lbMaxLevel = lbSolver().maxLevel();
  #ifdef _OPENMP
  #pragma omp parallel for
  #endif
    for(MInt lptCell = 0; lptCell < lpt().a_noCells(); lptCell++) {
      // TODO-timw: check lpt-exchange!  use below instead
      // for(MInt lptCell = 0; lptCell < lpt().noInternalCells(); lptCell++) {
      // the source term is only set on LPT leaf-cells
      if(!lpt().c_isLeafCell(lptCell)) continue;
      // TODO: always keep noParticles in cell up to date,
      //      so that cells without particles easily be skipped
      MInt lbCellId = lpt2lbId(lptCell);
      if(lbCellId > -1 && lbSolver().c_isLeafCell(lbCellId)) {
        const MInt lbLevel = lbSolver().a_level(lbCellId);
        const MFloat fLbCellVolume = FFPOW2(lbMaxLevel - lbLevel);
        // simple transfer
        for(MInt dir = 0; dir < nDim; dir++) {
          lbSolver().a_externalForces(lbCellId, dir) -=
              lpt().a_momentumFlux(lptCell, dir) * conversionLptLb.momentum * fLbCellVolume * m_factor;
          if(abs(lpt().a_momentumFlux(lptCell, dir)) > 1e-5)
            std::cerr << "lbforce " << lbSolver().a_externalForces(lbCellId, dir) << " conv " <<
  conversionLptLb.momentum
                      << " fLbCV " << fLbCellVolume << " flux " << lpt().a_momentumFlux(lptCell, dir) << std::endl;
        }
      }
    }
   */
 
#ifdef _OPENMP
#pragma omp parallel for
#endif
  for(MInt lptCellId = 0; lptCellId < lpt().a_noCells(); lptCellId++) {
    if(!lpt().c_isLeafCell(lptCellId)) continue;
    const MInt lbCellId = lpt2lbId(lptCellId);
    if(lbCellId < 0) continue;
    if(lbCellId > -1 && lbSolver().c_isLeafCell(lbCellId)) {
      for(MInt i = 0; i < nDim; i++) {
        // Think about different refinement levels of lb-cells and lpt-cells like in fvparticle.cpp ->
        // transferExternalSources()
        // obtain reaction force density related to cellvolume in lb-Units acting on fluid
        lbSolver().a_externalForces(lbCellId, i) -= lpt().a_momentumFlux(lptCellId, i) * conversionLptLb.momentum;
      }
    }
    // TODO different refinement of LPT an LB
  }
  lbSolver().exchangeExternalSources();
}

◆ updateLPTBndry()

template<MInt nDim, MInt nDist, class SysEqn >

void LbLpt< nDim, nDist, SysEqn >::updateLPTBndry

private

Author: Tim Wegmann, Julian Vorspohl j.vor.nosp@m.spoh.nosp@m.l@aia.nosp@m..rwt.nosp@m.h-aac.nosp@m.hen..nosp@m.de, Johannes Grafen

Date: Dec 2021

Definition at line 614 of file lblpt.cpp.

                                                {
  TRACE();
 
  if(!lpt().m_wallCollisions) return;
 
  if(!lpt().isActive()) return;
 
  MFloatScratchSpace bBox(2 * nDim, AT_, "bBox");
  lbSolver().m_geometry->getBoundingBox(bBox.getPointer());
 
  /*
  using Ld = LbLatticeDescriptor<nDim, nDist>;
  // just number of 2D distributions
  static constexpr MInt dist1 = Ld::distFld(0);
  static constexpr MInt maxDist1Idx = dist1; // for loops
  static constexpr MInt dist2 = Ld::distFld(1);
  static constexpr MInt maxDist2Idx = dist1 + dist2; // for loops
  */
  // Just once if no mesh adaptation during run
  for(MInt bndryId = lbSolver().m_noOuterBndryCells; bndryId < a_noBndCells(); bndryId++) {
    const MInt lbCellId = a_bndCellId(bndryId);
 
    if(!lbSolver().c_isLeafCell(lbCellId)) continue;
    MInt lptCellId = lb2lptId(lbCellId);
    if(lptCellId < 0) {
      lptCellId = lb2lptIdParent(lbCellId);
      if(lptCellId < 0) continue;
      if(lpt().c_level(lptCellId) < lpt().maxRefinementLevel()) continue;
      ASSERT(m_lptlbInterpolation, "");
    }
 
    if(!lpt().c_isLeafCell(lptCellId)) {
      ASSERT(m_lptlbInterpolation, "");
    }
 
    const MInt noSurf = 1; // lbSolver().m_bndCnd->m_bndCells->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!");
 
    MFloatScratchSpace surfaceC(nDim, nDim + 1, AT_, "surfaceC");
    std::array<MFloat, nDim> surfaceN;
    std::array<MFloat, nDim> surfaceV;
    std::array<MFloat, nDim + 1> bndryData;
 
    // TODO: check correctness of addbndryCellMethod before reusing!
    /* if(m_CalcSurface) {
      const MFloat dx = lbSolver().c_cellLengthAtCell(lbCellId);
      std::vector<const MFloat*> cellWallNormals; // store all Wall normals
      std::vector<const MFloat*>
          cellPlaneCoordinateVec; // 2D Distribution from cell center to point in the middle of an surface edge
      const MFloat* SCdist{};
      MInt wallCount = 0;
      std::array<MBool, nDim> gridBoxDifference{};
 
      for(MInt i = 0; i < nDim; i++) {
        bndryData.at(1 + i) = lbSolver().a_coordinate(lbCellId, i);
      }
 
      for(MInt j = 0; j < maxDist1Idx; j++) {
        if(lbSolver().a_hasNeighbor(lbCellId, j) == 0) {
          SCdist = Ld::ppdfDir(j); // only for 1D, dist from cell center to SC
          cellWallNormals.push_back(Ld::ppdfDir(Ld::oppositeDist(j)));
          wallCount++;
        }
      }
 
      // compute surface normals out of cellWallNormals, should be independent from number of distributions
      for(MInt n = 0; n < nDim; n++) {
        surfaceV.at(n) = 0; // for simple simulation not needed, can be set to zero;
        for(size_t a = 0; a < cellWallNormals.size(); a++)
          surfaceN.at(n) += cellWallNormals.at(a)[n]; // Assuming wallnormals have just one vec component unequal 0
      }
      maia::math::normalize(surfaceN);
 
      switch(wallCount) {
        case 0:
          std::cerr << "Something went wrong, " << lbCellId << " is not a boundaryCell" << std::endl;
          break;
 
        case 1:
          // set bndry-cell volume:
          bndryData.at(0) = POW3(dx);
          // Iterate over 2D distributions
          for(MInt j = maxDist1Idx; j < maxDist2Idx; j++) {
            for(MInt n = 0; n < nDim; n++) {
              // Check for -1 * -1 or 1 * 1; -1 * 1 should not pass since SCdist[n] and ppdf(j,n) are not equal.
              if(SCdist[n] * Ld::ppdfDir(j, n) + MFloatEps > 1.0) {
                cellPlaneCoordinateVec.push_back(Ld::ppdfDir(j));
                if(cellPlaneCoordinateVec.size() == 3) break; // only 3 points are needed
              }
            }
          }
 
          for(MInt n = 0; n < nDim; n++) {
            gridBoxDifference.at(n) = false;
            surfaceC.at(0).at(n) = bndryData.at(1 + n) - surfaceN.at(n) * dx / 2;
            if(surfaceN.at(n) > 0.0) {
              if(bBox[n] > m_gridBoundaries[2 * n]) {
                surfaceC.at(0).at(n) = bBox[n];
                gridBoxDifference.at(n) = true;
              }
            } else if(surfaceN.at(n) < 0.0) {
              if(bBox[n + nDim] < m_gridBoundaries[2 * n + 1]) {
                surfaceC.at(0).at(n) = bBox[n + nDim];
                gridBoxDifference.at(n) = true;
              }
            }
          }
          break;
 
        case 2:
          // set bndry-cell volume:
          bndryData.at(0) = POW3(dx) / 2;
          // Iterate over 1D and 2D distributions
          for(MInt j = 0; j < maxDist2Idx; j++) {
            std::array<MFloat, nDim> tmpDist{};
            for(MInt n = 0; n < nDim; n++) {
              tmpDist[n] = Ld::ppdfDir(j, n);
            }
            // search for 1D and 2D distributions that are perpendicular to surface normal vector
            if(abs(std::inner_product(surfaceN.cbegin(), surfaceN.cend(), tmpDist.cbegin(), 0.0)) < MFloatEps)
              cellPlaneCoordinateVec.push_back(Ld::ppdfDir(j));
            if(cellPlaneCoordinateVec.size() == 3) break;
          }
 
          for(MInt n = 0; n < nDim; n++) {
            surfaceC.at(0).at(n) = bndryData.at(1 + n);
          }
          break;
 
        case 3:
          // set bndry-cell volume:
          bndryData.at(0) = POW3(dx) * (1.0 - 0.25 * (0.5 * SQRT3 - sqrt(3 - SQRT6)));
          // Iterate over 1D distributions
          for(MInt j = 0; j < maxDist1Idx; j++) {
            std::array<MFloat, nDim> tmpDist{};
            for(MInt n = 0; n < nDim; n++) {
              tmpDist[n] = Ld::ppdfDir(j, n);
            }
            // search for 1D distributions that are pointing in opposite halfspace of surface normal -> va * vb = abs(a)
            // * abs(b) * cos(phi) < 0 -> yes
            if(std::inner_product(surfaceN.cbegin(), surfaceN.cend(), tmpDist.cbegin(), 0.0) < MFloatEps)
              cellPlaneCoordinateVec.push_back(Ld::ppdfDir(j));
            if(cellPlaneCoordinateVec.size() == 3) break;
          }
 
          for(MInt n = 0; n < nDim; n++) {
            surfaceC.at(0).at(n) = bndryData.at(1 + n) - surfaceN.at(n) * sqrt(3 - SQRT6) * dx; //? check
          }
          break;
 
        default:
          std::cerr << "No implementation for cells with more than 3 bounding walls!" << std::endl;
          break;
      }
 
      // find 3 Distributions to get 3 points on surface edges
      MFloat dL = 0.0;
      // loop over coordinate x,y,z
      for(MInt i = 0; i < nDim; i++) {
        if(gridBoxDifference.at(i))
          dL = bndryData.at(1 + i) - surfaceC.at(0).at(i);
        else
          dL = dx / 2;
        // loop over surface point 1,2,3
        for(MInt n = 0; n < nDim; n++) {
          surfaceC.at(1 + n).at(i) = bndryData.at(1 + i) + cellPlaneCoordinateVec.at(n)[i] * dL;
        }
      } */
    // Printing boundary surface information :
    /* std::cout << "lbcellId: " << lbCellId << std::endl
              << "lptcellId: " << lptCellId << std::endl
              << "wallCount: " << wallCount << std::endl
              << "bndrycell Volume: " << bndryData.at(0) << std::endl;
    for(MInt i = 0; i < nDim; i++) std::cout << "bndryData[" << bndryId << "].m_coordinates "<< i << ": " <<
    bndryData.at(1 + i) << std::endl; for(MInt i = 0; i < nDim; i++) std::cout << "surfaceN[ " << i << "] normalized:
    " << surfaceN.at(i) << std::endl; for(MInt i = 0; i < nDim; i++) std::cout << "surfaceC[0][" << i << "]: " <<
    surfaceC.at(0).at(i) << std::endl;
 
    for(MInt i = 0; i < nDim; i++)
      for(MInt n = 0; n <nDim; n++)
        std::cout << "cellPlaneCoordinateVec[" << i <<"]["<<n<<"]: " << cellPlaneCoordinateVec.at(i)[n] << std::endl;
    for(MInt i = 0; i < nDim; i++)
      for(MInt n = 0; n <nDim; n++)
        std::cout << "surfaceC[" << 1 + i << "]["<< n << "]: " <<  surfaceC.at(1 + i).at(n) << std::endl;
     */
 
    // clear all temporary vectors
    /* cellWallNormals.clear();
    cellPlaneCoordinateVec.clear();
  } */
    // append new LPT bndryCell based on LB data
    lpt().addBndryCell(lptCellId, &bndryData[0], &surfaceN[0], surfaceC, &surfaceV[0]);
  }
}

Member Data Documentation

◆ conversionLbLpt

template<MInt nDim, MInt nDist, class SysEqn >

ConversionFactor& LbLpt< nDim, nDist, SysEqn >::conversionLbLpt = BaseLptX::conversionFlowLpt

protected

Definition at line 55 of file lblpt.h.

◆ conversionLptLb

template<MInt nDim, MInt nDist, class SysEqn >

ConversionFactor& LbLpt< nDim, nDist, SysEqn >::conversionLptLb = BaseLptX::conversionLptFlow

protected

Definition at line 56 of file lblpt.h.

◆ m_CalcSurface

template<MInt nDim, MInt nDist, class SysEqn >

MBool LbLpt< nDim, nDist, SysEqn >::m_CalcSurface = false

private

Definition at line 125 of file lblpt.h.

◆ m_forceLbTimeStep

template<MInt nDim, MInt nDist, class SysEqn >

MBool LbLpt< nDim, nDist, SysEqn >::m_forceLbTimeStep = true

private

Definition at line 124 of file lblpt.h.

◆ m_gridBoundaries

template<MInt nDim, MInt nDist, class SysEqn >

std::array<MFloat, 2 * nDim> LbLpt< nDim, nDist, SysEqn >::m_gridBoundaries {}

private

Definition at line 120 of file lblpt.h.

◆ m_lbSolver

template<MInt nDim, MInt nDist, class SysEqn >

LbSolver* LbLpt< nDim, nDist, SysEqn >::m_lbSolver = nullptr

private

Definition at line 114 of file lblpt.h.

◆ m_lbSolverId

template<MInt nDim, MInt nDist, class SysEqn >

MInt LbLpt< nDim, nDist, SysEqn >::m_lbSolverId {}

private

Definition at line 117 of file lblpt.h.

◆ m_lptlbInterpolation

template<MInt nDim, MInt nDist, class SysEqn >

MBool LbLpt< nDim, nDist, SysEqn >::m_lptlbInterpolation = false

private

Definition at line 123 of file lblpt.h.

◆ m_lptSolverId

template<MInt nDim, MInt nDist, class SysEqn >

MInt LbLpt< nDim, nDist, SysEqn >::m_lptSolverId {}

private

Definition at line 116 of file lblpt.h.

◆ m_lptSolverOrder

template<MInt nDim, MInt nDist, class SysEqn >

MInt LbLpt< nDim, nDist, SysEqn >::m_lptSolverOrder {}

private

Definition at line 118 of file lblpt.h.

◆ m_noSolverSteps

template<MInt nDim, MInt nDist, class SysEqn >

MInt LbLpt< nDim, nDist, SysEqn >::m_noSolverSteps {}

private

Definition at line 119 of file lblpt.h.

◆ m_particle

template<MInt nDim, MInt nDist, class SysEqn >

LPT<nDim>* LbLpt< nDim, nDist, SysEqn >::m_particle = nullptr

private

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

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ BaseLb

◆ BaseLpt

◆ BaseLptX

◆ LbSolver

◆ LptSolver

Constructor & Destructor Documentation

◆ LbLpt()

Member Function Documentation

◆ a_bndCellId()

◆ a_cellLengthAtLevel()

◆ a_lbCellCoordinate()

◆ a_lbVariable()

◆ a_Ma()

◆ a_noBndCells()

◆ a_noCells()

◆ balancePre()

◆ calculateGridBoundaries()

◆ checkProperties()

◆ cleanUp()

◆ computeParticleInterphaseExchangeRate()

◆ finalizeBalance()

◆ finalizeCouplerInit()

◆ finalizeSubCoupleInit()

◆ init()

◆ initConversion()

◆ initData()

◆ initParticleVelocity()

◆ lb2lptId()

◆ lb2lptIdParent()

◆ lbBndCnd()

◆ lbSolver()

◆ lpt()

◆ lpt2lbId()

◆ lpt2lbIdParent()

◆ postCouple()

◆ preCouple()

◆ readProperties()

◆ transferCellStatus()

◆ transferFlowField()

◆ transferTimeStep()

◆ updateLbSolver()

◆ updateLPTBndry()

Member Data Documentation

◆ conversionLbLpt

◆ conversionLptLb

◆ m_CalcSurface

◆ m_forceLbTimeStep

◆ m_gridBoundaries

◆ m_lbSolver

◆ m_lbSolverId

◆ m_lptlbInterpolation

◆ m_lptSolverId

◆ m_lptSolverOrder

◆ m_noSolverSteps

◆ m_particle