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

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

#include <blockDynamicsMap.h>

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

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 iCell.
void	set (std::size_t iCell, Dynamics< T, DESCRIPTOR > *dynamics)
	Assigns dynamics pointer to cell index iCell.
void	collide (CollisionDispatchStrategy strategy)
	Executes local collision step for entire non-overlap area of lattice.
std::string	describe ()
	Returns a human-readable string listing all managed dynamics and their assigned fraction of cells.

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 358 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.

Setup support for legacy dynamics

Definition at line 401 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);
    });
 
    if constexpr (isPlatformCPU(PLATFORM)) {
      using LegacyO = LegacyBlockCollisionO<T,DESCRIPTOR,PLATFORM>;
      _map[typeid(LegacyO)] = std::make_unique<LegacyO>(_lattice.getNcells(),
                                                        _dynamicsOfCells.get());
      _map[typeid(LegacyO)]->setup(_lattice);
    }
  }

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 480 of file blockDynamicsMap.h.

  {
    switch (strategy) {
    case CollisionDispatchStrategy::Dominant:
      if (!_dominantCollisionO) {
        _dominantCollisionO = std::max_element(_map.begin(),
                                               _map.end(),
                                               [](const auto& lhs, const auto& rhs) -> bool {
                                                 return lhs.second->weight() < rhs.second->weight();
                                               })->second.get();
      }
      _dominantCollisionO->apply(_lattice, _coreMask, strategy);
      break;
 
    case CollisionDispatchStrategy::Individual:
      for (auto& [id, collisionO] : _map) {
        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, olb::Individual, and olb::AbstractCollisionO< T, DESCRIPTOR >::weight().

Here is the call graph for this function:

describe()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

std::string olb::BlockDynamicsMap< T, DESCRIPTOR, PLATFORM >::describe ( )

inline

Returns a human-readable string listing all managed dynamics and their assigned fraction of cells.

Definition at line 509 of file blockDynamicsMap.h.

  {
    std::stringstream out;
    for (auto& [_, collisionO] : _map) {
      out << collisionO->getDynamics()->getName() << ", "
          << static_cast<double>(collisionO.weight()) / (_coreMask.weight())
          << std::endl;
    }
    return out.str();
  }

References olb::AbstractCollisionO< T, DESCRIPTOR >::getDynamics(), and olb::AbstractCollisionO< T, DESCRIPTOR >::weight().

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 425 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 435 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 430 of file blockDynamicsMap.h.

  {
    return _dynamicsOfCells[iCell];
  }

set() [1/2]

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

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

inline

Assigns dynamics pointer to cell index iCell.

Dynamics at the pointed address must either be legacy or previously constructed from a promise.

Definition at line 452 of file blockDynamicsMap.h.

  {
    auto iter = _map.find(dynamics->id());
    if (iter != _map.end()) { // Non-legacy dynamics
      set(iCell, *iter->second);
    } else { // Legacy dynamics
      iter = _map.find(typeid(LegacyBlockCollisionO<T,DESCRIPTOR,PLATFORM>));
      if (iter != _map.end()) {
        // Order is important here as LegacyBlockCollisionO uses the dynamics
        // pointer to construct matching LegacyConcreteDynamics internally.
        _dynamicsOfCells[iCell] = dynamics;
        set(iCell, *iter->second);
      } else {
        throw std::runtime_error("Legacy dynamics not supported on this platform");
      }
    }
    _dominantCollisionO = nullptr;
  }

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

Here is the call graph for this function:

set() [2/2]

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 iCell.

Definition at line 441 of file blockDynamicsMap.h.

  {
    set(iCell, resolve(std::forward<decltype(promise)>(promise)));
    _dominantCollisionO = nullptr;
  }

---

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

• src/core/blockDynamicsMap.h