This class computes a convection BC on a flat wall in 2D. More...

#include <boundaryPostProcessors2D.h>

Collaboration diagram for olb::StraightConvectionBoundaryProcessor2D< T, DESCRIPTOR, direction, orientation >:

Classes
struct	PREV_CELL

Public Member Functions
int	getPriority () const

template<concepts::DynamicCell CELL>
void	initialize (CELL &cell) any_platform

template<concepts::DynamicCell CELL>
void	apply (CELL &cell) any_platform

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

Detailed Description

template<typename T, typename DESCRIPTOR, int direction, int orientation>
class olb::StraightConvectionBoundaryProcessor2D< T, DESCRIPTOR, direction, orientation >

This class computes a convection BC on a flat wall in 2D.

Definition at line 284 of file boundaryPostProcessors2D.h.

Member Function Documentation

◆ apply()

template<typename T , typename DESCRIPTOR , int direction, int orientation>

template<concepts::DynamicCell CELL>

void olb::StraightConvectionBoundaryProcessor2D< T, DESCRIPTOR, direction, orientation >::apply ( CELL & cell )

Definition at line 108 of file boundaryPostProcessors2D.hh.

{
  using V = typename CELL::value_t;
  constexpr auto missing =
      util::populationsContributingToVelocity<DESCRIPTOR, direction,
                                              -orientation>();
 
  auto prevCell = cell.template getField<PREV_CELL>();
 
  for (unsigned i = 0; i < missing.size(); ++i) {
    cell[missing[i]] = prevCell[i];
  }
 
  V rho0, u0[2];
  V rho1, u1[2];
  V rho2, u2[2];
 
  cell.computeRhoU(rho0, u0);
 
  static_assert(direction == 0 || direction == 1
                ,"Direction must be one of 0 or 1 in 2D");
  if constexpr (direction == 0) {
    cell.neighbor({-orientation, 0}).computeRhoU(rho1, u1);
    cell.neighbor({-orientation * 2, 0}).computeRhoU(rho2, u2);
  }
  else if constexpr (direction == 1) {
    cell.neighbor({0, -orientation}).computeRhoU(rho1, u1);
    cell.neighbor({0, -orientation * 2}).computeRhoU(rho2, u2);
  }
 
  V uDelta[2];
  V uAverage = rho0 * u0[direction];
 
  uDelta[0] =
      -uAverage * 0.5 * (3 * rho0 * u0[0] - 4 * rho1 * u1[0] + rho2 * u2[0]);
  uDelta[1] =
      -uAverage * 0.5 * (3 * rho0 * u0[1] - 4 * rho1 * u1[1] + rho2 * u2[1]);
 
  for (unsigned i = 0; i < missing.size(); ++i) {
    auto iPop = missing[i];
    prevCell[i] =
        cell[iPop] + descriptors::invCs2<V, DESCRIPTOR>() *
                         descriptors::t<V, DESCRIPTOR>(iPop) *
                         (uDelta[0] * descriptors::c<DESCRIPTOR>(iPop, 0) +
                          uDelta[1] * descriptors::c<DESCRIPTOR>(iPop, 1));
  }
 
  cell.template setField<PREV_CELL>(prevCell);
}

References olb::descriptors::c(), olb::descriptors::invCs2(), olb::util::populationsContributingToVelocity(), and olb::descriptors::t().

Here is the call graph for this function:

◆ getPriority()

template<typename T , typename DESCRIPTOR , int direction, int orientation>

int olb::StraightConvectionBoundaryProcessor2D< T, DESCRIPTOR, direction, orientation >::getPriority ( ) const

inline

Definition at line 294 of file boundaryPostProcessors2D.h.

                          {
    return 0;
  }

◆ initialize()

template<typename T , typename DESCRIPTOR , int direction, int orientation>

template<concepts::DynamicCell CELL>

void olb::StraightConvectionBoundaryProcessor2D< T, DESCRIPTOR, direction, orientation >::initialize ( CELL & cell )

Definition at line 94 of file boundaryPostProcessors2D.hh.

{
  constexpr auto missing =
      util::populationsContributingToVelocity<DESCRIPTOR, direction,
                                              -orientation>();
  auto prevCell = cell.template getFieldPointer<PREV_CELL>();
  for (unsigned i = 0; i < missing.size(); ++i) {
    prevCell[i] = cell[missing[i]];
  }
}