Implementation of BlockLattice on a concrete PLATFORM. More...

#include <blockLattice.h>

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

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

Public Types
using	value_t = T

using	descriptor_t = DESCRIPTOR

Public Member Functions
	ConcreteBlockLattice (Vector< int, DESCRIPTOR::d > size, int padding=0)

void	setProcessingContext (ProcessingContext context) override
	Set processing context.

ConcreteData< T, DESCRIPTOR, PLATFORM > &	getData ()

template<typename FIELD_TYPE >
bool	hasData () const

template<typename FIELD_TYPE >
const auto &	getData () const

template<typename FIELD_TYPE >
auto &	getData ()

template<typename FIELD >
const auto &	getField (FIELD field=FIELD()) const

template<typename FIELD >
auto &	getField (FIELD field=FIELD())

bool	hasCommunicatable (std::type_index field) const override

Communicatable &	getCommunicatable (std::type_index field) override

void	collide () override
	Apply collision step of non-overlap interior.

void	stream () override
	Perform propagation step on the whole block.

void	setCollisionO (std::function< void(ConcreteBlockLattice &)> &&op)
	Replace default collision logic of BlockDynamicsMap.

BlockDynamicsMap< T, DESCRIPTOR, PLATFORM > &	getDynamicsMap ()

Dynamics< T, DESCRIPTOR > *	getDynamics (CellID iCell) override
	Get reference to dynamics of cell by index.

void	setDynamics (CellID iCell, DynamicsPromise< T, DESCRIPTOR > &&promise) override
	Set dynamics at iCell to promised dynamics.

template<typename FIELD >
void	setParameter (FieldD< T, DESCRIPTOR, FIELD > value)

template<typename PARAMETER , typename _DESCRIPTOR , Platform _PLATFORM, typename FIELD >
void	setParameter (FieldArrayD< T, _DESCRIPTOR, _PLATFORM, FIELD > &fieldArray)

template<typename PARAMETER , typename _DESCRIPTOR , typename FIELD >
void	setParameter (AbstractFieldArrayD< T, _DESCRIPTOR, FIELD > &abstractFieldArray)

bool	hasPostProcessor (std::type_index stage, PostProcessorPromise< T, DESCRIPTOR > &&promise) override
	Returns true if stage contains post processor.

void	addPostProcessor (std::type_index stage, LatticeR< DESCRIPTOR::d > latticeR, PostProcessorPromise< T, DESCRIPTOR > &&promise) override
	Schedule post processor for application to latticeR in stage.

void	addPostProcessor (std::type_index stage, BlockIndicatorF< T, DESCRIPTOR::d > &indicator, PostProcessorPromise< T, DESCRIPTOR > &&promise) override
	Schedule post processor for application to indicated cells in stage.

void	addPostProcessor (std::type_index stage, PostProcessorPromise< T, DESCRIPTOR > &&promise) override
	Schedule post processor for application to entire block in stage.

void	postProcess (std::type_index stage) override
	Execute post processors of stage.

Vector< T *, DESCRIPTOR::q >	getPopulationPointers (CellID iCell) override
	Return pointers to population values of cell index iCell.

auto &	getDataRegistry ()
	Return reference to Data's FieldTypeRegistry.

void	writeDescription (std::ostream &clout) const override
	Prints human-readable summary of all used dynamics and post processors.

void	writeDynamicsAsCSV (std::ostream &clout) const override
	Prints CSV-structured list of all used dynamics.

void	writeOperatorAsCSV (std::ostream &clout) const override
	Prints CSV-structured list of all used operators.

std::size_t	getNblock () const override
	Number of data blocks for the serializable interface.

std::size_t	getSerializableSize () const override
	Binary size for the serializer.

bool *	getBlock (std::size_t iBlock, std::size_t &sizeBlock, bool loadingMode) override
	Return a pointer to the memory of the current block and its size for the serializable interface.

void	postLoad () override
	Reinit population structure after deserialization.

Public Member Functions inherited from olb::BlockLattice< T, DESCRIPTOR >
	BlockLattice (Vector< int, DESCRIPTOR::d > size, int padding, Platform platform)

virtual	~BlockLattice ()

Platform	getPlatform () const
	Return platform used to process lattice.

template<Platform PLATFORM>
ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM > &	asConcrete ()

template<typename FIELD_TYPE >
bool	hasData ()
	Return whether FIELD_TYPE is available / has been allocated.

template<typename FIELD_TYPE >
const auto &	getData (FIELD_TYPE field=FIELD_TYPE{}) const
	Return abstract interface for concrete FIELD_TYPE data.

template<typename FIELD_TYPE >
auto &	getData (FIELD_TYPE field=FIELD_TYPE{})
	Return abstract interface for concrete FIELD_TYPE data.

template<typename FIELD >
const auto &	getField (FIELD field=FIELD{}) const
	Return abstract interface for FIELD array.

template<typename FIELD >
auto &	getField (FIELD field=FIELD{})
	Return abstract interface for FIELD array.

Cell< T, DESCRIPTOR >	get (CellID iCell)
	Get Cell interface for index iCell.

ConstCell< T, DESCRIPTOR >	get (CellID iCell) const
	Get ConstCell interface for index iCell.

Cell< T, DESCRIPTOR >	get (LatticeR< DESCRIPTOR::d > loc)
	Get Cell interface for location loc.

ConstCell< T, DESCRIPTOR >	get (LatticeR< DESCRIPTOR::d > loc) const
	Get ConstCell interface for location loc.

template<typename... R>
std::enable_if_t< sizeof...(R)==DESCRIPTOR::d, Cell< T, DESCRIPTOR > >	get (R... latticeR)
	Get Cell interface for componentwise location latticeR.

template<typename... R>
std::enable_if_t< sizeof...(R)==DESCRIPTOR::d, ConstCell< T, DESCRIPTOR > >	get (R... latticeR) const
	Get ConstCell interface for componentwise location latticeR.

void	initialize ()
	Initialize the lattice cells to become ready for simulation.

bool	statisticsEnabled () const

void	setStatisticsEnabled (bool state)

bool	isIntrospectable () const

void	setIntrospectability (bool state)

template<typename... R>
std::enable_if_t< sizeof...(R)==DESCRIPTOR::d, Dynamics< T, DESCRIPTOR > * >	getDynamics (R... latticeR)
	Return pointer to dynamics assigned to latticeR.

void	defineDynamics (LatticeR< DESCRIPTOR::d > latticeR, DynamicsPromise< T, DESCRIPTOR > &&promise)
	Assign promised DYNAMICS to latticeR.

template<template< typename... > typename DYNAMICS>
void	defineDynamics (LatticeR< DESCRIPTOR::d > latticeR)
	Assign DYNAMICS to latticeR.

template<typename DYNAMICS >
void	defineDynamics ()
	Define DYNAMICS everywhere.

template<typename DYNAMICS >
void	defineDynamics (BlockIndicatorF< T, DESCRIPTOR::d > &indicator)
	Define DYNAMICS on a domain described by an indicator.

void	defineDynamics (BlockIndicatorF< T, DESCRIPTOR::d > &indicator, DynamicsPromise< T, DESCRIPTOR > &&promise)
	Define promised dynamics on a domain described by an indicator.

template<typename FIELD >
void	setParameter (FieldD< T, DESCRIPTOR, FIELD > value)
	Set value of parameter FIELD for any dynamics that provide it.

template<typename PARAMETER , typename _DESCRIPTOR , typename FIELD >
void	setParameter (AbstractFieldArrayD< T, _DESCRIPTOR, FIELD > &fieldArray)

template<typename PARAMETER , typename _DESCRIPTOR , Platform PLATFORM, typename FIELD >
void	setParameter (FieldArrayD< T, _DESCRIPTOR, PLATFORM, FIELD > &fieldArray)

template<typename STAGE >
void	postProcess ()
	Execute post processors of STAGE.

template<typename FIELD >
void	defineField (BlockIndicatorF< T, DESCRIPTOR::d > &indicator, AnalyticalF< DESCRIPTOR::d, T, T > &field)
	Define a field on a domain described by an indicator.

template<typename FIELD >
void	defineField (BlockIndicatorF< T, DESCRIPTOR::d > &indicator, BlockF< T, DESCRIPTOR::d > &field)
	Define a field on a domain described by an indicator.

template<typename FIELD >
void	defineField (BlockGeometry< T, DESCRIPTOR::d > &blockGeometry, IndicatorF< T, DESCRIPTOR::d > &indicatorF, AnalyticalF< DESCRIPTOR::d, T, T > &field)
	Define a field on a domain described by an analytical indicator.

void	defineRho (BlockIndicatorF< T, DESCRIPTOR::d > &indicator, AnalyticalF< DESCRIPTOR::d, T, T > &rho)
	Define rho on a domain described by an indicator.

void	defineU (BlockIndicatorF< T, DESCRIPTOR::d > &indicator, AnalyticalF< DESCRIPTOR::d, T, T > &u)
	Define u on a domain described by an indicator.

void	defineRhoU (BlockIndicatorF< T, DESCRIPTOR::d > &indicator, AnalyticalF< DESCRIPTOR::d, T, T > &rho, AnalyticalF< DESCRIPTOR::d, T, T > &u)
	Define rho and u on a domain described by an indicator.

void	definePopulations (BlockIndicatorF< T, DESCRIPTOR::d > &indicator, AnalyticalF< DESCRIPTOR::d, T, T > &Pop)
	Define a population on a domain described by an indicator.

void	definePopulations (BlockIndicatorF< T, DESCRIPTOR::d > &indicator, BlockF< T, DESCRIPTOR::d > &Pop)

void	iniEquilibrium (BlockIndicatorF< T, DESCRIPTOR::d > &indicator, AnalyticalF< DESCRIPTOR::d, T, T > &rho, AnalyticalF< DESCRIPTOR::d, T, T > &u)
	Initialize by equilibrium on a domain described by an indicator.

void	iniEquilibrium (BlockIndicatorF< T, DESCRIPTOR::d > &indicator, AnalyticalF< DESCRIPTOR::d, T, T > &rho, BlockF< T, DESCRIPTOR::d > &u)

void	iniRegularized (BlockIndicatorF< T, DESCRIPTOR::d > &indicator, AnalyticalF< DESCRIPTOR::d, T, T > &rho, AnalyticalF< DESCRIPTOR::d, T, T > &u, AnalyticalF< DESCRIPTOR::d, T, T > &pi)
	Initialize by non- and equilibrium on a domain described by an indicator.

void	stripeOffDensityOffset (T offset)
	Subtract the given offset from all densities.

LatticeStatistics< T > &	getStatistics ()
	Return a handle to the LatticeStatistics object.

LatticeStatistics< T > const &	getStatistics () const
	Return a constant handle to the LatticeStatistics object.

Public Member Functions inherited from olb::BlockStructureD< D >
	BlockStructureD (Vector< int, D > size, int padding=0)

	BlockStructureD ()

void	resize (Vector< int, D > size)

auto	getCore () const

int	getNx () const
	Read only access to block width.

int	getNy () const
	Read only access to block height.

int	getNz () const
	Read only access to block height.

LatticeR< D >	getExtent () const

int	getPadding () const
	Read only access to padding.

std::size_t	getNcells () const
	Get number of cells.

CellID	getCellId (LatticeR< D > latticeR) const
	Get 1D cell ID.

template<typename... L>
std::enable_if_t< sizeof...(L)==D, CellID >	getCellId (L... latticeR) const

LatticeR< D >	getLatticeR (CellID iCell) const

CellDistance	getNeighborDistance (LatticeR< D > dir) const
	Get 1D neighbor distance.

bool	isInside (LatticeR< D > latticeR) const
	Return whether location is valid.

bool	isInsideCore (LatticeR< D > latticeR) const
	Return whether location is inside core.

bool	isPadding (LatticeR< D > latticeR) const
	Return whether location is valid.

bool	isPadding (LatticeR< D > latticeR, int overlap) const

bool	isPadding (CellID iCell) const

template<typename... L>
std::enable_if_t< sizeof...(L)==D, bool >	isInside (L... latticeR) const

CellDistance	getNeighborhoodRadius (LatticeR< D > latticeR) const
	Return maximum valid neighborhood sphere radius w.r.t. latticeR.

template<typename F >
void	forSpatialLocations (F f) const

template<typename F >
void	forSpatialLocationsParallel (F f) const

template<typename F >
void	forSpatialLocations (LatticeR< D > min, LatticeR< D > max, F f) const

template<typename F >
void	forCoreSpatialLocations (F f) const

template<typename F >
void	forCellIndices (F f) const

Public Member Functions inherited from olb::Serializable
virtual	~Serializable ()=default

template<bool includeLogOutputDir = true>
bool	save (std::string fileName="", const bool enforceUint=false)
	Save `Serializable` into file `fileName`

template<bool includeLogOutputDir = true>
bool	load (std::string fileName="", const bool enforceUint=false)
	Load `Serializable` from file `fileName`

bool	save (std::uint8_t *buffer)
	Save `Serializable` into buffer of length `getSerializableSize`

bool	load (const std::uint8_t *buffer)
	Load `Serializable` from buffer of length `getSerializableSize`

Static Public Attributes
static constexpr Platform	platform = PLATFORM

Additional Inherited Members
Protected Member Functions inherited from olb::Serializable
template<typename DataType >
void	registerVar (const std::size_t iBlock, std::size_t &sizeBlock, std::size_t &currentBlock, bool *&dataPtr, const DataType &data, const size_t arrayLength=1) const
	Register primitive data types (`int`, `double`, ...) or arrays of those.

template<typename DataType >
void	registerSerializableOfConstSize (const std::size_t iBlock, std::size_t &sizeBlock, std::size_t &currentBlock, bool *&dataPtr, DataType &data, const bool loadingMode=false)
	Register `Serializable` object of constant size.

template<typename DataType >
void	registerSerializablesOfConstSize (const std::size_t iBlock, std::size_t &sizeBlock, std::size_t &currentBlock, bool &dataPtr, DataType data, const size_t arrayLength, const bool loadingMode=false)
	Register an array of `Serializable` objects of constant size.

Protected Attributes inherited from olb::BlockLattice< T, DESCRIPTOR >
const Platform	_platform
	Platform used by the derived concrete lattice.

bool	_statisticsEnabled
	True if statistics are gathered during collide.

LatticeStatistics< T > *	_statistics

bool	_introspectable
	True for lattice that can be introspected.

Protected Attributes inherited from olb::BlockStructureD< D >
LatticeR< D >	_core

LatticeR< D >	_size

LatticeR< D >	_projection

int	_padding

Detailed Description

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

Implementation of BlockLattice on a concrete PLATFORM.

Definition at line 37 of file communicator.h.

Member Typedef Documentation

◆ descriptor_t

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

using olb::ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM >::descriptor_t = DESCRIPTOR

Definition at line 481 of file blockLattice.h.

◆ value_t

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

using olb::ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM >::value_t = T

Definition at line 480 of file blockLattice.h.

Constructor & Destructor Documentation

◆ ConcreteBlockLattice()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

olb::ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM >::ConcreteBlockLattice	(	Vector< int, DESCRIPTOR::d >	size,
		int	padding = 0 )

Definition at line 394 of file blockLattice.hh.

  : BlockLattice<T,DESCRIPTOR>(size, padding, PLATFORM),
    _data(),
    _descriptorFields(),
    _dynamicsMap(*this)
{
  DESCRIPTOR::fields_t::for_each([&](auto id) {
    using field = typename decltype(id)::type;
    using field_type = Array<field>;
    auto& fieldArray = _data.template allocate<field_type>(this->getNcells());
    _descriptorFields.template set<field>(&fieldArray);
    _communicatables[typeid(field)] = std::unique_ptr<Communicatable>(new ConcreteCommunicatable<
      ColumnVector<typename ImplementationOf<typename field::template column_type<T>,PLATFORM>::type,
                 DESCRIPTOR::template size<field>()>
    >(fieldArray));
    _data.template setSerialization<field_type>(true);
  });
 
  for (CellID iCell=0; iCell < this->getNcells(); ++iCell) {
    _dynamicsMap.set(iCell, meta::id<NoDynamics<T,DESCRIPTOR>>{});
  }
}

References olb::BlockStructureD< D >::getNcells().

Here is the call graph for this function:

Member Function Documentation

◆ addPostProcessor() [1/3]

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

void olb::ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM >::addPostProcessor	(	std::type_index	stage,
		BlockIndicatorF< T, DESCRIPTOR::d > &	indicator,
		PostProcessorPromise< T, DESCRIPTOR > &&	promise )

inlineoverridevirtual

Schedule post processor for application to indicated cells in stage.

Implements olb::BlockLattice< T, DESCRIPTOR >.

Definition at line 634 of file blockLattice.h.

  {
    if (promise.scope() == OperatorScope::PerBlock) {
      if (!indicator.isEmpty()) {
        auto [postProcessorsOfPriority, _] = _postProcessors[stage].try_emplace(promise.priority(), this);
        std::get<1>(*postProcessorsOfPriority).add(std::forward<decltype(promise)>(promise));
      }
    } else {
      this->forCoreSpatialLocations([&](LatticeR<DESCRIPTOR::d> loc) {
        if (indicator(loc)) {
          addPostProcessor(stage, loc, std::forward<decltype(promise)>(promise));
        }
      });
    }
  }

References olb::ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM >::addPostProcessor(), olb::BlockStructureD< D >::forCoreSpatialLocations(), and olb::PerBlock.

Here is the call graph for this function:

◆ addPostProcessor() [2/3]

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

void olb::ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM >::addPostProcessor	(	std::type_index	stage,
		LatticeR< DESCRIPTOR::d >	latticeR,
		PostProcessorPromise< T, DESCRIPTOR > &&	promise )

inlineoverridevirtual

Schedule post processor for application to latticeR in stage.

Implements olb::BlockLattice< T, DESCRIPTOR >.

Definition at line 625 of file blockLattice.h.

  {
    auto [postProcessorsOfPriority, _] = _postProcessors[stage].try_emplace(promise.priority(), this);
    std::get<1>(*postProcessorsOfPriority).add(this->getCellId(latticeR),
                                               std::forward<decltype(promise)>(promise));
  }

Here is the caller graph for this function:

◆ addPostProcessor() [3/3]

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

void olb::ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM >::addPostProcessor	(	std::type_index	stage,
		PostProcessorPromise< T, DESCRIPTOR > &&	promise )

inlineoverridevirtual

Schedule post processor for application to entire block in stage.

Implements olb::BlockLattice< T, DESCRIPTOR >.

Definition at line 652 of file blockLattice.h.

  {
    if (promise.scope() == OperatorScope::PerBlock) {
      auto [postProcessorsOfPriority, _] = _postProcessors[stage].try_emplace(promise.priority(), this);
      std::get<1>(*postProcessorsOfPriority).add(std::forward<decltype(promise)>(promise));
    } else {
      this->forCoreSpatialLocations([&](LatticeR<DESCRIPTOR::d> loc) {
        addPostProcessor(stage, loc, std::forward<decltype(promise)>(promise));
      });
    }
  }

References olb::ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM >::addPostProcessor(), olb::BlockStructureD< D >::forCoreSpatialLocations(), and olb::PerBlock.

Here is the call graph for this function:

◆ collide()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

void olb::ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM >::collide ( )

overridevirtual

Apply collision step of non-overlap interior.

Implements olb::BlockLattice< T, DESCRIPTOR >.

Definition at line 304 of file blockLattice.hh.

{
  if (_customCollisionO) {
    _customCollisionO->operator()(*this);
  } else {
    if constexpr (isPlatformCPU(PLATFORM)) {
      _dynamicsMap.collide(CollisionDispatchStrategy::Dominant);
    } else {
      _dynamicsMap.collide(CollisionDispatchStrategy::Individual);
    }
  }
}

References olb::Dominant, olb::Individual, and olb::isPlatformCPU().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getBlock()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

bool * olb::ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM >::getBlock	(	std::size_t	iBlock,
		std::size_t &	sizeBlock,
		bool	loadingMode )

overridevirtual

Return a pointer to the memory of the current block and its size for the serializable interface.

Implements olb::Serializable.

Definition at line 622 of file blockLattice.hh.

{
  std::size_t currentBlock = 0;
  bool* dataPtr = nullptr;
 
  this->registerSerializableOfConstSize(iBlock, sizeBlock, currentBlock, dataPtr, _data, loadingMode);
 
  return dataPtr;
}

◆ getCommunicatable()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

Communicatable & olb::ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM >::getCommunicatable ( std::type_index field )

inlineoverridevirtual

Implements olb::BlockLattice< T, DESCRIPTOR >.

Definition at line 518 of file blockLattice.h.

                                                                  {
    return *_communicatables.at(field).get();
  }

Here is the caller graph for this function:

◆ getData() [1/3]

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

ConcreteData< T, DESCRIPTOR, PLATFORM > & olb::ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM >::getData ( )

inline

Definition at line 499 of file blockLattice.h.

                                                 {
    return _data;
  }

Here is the caller graph for this function:

◆ getData() [2/3]

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

template<typename FIELD_TYPE >

auto & olb::ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM >::getData ( )

Definition at line 436 of file blockLattice.hh.

{
  if (_data.template provides<FIELD_TYPE>()) {
    return _data.template get<FIELD_TYPE>();
  } else {
    // TODO: Implement more generic approach to constructing arbitrary data from specific args
    auto& data = _data.template allocate<FIELD_TYPE>(this->getNcells());
    // Manage serializables and communicatables for array fields
    using concrete_data_t = typename FIELD_TYPE::template type<T,DESCRIPTOR,PLATFORM>;
    if constexpr (std::is_base_of_v<ColumnVectorBase,concrete_data_t>) {
      using field_t = typename concrete_data_t::field_t;
      if constexpr (field_t::isSerializable()) {
        _data.template setSerialization<FIELD_TYPE>(true);
      }
      _communicatables[typeid(field_t)] = std::unique_ptr<Communicatable>(new ConcreteCommunicatable<
        ColumnVector<typename ImplementationOf<typename field_t::template column_type<T>,PLATFORM>::type,
                   DESCRIPTOR::template size<field_t>()>
      >(data));
    }
    return data;
  }
  __builtin_unreachable();
}

◆ getData() [3/3]

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

template<typename FIELD_TYPE >

const auto & olb::ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM >::getData ( ) const

Definition at line 427 of file blockLattice.hh.

{
  OLB_ASSERT(_data.template provides<FIELD_TYPE>(),
             "FIELD_TYPE must be allocated to be accessed");
  return _data.template get<FIELD_TYPE>();
}

References OLB_ASSERT.

◆ getDataRegistry()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

auto & olb::ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM >::getDataRegistry ( )

inline

Return reference to Data's FieldTypeRegistry.

Only of interest for implementing specific device support

Definition at line 683 of file blockLattice.h.

                          {
    return _data.getRegistry();
  }

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

Here is the call graph for this function:

◆ getDynamics()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

Dynamics< T, DESCRIPTOR > * olb::ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM >::getDynamics ( CellID iCell )

inlineoverridevirtual

Get reference to dynamics of cell by index.

Implements olb::BlockLattice< T, DESCRIPTOR >.

Definition at line 550 of file blockLattice.h.

  {
    return _dynamicsMap.get(iCell);
  }

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getDynamicsMap()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

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

inline

Definition at line 545 of file blockLattice.h.

                                                            {
    return _dynamicsMap;
  }

◆ getField() [1/2]

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

template<typename FIELD >

auto & olb::ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM >::getField ( FIELD field = FIELD() )

Definition at line 462 of file blockLattice.hh.

{
  if constexpr (DESCRIPTOR::fields_t::template contains<FIELD>()) {
    return static_cast<FieldArrayD<T,DESCRIPTOR,PLATFORM,FIELD>&>(*_descriptorFields.template get<FIELD>());
  } else {
    return getData<Array<FIELD>>();
  }
  __builtin_unreachable();
}

◆ getField() [2/2]

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

template<typename FIELD >

const auto & olb::ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM >::getField ( FIELD field = FIELD() ) const

Definition at line 474 of file blockLattice.hh.

{
  if constexpr (DESCRIPTOR::fields_t::template contains<FIELD>()) {
    return static_cast<const FieldArrayD<T,DESCRIPTOR,PLATFORM,FIELD>&>(*_descriptorFields.template get<FIELD>());
  } else {
    return getData<Array<FIELD>>();
  }
  __builtin_unreachable();
}

Here is the caller graph for this function:

◆ getNblock()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

std::size_t olb::ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM >::getNblock ( ) const

overridevirtual

Number of data blocks for the serializable interface.

Implements olb::Serializable.

Definition at line 610 of file blockLattice.hh.

{
  return _data.getNblock();
}

◆ getPopulationPointers()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

Vector< T *, DESCRIPTOR::q > olb::ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM >::getPopulationPointers ( CellID iCell )

inlineoverridevirtual

Return pointers to population values of cell index iCell.

Performance optimization for access via virtual Cell

Implements olb::BlockLattice< T, DESCRIPTOR >.

Definition at line 672 of file blockLattice.h.

                                                                      {
    auto& pops = getField<descriptors::POPULATION>();
    return Vector<T*,DESCRIPTOR::q>([&](unsigned iPop) -> T* {
      return &pops[iPop][iCell];
    });
  }

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

Here is the call graph for this function:

◆ getSerializableSize()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

std::size_t olb::ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM >::getSerializableSize ( ) const

overridevirtual

Binary size for the serializer.

Implements olb::Serializable.

Definition at line 616 of file blockLattice.hh.

{
  return _data.getSerializableSize();
}

◆ hasCommunicatable()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

bool olb::ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM >::hasCommunicatable ( std::type_index field ) const

inlineoverridevirtual

Implements olb::BlockLattice< T, DESCRIPTOR >.

Definition at line 515 of file blockLattice.h.

                                                             {
    return _communicatables.find(field) != _communicatables.end();
  }

◆ hasData()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

template<typename FIELD_TYPE >

bool olb::ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM >::hasData ( ) const

Definition at line 420 of file blockLattice.hh.

{
  return _data.template provides<FIELD_TYPE>();
}

◆ hasPostProcessor()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

bool olb::ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM >::hasPostProcessor	(	std::type_index	stage,
		PostProcessorPromise< T, DESCRIPTOR > &&	promise )

inlineoverridevirtual

Returns true if stage contains post processor.

Implements olb::BlockLattice< T, DESCRIPTOR >.

Definition at line 617 of file blockLattice.h.

  {
    auto [postProcessorsOfPriority, _] = _postProcessors[stage].try_emplace(promise.priority(), this);
    return std::get<1>(*postProcessorsOfPriority).contains(
      std::forward<decltype(promise)>(promise));
  }

◆ postLoad()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

void olb::ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM >::postLoad ( )

overridevirtual

Reinit population structure after deserialization.

Reimplemented from olb::Serializable.

Definition at line 633 of file blockLattice.hh.

{
  auto& population = getField<descriptors::POPULATION>();
  for (unsigned iPop=0; iPop < DESCRIPTOR::q; ++iPop) {
    population[iPop].postLoad();
  }
}

◆ postProcess()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

void olb::ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM >::postProcess ( std::type_index stage )

overridevirtual

Execute post processors of stage.

Implements olb::BlockLattice< T, DESCRIPTOR >.

Definition at line 485 of file blockLattice.hh.

{
  for (auto& [_, postProcessorsOfPriority] : _postProcessors[stage]) {
    postProcessorsOfPriority.apply();
  }
}

Here is the caller graph for this function:

◆ setCollisionO()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

void olb::ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM >::setCollisionO ( std::function< void(ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM > &)> && op )

inline

Replace default collision logic of BlockDynamicsMap.

May be used to inject domain knowledge for improving performance by e.g. reducing the need to use virtual dispatching for non-dominant dynamics. This is necessarily platform specific.

Definition at line 541 of file blockLattice.h.

                                                                    {
    _customCollisionO = op;
  }

◆ setDynamics()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

void olb::ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM >::setDynamics	(	CellID	iCell,
		DynamicsPromise< T, DESCRIPTOR > &&	)

inlineoverridevirtual

Set dynamics at iCell to promised dynamics.

Implements olb::BlockLattice< T, DESCRIPTOR >.

Definition at line 555 of file blockLattice.h.

  {
    _dynamicsMap.set(iCell, std::forward<decltype(promise)>(promise));
    auto cell = this->get(iCell);
    getDynamics(iCell)->initialize(cell);
  }

References olb::BlockLattice< T, DESCRIPTOR >::get(), olb::ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM >::getDynamics(), and olb::BlockDynamicsMap< T, DESCRIPTOR, PLATFORM >::set().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setParameter() [1/3]

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

template<typename PARAMETER , typename _DESCRIPTOR , typename FIELD >

void olb::ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM >::setParameter ( AbstractFieldArrayD< T, _DESCRIPTOR, FIELD > & abstractFieldArray )

inline

Definition at line 594 of file blockLattice.h.

  {
    if constexpr (PLATFORM == Platform::CPU_SIMD) {
      switch (abstractFieldArray.getPlatform()) {
        case Platform::CPU_SISD: {
          auto& fieldArray = dynamic_cast<FieldArrayD<T,_DESCRIPTOR,Platform::CPU_SISD,FIELD>&>(abstractFieldArray);
          setParameter<PARAMETER>(fieldArray);
          break;
        }
        case Platform::CPU_SIMD: {
          auto& fieldArray = dynamic_cast<FieldArrayD<T,_DESCRIPTOR,Platform::CPU_SIMD,FIELD>&>(abstractFieldArray);
          setParameter<PARAMETER>(fieldArray);
          break;
        }
        default:
          throw std::bad_cast();
      }
    } else {
      auto& fieldArray = dynamic_cast<FieldArrayD<T,_DESCRIPTOR,PLATFORM,FIELD>&>(abstractFieldArray);
      setParameter<PARAMETER>(fieldArray);
    }
  }

References olb::CPU_SIMD, olb::CPU_SISD, olb::AbstractFieldArrayD< T, DESCRIPTOR, FIELD >::getPlatform(), and olb::ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM >::setParameter().

Here is the call graph for this function:

◆ setParameter() [2/3]

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

template<typename PARAMETER , typename _DESCRIPTOR , Platform _PLATFORM, typename FIELD >

void olb::ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM >::setParameter ( FieldArrayD< T, _DESCRIPTOR, _PLATFORM, FIELD > & fieldArray )

inline

Definition at line 575 of file blockLattice.h.

  {
    static_assert(DESCRIPTOR::template size<PARAMETER>() == DESCRIPTOR::template size<FIELD>(),
                  "PARAMETER field size must match FIELD size");
    if constexpr (PLATFORM == Platform::GPU_CUDA) {
      static_assert(PLATFORM == _PLATFORM, "FieldArrayD must be available on PLATFORM");
    }
    FieldD<T,DESCRIPTOR,PARAMETER> fieldArrayPointers;
    for (unsigned iD=0; iD < fieldArray.d; ++iD) {
      if constexpr (PLATFORM == Platform::GPU_CUDA) {
        fieldArrayPointers[iD] = fieldArray[iD].deviceData();
      } else {
        fieldArrayPointers[iD] = fieldArray[iD].data();
      }
    }
    setParameter<PARAMETER>(std::move(fieldArrayPointers));
  }

References olb::ColumnVector< COLUMN, D >::d, olb::GPU_CUDA, and olb::ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM >::setParameter().

Here is the call graph for this function:

◆ setParameter() [3/3]

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

template<typename FIELD >

void olb::ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM >::setParameter ( FieldD< T, DESCRIPTOR, FIELD > value )

inline

Definition at line 563 of file blockLattice.h.

  {
    _data.template forEachCastable<AbstractedConcreteParameters<T,DESCRIPTOR>>([&](auto* parameters) {
      auto& params = parameters->asAbstract();
      if (params.template provides<FIELD>()) {
        params.template set<FIELD>(value);
        parameters->setProcessingContext(ProcessingContext::Simulation);
      }
    });
  }

References olb::Simulation.

Here is the caller graph for this function:

◆ setProcessingContext()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

void olb::ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM >::setProcessingContext ( ProcessingContext )

inlineoverridevirtual

Set processing context.

This is currently used to trigger data transfers between host and GPU data for Platform::GPU_CUDA.

Implements olb::BlockLattice< T, DESCRIPTOR >.

Definition at line 495 of file blockLattice.h.

                                                                {
    _data.setProcessingContext(context);
  }

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

Here is the call graph for this function:

◆ stream()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

void olb::ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM >::stream ( )

overridevirtual

Perform propagation step on the whole block.

Rotates the cyclic arrays storing the POPULATION field to perform implicit propagation using the PS pattern.

Kummerländer, A., Dorn, M., Frank, M., and Krause, M. J. Implicit Propagation of Directly Addressed Grids in Lattice Boltzmann Methods. DOI: 10.13140/RG.2.2.35085.87523

Implements olb::BlockLattice< T, DESCRIPTOR >.

Definition at line 318 of file blockLattice.hh.

{
  if constexpr (PLATFORM == Platform::GPU_CUDA) {
    DESCRIPTOR::template filter<descriptors::is_propagatable_field>
              ::for_each([&](auto field) {
      auto& population = getField(field.get());
      for (unsigned iPop=0; iPop < DESCRIPTOR::q; ++iPop) {
        population[iPop].rotate(this->getNeighborDistance(descriptors::c<DESCRIPTOR>(iPop)));
      }
      // Required for resolving populations in (gather,scatter)_any_fields kernel
      getDataRegistry().refreshDeviceFieldArray(population);
    });
  } else {
    DESCRIPTOR::template filter<descriptors::is_propagatable_field>
              ::for_each([&](auto field) {
      auto& population = getField(field.get());
      for (unsigned iPop=0; iPop < DESCRIPTOR::q; ++iPop) {
        population[iPop].rotate(this->getNeighborDistance(descriptors::c<DESCRIPTOR>(iPop)));
      }
    });
  }
}

References olb::descriptors::c(), and olb::GPU_CUDA.

Here is the call graph for this function:

◆ writeDescription()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

void olb::ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM >::writeDescription ( std::ostream & ) const

overridevirtual

Prints human-readable summary of all used dynamics and post processors.

Implements olb::BlockLattice< T, DESCRIPTOR >.

Definition at line 493 of file blockLattice.hh.

{
  const auto dynamics = _dynamicsMap.getAll();
  for (const auto& promise : dynamics) {
    auto simplifiedName = introspection::getSimplifiedDynamicsName(promise.name());
    std::istringstream stream(simplifiedName);
    std::string fragment;
    std::vector<std::string> fragments;
    while (std::getline(stream, fragment, '\n')) {
      if (!fragment.empty()) {
        fragments.push_back(fragment);
      }
    }
 
    clout << "---Dynamics Details---" << std::endl;
    clout << " name: " << fragments[0] << std::endl;
    for (unsigned i=1; i < fragments.size(); ++i) {
    clout << "       " << fragments[i] << std::endl;
    }
    clout << " weight:           " << _dynamicsMap.getWeight(promise) << std::endl;
    if (auto optimizable = promise.isOptimizable()) {
    clout << " isOptimizable:    " << *optimizable << std::endl;
    }
    clout << " isOptimized:      " << promise.hasOptimizedVersion() << std::endl;
    if (auto count = promise.getArithmeticOperationCount()) {
    clout << " operations[FLOP]: " << *count << std::endl;
    }
    if (auto count = promise.getMemoryBandwidth()) {
    clout << " bandwidth[byte]:  " << *count << std::endl;
    }
    clout << "----------------------" << std::endl;
  }
 
  for (const auto& [stage, map] : _postProcessors) {
    clout << "---Stage Details---" << std::endl;
    clout << " name: " << stage.name() << std::endl;
 
    for (const auto& [priority, postProcessorsOfPriority] : map) {
      clout << std::endl;
      const auto operators = postProcessorsOfPriority.getAll();
      for (const auto& promise : operators) {
        clout << "---Post Processor Details---" << std::endl;
        clout << " name:        " << promise.name() << std::endl;
        clout << " priority:    " << promise.priority() << std::endl;
        clout << " scope:       " << getName(promise.scope()) << std::endl;
        clout << " weight:      " << postProcessorsOfPriority.getWeight(promise) << std::endl;
        clout << " isOptimized: " << promise.hasOptimizedVersion() << std::endl;
        clout << "---------------------------" << std::endl;
      }
    }
 
    clout << "-------------------" << std::endl;
  }
}

◆ writeDynamicsAsCSV()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

void olb::ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM >::writeDynamicsAsCSV ( std::ostream & ) const

overridevirtual

Prints CSV-structured list of all used dynamics.

Used as input for automatic code generation

Implements olb::BlockLattice< T, DESCRIPTOR >.

Definition at line 549 of file blockLattice.hh.

{
  const auto dynamics = _dynamicsMap.getAll();
  clout << "name; weight; isOptimizable; isOptimized; FLOP; complexity; bandwidth" << std::endl;
  for (const auto& promise : dynamics) {
    clout << promise.name()
          << "; " << _dynamicsMap.getWeight(promise);
    if (auto optimizable = promise.isOptimizable()) {
    clout << "; " << *optimizable;
    } else {
    clout << "; -1";
    }
    clout << "; " << promise.hasOptimizedVersion();
    if (auto count = promise.getArithmeticOperationCount()) {
    clout << "; " << *count;
    } else {
    clout << "; -1";
    }
    if (auto count = promise.getComplexity()) {
    clout << "; " << *count;
    } else {
    clout << "; -1";
    }
    if (auto count = promise.getMemoryBandwidth()) {
    clout << "; " << *count;
    } else {
    clout << "; -1";
    }
    clout << std::endl;
  }
}

◆ writeOperatorAsCSV()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

void olb::ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM >::writeOperatorAsCSV ( std::ostream & ) const

overridevirtual

Prints CSV-structured list of all used operators.

Used as input for automatic code generation

Implements olb::BlockLattice< T, DESCRIPTOR >.

Definition at line 582 of file blockLattice.hh.

{
  clout << "name; descriptor; weight; isOptimizable; isOptimized, complexity" << std::endl;
  for (const auto& [stage, map] : _postProcessors) {
    for (const auto& [priority, postProcessorsOfPriority] : map) {
      const auto operators = postProcessorsOfPriority.getAll();
      for (const auto& promise : operators) {
        clout << promise.name()
              << "; " << fields::name<DESCRIPTOR>()
              << "; " << postProcessorsOfPriority.getWeight(promise);
        if (auto optimizable = promise.isOptimizable()) {
          clout << "; " << *optimizable;
        } else {
          clout << "; -1";
        }
        clout << "; " << promise.hasOptimizedVersion();
        if (auto count = promise.getArithmeticOperationCount()) {
          clout << "; " <<* count;
        } else {
          clout << "; -1";
        }
        clout << std::endl;
      }
    }
  }
}

References olb::fields::name().

Here is the call graph for this function:

Member Data Documentation

◆ platform

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

Platform olb::ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM >::platform = PLATFORM

staticconstexpr

Definition at line 488 of file blockLattice.h.

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

src/core/blockDynamicsMap.h
src/core/blockLattice.h
src/core/introspection.h
src/core/operator.h
src/core/platform/gpu/cuda/communicator.h
src/core/blockLattice.hh

Public Types

Public Member Functions

Static Public Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ descriptor_t

◆ value_t

Constructor & Destructor Documentation

◆ ConcreteBlockLattice()

Member Function Documentation

◆ addPostProcessor() [1/3]

◆ addPostProcessor() [2/3]

◆ addPostProcessor() [3/3]

◆ collide()

◆ getBlock()

◆ getCommunicatable()

◆ getData() [1/3]

◆ getData() [2/3]

◆ getData() [3/3]

◆ getDataRegistry()

◆ getDynamics()

◆ getDynamicsMap()

◆ getField() [1/2]

◆ getField() [2/2]

◆ getNblock()

◆ getPopulationPointers()

◆ getSerializableSize()

◆ hasCommunicatable()

◆ hasData()

◆ hasPostProcessor()

◆ postLoad()

◆ postProcess()

◆ setCollisionO()

◆ setDynamics()

◆ setParameter() [1/3]

◆ setParameter() [2/3]

◆ setParameter() [3/3]

◆ setProcessingContext()

◆ stream()

◆ writeDescription()

◆ writeDynamicsAsCSV()

◆ writeOperatorAsCSV()

Member Data Documentation

◆ platform