olb::collision::DualPorousBGK::type< DESCRIPTOR, MOMENTA, EQUILIBRIUM > Struct Template Reference

#include <dualDynamics.h>

Collaboration diagram for olb::collision::DualPorousBGK::type< DESCRIPTOR, MOMENTA, EQUILIBRIUM >:

Public Types
using	EquilibriumF = typename EQUILIBRIUM::template type<DESCRIPTOR,MOMENTA>
using	MomentaF = typename MOMENTA::template type<DESCRIPTOR>

Public Member Functions
template<CONCEPT(MinimalCell) CELL, typename PARAMETERS , typename V = typename CELL::value_t>
CellStatistic< V >	apply (CELL &cell, PARAMETERS &parameters) any_platform

Detailed Description

template<typename DESCRIPTOR, typename MOMENTA, typename EQUILIBRIUM>
struct olb::collision::DualPorousBGK::type< DESCRIPTOR, MOMENTA, EQUILIBRIUM >

Definition at line 54 of file dualDynamics.h.

Member Typedef Documentation

EquilibriumF

template<typename DESCRIPTOR , typename MOMENTA , typename EQUILIBRIUM >

using olb::collision::DualPorousBGK::type< DESCRIPTOR, MOMENTA, EQUILIBRIUM >::EquilibriumF = typename EQUILIBRIUM::template type<DESCRIPTOR,MOMENTA>

Definition at line 55 of file dualDynamics.h.

MomentaF

template<typename DESCRIPTOR , typename MOMENTA , typename EQUILIBRIUM >

using olb::collision::DualPorousBGK::type< DESCRIPTOR, MOMENTA, EQUILIBRIUM >::MomentaF = typename MOMENTA::template type<DESCRIPTOR>

Definition at line 56 of file dualDynamics.h.

Member Function Documentation

apply()

template<typename DESCRIPTOR , typename MOMENTA , typename EQUILIBRIUM >

template<CONCEPT(MinimalCell) CELL, typename PARAMETERS , typename V = typename CELL::value_t>

CellStatistic< V > olb::collision::DualPorousBGK::type< DESCRIPTOR, MOMENTA, EQUILIBRIUM >::apply ( CELL & cell, PARAMETERS & parameters )

inline

Definition at line 59 of file dualDynamics.h.

                                                                            {
      // Revert for backwards-in-time propagation
      //cell.revert();
      for (int iPop=1; iPop <= DESCRIPTOR::q/2; ++iPop) {
        V cell_iPop = cell[iPop];
        cell[iPop] = cell[descriptors::opposite<DESCRIPTOR>(iPop)];
        cell[descriptors::opposite<DESCRIPTOR>(iPop)] = cell_iPop;
      }
 
      // Preparation
      const auto pop_f =   cell.template getField<descriptors::F>();
      const auto dJdF  =   cell.template getFieldPointer<descriptors::DJDF>();
      const V d      =  cell.template getField<descriptors::POROSITY>();
      const V omega = parameters.template get<descriptors::OMEGA>();
 
      // Forward density and velocity
      V rho_f { };
      V u_f[DESCRIPTOR::d] { };
      //this->computeRhoU( pop_f.data(), rho_f, u_f);
      rho_f = V();
      for (int iD=0; iD < DESCRIPTOR::d; ++iD) {
        u_f[iD] = V();
      }
      for (int iPop=0; iPop < DESCRIPTOR::q; ++iPop) {
        rho_f += pop_f[iPop];
        for (int iD=0; iD < DESCRIPTOR::d; ++iD) {
          u_f[iD] += pop_f[iPop]*descriptors::c<DESCRIPTOR>(iPop,iD);
        }
      }
      rho_f += (V)1;
      for (int iD=0; iD < DESCRIPTOR::d; ++iD) {
        u_f[iD] /= rho_f;
      }
 
      // Adjoint equilibrium
      V pheq[DESCRIPTOR::q] { };
      for (int i=0; i < DESCRIPTOR::q; ++i) {
        pheq[i] = V{0};
        for (int j=0; j < DESCRIPTOR::q; ++j) {
          V feq_j = equilibrium<DESCRIPTOR>::secondOrder(j, rho_f, u_f)
              + descriptors::t<V,DESCRIPTOR>(j);
          V dot_ij = V();
          for (int iD=0; iD < DESCRIPTOR::d; ++iD) {
            dot_ij += ( descriptors::c<DESCRIPTOR>(j,iD) - d*u_f[iD] )
              * ( descriptors::c<DESCRIPTOR>(i,iD) - u_f[iD] );
          }
          pheq[i] += cell[j]*feq_j*( V{1} + descriptors::invCs2<V,DESCRIPTOR>()*d*dot_ij );
        }
        pheq[i] /= rho_f;
      }
 
      // Collision
      for (int i=0; i < DESCRIPTOR::q; ++i) {
        cell[i] = cell[i] - omega*( cell[i] - pheq[i] ) + dJdF[i];
      }
 
      // Statistics
      V rho_phi, u_phi[DESCRIPTOR::d];
      MomentaF().computeRhoU( cell, rho_phi, u_phi );
      V uSqr_phi = util::normSqr<V,DESCRIPTOR::d>( u_phi );
 
      // Undo revert
      //cell.revert();
      for (int iPop=1; iPop <= DESCRIPTOR::q/2; ++iPop) {
        V cell_iPop = cell[iPop];
        cell[iPop] = cell[descriptors::opposite<DESCRIPTOR>(iPop)];
        cell[descriptors::opposite<DESCRIPTOR>(iPop)] = cell_iPop;
      }
      return {rho_phi, uSqr_phi};
    };

References olb::equilibrium< DESCRIPTOR >::secondOrder().

Here is the call graph for this function:

---

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

• src/optimization/dualDynamics.h