olb::momenta::OffBoundaryMomentum Struct Reference

For offLattice boundary conditions. More...

#include <elements.h>

Collaboration diagram for olb::momenta::OffBoundaryMomentum:

Classes
struct	DISTANCES
struct	VELOCITY
struct	VELOCITY_COEFFICIENTS

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 , typename V = typename CELL::value_t, typename DESCRIPTOR = typename CELL::descriptor_t>
void	define (CELL &cell, const U &u) any_platform
template<typename TYPE , typename CELL , 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

For offLattice boundary conditions.

Definition at line 1051 of file elements.h.

Member Function Documentation

compute()

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

void olb::momenta::OffBoundaryMomentum::compute ( CELL & cell, J & j )

inline

Definition at line 1057 of file elements.h.

  {
    for (int iD=0; iD<DESCRIPTOR::d; ++iD) {
      j[iD] = V{};
    }
  }

computeU()

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

void olb::momenta::OffBoundaryMomentum::computeU ( CELL & cell, U & u )

inline

Definition at line 1065 of file elements.h.

  {
    const auto distances = cell.template getFieldPointer<DISTANCES>();
    const auto velocities = cell.template getFieldPointer<VELOCITY>();
 
    for (int iD = 0; iD < DESCRIPTOR::d; iD++) {
      u[iD] = V{};
    }
    unsigned counter = 0;
    for (int iPop = 0; iPop < DESCRIPTOR::q; iPop++) {
      if ( !util::nearZero(distances[iPop]+1) ) {
        for (int iD = 0; iD < DESCRIPTOR::d; iD++) {
          u[iD] += velocities[3*iPop + iD];
        }
        counter++;
      }
    }
    if (counter!=0) {
      for (int iD = 0; iD < DESCRIPTOR::d; iD++) {
        u[iD] /= counter;
      }
    }
  }

References olb::util::nearZero().

Here is the call graph for this function:

define()

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

void olb::momenta::OffBoundaryMomentum::define ( CELL & cell, const U & u )

inline

Definition at line 1090 of file elements.h.

  {
    const auto distances = cell.template getFieldPointer<DISTANCES>();
    auto velocities = cell.template getFieldPointer<VELOCITY>();
    auto velocityCoefficient = cell.template getFieldPointer<VELOCITY_COEFFICIENTS>();
 
    for (int iPop = 0; iPop < DESCRIPTOR::q; iPop++) {
      if ( !util::nearZero(distances[iPop]+1) ) {
        velocityCoefficient[iPop] = 0;
        // scalar product of c(iPop) and u
        for (int sum = 0; sum < DESCRIPTOR::d; sum++) { // +/- problem because of first stream than postprocess
          velocityCoefficient[iPop] -= descriptors::c<DESCRIPTOR>(iPop,sum)*u[sum];
        }
        // compute summand for boundary condition
        velocityCoefficient[iPop] *= 2*descriptors::invCs2<V,DESCRIPTOR>() * descriptors::t<V,DESCRIPTOR>(iPop);
 
        for (int iD = 0; iD < DESCRIPTOR::d; iD++) {
          velocities[3 * iPop + iD] = u[iD];
        }
      }
    }
  }

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

Here is the call graph for this function:

getName()

static std::string olb::momenta::OffBoundaryMomentum::getName ( )

inlinestatic

Definition at line 1125 of file elements.h.

                             {
    return "OffBoundaryMomentum";
  }

initialize()

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

void olb::momenta::OffBoundaryMomentum::initialize ( CELL & cell )

inline

Definition at line 1114 of file elements.h.

  {
    auto distances = cell.template getFieldPointer<DISTANCES>();
    for (int iPop = 0; iPop < DESCRIPTOR::q; iPop++) {
      distances[iPop] = -1;
    }
  }

inverseShift()

template<typename TYPE , typename CELL , typename U >

void olb::momenta::OffBoundaryMomentum::inverseShift ( CELL & cell, U & u )

inline

Definition at line 1123 of file elements.h.

{}

---

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

• src/dynamics/momenta/elements.h