#include <phaseFieldCoupling.h>

Collaboration diagram for olb::WellBalancedCahnHilliardPostProcessor:

Classes
struct	RHOS

struct	TAUS

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

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 597 of file phaseFieldCoupling.h.

Member Typedef Documentation

◆ parameters

using olb::WellBalancedCahnHilliardPostProcessor::parameters = meta::list<TAUS,RHOS>

Definition at line 601 of file phaseFieldCoupling.h.

Member Function Documentation

◆ apply()

template<typename CELL , typename PARAMETERS >

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

inline

Definition at line 608 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& cellCH = cells.template get<names::Component1>();
 
    V phi = cellCH.template getFieldComponent<descriptors::STATISTIC>(0);
    V mu = cellCH.template getField<descriptors::CHEM_POTENTIAL>();
    Vector<V,DESCRIPTOR::d> gradPhi{};
    Vector<V,DESCRIPTOR::d> gradMu{};
    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 = cellCH.neighbor(descriptors::c<DESCRIPTOR>(iPop)).template getFieldComponent<descriptors::STATISTIC>(0);
      const V mu_i = cellCH.neighbor(descriptors::c<DESCRIPTOR>(iPop)).template getField<descriptors::CHEM_POTENTIAL>();
      //const V phiMu_i = phi_i*mu_i;
      //gradPhi += phi_i * descriptors::c<DESCRIPTOR>(iPop) * descriptors::t<V,DESCRIPTOR>(iPop) * descriptors::invCs2<V,DESCRIPTOR>();
      //gradMu += mu_i * descriptors::c<DESCRIPTOR>(iPop) * descriptors::t<V,DESCRIPTOR>(iPop) * descriptors::invCs2<V,DESCRIPTOR>();
      if(int(cellCH.neighbor(descriptors::c<DESCRIPTOR>(iPop)).template getField<descriptors::BOUNDARY>())) gradMu += mu * descriptors::c<DESCRIPTOR>(iPop) * descriptors::t<V,DESCRIPTOR>(iPop) * descriptors::invCs2<V,DESCRIPTOR>();
      else gradMu += mu_i * descriptors::c<DESCRIPTOR>(iPop) * descriptors::t<V,DESCRIPTOR>(iPop) * descriptors::invCs2<V,DESCRIPTOR>();
      if(int(cellCH.neighbor(descriptors::c<DESCRIPTOR>(iPop)).template getField<descriptors::BOUNDARY>())) gradPhi += phi * descriptors::c<DESCRIPTOR>(iPop) * descriptors::t<V,DESCRIPTOR>(iPop) * descriptors::invCs2<V,DESCRIPTOR>();
      else 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 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;
 
    // Computation and storage of forces
    Vector<V,DESCRIPTOR::d> forceNS{};
    V u[DESCRIPTOR::d] {};
    forceNS += -phi*gradMu;
    //V mu = cellCH.template getField<descriptors::CHEM_POTENTIAL>();
    //forceNS += mu*gradPhi;
    auto externalBlockForce = cellNS.template getField<descriptors::EXTERNAL_FORCE>();
    cellNS.template setField<descriptors::FORCE>(externalBlockForce + 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);
 
    V source{};
    cellNS.computeU(u);
    for (int iD=0; iD < DESCRIPTOR::d; ++iD) {
      source += gradPhi[iD]*u[iD];
    }
    V source_old = cellCH.template getField<descriptors::SOURCE_OLD>();
    cellCH.template setField<descriptors::SOURCE>(1.5*source-0.5*source_old);
    cellCH.template setField<descriptors::SOURCE_OLD>(source);
    cellCH.template setField<descriptors::VELOCITY>(u);
  }

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

Here is the call graph for this function:

◆ getPriority()

int olb::WellBalancedCahnHilliardPostProcessor::getPriority ( ) const

inline

Definition at line 603 of file phaseFieldCoupling.h.

                          {
    return 0;
  }

Member Data Documentation

◆ scope

OperatorScope olb::WellBalancedCahnHilliardPostProcessor::scope = OperatorScope::PerCellWithParameters

staticconstexpr

Definition at line 598 of file phaseFieldCoupling.h.

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

src/dynamics/phaseFieldCoupling.h

Classes

Public Types

Public Member Functions

Static Public Attributes