Reference documentation for deal.II version Git d3aed38b93 2021-10-28 13:33:27 +0200
\(\newcommand{\dealvcentcolon}{\mathrel{\mathop{:}}}\) \(\newcommand{\dealcoloneq}{\dealvcentcolon\mathrel{\mkern-1.2mu}=}\) \(\newcommand{\jump}[1]{\left[\!\left[ #1 \right]\!\right]}\) \(\newcommand{\average}[1]{\left\{\!\left\{ #1 \right\}\!\right\}}\)
Public Types | Public Member Functions | Static Public Member Functions | Public Attributes | Static Public Attributes | Private Types | Private Member Functions | Private Attributes | List of all members
Functions::FEFieldFunction< dim, VectorType, spacedim > Class Template Reference

#include <deal.II/numerics/fe_field_function.h>

Inheritance diagram for Functions::FEFieldFunction< dim, VectorType, spacedim >:
[legend]

Public Types

using time_type = typename FunctionTime< typename numbers::NumberTraits< VectorType::value_type >::real_type >::time_type
 

Public Member Functions

 FEFieldFunction (const DoFHandler< dim, spacedim > &dh, const VectorType &data_vector, const Mapping< dim > &mapping=StaticMappingQ1< dim >::mapping)
 
void set_active_cell (const typename DoFHandler< dim, spacedim >::active_cell_iterator &newcell)
 
virtual void vector_value (const Point< dim > &p, Vector< typename VectorType::value_type > &values) const override
 
virtual VectorType::value_type value (const Point< dim > &p, const unsigned int component=0) const override
 
virtual void value_list (const std::vector< Point< dim >> &points, std::vector< typename VectorType::value_type > &values, const unsigned int component=0) const override
 
virtual void vector_value_list (const std::vector< Point< dim >> &points, std::vector< Vector< typename VectorType::value_type >> &values) const override
 
virtual void vector_gradient (const Point< dim > &p, std::vector< Tensor< 1, dim, typename VectorType::value_type >> &gradients) const override
 
virtual Tensor< 1, dim, typename VectorType::value_type > gradient (const Point< dim > &p, const unsigned int component=0) const override
 
virtual void vector_gradient_list (const std::vector< Point< dim >> &p, std::vector< std::vector< Tensor< 1, dim, typename VectorType::value_type >>> &gradients) const override
 
virtual void gradient_list (const std::vector< Point< dim >> &p, std::vector< Tensor< 1, dim, typename VectorType::value_type >> &gradients, const unsigned int component=0) const override
 
virtual VectorType::value_type laplacian (const Point< dim > &p, const unsigned int component=0) const override
 
virtual void vector_laplacian (const Point< dim > &p, Vector< typename VectorType::value_type > &values) const override
 
virtual void laplacian_list (const std::vector< Point< dim >> &points, std::vector< typename VectorType::value_type > &values, const unsigned int component=0) const override
 
virtual void vector_laplacian_list (const std::vector< Point< dim >> &points, std::vector< Vector< typename VectorType::value_type >> &values) const override
 
unsigned int compute_point_locations (const std::vector< Point< dim >> &points, std::vector< typename DoFHandler< dim, spacedim >::active_cell_iterator > &cells, std::vector< std::vector< Point< dim >>> &qpoints, std::vector< std::vector< unsigned int >> &maps) const
 
virtual void vector_values (const std::vector< Point< dim >> &points, std::vector< std::vector< VectorType::value_type >> &values) const
 
virtual void vector_gradients (const std::vector< Point< dim >> &points, std::vector< std::vector< Tensor< 1, dim, VectorType::value_type >>> &gradients) const
 
virtual SymmetricTensor< 2, dim, VectorType::value_type > hessian (const Point< dim > &p, const unsigned int component=0) const
 
virtual void vector_hessian (const Point< dim > &p, std::vector< SymmetricTensor< 2, dim, VectorType::value_type >> &values) const
 
virtual void hessian_list (const std::vector< Point< dim >> &points, std::vector< SymmetricTensor< 2, dim, VectorType::value_type >> &values, const unsigned int component=0) const
 
virtual void vector_hessian_list (const std::vector< Point< dim >> &points, std::vector< std::vector< SymmetricTensor< 2, dim, VectorType::value_type >>> &values) const
 
virtual std::size_t memory_consumption () const
 
Number get_time () const
 
virtual void set_time (const Number new_time)
 
virtual void advance_time (const Number delta_t)
 
template<class Archive >
void serialize (Archive &ar, const unsigned int version)
 
Subscriptor functionality

Classes derived from Subscriptor provide a facility to subscribe to this object. This is mostly used by the SmartPointer class.

void subscribe (std::atomic< bool > *const validity, const std::string &identifier="") const
 
void unsubscribe (std::atomic< bool > *const validity, const std::string &identifier="") const
 
unsigned int n_subscriptions () const
 
template<typename StreamType >
void list_subscribers (StreamType &stream) const
 
void list_subscribers () const
 

Static Public Member Functions

static ::ExceptionBaseExcInUse (int arg1, std::string arg2, std::string arg3)
 
static ::ExceptionBaseExcNoSubscriber (std::string arg1, std::string arg2)
 

Public Attributes

const unsigned int n_components
 

Static Public Attributes

static const unsigned int dimension
 

Private Types

using cell_hint_t = Threads::ThreadLocalStorage< typename DoFHandler< dim, spacedim >::active_cell_iterator >
 

Private Member Functions

std_cxx17::optional< Point< dim > > get_reference_coordinates (const typename DoFHandler< dim, spacedim >::active_cell_iterator &cell, const Point< dim > &point) const
 

Private Attributes

SmartPointer< const DoFHandler< dim, spacedim >, FEFieldFunction< dim, VectorType, spacedim > > dh
 
const VectorTypedata_vector
 
const Mapping< dim > & mapping
 
GridTools::Cache< dim, spacedim > cache
 
cell_hint_t cell_hint
 

Detailed Description

template<int dim, typename VectorType = Vector<double>, int spacedim = dim>
class Functions::FEFieldFunction< dim, VectorType, spacedim >

This is an interpolation function for the given dof handler and the given solution vector. The points at which this function can be evaluated MUST be inside the domain of the dof handler, but except from this, no other requirement is given. This function is rather slow, as it needs to construct a quadrature object for the point (or set of points) where you want to evaluate your finite element function. In order to do so, it needs to find out where the points lie.

If you know in advance in which cell your points lie, you can accelerate things a bit, by calling set_active_cell() before asking for values or gradients of the function. If you don't do this, and your points don't lie in the cell that is currently stored, the function GridTools::find_active_cell_around_point is called to find out where the point is. You can specify an optional mapping to use when looking for points in the grid. If you don't do so, this function uses a Q1 mapping.

Once the FEFieldFunction knows where the points lie, it creates a quadrature formula for those points, and calls FEValues::get_function_values or FEValues::get_function_gradients with the given quadrature points.

If you only need the quadrature points but not the values of the finite element function (you might want this for the adjoint interpolation), you can also use the function compute_point_locations() alone.

An example of how to use this function is the following:

// Generate two triangulations
// Read the triangulations from files, or build them up, or get them
// from some place. Assume that tria_2 is *entirely* included in tria_1.
// Associate a dof handler and a solution to the first triangulation
DoFHandler<dim> dh1 (tria_1);
Vector<double> solution_1;
// On this first domain, set up the various data structures,
// assemble matrices, solve the linear system, and get a Nobel
// prize for the work we have done here:
[...]
// Then create a DoFHandler and solution vector for the second domain:
DoFHandler<dim> dh2 (tria_2);
Vector<double> solution_2;
// Finally, project the solution on the first domain onto the
// second domain, assuming that this does not require querying
// values from outside the first domain:
Functions::FEFieldFunction<dim> fe_function_1 (dh_1, solution_1);
VectorTools::project (dh_2, constraints_2, quad,
fe_function_1, solution_2);
// Alternatively, we could have also interpolated it:
Vector<double> solution_3;
VectorTools::interpolate (dh_2, fe_function_1, solution_3);

The snippet of code above will work assuming that the second triangulation is entirely included in the first one.

FEFieldFunction is designed to be an easy way to get the results of your computations across different, possibly non matching, grids. No knowledge of the location of the points is assumed in this class, which makes it rely entirely on the GridTools::find_active_cell_around_point utility for its job. However the class can be fed an "educated guess" of where the points that will be computed actually are by using the FEFieldFunction::set_active_cell method, so if you have a smart way to tell where your points are, you will save a lot of computational time by letting this class know.

Using FEFieldFunction with parallel::distributed::Triangulation

When using this class with a parallel distributed triangulation object and evaluating the solution at a particular point, not every processor will own the cell at which the solution is evaluated. Rather, it may be that the cell in which this point is found is in fact a ghost or artificial cell (see GlossArtificialCell and GlossGhostCell). The solution can be evaluated on ghost cells, but for artificial cells we have no access to the solution there and functions that evaluate the solution at such a point will trigger an exception of type VectorTools::ExcPointNotAvailableHere.

To deal with this situation, you will want to use code as follows when, for example, evaluating the solution at the origin (here using a parallel TrilinosWrappers vector to hold the solution):

solution_function (dof_handler, solution);
double solution_at_origin;
bool point_found = true;
try
{
solution_at_origin = solution_function.value (origin);
}
{
point_found = false;
}
if (point_found == true)
...do something...;

Definition at line 167 of file fe_field_function.h.

Member Typedef Documentation

◆ cell_hint_t

template<int dim, typename VectorType = Vector<double>, int spacedim = dim>
using Functions::FEFieldFunction< dim, VectorType, spacedim >::cell_hint_t = Threads::ThreadLocalStorage< typename DoFHandler<dim, spacedim>::active_cell_iterator>
private

Typedef holding the local cell_hint.

Definition at line 450 of file fe_field_function.h.

◆ time_type

using Function< dim, VectorType::value_type >::time_type = typename FunctionTime< typename numbers::NumberTraits<VectorType::value_type >::real_type>::time_type
inherited

The scalar-valued real type used for representing time.

Definition at line 170 of file function.h.

Constructor & Destructor Documentation

◆ FEFieldFunction()

template<int dim, typename VectorType = Vector<double>, int spacedim = dim>
Functions::FEFieldFunction< dim, VectorType, spacedim >::FEFieldFunction ( const DoFHandler< dim, spacedim > &  dh,
const VectorType data_vector,
const Mapping< dim > &  mapping = StaticMappingQ1< dim >::mapping 
)

Construct a vector function. A smart pointers is stored to the dof handler, so you have to make sure that it make sense for the entire lifetime of this object. The number of components of this functions is equal to the number of components of the finite element object. If a mapping is specified, that is what is used to find out where the points lay. Otherwise the standard Q1 mapping is used.

Member Function Documentation

◆ set_active_cell()

template<int dim, typename VectorType = Vector<double>, int spacedim = dim>
void Functions::FEFieldFunction< dim, VectorType, spacedim >::set_active_cell ( const typename DoFHandler< dim, spacedim >::active_cell_iterator &  newcell)

Set the current cell. If you know in advance where your points lie, you can tell this object by calling this function. This will speed things up a little.

◆ vector_value()

template<int dim, typename VectorType = Vector<double>, int spacedim = dim>
virtual void Functions::FEFieldFunction< dim, VectorType, spacedim >::vector_value ( const Point< dim > &  p,
Vector< typename VectorType::value_type > &  values 
) const
overridevirtual

Get one vector value at the given point. It is inefficient to use single points. If you need more than one at a time, use the vector_value_list() function. For efficiency reasons, it is better if all the points lie on the same cell. This is not mandatory, however it does speed things up.

Note
When using this function on a parallel::distributed::Triangulation you may get an exception when trying to evaluate the solution at a point that lies on an artificial cell (see GlossLocallyOwnedCell). See the section in the general documentation of this class for more information.

Reimplemented from Function< dim, VectorType::value_type >.

◆ value()

template<int dim, typename VectorType = Vector<double>, int spacedim = dim>
virtual VectorType::value_type Functions::FEFieldFunction< dim, VectorType, spacedim >::value ( const Point< dim > &  p,
const unsigned int  component = 0 
) const
overridevirtual

Return the value of the function at the given point. Unless there is only one component (i.e. the function is scalar), you should state the component you want to have evaluated; it defaults to zero, i.e. the first component. It is inefficient to use single points. If you need more than one at a time, use the vector_value_list() function. For efficiency reasons, it is better if all the points lie on the same cell. This is not mandatory, however it does speed things up.

Note
When using this function on a parallel::distributed::Triangulation you may get an exception when trying to evaluate the solution at a point that lies on an artificial cell (see GlossLocallyOwnedCell). See the section in the general documentation of this class for more information.

Reimplemented from Function< dim, VectorType::value_type >.

◆ value_list()

template<int dim, typename VectorType = Vector<double>, int spacedim = dim>
virtual void Functions::FEFieldFunction< dim, VectorType, spacedim >::value_list ( const std::vector< Point< dim >> &  points,
std::vector< typename VectorType::value_type > &  values,
const unsigned int  component = 0 
) const
overridevirtual

Set values to the point values of the specified component of the function at the points. It is assumed that values already has the right size, i.e. the same size as the points array. This is rather efficient if all the points lie on the same cell. If this is not the case, things may slow down a bit.

Note
When using this function on a parallel::distributed::Triangulation you may get an exception when trying to evaluate the solution at a point that lies on an artificial cell (see GlossLocallyOwnedCell). See the section in the general documentation of this class for more information.

Reimplemented from Function< dim, VectorType::value_type >.

◆ vector_value_list()

template<int dim, typename VectorType = Vector<double>, int spacedim = dim>
virtual void Functions::FEFieldFunction< dim, VectorType, spacedim >::vector_value_list ( const std::vector< Point< dim >> &  points,
std::vector< Vector< typename VectorType::value_type >> &  values 
) const
overridevirtual

Set values to the point values of the function at the points. It is assumed that values already has the right size, i.e. the same size as the points array. This is rather efficient if all the points lie on the same cell. If this is not the case, things may slow down a bit.

Note
When using this function on a parallel::distributed::Triangulation you may get an exception when trying to evaluate the solution at a point that lies on an artificial cell (see GlossLocallyOwnedCell). See the section in the general documentation of this class for more information.

Reimplemented from Function< dim, VectorType::value_type >.

◆ vector_gradient()

template<int dim, typename VectorType = Vector<double>, int spacedim = dim>
virtual void Functions::FEFieldFunction< dim, VectorType, spacedim >::vector_gradient ( const Point< dim > &  p,
std::vector< Tensor< 1, dim, typename VectorType::value_type >> &  gradients 
) const
overridevirtual

Return the gradient of all components of the function at the given point. It is inefficient to use single points. If you need more than one at a time, use the vector_value_list() function. For efficiency reasons, it is better if all the points lie on the same cell. This is not mandatory, however it does speed things up.

Note
When using this function on a parallel::distributed::Triangulation you may get an exception when trying to evaluate the solution at a point that lies on an artificial cell (see GlossLocallyOwnedCell). See the section in the general documentation of this class for more information.

Reimplemented from Function< dim, VectorType::value_type >.

◆ gradient()

template<int dim, typename VectorType = Vector<double>, int spacedim = dim>
virtual Tensor<1, dim, typename VectorType::value_type> Functions::FEFieldFunction< dim, VectorType, spacedim >::gradient ( const Point< dim > &  p,
const unsigned int  component = 0 
) const
overridevirtual

Return the gradient of the specified component of the function at the given point. It is inefficient to use single points. If you need more than one at a time, use the vector_value_list() function. For efficiency reasons, it is better if all the points lie on the same cell. This is not mandatory, however it does speed things up.

Note
When using this function on a parallel::distributed::Triangulation you may get an exception when trying to evaluate the solution at a point that lies on an artificial cell (see GlossLocallyOwnedCell). See the section in the general documentation of this class for more information.

Reimplemented from Function< dim, VectorType::value_type >.

◆ vector_gradient_list()

template<int dim, typename VectorType = Vector<double>, int spacedim = dim>
virtual void Functions::FEFieldFunction< dim, VectorType, spacedim >::vector_gradient_list ( const std::vector< Point< dim >> &  p,
std::vector< std::vector< Tensor< 1, dim, typename VectorType::value_type >>> &  gradients 
) const
overridevirtual

Return the gradient of all components of the function at all the given points. This is rather efficient if all the points lie on the same cell. If this is not the case, things may slow down a bit.

Note
When using this function on a parallel::distributed::Triangulation you may get an exception when trying to evaluate the solution at a point that lies on an artificial cell (see GlossLocallyOwnedCell). See the section in the general documentation of this class for more information.

Reimplemented from Function< dim, VectorType::value_type >.

◆ gradient_list()

template<int dim, typename VectorType = Vector<double>, int spacedim = dim>
virtual void Functions::FEFieldFunction< dim, VectorType, spacedim >::gradient_list ( const std::vector< Point< dim >> &  p,
std::vector< Tensor< 1, dim, typename VectorType::value_type >> &  gradients,
const unsigned int  component = 0 
) const
overridevirtual

Return the gradient of the specified component of the function at all the given points. This is rather efficient if all the points lie on the same cell. If this is not the case, things may slow down a bit.

Note
When using this function on a parallel::distributed::Triangulation you may get an exception when trying to evaluate the solution at a point that lies on an artificial cell (see GlossLocallyOwnedCell). See the section in the general documentation of this class for more information.

Reimplemented from Function< dim, VectorType::value_type >.

◆ laplacian()

template<int dim, typename VectorType = Vector<double>, int spacedim = dim>
virtual VectorType::value_type Functions::FEFieldFunction< dim, VectorType, spacedim >::laplacian ( const Point< dim > &  p,
const unsigned int  component = 0 
) const
overridevirtual

Compute the Laplacian of a given component at point p.

Note
When using this function on a parallel::distributed::Triangulation you may get an exception when trying to evaluate the solution at a point that lies on an artificial cell (see GlossLocallyOwnedCell). See the section in the general documentation of this class for more information.

Reimplemented from Function< dim, VectorType::value_type >.

◆ vector_laplacian()

template<int dim, typename VectorType = Vector<double>, int spacedim = dim>
virtual void Functions::FEFieldFunction< dim, VectorType, spacedim >::vector_laplacian ( const Point< dim > &  p,
Vector< typename VectorType::value_type > &  values 
) const
overridevirtual

Compute the Laplacian of all components at point p and store them in values.

Note
When using this function on a parallel::distributed::Triangulation you may get an exception when trying to evaluate the solution at a point that lies on an artificial cell (see GlossLocallyOwnedCell). See the section in the general documentation of this class for more information.

Reimplemented from Function< dim, VectorType::value_type >.

◆ laplacian_list()

template<int dim, typename VectorType = Vector<double>, int spacedim = dim>
virtual void Functions::FEFieldFunction< dim, VectorType, spacedim >::laplacian_list ( const std::vector< Point< dim >> &  points,
std::vector< typename VectorType::value_type > &  values,
const unsigned int  component = 0 
) const
overridevirtual

Compute the Laplacian of one component at a set of points.

Note
When using this function on a parallel::distributed::Triangulation you may get an exception when trying to evaluate the solution at a point that lies on an artificial cell (see GlossLocallyOwnedCell). See the section in the general documentation of this class for more information.

Reimplemented from Function< dim, VectorType::value_type >.

◆ vector_laplacian_list()

template<int dim, typename VectorType = Vector<double>, int spacedim = dim>
virtual void Functions::FEFieldFunction< dim, VectorType, spacedim >::vector_laplacian_list ( const std::vector< Point< dim >> &  points,
std::vector< Vector< typename VectorType::value_type >> &  values 
) const
overridevirtual

Compute the Laplacians of all components at a set of points.

Note
When using this function on a parallel::distributed::Triangulation you may get an exception when trying to evaluate the solution at a point that lies on an artificial cell (see GlossLocallyOwnedCell). See the section in the general documentation of this class for more information.

Reimplemented from Function< dim, VectorType::value_type >.

◆ compute_point_locations()

template<int dim, typename VectorType = Vector<double>, int spacedim = dim>
unsigned int Functions::FEFieldFunction< dim, VectorType, spacedim >::compute_point_locations ( const std::vector< Point< dim >> &  points,
std::vector< typename DoFHandler< dim, spacedim >::active_cell_iterator > &  cells,
std::vector< std::vector< Point< dim >>> &  qpoints,
std::vector< std::vector< unsigned int >> &  maps 
) const

Given a set of points located in the domain (or, in the case of a parallel Triangulation, in the locally owned part of the domain or on the ghost cells for the current processor), sort these points into buckets for each of the cells on which at least one of the points is located.

This function fills three output vectors: cells, qpoints and maps. The first is a list of the cells that contain the points, the second is a list of quadrature points matching each cell of the first list, and the third contains the index of the given quadrature points, i.e., points[maps[3][4]] ends up as the 5th quadrature point in the 4th cell.

Returns
This function returns the number of cells that collectively contain the set of points give as points. This also equals the lengths of the output arrays.

This function simply calls GridTools::compute_point_locations : using the original function avoids computing a new Cache at every function call.

◆ get_reference_coordinates()

template<int dim, typename VectorType = Vector<double>, int spacedim = dim>
std_cxx17::optional<Point<dim> > Functions::FEFieldFunction< dim, VectorType, spacedim >::get_reference_coordinates ( const typename DoFHandler< dim, spacedim >::active_cell_iterator &  cell,
const Point< dim > &  point 
) const
private

Given a cell, return the reference coordinates of the given point within this cell if it indeed lies within the cell. Otherwise return an uninitialized std_cxx17::optional object.

◆ vector_values()

virtual void Function< dim, VectorType::value_type >::vector_values ( const std::vector< Point< dim >> &  points,
std::vector< std::vector< VectorType::value_type >> &  values 
) const
virtualinherited

For each component of the function, fill a vector of values, one for each point.

The default implementation of this function in Function calls value_list() for each component. In order to improve performance, this can be reimplemented in derived classes to speed up performance.

◆ vector_gradients()

virtual void Function< dim, VectorType::value_type >::vector_gradients ( const std::vector< Point< dim >> &  points,
std::vector< std::vector< Tensor< 1, dim, VectorType::value_type >>> &  gradients 
) const
virtualinherited

For each component of the function, fill a vector of gradient values, one for each point.

The default implementation of this function in Function calls value_list() for each component. In order to improve performance, this can be reimplemented in derived classes to speed up performance.

◆ hessian()

virtual SymmetricTensor<2, dim, VectorType::value_type > Function< dim, VectorType::value_type >::hessian ( const Point< dim > &  p,
const unsigned int  component = 0 
) const
virtualinherited

Compute the Hessian of a given component at point p, that is the gradient of the gradient of the function.

◆ vector_hessian()

virtual void Function< dim, VectorType::value_type >::vector_hessian ( const Point< dim > &  p,
std::vector< SymmetricTensor< 2, dim, VectorType::value_type >> &  values 
) const
virtualinherited

Compute the Hessian of all components at point p and store them in values.

◆ hessian_list()

virtual void Function< dim, VectorType::value_type >::hessian_list ( const std::vector< Point< dim >> &  points,
std::vector< SymmetricTensor< 2, dim, VectorType::value_type >> &  values,
const unsigned int  component = 0 
) const
virtualinherited

Compute the Hessian of one component at a set of points.

◆ vector_hessian_list()

virtual void Function< dim, VectorType::value_type >::vector_hessian_list ( const std::vector< Point< dim >> &  points,
std::vector< std::vector< SymmetricTensor< 2, dim, VectorType::value_type >>> &  values 
) const
virtualinherited

Compute the Hessians of all components at a set of points.

◆ memory_consumption()

virtual std::size_t Function< dim, VectorType::value_type >::memory_consumption ( ) const
virtualinherited

Return an estimate for the memory consumption, in bytes, of this object.

This function is virtual and can be overloaded by derived classes.

◆ get_time()

template<typename Number = double>
Number FunctionTime< Number >::get_time ( ) const
inherited

Return the value of the time variable.

◆ set_time()

template<typename Number = double>
virtual void FunctionTime< Number >::set_time ( const Number  new_time)
virtualinherited

Set the time to new_time, overwriting the old value.

◆ advance_time()

template<typename Number = double>
virtual void FunctionTime< Number >::advance_time ( const Number  delta_t)
virtualinherited

Advance the time by the given time step delta_t.

◆ subscribe()

void Subscriptor::subscribe ( std::atomic< bool > *const  validity,
const std::string &  identifier = "" 
) const
inherited

Subscribes a user of the object by storing the pointer validity. The subscriber may be identified by text supplied as identifier.

Definition at line 136 of file subscriptor.cc.

◆ unsubscribe()

void Subscriptor::unsubscribe ( std::atomic< bool > *const  validity,
const std::string &  identifier = "" 
) const
inherited

Unsubscribes a user from the object.

Note
The identifier and the validity pointer must be the same as the one supplied to subscribe().

Definition at line 156 of file subscriptor.cc.

◆ n_subscriptions()

unsigned int Subscriptor::n_subscriptions ( ) const
inlineinherited

Return the present number of subscriptions to this object. This allows to use this class for reference counted lifetime determination where the last one to unsubscribe also deletes the object.

Definition at line 301 of file subscriptor.h.

◆ list_subscribers() [1/2]

template<typename StreamType >
void Subscriptor::list_subscribers ( StreamType &  stream) const
inlineinherited

List the subscribers to the input stream.

Definition at line 318 of file subscriptor.h.

◆ list_subscribers() [2/2]

void Subscriptor::list_subscribers ( ) const
inherited

List the subscribers to deallog.

Definition at line 204 of file subscriptor.cc.

◆ serialize()

template<class Archive >
void Subscriptor::serialize ( Archive &  ar,
const unsigned int  version 
)
inlineinherited

Read or write the data of this object to or from a stream for the purpose of serialization using the BOOST serialization library.

This function does not actually serialize any of the member variables of this class. The reason is that what this class stores is only who subscribes to this object, but who does so at the time of storing the contents of this object does not necessarily have anything to do with who subscribes to the object when it is restored. Consequently, we do not want to overwrite the subscribers at the time of restoring, and then there is no reason to write the subscribers out in the first place.

Definition at line 310 of file subscriptor.h.

Member Data Documentation

◆ dh

template<int dim, typename VectorType = Vector<double>, int spacedim = dim>
SmartPointer<const DoFHandler<dim, spacedim>, FEFieldFunction<dim, VectorType, spacedim> > Functions::FEFieldFunction< dim, VectorType, spacedim >::dh
private

Pointer to the dof handler.

Definition at line 457 of file fe_field_function.h.

◆ data_vector

template<int dim, typename VectorType = Vector<double>, int spacedim = dim>
const VectorType& Functions::FEFieldFunction< dim, VectorType, spacedim >::data_vector
private

A reference to the actual data vector.

Definition at line 462 of file fe_field_function.h.

◆ mapping

template<int dim, typename VectorType = Vector<double>, int spacedim = dim>
const Mapping<dim>& Functions::FEFieldFunction< dim, VectorType, spacedim >::mapping
private

A reference to the mapping being used.

Definition at line 467 of file fe_field_function.h.

◆ cache

template<int dim, typename VectorType = Vector<double>, int spacedim = dim>
GridTools::Cache<dim, spacedim> Functions::FEFieldFunction< dim, VectorType, spacedim >::cache
private

The Cache object

Definition at line 472 of file fe_field_function.h.

◆ cell_hint

template<int dim, typename VectorType = Vector<double>, int spacedim = dim>
cell_hint_t Functions::FEFieldFunction< dim, VectorType, spacedim >::cell_hint
mutableprivate

The latest cell hint.

Definition at line 477 of file fe_field_function.h.

◆ dimension

const unsigned int Function< dim, VectorType::value_type >::dimension
staticinherited

Export the value of the template parameter as a static member constant. Sometimes useful for some expression template programming.

Definition at line 159 of file function.h.

◆ n_components

const unsigned int Function< dim, VectorType::value_type >::n_components
inherited

Number of vector components.

Definition at line 164 of file function.h.


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