/usr/include/deal.II/base/function_time.h is in libdeal.ii-dev 8.5.1-3.
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 | // ---------------------------------------------------------------------
//
// Copyright (C) 1999 - 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE at
// the top level of the deal.II distribution.
//
// ---------------------------------------------------------------------
#ifndef dealii__function_time_h
#define dealii__function_time_h
#include <deal.II/base/config.h>
#include <deal.II/base/exceptions.h>
DEAL_II_NAMESPACE_OPEN
/**
* Support for time dependent functions. The library was also designed for
* time dependent problems. For this purpose, the function objects also
* contain a field which stores the time, as well as functions manipulating
* them. Time independent problems should not access or even abuse them for
* other purposes, but since one normally does not create thousands of
* function objects, the gain in generality weighs out the fact that we need
* not store the time value for not time dependent problems. The second
* advantage is that the derived standard classes like <tt>ZeroFunction</tt>,
* <tt>ConstantFunction</tt> etc also work for time dependent problems.
*
* Access to the time goes through the following functions:
* @verbatim
* <li> <tt>get_time</tt>: return the present value of the time variable.
* <li> <tt>set_time</tt>: set the time value to a specific value.
* <li> <tt>advance_time</tt>: increase the time by a certain time step.
* @endverbatim
* The latter two functions are virtual, so that derived classes can perform
* computations which need only be done once for every new time. For example,
* if a time dependent function had a factor <tt>sin(t)</tt>, then it may be a
* reasonable choice to calculate this factor in a derived version of
* set_time(), store it in a member variable and use that one rather than
* computing it every time <tt>value()</tt>, <tt>value_list</tt> or one of the
* other functions of class Function is called.
*
* By default, the advance_time() function calls the set_time() function with
* the new time, so it is sufficient in most cases to overload only set_time()
* for computations as sketched out above.
*
* The constructor of this class takes an initial value for the time variable,
* which defaults to zero. Because a default value is given, none of the
* derived classes needs to take an initial value for the time variable if not
* needed.
*
* @tparam Number The data type in which time values are to be stored. This
* will, in almost all cases, simply be the default @p double, but there are
* cases where one may want to store the time in a different (and always
* scalar) type. An example would be an interval type that can store a value
* as well as its uncertainty. Another example would be a type that allows for
* Automatic Differentiation (see, for example, the Sacado type used in
* step-33) and thereby can generate analytic (temporal) derivatives of a
* function.
*
*
* @ingroup functions
* @author Wolfgang Bangerth, Guido Kanschat, 1998, 1999
*/
template <typename Number=double>
class FunctionTime
{
public:
/**
* Constructor. May take an initial value for the time variable, which
* defaults to zero.
*/
FunctionTime (const Number initial_time = Number(0.0));
/**
* Virtual destructor.
*/
virtual ~FunctionTime();
/**
* Return the value of the time variable.
*/
Number get_time () const;
/**
* Set the time to <tt>new_time</tt>, overwriting the old value.
*/
virtual void set_time (const Number new_time);
/**
* Advance the time by the given time step <tt>delta_t</tt>.
*/
virtual void advance_time (const Number delta_t);
private:
/**
* Store the present time.
*/
Number time;
};
/*------------------------------ Inline functions ------------------------------*/
#ifndef DOXYGEN
template<typename Number>
inline Number
FunctionTime<Number>::get_time () const
{
return time;
}
#endif
DEAL_II_NAMESPACE_CLOSE
#endif
|