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<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 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<concepts::DynamicCell CELL>

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

(

CELL &

cell

)

Definition at line 168 of file boundaryPostProcessors3D.hh.

{
  using V = typename CELL::value_t;
  using namespace olb::util::tensorIndices3D;
 
  constexpr auto direction1 = (plane+1)%3;
  constexpr auto direction2 = (plane+2)%3;
 
  auto& dynamics = cell.getDynamics();
 
  V rho10 = getNeighborRho(cell, 1,0);
  V rho01 = getNeighborRho(cell, 0,1);
  V rho20 = getNeighborRho(cell, 2,0);
  V rho02 = getNeighborRho(cell, 0,2);
  V rho = (V)2/(V)3*(rho01+rho10)-(V)1/(V)6*(rho02+rho20);
 
  V 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]);
 
  V 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];
  }
  V omega = dynamics.getOmegaOrFallback(std::numeric_limits<V>::signaling_NaN());
  V sToPi = - rho / descriptors::invCs2<V,DESCRIPTOR>() / omega;
  V pi[util::TensorVal<DESCRIPTOR>::n];
  pi[xx] = (V)2 * dA_uB[0][0] * sToPi;
  pi[yy] = (V)2 * dA_uB[1][1] * sToPi;
  pi[zz] = (V)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
  V u[DESCRIPTOR::d];
  cell.computeU(u);
 
  V fEq[DESCRIPTOR::q] { };
  dynamics.computeEquilibrium(cell, rho, u, fEq);
  for (int iPop = 0; iPop < DESCRIPTOR::q; ++iPop) {
    cell[iPop] = fEq[iPop] + equilibrium<DESCRIPTOR>::template fromPiToFneq<V>(iPop, pi);
  }
}

References olb::descriptors::invCs2().

Here is the call graph for this function:

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>

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