* considerable data compression), @p affine for cells with affine mappings,
* and @p general for general cells without any compressed storage applied.
*/
- internal::MatrixFreeFunctions::CellType get_cell_type() const;
+ internal::MatrixFreeFunctions::GeometryType get_cell_type() const;
/**
* Return a reference to the ShapeInfo object currently in use.
* have different implications on how the Jacobian transformations are
* stored internally in MappingInfo.
*/
- internal::MatrixFreeFunctions::CellType cell_type;
+ internal::MatrixFreeFunctions::GeometryType cell_type;
/**
* Debug information to track whether dof values have been initialized
template <int dim, int n_components_, typename Number>
inline
-internal::MatrixFreeFunctions::CellType
+internal::MatrixFreeFunctions::GeometryType
FEEvaluationBase<dim,n_components_,Number>::get_cell_type () const
{
Assert (cell != numbers::invalid_unsigned_int, ExcNotInitialized());
namespace MatrixFreeFunctions
{
/**
- * An enum to identify various types of cells. The most general type is
- * what we typically compute in the FEValues context but for many
+ * An enum to identify various types of cells and faces. The most general
+ * type is what we typically compute in the FEValues context but for many
* geometries we can save significant storage.
*/
- enum CellType : unsigned char
+ enum GeometryType : unsigned char
{
/**
- * The cell is Cartesian.
+ * The cell or face is Cartesian.
*/
cartesian = 0,
/**
- * The cell may be described with an affine mapping.
+ * The cell or face can be described with an affine mapping.
*/
affine = 1,
/**
- * The current face is flat, i.e., the normal factor on a face is the
- * same on all quadrature points.
+ * The face is flat, i.e., the normal factor on a face is the same on
+ * all quadrature points. This type is not assigned for cells.
*/
flat_faces = 2,
/**
* There is no special information available for compressing the
- * representation of the cell.
+ * representation of the object under consideration.
*/
general = 3
};
/**
* Return the type of a given cell as detected during initialization.
*/
- CellType get_cell_type (const unsigned int cell_chunk_no) const;
+ GeometryType get_cell_type (const unsigned int cell_chunk_no) const;
/**
* Clear all data fields in this class.
* 3). Type 2 is only used for faces and no cells are assigned this
* value.
*/
- std::vector<CellType> cell_type;
+ std::vector<GeometryType> cell_type;
/**
* Stores whether a face (and both cells adjacent to the face) is
* the same throughout the face (face type 2), or is general (face type
* 3).
*/
- std::vector<CellType> face_type;
+ std::vector<GeometryType> face_type;
/**
* The data cache for the cells.
template <int dim, typename Number>
inline
- CellType
+ GeometryType
MappingInfo<dim,Number>::get_cell_type (const unsigned int cell_no) const
{
AssertIndexRange (cell_no, cell_type.size());
void evaluate_on_cell (const dealii::Triangulation<dim> &tria,
const std::pair<unsigned int,unsigned int> *cells,
const unsigned int my_q,
- CellType &cell_t_prev,
- CellType (&cell_t)[VectorizedArray<Number>::n_array_elements],
+ GeometryType &cell_t_prev,
+ GeometryType (&cell_t)[VectorizedArray<Number>::n_array_elements],
dealii::FEValues<dim,dim> &fe_val,
LocalData<dim,Number> &cell_data)
{
// encodes the cell types of the current cell. Since several cells
// must be considered together, this variable holds the individual
// info of the last chunk of cells
- CellType cell_t [VectorizedArray<Number>::n_array_elements];
- CellType cell_t_prev = general;
+ GeometryType cell_t [VectorizedArray<Number>::n_array_elements];
+ GeometryType cell_t_prev = general;
// fe_values object that is used to compute the mapping data. for
// the hp case there might be more than one finite element. since we
// old cell type to invalid (otherwise, we might detect
// similarity due to some cells further ahead)
if (my_q > 0)
- cell_t_prev = CellType(mapping_info.cell_type[cell]);
+ cell_t_prev = GeometryType(mapping_info.cell_type[cell]);
else if (cell > cell_range.first && active_fe_index.size() > 0 &&
active_fe_index[cell] != active_fe_index[cell-1])
cell_t_prev = general;
{
// find the most general cell type (most general type is 3
// (general cell))
- CellType most_general_type = cartesian;
+ GeometryType most_general_type = cartesian;
for (unsigned int j=0; j<VectorizedArray<Number>::n_array_elements; ++j)
if (cell_t[j] > most_general_type)
most_general_type = cell_t[j];
copy_data (const unsigned int first_cell,
const std::array<std::size_t,2> &data_shift,
const std::vector<unsigned int> &indices_compressed,
- const std::vector<CellType> &cell_type,
+ const std::vector<GeometryType> &cell_type,
MappingInfoStorage<structdim,dim,Number> &data_cells_local,
MappingInfoStorage<structdim,dim,Number> &data_cells)
{
std::size_t
memory = MemoryConsumption::memory_consumption (cell_data);
memory += MemoryConsumption::memory_consumption (face_data);
- memory += cell_type.capacity()*sizeof(CellType);
- memory += face_type.capacity()*sizeof(CellType);
+ memory += cell_type.capacity()*sizeof(GeometryType);
+ memory += face_type.capacity()*sizeof(GeometryType);
memory += sizeof (*this);
return memory;
}
{
out << " Cell types: ";
task_info.print_memory_statistics
- (out, cell_type.capacity()*sizeof(CellType));
+ (out, cell_type.capacity()*sizeof(GeometryType));
out << " Face types: ";
task_info.print_memory_statistics
- (out, face_type.capacity()*sizeof(CellType));
+ (out, face_type.capacity()*sizeof(GeometryType));
for (unsigned int j=0; j<cell_data.size(); ++j)
{
out << " Data component " << j << std::endl;
projects / dealii.git / commitdiff