maia::lb::LbSrcTerm_sponge< nDim, nDist, SysEqn > Class Template Reference

Base class for lb sponge layers. More...

#include <lbsrctermsponge.h>

Inheritance diagram for maia::lb::LbSrcTerm_sponge< nDim, nDist, SysEqn >:

Collaboration diagram for maia::lb::LbSrcTerm_sponge< nDim, nDist, SysEqn >:

Classes
struct	SpongeCell

Public Member Functions
	LbSrcTerm_sponge (LbSolverDxQy< nDim, nDist, SysEqn > *p_solver)
void	init () override
	Initialize properties common by all lb sponge terms. More...
Public Member Functions inherited from maia::lb::LbSrcTerm< nDim, nDist, SysEqn >
virtual void	init ()=0
virtual void	apply_preCollision ()=0
virtual void	apply_postCollision ()=0
virtual void	apply_postPropagation ()=0
virtual	~LbSrcTerm ()=default

Protected Member Functions
MInt	a_spongeCellId (const MInt cellId)
	Get index of cellId in m_spongeCells, returns -1 if unavailable. More...
void	readProperties () override
	Reading basics properties common for all lb sponge terms. More...
virtual void	readProperties ()=0

Protected Attributes
LbSolverDxQy< nDim, nDist, SysEqn > *	m_solver
MBool	m_isActive = false
std::vector< SpongeCell >	m_spongeCells
std::unordered_map< MInt, MInt >	m_mapCellId2SpongeCellId
MFloat	m_spongeLayerThickness = 0.0
std::array< MFloat, 2 *nDim >	m_spongeThicknessFactor {}
MFloat	m_spongeSigma = 0.0
MFloat	m_spongeBeta = 2.0
MFloat	m_trgRho = 1.0
std::array< MFloat, nDim >	m_trgU {}

Private Member Functions
void	updateMapCellId2PmlCellId ()
	Update m_mapCellIds2PmlCellId. More...

Additional Inherited Members
Public Types inherited from maia::lb::LbSrcTerm< nDim, nDist, SysEqn >
using	SysEqn = SysEqn
Static Public Attributes inherited from maia::lb::LbSrcTerm< nDim, nDist, SysEqn >
static constexpr MInt	nDim
static constexpr MInt	nDist

Detailed Description

template<MInt nDim, MInt nDist, class SysEqn>
class maia::lb::LbSrcTerm_sponge< nDim, nDist, SysEqn >

Author

Miro Gondrum

Date

22.12.2023

Definition at line 22 of file lbsrctermsponge.h.

Constructor & Destructor Documentation

LbSrcTerm_sponge()

template<MInt nDim, MInt nDist, class SysEqn >

maia::lb::LbSrcTerm_sponge< nDim, nDist, SysEqn >::LbSrcTerm_sponge ( LbSolverDxQy< nDim, nDist, SysEqn > *  p_solver )

inline

Definition at line 62 of file lbsrctermsponge.h.

: m_solver(p_solver) { readProperties(); };

Member Function Documentation

a_spongeCellId()

template<MInt nDim, MInt nDist, class SysEqn >

MInt maia::lb::LbSrcTerm_sponge< nDim, nDist, SysEqn >::a_spongeCellId ( const MInt  cellId )

inlineprotected

Author

Miro Gondrum

Date

22.12.2023

Definition at line 50 of file lbsrctermsponge.h.

                                         {
    MInt spongeCellId = -1;
    auto search = m_mapCellId2SpongeCellId.find(cellId);
    if(search != m_mapCellId2SpongeCellId.end()) {
      spongeCellId = search->second;
    }
    return spongeCellId;
  };

init()

template<MInt nDim, MInt nDist, class SysEqn >

void maia::lb::LbSrcTerm_sponge< nDim, nDist, SysEqn >::init

overridevirtual

Author

Miro Gondrum

Date

22.12.2023

Implements maia::lb::LbSrcTerm< nDim, nDist, SysEqn >.

Definition at line 135 of file lbsrctermsponge.h.

                                                 {
  TRACE();
  m_isActive = (m_spongeLayerThickness > 0.0) && m_solver->isActive();
  if(!m_isActive) return;
 
  const MFloat epsilon = m_solver->c_cellLengthAtLevel(m_solver->maxLevel()) / 1000.0;
  std::array<MFloat, 2 * nDim> domainBoundaries{};
  {
    const MFloat halfCellWidth = F1B2 * m_solver->grid().cellLengthAtCell(0);
    for(MInt i = 0; i < nDim; i++) {
      domainBoundaries[2 * i + 0] = m_solver->a_coordinate(0, i) - halfCellWidth;
      domainBoundaries[2 * i + 1] = m_solver->a_coordinate(0, i) + halfCellWidth;
    }
  }
 
  for(MInt cellId = 0; cellId < m_solver->m_cells.size(); cellId++) {
    if(!m_solver->c_isLeafCell(cellId)) continue;
    const MFloat halfCellWidth = F1B2 * m_solver->grid().cellLengthAtCell(cellId);
    for(MInt i = 0; i < nDim; i++) {
      domainBoundaries[2 * i + 0] =
          std::min(domainBoundaries[2 * i + 0], m_solver->a_coordinate(cellId, i) - halfCellWidth);
      domainBoundaries[2 * i + 1] =
          std::max(domainBoundaries[2 * i + 1], m_solver->a_coordinate(cellId, i) + halfCellWidth);
    }
  }
  // exchange domain boundaries
  std::array<MFloat, nDim> tmpMin{};
  std::array<MFloat, nDim> tmpMax{};
  for(MInt i = 0; i < nDim; i++) {
    tmpMin[i] = domainBoundaries[2 * i + 0];
    tmpMax[i] = domainBoundaries[2 * i + 1];
  }
  MPI_Allreduce(MPI_IN_PLACE, tmpMin.data(), nDim, maia::type_traits<MFloat>::mpiType(), MPI_MIN, m_solver->mpiComm(),
                AT_, "MPI_IN_PLACE", "tmpMin");
  MPI_Allreduce(MPI_IN_PLACE, tmpMax.data(), nDim, maia::type_traits<MFloat>::mpiType(), MPI_MAX, m_solver->mpiComm(),
                AT_, "MPI_IN_PLACE", "tmpMax");
  for(MInt i = 0; i < nDim; i++) {
    domainBoundaries[2 * i + 0] = tmpMin[i];
    domainBoundaries[2 * i + 1] = tmpMax[i];
  }
 
  // fill sponge coordinate
  std::array<MFloat, 2 * nDim> spongeCoord{};
  for(MInt i = 0; i < nDim; i++) {
    spongeCoord[2 * i + 0] = domainBoundaries[2 * i + 0] + m_spongeLayerThickness * m_spongeThicknessFactor[2 * i + 0];
    spongeCoord[2 * i + 1] = domainBoundaries[2 * i + 1] - m_spongeLayerThickness * m_spongeThicknessFactor[2 * i + 1];
  }
  std::array<MFloat, 2 * nDim> F1BspongeCoord{};
  for(MInt i = 0; i < nDim; i++) {
    F1BspongeCoord[2 * i + 0] = 1.0 / std::max(epsilon, m_spongeLayerThickness * m_spongeThicknessFactor[2 * i + 0]);
    F1BspongeCoord[2 * i + 1] = 1.0 / std::max(epsilon, m_spongeLayerThickness * m_spongeThicknessFactor[2 * i + 1]);
  }
 
  // search sponge ids
  for(MInt cellId = 0; cellId < m_solver->m_cells.size(); cellId++) {
    if(m_solver->a_isHalo(cellId)) continue;
 
    std::array<MFloat, nDim> dist{};
    for(MInt i = 0; i < nDim; i++) {
      const MUint distIdNegSide = 2 * i + 0;
      const MUint distIdPosSide = 2 * i + 1;
      const MFloat distNegSide =
          (spongeCoord[distIdNegSide] - m_solver->a_coordinate(cellId, i)) * F1BspongeCoord[distIdNegSide];
      const MFloat distPosSide =
          (m_solver->a_coordinate(cellId, i) - spongeCoord[distIdPosSide]) * F1BspongeCoord[distIdPosSide];
      dist[i] = std::max(distNegSide, distPosSide);
    }
 
    // choose the farthest sponge region
    const MFloat relDist = *std::max_element(dist.begin(), dist.end());
 
    if(relDist <= 0.0) continue;
 
    const MFloat nodeDist = std::pow(relDist, m_spongeBeta);
    const MFloat spongeFactor = m_spongeSigma * nodeDist;
 
    constexpr MFloat epsSpongeFactor = 1e-15;
    if(spongeFactor > epsSpongeFactor) {
      auto& cell = m_spongeCells.emplace_back();
      cell.cellId = cellId;
      cell.spongeFactor = spongeFactor;
    }
  }
  // Update map cellId->spongeCellId
  updateMapCellId2PmlCellId();
}

readProperties()

template<MInt nDim, MInt nDist, class SysEqn >

void maia::lb::LbSrcTerm_sponge< nDim, nDist, SysEqn >::readProperties

overrideprotectedvirtual

Author

Miro Gondrum

Date

22.12.2023

Implements maia::lb::LbSrcTerm< nDim, nDist, SysEqn >.

Definition at line 86 of file lbsrctermsponge.h.

                                                           {
  TRACE();
  const MInt solverId = m_solver->m_solverId;
 
  std::stringstream ss;
  ss << "--------------------------------------------------------------------------------" << std::endl;
  ss << " Sponge properties" << std::endl;
  ss << "--------------------------------------------------------------------------------" << std::endl;
  ss << " [Sponge region]" << std::endl;
 
  // sponge information
  m_spongeSigma = Context::getSolverProperty<MFloat>("spongeSigma", solverId, AT_, &m_spongeSigma);
  m_spongeLayerThickness =
      Context::getSolverProperty<MFloat>("spongeLayerThickness", solverId, AT_, &m_spongeLayerThickness);
  ss << "  spongeSigma:             " << m_spongeSigma << std::endl;
  ss << "  spongeLayerThickness:    " << m_spongeLayerThickness << std::endl;
  ss << "  spongeThicknessFactor: [ ";
  for(MInt i = 0; i < 2 * nDim; i++) {
    m_spongeThicknessFactor[i] = Context::getSolverProperty<MFloat>("spongeThicknessFactor", solverId, AT_, i);
    ss << m_spongeThicknessFactor[i] << " ";
  }
  ss << "]" << std::endl;
  ss << " [Sponge shape]" << std::endl;
  m_spongeBeta = Context::getSolverProperty<MFloat>("spongeBeta", solverId, AT_, &m_spongeBeta);
  ss << "  spongeBeta:              " << m_spongeBeta << std::endl;
  ss << " [Sponge target state]" << std::endl;
  m_trgRho = (m_solver->m_densityFluctuations) ? 0.0 : 1.0;
  m_trgRho = Context::getSolverProperty<MFloat>("spongeTrgRho", solverId, AT_, &m_trgRho);
  ss << "  spongeTrgRho:            " << m_trgRho << std::endl;
  m_trgU.fill(0.0);
  for(MInt i = 0; i < nDim; i++) {
    m_trgU[i] = Context::getSolverProperty<MFloat>("spongeTrgU", solverId, AT_, &m_trgU[i], i) * m_solver->m_Ma * LBCS;
  }
  ss << "  spongeTrgU:              ";
  for(MInt i = 0; i < nDim; i++) {
    ss << m_trgU[i] << " ";
  }
  ss << std::endl;
  ss << "--------------------------------------------------------------------------------" << std::endl;
 
  if(m_solver->domainId() == 0) std::cout << ss.str();
  m_log << ss.str();
}

updateMapCellId2PmlCellId()

template<MInt nDim, MInt nDist, class SysEqn >

void maia::lb::LbSrcTerm_sponge< nDim, nDist, SysEqn >::updateMapCellId2PmlCellId

private

Author

Miro Gondrum

Date

22.12.2023

Definition at line 72 of file lbsrctermsponge.h.

                                                                      {
  const MInt noSpongeCells = m_spongeCells.size();
  m_mapCellId2SpongeCellId.clear();
  m_mapCellId2SpongeCellId.reserve(noSpongeCells);
  for(MInt spongeCellId = 0; spongeCellId < noSpongeCells; spongeCellId++) {
    m_mapCellId2SpongeCellId.emplace(m_spongeCells[spongeCellId].cellId, spongeCellId);
  }
}

Member Data Documentation

m_isActive

template<MInt nDim, MInt nDist, class SysEqn >

MBool maia::lb::LbSrcTerm_sponge< nDim, nDist, SysEqn >::m_isActive = false

protected

Definition at line 29 of file lbsrctermsponge.h.

m_mapCellId2SpongeCellId

template<MInt nDim, MInt nDist, class SysEqn >

std::unordered_map<MInt, MInt> maia::lb::LbSrcTerm_sponge< nDim, nDist, SysEqn >::m_mapCellId2SpongeCellId

protected

Definition at line 37 of file lbsrctermsponge.h.

m_solver

template<MInt nDim, MInt nDist, class SysEqn >

LbSolverDxQy<nDim, nDist, SysEqn>* maia::lb::LbSrcTerm_sponge< nDim, nDist, SysEqn >::m_solver

protected

Definition at line 27 of file lbsrctermsponge.h.

m_spongeBeta

template<MInt nDim, MInt nDist, class SysEqn >

MFloat maia::lb::LbSrcTerm_sponge< nDim, nDist, SysEqn >::m_spongeBeta = 2.0

protected

Definition at line 42 of file lbsrctermsponge.h.

m_spongeCells

template<MInt nDim, MInt nDist, class SysEqn >

std::vector<SpongeCell> maia::lb::LbSrcTerm_sponge< nDim, nDist, SysEqn >::m_spongeCells

protected

Definition at line 36 of file lbsrctermsponge.h.

m_spongeLayerThickness

template<MInt nDim, MInt nDist, class SysEqn >

MFloat maia::lb::LbSrcTerm_sponge< nDim, nDist, SysEqn >::m_spongeLayerThickness = 0.0

protected

Definition at line 39 of file lbsrctermsponge.h.

m_spongeSigma

template<MInt nDim, MInt nDist, class SysEqn >

MFloat maia::lb::LbSrcTerm_sponge< nDim, nDist, SysEqn >::m_spongeSigma = 0.0

protected

Definition at line 41 of file lbsrctermsponge.h.

m_spongeThicknessFactor

template<MInt nDim, MInt nDist, class SysEqn >

std::array<MFloat, 2 * nDim> maia::lb::LbSrcTerm_sponge< nDim, nDist, SysEqn >::m_spongeThicknessFactor {}

protected

Definition at line 40 of file lbsrctermsponge.h.

m_trgRho

template<MInt nDim, MInt nDist, class SysEqn >

MFloat maia::lb::LbSrcTerm_sponge< nDim, nDist, SysEqn >::m_trgRho = 1.0

protected

Definition at line 43 of file lbsrctermsponge.h.

m_trgU

template<MInt nDim, MInt nDist, class SysEqn >

std::array<MFloat, nDim> maia::lb::LbSrcTerm_sponge< nDim, nDist, SysEqn >::m_trgU {}

protected

Definition at line 44 of file lbsrctermsponge.h.

---

The documentation for this class was generated from the following file:

• /home/gitlab-runner/scratch/builds/oxpnswJ6/1/aia/m-AIA/m-AIA/src/LB/lbsrctermsponge.h