olb::momenta::PressureBoundaryMomentum< direction, orientation > Struct Template Reference

The velocity is stored in the external field U, except for the component "direction", which is computed by means of the population and the pressure. More...

#include <elements.h>

Collaboration diagram for olb::momenta::PressureBoundaryMomentum< direction, orientation >:

Classes
struct	VELOCITY

Public Member Functions
template<typename TYPE , typename CELL , typename J , typename V = typename CELL::value_t, typename DESCRIPTOR = typename CELL::descriptor_t>
void	compute (CELL &cell, J &j) any_platform
template<typename TYPE , typename CELL , typename U , typename V = typename CELL::value_t, typename DESCRIPTOR = typename CELL::descriptor_t>
void	computeU (CELL &cell, U &u) any_platform
template<typename TYPE , typename CELL , typename U >
void	define (CELL &cell, const U &u) any_platform
template<typename TYPE , typename CELL , typename V = typename CELL::value_t, typename DESCRIPTOR = typename CELL::descriptor_t>
void	initialize (CELL &cell) any_platform
template<typename TYPE , typename CELL , typename U >
void	inverseShift (CELL &cell, U &u) any_platform

Static Public Member Functions
static std::string	getName ()

Detailed Description

template<int direction, int orientation>
struct olb::momenta::PressureBoundaryMomentum< direction, orientation >

The velocity is stored in the external field U, except for the component "direction", which is computed by means of the population and the pressure.

This is for incompressible multi-phase models.

Definition at line 648 of file elements.h.

Member Function Documentation

compute()

template<int direction, int orientation>

template<typename TYPE , typename CELL , typename J , typename V = typename CELL::value_t, typename DESCRIPTOR = typename CELL::descriptor_t>

void olb::momenta::PressureBoundaryMomentum< direction, orientation >::compute ( CELL & cell, J & j )

inline

Definition at line 653 of file elements.h.

  {
    computeU<TYPE>(cell, j);
    auto rho = cell.template getField<descriptors::RHO>();
    for (int iD=0; iD<DESCRIPTOR::d; ++iD) {
      j[iD] *= rho;
    }
  }

References olb::momenta::PressureBoundaryMomentum< direction, orientation >::computeU().

Here is the call graph for this function:

computeU()

template<int direction, int orientation>

template<typename TYPE , typename CELL , typename U , typename V = typename CELL::value_t, typename DESCRIPTOR = typename CELL::descriptor_t>

void olb::momenta::PressureBoundaryMomentum< direction, orientation >::computeU ( CELL & cell, U & u )

inline

Definition at line 664 of file elements.h.

  {
    auto values = cell.template getField<VELOCITY>();
    for (int iD=0; iD<DESCRIPTOR::d; ++iD) {
      u[iD] = values[iD];
    }
    auto rho = cell.template getField<descriptors::RHO>();
    auto gradRho = cell.template getField<descriptors::NABLARHO>();
    //V rho = 10.;
    //V gradRho[2] = {0.,0.};
    auto force = cell.template getField<descriptors::FORCE>();
    const V p = TYPE().computeRho(cell);
 
    constexpr auto onWallIndices = util::populationsContributingToVelocity<DESCRIPTOR,direction,0>();
    constexpr auto normalIndices = util::populationsContributingToVelocity<DESCRIPTOR,direction,orientation>();
 
    V popOnWall = V{};
    for (auto e : onWallIndices) {
      popOnWall += cell[e];
    }
    popOnWall -= cell[0];
 
    V popNormal = V{};
    for (auto e : normalIndices) {
      popNormal += cell[e];
    }
 
    V w0 = descriptors::t<V,DESCRIPTOR>(0);
    V cs2 = 1./descriptors::invCs2<V,DESCRIPTOR>();
    V pops = V{2}*popNormal+popOnWall;
    V term = cs2*(V{2}*rho-gradRho[direction])/(V{2}*rho*w0);
    V otherU = 0;
    for (int iDim = 1; iDim < DESCRIPTOR::d; ++iDim) {
      u[(direction+iDim)%DESCRIPTOR::d] = 0.5/rho*force[(direction+iDim)%DESCRIPTOR::d];
      otherU += cs2*0.5*u[(direction+iDim)%DESCRIPTOR::d]*gradRho[(direction+iDim)%DESCRIPTOR::d]
                -0.5*w0*rho*u[(direction+iDim)%DESCRIPTOR::d]*u[(direction+iDim)%DESCRIPTOR::d];
    }
    u[direction] = orientation*(-term + util::sqrt(term*term + V{2}/rho/w0*(cs2*(pops+0.5*force[direction])-(V{1}-w0)*p+otherU)));
  }

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

Here is the call graph for this function:

Here is the caller graph for this function:

define()

template<int direction, int orientation>

template<typename TYPE , typename CELL , typename U >

void olb::momenta::PressureBoundaryMomentum< direction, orientation >::define ( CELL & cell, const U & u )

inline

Definition at line 706 of file elements.h.

  {
    cell.template setField<VELOCITY>(u);
  }

getName()

template<int direction, int orientation>

static std::string olb::momenta::PressureBoundaryMomentum< direction, orientation >::getName ( )

inlinestatic

Definition at line 721 of file elements.h.

                             {
    return "PressureBoundaryMomentum";
  }

initialize()

template<int direction, int orientation>

template<typename TYPE , typename CELL , typename V = typename CELL::value_t, typename DESCRIPTOR = typename CELL::descriptor_t>

void olb::momenta::PressureBoundaryMomentum< direction, orientation >::initialize ( CELL & cell )

inline

Definition at line 712 of file elements.h.

  {
    V u[DESCRIPTOR::d] { V{} };
    cell.template setField<VELOCITY>(u);
  }

inverseShift()

template<int direction, int orientation>

template<typename TYPE , typename CELL , typename U >

void olb::momenta::PressureBoundaryMomentum< direction, orientation >::inverseShift ( CELL & cell, U & u )

inline

Definition at line 719 of file elements.h.

{};

---

The documentation for this struct was generated from the following file:

• src/dynamics/momenta/elements.h