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

Map between cell indices and concrete dynamics. More...

#include <blockDynamicsMap.h>

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

Public Member Functions
	BlockDynamicsMap (ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM > &lattice)
	Constructor for a BlockDynamicsMap.
Dynamics< T, DESCRIPTOR > *	get (DynamicsPromise< T, DESCRIPTOR > &&promise)
	Returns a pointer to dynamics matching the promise.
const Dynamics< T, DESCRIPTOR > *	get (std::size_t iCell) const
Dynamics< T, DESCRIPTOR > *	get (std::size_t iCell)
void	set (std::size_t iCell, DynamicsPromise< T, DESCRIPTOR > &&promise)
	Assigns promised dynamics to cell index and updates block masks.
void	collide (CollisionDispatchStrategy strategy)
	Executes local collision step for entire non-overlap area of lattice.
std::size_t	getWeight (const DynamicsPromise< T, DESCRIPTOR > &promise) const
	Returns number of cells assigned to promised dynamics.
std::set< DynamicsPromise< T, DESCRIPTOR > >	getAll () const
	Returns set of all dynamics maintained this map.

Detailed Description

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

Map between cell indices and concrete dynamics.

Central class for managing and applying dynamics of / to a block lattice.

Maintains both a map of cell indices to dynamics and of dynamics to a mask of all assigned cell indices.

Automatically determines the dominant dynamics and applies the collision step to all cells via the dominant dynamics' ConcreteBlockCollisionO.

Definition at line 265 of file blockDynamicsMap.h.

Constructor & Destructor Documentation

BlockDynamicsMap()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

olb::BlockDynamicsMap< T, DESCRIPTOR, PLATFORM >::BlockDynamicsMap ( ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM > & lattice )

inline

Constructor for a BlockDynamicsMap.

Definition at line 306 of file blockDynamicsMap.h.

                                                                        :
    _lattice(lattice),
    _dynamicsOfCells(new Dynamics<T,DESCRIPTOR>*                [_lattice.getNcells()] { nullptr }),
    _operatorOfCells(new BlockCollisionO<T,DESCRIPTOR,PLATFORM>*[_lattice.getNcells()] { nullptr }),
    _coreMask(lattice.template getData<CollisionSubdomainMask>()),
    _dominantCollisionO(nullptr)
  {
    _lattice.forCoreSpatialLocations([&](LatticeR<DESCRIPTOR::d> lattice) {
      _coreMask.set(_lattice.getCellId(lattice), true);
    });
  }

Member Function Documentation

collide()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

void olb::BlockDynamicsMap< T, DESCRIPTOR, PLATFORM >::collide ( CollisionDispatchStrategy strategy )

inline

Executes local collision step for entire non-overlap area of lattice.

When using the default CollisionDispatchStrategy::Dominant, the most frequently assigned dynamics resp. collision operator is applied and responsible for also colliding cells excluded by its masks using their respective dynamics.

Correspondingly, the alternative CollisionDispatchStrategy::Individual applies all dynamics separately using a list-based approach.

Definition at line 361 of file blockDynamicsMap.h.

  {
    switch (strategy) {
    case CollisionDispatchStrategy::Dominant:
      if (!_dominantCollisionO) {
        _dominantCollisionO = std::get<1>(std::max_element(
          _map.begin(),
          _map.end(),
          [](const auto& lhs, const auto& rhs) -> bool {
            return std::get<1>(lhs.second)->weight()
                 < std::get<1>(rhs.second)->weight();
          })->second).get();
      }
      _dominantCollisionO->apply(_lattice, _coreMask, strategy);
      break;
 
    case CollisionDispatchStrategy::Individual:
      for (auto& [id, value] : _map) {
        auto& [promise, collisionO] = value;
        if (collisionO->weight() > 0) {
          collisionO->apply(_lattice, _coreMask, strategy);
        }
      }
      break;
 
    default:
      throw std::runtime_error("Invalid collision dispatch strategy");
      break;
    }
  }

References olb::BlockCollisionO< T, DESCRIPTOR, PLATFORM >::apply(), olb::Dominant, and olb::Individual.

Here is the call graph for this function:

get() [1/3]

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

Dynamics< T, DESCRIPTOR > * olb::BlockDynamicsMap< T, DESCRIPTOR, PLATFORM >::get ( DynamicsPromise< T, DESCRIPTOR > && promise )

inline

Returns a pointer to dynamics matching the promise.

Promise is only realized if dynamics were not previously constructed

Definition at line 322 of file blockDynamicsMap.h.

  {
    return resolve(std::forward<decltype(promise)>(promise)).getDynamics();
  }

Here is the caller graph for this function:

get() [2/3]

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

Dynamics< T, DESCRIPTOR > * olb::BlockDynamicsMap< T, DESCRIPTOR, PLATFORM >::get ( std::size_t iCell )

inline

Definition at line 332 of file blockDynamicsMap.h.

  {
    return _dynamicsOfCells[iCell];
  }

get() [3/3]

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

const Dynamics< T, DESCRIPTOR > * olb::BlockDynamicsMap< T, DESCRIPTOR, PLATFORM >::get ( std::size_t iCell ) const

inline

Definition at line 327 of file blockDynamicsMap.h.

  {
    return _dynamicsOfCells[iCell];
  }

getAll()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

std::set< DynamicsPromise< T, DESCRIPTOR > > olb::BlockDynamicsMap< T, DESCRIPTOR, PLATFORM >::getAll ( ) const

inline

Returns set of all dynamics maintained this map.

Definition at line 407 of file blockDynamicsMap.h.

                                                       {
    std::set<DynamicsPromise<T,DESCRIPTOR>> dynamics;
    for (auto& [id, value] : _map) {
      const auto& [promise, collisionO] = value;
      dynamics.emplace(promise);
    }
    return dynamics;
  }

getWeight()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

std::size_t olb::BlockDynamicsMap< T, DESCRIPTOR, PLATFORM >::getWeight ( const DynamicsPromise< T, DESCRIPTOR > & promise ) const

inline

Returns number of cells assigned to promised dynamics.

Doesn't allocate, intended for introspection

Definition at line 396 of file blockDynamicsMap.h.

                                                                          {
    auto iter = _map.find(promise.id());
    if (iter != _map.end()) {
      const auto& [_, collisionO] = std::get<1>(*iter);
      return collisionO->weight();
    } else {
      return 0;
    }
  }

References olb::DynamicsPromise< T, DESCRIPTOR >::id().

Here is the call graph for this function:

set()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

void olb::BlockDynamicsMap< T, DESCRIPTOR, PLATFORM >::set ( std::size_t iCell, DynamicsPromise< T, DESCRIPTOR > && promise )

inline

Assigns promised dynamics to cell index and updates block masks.

Definition at line 338 of file blockDynamicsMap.h.

  {
    auto& collisionO = resolve(std::forward<decltype(promise)>(promise));
    if (_operatorOfCells[iCell] != nullptr) {
      _operatorOfCells[iCell]->set(iCell, false, !_coreMask[iCell]);
    }
    collisionO.set(iCell, true, !_coreMask[iCell]);
    _operatorOfCells[iCell] = &collisionO;
    if (Dynamics<T,DESCRIPTOR>* dynamics = collisionO.getDynamics()) {
      _dynamicsOfCells[iCell] = dynamics;
    }
    _dominantCollisionO = nullptr;
  }

Here is the caller graph for this function:

---

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

• src/core/blockDynamicsMap.h