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

Class to handle acoustic monopole source terms in lb solver. More...

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

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

Classes
struct	MonopoleInfo

Public Member Functions
	LbSrcTerm_monopole (LbSolverDxQy< nDim, nDist, SysEqn > *p_solver)
void	init () override
void	apply_preCollision () override
void	apply_postCollision () override
void	apply_postPropagation () override
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
void	readProperties () override
virtual void	readProperties ()=0

Private Attributes
LbSolverDxQy< nDim, nDist, SysEqn > *	m_solver
std::vector< MonopoleInfo >	m_monopole

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_monopole< nDim, nDist, SysEqn >

Author

Miro Gondrum, Benyamin Krisna

Date

01.02.2022

Definition at line 25 of file lbsrcterm.cpp.

Constructor & Destructor Documentation

LbSrcTerm_monopole()

template<MInt nDim, MInt nDist, class SysEqn >

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

inline

Definition at line 51 of file lbsrcterm.cpp.

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

Member Function Documentation

apply_postCollision()

template<MInt nDim, MInt nDist, class SysEqn >

void maia::lb::LbSrcTerm_monopole< nDim, nDist, SysEqn >::apply_postCollision

overridevirtual

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

Definition at line 164 of file lbsrcterm.cpp.

                                                                  {
  using Ld = LbLatticeDescriptor<nDim, nDist>;
  TRACE();
  for(auto& monopole : m_monopole) {
    if(!monopole.isActive) continue;
    const MInt noSrcTermCells = monopole.cellIds.size();
    for(MInt i = 0; i < noSrcTermCells; i++) {
      //-update source term
      monopole.srcTerms[i] =
          -monopole.rhoFluct * monopole.omega * sin((monopole.omega + monopole.phaseShift) * globalTimeStep);
      if(monopole.windowing) {
        // Windowing shall be performed for the first wave length
        if(globalTimeStep < 2 * PI / (monopole.omega)) {
          const MFloat S = (globalTimeStep == 0 ? 0.5 : 1);
          const MFloat hannHalfWindow = S * 0.5 * (1 - cos(monopole.omega * globalTimeStep / 2.0));
          monopole.srcTerms[i] *= hannHalfWindow;
        }
      }
 
      //-apply source term in solver
      const MInt cellId = monopole.cellIds[i];
      for(MInt j = 0; j < nDist; j++) {
        m_solver->a_distribution(cellId, j) += Ld::tp(Ld::distType(j)) * monopole.srcTerms[i];
      }
    }
  }
}

apply_postPropagation()

template<MInt nDim, MInt nDist, class SysEqn >

void maia::lb::LbSrcTerm_monopole< nDim, nDist, SysEqn >::apply_postPropagation ( )

inlineoverridevirtual

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

Definition at line 56 of file lbsrcterm.cpp.

{};

apply_preCollision()

template<MInt nDim, MInt nDist, class SysEqn >

void maia::lb::LbSrcTerm_monopole< nDim, nDist, SysEqn >::apply_preCollision ( )

inlineoverridevirtual

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

Definition at line 54 of file lbsrcterm.cpp.

{/*UNUSED FOR FIRST ORDER IMPLEMENTATION*/};

init()

template<MInt nDim, MInt nDist, class SysEqn >

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

overridevirtual

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

Definition at line 109 of file lbsrcterm.cpp.

                                                   {
  TRACE();
  for(auto& monopole : m_monopole) {
    // First, clear everything -> usable to reinit
    monopole.cellIds.clear();
    monopole.srcTerms.clear();
    // Now initialize
    if(monopole.radius < 0.0) {
      const MInt monopoleCellId = m_solver->getIdAtPoint(monopole.position.data());
      if(monopoleCellId != -1) {
        monopole.isActive = true;
        monopole.cellIds.push_back(monopoleCellId);
      }
    } else {
      const MFloat radiusSq = POW2(monopole.radius);
      for(MInt i = 0; i < m_solver->m_currentMaxNoCells; i++) {
        const MInt cellId = m_solver->m_activeCellList[i];
        MFloat radiusSq_ = 0.0;
        for(MInt d = 0; d < nDim; d++) {
          radiusSq_ += POW2(monopole.position[d] - m_solver->a_coordinate(cellId, d));
        }
        if(radiusSq_ < radiusSq) {
          monopole.isActive = true;
          monopole.cellIds.push_back(cellId);
        }
      }
    }
    const MInt noSrcTermCells = monopole.cellIds.size();
    monopole.srcTerms.resize(noSrcTermCells, 0.0);
    //- info output
    MInt noSrcTermCellsGlobal = noSrcTermCells;
    MPI_Allreduce(MPI_IN_PLACE, &noSrcTermCellsGlobal, 1, MPI_INT, MPI_SUM, m_solver->mpiComm(), AT_, "MPI_IN_PLACE",
                  "noSrcTermCellsGlobal");
    const MFloat ppw = 2 * PI * LBCS / monopole.omega; // ppw = lambda in LB units
    const MFloat periode = m_solver->m_referenceLength / (monopole.strouhal * m_solver->m_Ma * LBCS);
    std::stringstream ss;
    ss << "INFO: LbSrcTerm_monopole " << monopole.id << ":" << std::endl;
    ss << "    amplitude             :" << monopole.amplitude << std::endl;
    ss << "    rhoFluct              :" << monopole.rhoFluct << std::endl;
    ss << "    radius                :" << monopole.radius << std::endl;
    ss << "    strouhal              :" << monopole.strouhal << std::endl;
    ss << "    omega                 :" << monopole.omega << std::endl;
    ss << "    phaseShift            :" << monopole.phaseShift << std::endl;
    ss << "    windowing             :" << monopole.windowing << std::endl;
    ss << "    noSrcTermCells        :" << noSrcTermCellsGlobal << std::endl;
    ss << "    points per wave       :" << ppw << std::endl;
    ss << "    timesteps per periode :" << periode << std::endl;
    if(m_solver->domainId() == 0) {
      std::cout << ss.str();
    }
    m_log << ss.str();
  }
}

readProperties()

template<MInt nDim, MInt nDist, class SysEqn >

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

overrideprotectedvirtual

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

Definition at line 61 of file lbsrcterm.cpp.

                                                             {
  TRACE();
  const MInt solverId = m_solver->m_solverId;
  MInt noMonopole = 0;
  for(MInt id = 0;; id++) {
    if(!Context::propertyExists("monopoleAmplitude_" + std::to_string(id))) {
      break;
    }
    noMonopole++;
    auto& monopole = m_monopole.emplace_back();
    monopole.id = id;
    for(MInt d = 0; d < nDim; d++) {
      monopole.position[d] = Context::getSolverProperty<MFloat>("monopolePos_" + std::to_string(id), solverId, AT_);
    }
    monopole.amplitude = Context::getSolverProperty<MFloat>("monopoleAmplitude_" + std::to_string(id), solverId, AT_);
    monopole.strouhal = Context::getSolverProperty<MFloat>("monopoleStrouhal_" + std::to_string(id), solverId, AT_);
    monopole.radius =
        Context::getSolverProperty<MFloat>("monopoleRadius_" + std::to_string(id), solverId, AT_, &monopole.radius);
    monopole.windowing = Context::getSolverProperty<MBool>("monopoleWindowing_" + std::to_string(id), solverId, AT_,
                                                           &monopole.windowing);
    const MFloat phaseShiftStrouhal = Context::getSolverProperty<MFloat>("monopolePhaseShift_" + std::to_string(id),
                                                                         solverId, AT_, &monopole.phaseShift);
    if(monopole.radius < m_solver->c_cellLengthAtLevel(m_solver->maxLevel())) {
      m_log << "monopoleRadius < max level cell length: Hence, it is clipped to max level cell length" << std::endl;
      monopole.radius = m_solver->c_cellLengthAtLevel(m_solver->maxLevel());
    }
    const MFloat u_infty = m_solver->m_Ma * LBCS;
    const MFloat dxLb = m_solver->c_cellLengthAtLevel(m_solver->maxLevel());
    const MFloat massAmp = monopole.amplitude * (POW3(1.0 / dxLb)); // from STL to LB units m=rho*L^3
    const MFloat densityAmp = massAmp / (F4B3 * PI * POW3(monopole.radius / dxLb));
    monopole.omega = 2.0 * PI * (monopole.strouhal * u_infty / m_solver->m_referenceLength);
    monopole.rhoFluct = densityAmp;
    monopole.phaseShift = 2.0 * PI * (phaseShiftStrouhal * u_infty / m_solver->m_referenceLength);
    if(m_solver->domainId() == 0) {
      std::stringstream ss;
      ss << "INFO: LbSrcTerm_monopole " << monopole.id << " analytical solution:" << std::endl;
      ss << "rho(r,t)= 1.0 -" << (massAmp * POW2(monopole.omega)) / (4 * PI * POW2(LBCS)) << "/ (mag(coords)/" << dxLb
         << ") * cos(" << monopole.omega << "* (" << g_timeSteps - 1 << " - mag(coords)/" << dxLb << "/" << LBCS << "))"
         << std::endl;
      std::cout << ss.str();
    }
  }
  if(noMonopole == 0) {
    TERMM(1, "Property monopoleAmplitude_0 is missing!");
  }
}

Member Data Documentation

m_monopole

template<MInt nDim, MInt nDist, class SysEqn >

std::vector<MonopoleInfo> maia::lb::LbSrcTerm_monopole< nDim, nDist, SysEqn >::m_monopole

private

Definition at line 43 of file lbsrcterm.cpp.

m_solver

template<MInt nDim, MInt nDist, class SysEqn >

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

private

Definition at line 27 of file lbsrcterm.cpp.

---

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/lbsrcterm.cpp