From 066a19b6850b6ce6eff77353cf2a0456a6db96b1 Mon Sep 17 00:00:00 2001 From: guido Date: Fri, 5 Feb 1999 13:08:02 +0000 Subject: [PATCH] FunctionTime base object for Function git-svn-id: https://svn.dealii.org/trunk@756 0785d39b-7218-0410-832d-ea1e28bc413d --- deal.II/base/include/base/function.h | 71 ++------------- deal.II/base/include/base/function_time.h | 100 ++++++++++++++++++++++ deal.II/base/include/base/tensor.h | 6 +- deal.II/base/source/function.cc | 27 +----- deal.II/base/source/function_time.cc | 27 ++++++ 5 files changed, 142 insertions(+), 89 deletions(-) create mode 100644 deal.II/base/include/base/function_time.h create mode 100644 deal.II/base/source/function_time.cc diff --git a/deal.II/base/include/base/function.h b/deal.II/base/include/base/function.h index f992406d9c..e3a6acde4b 100644 --- a/deal.II/base/include/base/function.h +++ b/deal.II/base/include/base/function.h @@ -9,7 +9,7 @@ #include #include #include - +#include @@ -34,53 +34,15 @@ * less than the virtual function call itself. * * - * \subsection{Support for time dependant functions} - * - * The library was also designed for time dependant problems. For this - * purpose, the function objects also contain a field which stores the - * time, as well as functions manipulating them. Time independant 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 dependant problems. The second advantage is that the derived - * standard classes like #ZeroFunction#, #ConstantFunction# etc also work - * for time dependant problems. - * - * Access to the time goes through the following functions: - * \begin{verbatim} - * \item #get_time#: return the present value of the time variable. - * \item #set_time#: set the time value to a specific value. - * \item #advance_time#: increase the time by a certain time step. - * \end{verbatim} - * 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 dependant function had a factor #sin(t)#, 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 #operator()#, #value_list# or one - * of the other functions 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. - * - * Derived classes should access the time variable directly, which is - * available under the obvious name #time#, rather than calling - * #get_time#. - * - * 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. - * - * Once again the warning: do not use the #time# variable for any other - * purpose than the intended one! This will inevitably lead to confusion. - * - * - * @author Wolfgang Bangerth, 1998 + * Support for time dependant functions can be found in the base + * class #FunctionTime#. + + * @author Wolfgang Bangerth, 1998, 1999 */ template -class Function { +class Function : + public FunctionTime +{ public: /** * Constructor. May take an initial vakue @@ -127,23 +89,6 @@ class Function { */ virtual void gradient_list (const vector > &points, vector > &gradients) const; - - /** - * Return the value of the time variable/ - */ - double get_time () const; - - /** - * Set the time to #new_time#, overwriting - * the old value. - */ - virtual void set_time (const double new_time); - - /** - * Advance the time by the given - * time step #delta_t#. - */ - virtual void advance_time (const double delta_t); /** * Exception diff --git a/deal.II/base/include/base/function_time.h b/deal.II/base/include/base/function_time.h new file mode 100644 index 0000000000..d29dc463a2 --- /dev/null +++ b/deal.II/base/include/base/function_time.h @@ -0,0 +1,100 @@ +/*---------------------------- functiontime.h ---------------------------*/ +/* $Id$ */ +/* Copyright W. Bangerth, Guido Kanschat + * University of Heidelberg, 1998, 1999 */ +#ifndef __functiontime_H +#define __functiontime_H +/*---------------------------- functiontime.h ---------------------------*/ + + +#include + +/** + * 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 #ZeroFunction#, #ConstantFunction# etc also work + * for time dependent problems. + * + * Access to the time goes through the following functions: + * \begin{verbatim} + * \item #get_time#: return the present value of the time variable. + * \item #set_time#: set the time value to a specific value. + * \item #advance_time#: increase the time by a certain time step. + * \end{verbatim} + * 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 #sin(t)#, 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 #operator()#, #value_list# or one + * of the other functions 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. + * + * Once again the warning: do not use the #time# variable for any other + * purpose than the intended one! This will inevitably lead to confusion. + * + * + * @author Wolfgang Bangerth, Guido Kanschat, 1998, 1999 + */ +class FunctionTime { + public: + /** + * Constructor. May take an initial vakue + * for the time variable, which defaults + * to zero. + */ + FunctionTime (const double initial_time = 0.0); + + /** + * Virtual destructor. + */ + virtual ~FunctionTime(); + + /** + * Return the value of the time variable/ + */ + double get_time () const; + + /** + * Set the time to #new_time#, overwriting + * the old value. + */ + virtual void set_time (const double new_time); + + /** + * Advance the time by the given + * time step #delta_t#. + */ + virtual void advance_time (const double delta_t); + +private: + /** + * Store the present time. + */ + double time; +}; + +inline double +FunctionTime::get_time () const +{ + return time; +}; + +/*---------------------------- functiontime.h ---------------------------*/ +/* end of #ifndef __functiontime_H */ +#endif +/*---------------------------- functiontime.h ---------------------------*/ diff --git a/deal.II/base/include/base/tensor.h b/deal.II/base/include/base/tensor.h index fa679b2cc1..3806731eb5 100644 --- a/deal.II/base/include/base/tensor.h +++ b/deal.II/base/include/base/tensor.h @@ -16,11 +16,11 @@ * functionality is recursively handed down to tensors of rank 1 or * put into external templated functions, e.g. the #contract# family. * - * Using this tensor class for objects of rank to has advantages over + * Using this tensor class for objects of rank 2 has advantages over * matrices in many cases since the dimension is known to the compiler * as well as the location of the data. It is therefore possible to * produce far more efficient code than for matrices with - * runtime-dependant dimension. + * runtime-dependent dimension. */ template class Tensor { @@ -106,7 +106,7 @@ class Tensor { Tensor & operator -= (const Tensor &); /** - * Scale the vector by #factor#, i.e. multiply + * Scale the tensor by #factor#, i.e. multiply * all coordinates by #factor#. */ Tensor & operator *= (const double &factor); diff --git a/deal.II/base/source/function.cc b/deal.II/base/source/function.cc index 3b7a77494b..d2905c2a5b 100644 --- a/deal.II/base/source/function.cc +++ b/deal.II/base/source/function.cc @@ -7,12 +7,14 @@ template Function::Function (const double initial_time) : - time(initial_time) {}; + FunctionTime(initial_time) +{}; template -Function::~Function () {}; +Function::~Function () +{}; @@ -57,27 +59,6 @@ void Function::gradient_list (const vector > &points, -template -double Function::get_time () const { - return time; -}; - - - -template -void Function::set_time (const double new_time) { - time = new_time; -}; - - - -template -void Function::advance_time (const double delta_t) { - set_time (time+delta_t); -}; - - - template diff --git a/deal.II/base/source/function_time.cc b/deal.II/base/source/function_time.cc new file mode 100644 index 0000000000..0fa1f827c9 --- /dev/null +++ b/deal.II/base/source/function_time.cc @@ -0,0 +1,27 @@ +// $Id$ + +#include + + +FunctionTime::FunctionTime(double initial_time) + : + time(initial_time) +{} + +FunctionTime::~FunctionTime() +{} + +void +FunctionTime::set_time (const double new_time) +{ + time = new_time; +}; + +void +FunctionTime::advance_time (const double delta_t) +{ + set_time (time+delta_t); +}; + + + -- 2.39.5