olb::PhaseFieldCouplingPostProcessor2D< T, DESCRIPTOR > Class Template Reference

#include <navierStokesAdvectionDiffusionCouplingPostProcessor2D.h>

Inheritance diagram for olb::PhaseFieldCouplingPostProcessor2D< T, DESCRIPTOR >:

Collaboration diagram for olb::PhaseFieldCouplingPostProcessor2D< T, DESCRIPTOR >:

Public Member Functions
	PhaseFieldCouplingPostProcessor2D (int x0_, int x1_, int y0_, int y1_, T rho_L, T rho_H, T mu_L, T mu_H, T surface_tension, T interface_thickness, std::vector< BlockStructureD< 2 > * > partners_)
int	extent () const override
	Extent of application area (0 for purely local operations)
int	extent (int whichDirection) const override
	Extent of application area along a direction (0 or 1)
void	process (BlockLattice< T, DESCRIPTOR > &blockLattice) override
	Execute post-processing step.
void	processSubDomain (BlockLattice< T, DESCRIPTOR > &blockLattice, int x0_, int x1_, int y0_, int y1_) override
	Execute post-processing step on a sublattice.
Public Member Functions inherited from olb::PostProcessor2D< T, DESCRIPTOR >
	PostProcessor2D ()
virtual	~PostProcessor2D ()
std::string &	getName ()
	read and write access to name
std::string const &	getName () const
	read only access to name
int	getPriority () const
	read only access to priority

Additional Inherited Members
Protected Attributes inherited from olb::PostProcessor2D< T, DESCRIPTOR >
int	_priority

Detailed Description

template<typename T, typename DESCRIPTOR>
class olb::PhaseFieldCouplingPostProcessor2D< T, DESCRIPTOR >

Definition at line 82 of file navierStokesAdvectionDiffusionCouplingPostProcessor2D.h.

Constructor & Destructor Documentation

PhaseFieldCouplingPostProcessor2D()

template<typename T , typename DESCRIPTOR >

olb::PhaseFieldCouplingPostProcessor2D< T, DESCRIPTOR >::PhaseFieldCouplingPostProcessor2D	(	int	x0_,
		int	x1_,
		int	y0_,
		int	y1_,
		T	rho_L,
		T	rho_H,
		T	mu_L,
		T	mu_H,
		T	surface_tension,
		T	interface_thickness,
		std::vector< BlockStructureD< 2 > * >	partners_ )

Definition at line 145 of file navierStokesAdvectionDiffusionCouplingPostProcessor2D.hh.

  :  x0(x0_), x1(x1_), y0(y0_), y1(y1_),
     _rho_L(rho_L), _rho_H(rho_H), _delta_rho(rho_H - rho_L), _mu_L(mu_L), _mu_H(mu_H), _surface_tension(surface_tension), _interface_thickness(interface_thickness),
     _beta(12.0 * surface_tension / interface_thickness), _kappa(1.5 * surface_tension * interface_thickness)
{
  this->getName() = "PhaseFieldCouplingPostProcessor2D";
  tPartner = static_cast<BlockLattice<T,descriptors::D2Q5<descriptors::VELOCITY,descriptors::INTERPHASE_NORMAL>> *>(partners_[0]);
}

References olb::PostProcessor2D< T, DESCRIPTOR >::getName().

Here is the call graph for this function:

Member Function Documentation

extent() [1/2]

template<typename T , typename DESCRIPTOR >

int olb::PhaseFieldCouplingPostProcessor2D< T, DESCRIPTOR >::extent ( ) const

inlineoverridevirtual

Extent of application area (0 for purely local operations)

Implements olb::PostProcessor2D< T, DESCRIPTOR >.

Definition at line 87 of file navierStokesAdvectionDiffusionCouplingPostProcessor2D.h.

  {
    return 0;
  }

extent() [2/2]

template<typename T , typename DESCRIPTOR >

int olb::PhaseFieldCouplingPostProcessor2D< T, DESCRIPTOR >::extent ( int direction ) const

inlineoverridevirtual

Extent of application area along a direction (0 or 1)

Implements olb::PostProcessor2D< T, DESCRIPTOR >.

Definition at line 91 of file navierStokesAdvectionDiffusionCouplingPostProcessor2D.h.

  {
    return 0;
  }

process()

template<typename T , typename DESCRIPTOR >

void olb::PhaseFieldCouplingPostProcessor2D< T, DESCRIPTOR >::process ( BlockLattice< T, DESCRIPTOR > & blockLattice )

overridevirtual

Execute post-processing step.

Implements olb::PostProcessor2D< T, DESCRIPTOR >.

Definition at line 269 of file navierStokesAdvectionDiffusionCouplingPostProcessor2D.hh.

{
  processSubDomain(blockLattice, x0, x1, y0, y1);
}

processSubDomain()

template<typename T , typename DESCRIPTOR >

void olb::PhaseFieldCouplingPostProcessor2D< T, DESCRIPTOR >::processSubDomain ( BlockLattice< T, DESCRIPTOR > & blockLattice, int x0_, int x1_, int y0_, int y1_ )

overridevirtual

Execute post-processing step on a sublattice.

Implements olb::PostProcessor2D< T, DESCRIPTOR >.

Definition at line 158 of file navierStokesAdvectionDiffusionCouplingPostProcessor2D.hh.

{
 
  int newX0, newX1, newY0, newY1;
  if ( util::intersect ( x0, x1, y0, y1,
                         x0_, x1_, y0_, y1_,
                         newX0, newX1, newY0, newY1 ) ) {
 
    // generate phi cache
    auto& phi_cache = blockLattice.template getField<PHI_CACHE>()[0];
    for (int iX=newX0-1; iX<=newX1+1; ++iX) {
      for (int iY=newY0-1; iY<=newY1+1; ++iY) {
        phi_cache[blockLattice.getCellId(iX,iY)] = util::max(util::min(tPartner->get(iX,iY).computeRho(), 1.0), 0.0);
      }
    }
 
    for (int iX=newX0; iX<=newX1; ++iX) {
      for (int iY=newY0; iY<=newY1; ++iY) {
        auto cell = blockLattice.get(iX,iY);
        auto partnerCell = tPartner->get(iX,iY);
 
        T phi = phi_cache[blockLattice.getCellId(iX,iY)];
 
        // compute rho from phi
        T rho = _rho_L + phi * _delta_rho;
 
        // compute dynamic viscosity
        T viscosity = _mu_L + phi * (_mu_H - _mu_L);
 
        // get relaxation time
        T tau = cell.template getField<descriptors::TAU_EFF>();
 
        // compute grad phi and laplace phi
        Vector<T,L::d> grad_phi(0.0, 0.0);
        T laplace_phi = 0.0;
        for (int iPop = 1; iPop < L::q; ++iPop) {
          int nextX = iX + descriptors::c<L>(iPop,0);
          int nextY = iY + descriptors::c<L>(iPop,1);
          T neighbor_phi = phi_cache[blockLattice.getCellId(nextX,nextY)];
 
          laplace_phi += (neighbor_phi - phi) * descriptors::t<T,L>(iPop);
 
          neighbor_phi *= descriptors::t<T,L>(iPop);
          grad_phi += neighbor_phi * descriptors::c<L>(iPop);
        }
        grad_phi *= descriptors::invCs2<T,L>();
        laplace_phi *= 2.0 * descriptors::invCs2<T,L>();
 
        // compute grad rho
        Vector<T,L::d> grad_rho(_delta_rho, _delta_rho);
        grad_rho *= grad_phi;
 
        // compute interphase normal, save to external field
        T norm_grad_phi = norm(grad_phi);
        norm_grad_phi = util::max(norm_grad_phi, std::numeric_limits<T>::epsilon());
        partnerCell.template setField<descriptors::INTERPHASE_NORMAL>(grad_phi / norm_grad_phi);
 
        // compute forces (F_s, F_b, F_p, F_nu)
        // F_s (surface tension)
        T chemical_potential = (4.0 * _beta * (phi - 0.0) * (phi - 0.5) * (phi - 1.0)) - _kappa * laplace_phi;
        T surface_tension_force[] = {chemical_potential*grad_phi[0], chemical_potential*grad_phi[1]};
 
        // F_b (body force, e.g. bouyancy)
        T body_force[] = {0.0, 0.0};
 
        // F_p (pressure)
        T pressure = blockLattice.get(iX,iY).computeRho();
        T pressure_force[] = {-pressure / descriptors::invCs2<T,L>() * grad_rho[0], -pressure / descriptors::invCs2<T,L>() * grad_rho[1]};
 
        // F_nu (viscous)
        T viscous_force[] = {0.0, 0.0};
        T rho_tmp, u_tmp[2];
        cell.computeRhoU( rho_tmp, u_tmp );
        T p_tmp = rho_tmp / descriptors::invCs2<T,DESCRIPTOR>();
        T uSqr_tmp = util::normSqr<T,DESCRIPTOR::d>(u_tmp);
        for (int iPop = 0; iPop < L::q; ++iPop) {
          T fEq = cell.getDynamics()->computeEquilibrium( iPop, p_tmp, u_tmp);
          T fNeq = cell[iPop] - fEq;
          for (int iD = 0; iD < L::d; ++iD) {
            for (int jD = 0; jD < L::d; ++jD) {
              viscous_force[iD] += descriptors::c<L>(iPop,iD) * descriptors::c<L>(iPop,jD) * fNeq * grad_rho[jD];
            }
          }
        }
        for (int iD = 0; iD < L::d; ++iD) {
          viscous_force[iD] *= - viscosity / rho / tau * descriptors::invCs2<T,L>();
        }
 
        // save force/rho to external field
        auto force = cell.template getFieldPointer<descriptors::FORCE>();
        for (int iD = 0; iD < L::d; ++iD) {
          force[iD] = (surface_tension_force[iD] + body_force[iD] + pressure_force[iD] + viscous_force[iD]) / rho;
        }
 
        // compute u, save to external field
        Vector<T,DESCRIPTOR::template size<descriptors::VELOCITY>()> u;
        cell.computeU(u.data());
        partnerCell.template setField<descriptors::VELOCITY>(u);
 
        // compute relaxation time, save to external field
 
        tau = viscosity / rho * descriptors::invCs2<T,L>() + 0.5;
        cell.template setField<descriptors::TAU_EFF>(tau);
      }
    }
  }
}

References olb::BlockLattice< T, DESCRIPTOR >::get(), olb::BlockStructureD< D >::getCellId(), olb::util::intersect(), olb::util::max(), olb::util::min(), and olb::norm().

Here is the call graph for this function:

---

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

• src/dynamics/navierStokesAdvectionDiffusionCouplingPostProcessor2D.h
• src/dynamics/navierStokesAdvectionDiffusionCouplingPostProcessor2D.hh