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 levelset 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 cellbycell 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 cellbycell 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 cellbycell 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 cellbycell 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.