olb::OuterVelocityEdgeProcessor3D< T, DESCRIPTOR, plane, normal1, normal2 > Class Template Reference

This class computes the skordos BC on a convex edge wall in 3D but with a limited number of terms added to the equilibrium distributions (i.e. More...

#include <boundaryPostProcessors3D.h>

Collaboration diagram for olb::OuterVelocityEdgeProcessor3D< T, DESCRIPTOR, plane, normal1, normal2 >:

Public Member Functions
int	getPriority () const
template<CONCEPT(Cell) CELL>
void	apply (CELL &cell) any_platform

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

Detailed Description

template<typename T, typename DESCRIPTOR, int plane, int normal1, int normal2>
class olb::OuterVelocityEdgeProcessor3D< T, DESCRIPTOR, plane, normal1, normal2 >

This class computes the skordos BC on a convex edge wall in 3D but with a limited number of terms added to the equilibrium distributions (i.e.

only the Q_i : Pi term)

Definition at line 88 of file boundaryPostProcessors3D.h.

Member Function Documentation

apply()

template<typename T , typename DESCRIPTOR , int plane, int normal1, int normal2>

template<CONCEPT(Cell) CELL>

void olb::OuterVelocityEdgeProcessor3D< T, DESCRIPTOR, plane, normal1, normal2 >::apply

(

CELL &

cell

)

Definition at line 166 of file boundaryPostProcessors3D.hh.

{
  using namespace olb::util::tensorIndices3D;
 
  constexpr auto direction1 = (plane+1)%3;
  constexpr auto direction2 = (plane+2)%3;
 
  auto& dynamics = cell.getDynamics();
 
  T rho10 = getNeighborRho(cell, 1,0);
  T rho01 = getNeighborRho(cell, 0,1);
  T rho20 = getNeighborRho(cell, 2,0);
  T rho02 = getNeighborRho(cell, 0,2);
  T rho = (T)2/(T)3*(rho01+rho10)-(T)1/(T)6*(rho02+rho20);
 
  T dA_uB_[3][3];
 
  interpolateGradients<plane,0>           (cell, dA_uB_[0]);
  interpolateGradients<direction1,normal1>(cell, dA_uB_[1]);
  interpolateGradients<direction2,normal2>(cell, dA_uB_[2]);
 
  T dA_uB[3][3];
  for (int iBeta=0; iBeta<3; ++iBeta) {
    dA_uB[plane][iBeta]      = dA_uB_[0][iBeta];
    dA_uB[direction1][iBeta] = dA_uB_[1][iBeta];
    dA_uB[direction2][iBeta] = dA_uB_[2][iBeta];
  }
  T omega = dynamics.getOmegaOrFallback(std::numeric_limits<T>::signaling_NaN());
  T sToPi = - rho / descriptors::invCs2<T,DESCRIPTOR>() / omega;
  T pi[util::TensorVal<DESCRIPTOR>::n];
  pi[xx] = (T)2 * dA_uB[0][0] * sToPi;
  pi[yy] = (T)2 * dA_uB[1][1] * sToPi;
  pi[zz] = (T)2 * dA_uB[2][2] * sToPi;
  pi[xy] = (dA_uB[0][1]+dA_uB[1][0]) * sToPi;
  pi[xz] = (dA_uB[0][2]+dA_uB[2][0]) * sToPi;
  pi[yz] = (dA_uB[1][2]+dA_uB[2][1]) * sToPi;
 
  // Computation of the particle distribution functions
  // according to the regularized formula
  T u[DESCRIPTOR::d];
  cell.computeU(u);
 
  for (int iPop = 0; iPop < DESCRIPTOR::q; ++iPop) {
    cell[iPop] = dynamics.computeEquilibrium(iPop,rho,u)
               + equilibrium<DESCRIPTOR>::template fromPiToFneq<T>(iPop, pi);
  }
}

getPriority()

template<typename T , typename DESCRIPTOR , int plane, int normal1, int normal2>

int olb::OuterVelocityEdgeProcessor3D< T, DESCRIPTOR, plane, normal1, normal2 >::getPriority ( ) const

inline

Definition at line 92 of file boundaryPostProcessors3D.h.

                          {
    return 0;
  }

Member Data Documentation

scope

template<typename T , typename DESCRIPTOR , int plane, int normal1, int normal2>

constexpr OperatorScope olb::OuterVelocityEdgeProcessor3D< T, DESCRIPTOR, plane, normal1, normal2 >::scope = OperatorScope::PerCell

staticconstexpr

Definition at line 90 of file boundaryPostProcessors3D.h.

---

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

• src/boundary/boundaryPostProcessors3D.h
• src/boundary/boundaryPostProcessors3D.hh