olb::LegacyBlockCollisionO< T, DESCRIPTOR, PLATFORM > Class Template Reference

Concrete collision operator for legacy dynamics. More...

#include <blockDynamicsMap.h>

Inheritance diagram for olb::LegacyBlockCollisionO< T, DESCRIPTOR, PLATFORM >:

Collaboration diagram for olb::LegacyBlockCollisionO< T, DESCRIPTOR, PLATFORM >:

Public Member Functions
	LegacyBlockCollisionO (std::size_t count, Dynamics< T, DESCRIPTOR > **dynamics)
std::type_index	id () const override
std::size_t	weight () const override
	Returns number of assigned cells.
void	set (CellID iCell, bool state, bool overlap) override
	Set whether iCell is covered by the present collision step.
Dynamics< T, DESCRIPTOR > *	getDynamics () override
void	setup (ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM > &block) override
	Setup collision on block.
void	apply (ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM > &block, ConcreteBlockMask< T, PLATFORM > &subdomain, CollisionDispatchStrategy strategy) override
	Apply collision on subdomain of block.
Public Member Functions inherited from olb::AbstractBlockO
virtual	~AbstractBlockO ()=default

Detailed Description

template<typename T, typename DESCRIPTOR, Platform PLATFORM>
class olb::LegacyBlockCollisionO< T, DESCRIPTOR, PLATFORM >

Concrete collision operator for legacy dynamics.

To be removed once both all OpenLB-included dynamics are adapted and legacy support was included in at least one release.

Legacy dynamics are only supported on CPU targets.

Definition at line 133 of file blockDynamicsMap.h.

Constructor & Destructor Documentation

LegacyBlockCollisionO()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

olb::LegacyBlockCollisionO< T, DESCRIPTOR, PLATFORM >::LegacyBlockCollisionO ( std::size_t count, Dynamics< T, DESCRIPTOR > ** dynamics )

inline

Definition at line 159 of file blockDynamicsMap.h.

                                                                           :
    _mask{count},
    _legacyDynamics{dynamics}
  { }

Here is the caller graph for this function:

Member Function Documentation

apply()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

void olb::LegacyBlockCollisionO< T, DESCRIPTOR, PLATFORM >::apply ( ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM > & block, ConcreteBlockMask< T, PLATFORM > & subdomain, CollisionDispatchStrategy strategy )

inlineoverridevirtual

Apply collision on subdomain of block.

Loop excludes overlap areas of block as collisions are never applied there. This assumes that subdomain is the core mask of BlockDynamicsMap.

Implements olb::BlockCollisionO< T, DESCRIPTOR, PLATFORM >.

Definition at line 202 of file blockDynamicsMap.h.

  {
    if (strategy != CollisionDispatchStrategy::Dominant) {
      throw std::runtime_error("LegacyBlockCollisionO only supports CollisionDispatchStrategy::Dominant");
    }
 
    typename LatticeStatistics<T>::Aggregatable statistics{};
    #ifdef PARALLEL_MODE_OMP
    #pragma omp declare reduction(+ : typename LatticeStatistics<T>::Aggregatable : omp_out += omp_in) initializer (omp_priv={})
    #endif
 
    if constexpr (DESCRIPTOR::d == 3) {
      #ifdef PARALLEL_MODE_OMP
      #pragma omp parallel for schedule(dynamic,1) reduction(+ : statistics)
      #endif
      for (int iX=0; iX < block.getNx(); ++iX) {
        auto cell = block.get(iX,0,0);
        for (int iY=0; iY < block.getNy(); ++iY) {
          for (int iZ=0; iZ < block.getNz(); ++iZ) {
            CellID iCell = block.getCellId(iX,iY,iZ);
            if (_mask[iCell]) {
              cell.setCellId(iCell);
              if (auto cellStatistic = _legacyDynamics[iCell]->collide(cell)) {
                statistics.increment(cellStatistic.rho, cellStatistic.uSqr);
              }
            } else {
              cpu::Cell<T,DESCRIPTOR,PLATFORM> cell(block, iCell);
              if (auto cellStatistic = _dynamicsOfCells[iCell]->collide(cell)) {
                statistics.increment(cellStatistic.rho, cellStatistic.uSqr);
              }
            }
          }
        }
      }
    } else {
      #ifdef PARALLEL_MODE_OMP
      #pragma omp parallel for schedule(dynamic,1) reduction(+ : statistics)
      #endif
      for (int iX=0; iX < block.getNx(); ++iX) {
        auto cell = block.get(iX,0);
        for (int iY=0; iY < block.getNy(); ++iY) {
          CellID iCell = block.getCellId(iX,iY);
          if (_mask[iCell]) {
            cell.setCellId(iCell);
            if (auto cellStatistic = _legacyDynamics[iCell]->collide(cell)) {
              statistics.increment(cellStatistic.rho, cellStatistic.uSqr);
            }
          } else {
            cpu::Cell<T,DESCRIPTOR,PLATFORM> cell(block, iCell);
            if (auto cellStatistic = _dynamicsOfCells[iCell]->collide(cell)) {
              statistics.increment(cellStatistic.rho, cellStatistic.uSqr);
            }
          }
        }
      }
    }
 
    block.getStatistics().incrementStats(statistics);
  }

References olb::Dominant, olb::BlockLattice< T, DESCRIPTOR >::get(), olb::BlockStructureD< D >::getCellId(), olb::BlockStructureD< D >::getNx(), olb::BlockStructureD< D >::getNy(), olb::BlockStructureD< D >::getNz(), and olb::BlockLattice< T, DESCRIPTOR >::getStatistics().

Here is the call graph for this function:

getDynamics()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

Dynamics< T, DESCRIPTOR > * olb::LegacyBlockCollisionO< T, DESCRIPTOR, PLATFORM >::getDynamics ( )

inlineoverridevirtual

Implements olb::AbstractCollisionO< T, DESCRIPTOR >.

Definition at line 184 of file blockDynamicsMap.h.

  {
    return nullptr;
  }

id()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

std::type_index olb::LegacyBlockCollisionO< T, DESCRIPTOR, PLATFORM >::id ( ) const

inlineoverridevirtual

Implements olb::AbstractBlockO.

Definition at line 164 of file blockDynamicsMap.h.

  {
    return typeid(LegacyBlockCollisionO);
  }

References olb::LegacyBlockCollisionO< T, DESCRIPTOR, PLATFORM >::LegacyBlockCollisionO().

Here is the call graph for this function:

set()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

void olb::LegacyBlockCollisionO< T, DESCRIPTOR, PLATFORM >::set ( CellID iCell, bool state, bool overlap )

inlineoverridevirtual

Set whether iCell is covered by the present collision step.

Parameters

iCell	Cell index
state	(De)activate for this dynamics / collision
overlap	Cell index in overlap (set dynamics but do not collide)

Implements olb::AbstractCollisionO< T, DESCRIPTOR >.

Definition at line 174 of file blockDynamicsMap.h.

  {
    if (!overlap) {
      _mask.set(iCell, state);
    }
    if (state) {
      _dynamicsOfCells[iCell] = resolve(iCell);
    }
  }

setup()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

void olb::LegacyBlockCollisionO< T, DESCRIPTOR, PLATFORM >::setup ( ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM > & block )

inlineoverridevirtual

Setup collision on block.

Implements olb::BlockCollisionO< T, DESCRIPTOR, PLATFORM >.

Definition at line 189 of file blockDynamicsMap.h.

  {
    // Remember block in order to construct LegacyConcreteDynamics
    _block = █
    // Fetch pointer to concretized dynamic-dispatch field
    _dynamicsOfCells = block.template getField<cpu::DYNAMICS<T,DESCRIPTOR,PLATFORM>>()[0].data();
  }

weight()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

std::size_t olb::LegacyBlockCollisionO< T, DESCRIPTOR, PLATFORM >::weight ( ) const

inlineoverridevirtual

Returns number of assigned cells.

Used to determine the dominant dynamics to choose e.g. which collision operator to vectorize or to prefer in GPU kernels.

Implements olb::AbstractCollisionO< T, DESCRIPTOR >.

Definition at line 169 of file blockDynamicsMap.h.

  {
    return _mask.weight();
  }

---

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

• src/core/blockDynamicsMap.h