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

Inheritance diagram for TensorFunction< rank, dim, Number >:

Public Types
using	value_type = Tensor< rank, dim, Number >

using	gradient_type = Tensor< rank+1, dim, Number >

using	time_type = typename FunctionTime< typename numbers::NumberTraits< Number >::real_type >::time_type

Public Member Functions
	TensorFunction (const time_type initial_time=time_type(0.0))

virtual	~TensorFunction () override=default

virtual value_type	value (const Point< dim > &p) const

virtual void	value_list (const std::vector< Point< dim > > &points, std::vector< value_type > &values) const

virtual gradient_type	gradient (const Point< dim > &p) const

virtual void	gradient_list (const std::vector< Point< dim > > &points, std::vector< gradient_type > &gradients) const

Number	get_time () const

virtual void	set_time (const Number new_time)

virtual void	advance_time (const Number delta_t)

Private Attributes
Number	time

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

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

std::atomic< unsigned int >	counter

std::map< std::string, unsigned int >	counter_map

std::vector< std::atomic< bool > * >	validity_pointers

const std::type_info *	object_info

using	map_value_type = decltype(counter_map)::value_type

using	map_iterator = decltype(counter_map)::iterator

static std::mutex	mutex

static ::ExceptionBase &	ExcInUse (int arg1, std::string arg2, std::string arg3)

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

void	check_no_subscribers () const noexcept

Detailed Description

template<int rank, int dim, typename Number = double>
class TensorFunction< rank, dim, Number >

This class is a model for a tensor valued function. The interface of the class is mostly the same as that for the Function class, with the exception that it does not support vector-valued functions with several components, but that the return type is always tensor-valued. The returned values of the evaluation of objects of this type are always whole tensors, while for the Function class, one can ask for a specific component only, or use the vector_value function, which however does not return the value, but rather writes it into the address provided by its second argument. The reason for the different behavior of the classes is that in the case of tensor valued functions, the size of the argument is known to the compiler a priori, such that the correct amount of memory can be allocated on the stack for the return value; on the other hand, for the vector valued functions, the size is not known to the compiler, so memory has to be allocated on the heap, resulting in relatively expensive copy operations. One can therefore consider this class a specialization of the Function class for which the size is known. An additional benefit is that tensors of arbitrary rank can be returned, not only vectors, as for them the size can be determined similarly simply.

Definition at line 56 of file tensor_function.h.