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

Free Surface Processor 6 Calculates mass excess from the cell type conversions and distributes them to neighbouring interface cells Keeps mass local if no neighbour exists until an interface reappears at this position. More...

#include <freeSurfacePostProcessor3D.h>

Collaboration diagram for olb::FreeSurfaceMassExcessPostProcessor3D< 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::FreeSurfaceMassExcessPostProcessor3D< T, DESCRIPTOR >

Free Surface Processor 6 Calculates mass excess from the cell type conversions and distributes them to neighbouring interface cells Keeps mass local if no neighbour exists until an interface reappears at this position.

Definition at line 110 of file freeSurfacePostProcessor3D.h.

Member Function Documentation

apply()

template<typename T , typename DESCRIPTOR >

template<typename CELL >

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

(

CELL &

cell

)

@hint EPSILON of neighbours used here @hint Mass can be set in this processor, but not epsilon since it is needed for the normal computation. epsilon is set in the next processor Became untrue due to code section removal, but epsilon is still set in the next part because of pushed mass excess

Definition at line 326 of file freeSurfacePostProcessor3D.hh.

                                                                          {
  using namespace olb::FreeSurface;
  if( !isCellType(cell, FreeSurface::Type::Interface) ){
    return;
  }
 
  T rho = cell.computeRho();
  T mass = cell.template getField<FreeSurface::MASS>( );
  T mass_excess = 0.;
 
  auto normal = computeParkerYoungInterfaceNormal(cell);
  // redistribute excess mass
 
  if(hasCellFlags(cell, FreeSurface::Flags::ToGas)){
    mass_excess = mass;
    cell.template setField<FreeSurface::MASS>( 0. );
    normal *= -1;
  } else if (hasCellFlags(cell, FreeSurface::Flags::ToFluid)) {
    mass_excess = mass - rho;
    cell.template setField<FreeSurface::MASS>( rho );
  } else {
    return;
  }
 
  std::array<T,DESCRIPTOR::q> products;
  products[0] = 0.;
  T product_sum = 0.;
  std::size_t product_total = 0;
 
  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)});
    products[iPop] = 0.;
 
    // Thuerey Paper says we can't use new interface cells
    // or flagged cells
    // But surface tension showed us that it has anisotropic effects
    if( (isCellType(cellC, FreeSurface::Type::Interface) && (!hasCellFlags(cellC,
          static_cast<FreeSurface::Flags>(255)) /*|| hasCellFlags(cellC, FreeSurface::Flags::ToFluid)*/ ))
        /*|| isCellType(cellC, FreeSurface::Type::Fluid)*/
        ){
      products[iPop] = (normal[0] * descriptors::c<DESCRIPTOR>(iPop, 0) + normal[1] * descriptors::c<DESCRIPTOR>(iPop,1) + normal[2] * descriptors::c<DESCRIPTOR>(iPop,2));
      if(products[iPop] <= 0){
        products[iPop] = 0.;
      }
      ++product_total;
      product_sum += products[iPop];
    }
  }
 
  /* Prepare Mass excess push */
  Vector<T,DESCRIPTOR::q> mass_excess_vector{};
  mass_excess_vector[0] = 0.;
  /*
  if(product_sum > 0){
    T fraction = 1./ product_sum;
 
    for(int iPop = 1; iPop < DESCRIPTOR::q; ++iPop){
      mass_excess_vector[iPop] = mass_excess * products[iPop] * fraction;
    }
    cell.template setField<FreeSurface::TEMP_MASS_EXCHANGE>( mass_excess_vector );
  }
  else*/
  if (product_total > 0) {
    T product_fraction = 1. / product_total;
    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)});
      if( (isCellType(cellC, FreeSurface::Type::Interface) && (!hasCellFlags(cellC,
          static_cast<FreeSurface::Flags>(255)) /*|| hasCellFlags(cellC, FreeSurface::Flags::ToFluid)*/ ))
          /*|| isCellType(cellC, FreeSurface::Type::Fluid)*/
          ){
        mass_excess_vector[iPop] = mass_excess * product_fraction;
      } else {
        mass_excess_vector[iPop] = 0.;
      }
    }
    cell.template setField<FreeSurface::TEMP_MASS_EXCHANGE>( mass_excess_vector );
  } else {
    mass_excess_vector[0] = mass_excess;
    for(int iPop=1; iPop < DESCRIPTOR::q; iPop++) {
      mass_excess_vector[iPop] = 0.;
    }
    cell.template setField<FreeSurface::TEMP_MASS_EXCHANGE>( mass_excess_vector );
  }
}

References olb::FreeSurface::Interface, olb::FreeSurface::ToFluid, and olb::FreeSurface::ToGas.

getPriority()

template<typename T , typename DESCRIPTOR >

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

inline

Definition at line 114 of file freeSurfacePostProcessor3D.h.

                          {
    return 6;
  }

Member Data Documentation

scope

template<typename T , typename DESCRIPTOR >

constexpr OperatorScope olb::FreeSurfaceMassExcessPostProcessor3D< T, DESCRIPTOR >::scope = OperatorScope::PerCell

staticconstexpr

Definition at line 112 of file freeSurfacePostProcessor3D.h.

---

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

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