/usr/include/deal.II/base/function_derivative.h is in libdeal.ii-dev 6.3.1-1.1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 | //---------------------------------------------------------------------------
// $Id: function_derivative.h 14881 2007-08-02 15:11:31Z kanschat $
// Version: $Name$
//
// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// to the file deal.II/doc/license.html for the text and
// further information on this license.
//
//---------------------------------------------------------------------------
#ifndef __deal2__function_derivative_h
#define __deal2__function_derivative_h
#include <base/config.h>
#include <base/exceptions.h>
#include <base/function.h>
#include <base/auto_derivative_function.h>
DEAL_II_NAMESPACE_OPEN
/**
* Derivative of a function object. The value access functions of
* this class return the directional derivative of a function with
* respect to a direction provided on construction. If <tt>b</tt> is the
* vector, the derivative <tt>b . grad f</tt> is computed. This derivative
* is evaluated directly, not by computing the gradient of <tt>f</tt> and
* its scalar product with <tt>b</tt>.
*
* The derivative is computed numerically, using one of the provided
* difference formulas (see <tt>set_formula</tt> for available
* schemes). Experimenting with <tt>h</tt> and the difference scheme may be
* necessary to obtain sufficient results.
*
* @ingroup functions
* @author Guido Kanschat, 2000
*/
template <int dim>
class FunctionDerivative : public AutoDerivativeFunction<dim>
{
public:
/**
* Constructor. Provided are the
* functions to compute
* derivatives of, the direction
* vector of the differentiation
* and the step size <tt>h</tt> of the
* difference formula.
*/
FunctionDerivative (const Function<dim> &f,
const Point<dim> &direction,
const double h = 1.e-6);
/**
* Constructor. Provided are the
* functions to compute
* derivatives of and the
* direction vector of the
* differentiation in each
* quadrature point and the
* difference step size.
*
* This is the constructor for a
* variable velocity field. Most
* probably, a new object of
* <tt>FunctionDerivative</tt> has to
* be constructed for each set of
* quadrature points.
*
* The number of quadrature point
* must still be the same, when
* values are accessed.
*/
FunctionDerivative (const Function<dim> &f,
const std::vector<Point<dim> > &direction,
const double h = 1.e-6);
/**
* Choose the difference formula.
* This is set to the default in
* the constructor.
*
* Formulas implemented right now
* are first order backward Euler
* (<tt>UpwindEuler</tt>), second
* order symmetric Euler
* (<tt>Euler</tt>) and a symmetric
* fourth order formula
* (<tt>FourthOrder</tt>).
*/
void set_formula (typename AutoDerivativeFunction<dim>::DifferenceFormula formula
= AutoDerivativeFunction<dim>::Euler);
/**
* Change the base step size of
* the difference formula
*/
void set_h (const double h);
virtual double value (const Point<dim>& p,
const unsigned int component = 0) const;
virtual void vector_value(const Point<dim>& p,
Vector<double>& value) const;
virtual void value_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
const unsigned int component = 0) const;
/**
* Determine an estimate for
* the memory consumption (in
* bytes) of this
* object. Since sometimes
* the size of objects can
* not be determined exactly
* (for example: what is the
* memory consumption of an
* STL <tt>std::map</tt> type with a
* certain number of
* elements?), this is only
* an estimate. however often
* quite close to the true
* value.
*/
unsigned int memory_consumption () const;
/** @addtogroup Exceptions
* @{ */
/**
* Exception.
*/
DeclException0(ExcInvalidFormula);
//@}
private:
/**
* Function for differentiation.
*/
const Function<dim>& f;
/**
* Step size of the difference
* formula.
*/
double h;
/**
* Difference formula.
*/
typename AutoDerivativeFunction<dim>::DifferenceFormula formula;
/**
* Helper object. Contains the
* increment vector for the
* formula.
*/
std::vector<Point<dim> > incr;
};
DEAL_II_NAMESPACE_CLOSE
#endif
|