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 72 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 229 of file freeSurfacePostProcessor3D.hh.

                                                                                     {
  using namespace olb::FreeSurface;
  /*
  * Initializing new interface cells with DFs from surrounding fluid and interface cells
  * Just takes the arithmetic average.
  */
  if(isCellType(cell, FreeSurface::Type::Gas)){
    if(hasNeighbourFlags(cell, FreeSurface::Flags::ToFluid)){
      setCellFlags(cell, FreeSurface::Flags::NewInterface);
      T rho_avg = 0.;
      T u_avg[DESCRIPTOR::d] = {0., 0.};
 
      std::size_t ctr = 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)});
 
        if (isCellType(cellC, FreeSurface::Type::Fluid) || isCellType(cellC, FreeSurface::Type::Interface)){
          T rho_tmp = 0.;
          T u_tmp[DESCRIPTOR::d] = {0., 0.};
          ++ctr;
          cellC.computeRhoU(rho_tmp, u_tmp);
          rho_avg += rho_tmp;
          for(size_t i = 0; i < DESCRIPTOR::d; ++i){
            u_avg[i] += u_tmp[i];
          }
        }
      }
 
      if(ctr > 0){
        rho_avg /= static_cast<T>(ctr);
        for(size_t i = 0; i < DESCRIPTOR::d; ++i){
          u_avg[i] /= static_cast<T>(ctr);
        }
      }
 
      cell.iniEquilibrium(rho_avg, u_avg);
    }
  }else if(hasCellFlags(cell, FreeSurface::Flags::ToGas)){
    /*
    * If a toGas cell has a neighbouring toFluid cell, unset the toGas flag
    */
    if(hasNeighbourFlags(cell, FreeSurface::Flags::ToFluid)){
      setCellFlags(cell, static_cast<FreeSurface::Flags>(0));
    }
  }
}

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::FreeSurfaceToFluidCellConversionPostProcessor3D< T, DESCRIPTOR >::getPriority ( ) const

inline

Definition at line 76 of file freeSurfacePostProcessor3D.h.

                          {
    return 4;
  }

Member Data Documentation

scope

template<typename T , typename DESCRIPTOR >

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

staticconstexpr

Definition at line 74 of file freeSurfacePostProcessor3D.h.

---

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

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