olb::ConcreteBlockCollisionO< T, DESCRIPTOR, Platform::CPU_SIMD, DYNAMICS > Class Template Reference

Application of the collision step on a concrete SIMD block. More...

#include <operator.h>

Inheritance diagram for olb::ConcreteBlockCollisionO< T, DESCRIPTOR, Platform::CPU_SIMD, DYNAMICS >:

Collaboration diagram for olb::ConcreteBlockCollisionO< T, DESCRIPTOR, Platform::CPU_SIMD, DYNAMICS >:

Public Member Functions
	ConcreteBlockCollisionO ()
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::CPU_SIMD > &block) override
void	apply (ConcreteBlockLattice< T, DESCRIPTOR, Platform::CPU_SIMD > &block, ConcreteBlockMask< T, Platform::CPU_SIMD > &subdomain, CollisionDispatchStrategy strategy) override
	Apply collision on entire block.
Public Member Functions inherited from olb::BlockCollisionO< T, DESCRIPTOR, Platform::CPU_SIMD >
virtual void	setup (ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM > &block)=0
	Setup collision on block.
virtual void	apply (ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM > &block, ConcreteBlockMask< T, PLATFORM > &subdomain, CollisionDispatchStrategy strategy)=0
	Apply collision on subdomain of block using strategy.
Public Member Functions inherited from olb::AbstractBlockO
virtual	~AbstractBlockO ()=default

Detailed Description

template<typename T, typename DESCRIPTOR, typename DYNAMICS>
class olb::ConcreteBlockCollisionO< T, DESCRIPTOR, Platform::CPU_SIMD, DYNAMICS >

Application of the collision step on a concrete SIMD block.

ConcreteBlockCollisionO::apply allows for applying DYNAMICS on a given cell index or an entire block. The latter option accepts a ConcreteBlockMask instance describing the subset of cells for which DYNAMICS is to be vectorized.

Definition at line 310 of file operator.h.

Constructor & Destructor Documentation

ConcreteBlockCollisionO()

template<typename T , typename DESCRIPTOR , typename DYNAMICS >

olb::ConcreteBlockCollisionO< T, DESCRIPTOR, Platform::CPU_SIMD, DYNAMICS >::ConcreteBlockCollisionO ( )

inline

Definition at line 364 of file operator.h.

                           :
    _dynamics(new DYNAMICS()),
    _parameters(nullptr),
    _mask(nullptr)
  { }

Member Function Documentation

apply()

template<typename T , typename DESCRIPTOR , typename DYNAMICS >

void olb::ConcreteBlockCollisionO< T, DESCRIPTOR, Platform::CPU_SIMD, DYNAMICS >::apply ( ConcreteBlockLattice< T, DESCRIPTOR, Platform::CPU_SIMD > & block, ConcreteBlockMask< T, Platform::CPU_SIMD > & subdomain, CollisionDispatchStrategy strategy )

inlineoverride

Apply collision on entire block.

Definition at line 412 of file operator.h.

  {
    if (strategy != CollisionDispatchStrategy::Dominant) {
      throw std::runtime_error("Platform::CPU_SIMD currently only support CollisionDispatchStrategy::Dominant");
    }
 
    auto& mask = *_mask;
    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 (dynamics::is_vectorizable_v<DYNAMICS>) {
      // Ensure that serialized mask storage is up-to-date
      mask.setProcessingContext(ProcessingContext::Simulation);
      // Apply collision to cells
      #ifdef PARALLEL_MODE_OMP
      #pragma omp parallel for schedule(static) reduction(+ : statistics)
      #endif
      for (CellID iCell=0; iCell < block.getNcells(); iCell += cpu::simd::Pack<T>::size) {
        apply(block, subdomain, mask, *_parameters, statistics, iCell);
      }
    } else { // Fallback for non-vectorizable collision operators
      #ifdef PARALLEL_MODE_OMP
      #pragma omp parallel for schedule(static) reduction(+ : statistics)
      #endif
      for (std::size_t iCell=0; iCell < block.getNcells(); ++iCell) {
        if (mask[iCell]) {
          cpu::Cell<T,DESCRIPTOR,Platform::CPU_SIMD> cell(block, iCell);
          if (auto cellStatistic = DYNAMICS().apply(cell, *_parameters)) {
            statistics.increment(cellStatistic.rho, cellStatistic.uSqr);
          }
        } else if (subdomain[iCell]) {
          applyOther(block, statistics, iCell);
        }
      }
    }
 
    block.getStatistics().incrementStats(statistics);
  }

References olb::Dominant, olb::BlockStructureD< D >::getNcells(), olb::BlockLattice< T, DESCRIPTOR >::getStatistics(), olb::LatticeStatistics< T >::Aggregatable::increment(), and olb::Simulation.

Here is the call graph for this function:

getDynamics()

template<typename T , typename DESCRIPTOR , typename DYNAMICS >

Dynamics< T, DESCRIPTOR > * olb::ConcreteBlockCollisionO< T, DESCRIPTOR, Platform::CPU_SIMD, DYNAMICS >::getDynamics ( )

inlineoverridevirtual

Implements olb::AbstractCollisionO< T, DESCRIPTOR >.

Definition at line 393 of file operator.h.

  {
    return _dynamics.get();
  }

id()

template<typename T , typename DESCRIPTOR , typename DYNAMICS >

std::type_index olb::ConcreteBlockCollisionO< T, DESCRIPTOR, Platform::CPU_SIMD, DYNAMICS >::id ( ) const

inlineoverridevirtual

Implements olb::AbstractBlockO.

Definition at line 370 of file operator.h.

  {
    return typeid(DYNAMICS);
  }

set()

template<typename T , typename DESCRIPTOR , typename DYNAMICS >

void olb::ConcreteBlockCollisionO< T, DESCRIPTOR, Platform::CPU_SIMD, DYNAMICS >::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)

Only unmask cells that actually do something

Implements olb::AbstractCollisionO< T, DESCRIPTOR >.

Definition at line 380 of file operator.h.

  {
    if constexpr (!std::is_same_v<DYNAMICS,NoDynamics<T,DESCRIPTOR>>) {
      if (!overlap) {
        _mask->set(iCell, state);
      }
    }
    if (state) {
      _dynamicsOfCells[iCell] = _concreteDynamics.get();
    }
  }

setup()

template<typename T , typename DESCRIPTOR , typename DYNAMICS >

void olb::ConcreteBlockCollisionO< T, DESCRIPTOR, Platform::CPU_SIMD, DYNAMICS >::setup ( ConcreteBlockLattice< T, DESCRIPTOR, Platform::CPU_SIMD > & block )

inlineoverride

Definition at line 398 of file operator.h.

  {
    _parameters = &block.template getData<OperatorParameters<DYNAMICS>>().parameters;
    _mask = &block.template getData<DynamicsMask<DYNAMICS>>();
    if constexpr (dynamics::has_parametrized_momenta_v<DYNAMICS>) {
      _dynamics->setMomentaParameters(_parameters);
    }
 
    _concreteDynamics.reset(new cpu::simd::ConcreteDynamics<T,DESCRIPTOR,DYNAMICS>(_parameters));
    // Fetch pointer to concretized dynamic-dispatch field
    _dynamicsOfCells = block.template getField<cpu::DYNAMICS<T,DESCRIPTOR,Platform::CPU_SIMD>>()[0].data();
  }

weight()

template<typename T , typename DESCRIPTOR , typename DYNAMICS >

std::size_t olb::ConcreteBlockCollisionO< T, DESCRIPTOR, Platform::CPU_SIMD, DYNAMICS >::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 375 of file operator.h.

  {
    return _mask->weight();
  }

---

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

• src/core/platform/cpu/simd/operator.h