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

Class to handle non-newtonian fluids. More...

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

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

Public Member Functions
	LbSrcTerm_nonnewtonian (LbSolverDxQy< nDim, nDist, SysEqn > *p_solver)
void	init () override
void	apply_preCollision () override
void	apply_postCollision () override
void	apply_postPropagation () override
MFloat	powerLaw (const MFloat gamma_dot)
MFloat	carreau (const MFloat gamma_dot)
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

Public Attributes
MFloat(LbSrcTerm_nonnewtonian::*	m_getNuFromNonNewtonianModel )(const MFloat gamma_dot)

Protected Member Functions
void	readProperties () override
virtual void	readProperties ()=0

Protected Attributes
LbSolverDxQy< nDim, nDist, SysEqn > *	m_solver
MFloat	m_nu0 = F0
MFloat	m_nuInf = F0
MFloat	m_lambda = F0
MFloat	m_n = F0
MFloat	m_a = F0
MString	m_model = ""

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

Author

Moritz Waldmann

Date

12.10.2023

Definition at line 24 of file lbsrctermnonnewtonian.cpp.

Constructor & Destructor Documentation

LbSrcTerm_nonnewtonian()

template<MInt nDim, MInt nDist, class SysEqn >

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

inline

Definition at line 39 of file lbsrctermnonnewtonian.cpp.

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

Member Function Documentation

apply_postCollision()

template<MInt nDim, MInt nDist, class SysEqn >

void maia::lb::LbSrcTerm_nonnewtonian< nDim, nDist, SysEqn >::apply_postCollision ( )

inlineoverridevirtual

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

Definition at line 43 of file lbsrctermnonnewtonian.cpp.

{/*NOT USED*/};

apply_postPropagation()

template<MInt nDim, MInt nDist, class SysEqn >

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

inlineoverridevirtual

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

Definition at line 44 of file lbsrctermnonnewtonian.cpp.

{/*NOT USED*/};

apply_preCollision()

template<MInt nDim, MInt nDist, class SysEqn >

void maia::lb::LbSrcTerm_nonnewtonian< nDim, nDist, SysEqn >::apply_preCollision

overridevirtual

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

Definition at line 92 of file lbsrctermnonnewtonian.cpp.

                                                                     {
  TRACE();
  LbSolverDxQy<nDim, nDist, SysEqn>& s = *(m_solver); // alias for readability
 
  s.m_nu = s.m_Ma * LBCS / s.m_Re * s.m_referenceLength;
  maia::parallelFor(0, s.m_currentMaxNoCells, [&](MInt index) {
    const MInt pCellId = s.m_activeCellList[index];
    const MInt lvlDiff = s.maxLevel() - s.a_level(pCellId);
    if((globalTimeStep - 1) % IPOW2(lvlDiff) != 0) return;
 
    constexpr MInt nDimSqr = nDim * nDim;
    std::array<MFloat, nDimSqr> c{};
    const MFloat rho = s.a_variable(pCellId, s.PV->RHO);
#ifndef WAR_NVHPC_PSTL
    const MFloat* const u = &s.a_variable(pCellId, s.PV->U);
    const MFloat* const dist = &s.a_oldDistribution(pCellId, 0);
    s.sysEqn().calcMomentumFlux(rho, u, dist, c.data());
#else
    MFloat u[nDim] = {F0};
    MFloat dist[nDist] = {F0};
    for(MInt d = 0; d < nDim; d++) {
      u[d] = s.a_variable(pCellId, d);
    }
    for(MInt d = 0; d < nDist; d++) {
      dist[d] = s.a_oldDistribution(pCellId, d);
    }
    s.sysEqn().calcMomentumFlux(rho, u, dist, c.data());
#endif
 
    // Compute derivative of rate-of-strain tensor
    std::array<MFloat, nDimSqr> localS{};
 
    MFloat nu = F0;
    MInt noIterations = 0;
    MBool converged = false;
    MFloat nuOld = s.a_oldNu(pCellId);
    const MFloat F1Brho = F1 / rho;
    while(!converged && noIterations < 50) {
      MFloat omega = F2 / (F6 * nuOld * FFPOW2(lvlDiff) + F1);
      for(MInt d = 0; d < nDimSqr; d++) {
        localS[d] = -F3B2 * omega * F1Brho * c[d];
      }
 
      if(nDim == 3) {
        const MFloat volumeStrains = F1B3 * (localS[0] + localS[4] + localS[8]);
        localS[0] -= volumeStrains;
        localS[4] -= volumeStrains;
        localS[8] -= volumeStrains;
      }
 
      // Compute second invariant of the rate-of-strain tensor
      MFloat D = F0; // Second invariant of rate-of-strain tensor
      for(MInt d = 0; d < nDimSqr; d++) {
        D += localS[d] * localS[d];
      }
      const MFloat gamma_dot = sqrt(F2 * D);
 
      nu = (this->*m_getNuFromNonNewtonianModel)(gamma_dot);
 
      if(fabs(nuOld - nu) < 1e-10) converged = true;
 
      nuOld = nu;
      noIterations++;
    }
 
    s.a_nu(pCellId) = nu;
  });
}

carreau()

template<MInt nDim, MInt nDist, class SysEqn >

MFloat maia::lb::LbSrcTerm_nonnewtonian< nDim, nDist, SysEqn >::carreau

(

const MFloat

gamma_dot

)

Definition at line 174 of file lbsrctermnonnewtonian.cpp.

                                                                                  {
  TRACE();
 
  // Compute local viscosity
  const MFloat exp = (m_n - F1) / m_a;
  const MFloat base = pow(m_lambda * gamma_dot, m_a) + F1;
  const MFloat nu = m_nuInf + (m_nu0 - m_nuInf) * (pow(base, exp));
 
  return nu;
}

init()

template<MInt nDim, MInt nDist, class SysEqn >

void maia::lb::LbSrcTerm_nonnewtonian< nDim, nDist, SysEqn >::init ( )

inlineoverridevirtual

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

Definition at line 41 of file lbsrctermnonnewtonian.cpp.

{/*NOT USED*/};

powerLaw()

template<MInt nDim, MInt nDist, class SysEqn >

MFloat maia::lb::LbSrcTerm_nonnewtonian< nDim, nDist, SysEqn >::powerLaw

(

const MFloat

gamma_dot

)

Definition at line 162 of file lbsrctermnonnewtonian.cpp.

                                                                                   {
  TRACE();
 
  // Compute local viscosity
  const MFloat exp = m_n - F1;
  const MFloat base = gamma_dot;
  const MFloat nu = m_nu0 * (pow(base, exp));
 
  return nu;
}

readProperties()

template<MInt nDim, MInt nDist, class SysEqn >

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

overrideprotectedvirtual

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

Definition at line 53 of file lbsrctermnonnewtonian.cpp.

                                                                 {
  TRACE();
  const MInt solverId = m_solver->m_solverId;
 
  m_model = Context::getSolverProperty<MString>("nonNewtonianModel", solverId, AT_);
 
  switch(string2enum(m_model)) {
    case CARREAU: {
      m_nu0 = m_solver->m_nu;
      const MFloat nu0 = Context::getSolverProperty<MFloat>("nu0", solverId, AT_);
      const MFloat c_nu = nu0 / m_nu0;
 
      const MFloat nuInf = Context::getSolverProperty<MFloat>("nuInf", solverId, AT_);
      m_nuInf = nuInf / c_nu;
 
      const MFloat lambda = Context::getSolverProperty<MFloat>("lambda", solverId, AT_);
 
      m_lambda = lambda * m_solver->m_referenceLength / (m_solver->m_Ma * LBCS);
 
      m_n = Context::getSolverProperty<MFloat>("nonNewtonian_n", solverId, AT_);
      m_a = Context::getSolverProperty<MFloat>("nonNewtonian_a", solverId, AT_);
      m_getNuFromNonNewtonianModel = &LbSrcTerm_nonnewtonian::carreau;
      break;
    }
    case POWERLAW: {
      m_n = Context::getSolverProperty<MFloat>("nonNewtonian_n", solverId, AT_);
 
      m_solver->m_nu = pow(m_solver->m_Ma * LBCS, F2 - m_n) / m_solver->m_Re * pow(m_solver->m_referenceLength, m_n);
      m_nu0 = m_solver->m_nu;
      m_getNuFromNonNewtonianModel = &LbSrcTerm_nonnewtonian::powerLaw;
      break;
    }
    default: {
      mTerm(1, AT_, "This is not an implemented model!!!");
    }
  }
}

Member Data Documentation

m_a

template<MInt nDim, MInt nDist, class SysEqn >

MFloat maia::lb::LbSrcTerm_nonnewtonian< nDim, nDist, SysEqn >::m_a = F0

protected

Definition at line 32 of file lbsrctermnonnewtonian.cpp.

m_getNuFromNonNewtonianModel

template<MInt nDim, MInt nDist, class SysEqn >

MFloat(LbSrcTerm_nonnewtonian::* maia::lb::LbSrcTerm_nonnewtonian< nDim, nDist, SysEqn >::m_getNuFromNonNewtonianModel) (const MFloat gamma_dot)

Definition at line 46 of file lbsrctermnonnewtonian.cpp.

m_lambda

template<MInt nDim, MInt nDist, class SysEqn >

MFloat maia::lb::LbSrcTerm_nonnewtonian< nDim, nDist, SysEqn >::m_lambda = F0

protected

Definition at line 30 of file lbsrctermnonnewtonian.cpp.

m_model

template<MInt nDim, MInt nDist, class SysEqn >

MString maia::lb::LbSrcTerm_nonnewtonian< nDim, nDist, SysEqn >::m_model = ""

protected

Definition at line 33 of file lbsrctermnonnewtonian.cpp.

m_n

template<MInt nDim, MInt nDist, class SysEqn >

MFloat maia::lb::LbSrcTerm_nonnewtonian< nDim, nDist, SysEqn >::m_n = F0

protected

Definition at line 31 of file lbsrctermnonnewtonian.cpp.

m_nu0

template<MInt nDim, MInt nDist, class SysEqn >

MFloat maia::lb::LbSrcTerm_nonnewtonian< nDim, nDist, SysEqn >::m_nu0 = F0

protected

Definition at line 28 of file lbsrctermnonnewtonian.cpp.

m_nuInf

template<MInt nDim, MInt nDist, class SysEqn >

MFloat maia::lb::LbSrcTerm_nonnewtonian< nDim, nDist, SysEqn >::m_nuInf = F0

protected

Definition at line 29 of file lbsrctermnonnewtonian.cpp.

m_solver

template<MInt nDim, MInt nDist, class SysEqn >

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

protected

Definition at line 26 of file lbsrctermnonnewtonian.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/lbsrctermnonnewtonian.cpp