Reference documentation for deal.II version 8.4.1
FunctionParser< dim > Class Template Reference

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

Inheritance diagram for FunctionParser< dim >:
[legend]

## Public Types

typedef std::map< std::string, double > ConstMap

typedef ConstMap::iterator ConstMapIterator

## Public Member Functions

FunctionParser (const unsigned int n_components=1, const double initial_time=0.0)

~FunctionParser ()

void initialize (const std::string &vars, const std::vector< std::string > &expressions, const ConstMap &constants, const bool time_dependent=false)

void initialize (const std::string &vars, const std::string &expression, const ConstMap &constants, const bool time_dependent=false)

virtual double value (const Point< dim > &p, const unsigned int component=0) const

virtual void vector_value (const Point< dim > &p, Vector< double > &values) const

Public Member Functions inherited from Function< dim >
Function (const unsigned int n_components=1, const doubleinitial_time=0.0)

virtual ~Function ()=0

Functionoperator= (const Function &f)

virtual void value_list (const std::vector< Point< dim > > &points, std::vector< double > &values, const unsigned int component=0) const

virtual void vector_value_list (const std::vector< Point< dim > > &points, std::vector< Vector< double > > &values) const

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

virtual Tensor< 1, dim, double > gradient (const Point< dim > &p, const unsigned int component=0) const

virtual void vector_gradient (const Point< dim > &p, std::vector< Tensor< 1, dim, double > > &gradients) const

virtual void gradient_list (const std::vector< Point< dim > > &points, std::vector< Tensor< 1, dim, double > > &gradients, const unsigned int component=0) const

virtual void vector_gradients (const std::vector< Point< dim > > &points, std::vector< std::vector< Tensor< 1, dim, double > > > &gradients) const

virtual void vector_gradient_list (const std::vector< Point< dim > > &points, std::vector< std::vector< Tensor< 1, dim, double > > > &gradients) const

virtual double laplacian (const Point< dim > &p, const unsigned int component=0) const

virtual void vector_laplacian (const Point< dim > &p, Vector< double > &values) const

virtual void laplacian_list (const std::vector< Point< dim > > &points, std::vector< double > &values, const unsigned int component=0) const

virtual void vector_laplacian_list (const std::vector< Point< dim > > &points, std::vector< Vector< double > > &values) const

virtual SymmetricTensor< 2, dim, double > hessian (const Point< dim > &p, const unsigned int component=0) const

virtual void vector_hessian (const Point< dim > &p, std::vector< SymmetricTensor< 2, dim, double > > &values) const

virtual void hessian_list (const std::vector< Point< dim > > &points, std::vector< SymmetricTensor< 2, dim, double > > &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, double > > > &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 ()

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 &)

virtual ~Subscriptor ()

Subscriptoroperator= (const Subscriptor &)

void subscribe (const char *identifier=0) const

void unsubscribe (const char *identifier=0) const

unsigned int n_subscriptions () const

void list_subscribers () const

DeclException3 (ExcInUse, int, char *, std::string &,<< "Object of class "<< arg2<< " is still used by "<< arg1<< " other objects."<< "\n\n"<< "(Additional information: "<< arg3<< ")\n\n"<< "See the entry in the Frequently Asked Questions of "<< "deal.II (linked to from http://www.dealii.org/) for "<< "a lot more information on what this error means and "<< "how to fix programs in which it happens.")

DeclException2 (ExcNoSubscriber, char *, char *,<< "No subscriber with identifier <"<< arg2<< "> subscribes to this object of class "<< arg1<< ". Consequently, it cannot be unsubscribed.")

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

## Static Public Member Functions

static std::string default_variable_names ()

## Private Member Functions

void init_muparser () const

## Private Attributes

std::map< std::string, double > constants

std::vector< std::string > var_names

std::vector< std::string > expressions

bool initialized

unsigned int n_vars

Public Attributes inherited from Function< dim >
const unsigned int n_components

Static Public Attributes inherited from Function< dim >
static const unsigned int dimension

## Detailed Description

### template<int dim> class FunctionParser< dim >

This class implements a function object that gets its value by parsing a string describing this function. It is a wrapper class for the muparser library (see http://muparser.beltoforion.de/). This class lets you evaluate strings such as "sqrt(1-x^2+y^2)" for given values of 'x' and 'y'. Please refer to the muparser documentation for more information. This class is used in the step-33 and step-36 tutorial programs (the latter being much simpler to understand).

The following examples shows how to use this class:

// set up problem:
std::string variables = "x,y";
std::string expression = "cos(x)+sqrt(y)";
std::map<std::string,double> constants;
// FunctionParser with 2 variables and 1 component:
fp.initialize(variables,
expression,
constants);
// Point at which we want to evaluate the function
Point<2> point(0.0, 4.0);
// evaluate the expression at 'point':
double result = fp.value(point);
deallog << "Function '" << expression << "'"
<< " @ " << point
<< " is " << result << std::endl;

The second example is a bit more complex:

// Define some constants that will be used by the function parser
std::map<std::string,double> constants;
constants["pi"] = numbers::PI;
// Define the variables that will be used inside the expressions
std::string variables = "x,y,z";
// Define the expressions of the individual components of a
// vector valued function with two components:
std::vector<std::string> expressions(2);
expressions[0] = "sin(2*pi*x)+sinh(pi*z)";
expressions[1] = "sin(2*pi*y)*exp(x^2)";
// function parser with 3 variables and 2 components
FunctionParser<3> vector_function(2);
// And populate it with the newly created objects.
vector_function.initialize(variables,
constants);
// Point at which we want to evaluate the function
Point<3> point(0.0, 1.0, 1.0);
// This Vector will store the result
Vector<double> result(2);
// Fill 'result' by evaluating the function
vector_function.vector_value(point, result);
// We can also only evaluate the 2nd component:
const double c = vector_function.value(point, 1);
// Output the evaluated function
deallog << "Function '" << expressions[0] << "," << expressions[1] << "'"
<< " at " << point
<< " is " << result << std::endl;

This class overloads the virtual methods value() and vector_value() of the Function base class with the byte compiled versions of the expressions given to the initialize() methods. Note that the class will not work unless you first call the initialize() method that accepts the text description of the function as an argument (among other things).

The syntax to describe a function follows usual programming practice, and is explained in detail at the homepage of the underlying muparser library at http://muparser.beltoforion.de/ .

For a wrapper of the FunctionParser class that supports ParameterHandler, see ParsedFunction.

Vector-valued functions can either be declared using strings where the function components are separated by semicolons, or using a vector of strings each defining one vector component.

An example of time dependent scalar function is the following:

// Empty constants object
std::map<std::string> constants;
// Variables that will be used inside the expressions
std::string variables = "x,y,t";
// Define the expression of the scalar time dependent function.
std::string expression = "exp(y*x)*exp(-t)";
// Generate an empty scalar function
// And populate it with the newly created objects.
function.initialize(variables,
expression,
constants,
true); // This tells the parser that
// it is a time-dependent function
// and there is another variable
// to be taken into account (t).

The following is another example of how to instantiate a vector valued function by using a single string:

// Empty constants object
std::map<std::string> constants;
// Variables that will be used inside the expressions
std::string variables = "x,y";
// Define the expression of the vector valued function.
std::string expression = "cos(2*pi*x)*y^2; sin(2*pi*x)*exp(y)";
// Generate an empty vector valued function
FunctionParser<2> function(2);
// And populate it with the newly created objects.
function.initialize(variables,
expression,
constants);

Definition at line 180 of file function_parser.h.

## Member Typedef Documentation

template<int dim>
 typedef std::map FunctionParser< dim >::ConstMap

Type for the constant map. Used by the initialize() method.

Definition at line 202 of file function_parser.h.

template<int dim>
 typedef ConstMap::iterator FunctionParser< dim >::ConstMapIterator

Iterator for the constants map. Used by the initialize() method.

Definition at line 207 of file function_parser.h.

## Constructor & Destructor Documentation

template<int dim>
 DEAL_II_DISABLE_EXTRA_DIAGNOSTICS DEAL_II_ENABLE_EXTRA_DIAGNOSTICS DEAL_II_DISABLE_EXTRA_DIAGNOSTICS DEAL_II_ENABLE_EXTRA_DIAGNOSTICS FunctionParser< dim >::FunctionParser ( const unsigned int n_components = 1, const double initial_time = 0.0 )

Constructor for Parsed functions. Its arguments are the same of the base class Function. The only difference is that this object needs to be initialized with initialize() method before you can use it. If an attempt to use this function is made before the initialize() method has been called, then an exception is thrown.

Definition at line 48 of file function_parser.cc.

template<int dim>
 FunctionParser< dim >::~FunctionParser ( )

Destructor. Explicitly delete the FunctionParser objects (there is one for each component of the function).

Definition at line 57 of file function_parser.cc.

## Member Function Documentation

template<int dim>
 void FunctionParser< dim >::initialize ( const std::string & vars, const std::vector< std::string > & expressions, const ConstMap & constants, const bool time_dependent = false )

Initialize the function. This methods accepts the following parameters:

vars: a string with the variables that will be used by the expressions to be evaluated. Note that the variables can have any name (of course different from the function names defined above!), but the order IS important. The first variable will correspond to the first component of the point in which the function is evaluated, the second variable to the second component and so forth. If this function is also time dependent, then it is necessary to specify it by setting the time_dependent parameter to true. An exception is thrown if the number of variables specified here is different from dim (if this function is not time-dependent) or from dim+1 (if it is time- dependent).

expressions: a list of strings containing the expressions that will be byte compiled by the internal parser (FunctionParser). Note that the size of this vector must match exactly the number of components of the FunctionParser, as declared in the constructor. If this is not the case, an exception is thrown.

constants: a map of constants used to pass any necessary constant that we want to specify in our expressions (in the example above the number pi). An expression is valid if and only if it contains only defined variables and defined constants (other than the functions specified above). If a constant is given whose name is not valid (eg: constants["sin"] = 1.5;) an exception is thrown.

time_dependent. If this is a time dependent function, then the last variable declared in vars is assumed to be the time variable, and this->get_time() is used to initialize it when evaluating the function. Naturally the number of variables parsed by the initialize() method in this case is dim+1. The value of this parameter defaults to false, i.e. do not consider time.

Definition at line 63 of file function_parser.cc.

template<int dim>
 void FunctionParser< dim >::initialize ( const std::string & vars, const std::string & expression, const ConstMap & constants, const bool time_dependent = false )

Initialize the function. Same as above, but accepts a string rather than a vector of strings. If this is a vector valued function, its components are expected to be separated by a semicolon. An exception is thrown if this method is called and the number of components successfully parsed does not match the number of components of the base function.

Definition at line 356 of file function_parser.cc.

template<int dim>
 std::string FunctionParser< dim >::default_variable_names ( )
static

A function that returns default names for variables, to be used in the first argument of the initialize() functions: it returns "x" in 1d, "x,y" in 2d, and "x,y,z" in 3d.

Definition at line 362 of file function_parser.h.

template<int dim>
 double FunctionParser< dim >::value ( const Point< dim > & p, const unsigned int component = 0 ) const
virtual

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.

Reimplemented from Function< dim >.

Definition at line 368 of file function_parser.cc.

template<int dim>
 void FunctionParser< dim >::vector_value ( const Point< dim > & p, Vector< double > & values ) const
virtual

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

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

Reimplemented from Function< dim >.

Definition at line 403 of file function_parser.cc.

template<int dim>
 void FunctionParser< dim >::init_muparser ( ) const
private

Initialize fp and vars on the current thread. This function may only be called once per thread. A thread can test whether the function has already been called by testing whether 'fp.get().size()==0' (not initialized) or >0 (already initialized).

Definition at line 220 of file function_parser.cc.

## Member Data Documentation

template<int dim>
mutableprivate

Place for the variables for each thread

Definition at line 309 of file function_parser.h.

template<int dim>
mutableprivate

The muParser objects for each thread (and one for each component)

Definition at line 314 of file function_parser.h.

template<int dim>
 std::map FunctionParser< dim >::constants
private

An array to keep track of all the constants, required to initialize fp in each thread.

Definition at line 320 of file function_parser.h.

template<int dim>
 std::vector FunctionParser< dim >::var_names
private

An array for the variable names, required to initialize fp in each thread.

Definition at line 326 of file function_parser.h.

template<int dim>
 std::vector FunctionParser< dim >::expressions
private

An array of function expressions (one per component), required to initialize fp in each thread.

Definition at line 332 of file function_parser.h.

template<int dim>
 bool FunctionParser< dim >::initialized
private

State of usability. This variable is checked every time the function is called for evaluation. It's set to true in the initialize() methods.

Definition at line 347 of file function_parser.h.

template<int dim>
 unsigned int FunctionParser< dim >::n_vars
private

Number of variables. If this is also a function of time, then the number of variables is dim+1, otherwise it is dim. In the case that this is a time dependent function, the time is supposed to be the last variable. If n_vars is not identical to the number of the variables parsed by the initialize() method, then an exception is thrown.

Definition at line 356 of file function_parser.h.

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