#include <navierStokesAdvectionDiffusionCouplingPostProcessor3D.h>

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

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

Public Member Functions
	PhaseFieldCouplingPostProcessor3D (int x0_, int x1_, int y0_, int y1_, int z0_, int z1_, T rho_L, T rho_H, T mu_L, T mu_H, T surface_tension, T interface_thickness, std::vector< BlockStructureD< 3 > * > 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_, int z0_, int z1_) override
	Execute post-processing step on a sublattice.

Public Member Functions inherited from olb::PostProcessor3D< T, DESCRIPTOR >
	PostProcessor3D ()

virtual	~PostProcessor3D ()

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::PostProcessor3D< T, DESCRIPTOR >
int	_priority

Detailed Description

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

Definition at line 86 of file navierStokesAdvectionDiffusionCouplingPostProcessor3D.h.

Constructor & Destructor Documentation

◆ PhaseFieldCouplingPostProcessor3D()

template<typename T , typename DESCRIPTOR >

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

Definition at line 150 of file navierStokesAdvectionDiffusionCouplingPostProcessor3D.hh.

  :  x0(x0_), x1(x1_), y0(y0_), y1(y1_), z0(z0_), z1(z1_),
     _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() = "PhaseFieldCouplingPostProcessor3D";
  tPartner = static_cast<BlockLattice<T,descriptors::D3Q7<descriptors::VELOCITY,descriptors::INTERPHASE_NORMAL>> *>(partners_[0]);
}

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

Here is the call graph for this function:

Member Function Documentation

◆ extent() [1/2]

template<typename T , typename DESCRIPTOR >

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

inlineoverridevirtual

Extent of application area (0 for purely local operations)

Implements olb::PostProcessor3D< T, DESCRIPTOR >.

Definition at line 91 of file navierStokesAdvectionDiffusionCouplingPostProcessor3D.h.

  {
    return 0;
  }

◆ extent() [2/2]

template<typename T , typename DESCRIPTOR >

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

inlineoverridevirtual

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

Implements olb::PostProcessor3D< T, DESCRIPTOR >.

Definition at line 95 of file navierStokesAdvectionDiffusionCouplingPostProcessor3D.h.

  {
    return 0;
  }

◆ process()

template<typename T , typename DESCRIPTOR >

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

overridevirtual

Execute post-processing step.

Implements olb::PostProcessor3D< T, DESCRIPTOR >.

Definition at line 269 of file navierStokesAdvectionDiffusionCouplingPostProcessor3D.hh.

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

◆ processSubDomain()

template<typename T , typename DESCRIPTOR >

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

overridevirtual

Execute post-processing step on a sublattice.

Implements olb::PostProcessor3D< T, DESCRIPTOR >.

Definition at line 163 of file navierStokesAdvectionDiffusionCouplingPostProcessor3D.hh.

{
 
  int newX0, newX1, newY0, newY1, newZ0, newZ1;
  if ( util::intersect (
         x0, x1, y0, y1, z0, z1,
         x0_, x1_, y0_, y1_, z0_, z1_,
         newX0, newX1, newY0, newY1, newZ0, newZ1 ) ) {
 
    // 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) {
        for (int iZ=newZ0-1; iZ<=newZ1+1; ++iZ) {
          phi_cache[blockLattice.getCellId(iX,iY,iZ)] = util::max(util::min(tPartner->get(iX,iY,iZ).computeRho(), 1.0), 0.0);
        }
      }
    }
 
    for (int iX=newX0; iX<=newX1; ++iX) {
      for (int iY=newY0; iY<=newY1; ++iY) {
        for (int iZ=newZ0; iZ<=newZ1; ++iZ) {
          T phi = phi_cache[blockLattice.getCellId(iX, iY, iZ)];
 
          // 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
          auto tau = blockLattice.get(iX,iY,iZ).template getFieldPointer<descriptors::TAU_EFF>();
 
          // compute grad phi and laplace phi
          Vector<T,3> grad_phi;
          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);
            int nextZ = iZ + descriptors::c<L>(iPop,2);
            T neighbor_phi = phi_cache[blockLattice.getCellId(nextX, nextY, nextZ)];
 
            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,3> grad_rho = _delta_rho * grad_phi;
 
          // compute interphase normal, save to external field
          T norm_grad_phi = util::max(norm(grad_phi), std::numeric_limits<T>::epsilon());
          tPartner->get(iX,iY,iZ).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;
          Vector<T,3> surface_tension_force = chemical_potential * grad_phi;
 
          // F_b (body force, e.g. bouyancy)
          Vector<T,3> body_force;
 
          // F_p (pressure)
          T pressure = blockLattice.get(iX,iY,iZ).computeRho();
          Vector<T,3> pressure_force = -pressure / descriptors::invCs2<T,L>() * grad_rho;
 
          // F_nu (viscous)
          Vector<T,3> viscous_force;
          T rho_tmp, u_tmp[3];
          blockLattice.get(iX,iY,iZ).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 = blockLattice.get(iX,iY,iZ).getDynamics()->computeEquilibrium( iPop, p_tmp, u_tmp );
            T fNeq = blockLattice.get(iX,iY,iZ)[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];
              }
            }
          }
          viscous_force *= -viscosity / rho / tau[0] * descriptors::invCs2<T,L>();
 
          // save force/rho to external field
          blockLattice.get(iX,iY,iZ).template setField<descriptors::FORCE>(
            (surface_tension_force + body_force + pressure_force + viscous_force) / rho
          );
 
          // compute u, save to external field
          auto u = tPartner->get(iX,iY,iZ).template getField<descriptors::VELOCITY>();
          blockLattice.get(iX,iY,iZ).computeU(u.data());
          tPartner->get(iX,iY,iZ).template setField<descriptors::VELOCITY>(u);
 
          // compute relaxation time, save to external field
          tau[0] = viscosity / rho * descriptors::invCs2<T,L>() + 0.5;
        }
      }
    }
  }
}

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/navierStokesAdvectionDiffusionCouplingPostProcessor3D.h
src/dynamics/navierStokesAdvectionDiffusionCouplingPostProcessor3D.hh

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ PhaseFieldCouplingPostProcessor3D()

Member Function Documentation

◆ extent() [1/2]

◆ extent() [2/2]

◆ process()

◆ processSubDomain()