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

Free Surface Processor 1 Mass Flow Cleans up leftover flags from the previous simulation step. More...

#include <freeSurfacePostProcessor2D.h>

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

Public Member Functions
int	getPriority () const
template<typename CELL >
void	apply (CELL &cell) any_platform
	Free Surface Processor 1: Mass Flow.

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

Detailed Description

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

Free Surface Processor 1 Mass Flow Cleans up leftover flags from the previous simulation step.

This post processor is responsible for the calculation of exchange mass with the help of the distribution functions. This whole step should be included in the collideAndStream step, though heavy modification of openlb would be necessary

Definition at line 43 of file freeSurfacePostProcessor2D.h.

Member Function Documentation

apply()

template<typename T , typename DESCRIPTOR >

template<typename CELL >

void olb::FreeSurfaceMassFlowPostProcessor2D< T, DESCRIPTOR >::apply

(

CELL &

cell

)

Free Surface Processor 1: Mass Flow.

Definition at line 38 of file freeSurfacePostProcessor2D.hh.

                                                                        {
 
  using namespace olb::FreeSurface;
 
  // Reset CELL_FLAGS and TEMP_MASS_EXCHANGE here, as they are needed in the final post-processor step
  setCellFlags(cell, FreeSurface::Flags::None);
  Vector<T, DESCRIPTOR::q> zero_mass_exchange{};
  cell.template setField<FreeSurface::TEMP_MASS_EXCHANGE>(zero_mass_exchange);
 
  // Skip if the current cell is not an interface cell.
  if (!isCellType(cell, FreeSurface::Type::Interface)) {
    return;
  }
 
  // Check if the current interface cell has gas or fluid neighbours
  FreeSurface::NeighbourInfo nbrInfo = getNeighbourInfo(cell);
  bool hasNoGasNeighbours = !nbrInfo.has_gas_neighbours;
  bool hasNoFluidNeighbours = !nbrInfo.has_fluid_neighbours;
  bool isHealthyInterfaceCell = isHealthyInterface(cell);
 
  // The cell has only interface cells as neighbours
  if (hasNoGasNeighbours && hasNoFluidNeighbours) {
    hasNoGasNeighbours = false;
    hasNoFluidNeighbours = false;
    isHealthyInterfaceCell = true;
  }
 
  // The notation used here differs from that in N. Thuerey's dissertation (2007), specifically in Section 4.1.
  // This is because the free-surface post-processors are scheduled for execution during the PostStream stage,
  // which occurs after the collideAndStream step. However, mass exchange computations require access to
  // post-collision distribution functions at this stage.
  // Since the post-collision distribution functions are not directly available here, we rely on the fact that,
  // for the current cell, the post-collision f_(i) is equal to that of the corresponding neighbouring cell
  // post-stream, i.e., cell[i](*) = nbrCell[i].
  // Keep in mind that each cell has DESCRIPTOR::q neighbours, and each neighbor contains DESCRIPTOR::q
  // distribution functions.
  T mass_exchange = T(0);
  for (int iPop = 1; iPop < DESCRIPTOR::q; ++iPop) {
    auto nbrCell = cell.neighbor(descriptors::c<DESCRIPTOR>(iPop));
 
    // Skip if the neighbour is a gas cell, i.e., no mass exchange
    if (isCellType(nbrCell, FreeSurface::Type::Gas)) { continue; }
 
    // Mass exchange with a liquid neighbour, i.e., computed uisng the difference between incoming and outgoing DFs
    if (isCellType(nbrCell, FreeSurface::Type::Fluid)) {
      mass_exchange += cell[descriptors::opposite<DESCRIPTOR>(iPop)] - nbrCell[iPop];
      continue;
    }
 
    // Check if the neighbour cell has gas or fluid neighbours
    FreeSurface::NeighbourInfo nbrNeighbourInfo = getNeighbourInfo(nbrCell);
    bool nbrHasNoGasNeighbours = !nbrNeighbourInfo.has_gas_neighbours;
    bool nbrHasNoFluidNeighbours = !nbrNeighbourInfo.has_fluid_neighbours;
    bool nbrIsHealthyInterfaceCell = isHealthyInterface(nbrCell);
 
    // Neighbour cell has only interface cells as neighbours
    if (nbrHasNoGasNeighbours && nbrHasNoFluidNeighbours) {
      nbrHasNoGasNeighbours = false;
      nbrHasNoFluidNeighbours = false;
      nbrIsHealthyInterfaceCell = true;
    }
 
    T pdf_difference = T(0);
    if (isCellType(nbrCell, FreeSurface::Type::Interface)) {
      // Simple mass exchange if both current cell and neighbour cell are healthy interfaces
      if (isHealthyInterfaceCell && nbrIsHealthyInterfaceCell) {
        pdf_difference = cell[descriptors::opposite<DESCRIPTOR>(iPop)] - nbrCell[iPop];
      }
      else {
        // A healthy interface cell with a neighbour that has no gas neighbours itself,
        // or an interface cell with no liquid neighbours, but its neighbor has a liquid neighbour.
        // make this cell empty, ref. N. Thuerey dissertation, 2007.
        if ((isHealthyInterfaceCell && nbrHasNoGasNeighbours) || (hasNoFluidNeighbours && !nbrHasNoFluidNeighbours)) {
          pdf_difference = -nbrCell[iPop];
        }
        else {
          // A healthy interface cell with a neighbour that has no fluid neighbours itself,
          // or an interface cell with no gas neighbours, but its neighbour has a gas neighbour.
          // make the neighbour cell empty, ref. N. Thuerey dissertation, 2007.
          if ((isHealthyInterfaceCell && nbrHasNoFluidNeighbours) || (hasNoGasNeighbours && !nbrHasNoGasNeighbours)) {
            pdf_difference = cell[descriptors::opposite<DESCRIPTOR>(iPop)];
          }
          else {
            // An interface cell with no liquid neighbors, whose neighbor also has no liquid neighbors,
            // or an interface cell with no gas neighbors, whose neighbor also has no liquid neighbors.
            // ref. N. Thuerey dissertation, 2007.
            if ((hasNoFluidNeighbours && nbrHasNoFluidNeighbours) || (hasNoGasNeighbours && nbrHasNoGasNeighbours)) {
              pdf_difference = cell[descriptors::opposite<DESCRIPTOR>(iPop)] - nbrCell[iPop];
            }
          }
        }
      }
    }
 
    const T epsilon_average = T(0.5) * (getClampedEpsilon(cell) + getClampedEpsilon(nbrCell));
    mass_exchange += pdf_difference * epsilon_average;
  }
 
  // Update the mass of interface cell
  const auto mass = cell.template getField<FreeSurface::MASS>();
  cell.template setField<FreeSurface::MASS>(mass + mass_exchange);
}

References olb::descriptors::c(), olb::FreeSurface::Fluid, olb::FreeSurface::Gas, olb::FreeSurface::NeighbourInfo::has_fluid_neighbours, olb::FreeSurface::NeighbourInfo::has_gas_neighbours, olb::FreeSurface::Interface, olb::FreeSurface::None, and olb::descriptors::opposite().

Here is the call graph for this function:

getPriority()

template<typename T , typename DESCRIPTOR >

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

inline

Definition at line 47 of file freeSurfacePostProcessor2D.h.

                          {
    return 1;
  }

Member Data Documentation

scope

template<typename T , typename DESCRIPTOR >

OperatorScope olb::FreeSurfaceMassFlowPostProcessor2D< T, DESCRIPTOR >::scope = OperatorScope::PerCell

staticconstexpr

Definition at line 45 of file freeSurfacePostProcessor2D.h.

---

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

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