Reference documentation for deal.II version GIT relicensing837gaf73e64026 20240615 22:40:02+00:00

#include <deal.II/base/data_out_base.h>
Public Member Functions  
Patch ()  
bool  operator== (const Patch &patch) const 
std::size_t  memory_consumption () const 
void  swap (Patch< 0, spacedim > &other_patch) noexcept 
Static Public Member Functions  
static ::ExceptionBase &  ExcInvalidCombinationOfDimensions (int arg1, int arg2) 
Public Attributes  
Point< spacedim >  vertices [1] 
unsigned int  patch_index 
Table< 2, float >  data 
bool  points_are_available 
Static Public Attributes  
static const unsigned int  space_dim = spacedim 
static unsigned int  neighbors [1] 
static const unsigned int  n_subdivisions = 1 
static const ReferenceCell  reference_cell 
static const unsigned int  no_neighbor = numbers::invalid_unsigned_int 
A specialization of the general Patch<dim,spacedim> template that is tailored to the case of points, i.e., zerodimensional objects embedded in spacedim
dimensional space.
The current class is compatible with the general template to allow for using the same functions accessing patches of arbitrary dimensionality in a generic way. However, it makes some variables that are nonsensical for zerodimensional patches into static
variables that exist only once in the entire program, as opposed to once per patch. Specifically, this is the case for the neighbors
array and the n_subdivisions
member variable that make no sense for zerodimensional patches because points have no natural neighbors across their nonexistent faces, nor can they reasonably be subdivided.
Definition at line 417 of file data_out_base.h.
DataOutBase::Patch< 0, spacedim >::Patch  (  ) 
Default constructor. Sets points_are_available to false, and patch_index to no_neighbor.
Definition at line 1880 of file data_out_base.cc.
bool DataOutBase::Patch< 0, spacedim >::operator==  (  const Patch< 0, 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 1891 of file data_out_base.cc.
std::size_t DataOutBase::Patch< 0, spacedim >::memory_consumption  (  )  const 
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 1925 of file data_out_base.cc.

noexcept 
Swap the current object's contents with those of the given argument.
Definition at line 1937 of file data_out_base.cc.

static 
Make the spacedim
template parameter available.
Definition at line 422 of file data_out_base.h.
Point<spacedim> DataOutBase::Patch< 0, spacedim >::vertices[1] 
Corner points of a patch. For the current class of zerodimensional patches, there is of course only a single vertex.
If points_are_available==true
, then the coordinates of the point at which output is to be generated is attached as an additional row to the data
table.
Definition at line 432 of file data_out_base.h.

static 
An unused, static
variable that exists only to allow access from general code in a generic fashion.
Definition at line 438 of file data_out_base.h.
unsigned int DataOutBase::Patch< 0, 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 444 of file data_out_base.h.

static 
Number of subdivisions with which this patch is to be written. 1
means no subdivision, 2
means bisection, 3
trisection, etc.
Since subdivision makes no sense for zerodimensional patches, this variable is not used but exists only to allow access from general code in a generic fashion.
Definition at line 455 of file data_out_base.h.
Table<2, float> DataOutBase::Patch< 0, spacedim >::data 
Data vectors. The format is as follows: data(i,.)
denotes the data belonging to the i
th data vector. data.n_cols()
therefore equals the number of output points; this number is of course one for the current class, given that we produce output on points. 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
; for the current class, j
can only be zero.
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 477 of file data_out_base.h.
bool DataOutBase::Patch< 0, 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 491 of file data_out_base.h.

static 
Referencecell type of the underlying cell of this patch. Since for zerodimensional objects, a patch can only refer to a vertex, this field is always equal to ReferenceCells::Vertex and can not be changed.
Definition at line 498 of file data_out_base.h.

static 
Value to be used if this patch has no neighbor on one side.
Definition at line 531 of file data_out_base.h.