#include <couplerlbfveemultiphase.h>

Inheritance diagram for CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >:

Collaboration diagram for CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >:

Public Types
using	LbSolver = LbSolverDxQy< nDim, nDist, SysEqnLb >

using	FvCartesianSolver = FvCartesianSolverXD< nDim, SysEqnFv >

using	Cell = typename maia::grid::tree::Tree< nDim >::Cell

Public Types inherited from CouplerLbFv< nDim, nDist, SysEqnLb, SysEqnFv >
using	LbSolver = LbSolverDxQy< nDim, nDist, SysEqnLb >

using	FvCartesianSolver = FvCartesianSolverXD< nDim, SysEqnFv >

using	BaseLb = CouplingLB< nDim, nDist, SysEqnLb >

using	BaseFv = CouplingFv< nDim, SysEqnFv >

using	Cell = typename maia::grid::tree::Tree< nDim >::Cell

Public Types inherited from CouplingFv< nDim, SysEqnFv >
using	solverType = FvCartesianSolverXD< nDim, SysEqnFv >

Public Types inherited from CouplingLB< nDim, nDist, SysEqnLb >
using	solverType = LbSolverDxQy< nDim, nDist, SysEqnLb >

using	LbBndCnd = LbBndCndDxQy< nDim, nDist, SysEqnLb >

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

Public Member Functions
	CouplerLbFvEEMultiphase (const MInt couplerId, LbSolver lb, FvCartesianSolver fv)

void	initDepthcorrection ()

void	correctInvalidAlpha ()
	find cells with invalid alpha values and redistribute mass from/to neighboring cells to raise/lower alpha value More...

std::vector< MInt >	findRedistCells (const MInt cellId, const MBool searchUp, const MFloat limit)
	find neighbor Cells to cellId, that are candidates for alpha corrections More...

void	transferPressureLb2Fv (const MFloat rkAlpha, const MBool update)

template<MBool updateGradients>
void	transferULb2Fv (const MFloat rkAlpha)

void	transferUFv2Lb ()

void	transferNuLb2Fv (const MFloat rkAlpha)

void	transferAlphaFv2Lb ()

void	preCouple (MInt) override

void	postcouple (MInt)

void	subCouple (MInt, MInt, std::vector< MBool > &solverCompleted) override

void	finalizeCouplerInit () override

void	finalizeSubCoupleInit (MInt) override

void	init () override

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

void	balancePost () override

void	revertLb ()

void	revertFv ()

Public Member Functions inherited from CouplerLbFv< nDim, nDist, SysEqnLb, SysEqnFv >
	CouplerLbFv (const MInt couplingId, LbSolver lb, FvCartesianSolver fv)

virtual void	init ()

virtual void	initConversionFactors ()

void	postCouple (MInt)

virtual void	finalizeCouplerInit ()

virtual void	finalizeSubCoupleInit (MInt)

virtual void	subCouple (MInt, MInt, std::vector< MBool > &)

virtual void	checkProperties ()

virtual void	readProperties ()

MInt	fv2lbId (const MInt fvId) const

MInt	lb2fvId (const MInt lbId) const

void	testCoupling ()

MInt	a_fvSolverId () const

MInt	a_lbSolverId () const

Public Member Functions inherited from CouplingFv< nDim, SysEqnFv >
	CouplingFv (const MInt couplingId, std::vector< FvCartesianSolverXD< nDim, SysEqnFv > * > fvSolvers, const MInt noSolvers)

	CouplingFv (const MInt couplingId, Solver *solvers)

	CouplingFv (const CouplingFv &)=delete

	~CouplingFv () override=default

CouplingFv &	operator= (const CouplingFv &)=delete

Public Member Functions inherited from Coupling
	Coupling (const MInt couplingId)

virtual	~Coupling ()=default

	Coupling (const Coupling &)=delete

Coupling &	operator= (const Coupling &)=delete

MInt	couplerId () const

virtual void	init ()=0

virtual void	finalizeSubCoupleInit (MInt solverId)=0

virtual void	finalizeCouplerInit ()=0

virtual void	preCouple (MInt recipeStep)=0

virtual void	subCouple (MInt recipeStep, MInt solverId, std::vector< MBool > &solverCompleted)=0

virtual void	postCouple (MInt recipeStep)=0

virtual void	cleanUp ()=0

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

virtual void	balancePost ()

virtual void	reinitAfterBalance ()

virtual void	prepareAdaptation ()

virtual void	postAdaptation ()

virtual void	finalizeAdaptation (const MInt)

virtual void	writeRestartFile (const MInt)

virtual MInt	noCellDataDlb () const
	Methods to inquire coupler data during balancing. More...

virtual MInt	cellDataTypeDlb (const MInt NotUsed(dataId)) const

virtual MInt	cellDataSizeDlb (const MInt NotUsed(dataId), const MInt NotUsed(cellId))

virtual void	getCellDataDlb (const MInt NotUsed(dataId), const MInt NotUsed(oldNoCells), const MInt const NotUsed(bufferIdToCellId), MInt const NotUsed(data))

virtual void	getCellDataDlb (const MInt NotUsed(dataId), const MInt NotUsed(oldNoCells), const MInt const NotUsed(bufferIdToCellId), MLong const NotUsed(data))

virtual void	getCellDataDlb (const MInt NotUsed(dataId), const MInt NotUsed(oldNoCells), const MInt const NotUsed(bufferIdToCellId), MFloat const NotUsed(data))

virtual void	setCellDataDlb (const MInt NotUsed(dataId), const MInt *const NotUsed(data))

virtual void	setCellDataDlb (const MInt NotUsed(dataId), const MLong *const NotUsed(data))

virtual void	setCellDataDlb (const MInt NotUsed(dataId), const MFloat *const NotUsed(data))

virtual void	finalizeBalance (const MInt)

virtual MInt	noCouplingTimers (const MBool NotUsed(allTimings)) const
	Number of coupling timers. More...

virtual void	getCouplingTimings (std::vector< std::pair< MString, MFloat > > &NotUsed(timings), const MBool NotUsed(allTimings))
	Return coupling timings. More...

virtual void	getDomainDecompositionInformation (std::vector< std::pair< MString, MInt > > &NotUsed(domainInfo))
	Return information on current domain decomposition (e.g. number of coupled cells/elements/...) More...

void	setDlbTimer (const MInt timerId)

void	startLoadTimer (const MString &name) const
	Start the load timer of the coupler. More...

void	stopLoadTimer (const MString &name) const
	Stop the load timer of the coupler. More...

Public Member Functions inherited from CouplingLB< nDim, nDist, SysEqnLb >
	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)

Public Attributes
MInt	m_alphaConvergenceCheck {}

MInt	m_maxNoAlphaIterations {}

MFloat	m_epsAlpha {}

MInt	m_initAlphaMethod {}

MFloat	m_initialAlpha {}

MFloat	m_alphaInf {}

MBool	m_redistributeAlpha {}

MBool	m_disableSubstepAlphaRedist {}

std::array< MFloat, nDim >	m_gravityRefCoords {}

MFloat *	m_depthCorrectionValues = nullptr

std::array< MFloat, nDim >	m_depthCorrectionCoefficients {}

MBool	m_updateAfterPropagation {}

MFloat	m_interpolationFactor {}

MBool	m_updateFVBC {}

MFloat	m_alphaCeil {}

MFloat	m_alphaFloor {}

Public Attributes inherited from CouplerLbFv< nDim, nDist, SysEqnLb, SysEqnFv >
ConversionFactors	conversionLbFv

ConversionFactors	conversionFvLb

Private Types
using	Base = CouplerLbFv< nDim, nDist, SysEqnLb, SysEqnFv >

Private Member Functions
void	initData ()

void	initAlpha ()

void	readProperties ()

void	cleanUp () override

void	revertLbVariables ()

void	revertLbDistributions ()

void	revertLbOldVariables ()

void	revertFvVariables ()

MBool	checkAlphaConverged ()

MInt	a_fvSolverId () const

MInt	a_lbSolverId () const

MInt	fv2lbId (const MInt fvId) const

MInt	lb2fvId (const MInt lbId) const

Private Attributes
ConversionFactors	conversionFvLb

ConversionFactors	conversionLbFv

Additional Inherited Members
Protected Member Functions inherited from CouplingFv< nDim, SysEqnFv >
MInt	noSolvers () const

solverType &	fvSolver (const MInt solverId=0) const

MInt	a_noFvCells () const

MInt	a_noFvGridCells () const

Protected Member Functions inherited from Coupling
MFloat	returnLoadRecord () const

MFloat	returnIdleRecord () const

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

solverType &	lbSolver (const MInt solverId=0) const

LbBndCnd &	lbBndCnd (const MInt id=0)

Protected Attributes inherited from CouplingFv< nDim, SysEqnFv >
std::vector< solverType * >	m_fvSolvers

Detailed Description

template<MInt nDim, MInt nDist, class SysEqnLb, class SysEqnFv>
class CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >

Definition at line 38 of file couplerlbfveemultiphase.h.

Member Typedef Documentation

◆ Base

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

using CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::Base = CouplerLbFv<nDim, nDist, SysEqnLb, SysEqnFv>

private

Definition at line 51 of file couplerlbfveemultiphase.h.

◆ Cell

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

using CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::Cell = typename maia::grid::tree::Tree<nDim>::Cell

Definition at line 69 of file couplerlbfveemultiphase.h.

◆ FvCartesianSolver

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

using CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::FvCartesianSolver = FvCartesianSolverXD<nDim, SysEqnFv>

Definition at line 68 of file couplerlbfveemultiphase.h.

◆ LbSolver

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

using CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::LbSolver = LbSolverDxQy<nDim, nDist, SysEqnLb>

Definition at line 67 of file couplerlbfveemultiphase.h.

Constructor & Destructor Documentation

◆ CouplerLbFvEEMultiphase()

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::CouplerLbFvEEMultiphase	(	const MInt	couplerId,
		LbSolver *	lb,
		FvCartesianSolver *	fv
	)

Definition at line 16 of file couplerlbfveemultiphase.cpp.

  : Coupling(couplerId), CouplerLbFv<nDim, nDist, SysEqnLb, SysEqnFv>(couplerId, lb, fv) {
  initData();
  readProperties();
  initAlpha();
}

Member Function Documentation

◆ a_fvSolverId()

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

MInt CouplerLbFv< nDim, nDist, SysEqnLb, SysEqnFv >::a_fvSolverId ( ) const

inlineprivate

Definition at line 120 of file couplerlbfv.h.

120{ return m_fvSolverId; }

CouplerLbFv::m_fvSolverId

MInt m_fvSolverId

Definition: couplerlbfv.h:66

◆ a_lbSolverId()

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

MInt CouplerLbFv< nDim, nDist, SysEqnLb, SysEqnFv >::a_lbSolverId ( ) const

inlineprivate

Definition at line 121 of file couplerlbfv.h.

121{ return m_lbSolverId; }

CouplerLbFv::m_lbSolverId

MInt m_lbSolverId

Definition: couplerlbfv.h:65

◆ balancePost()

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

void CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::balancePost ( )

inlineoverridevirtual

Reimplemented from Coupling.

Definition at line 90 of file couplerlbfveemultiphase.h.

90{};

◆ balancePre()

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

void CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::balancePre

overridevirtual

Reimplemented from Coupling.

Definition at line 50 of file couplerlbfveemultiphase.cpp.

                                                                          {
  if(!fvSolver().m_EEGas.depthCorrection) {
    TERMM(1, "not implemented for in-coupler depthCorrection!");
  }
}

◆ checkAlphaConverged()

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

MBool CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::checkAlphaConverged

private

Definition at line 668 of file couplerlbfveemultiphase.cpp.

                                                                                    {
  MBool converged = false;
  switch(m_alphaConvergenceCheck) {
    case 0:
      converged = true;
      break;
 
    case 1:
      converged = true;
      for(MInt cellId = 0; cellId < a_noFvCells(); cellId++) {
        if(fv2lbId(cellId) < 0) continue;
        if(m_epsAlpha < std::abs(fvSolver().a_alphaGas(cellId) - lbSolver().a_alphaGas(fv2lbId(cellId)))) {
          converged = false;
          break;
        }
      }
      MPI_Allreduce(MPI_IN_PLACE, &converged, 1, maia::type_traits<MBool>::mpiType(), MPI_LAND, fvSolver().mpiComm(),
                    AT_, "MPI_IN_PLACE", "converged");
      break;
 
    default:
      mTerm(1, AT_, "not a valid alphaConvergenceCheck!");
      break;
  }
  return converged;
}

◆ cleanUp()

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

void CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::cleanUp ( )

inlineoverrideprivatevirtual

Reimplemented from CouplerLbFv< nDim, nDist, SysEqnLb, SysEqnFv >.

Definition at line 43 of file couplerlbfveemultiphase.h.

43{};

◆ correctInvalidAlpha()

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

void CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::correctInvalidAlpha

Author: Daniel Lauwers

Date: 2020-11-30

Definition at line 701 of file couplerlbfveemultiphase.cpp.

                                                                                   {
  const MInt noCVars = fvSolver().CV->noVariables;
 
  fvSolver().computePV();
  fvSolver().exchange();
 
  // Request conservative variables of halo cells
  // modified from smallcellcorrection()
  {
    MIntScratchSpace sendBufferCnts(mMax(1, fvSolver().noNeighborDomains()), AT_, "sendBufferCnts");
    MIntScratchSpace recvBufferCnts(mMax(1, fvSolver().noNeighborDomains()), AT_, "recvBufferCnts");
    ScratchSpace<MPI_Request> sendReq(mMax(1, fvSolver().noNeighborDomains()), AT_, "sendReq");
    ScratchSpace<MPI_Request> recvReq(mMax(1, fvSolver().noNeighborDomains()), AT_, "recvReq");
    sendReq.fill(MPI_REQUEST_NULL);
    recvReq.fill(MPI_REQUEST_NULL);
    sendBufferCnts.fill(0);
    recvBufferCnts.fill(0);
    for(MInt i = 0; i < fvSolver().noNeighborDomains(); i++) {
      sendBufferCnts(i) = noCVars * fvSolver().m_noMaxLevelWindowCells[i];
      recvBufferCnts(i) = noCVars * fvSolver().m_noMaxLevelHaloCells[i];
      MInt sendBufferCounter = 0;
      for(MInt j = 0; j < fvSolver().m_noMaxLevelWindowCells[i]; j++) {
        MInt cellId = fvSolver().m_maxLevelWindowCells[i][j];
        for(MInt v = 0; v < noCVars; v++) {
          fvSolver().m_sendBuffers[i][sendBufferCounter] = fvSolver().a_variable(cellId, v);
          sendBufferCounter++;
        }
      }
    }
    MInt sendCnt = 0;
    MInt recvCnt = 0;
    if(fvSolver().m_nonBlockingComm) {
      for(MInt i = 0; i < fvSolver().noNeighborDomains(); i++) {
        if(sendBufferCnts(i) == 0) continue;
        ASSERT(sendBufferCnts(i) <= fvSolver().m_noMaxLevelWindowCells[i] * fvSolver().m_dataBlockSize, "");
        MPI_Isend(fvSolver().m_sendBuffers[i], sendBufferCnts(i), MPI_DOUBLE, fvSolver().neighborDomain(i), 12,
                  fvSolver().mpiComm(), &sendReq[sendCnt], AT_, "m_sendBuffers[" + std::to_string(i) + "],0");
        sendCnt++;
      }
      for(MInt i = 0; i < fvSolver().noNeighborDomains(); i++) {
        if(recvBufferCnts(i) == 0) continue;
        ASSERT(recvBufferCnts(i) <= fvSolver().m_noMaxLevelHaloCells[i] * fvSolver().m_dataBlockSize, "");
        MPI_Irecv(fvSolver().m_receiveBuffers[i], recvBufferCnts(i), MPI_DOUBLE, fvSolver().neighborDomain(i), 12,
                  fvSolver().mpiComm(), &recvReq[recvCnt], AT_, "m_receiveBuffers[" + std::to_string(i) + "],0");
        recvCnt++;
      }
      if(recvCnt > 0) MPI_Waitall(recvCnt, &recvReq[0], MPI_STATUSES_IGNORE, AT_);
    } else {
      for(MInt i = 0; i < fvSolver().noNeighborDomains(); i++) {
        if(sendBufferCnts(i) == 0) continue;
        ASSERT(sendBufferCnts(i) <= fvSolver().m_noMaxLevelWindowCells[i] * fvSolver().m_dataBlockSize, "");
        MPI_Issend(fvSolver().m_sendBuffers[i], sendBufferCnts(i), MPI_DOUBLE, fvSolver().neighborDomain(i), 12,
                   fvSolver().mpiComm(), &sendReq[sendCnt], AT_, "m_sendBuffers[" + std::to_string(i) + "],0");
        sendCnt++;
      }
      for(MInt i = 0; i < fvSolver().noNeighborDomains(); i++) {
        if(recvBufferCnts(i) == 0) continue;
        ASSERT(recvBufferCnts(i) <= fvSolver().m_noMaxLevelHaloCells[i] * fvSolver().m_dataBlockSize, "");
        MPI_Recv(fvSolver().m_receiveBuffers[i], recvBufferCnts(i), MPI_DOUBLE, fvSolver().neighborDomain(i), 12,
                 fvSolver().mpiComm(), MPI_STATUS_IGNORE, AT_, "m_receiveBuffers[" + std::to_string(i) + "],0");
        recvCnt++;
      }
    }
    for(MInt i = 0; i < fvSolver().noNeighborDomains(); i++) {
      MInt recvBufferCounter = 0;
      for(MInt j = 0; j < fvSolver().m_noMaxLevelHaloCells[i]; j++) {
        MInt cellId = fvSolver().m_maxLevelHaloCells[i][j];
        for(MInt v = 0; v < noCVars; v++) {
          fvSolver().a_variable(cellId, v) = fvSolver().m_receiveBuffers[i][recvBufferCounter];
          recvBufferCounter++;
        }
      }
    }
    if(sendCnt > 0) MPI_Waitall(sendCnt, &sendReq[0], MPI_STATUSES_IGNORE, AT_);
  }
 
  // find cells with invalid alpha values and redistribute mass and momentum from/to them
  // TODO labels:COUPLER,toenhance replace struct by std::vector or something else
  struct transferCV {
    MFloat rhoAlpha;
    MFloat rhoUAlpha;
    MFloat rhoVAlpha;
    MFloat rhoWAlpha;
  };
  constexpr MInt noTransferCV = 4;
  std::map<MInt, transferCV>
      haloCorrections; // save which Halo cells are altered to communicate the changes to their domains
  for(MInt cellId = 0; cellId < fvSolver().m_bndryGhostCellsOffset; cellId++) {
    if(fvSolver().a_isHalo(cellId)) continue;
    if(!fvSolver().c_isLeafCell(cellId)) continue;
 
    const MFloat origAlpha = fvSolver().a_pvariable(cellId, fvSolver().PV->A);
 
    if(origAlpha < (m_alphaFloor - 1.0e-8)) {
      const MFloat origMass = fvSolver().a_variable(cellId, fvSolver().CV->A_RHO) * fvSolver().a_cellVolume(cellId);
      const MFloat deltaMass = 0.0 - origMass;
      const std::vector<MInt> neighbors = findRedistCells(cellId, true, 0.0);
      std::vector<MInt> redistNeighbors = neighbors;
      MInt noRedistNbs = 0;
      MFloat massNeedPerCell = 0.0;
      while(true) {
        MBool change = false;
        noRedistNbs = redistNeighbors.size();
        massNeedPerCell = deltaMass / noRedistNbs;
        for(auto it = redistNeighbors.begin(); it != redistNeighbors.end(); ++it) {
          const MInt candidateId = *it;
          if(fvSolver().a_variable(candidateId, fvSolver().CV->A_RHO) * fvSolver().a_cellVolume(candidateId)
             < massNeedPerCell) {
            change = true;
            redistNeighbors.erase(it);
            break;
          }
        }
        if(change) continue;
        break;
      }
      MFloat momentumTransfer[3] = {0.0, 0.0, 0.0};
      if(!redistNeighbors.empty()) {
        for(auto redistId : redistNeighbors) {
          const MFloat delRho = massNeedPerCell / fvSolver().a_cellVolume(redistId);
          const MFloat delRhoVV[3] = {delRho * fvSolver().a_pvariable(redistId, fvSolver().PV->VV[0]),
                                      delRho * fvSolver().a_pvariable(redistId, fvSolver().PV->VV[1]),
                                      delRho * fvSolver().a_pvariable(redistId, fvSolver().PV->VV[2])};
          fvSolver().a_variable(redistId, fvSolver().CV->A_RHO) -= delRho;
          for(MInt dir = 0; dir < 3; dir++) {
            fvSolver().a_variable(redistId, fvSolver().CV->A_RHO_VV[dir]) -= delRhoVV[dir];
            momentumTransfer[dir] += delRhoVV[dir] * fvSolver().a_cellVolume(redistId);
          }
          fvSolver().setPrimitiveVariables(redistId);
 
          if(fvSolver().a_isHalo(redistId)) {
            const transferCV delCV = {
                -delRho,
                -delRhoVV[0],
                -delRhoVV[1],
                -delRhoVV[2],
            };
            auto success = haloCorrections.insert(std::pair<MInt, transferCV>(redistId, delCV));
            if(!success.second) { // redistId already in map
              success.first->second.rhoAlpha += delCV.rhoAlpha;
              success.first->second.rhoUAlpha += delCV.rhoUAlpha;
              success.first->second.rhoVAlpha += delCV.rhoVAlpha;
              success.first->second.rhoWAlpha += delCV.rhoWAlpha;
            }
          }
        }
        fvSolver().a_variable(cellId, fvSolver().CV->A_RHO) +=
            massNeedPerCell * noRedistNbs / fvSolver().a_cellVolume(cellId);
        for(MInt dir = 0; dir < 3; dir++) {
          fvSolver().a_variable(cellId, fvSolver().CV->A_RHO_VV[dir]) +=
              momentumTransfer[dir] / fvSolver().a_cellVolume(cellId);
        }
        fvSolver().setPrimitiveVariables(cellId);
      } else {
        // if there is not enough mass in any cell to get the negative cell to 0, take as much, as you can from cells
        redistNeighbors = neighbors;
 
        MFloat massTransfer = 0.0;
        for(auto redistId : redistNeighbors) {
          const MFloat massAvail =
              fvSolver().a_variable(redistId, fvSolver().CV->A_RHO) * fvSolver().a_cellVolume(redistId);
          const MFloat delRho = massAvail / fvSolver().a_cellVolume(redistId);
          const MFloat delRhoVV[3] = {delRho * fvSolver().a_pvariable(redistId, fvSolver().PV->VV[0]),
                                      delRho * fvSolver().a_pvariable(redistId, fvSolver().PV->VV[1]),
                                      delRho * fvSolver().a_pvariable(redistId, fvSolver().PV->VV[2])};
          massTransfer += massAvail;
          fvSolver().a_variable(redistId, fvSolver().CV->A_RHO) -= delRho;
          for(MInt dir = 0; dir < 3; dir++) {
            fvSolver().a_variable(redistId, fvSolver().CV->A_RHO_VV[dir]) -= delRhoVV[dir];
            momentumTransfer[dir] += delRhoVV[dir] * fvSolver().a_cellVolume(redistId);
          }
          fvSolver().setPrimitiveVariables(redistId);
 
          if(fvSolver().a_isHalo(redistId)) {
            const transferCV delCV = {
                -delRho,
                -delRhoVV[0],
                -delRhoVV[1],
                -delRhoVV[2],
            };
            auto success = haloCorrections.insert(std::pair<MInt, transferCV>(redistId, delCV));
            if(!success.second) { // redistId already in map
              success.first->second.rhoAlpha += delCV.rhoAlpha;
              success.first->second.rhoUAlpha += delCV.rhoUAlpha;
              success.first->second.rhoVAlpha += delCV.rhoVAlpha;
              success.first->second.rhoWAlpha += delCV.rhoWAlpha;
            }
          }
        }
        fvSolver().a_variable(cellId, fvSolver().CV->A_RHO) += massTransfer / fvSolver().a_cellVolume(cellId);
        for(MInt dir = 0; dir < 3; dir++) {
          fvSolver().a_variable(cellId, fvSolver().CV->A_RHO_VV[dir]) +=
              momentumTransfer[dir] / fvSolver().a_cellVolume(cellId);
        }
        fvSolver().setPrimitiveVariables(cellId);
      }
    } else if(origAlpha > (m_alphaCeil + 1.0e-8)) {
      const MFloat origMass = fvSolver().a_variable(cellId, fvSolver().CV->A_RHO) * fvSolver().a_cellVolume(cellId);
      const MFloat deltaMass =
          m_alphaCeil * fvSolver().a_pvariable(cellId, fvSolver().PV->RHO) * fvSolver().a_cellVolume(cellId) - origMass;
      std::vector<MInt> neighbors = findRedistCells(cellId, false, m_alphaCeil);
      MBool isOutlet = false;
 
      if(fvSolver().a_bndryId(cellId) >= 0) {
        const MInt bndryId = fvSolver().a_bndryId(cellId);
        for(MInt srfc = 0; srfc < fvSolver().m_bndryCells->a[bndryId].m_noSrfcs; srfc++) {
          const MInt bndrCndId = fvSolver().m_fvBndryCnd->m_bndryCell[bndryId].m_srfcs[srfc]->m_bndryCndId;
          if(bndrCndId == 1002) {
            isOutlet = true;
            break;
          }
        }
      }
      if(isOutlet) {
        for(MUint dir = 0; dir < 26; dir++) { // loop over ALL the directions!
          const MInt neighborId = fvSolver().grid().neighborList(cellId, dir);
          if(fvSolver().a_isBndryGhostCell(neighborId)) {
            neighbors.push_back(neighborId);
          }
        }
      }
      std::vector<MInt> redistNeighbors = neighbors;
 
      MInt noRedistNbs = 0;
      MFloat massExcessPerCell = 0.0;
      while(true) {
        MBool change = false;
        noRedistNbs = redistNeighbors.size();
        massExcessPerCell = -deltaMass / noRedistNbs;
        for(auto it = redistNeighbors.begin(); it != redistNeighbors.end(); ++it) {
          const MInt candidateId = *it;
          if(!fvSolver().a_isBndryGhostCell(candidateId)
             && ((fvSolver().a_variable(candidateId, fvSolver().CV->A_RHO)
                  + massExcessPerCell / fvSolver().a_cellVolume(candidateId))
                 > fvSolver().a_pvariable(candidateId, fvSolver().PV->RHO) * m_alphaCeil)) {
            change = true;
            redistNeighbors.erase(it);
            break;
          }
        }
        if(change) continue;
        break;
      }
      MFloat momentumTransfer[3] = {0.0, 0.0, 0.0};
      if(!redistNeighbors.empty() || isOutlet) {
        if(redistNeighbors.empty()) {
          noRedistNbs = 1;
          massExcessPerCell = -deltaMass / noRedistNbs;
          for(MInt dir = 0; dir < 3; dir++) {
            momentumTransfer[dir] += massExcessPerCell * fvSolver().a_pvariable(cellId, fvSolver().PV->VV[dir]);
          }
        }
        for(auto redistId : redistNeighbors) {
          if(fvSolver().a_isBndryGhostCell(redistId)) continue;
          const MFloat delRho = massExcessPerCell / fvSolver().a_cellVolume(redistId);
          const MFloat delRhoVV[3] = {delRho * fvSolver().a_pvariable(redistId, fvSolver().PV->VV[0]),
                                      delRho * fvSolver().a_pvariable(redistId, fvSolver().PV->VV[1]),
                                      delRho * fvSolver().a_pvariable(redistId, fvSolver().PV->VV[2])};
          fvSolver().a_variable(redistId, fvSolver().CV->A_RHO) += delRho;
          for(MInt dir = 0; dir < 3; dir++) {
            fvSolver().a_variable(redistId, fvSolver().CV->A_RHO_VV[dir]) += delRhoVV[dir];
            momentumTransfer[dir] += delRhoVV[dir] * fvSolver().a_cellVolume(redistId);
          }
          fvSolver().setPrimitiveVariables(redistId);
 
          if(fvSolver().a_isHalo(redistId)) {
            const transferCV delCV = {
                delRho,
                delRhoVV[0],
                delRhoVV[1],
                delRhoVV[2],
            };
            auto success = haloCorrections.insert(std::pair<MInt, transferCV>(redistId, delCV));
            if(!success.second) { // redistId already in map
              success.first->second.rhoAlpha += delCV.rhoAlpha;
              success.first->second.rhoUAlpha += delCV.rhoUAlpha;
              success.first->second.rhoVAlpha += delCV.rhoVAlpha;
              success.first->second.rhoWAlpha += delCV.rhoWAlpha;
            }
          }
        }
        fvSolver().a_variable(cellId, fvSolver().CV->A_RHO) -=
            massExcessPerCell / fvSolver().a_cellVolume(cellId) * noRedistNbs;
        for(MInt dir = 0; dir < 3; dir++) {
          fvSolver().a_variable(cellId, fvSolver().CV->A_RHO_VV[dir]) -=
              momentumTransfer[dir] / fvSolver().a_cellVolume(cellId);
        }
        fvSolver().setPrimitiveVariables(cellId);
      } else {
        // if no neighbor can take enough mass to bring our cell under alphaCeil, give them as much as they can take
        redistNeighbors = neighbors;
        if(redistNeighbors.empty()) {
          redistNeighbors = findRedistCells(cellId, false, std::numeric_limits<MFloat>::max());
        }
        MFloat massTransfer = 0.0;
        for(auto redistId : redistNeighbors) {
          const MFloat massCapacityAvail = (fvSolver().a_pvariable(redistId, fvSolver().PV->RHO) * m_alphaCeil
                                            - fvSolver().a_variable(redistId, fvSolver().CV->A_RHO))
                                           * fvSolver().a_cellVolume(redistId);
          if(massCapacityAvail < 0.0) continue;
          const MFloat delRho = massCapacityAvail / fvSolver().a_cellVolume(redistId);
          const MFloat delRhoVV[3] = {delRho * fvSolver().a_pvariable(redistId, fvSolver().PV->VV[0]),
                                      delRho * fvSolver().a_pvariable(redistId, fvSolver().PV->VV[1]),
                                      delRho * fvSolver().a_pvariable(redistId, fvSolver().PV->VV[2])};
          massTransfer += massCapacityAvail;
          fvSolver().a_variable(redistId, fvSolver().CV->A_RHO) += delRho;
          for(MInt dir = 0; dir < 3; dir++) {
            fvSolver().a_variable(redistId, fvSolver().CV->A_RHO_VV[dir]) += delRhoVV[dir];
            momentumTransfer[dir] += delRhoVV[dir] * fvSolver().a_cellVolume(redistId);
          }
          fvSolver().setPrimitiveVariables(redistId);
 
          if(fvSolver().a_isHalo(redistId)) {
            const transferCV delCV = {
                delRho,
                delRhoVV[0],
                delRhoVV[1],
                delRhoVV[2],
            };
            auto success = haloCorrections.insert(std::pair<MInt, transferCV>(redistId, delCV));
            if(!success.second) { // redistId already in map
              success.first->second.rhoAlpha += delCV.rhoAlpha;
              success.first->second.rhoUAlpha += delCV.rhoUAlpha;
              success.first->second.rhoVAlpha += delCV.rhoVAlpha;
              success.first->second.rhoWAlpha += delCV.rhoWAlpha;
            }
          }
        }
        fvSolver().a_variable(cellId, fvSolver().CV->A_RHO) -= massTransfer / fvSolver().a_cellVolume(cellId);
        for(MInt dir = 0; dir < 3; dir++) {
          fvSolver().a_variable(cellId, fvSolver().CV->A_RHO_VV[dir]) -=
              momentumTransfer[dir] / fvSolver().a_cellVolume(cellId);
        }
        fvSolver().setPrimitiveVariables(cellId);
      }
    }
  }
 
  // Communicate the changes in the CVs to the neighboring domains
  // Since this function changed the CV in the halo cells, m_send- and m_receiveBuffer are swapped in this communication
  {
    if(noTransferCV > fvSolver().m_dataBlockSize)
      mTerm(1, AT_, "The send- and receive Buffers are too small for this communication!");
    // gather
    for(MInt i = 0; i < fvSolver().noNeighborDomains(); i++) {
      MInt receiveBufferCounter = 0;
      for(MInt j = 0; j < fvSolver().m_noMaxLevelHaloCells[i]; j++) {
        auto it = haloCorrections.find(fvSolver().m_maxLevelHaloCells[i][j]);
        if(it != haloCorrections.end()) {
          fvSolver().m_receiveBuffers[i][receiveBufferCounter + fvSolver().CV->A_RHO] = it->second.rhoAlpha;
          fvSolver().m_receiveBuffers[i][receiveBufferCounter + fvSolver().CV->A_RHO_U] = it->second.rhoUAlpha;
          fvSolver().m_receiveBuffers[i][receiveBufferCounter + fvSolver().CV->A_RHO_V] = it->second.rhoVAlpha;
          fvSolver().m_receiveBuffers[i][receiveBufferCounter + fvSolver().CV->A_RHO_W] = it->second.rhoWAlpha;
        } else {
          fvSolver().m_receiveBuffers[i][receiveBufferCounter + fvSolver().CV->A_RHO] = 0.0;
          fvSolver().m_receiveBuffers[i][receiveBufferCounter + fvSolver().CV->A_RHO_U] = 0.0;
          fvSolver().m_receiveBuffers[i][receiveBufferCounter + fvSolver().CV->A_RHO_V] = 0.0;
          fvSolver().m_receiveBuffers[i][receiveBufferCounter + fvSolver().CV->A_RHO_W] = 0.0;
        }
        receiveBufferCounter += noTransferCV;
      }
    }
 
    // send
    MInt bufSize = 0;
    for(MInt i = 0; i < fvSolver().noNeighborDomains(); i++) {
      bufSize = fvSolver().m_noMaxLevelHaloCells[i] * noTransferCV;
      MPI_Issend(fvSolver().m_receiveBuffers[i], bufSize, MPI_DOUBLE, fvSolver().neighborDomain(i), 0,
                 fvSolver().mpiComm(), &fvSolver().m_mpi_request[i], AT_,
                 "m_receiveBuffers[" + std::to_string(i) + "],1");
    }
 
    // receive
    MPI_Status status;
    for(MInt i = 0; i < fvSolver().noNeighborDomains(); i++) {
      bufSize = fvSolver().m_noMaxLevelWindowCells[i] * noTransferCV;
      MPI_Recv(fvSolver().m_sendBuffers[i], bufSize, MPI_DOUBLE, fvSolver().neighborDomain(i), 0, fvSolver().mpiComm(),
               &status, AT_, "m_sendBuffers[" + std::to_string(i) + "],1");
    }
    for(MInt i = 0; i < fvSolver().noNeighborDomains(); i++) {
      MPI_Wait(&fvSolver().m_mpi_request[i], &status, AT_);
    }
 
    // scatter
    MInt sendBufferCounter = 0;
    for(MInt i = 0; i < fvSolver().noNeighborDomains(); i++) {
      sendBufferCounter = 0;
      for(MInt j = 0; j < fvSolver().m_noMaxLevelWindowCells[i]; j++) {
        fvSolver().a_variable(fvSolver().m_maxLevelWindowCells[i][j], fvSolver().CV->A_RHO) +=
            fvSolver().m_sendBuffers[i][sendBufferCounter + fvSolver().CV->A_RHO];
        for(MInt dir = 0; dir < nDim; dir++) {
          fvSolver().a_variable(fvSolver().m_maxLevelWindowCells[i][j], fvSolver().CV->A_RHO_VV[dir]) +=
              fvSolver().m_sendBuffers[i][sendBufferCounter + fvSolver().CV->A_RHO_VV[dir]];
        }
        sendBufferCounter += noTransferCV;
      }
    }
  }
  fvSolver().computePV();
  fvSolver().exchange();
}

◆ finalizeCouplerInit()

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

void CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::finalizeCouplerInit

overridevirtual

Reimplemented from CouplerLbFv< nDim, nDist, SysEqnLb, SysEqnFv >.

Definition at line 42 of file couplerlbfveemultiphase.cpp.

                                                                                   {
  if(!fvSolver().m_EEGas.depthCorrection) {
    initDepthcorrection();
  }
  transferUFv2Lb();
}

◆ finalizeSubCoupleInit()

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

void CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::finalizeSubCoupleInit ( MInt )

overridevirtual

Reimplemented from CouplerLbFv< nDim, nDist, SysEqnLb, SysEqnFv >.

Definition at line 112 of file couplerlbfveemultiphase.cpp.

                                                                                         {
  transferPressureLb2Fv(1.0, false);
}

◆ findRedistCells()

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

std::vector< MInt > CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::findRedistCells	(	const MInt	cellId,
		const MBool	searchUp,
		const MFloat	limit
	)

Author: Daniel Lauwers

Parameters

[in]	cellId	the cell id that needs to be corrected
[in]	searchUp	if true, search cells with a gas mass > limit, else gas mass < limit
[in]	limit	the limit of alpha to be considered

Returns: vector of Ids of candidates for redistribution

Definition at line 1113 of file couplerlbfveemultiphase.cpp.

                                                                                                                {
  std::vector<MInt> redistNeighbors;
  redistNeighbors.reserve(56);
 
  MIntScratchSpace adjacentLeafCells(56, AT_, "adjacentLeafCells");
  MIntScratchSpace layers(56, AT_, "layers");
  const MInt noLeafCells = fvSolver().getAdjacentLeafCells_d2(cellId, 1, adjacentLeafCells, layers);
 
  for(MInt i = 0; i < noLeafCells; i++) {
    const MInt neighborId = adjacentLeafCells[i];
    const MFloat alpha = fvSolver().a_pvariable(neighborId, fvSolver().PV->A);
    if(searchUp && alpha < limit) continue;
    if(!searchUp && alpha > limit) continue;
    redistNeighbors.push_back(neighborId);
  }
  return redistNeighbors;
}

◆ fv2lbId()

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

MInt CouplerLbFv< nDim, nDist, SysEqnLb, SysEqnFv >::fv2lbId ( const MInt fvId ) const

inlineprivate

Definition at line 115 of file couplerlbfv.h.

115{ return convertId(fvSolver(), lbSolver(), fvId); };

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

◆ init()

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

void CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::init

overridevirtual

Reimplemented from CouplerLbFv< nDim, nDist, SysEqnLb, SysEqnFv >.

Definition at line 33 of file couplerlbfveemultiphase.cpp.

                                                                    {
  this->initConversionFactors();
  if(!fvSolver().m_EEGas.depthCorrection) {
    mAlloc(m_depthCorrectionValues, fvSolver().maxNoGridCells(), "m_depthCorrectionValues", F0, AT_);
    initDepthcorrection();
  }
}

◆ initAlpha()

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

void CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::initAlpha

private

Definition at line 120 of file couplerlbfveemultiphase.cpp.

                                                                         {
  switch(m_initAlphaMethod) {
    case 0: // initialize alphaGas to be zero everywhere
    {
      for(MInt lbCellId = 0; lbCellId < a_noLbCells(); lbCellId++) {
        lbSolver().a_alphaGas(lbCellId) = 0.0;
      }
      for(MInt fvCellId = 0; fvCellId < a_noFvCells(); fvCellId++) {
        fvSolver().a_alphaGas(fvCellId) = 0.0;
      }
      break;
    } // case 0
 
    case 1: // initialize alphaGas to a constant value given in m_initialAlpha
    {
      const MFloat alpha = m_initialAlpha;
      for(MInt lbCellId = 0; lbCellId < a_noLbCells(); lbCellId++) {
        lbSolver().a_alphaGas(lbCellId) = alpha;
      }
      for(MInt fvCellId = 0; fvCellId < a_noFvCells(); fvCellId++) {
        fvSolver().a_alphaGas(fvCellId) = alpha;
      }
      break;
    } // case 1
 
    case 2: // initialize alphaGas to a constant value given in m_initialAlpha in a sphere with radius 0.5 around the
            // origin, else m_alphaInf
    {
      const MFloat alpha = m_initialAlpha;
      for(MInt i = 0; i < a_noLbCells(); i++) {
        MFloat xcoord = lbSolver().a_coordinate(i, 0);
        MFloat ycoord = lbSolver().a_coordinate(i, 1);
        MFloat zcoord = lbSolver().a_coordinate(i, 2);
        if(xcoord * xcoord + ycoord * ycoord + zcoord * zcoord < 0.5) {
          lbSolver().a_alphaGas(i) = alpha;
        } else {
          lbSolver().a_alphaGas(i) = m_alphaInf;
        }
      }
      for(MInt i = 0; i < a_noFvCells(); i++) {
        MFloat xcoord = fvSolver().a_coordinate(i, 0);
        MFloat ycoord = fvSolver().a_coordinate(i, 1);
        MFloat zcoord = fvSolver().a_coordinate(i, 2);
        if(xcoord * xcoord + ycoord * ycoord + zcoord * zcoord < 0.5) {
          fvSolver().a_alphaGas(i) = alpha;
        } else {
          fvSolver().a_alphaGas(i) = m_alphaInf;
        }
      }
      break;
    } // case 2
 
    case 3: // initialize alphaGas to a constant value given in m_initialAlpha below the z value of 0, else m_alphaInf
    {
      const MFloat alpha = m_initialAlpha;
      for(MInt i = 0; i < a_noLbCells(); i++) {
        MFloat zcoord = lbSolver().a_coordinate(i, 2);
        if(zcoord < 0.0) {
          lbSolver().a_alphaGas(i) = alpha;
        } else {
          lbSolver().a_alphaGas(i) = m_alphaInf;
        }
      }
      for(MInt i = 0; i < a_noFvCells(); i++) {
        MFloat zcoord = fvSolver().a_coordinate(i, 2);
        if(zcoord < 0.0) {
          fvSolver().a_alphaGas(i) = alpha;
        } else {
          fvSolver().a_alphaGas(i) = m_alphaInf;
        }
      }
      break;
    }
 
    case 4: // alpha Gradient in z direction with initial alpha at 0, alphaInf at 1 and (2 initial alpha - alphaInf) at
            // -1
    {
      const MFloat delAlpha = m_initialAlpha - m_alphaInf;
      for(MInt i = 0; i < a_noLbCells(); i++) {
        MFloat zcoord = lbSolver().a_coordinate(i, 2);
        if(zcoord < -1.0) {
          lbSolver().a_alphaGas(i) = m_initialAlpha + delAlpha;
        } else if(zcoord > 1.0) {
          lbSolver().a_alphaGas(i) = m_initialAlpha - delAlpha;
        } else {
          lbSolver().a_alphaGas(i) = m_initialAlpha - zcoord * delAlpha;
        }
      }
      for(MInt i = 0; i < a_noFvCells(); i++) {
        MFloat zcoord = fvSolver().a_coordinate(i, 2);
        if(zcoord < -1.0) {
          fvSolver().a_alphaGas(i) = m_initialAlpha + delAlpha;
        } else if(zcoord > 1.0) {
          fvSolver().a_alphaGas(i) = m_initialAlpha - delAlpha;
        } else {
          fvSolver().a_alphaGas(i) = m_initialAlpha - zcoord * delAlpha;
        }
      }
      break;
    }
 
    default: {
      mTerm(1, AT_, "initAlphaMethod not matching any case!");
      break;
    } // default
 
  } // switch (m_initAlphaMethod)
}

◆ initData()

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

void CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::initData

private

Definition at line 117 of file couplerlbfveemultiphase.cpp.

117{}

◆ initDepthcorrection()

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

void CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::initDepthcorrection

Definition at line 408 of file couplerlbfveemultiphase.cpp.

                                                                                   {
  MFloat TInf = fvSolver().m_TInfinity;
  if(std::isnan(TInf)) {
    TInf = fvSolver().m_initialCondition == 465 || fvSolver().m_initialCondition == 9465
               ? 1.0
               : 1.0 / (1.0 + 0.5 * (fvSolver().m_gamma - 1.0) * POW2(fvSolver().m_Ma));
  }
  for(MInt fvCellId = 0; fvCellId < a_noFvCells(); fvCellId++) {
    MFloat depthCorrectionValue = 0.0;
    for(MInt i = 0; i < nDim; i++) {
      const MFloat deltaH = fvSolver().a_coordinate(fvCellId, i) - m_gravityRefCoords[i];
      depthCorrectionValue +=
          fvSolver().m_EEGas.liquidDensity * m_depthCorrectionCoefficients[i] * deltaH * TInf / fvSolver().m_gamma;
    }
    m_depthCorrectionValues[fvCellId] = depthCorrectionValue;
  }
}

◆ lb2fvId()

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

MInt CouplerLbFv< nDim, nDist, SysEqnLb, SysEqnFv >::lb2fvId ( const MInt lbId ) const

inlineprivate

Definition at line 116 of file couplerlbfv.h.

116{ return convertId(lbSolver(), fvSolver(), lbId); };

◆ postcouple()

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

void CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::postcouple ( MInt )

inline

Definition at line 84 of file couplerlbfveemultiphase.h.

84{};

◆ preCouple()

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

void CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::preCouple ( MInt )

overridevirtual

Implements Coupling.

Definition at line 25 of file couplerlbfveemultiphase.cpp.

                                                                               {
  if(m_alphaConvergenceCheck > 0) {
    lbSolver().storeOldDistributions();
    if(m_updateAfterPropagation) lbSolver().storeOldVariables();
  }
}

◆ readProperties()

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

void CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::readProperties ( )

privatevirtual

Reimplemented from CouplerLbFv< nDim, nDist, SysEqnLb, SysEqnFv >.

◆ revertFv()

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

void CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::revertFv

Definition at line 661 of file couplerlbfveemultiphase.cpp.

                                                                        {
  revertFvVariables();
  fvSolver().revertTimestep();
  fvSolver().exchange();
}

◆ revertFvVariables()

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

void CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::revertFvVariables

private

Definition at line 651 of file couplerlbfveemultiphase.cpp.

                                                                                 {
  for(MInt cellId = 0; cellId < a_noFvCells(); cellId++) {
    for(MInt varId = 0; varId < fvSolver().noVariables(); varId++) {
      fvSolver().a_variable(cellId, varId) = fvSolver().a_oldVariable(cellId, varId);
    }
  }
  fvSolver().computePV();
}

◆ revertLb()

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

void CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::revertLb

Definition at line 637 of file couplerlbfveemultiphase.cpp.

                                                                        {
  if(m_alphaConvergenceCheck <= 0) {
    mTerm(1, AT_, "Didn't store the variables to revert the LB solver!");
  }
  revertLbVariables();
  revertLbDistributions();
  if(m_updateAfterPropagation) revertLbOldVariables();
  if(lbSolver().noDomains() > 1) {
    lbSolver().exchange();
    lbSolver().exchangeOldDistributions();
  }
}

◆ revertLbDistributions()

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

void CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::revertLbDistributions

private

Definition at line 618 of file couplerlbfveemultiphase.cpp.

                                                                                     {
  for(MInt cellId = 0; cellId < a_noLbCells(); cellId++) {
    for(MInt distr = 0; distr < lbSolver().m_noDistributions; distr++) {
      lbSolver().a_oldDistribution(cellId, distr) = lbSolver().a_previousDistribution(cellId, distr);
    }
  }
}

◆ revertLbOldVariables()

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

void CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::revertLbOldVariables

private

Definition at line 627 of file couplerlbfveemultiphase.cpp.

                                                                                    {
  for(MInt cellId = 0; cellId < a_noLbCells(); cellId++) {
    lbSolver().a_oldVariable(cellId, lbSolver().PV->RHO) = lbSolver().a_previousVariable(cellId, lbSolver().PV->RHO);
    lbSolver().a_oldVariable(cellId, lbSolver().PV->U) = lbSolver().a_previousVariable(cellId, lbSolver().PV->U);
    lbSolver().a_oldVariable(cellId, lbSolver().PV->V) = lbSolver().a_previousVariable(cellId, lbSolver().PV->V);
    lbSolver().a_oldVariable(cellId, lbSolver().PV->W) = lbSolver().a_previousVariable(cellId, lbSolver().PV->W);
  }
}

◆ revertLbVariables()

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

void CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::revertLbVariables

private

Definition at line 608 of file couplerlbfveemultiphase.cpp.

                                                                                 {
  for(MInt cellId = 0; cellId < a_noLbCells(); cellId++) {
    lbSolver().a_variable(cellId, lbSolver().PV->RHO) = lbSolver().a_oldVariable(cellId, lbSolver().PV->RHO);
    lbSolver().a_variable(cellId, lbSolver().PV->U) = lbSolver().a_oldVariable(cellId, lbSolver().PV->U);
    lbSolver().a_variable(cellId, lbSolver().PV->V) = lbSolver().a_oldVariable(cellId, lbSolver().PV->V);
    lbSolver().a_variable(cellId, lbSolver().PV->W) = lbSolver().a_oldVariable(cellId, lbSolver().PV->W);
  }
}

◆ subCouple()

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

void CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::subCouple	(	MInt	,
		MInt	,
		std::vector< MBool > &	solverCompleted
	)

overridevirtual

Reimplemented from CouplerLbFv< nDim, nDist, SysEqnLb, SysEqnFv >.

Definition at line 57 of file couplerlbfveemultiphase.cpp.

                                                                                                            {
  static MInt noAlphaIterations = 0;
 
  if(m_redistributeAlpha && !m_disableSubstepAlphaRedist
     && !(solverCompleted[a_lbSolverId()] && solverCompleted[a_fvSolverId()]))
    correctInvalidAlpha();
 
  if(solverCompleted[a_lbSolverId()] && solverCompleted[a_fvSolverId()]) {
    if(m_redistributeAlpha) correctInvalidAlpha();
    // both Solvers completed -> check for convergence of alpha
    MBool alphaConverged = true;
    if(noAlphaIterations < m_maxNoAlphaIterations) alphaConverged = checkAlphaConverged();
    if(alphaConverged) {
      transferAlphaFv2Lb();
      transferUFv2Lb();
 
#ifndef NDEBUG
      if(fvSolver().domainId() == 0 && m_alphaConvergenceCheck != 0 && noAlphaIterations > 3) {
        if(noAlphaIterations < m_maxNoAlphaIterations)
          std::cerr << "Globaltimestep: " << globalTimeStep << "   alpha Converged after " << noAlphaIterations
                    << " Iterations!" << std::endl;
        else
          std::cerr << "Globaltimestep: " << globalTimeStep
                    << "   max number of alphaIterations reached: " << noAlphaIterations << std::endl;
      }
#endif
 
      noAlphaIterations = 0;
      return;
    } else {
      transferAlphaFv2Lb();
      revertLb();
      revertFv();
      noAlphaIterations++;
      solverCompleted[a_lbSolverId()] = false;
      solverCompleted[a_fvSolverId()] = false;
      return;
    }
  } else if(solverCompleted[a_lbSolverId()]) {
    // LB Solver completed -> transfer new liquid variables
    transferPressureLb2Fv(fvSolver().m_RKalpha[fvSolver().m_RKStep], m_updateFVBC);
    if(fvSolver().m_RKStep == 0)
      transferULb2Fv<true>(fvSolver().m_RKalpha[fvSolver().m_RKStep]);
    else
      transferULb2Fv<false>(fvSolver().m_RKalpha[fvSolver().m_RKStep]);
    transferNuLb2Fv(fvSolver().m_RKalpha[fvSolver().m_RKStep]);
    fvSolver().exchange();
    return;
  } else if(solverCompleted[a_fvSolverId()]) {
    mTerm(1, AT_, "Fv Solver cant be completed before Lb Solver is completed in LB-FV-Euler-Euler-Multiphase!");
  }
}

◆ transferAlphaFv2Lb()

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

void CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::transferAlphaFv2Lb

Definition at line 598 of file couplerlbfveemultiphase.cpp.

                                                                                  {
  for(MInt fvCellId = 0; fvCellId < a_noFvCells(); fvCellId++) {
    const MInt lbCellId = fv2lbId(fvCellId);
    if(lbCellId < 0) continue;
 
    lbSolver().a_alphaGas(lbCellId) = fvSolver().a_alphaGas(fvCellId);
  }
}

◆ transferNuLb2Fv()

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

void CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::transferNuLb2Fv ( const MFloat rkAlpha )

Definition at line 580 of file couplerlbfveemultiphase.cpp.

                                                                                                   {
  for(MInt lbCellId = 0; lbCellId < a_noLbCells(); lbCellId++) {
    const MInt lvlDiff = lbSolver().maxLevel() - lbSolver().a_level(lbCellId);
    const MInt tsSinceUpdate = globalTimeStep % IPOW2(lvlDiff);
    const MFloat dt =
        m_interpolationFactor > 0.0 ? (rkAlpha * m_interpolationFactor - 1.0 + tsSinceUpdate) * FFPOW2(lvlDiff) : 0.0;
    const MInt fvCellId = lb2fvId(lbCellId);
    if(fvCellId < 0) continue;
    if(fvSolver().a_isBndryGhostCell(fvCellId)) continue;
 
    fvSolver().a_nuEffOtherPhase(fvCellId) =
        ((1.0 + dt) * lbSolver().a_nu(lbCellId) - dt * lbSolver().a_oldNu(lbCellId)) * conversionLbFv.viscosity;
    fvSolver().a_nuTOtherPhase(fvCellId) =
        ((1.0 + dt) * lbSolver().a_nuT(lbCellId) - dt * lbSolver().a_oldNuT(lbCellId)) * conversionLbFv.viscosity;
  }
}

◆ transferPressureLb2Fv()

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

void CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::transferPressureLb2Fv	(	const MFloat	rkAlpha,
		const MBool	update
	)

Definition at line 427 of file couplerlbfveemultiphase.cpp.

                                                                                                         {
  // conversion factor for pressure from LB to FV: 3 / (1 + (gamma-1)/2 * Ma_inf^2)^(gamma/(gamma-1))
  //                                             = 3 * T_inf ^ (gamma/(gamma-1))
  // conversion factor LB RHO to P: p = rho / (3 * gamma)
  // total conversion factor: T_inf ^ (gamma/(gamma-1)) / gamma
 
  for(MInt lbCellId = 0; lbCellId < a_noLbCells(); lbCellId++) {
    const MInt lvlDiff = lbSolver().maxLevel() - lbSolver().a_level(lbCellId);
    const MInt tsSinceUpdate = globalTimeStep % IPOW2(lvlDiff);
    const MFloat dt =
        m_interpolationFactor > 0.0 ? (rkAlpha * m_interpolationFactor - 1.0 + tsSinceUpdate) * FFPOW2(lvlDiff) : 0.0;
    MInt fvCellId = lb2fvId(lbCellId);
    if(fvCellId < 0) continue;
 
    if(!fvSolver().m_EEGas.depthCorrection) {
      fvSolver().a_pvariable(fvCellId, fvSolver().PV->P) =
          conversionLbFv.pressure * lbSolver().a_interpolatedVariable(lbCellId, lbSolver().PV->RHO, dt)
              / fvSolver().m_gamma
          + m_depthCorrectionValues[fvCellId];
    } else {
      fvSolver().a_pvariable(fvCellId, fvSolver().PV->P) =
          conversionLbFv.pressure * lbSolver().a_interpolatedVariable(lbCellId, lbSolver().PV->RHO, dt)
          / fvSolver().m_gamma;
    }
  }
  for(MInt bndIndex = 0; bndIndex < (MInt)(lbBndCnd().m_bndCndIds.size()); bndIndex++) {
    for(MInt bndId = lbBndCnd().m_bndCndOffsets[bndIndex]; bndId < lbBndCnd().m_bndCndOffsets[bndIndex + 1]; bndId++) {
      if(lbBndCnd().m_bndCells[bndId].m_isFluid) continue; // extrapolate only solid boundary cells from flow field
      const MInt lbCellId = lbBndCnd().m_bndCells[bndId].m_cellId;
      const MInt fvCellId = lb2fvId(lbCellId);
      if(fvCellId < 0) continue;
      for(MInt i = 0; i < 26; i++) { // look in all directions, including diagonals
        if(!lbSolver().a_hasNeighbor(lbCellId, i)) {
          MInt lbOppNId = lbSolver().c_neighborId(lbCellId, oppositeDirGrid[i]);
          if(lbOppNId >= 0 && !lbSolver().a_isBndryCell(lbOppNId)) {
            MInt fvOppNId = lb2fvId(lbOppNId);
            if(fvOppNId >= a_noFvCells() || fvOppNId < 0) {
              break;
            }
            if(!fvSolver().m_EEGas.depthCorrection) {
              fvSolver().a_pvariable(fvCellId, fvSolver().PV->P) = fvSolver().a_pvariable(fvOppNId, fvSolver().PV->P)
                                                                   - m_depthCorrectionValues[fvOppNId]
                                                                   + m_depthCorrectionValues[fvCellId];
            } else {
              fvSolver().a_pvariable(fvCellId, fvSolver().PV->P) = fvSolver().a_pvariable(fvOppNId, fvSolver().PV->P);
            }
            break;
          }
        }
      }
    }
  }
 
  if(update) {
    fvSolver().computePV();
    fvSolver().exchange();
    fvSolver().m_fvBndryCnd->updateGhostCellVariables();
 
    // apply von Neumann boundary conditions
    fvSolver().m_fvBndryCnd->applyNeumannBoundaryCondition();
  }
}

◆ transferUFv2Lb()

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

void CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::transferUFv2Lb

Definition at line 563 of file couplerlbfveemultiphase.cpp.

                                                                              {
  // conversion factor for velocity from LB to FV: sqrt((1 + (gamma-1)/2 * Ma_inf^2) / 3)
 
  for(MInt fvCellId = 0; fvCellId < a_noFvCells(); fvCellId++) {
    MInt lbCellId = fv2lbId(fvCellId);
    if(lbCellId < 0) continue;
 
    lbSolver().a_uOtherPhase(lbCellId, 0) =
        conversionFvLb.velocity * fvSolver().a_pvariable(fvCellId, fvSolver().PV->U);
    lbSolver().a_uOtherPhase(lbCellId, 1) =
        conversionFvLb.velocity * fvSolver().a_pvariable(fvCellId, fvSolver().PV->V);
    lbSolver().a_uOtherPhase(lbCellId, 2) =
        conversionFvLb.velocity * fvSolver().a_pvariable(fvCellId, fvSolver().PV->W);
  }
}

◆ transferULb2Fv()

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

template<MBool updateGradients>

void CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::transferULb2Fv ( const MFloat rkAlpha )

Definition at line 493 of file couplerlbfveemultiphase.cpp.

                                                                                                  {
  static MBool firstCall = true;
 
  // conversion factor for velocity from LB to FV: sqrt(3 / (1 + (gamma-1)/2 * Ma_inf^2))
  const MFloat ufactor = conversionLbFv.velocity;
 
  // derivatives need an additional conversion factor
  const MFloat dufactor = conversionLbFv.length;
 
  // swap the pointers instead of copying all values from m_EEGas.uOtherPhase to m_EEGas.uOtherPhaseOld
  MFloat** tempPointer = fvSolver().m_EEGas.uOtherPhaseOld;
  fvSolver().m_EEGas.uOtherPhaseOld = fvSolver().m_EEGas.uOtherPhase;
  fvSolver().m_EEGas.uOtherPhase = tempPointer;
 
  lbSolver().exchange();
 
  // update the velocity arrays
  const MBool interpolate = m_interpolationFactor > 0.0;
  for(MInt lbCellId = 0; lbCellId < a_noLbCells(); lbCellId++) {
    MInt fvCellId = lb2fvId(lbCellId);
    if(fvCellId < 0) continue;
 
    if(interpolate) {
      const MInt lvlDiff = lbSolver().maxLevel() - lbSolver().a_level(lbCellId);
      const MInt tsSinceUpdate = globalTimeStep % IPOW2(lvlDiff);
      const MFloat dt = (rkAlpha * m_interpolationFactor - 1.0 + tsSinceUpdate) * FFPOW2(lvlDiff);
      // since the gradients are not updated for each RK step, they are interpolated for the whole timestep
      for(MInt i = 0; i < nDim; i++) {
        fvSolver().a_uOtherPhase(fvCellId, i) = ufactor * lbSolver().a_interpolatedVariable(lbCellId, i, dt);
        IF_CONSTEXPR(updateGradients) {
          const MFloat dtGrad = (m_interpolationFactor - 1.0 + tsSinceUpdate) * FFPOW2(lvlDiff);
          for(MInt j = 0; j < nDim; j++) {
            fvSolver().a_gradUOtherPhase(fvCellId, i, j) =
                ufactor * dufactor * lbSolver().calculateInterpolatedDerivative(lbCellId, i, j, dtGrad);
          }
        }
      }
    } else {
      for(MInt i = 0; i < nDim; i++) {
        fvSolver().a_uOtherPhase(fvCellId, i) = ufactor * lbSolver().a_variable(lbCellId, i);
        IF_CONSTEXPR(updateGradients) {
          for(MInt j = 0; j < nDim; j++) {
            fvSolver().a_gradUOtherPhase(fvCellId, i, j) =
                ufactor * dufactor * lbSolver().calculateDerivative(lbCellId, i, j);
          }
        }
      }
    }
    IF_CONSTEXPR(updateGradients) {
      fvSolver().a_vortOtherPhase(fvCellId, 0) =
          fvSolver().a_gradUOtherPhase(fvCellId, 2, 1) - fvSolver().a_gradUOtherPhase(fvCellId, 1, 2);
      fvSolver().a_vortOtherPhase(fvCellId, 1) =
          fvSolver().a_gradUOtherPhase(fvCellId, 0, 2) - fvSolver().a_gradUOtherPhase(fvCellId, 2, 0);
      fvSolver().a_vortOtherPhase(fvCellId, 2) =
          fvSolver().a_gradUOtherPhase(fvCellId, 1, 0) - fvSolver().a_gradUOtherPhase(fvCellId, 0, 1);
    }
  }
  if(firstCall) {
    for(MInt lbCellId = 0; lbCellId < a_noLbCells(); lbCellId++) {
      MInt fvCellId = lb2fvId(lbCellId);
      if(fvCellId < 0) continue;
      for(MInt i = 0; i < 3; i++) {
        fvSolver().a_uOtherPhaseOld(fvCellId, i) = fvSolver().a_uOtherPhase(fvCellId, i);
      }
    }
    firstCall = false;
  }
}

Member Data Documentation

◆ conversionFvLb

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

ConversionFactors CouplerLbFv< nDim, nDist, SysEqnLb, SysEqnFv >::conversionFvLb

private

Definition at line 104 of file couplerlbfv.h.

◆ conversionLbFv

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

ConversionFactors CouplerLbFv< nDim, nDist, SysEqnLb, SysEqnFv >::conversionLbFv

private

Definition at line 103 of file couplerlbfv.h.

◆ m_alphaCeil

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

MFloat CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::m_alphaCeil {}

Definition at line 109 of file couplerlbfveemultiphase.h.

◆ m_alphaConvergenceCheck

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

MInt CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::m_alphaConvergenceCheck {}

Definition at line 95 of file couplerlbfveemultiphase.h.

◆ m_alphaFloor

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

MFloat CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::m_alphaFloor {}

Definition at line 110 of file couplerlbfveemultiphase.h.

◆ m_alphaInf

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

MFloat CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::m_alphaInf {}

Definition at line 100 of file couplerlbfveemultiphase.h.

◆ m_depthCorrectionCoefficients

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

std::array<MFloat, nDim> CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::m_depthCorrectionCoefficients {}

Definition at line 105 of file couplerlbfveemultiphase.h.

◆ m_depthCorrectionValues

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

MFloat* CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::m_depthCorrectionValues = nullptr

Definition at line 104 of file couplerlbfveemultiphase.h.

◆ m_disableSubstepAlphaRedist

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

MBool CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::m_disableSubstepAlphaRedist {}

Definition at line 102 of file couplerlbfveemultiphase.h.

◆ m_epsAlpha

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

MFloat CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::m_epsAlpha {}

Definition at line 97 of file couplerlbfveemultiphase.h.

◆ m_gravityRefCoords

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

std::array<MFloat, nDim> CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::m_gravityRefCoords {}

Definition at line 103 of file couplerlbfveemultiphase.h.

◆ m_initAlphaMethod

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

MInt CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::m_initAlphaMethod {}

Definition at line 98 of file couplerlbfveemultiphase.h.

◆ m_initialAlpha

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

MFloat CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::m_initialAlpha {}

Definition at line 99 of file couplerlbfveemultiphase.h.

◆ m_interpolationFactor

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

MFloat CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::m_interpolationFactor {}

Definition at line 107 of file couplerlbfveemultiphase.h.

◆ m_maxNoAlphaIterations

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

MInt CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::m_maxNoAlphaIterations {}

Definition at line 96 of file couplerlbfveemultiphase.h.

◆ m_redistributeAlpha

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

MBool CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::m_redistributeAlpha {}

Definition at line 101 of file couplerlbfveemultiphase.h.

◆ m_updateAfterPropagation

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

MBool CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::m_updateAfterPropagation {}

Definition at line 106 of file couplerlbfveemultiphase.h.

◆ m_updateFVBC

template<MInt nDim, MInt nDist, class SysEqnLb , class SysEqnFv >

MBool CouplerLbFvEEMultiphase< nDim, nDist, SysEqnLb, SysEqnFv >::m_updateFVBC {}

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

Public Types

Public Member Functions

Public Attributes

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ Base

◆ Cell

◆ FvCartesianSolver

◆ LbSolver

Constructor & Destructor Documentation

◆ CouplerLbFvEEMultiphase()

Member Function Documentation

◆ a_fvSolverId()

◆ a_lbSolverId()

◆ balancePost()

◆ balancePre()

◆ checkAlphaConverged()

◆ cleanUp()

◆ correctInvalidAlpha()

◆ finalizeCouplerInit()

◆ finalizeSubCoupleInit()

◆ findRedistCells()

◆ fv2lbId()

◆ init()

◆ initAlpha()

◆ initData()

◆ initDepthcorrection()

◆ lb2fvId()

◆ postcouple()

◆ preCouple()

◆ readProperties()

◆ revertFv()

◆ revertFvVariables()

◆ revertLb()

◆ revertLbDistributions()

◆ revertLbOldVariables()

◆ revertLbVariables()

◆ subCouple()

◆ transferAlphaFv2Lb()

◆ transferNuLb2Fv()

◆ transferPressureLb2Fv()

◆ transferUFv2Lb()

◆ transferULb2Fv()

Member Data Documentation

◆ conversionFvLb

◆ conversionLbFv

◆ m_alphaCeil

◆ m_alphaConvergenceCheck

◆ m_alphaFloor

◆ m_alphaInf

◆ m_depthCorrectionCoefficients

◆ m_depthCorrectionValues

◆ m_disableSubstepAlphaRedist

◆ m_epsAlpha

◆ m_gravityRefCoords

◆ m_initAlphaMethod

◆ m_initialAlpha

◆ m_interpolationFactor

◆ m_maxNoAlphaIterations

◆ m_redistributeAlpha

◆ m_updateAfterPropagation

◆ m_updateFVBC