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

Inheritance diagram for Functions::FEFieldFunction< dim, DoFHandlerType, VectorType >:

Public Member Functions
	FEFieldFunction (const DoFHandlerType &dh, const VectorType &data_vector, const Mapping< dim > &mapping=StaticMappingQ1< dim >::mapping)

void	set_active_cell (const typename DoFHandlerType::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 DoFHandlerType::active_cell_iterator > &cells, std::vector< std::vector< Point< dim >>> &qpoints, std::vector< std::vector< unsigned int >> &maps) const

Public Member Functions inherited from Function< dim, VectorType::value_type >
	Function (const unsigned int n_components=1, const time_type initial_time=0.0)

virtual	~Function () override=0

Function &	operator= (const Function &f)

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

std::size_t	memory_consumption () const

Public Member Functions inherited from FunctionTime< Number >
	FunctionTime (const Number initial_time=Number(0.0))

virtual	~FunctionTime ()=default

Number	get_time () const

virtual void	set_time (const Number new_time)

virtual void	advance_time (const Number delta_t)

Public Member Functions inherited from Subscriptor
	Subscriptor ()

	Subscriptor (const Subscriptor &)

	Subscriptor (Subscriptor &&) noexcept

virtual	~Subscriptor ()

Subscriptor &	operator= (const Subscriptor &)

Subscriptor &	operator= (Subscriptor &&) noexcept

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

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

Private Types
using	cell_hint_t = Threads::ThreadLocalStorage< typename DoFHandlerType::active_cell_iterator >

Private Member Functions
boost::optional< Point< dim > >	get_reference_coordinates (const typename DoFHandlerType::active_cell_iterator &cell, const Point< dim > &point) const

Private Attributes
SmartPointer< const DoFHandlerType, FEFieldFunction< dim, DoFHandlerType, VectorType > >	dh

const VectorType &	data_vector

const Mapping< dim > &	mapping

GridTools::Cache< dim, DoFHandlerType::space_dimension >	cache

cell_hint_t	cell_hint

Additional Inherited Members
Public Types inherited from Function< dim, VectorType::value_type >
using	time_type = typename FunctionTime< typename numbers::NumberTraits< VectorType::value_type >::real_type >::time_type

Public Types inherited from FunctionTime< Number >
using	time_type = Number

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

static ::ExceptionBase &	ExcNoSubscriber (std::string arg1, std::string arg2)

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

Static Public Attributes inherited from Function< dim, VectorType::value_type >
static const unsigned int	dimension

Detailed Description

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

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_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
Triangulation<dim> tria_1;
Triangulation<dim> tria_2;
// 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;
// Do the same with the second
DoFHandler<dim> dh2 (tria_2);
Vector<double> solution_2;
// Setup the system, assemble matrices, solve problems and get the
// nobel prize on the first domain...
// Now project it to the second domain
FEFieldFunction<dim> fe_function_1 (dh_1, solution_1);
VectorTools::project (dh_2, constraints_2, quad,
                      fe_function_1, solution_2);
// Or interpolate 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):

Functions::FEFieldFunction<dim,DoFHandler<dim>,TrilinosWrappers::MPI::Vector>
  solution_function (dof_handler, solution);
Point<dim> origin = Point<dim>();
double solution_at_origin;
bool   point_found = true;
try
  {
    solution_at_origin = solution_function.value (origin);
  }
catch (const VectorTools::ExcPointNotAvailableHere &)
  {
    point_found = false;
  }
if (point_found == true)
  ...do something...;

Author: Luca Heltai, 2006, Markus Buerg, 2012, Wolfgang Bangerth, 2013

Definition at line 162 of file fe_field_function.h.

Member Typedef Documentation

◆ cell_hint_t

template<int dim, typename DoFHandlerType = DoFHandler<dim>, typename VectorType = Vector<double>>

using Functions::FEFieldFunction< dim, DoFHandlerType, VectorType >::cell_hint_t = Threads::ThreadLocalStorage< typename DoFHandlerType::active_cell_iterator>

private

Typedef holding the local cell_hint.

Definition at line 444 of file fe_field_function.h.

Constructor & Destructor Documentation

◆ FEFieldFunction()

template<int dim, typename DoFHandlerType = DoFHandler<dim>, typename VectorType = Vector<double>>

Functions::FEFieldFunction< dim, DoFHandlerType, VectorType >::FEFieldFunction	(	const DoFHandlerType &	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 DoFHandlerType = DoFHandler<dim>, typename VectorType = Vector<double>>

void Functions::FEFieldFunction< dim, DoFHandlerType, VectorType >::set_active_cell ( const typename DoFHandlerType::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 DoFHandlerType = DoFHandler<dim>, typename VectorType = Vector<double>>

virtual void Functions::FEFieldFunction< dim, DoFHandlerType, VectorType >::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 DoFHandlerType = DoFHandler<dim>, typename VectorType = Vector<double>>

virtual VectorType::value_type Functions::FEFieldFunction< dim, DoFHandlerType, VectorType >::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 DoFHandlerType = DoFHandler<dim>, typename VectorType = Vector<double>>

virtual void Functions::FEFieldFunction< dim, DoFHandlerType, VectorType >::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 DoFHandlerType = DoFHandler<dim>, typename VectorType = Vector<double>>

virtual void Functions::FEFieldFunction< dim, DoFHandlerType, VectorType >::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 DoFHandlerType = DoFHandler<dim>, typename VectorType = Vector<double>>

virtual void Functions::FEFieldFunction< dim, DoFHandlerType, VectorType >::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 DoFHandlerType = DoFHandler<dim>, typename VectorType = Vector<double>>

virtual Tensor<1, dim, typename VectorType::value_type> Functions::FEFieldFunction< dim, DoFHandlerType, VectorType >::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 DoFHandlerType = DoFHandler<dim>, typename VectorType = Vector<double>>

virtual void Functions::FEFieldFunction< dim, DoFHandlerType, VectorType >::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 DoFHandlerType = DoFHandler<dim>, typename VectorType = Vector<double>>

virtual void Functions::FEFieldFunction< dim, DoFHandlerType, VectorType >::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 DoFHandlerType = DoFHandler<dim>, typename VectorType = Vector<double>>

virtual VectorType::value_type Functions::FEFieldFunction< dim, DoFHandlerType, VectorType >::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 DoFHandlerType = DoFHandler<dim>, typename VectorType = Vector<double>>

virtual void Functions::FEFieldFunction< dim, DoFHandlerType, VectorType >::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 DoFHandlerType = DoFHandler<dim>, typename VectorType = Vector<double>>

virtual void Functions::FEFieldFunction< dim, DoFHandlerType, VectorType >::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 DoFHandlerType = DoFHandler<dim>, typename VectorType = Vector<double>>

virtual void Functions::FEFieldFunction< dim, DoFHandlerType, VectorType >::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 DoFHandlerType = DoFHandler<dim>, typename VectorType = Vector<double>>

unsigned int Functions::FEFieldFunction< dim, DoFHandlerType, VectorType >::compute_point_locations	(	const std::vector< Point< dim >> &	points,
		std::vector< typename DoFHandlerType::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 DoFHandlerType = DoFHandler<dim>, typename VectorType = Vector<double>>

boost::optional<Point<dim> > Functions::FEFieldFunction< dim, DoFHandlerType, VectorType >::get_reference_coordinates	(	const typename DoFHandlerType::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 boost::optional object.

Member Data Documentation

◆ dh

template<int dim, typename DoFHandlerType = DoFHandler<dim>, typename VectorType = Vector<double>>

SmartPointer<const DoFHandlerType, FEFieldFunction<dim, DoFHandlerType, VectorType> > Functions::FEFieldFunction< dim, DoFHandlerType, VectorType >::dh

private

Pointer to the dof handler.

Definition at line 451 of file fe_field_function.h.

◆ data_vector

template<int dim, typename DoFHandlerType = DoFHandler<dim>, typename VectorType = Vector<double>>

const VectorType& Functions::FEFieldFunction< dim, DoFHandlerType, VectorType >::data_vector

private

A reference to the actual data vector.

Definition at line 456 of file fe_field_function.h.

◆ mapping

template<int dim, typename DoFHandlerType = DoFHandler<dim>, typename VectorType = Vector<double>>

const Mapping<dim>& Functions::FEFieldFunction< dim, DoFHandlerType, VectorType >::mapping

private

A reference to the mapping being used.

Definition at line 461 of file fe_field_function.h.

◆ cache

template<int dim, typename DoFHandlerType = DoFHandler<dim>, typename VectorType = Vector<double>>

GridTools::Cache<dim, DoFHandlerType::space_dimension> Functions::FEFieldFunction< dim, DoFHandlerType, VectorType >::cache

private

The Cache object

Definition at line 466 of file fe_field_function.h.

◆ cell_hint

template<int dim, typename DoFHandlerType = DoFHandler<dim>, typename VectorType = Vector<double>>

cell_hint_t Functions::FEFieldFunction< dim, DoFHandlerType, VectorType >::cell_hint

mutableprivate

The latest cell hint.

Definition at line 471 of file fe_field_function.h.

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

deal.II/numerics/fe_field_function.h

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

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

Using FEFieldFunction with parallel::distributed::Triangulation

Member Typedef Documentation

◆ cell_hint_t

Constructor & Destructor Documentation

◆ FEFieldFunction()

Member Function Documentation

◆ set_active_cell()

◆ vector_value()

◆ value()

◆ value_list()

◆ vector_value_list()

◆ vector_gradient()

◆ gradient()

◆ vector_gradient_list()

◆ gradient_list()

◆ laplacian()

◆ vector_laplacian()

◆ laplacian_list()

◆ vector_laplacian_list()

◆ compute_point_locations()

◆ get_reference_coordinates()

Member Data Documentation

◆ dh

◆ data_vector

◆ mapping

◆ cache

◆ cell_hint

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