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

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

#include <freeSurfacePostProcessor3D.h>

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

Public Types
using	parameters

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

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

Detailed Description

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

Free Surface Processor 1-3 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. 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. This whole step should be included in the collideAndStream step, though heavy modification of openlb would be necessary

Definition at line 43 of file freeSurfacePostProcessor3D.h.

Member Typedef Documentation

parameters

template<typename T , typename DESCRIPTOR >

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

Initial value:

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

Definition at line 45 of file freeSurfacePostProcessor3D.h.

Member Function Documentation

apply()

template<typename T , typename DESCRIPTOR >

template<typename CELL , typename PARAMETERS >

void olb::FreeSurfaceMassFlowPostProcessor3D< T, DESCRIPTOR >::apply	(	CELL &	cell,
		PARAMETERS &	parameters )

Definition at line 55 of file freeSurfacePostProcessor3D.hh.

                                                                                          {
 
  using namespace olb::FreeSurface;
 
  const bool drop_isolated_cells = vars.template get<FreeSurface::DROP_ISOLATED_CELLS>();
  const T transition = vars.template get<FreeSurface::TRANSITION>();
  const T lonely_threshold = vars.template get<FreeSurface::LONELY_THRESHOLD>();
  const bool has_surface_tension = vars.template get<FreeSurface::HAS_SURFACE_TENSION>();
  const T surface_tension_parameter = vars.template get<FreeSurface::SURFACE_TENSION_PARAMETER>();
  //const T force_conversion_factor = vars.template get<FreeSurface::FORCE_CONVERSION_FACTOR>();
  //const T lattice_size = vars.template get<FreeSurface::LATTICE_SIZE>();
 
  /*
  * Minor "hack". Remove all cell flags here, because it is needed in the last processor due to pulling steps in processor 6 and 7
  */
  setCellFlags(cell, static_cast<FreeSurface::Flags>(0));
 
  /*
  * This processor only works on interface types
  */
  if (isCellType(cell, FreeSurface::Type::Interface )) {
    T mass_tmp = cell.template getField<FreeSurface::MASS>();
 
    FreeSurface::NeighbourInfo neighbour_info = getNeighbourInfo(cell);
 
    for (int iPop = 1; iPop < DESCRIPTOR::q; ++iPop){
      auto cellC = cell.neighbor({descriptors::c<DESCRIPTOR>(iPop, 0),
                                  descriptors::c<DESCRIPTOR>(iPop, 1),
                                  descriptors::c<DESCRIPTOR>(iPop, 2)});
      int iPop_op = descriptors::opposite<DESCRIPTOR>(iPop);
 
      /*
      * Iterate over neighbours and perform a mass exchange. Interface to fluid are simple cases.
      * Interface to interface has to be symmetric and multiple cases are for artifact reduction
      * from Thuerey
      * Added a distinction between the amount of interface nodes. Weight consideration seems to cause artifacts.
      */
      if( isCellType(cellC, FreeSurface::Type::Fluid)) {
        mass_tmp += cell[iPop_op] - cellC[iPop];
      } else if ( isCellType(cellC, FreeSurface::Type::Interface)) {
        FreeSurface::NeighbourInfo neighbour_neighbour_info = getNeighbourInfo(cellC);
 
        T mass_flow = 0.;
 
        if( !neighbour_info.has_fluid_neighbours){
          if(!neighbour_neighbour_info.has_fluid_neighbours){
            if(neighbour_info.interface_neighbours < neighbour_neighbour_info.interface_neighbours){
              mass_flow = -cellC[iPop];// - descriptors::t<T,DESCRIPTOR>(iPop);
            }else if(neighbour_info.interface_neighbours > neighbour_neighbour_info.interface_neighbours){
              mass_flow = cell[iPop_op];// + descriptors::t<T,DESCRIPTOR>(iPop_op);
            }else{
              mass_flow = cell[iPop_op] - cellC[iPop];
            }
          }else {
            mass_flow = -cellC[iPop];// - descriptors::t<T,DESCRIPTOR>(iPop);
          }
        }else if(!neighbour_info.has_gas_neighbours){
          if(!neighbour_neighbour_info.has_gas_neighbours){
            if(neighbour_info.interface_neighbours < neighbour_neighbour_info.interface_neighbours){
              mass_flow = cell[iPop_op];// + descriptors::t<T,DESCRIPTOR>(iPop_op);
            }else if(neighbour_info.interface_neighbours > neighbour_neighbour_info.interface_neighbours){
              mass_flow = -cellC[iPop];// - descriptors::t<T,DESCRIPTOR>(iPop);
            }else{
              mass_flow = cell[iPop_op] - cellC[iPop];
            }
          }else {
            mass_flow = cell[iPop_op];// + descriptors::t<T,DESCRIPTOR>(iPop_op);
          }
        }else {
          if(!neighbour_neighbour_info.has_fluid_neighbours){
            mass_flow = cell[iPop_op];// + descriptors::t<T,DESCRIPTOR>(iPop_op);
          }else if(!neighbour_neighbour_info.has_gas_neighbours){
            mass_flow = -cellC[iPop];// - descriptors::t<T,DESCRIPTOR>(iPop);
          }else {
            mass_flow = cell[iPop_op] - cellC[iPop];
          }
        }
 
        /*
        * Exchange depends on how filled the interfaces are
        */
        mass_tmp += mass_flow * 0.5 * (getClampedEpsilon(cell) + getClampedEpsilon(cellC));
      }
    }
 
    cell.template setField<FreeSurface::MASS>(mass_tmp);
 
    // Former 2 Step
 
    // Because I need the distribution functions of the last step I will write results in a temporary
    // array, before copying it back into the DFs
 
    Vector<T,DESCRIPTOR::q> dfs;
 
    T curvature = 0.;
 
    if(has_surface_tension){
      FreeSurface::NeighbourInfo info = getNeighbourInfo(cell);
      if(info.has_gas_neighbours){
        curvature = calculateSurfaceTensionCurvature(cell);
      }
 
    }
 
    // Gas pressure adjusting
    T gas_pressure = 1. - 6. * surface_tension_parameter * curvature;
 
    for(int iPop=1; iPop < DESCRIPTOR::q; iPop++) {
      auto cellC = cell.neighbor({descriptors::c<DESCRIPTOR>(iPop, 0),
                                  descriptors::c<DESCRIPTOR>(iPop, 1),
                                  descriptors::c<DESCRIPTOR>(iPop, 2)});
      int iPop_op = descriptors::opposite<DESCRIPTOR>(iPop);
 
      /*
      * Gas replacement
      */
      if ( isCellType(cellC, FreeSurface::Type::Gas )) {
        Vector<T, DESCRIPTOR::d> u_vel = cell.template getField<FreeSurface::PREVIOUS_VELOCITY>();
        T u[DESCRIPTOR::d];
        for(size_t u_i = 0; u_i < DESCRIPTOR::d; ++u_i){
          u[u_i] = u_vel[u_i];
        }
        //T uSqr = util::normSqr<T,DESCRIPTOR::d>(u);
        dfs[iPop_op] = equilibrium<DESCRIPTOR>::secondOrder(iPop, gas_pressure, u)
          + equilibrium<DESCRIPTOR>::secondOrder(iPop_op, gas_pressure, u)
          - cellC[iPop];
      }else {
        dfs[iPop_op] = cell[iPop_op];
      }
    }
 
    for(int iPop=1; iPop<DESCRIPTOR::q; iPop++) {
      cell[iPop] = dfs[iPop];
    }
 
    // Former 3 Step
    /*
    * Based on the mass calculation, flag this interface cell as toFluid or toGas if set boundaries are met
    */
    T rho = cell.computeRho();
 
    // Check if transition needs to happen.
    if ( mass_tmp < -transition * rho || (mass_tmp < lonely_threshold * rho && !neighbour_info.has_fluid_neighbours) ){
      setCellFlags(cell, FreeSurface::Flags::ToGas);
    }
    else if ( mass_tmp > (1. + transition)*rho  || ( mass_tmp > (1-lonely_threshold) * rho && !neighbour_info.has_gas_neighbours) ){
      setCellFlags(cell, FreeSurface::Flags::ToFluid);
    }else if(drop_isolated_cells && (neighbour_info.interface_neighbours == 0)){
      if(!neighbour_info.has_gas_neighbours){
        setCellFlags(cell, FreeSurface::Flags::ToFluid);
      }else if(!neighbour_info.has_fluid_neighbours){
        //setCellFlags(cell, FreeSurface::Flags::ToGas);
      }
    }
  }
}

References olb::FreeSurface::Fluid, olb::FreeSurface::Gas, olb::FreeSurface::NeighbourInfo::has_fluid_neighbours, olb::FreeSurface::NeighbourInfo::has_gas_neighbours, olb::FreeSurface::Interface, olb::FreeSurface::NeighbourInfo::interface_neighbours, olb::equilibrium< DESCRIPTOR >::secondOrder(), olb::FreeSurface::ToFluid, and olb::FreeSurface::ToGas.

Here is the call graph for this function:

getPriority()

template<typename T , typename DESCRIPTOR >

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

inline

Definition at line 57 of file freeSurfacePostProcessor3D.h.

                          {
    return 1;
  }

Member Data Documentation

scope

template<typename T , typename DESCRIPTOR >

constexpr OperatorScope olb::FreeSurfaceMassFlowPostProcessor3D< T, DESCRIPTOR >::scope = OperatorScope::PerCellWithParameters

staticconstexpr

Definition at line 55 of file freeSurfacePostProcessor3D.h.

---

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

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