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

Free Surface Processor 2-3 Interface Reconstruction Replaces incoming DFs by calculating equilibrium functions and using the laplace pressure to include surface tension. More...

#include <freeSurfacePostProcessor2D.h>

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

Public Types
using	parameters

Public Member Functions
int	getPriority () const
template<typename CELL , typename PARAMETERS >
void	apply (CELL &cell, PARAMETERS &params) any_platform
	Free Surface Processor 2-3: Interface Reconstruction.

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

Detailed Description

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

Free Surface Processor 2-3 Interface Reconstruction Replaces incoming DFs by calculating equilibrium functions and using the laplace pressure to include surface tension.

Marks cells which may be changed at the last step.

Definition at line 63 of file freeSurfacePostProcessor2D.h.

Member Typedef Documentation

parameters

template<typename T , typename DESCRIPTOR >

using olb::FreeSurfaceInterfaceReconstructionPostProcessor2D< T, DESCRIPTOR >::parameters

Initial value:

 meta::list<
    FreeSurface::DROP_ISOLATED_CELLS,
    FreeSurface::TRANSITION,
    FreeSurface::LONELY_THRESHOLD,
    FreeSurface::HAS_SURFACE_TENSION,
    FreeSurface::SURFACE_TENSION_PARAMETER
  >

Definition at line 65 of file freeSurfacePostProcessor2D.h.

Member Function Documentation

apply()

template<typename T , typename DESCRIPTOR >

template<typename CELL , typename PARAMETERS >

void olb::FreeSurfaceInterfaceReconstructionPostProcessor2D< T, DESCRIPTOR >::apply	(	CELL &	cell,
		PARAMETERS &	params )

Free Surface Processor 2-3: Interface Reconstruction.

Definition at line 146 of file freeSurfacePostProcessor2D.hh.

                                                                                                           {
 
  using namespace olb::FreeSurface;
 
  const bool drop_isolated_cells = params.template get<FreeSurface::DROP_ISOLATED_CELLS>();
  const auto transition          = params.template get<FreeSurface::TRANSITION>();
  const auto lonely_threshold    = params.template get<FreeSurface::LONELY_THRESHOLD>();
  const bool has_surface_tension = params.template get<FreeSurface::HAS_SURFACE_TENSION>();
  const auto surface_tension     = params.template get<FreeSurface::SURFACE_TENSION_PARAMETER>();
 
  if (!isCellType(cell, FreeSurface::Type::Interface)) {
    return;
  }
 
  FreeSurface::NeighbourInfo nbrInfo = getNeighbourInfo(cell);
 
  // Adjust gas density, using Laplace pressure but without support for the bubble model
  T deltaRho = T(0);
  if (has_surface_tension && nbrInfo.has_gas_neighbours) {
    const T curvature = computeCurvature(cell);
    deltaRho = T(6) * surface_tension * curvature;
  }
  const T bubble_density = T(1);
  const T gas_density = bubble_density - deltaRho;
 
  // Replace the distribution functions of the gas cell using the updated density.
  // A race condition is not expected here since only the distribution functions
  // of an interface cell are modified, while only the distribution functions of
  // a neighboring gas cell are read.
  Vector<T, DESCRIPTOR::q> dfs{};
  for (int iPop = 1; iPop < DESCRIPTOR::q; iPop++) {
    auto nbrCell = cell.neighbor(descriptors::c<DESCRIPTOR>(iPop));
 
    // Distribution functions of an interface cell are reconstructed only for the missing directions,
    // i.e., incoming DFs from gas cells, using the pressure anti bounce back boundary condition.
    // Note: the notation used here differs from that in N. Thuerey's dissertation (2007), refer to the
    // explanation given above.
    if (isCellType(nbrCell, FreeSurface::Type::Gas)) {
      constexpr bool usePrecise = true;
      Vector<T, DESCRIPTOR::d> prev_velocity = cell.template getField<FreeSurface::PREVIOUS_VELOCITY>();
 
      // (1) Precise formulation of the pressure anti bounce back boundary condition: feq_(i) + feq_(-i) - nbr(i)
      // This is mathematically identical to the regular formulation, but the linear term of the 2nd order
      // equilibrium equation is manually eliminated due to its cancellation during summation, i.e., c_(-i).u = -(c_(i).u).
      // This formulation offers consistent floating-point rounding behaviour during arithmetic operations.
      if constexpr (usePrecise) {
        const T uSqr = util::normSqr<T, DESCRIPTOR::d>(prev_velocity);
        Vector<T, DESCRIPTOR::d> direction{};
        for (int i = 0; i < DESCRIPTOR::d; ++i) { direction[i] = descriptors::c<DESCRIPTOR>(iPop, i); }
        const T c_u = util::dotProduct(direction, prev_velocity);
 
        dfs[descriptors::opposite<DESCRIPTOR>(iPop)] =
            T(2) * gas_density * descriptors::t<T, DESCRIPTOR>(iPop) * (T(1) + T(4.5) * c_u * c_u - T(1.5) * uSqr)
          - T(2) * descriptors::t<T, DESCRIPTOR>(iPop)
          - nbrCell[iPop];
      }
      // (2) Regular formulation of the pressure anti bounce back boundary condition: feq_(i) + feq_(-i) - nbr(i)
      // This formulation might suffer from inconsistent floating-point rounding behaviour during arithmetic
      // operations, where the expression c_(-i).u = -(c_(i).u) could become untrue.
      else {
        T u[DESCRIPTOR::d] = {prev_velocity[0], prev_velocity[1]};
        dfs[descriptors::opposite<DESCRIPTOR>(iPop)] =
            equilibrium<DESCRIPTOR>::secondOrder(iPop, gas_density, u)
          + equilibrium<DESCRIPTOR>::secondOrder(descriptors::opposite<DESCRIPTOR>(iPop), gas_density, u)
          - nbrCell[iPop];
      }
    }
    else {
      dfs[descriptors::opposite<DESCRIPTOR>(iPop)] =
        cell[descriptors::opposite<DESCRIPTOR>(iPop)];
    }
  }
 
  // Update interafce cell populations using the computed dfs in previous step.
  for (int iPop = 1; iPop < DESCRIPTOR::q; iPop++) { cell[iPop] = dfs[iPop]; }
 
  // Using the updated mass and density, find and set appropriate flag on the current interface cell
  const auto rho = cell.computeRho();
  const auto mass = cell.template getField<FreeSurface::MASS>();
 
  // An interface cell is flagged as toGas if its volume fraction is below the threshold
  if (mass < -transition * rho) {
    setCellFlags(cell, FreeSurface::Flags::ToGas);
    return;
  }
 
  // An interface cell is flagged as toFluid if its volume fraction is above the (1.0 + threshold)
  if (mass > (T(1) + transition) * rho) {
    setCellFlags(cell, FreeSurface::Flags::ToFluid);
    return;
  }
 
  // An interface cell with no fluid neighbours is flagged as toGas:
  // (1) If its volume fraction is below the (lonely threshold) and has interface neighbours (not isolated)
  // (2) If it has no interface neighbours (isolated) and drop_isolated_cells is set
  if (!nbrInfo.has_fluid_neighbours) {
    if (mass < lonely_threshold * rho && nbrInfo.interface_neighbours != 0) {
      setCellFlags(cell, FreeSurface::Flags::ToGas);
      return;
    }
 
    if (nbrInfo.interface_neighbours == 0 && drop_isolated_cells) {
      setCellFlags(cell, FreeSurface::Flags::ToGas);
      return;
    }
  }
 
  // An interface cell with no gas neighbours is flagged as toFluid:
  // (1) If its volume fraction is above the (1.0 - lonely threshold) and has interface neighbours (not isolated)
  // (2) If it has no interface neighbours (isolated) and drop_isolated_cells is set
  if (!nbrInfo.has_gas_neighbours) {
    if (mass > (T(1) - lonely_threshold) * rho && nbrInfo.interface_neighbours != 0) {
      setCellFlags(cell, FreeSurface::Flags::ToFluid);
      return;
    }
 
    if (nbrInfo.interface_neighbours == 0 && drop_isolated_cells) {
      setCellFlags(cell, FreeSurface::Flags::ToFluid);
      return;
    }
  }
}

References olb::descriptors::c(), olb::util::dotProduct(), olb::FreeSurface::Gas, olb::FreeSurface::NeighbourInfo::has_fluid_neighbours, olb::FreeSurface::NeighbourInfo::has_gas_neighbours, olb::FreeSurface::Interface, olb::FreeSurface::NeighbourInfo::interface_neighbours, olb::util::normSqr(), olb::descriptors::opposite(), olb::equilibrium< DESCRIPTOR >::secondOrder(), olb::descriptors::t(), olb::FreeSurface::ToFluid, and olb::FreeSurface::ToGas.

Here is the call graph for this function:

getPriority()

template<typename T , typename DESCRIPTOR >

int olb::FreeSurfaceInterfaceReconstructionPostProcessor2D< T, DESCRIPTOR >::getPriority ( ) const

inline

Definition at line 75 of file freeSurfacePostProcessor2D.h.

                          {
    return 2;
  }

Member Data Documentation

scope

template<typename T , typename DESCRIPTOR >

OperatorScope olb::FreeSurfaceInterfaceReconstructionPostProcessor2D< T, DESCRIPTOR >::scope = OperatorScope::PerCellWithParameters

staticconstexpr

Definition at line 73 of file freeSurfacePostProcessor2D.h.

---

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

• src/dynamics/freeSurfacePostProcessor2D.h
• src/dynamics/freeSurfacePostProcessor2D.hh