#include <boundaryPostProcessors3D.h>

Collaboration diagram for olb::StraightConvectionBoundaryProcessor3D< DESCRIPTOR, direction, orientation >:

Classes
struct	PREV_CELL

Public Member Functions
int	getPriority () const

template<CONCEPT(Cell) CELL>
void	initialize (CELL &cell) any_platform

template<CONCEPT(Cell) CELL>
void	apply (CELL &cell) any_platform

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

Detailed Description

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

Definition at line 61 of file boundaryPostProcessors3D.h.

Member Function Documentation

◆ apply()

template<typename DESCRIPTOR , int direction, int orientation>

template<CONCEPT(Cell) CELL>

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

Definition at line 105 of file boundaryPostProcessors3D.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[3];
  V rho1, u1[3];
  V rho2, u2[3];
 
  cell.computeRhoU(rho0, u0);
 
  static_assert(direction == 0 || direction == 1 || direction ==2,
                "Direction must be one of 0, 1 or 2");
  if constexpr (direction == 0) {
    cell.neighbor({-orientation  ,0,0}).computeRhoU(rho1, u1);
    cell.neighbor({-orientation*2,0,0}).computeRhoU(rho2, u2);
  }
  else if constexpr (direction == 1) {
    cell.neighbor({0,-orientation  ,0}).computeRhoU(rho1, u1);
    cell.neighbor({0,-orientation*2,0}).computeRhoU(rho2, u2);
  }
  else if constexpr (direction == 2) {
    cell.neighbor({0,0,-orientation  }).computeRhoU(rho1, u1);
    cell.neighbor({0,0,-orientation*2}).computeRhoU(rho2, u2);
  }
 
  V uDelta[3];
  V uAverage = rho0*u0[direction];
  //if (uAv!=nullptr) {
  //  rho0 = V{1};
  //  rho1 = V{1};
  //  rho2 = V{1};
  //  uAverage = *uAv * rho0;
  //}
 
  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]);
  uDelta[2] = -uAverage*0.5*(3*rho0*u0[2]-4*rho1*u1[2]+rho2*u2[2]);
 
  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)
                    + uDelta[2]*descriptors::c<DESCRIPTOR>(iPop,2));
  }
 
  cell.template setField<PREV_CELL>(prevCell);
}

References olb::util::populationsContributingToVelocity().

Here is the call graph for this function:

◆ getPriority()

template<typename DESCRIPTOR , int direction, int orientation>

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

inline

Definition at line 69 of file boundaryPostProcessors3D.h.

                          {
    return 0;
  }

◆ initialize()

template<typename DESCRIPTOR , int direction, int orientation>

template<CONCEPT(Cell) CELL>

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

Definition at line 94 of file boundaryPostProcessors3D.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]];
  }
}