List of cell indices and associated field data. More...

#include <cellIndexListD.h>

Inheritance diagram for olb::CellIndexListD< T, DESCRIPTOR, FIELDS >:

Collaboration diagram for olb::CellIndexListD< T, DESCRIPTOR, FIELDS >:

Public Member Functions
	CellIndexListD (std::size_t capacity=64)

	CellIndexListD (std::vector< CellID > &&indices)

std::size_t	size () const

std::size_t	append (std::size_t iCell)
	Append cell index and allocate attached field data.

void	sort ()
	Ascending sort of cell indices.

template<typename FIELD >
auto	getFieldPointer (std::size_t index)
	Return pointer to FIELD at index.

template<typename FIELD >
auto	getField (std::size_t index) const
	Return copy of FIELD data at index.

template<typename FIELD >
void	setField (std::size_t index, const FieldD< T, DESCRIPTOR, FIELD > &v)
	Set FIELD data at index.

template<typename FIELD >
const auto &	getFieldArray () const

std::size_t	getNblock () const override
	Returns the number of blocks.

std::size_t	getSerializableSize () const override
	Returns the binary size of the data to be saved.

bool *	getBlock (std::size_t iBlock, std::size_t &sizeBlock, bool loadingMode) override
	Returns the address of the i-th block and its size.

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, typename... FIELDS>
class olb::CellIndexListD< T, DESCRIPTOR, FIELDS >

List of cell indices and associated field data.

To be used as a possible input for upcoming Operators.

e.g. a velocity boundary operator accepts such a CellIndexListD containing the indices of boundary cells together with the velocity field to be applied.

Definition at line 49 of file cellIndexListD.h.

Constructor & Destructor Documentation

◆ CellIndexListD() [1/2]

template<typename T , typename DESCRIPTOR , typename... FIELDS>

olb::CellIndexListD< T, DESCRIPTOR, FIELDS >::CellIndexListD ( std::size_t capacity = 64 )

inline

Definition at line 56 of file cellIndexListD.h.

                                       :
    _count(0),
    _capacity(capacity),
    _fields(capacity)
  { }

◆ CellIndexListD() [2/2]

template<typename T , typename DESCRIPTOR , typename... FIELDS>

olb::CellIndexListD< T, DESCRIPTOR, FIELDS >::CellIndexListD ( std::vector< CellID > && indices )

inline

Definition at line 62 of file cellIndexListD.h.

                                             :
    _capacity(indices.size()),
    _fields(_capacity)
  {
    for (std::size_t i=0; i < indices.size(); ++i) {
      _fields.template get<descriptors::CELL_ID>()[0][i] = indices[i];
    }
  }

Member Function Documentation

◆ append()

template<typename T , typename DESCRIPTOR , typename... FIELDS>

std::size_t olb::CellIndexListD< T, DESCRIPTOR, FIELDS >::append ( std::size_t iCell )

Append cell index and allocate attached field data.

Definition at line 118 of file cellIndexListD.h.

{
  if (_count == _capacity) {
    _capacity *= 2;
    _fields.resize(_capacity);
  }
  _fields.template get<descriptors::CELL_ID>()[0][_count] = iCell;
  return _count++;
}

◆ getBlock()

template<typename T , typename DESCRIPTOR , typename... FIELDS>

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

overridevirtual

Returns the address of the i-th block and its size.

Parameters

iBlock	Index of the block to be returned
sizeBlock	Reference to the size of the returned block

Returns: Pointer to the current block

Each getBlock() method should look like this:

std::size_t currentBlock = 0;
bool* dataPtr = nullptr;

// ... register methods...

return dataPtr;

Implements olb::Serializable.

Definition at line 169 of file cellIndexListD.h.

{
  std::size_t currentBlock = 0;
  bool* dataPtr = nullptr;
 
  registerVar(iBlock, sizeBlock, currentBlock, dataPtr, _count);
  registerVar(iBlock, sizeBlock, currentBlock, dataPtr, _capacity);
  if (loadingMode && iBlock == 2) {
    _fields.resize(_capacity);
  }
  registerSerializableOfConstSize(iBlock, sizeBlock, currentBlock, dataPtr, _fields, loadingMode);
 
  return dataPtr;
}

◆ getField()

template<typename T , typename DESCRIPTOR , typename... FIELDS>

template<typename FIELD >

auto olb::CellIndexListD< T, DESCRIPTOR, FIELDS >::getField ( std::size_t index ) const

inline

Return copy of FIELD data at index.

Definition at line 94 of file cellIndexListD.h.

  {
    return _fields.template getField<FIELD>(index);
  }

◆ getFieldArray()

template<typename T , typename DESCRIPTOR , typename... FIELDS>

template<typename FIELD >

const auto & olb::CellIndexListD< T, DESCRIPTOR, FIELDS >::getFieldArray ( ) const

inline

Definition at line 106 of file cellIndexListD.h.

  {
    return _fields.template get<FIELD>();
  }

◆ getFieldPointer()

template<typename T , typename DESCRIPTOR , typename... FIELDS>

template<typename FIELD >

auto olb::CellIndexListD< T, DESCRIPTOR, FIELDS >::getFieldPointer ( std::size_t index )

inline

Return pointer to FIELD at index.

Definition at line 87 of file cellIndexListD.h.

  {
    return _fields.template get<FIELD>().getRowPointer(index);
  }

◆ getNblock()

template<typename T , typename DESCRIPTOR , typename... FIELDS>

std::size_t olb::CellIndexListD< T, DESCRIPTOR, FIELDS >::getNblock ( ) const

overridevirtual

Returns the number of blocks.

All Serializable classes have to implement this method.

Implements olb::Serializable.

Definition at line 155 of file cellIndexListD.h.

{
  return 2
         + _fields.getNblock();
}

◆ getSerializableSize()

template<typename T , typename DESCRIPTOR , typename... FIELDS>

std::size_t olb::CellIndexListD< T, DESCRIPTOR, FIELDS >::getSerializableSize ( ) const

overridevirtual

Returns the binary size of the data to be saved.

This method must be overloaded by all child classes.

Implements olb::Serializable.

Definition at line 162 of file cellIndexListD.h.

{
  return 2 * sizeof(std::size_t)
         + _fields.getSerializableSize();
}

◆ setField()

template<typename T , typename DESCRIPTOR , typename... FIELDS>

template<typename FIELD >

void olb::CellIndexListD< T, DESCRIPTOR, FIELDS >::setField	(	std::size_t	index,
		const FieldD< T, DESCRIPTOR, FIELD > &	v )

inline

Set FIELD data at index.

Definition at line 100 of file cellIndexListD.h.

  {
    return _fields.template setField<FIELD>(index, v);
  }

◆ size()

template<typename T , typename DESCRIPTOR , typename... FIELDS>

std::size_t olb::CellIndexListD< T, DESCRIPTOR, FIELDS >::size ( ) const

inline

Definition at line 71 of file cellIndexListD.h.

                         {
    return _count;
  };

◆ sort()

template<typename T , typename DESCRIPTOR , typename... FIELDS>

void olb::CellIndexListD< T, DESCRIPTOR, FIELDS >::sort ( )

Ascending sort of cell indices.

Attached data is moved accordingly. Only useful for when processing chunks of sequential cell indices.

Definition at line 129 of file cellIndexListD.h.

{
  auto& cell_id = _fields.template get<descriptors::CELL_ID>()[0];
  std::vector<std::size_t> permutation(_count);
  std::iota(permutation.begin(), permutation.end(), 0);
  std::sort(permutation.begin(), permutation.end(), [&cell_id](auto i, auto j) {
    return cell_id[i] < cell_id[j];
  });
  std::vector<bool> swapped(_count, false);
  for (std::size_t i=0; i < _count; ++i) {
    if (swapped[i]) {
      continue;
    }
    swapped[i] = true;
    std::size_t prev_j = i;
    std::size_t next_j = permutation[i];
    while (prev_j != next_j && !swapped[next_j]) {
      _fields.swap(prev_j, next_j);
      swapped[next_j] = true;
      prev_j = next_j;
      next_j = permutation[next_j];
    }
  }
}

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

src/core/cellIndexListD.h

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ CellIndexListD() [1/2]

◆ CellIndexListD() [2/2]

Member Function Documentation

◆ append()

◆ getBlock()

◆ getField()

◆ getFieldArray()

◆ getFieldPointer()

◆ getNblock()

◆ getSerializableSize()

◆ setField()

◆ size()

◆ sort()