Reference documentation for deal.II version GIT 92344eb39a 2023-03-23 02:40:02+00:00
DataOutBase::Patch< dim, spacedim > Struct Template Reference

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

Inheritance diagram for DataOutBase::Patch< dim, spacedim >:
[legend]

## Public Member Functions

Patch ()

bool operator== (const Patch &patch) const

std::size_t memory_consumption () const

void swap (Patch< dim, spacedim > &other_patch)

## Static Public Member Functions

static ::ExceptionBaseExcInvalidCombinationOfDimensions (int arg1, int arg2)

## Public Attributes

std::array< Point< spacedim >, GeometryInfo< dim >::vertices_per_cell > vertices

std::array< unsigned int, GeometryInfo< dim >::faces_per_cell > neighbors

unsigned int patch_index

unsigned int n_subdivisions

Table< 2, float > data

bool points_are_available

ReferenceCell reference_cell

## Static Public Attributes

static const unsigned int space_dim = spacedim

static const unsigned int no_neighbor = numbers::invalid_unsigned_int

## Detailed Description

### template<int dim, int spacedim = dim> struct DataOutBase::Patch< dim, spacedim >

Data structure describing a patch of data in dim space dimensions.

A patch consists of the following data:

• the corner vertices,
• the number n_subdivisions of the number of cells the Patch has in each space direction,
• the data attached to each vertex, in the usual lexicographic ordering,
• information on neighbors.

See the general documentation of the DataOutBase class for more information on its contents and purposes. In the case of two dimensions, the next picture is an example of n_subdivisions = 4 because the number of (sub)cells within each patch is equal to 2dim.

Definition at line 266 of file data_out_base.h.

## ◆ Patch()

template<int dim, int spacedim>
 DataOutBase::Patch< dim, spacedim >::Patch

Default constructor. Sets n_subdivisions to one, points_are_available to false, and patch_index to no_neighbor.

Definition at line 1775 of file data_out_base.cc.

## ◆ operator==()

template<int dim, int spacedim>
 bool DataOutBase::Patch< dim, spacedim >::operator== ( const Patch< dim, spacedim > & patch ) const

Compare the present patch for equality with another one. This is used in a few of the automated tests in our testsuite.

Definition at line 1794 of file data_out_base.cc.

## ◆ memory_consumption()

template<int dim, int spacedim>
 std::size_t DataOutBase::Patch< dim, spacedim >::memory_consumption

Return an estimate for the memory consumption, in bytes, of this object. This is not exact (but will usually be close) because calculating the memory usage of trees (e.g., std::map) is difficult.

Definition at line 1836 of file data_out_base.cc.

## ◆ swap()

template<int dim, int spacedim>
 void DataOutBase::Patch< dim, spacedim >::swap ( Patch< dim, spacedim > & other_patch )

Swap the current object's contents with those of the given argument.

Definition at line 1853 of file data_out_base.cc.

## ◆ space_dim

template<int dim, int spacedim>
 const unsigned int DataOutBase::Patch< dim, spacedim >::space_dim = spacedim
static

Make the spacedim template parameter available.

Definition at line 271 of file data_out_base.h.

## ◆ vertices

template<int dim, int spacedim = dim>
 std::array, GeometryInfo::vertices_per_cell> DataOutBase::Patch< dim, spacedim >::vertices

Corner points of a patch. Interior points are computed by a multilinear transformation of the unit cell to the cell specified by these corner points, if points_are_available==false.

On the other hand, if points_are_available==true, then the coordinates of the points at which output is to be generated is attached in additional rows to the data table.

The order of points is the same as for cells in the triangulation.

Note
This array is sized to accommodate the maximal number of vertices one might encounter in a cell, namely those for a hypercube cell. For other kinds of cells (triangles, tetrahedra, etc.), only the first few elements of this array will be used.

Definition at line 290 of file data_out_base.h.

## ◆ neighbors

template<int dim, int spacedim = dim>
 std::array::faces_per_cell> DataOutBase::Patch< dim, spacedim >::neighbors

Patch indices of neighbors of the current patch. This is made available for the OpenDX format that requires neighbor information for advanced output.

Note
This array is sized to accommodate the maximal number of faces one might encounter in a cell, namely those for a hypercube cell. For other kinds of cells (triangles, tetrahedra, etc.), only the first few elements of this array will be used.

Definition at line 302 of file data_out_base.h.

## ◆ patch_index

template<int dim, int spacedim = dim>
 unsigned int DataOutBase::Patch< dim, spacedim >::patch_index

Number of this patch. Since we are not sure patches are always handled in the same order, we better store this.

Definition at line 308 of file data_out_base.h.

## ◆ n_subdivisions

template<int dim, int spacedim = dim>
 unsigned int DataOutBase::Patch< dim, spacedim >::n_subdivisions

Number of subdivisions with which this patch is to be written. 1 means no subdivision, 2 means bisection, 3 trisection, etc.

Definition at line 315 of file data_out_base.h.

## ◆ data

template<int dim, int spacedim = dim>
 Table<2, float> DataOutBase::Patch< dim, spacedim >::data

Data vectors. The format is as follows: data(i,.) denotes the data belonging to the ith data vector. data.n_cols() therefore equals the number of output points; this number is (subdivisions+1)^{dim}. data.n_rows() equals the number of data vectors. For the current purpose, a data vector equals one scalar, even if multiple scalars may later be interpreted as vectors.

Within each column, data(.,j) are the data values at the output point j, where j denotes the usual lexicographic ordering in deal.II. This is also the order of points as provided by the QIterated class when used with the QTrapezoid class as subquadrature.

Since the number of data vectors is usually the same for all patches to be printed, data.size() should yield the same value for all patches provided. The exception are patches for which points_are_available are set, where the actual coordinates of the point are appended to the 'data' field, see the documentation of the points_are_available flag.

Definition at line 338 of file data_out_base.h.

## ◆ points_are_available

template<int dim, int spacedim = dim>
 bool DataOutBase::Patch< dim, spacedim >::points_are_available

A flag indicating whether the coordinates of the interior patch points (assuming that the patch is supposed to be subdivided further) are appended to the data table (true) or not (false). The latter is the default and in this case the locations of the points interior to this patch are computed by (bi-, tri-)linear interpolation from the vertices of the patch.

This option exists since patch points may be evaluated using a Mapping (rather than by a linear interpolation) and therefore have to be stored in the Patch structure.

Definition at line 352 of file data_out_base.h.

## ◆ reference_cell

template<int dim, int spacedim = dim>
 ReferenceCell DataOutBase::Patch< dim, spacedim >::reference_cell

Reference-cell type of the underlying cell of this patch.

Definition at line 357 of file data_out_base.h.

## ◆ no_neighbor

template<int dim, int spacedim>
 const unsigned int DataOutBase::Patch< dim, spacedim >::no_neighbor = numbers::invalid_unsigned_int
static

Value to be used if this patch has no neighbor on one side.

Definition at line 390 of file data_out_base.h.

The documentation for this struct was generated from the following files: