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

Free Surface Processor 7 Finishes up left over cell conversions and prepares the state for the next simulation step. More...

#include <freeSurfacePostProcessor3D.h>

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

Free Surface Processor 7 Finishes up left over cell conversions and prepares the state for the next simulation step.

Definition at line 128 of file freeSurfacePostProcessor3D.h.

Member Function Documentation

apply()

template<typename T , typename DESCRIPTOR >

template<typename CELL >

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

(

CELL &

cell

)

@hint moved flag removal to processor 1 without any negative effects

@hint moved flag removal to processor 1 without any negative effects

Definition at line 440 of file freeSurfacePostProcessor3D.hh.

                                                                                  {
  using namespace olb::FreeSurface;
  /* Convert flagged cells to appropriate cell types */
  FreeSurface::Flags flags = static_cast<FreeSurface::Flags>(cell.template getField<FreeSurface::CELL_FLAGS>());
 
  switch(flags){
    case FreeSurface::Flags::ToFluid:
    {
      setCellType(cell, FreeSurface::Type::Fluid);
      cell.template setField<FreeSurface::EPSILON>( 1. );
      T mass_tmp = cell.template getField<FreeSurface::MASS>();
      mass_tmp += cell.template getField<FreeSurface::TEMP_MASS_EXCHANGE>()[0];
      cell.template setField<FreeSurface::MASS>(mass_tmp);
 
    }
    break;
    case FreeSurface::Flags::ToGas:
    {
      setCellType(cell, FreeSurface::Type::Gas);
      cell.template setField<FreeSurface::EPSILON>( 0. );
      T mass_tmp = cell.template getField<FreeSurface::MASS>();
      mass_tmp += cell.template getField<FreeSurface::TEMP_MASS_EXCHANGE>()[0];
      cell.template setField<FreeSurface::MASS>(mass_tmp);
 
    }
    break;
    case FreeSurface::Flags::NewInterface:
    {
      setCellType(cell, FreeSurface::Type::Interface);
    }
    break;
    default:
    break;
  }
 
  FreeSurface::Type type = static_cast<FreeSurface::Type>(cell.template getField<FreeSurface::CELL_TYPE>());
 
  /* Collection of mass excess in a pulling step */
  switch(type){
    case FreeSurface::Type::Interface:
    {
      T collected_excess = 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)});
        auto tempMassExchange = cellC.template getFieldPointer<FreeSurface::TEMP_MASS_EXCHANGE>();
 
        if (hasCellFlags(cellC,
                FreeSurface::Flags::ToFluid
              | FreeSurface::Flags::ToGas)){
            int iPop_op = descriptors::opposite<DESCRIPTOR>(iPop);
            collected_excess += tempMassExchange[iPop_op];
          }
      }
 
      T mass_tmp = cell.template getField<FreeSurface::MASS>();
 
      mass_tmp += collected_excess;
      T rho;
      T u_tmp[DESCRIPTOR::d];
      cell.computeRhoU(rho, u_tmp);
 
      Vector<T,DESCRIPTOR::d> u_vel{u_tmp[0], u_tmp[1], u_tmp[2]};
 
      cell.template setField<FreeSurface::EPSILON>( mass_tmp / rho );
      cell.template setField<FreeSurface::MASS>(mass_tmp);
      cell.template setField<FreeSurface::PREVIOUS_VELOCITY>(u_vel);
    }
    break;
    case FreeSurface::Type::Fluid:
    {
      T collected_excess = 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)});
        auto tempMassExchange = cellC.template getFieldPointer<FreeSurface::TEMP_MASS_EXCHANGE>();
        if (hasCellFlags(cellC,
              FreeSurface::Flags::ToFluid
            | FreeSurface::Flags::ToGas)) {
          int iPop_op = descriptors::opposite<DESCRIPTOR>(iPop);
          collected_excess += tempMassExchange[iPop_op];
        }
      }
 
      T mass_tmp = cell.template getField<FreeSurface::MASS>();
      mass_tmp += collected_excess;
      cell.template setField<FreeSurface::MASS>(mass_tmp);
    }
    break;
    default:
    break;
  }
}

References olb::FreeSurface::Fluid, olb::FreeSurface::Gas, olb::FreeSurface::Interface, olb::FreeSurface::NewInterface, olb::FreeSurface::ToFluid, and olb::FreeSurface::ToGas.

getPriority()

template<typename T , typename DESCRIPTOR >

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

inline

Definition at line 132 of file freeSurfacePostProcessor3D.h.

                          {
    return 7;
  }

Member Data Documentation

scope

template<typename T , typename DESCRIPTOR >

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

staticconstexpr

Definition at line 130 of file freeSurfacePostProcessor3D.h.

---

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

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