ASPECT
Public Member Functions | Private Attributes | List of all members
aspect::VectorFunctionFromTensorFunctionObject< dim, RangeNumberType > Class Template Reference

Inherits Function< dim, RangeNumberType >.

Public Member Functions

 VectorFunctionFromTensorFunctionObject (const std::function< Tensor< 1, dim, RangeNumberType >(const Point< dim > &)> &tensor_function_object, const unsigned int selected_component=0, const unsigned int n_components=dim)
 
virtual ~VectorFunctionFromTensorFunctionObject () override=default
 
virtual RangeNumberType value (const Point< dim > &p, const unsigned int component=0) const override
 
virtual void vector_value (const Point< dim > &p, Vector< RangeNumberType > &values) const override
 
virtual void vector_value_list (const std::vector< Point< dim >> &points, std::vector< Vector< RangeNumberType >> &value_list) const override
 

Private Attributes

const std::function< Tensor< 1, dim, RangeNumberType >const Point< dim > &)> tensor_function_object
 
const unsigned int selected_component
 

Detailed Description

template<int dim, typename RangeNumberType = double>
class aspect::VectorFunctionFromTensorFunctionObject< dim, RangeNumberType >

This class is built as a means of translating the Tensor<1,dim, RangeNumberType> values produced by function objects that for a given point return a tensor, and returning them as a multiple component version of the same thing as a Vector for use in, for example, the VectorTools::interpolate or the many other functions taking Function objects. It allows the user to place the desired components into an n_components long vector starting at the selected_component location in that vector and have all other components be 0.

For example: Say you created a function object that returns the gravity (here, a radially inward pointing vector of magnitude 9.81):

const auto gravity
= [](const Point<dim> &p) -> Tensor<1,dim> { return -9.81 * (p /
p.norm()); }

and you want to interpolate this onto your mesh using the VectorTools::interpolate function, with a finite element for the DoFHandler object has 3 copies of a finite element with dim components, for a total of 3*dim components. To interpolate onto that DoFHandler, you need an object of type Function that has 3*dim vector components. Creating such an object from the existing gravity object is done using this piece of code:

VectorFunctionFromTensorFunctionObject<dim, RangeNumberType>
gravity_vector_function(gravity, 0, 3*dim);

where the dim components of the gravity function are placed into the first dim components of the function object.

Definition at line 265 of file compat.h.

Constructor & Destructor Documentation

§ VectorFunctionFromTensorFunctionObject()

template<int dim, typename RangeNumberType>
aspect::VectorFunctionFromTensorFunctionObject< dim, RangeNumberType >::VectorFunctionFromTensorFunctionObject ( const std::function< Tensor< 1, dim, RangeNumberType >(const Point< dim > &)> &  tensor_function_object,
const unsigned int  selected_component = 0,
const unsigned int  n_components = dim 
)
explicit

Given a function object that takes a Point and returns a Tensor<1,dim, RangeNumberType> value, convert this into an object that matches the Function<dim> interface.

By default, create a Vector object of the same size as tensor_function returns, i.e., with dim components.

Parameters
tensor_function_objectThe TensorFunction that will form dim components of the resulting Vector Function object.
n_componentsThe total number of vector components of the resulting TensorFunction object. This clearly has to be at least dim.
selected_componentThe first component that should be filled by the first argument. This should be such that the entire tensor_function fits inside the n_component length return vector.

Definition at line 344 of file compat.h.

§ ~VectorFunctionFromTensorFunctionObject()

template<int dim, typename RangeNumberType = double>
virtual aspect::VectorFunctionFromTensorFunctionObject< dim, RangeNumberType >::~VectorFunctionFromTensorFunctionObject ( )
overridevirtualdefault

This destructor is defined as virtual so as to coincide with all other aspects of class.

Member Function Documentation

§ value()

template<int dim, typename RangeNumberType >
RangeNumberType aspect::VectorFunctionFromTensorFunctionObject< dim, RangeNumberType >::value ( const Point< dim > &  p,
const unsigned int  component = 0 
) const
inlineoverridevirtual

Return a single component of a vector-valued function at a given point.

Definition at line 362 of file compat.h.

§ vector_value()

template<int dim, typename RangeNumberType>
void aspect::VectorFunctionFromTensorFunctionObject< dim, RangeNumberType >::vector_value ( const Point< dim > &  p,
Vector< RangeNumberType > &  values 
) const
inlineoverridevirtual

Return all components of a vector-valued function at a given point.

values shall have the right size beforehand, i.e. #n_components.

Definition at line 387 of file compat.h.

§ vector_value_list()

template<int dim, typename RangeNumberType>
void aspect::VectorFunctionFromTensorFunctionObject< dim, RangeNumberType >::vector_value_list ( const std::vector< Point< dim >> &  points,
std::vector< Vector< RangeNumberType >> &  value_list 
) const
overridevirtual

Return all components of a vector-valued function at a list of points.

value_list shall be the same size as points and each element of the vector will be passed to vector_value() to evaluate the function

Member function vector_value_list is the interface for giving a list of points (vector<Point<dim>>) of which to evaluate using the vector_value member function. Again, this function is written so as to not replicate the function definition but passes each point on to vector_value to be evaluated.

Definition at line 420 of file compat.h.

Member Data Documentation

§ tensor_function_object

template<int dim, typename RangeNumberType = double>
const std::function<Tensor<1, dim, RangeNumberType>const Point<dim> &)> aspect::VectorFunctionFromTensorFunctionObject< dim, RangeNumberType >::tensor_function_object
private

The TensorFunction object which we call when this class's vector_value() or vector_value_list() functions are called.

Definition at line 330 of file compat.h.

§ selected_component

template<int dim, typename RangeNumberType = double>
const unsigned int aspect::VectorFunctionFromTensorFunctionObject< dim, RangeNumberType >::selected_component
private

The first vector component whose value is to be filled by the given TensorFunction. The values will be placed in components selected_component to selected_component+dim-1 for a TensorFunction<1,dim, RangeNumberType> object.

Definition at line 338 of file compat.h.


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