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

#include <freeSurfacePostProcessor3D.h>

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

Public Member Functions
int	getPriority () const
template<typename CELL >
void	apply (CELL &cell) any_platform

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

Detailed Description

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

Definition at line 90 of file freeSurfacePostProcessor3D.h.

Member Function Documentation

apply()

template<typename T , typename DESCRIPTOR >

template<typename CELL >

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

(

CELL &

cell

)

Definition at line 274 of file freeSurfacePostProcessor3D.hh.

                                                                                     {
  using namespace olb::FreeSurface;
 
  // Convert a gas cell to interface if it is in the neighborhood of a toFluid neighbour cell
  if (isCellType(cell, FreeSurface::Type::Gas) && hasNeighbourFlags(cell, FreeSurface::Flags::ToFluid)) {
    // Initialize distribution functions for a cell converted to interface from gas, using the
    // equilibrium refilling method, i.e., the average velocity and density of neighboring cells.
    setCellFlags(cell, FreeSurface::Flags::NewInterface);
    T rho_average = T(0);
    T u_average[DESCRIPTOR::d] = {T(0), T(0), T(0)};
    std::uint8_t count = std::uint8_t(0);
 
    for (int iPop = 1; iPop < DESCRIPTOR::q; ++iPop) {
      auto nbrCell = cell.neighbor(descriptors::c<DESCRIPTOR>(iPop));
 
      // Only consider neighbouring cells which are fluid or interface cells.
      // Note: newly converted interface cells are not considered here, i.e., CELL_TYPE is not updated yet.
      if (isCellType(nbrCell, FreeSurface::Type::Fluid) || isCellType(nbrCell, FreeSurface::Type::Interface)) {
        T rho_tmp = T(0);
        T u_tmp[DESCRIPTOR::d] = {T(0), T(0), T(0)};
        ++count;
        nbrCell.computeRhoU(rho_tmp, u_tmp);
        rho_average += rho_tmp;
        for (std::size_t i = 0; i < DESCRIPTOR::d; ++i) { u_average[i] += u_tmp[i]; }
      }
    }
 
    if (count > std::uint8_t(0)) {
      rho_average /= static_cast<T>(count);
      for (std::size_t i = 0; i < DESCRIPTOR::d; ++i) { u_average[i] /= static_cast<T>(count); }
    }
    else {
      // If no valid neighbouring cells are found
      rho_average = T(1);
      for (std::size_t i = 0; i < DESCRIPTOR::d; ++i) { u_average[i] = T(0); }
    }
 
    cell.iniEquilibrium(rho_average, u_average);
  }
 
  // If an interface cell with a ToGas flag has a neighbouring ToFluid cell, unset the ToGas flag
  if (hasCellFlags(cell, FreeSurface::Flags::ToGas)) {
    if (hasNeighbourFlags(cell, FreeSurface::Flags::ToFluid)) {
      setCellFlags(cell, FreeSurface::Flags::None);
    }
  }
}

References olb::descriptors::c(), olb::FreeSurface::Fluid, olb::FreeSurface::Gas, olb::FreeSurface::Interface, olb::FreeSurface::NewInterface, olb::FreeSurface::None, olb::FreeSurface::ToFluid, and olb::FreeSurface::ToGas.

Here is the call graph for this function:

getPriority()

template<typename T , typename DESCRIPTOR >

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

inline

Definition at line 94 of file freeSurfacePostProcessor3D.h.

                          {
    return 3;
  }

Member Data Documentation

scope

template<typename T , typename DESCRIPTOR >

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

staticconstexpr

Definition at line 92 of file freeSurfacePostProcessor3D.h.

---

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

• src/dynamics/freeSurfacePostProcessor3D.h
• src/dynamics/freeSurfacePostProcessor3D.hh