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

Storage of any FIELD_TYPE data on PLATFORM. More...

#include <data.h>

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

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

Public Member Functions
template<typename FIELD_TYPE >
bool	provides () const
	Returns true iff FIELD_TYPE is allocated and can be accessed.
template<typename FIELD_TYPE , typename... ARGS>
auto &	allocate (ARGS &&... args)
	Allocate and return FIELD_TYPE data.
template<typename FIELD_TYPE >
void	setSerialization (bool active)
	Sets FIELD_TYPE serialization state to active.
template<typename FIELD_TYPE >
auto &	get ()
	Return reference to data of FIELD_TYPE.
template<typename FIELD >
FieldArrayD< T, DESCRIPTOR, PLATFORM, FIELD > &	getFieldArray ()
	Return reference to data of Array<FIELD>, i.e. FieldArrayD<FIELD>
void	setProcessingContext (ProcessingContext context)
template<typename F >
void	forEach (F f)
	Call f for each managed AnyFieldType.
template<typename TYPE , typename F >
void	forEachCastable (F f)
	Call f for each managed AnyFieldType of TYPE.
auto &	getRegistry ()
	Expose FieldTypeRegistry for device-support.
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.
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
virtual void	postLoad ()

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.

Detailed Description

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

Storage of any FIELD_TYPE data on PLATFORM.

Manages access and serialization of dynamically allocated FIELD_TYPE data. This is the core storage class used for ConcreteBlockLattice on any platform supported by OpenLB.

Definition at line 155 of file data.h.

Member Function Documentation

allocate()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

template<typename FIELD_TYPE , typename... ARGS>

auto & olb::Data< T, DESCRIPTOR, PLATFORM >::allocate ( ARGS &&... args )

inline

Allocate and return FIELD_TYPE data.

Must only be called once for each FIELD_TYPE

Definition at line 176 of file data.h.

                                 {
    _map[typeid(FIELD_TYPE)] = std::make_unique<AnyFieldType<T,DESCRIPTOR,PLATFORM>>(
      meta::id<FIELD_TYPE>(), std::forward<decltype(args)>(args)...);
 
    AnyFieldType<T,DESCRIPTOR,PLATFORM>* newField = _map[typeid(FIELD_TYPE)].get();
    _registry.template track<FIELD_TYPE>(newField);
    return *newField->template as<FIELD_TYPE>();
  }

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

Here is the call graph for this function:

forEach()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

template<typename F >

void olb::Data< T, DESCRIPTOR, PLATFORM >::forEach ( F f )

inline

Call f for each managed AnyFieldType.

Definition at line 223 of file data.h.

                    {
    for (auto& [_, field] : _map) {
      f(*field);
    }
  }

Here is the caller graph for this function:

forEachCastable()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

template<typename TYPE , typename F >

void olb::Data< T, DESCRIPTOR, PLATFORM >::forEachCastable ( F f )

inline

Call f for each managed AnyFieldType of TYPE.

Used to e.g. iterate over all field arrays

Definition at line 234 of file data.h.

                            {
    forEach([&f](AnyFieldType<T,DESCRIPTOR,PLATFORM>& any) {
      if (auto casted = any.template tryAs<TYPE>()) {
        f(*casted);
      }
    });
  }

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

Here is the call graph for this function:

get()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

template<typename FIELD_TYPE >

auto & olb::Data< T, DESCRIPTOR, PLATFORM >::get ( )

inline

Return reference to data of FIELD_TYPE.

Definition at line 202 of file data.h.

              {
    return *_registry.template get<FIELD_TYPE>()->template as<FIELD_TYPE>();
  }

Here is the caller graph for this function:

getBlock()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

bool * olb::Data< 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 277 of file data.h.

{
  std::size_t currentBlock = 0;
  bool* dataPtr = nullptr;
 
  for (const auto& [_, serializable] : _serializationNames) {
    registerSerializableOfConstSize(iBlock, sizeBlock, currentBlock, dataPtr, *serializable, loadingMode);
  }
 
  return dataPtr;
}

getFieldArray()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

template<typename FIELD >

FieldArrayD< T, DESCRIPTOR, PLATFORM, FIELD > & olb::Data< T, DESCRIPTOR, PLATFORM >::getFieldArray ( )

inline

Return reference to data of Array<FIELD>, i.e. FieldArrayD<FIELD>

Most common field type, used for any lattice structured data in ConcreteBlockLattice

Definition at line 211 of file data.h.

                                                            {
    return get<Array<FIELD>>();
  }

getNblock()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

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

overridevirtual

Number of data blocks for the serializable interface.

Implements olb::Serializable.

Definition at line 257 of file data.h.

{
  std::size_t nBlock = 0;
  for (const auto& [_, serializable] : _serializationNames) {
    nBlock += serializable->getNblock();
  }
  return nBlock;
}

getRegistry()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

auto & olb::Data< T, DESCRIPTOR, PLATFORM >::getRegistry ( )

inline

Expose FieldTypeRegistry for device-support.

Definition at line 243 of file data.h.

                      {
    return _registry;
  }

Here is the caller graph for this function:

getSerializableSize()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

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

overridevirtual

Binary size for the serializer.

Implements olb::Serializable.

Definition at line 267 of file data.h.

{
  std::size_t size = 0;
  for (const auto& [_, serializable] : _serializationNames) {
    size += serializable->getSerializableSize();
  }
  return size;
}

provides()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

template<typename FIELD_TYPE >

bool olb::Data< T, DESCRIPTOR, PLATFORM >::provides ( ) const

inline

Returns true iff FIELD_TYPE is allocated and can be accessed.

Definition at line 167 of file data.h.

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

setProcessingContext()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

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

inline

Definition at line 215 of file data.h.

                                                       {
    for (auto& [_, field] : _map) {
      field->setProcessingContext(context);
    }
  }

Here is the caller graph for this function:

setSerialization()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

template<typename FIELD_TYPE >

void olb::Data< T, DESCRIPTOR, PLATFORM >::setSerialization ( bool active )

inline

Sets FIELD_TYPE serialization state to active.

By default Data doesn't (de)serialize any fields but ConcreteBlockLattice sets all descriptor-declared field arrays to active.

Definition at line 192 of file data.h.

                                     {
    if (active) {
      _serializationNames[meta::name<FIELD_TYPE>()] = _registry.template get<FIELD_TYPE>()->asSerializable();
    } else {
      _serializationNames.erase(meta::name<FIELD_TYPE>());
    }
  }

---

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

• src/core/data.h