olb::AllenCahnPostProcessor Struct Reference

#include <phaseFieldCoupling.h>

Collaboration diagram for olb::AllenCahnPostProcessor:

Classes
struct	NONLOCALITY
struct	RHOS
struct	SIGMA
struct	TAUS
struct	W

Public Types
using	parameters = meta::list<SIGMA,W,TAUS,RHOS,NONLOCALITY>

Public Member Functions
int	getPriority () const
template<typename CELL , typename PARAMETERS >
void	apply (CELL &cells, PARAMETERS &parameters) any_platform

Static Public Attributes
static constexpr OperatorScope	scope = OperatorScope::PerCellWithParameters

Detailed Description

Definition at line 270 of file phaseFieldCoupling.h.

Member Typedef Documentation

parameters

using olb::AllenCahnPostProcessor::parameters = meta::list<SIGMA,W,TAUS,RHOS,NONLOCALITY>

Definition at line 277 of file phaseFieldCoupling.h.

Member Function Documentation

apply()

template<typename CELL , typename PARAMETERS >

void olb::AllenCahnPostProcessor::apply ( CELL & cells, PARAMETERS & parameters )

inline

Definition at line 284 of file phaseFieldCoupling.h.

  {
    using V = typename CELL::template value_t<names::NavierStokes>::value_t;
    using DESCRIPTOR = typename CELL::template value_t<names::NavierStokes>::descriptor_t;
 
    auto& cellNS = cells.template get<names::NavierStokes>();
    auto& cellAC = cells.template get<names::Component1>();
 
    V phi = cellAC.template getFieldComponent<descriptors::STATISTIC>(0);
    Vector<V,DESCRIPTOR::d> gradPhi{};
    V laplacePhi = 0;
    //TODO: use lattice gradient schemes here from Cahn-Hilliard implementation
    for (int iPop=0; iPop < DESCRIPTOR::q; ++iPop) {
      const V phi_i = cellAC.neighbor(descriptors::c<DESCRIPTOR>(iPop)).template getFieldComponent<descriptors::STATISTIC>(0);
      gradPhi += phi_i * descriptors::c<DESCRIPTOR>(iPop) * descriptors::t<V,DESCRIPTOR>(iPop) * descriptors::invCs2<V,DESCRIPTOR>();
      laplacePhi += 2*(phi_i - phi) * descriptors::t<V,DESCRIPTOR>(iPop) * descriptors::invCs2<V,DESCRIPTOR>();
    }
 
    auto scale = cellNS.template getField<descriptors::SCALAR>();
    auto sigma = parameters.template get<SIGMA>()*(0.99*scale+0.01);
    auto w = parameters.template get<W>();
    auto rho_v = parameters.template get<RHOS>()[0];
    auto rho_l = parameters.template get<RHOS>()[1];
    V rho = rho_v + (rho_l-rho_v)*phi;
    auto tau_v = parameters.template get<TAUS>()[0];
    auto tau_l = parameters.template get<TAUS>()[1];
    V tau = (tau_v + (tau_l-tau_v)*phi);//*(-9.*scale+10.);
    auto gamma = parameters.template get<NONLOCALITY>();
    auto tau_mobil = parameters.template get<TAUS>()[2];
    V M = (tau_mobil-0.5)/descriptors::invCs2<V,DESCRIPTOR>();
 
    // Computation and storage of forces
    Vector<V,DESCRIPTOR::d> forceNS{};
    V u[DESCRIPTOR::d] {};
    //cellNS.computeU(u);
    V k = 1.5*sigma*w;
    V beta = 12*sigma/w;
    V mu = 4*beta*phi*(phi-1.)*(phi-0.5)-k*laplacePhi;
    forceNS += mu*gradPhi;
    auto externalForce = cellNS.template getField<descriptors::EXTERNAL_FORCE>();
    cellNS.template setField<descriptors::FORCE>(externalForce + forceNS/rho);
    cellNS.template setField<descriptors::NABLARHO>((rho_l-rho_v)*gradPhi);
    cellNS.template setField<descriptors::TAU_EFF>(tau);
    cellNS.template setField<descriptors::RHO>(rho);
    cellNS.computeU(u);
 
    V psi = cellAC.template getField<descriptors::PSI>();
    V interfaceIndicator = 0.;
    if (util::fabs(psi) < 3.*w) interfaceIndicator = 1;
    Vector<V,DESCRIPTOR::d> forceAC{};
    Vector<V,DESCRIPTOR::d> old_phiU{};
    Vector<V,DESCRIPTOR::d> n{};
    Vector<V,DESCRIPTOR::d> phiU{};
    V gradPhiSqr = 0;
    for (int iD=0; iD < DESCRIPTOR::d; ++iD) {
      gradPhiSqr += gradPhi[iD]*gradPhi[iD];
      phiU[iD] = phi*u[iD];
    }
    if (gradPhiSqr >= 1e-28) {
      n += gradPhi/util::sqrt(gradPhiSqr);
    }
    old_phiU = cellAC.template getField<descriptors::OLD_PHIU>();
    cellAC.template setField<descriptors::OLD_PHIU>(phiU);
    V lambda = 4*phi*(1.-phi)/w;
    V D_N = 4*beta/k*(interfaceIndicator-1.)*(phi*(phi-1.)*(phi-0.5)-gamma*(1.-phi)*phi);
    V source_old = cellAC.template getField<descriptors::SOURCE_OLD>();
    cellAC.template setField<descriptors::SOURCE_OLD>(M*D_N);
    forceAC += (phiU - old_phiU) + interfaceIndicator*lambda*n/descriptors::invCs2<V,DESCRIPTOR>();
    cellAC.template setField<descriptors::FORCE>(forceAC);
    V source = 1.5*M*D_N-0.5*source_old;
    cellAC.template setField<descriptors::SOURCE>(source);
    cellAC.template setField<descriptors::VELOCITY>(u);
  }

References olb::descriptors::c(), olb::util::fabs(), olb::descriptors::invCs2(), olb::util::sqrt(), and olb::descriptors::t().

Here is the call graph for this function:

getPriority()

int olb::AllenCahnPostProcessor::getPriority ( ) const

inline

Definition at line 279 of file phaseFieldCoupling.h.

                          {
    return 0;
  }

Member Data Documentation

scope

OperatorScope olb::AllenCahnPostProcessor::scope = OperatorScope::PerCellWithParameters

staticconstexpr

Definition at line 271 of file phaseFieldCoupling.h.

---

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

• src/dynamics/phaseFieldCoupling.h