Reference documentation for deal.II version Git bd58e18 2017-08-22 18:42:24 +0200
Public Member Functions | Private Attributes | List of all members
CellDataStorage< CellIteratorType, DataType > Class Template Reference

#include <deal.II/base/quadrature_point_data.h>

Inheritance diagram for CellDataStorage< CellIteratorType, DataType >:
[legend]

Public Member Functions

 CellDataStorage ()
 
 ~CellDataStorage ()
 
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
 
- Public Member Functions inherited from Subscriptor
 Subscriptor ()
 
 Subscriptor (const Subscriptor &)
 
 Subscriptor (Subscriptor &&)
 
virtual ~Subscriptor ()
 
Subscriptoroperator= (const Subscriptor &)
 
Subscriptoroperator= (Subscriptor &&)
 
void subscribe (const char *identifier=nullptr) const
 
void unsubscribe (const char *identifier=nullptr) const
 
unsigned int n_subscriptions () const
 
void list_subscribers () const
 
template<class Archive >
void serialize (Archive &ar, const unsigned int version)
 

Private Attributes

std::map< CellIteratorType, std::vector< std::shared_ptr< DataType > > > map
 

Additional Inherited Members

- Static Public Member Functions inherited from Subscriptor
static::ExceptionBase & ExcInUse (int arg1, char *arg2, std::string &arg3)
 
static::ExceptionBase & ExcNoSubscriber (char *arg1, char *arg2)
 

Detailed Description

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().

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.
Author
Denis Davydov, Jean-Paul Pelteret, 2016

Definition at line 55 of file quadrature_point_data.h.

Constructor & Destructor Documentation

template<typename CellIteratorType, typename DataType>
CellDataStorage< CellIteratorType, DataType >::CellDataStorage ( )

Default constructor.

template<typename CellIteratorType, typename DataType>
CellDataStorage< CellIteratorType, DataType >::~CellDataStorage ( )

Default destructor.

Member Function Documentation

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.
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>
bool CellDataStorage< CellIteratorType, DataType >::erase ( const CellIteratorType &  cell)

Removes data stored at the cell. Returns true if the data was removed. If no data is attached to the cell, this function will not do anything and returns false.

Note
This function will also check that there are no outstanding references to the data stored on this cell. That is to say, that the only references to the stored data are that made by this class.
template<typename CellIteratorType, typename DataType>
void CellDataStorage< CellIteratorType, DataType >::clear ( )

Clear all the data stored in this object.

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() .
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() .

Member Data Documentation

template<typename CellIteratorType, typename DataType>
std::map<CellIteratorType, std::vector<std::shared_ptr<DataType> > > CellDataStorage< CellIteratorType, DataType >::map
private

A map to store a vector of data on a cell.

Definition at line 149 of file quadrature_point_data.h.


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