|
| | CellDataStorage ()=default |
| |
| | ~CellDataStorage () override=default |
| |
| template<typename T = DataType> |
| void | initialize (const CellIteratorType &cell, const unsigned int number_of_data_points_per_cell) |
| |
| template<typename T = DataType> |
| void | initialize (const CellIteratorType &cell_start, const CellIteratorType &cell_end, const unsigned int number_of_data_points_per_cell) |
| |
| bool | erase (const CellIteratorType &cell) |
| |
| void | clear () |
| |
| template<typename T = DataType> |
| std::vector< std::shared_ptr< T > > | get_data (const CellIteratorType &cell) |
| |
| template<typename T = DataType> |
| std::vector< std::shared_ptr< const T > > | get_data (const CellIteratorType &cell) const |
| |
| template<typename T = DataType> |
| std_cxx17::optional< std::vector< std::shared_ptr< T > > > | try_get_data (const CellIteratorType &cell) |
| |
| template<typename T = DataType> |
| std_cxx17::optional< std::vector< std::shared_ptr< const T > > > | try_get_data (const CellIteratorType &cell) const |
| |
template<typename CellIteratorType, typename DataType>
class CellDataStorage< CellIteratorType, DataType >
A class for storing at each cell represented by iterators of type CellIteratorType a vector of data DataType . The underlying structure and the initialize() method of this class are designed in such a way that one could use different child classes derived from the base DataType class to store data on a given cell. This implies the usage of pointers, in our case – std::shared_ptr.
The type DataType is arbitrary, but when using a class derived from TransferableQuadraturePointData one can use the facilities of parallel::distributed::ContinuousQuadratureDataTransfer.
- Note
- The data type stored on each cell can be different. However, within the cell this class stores a vector of objects of a single data type. For this reason, this class may not be sufficiently flexible when, for example, adopting a level-set approach to describe material behavior.
Definition at line 62 of file quadrature_point_data.h.
template<typename CellIteratorType , typename DataType >
template<typename T = DataType>
| void CellDataStorage< CellIteratorType, DataType >::initialize |
( |
const CellIteratorType & |
cell, |
|
|
const unsigned int |
number_of_data_points_per_cell |
|
) |
| |
Initialize data on the cell to store number_of_data_points_per_cell of objects of type T . The typename T is possibly another class which is derived from the base DataType class. In order to initialize the vector of objects we have to assume that the class T has a default constructor. This function has to be called on every cell where data is to be stored.
After the data is initialized, it can be modified using the get_data() function.
- Note
- Subsequent calls of this function with the same
cell will not alter the objects associated with it. In order to remove the stored data, use the erase() function.
-
It is possible to use different types
T for different cells which may reflect, for example, different constitutive models of continuum mechanics in different parts of the domain.
-
The first time this method is called, it stores a SmartPointer to the Triangulation object that owns the cell. The future invocations of this method expects the cell to be from the same stored triangulation.
- Precondition
- The type
T needs to either equal DataType, or be a class derived from DataType. T needs to be default constructible.
template<typename CellIteratorType , typename DataType >
template<typename T = DataType>
| void CellDataStorage< CellIteratorType, DataType >::initialize |
( |
const CellIteratorType & |
cell_start, |
|
|
const CellIteratorType & |
cell_end, |
|
|
const unsigned int |
number_of_data_points_per_cell |
|
) |
| |
Same as above but for a range of iterators starting at cell_start until, but not including, cell_end for all locally owned cells, i.e. for which cell->is_locally_owned()==true .
template<typename CellIteratorType , typename DataType >
template<typename T = DataType>
| std::vector< std::shared_ptr< T > > CellDataStorage< CellIteratorType, DataType >::get_data |
( |
const CellIteratorType & |
cell | ) |
|
Get a vector of the data located at cell . A possible additional typename T is the class to which the base class DataType could be cast. Since DataType is stored as shared pointers, there is minimal overhead in returning a vector by value instead of by reference. This allows flexibility if class T is not the same as DataType on a cell-by-cell basis.
- Precondition
- The type
T needs to match the class provided to initialize() .
-
cell must be from the same Triangulation that is used to initialize() the cell data.
template<typename CellIteratorType , typename DataType >
template<typename T = DataType>
| std::vector< std::shared_ptr< const T > > CellDataStorage< CellIteratorType, DataType >::get_data |
( |
const CellIteratorType & |
cell | ) |
const |
Get a vector of constant pointers to data located at cell . A possible additional typename T is the class to which the base class DataType could be cast. Since DataType is stored as shared pointers, there is minimal overhead in returning a vector by value instead of by reference. This allows flexibility if class T is not the same as DataType on a cell-by-cell basis.
- Precondition
- The type
T needs to match the class provided to initialize() .
-
cell must be from the same Triangulation that is used to initialize() the cell data.
template<typename CellIteratorType , typename DataType >
template<typename T = DataType>
| std_cxx17::optional< std::vector< std::shared_ptr< T > > > CellDataStorage< CellIteratorType, DataType >::try_get_data |
( |
const CellIteratorType & |
cell | ) |
|
Returns a std_cxx17::optional indicating whether cell contains an associated data or not. If data is available, dereferencing the std_cxx17::optional reveals a vector of pointers to the underlying data at the quadrature points. A possible additional typename T is the class to which the base class DataType could be cast. Since DataType is stored as shared pointers, there is minimal overhead in returning a vector by value instead of by reference. This allows flexibility if class T is not the same as DataType on a cell-by-cell basis.
- Precondition
- The type
T needs to match the class provided to initialize().
-
cell must be from the same Triangulation that is used to initialize() the cell data.
template<typename CellIteratorType , typename DataType >
template<typename T = DataType>
| std_cxx17::optional< std::vector< std::shared_ptr< const T > > > CellDataStorage< CellIteratorType, DataType >::try_get_data |
( |
const CellIteratorType & |
cell | ) |
const |
Returns a std_cxx17::optional indicating whether cell contains an associated data or not. If data is available, dereferencing the std_cxx17::optional reveals a vector of constant pointers to the underlying data at the quadrature points. A possible additional typename T is the class to which the base class DataType could be cast. Since DataType is stored as shared pointers, there is minimal overhead in returning a vector by value instead of by reference. This allows flexibility if class T is not the same as DataType on a cell-by-cell basis.
- Precondition
- The type
T needs to match the class provided to initialize().
-
cell must be from the same Triangulation that is used to initialize() the cell data.
1.9.4