Prev

Next

Index-> contents reference index search external

Up-> CppAD library OdeErrControl

CppAD-> Install Introduction AD ADFun multi_thread library cppad_ipopt_nlp Example preprocessor Appendix

library-> ErrorHandler NearEqual speed_test SpeedTest time_test NumericType CheckNumericType SimpleVector CheckSimpleVector nan pow_int Poly LuDetAndSolve RombergOne RombergMul Runge45 Rosen34 OdeErrControl OdeGear OdeGearControl BenderQuad opt_val_hes LuRatio CppAD_vector thread_alloc memory_leak

OdeErrControl-> OdeErrControl.cpp OdeErrMaxabs.cpp

Headings-> Syntax Description Include Notation xf Method ---..step ---..Nan ---..order ti tf xi smin smax scur eabs erel ef maxabs nstep Error Criteria Discussion Scalar Vector Example Theory Source Code

An Error Controller for ODE Solvers
Syntax
# include <cppad/ode_err_control.hpp>
xf = OdeErrControl(method, ti, tf, xi,
     smin, smax, scur, eabs, erel, ef , maxabs, nstep )

Description
Let $\mathbf{R}$ denote the real numbers and let $\mathit{F}:\mathbf{R}\times {\mathbf{R}}^{\mathit{n}}\to {\mathbf{R}}^{\mathit{n}}$ be a smooth function. We define $\mathit{X}:[\mathit{ti},\mathit{tf}]\to {\mathbf{R}}^{\mathit{n}}$ by the following initial value problem: $$\begin{array}{ccc}\hfill \mathit{X}(\mathit{ti})& \hfill =\hfill & \mathit{xi}\hfill \\ \hfill \mathit{X}\text{'}(\mathit{t})& \hfill =\hfill & \mathit{F}[\mathit{t},\mathit{X}(\mathit{t})]\hfill \end{array}$$ The routine OdeErrControl can be used to adjust the step size used an arbitrary integration methods in order to be as fast as possible and still with in a requested error bound.

Include
The file cppad/ode_err_control.hpp is included by cppad/cppad.hpp but it can also be included separately with out the rest of the CppAD routines.

Notation
The template parameter types Scalar and Vector are documented below.

xf
The return value xf has the prototype
     Vector xf
(see description of Vector below). and the size of xf is equal to n. If xf contains not a number nan , see the discussion of step .

Method
The class Method and the object method satisfy the following syntax
     Method &method
The object method must support step and order member functions defined below:

step
The syntax
     method.step(ta, tb, xa, xb, eb)
executes one step of the integration method.

ta
The argument ta has prototype
     const Scalar &ta
It specifies the initial time for this step in the ODE integration. (see description of Scalar below).

tb
The argument tb has prototype
     const Scalar &tb
It specifies the final time for this step in the ODE integration.

xa
The argument xa has prototype
     const Vector &xa
and size n. It specifies the value of $\mathit{X}(\mathit{ta})$ . (see description of Vector below).

xb
The argument value xb has prototype
     Vector &xb
and size n. The input value of its elements does not matter. On output, it contains the approximation for $\mathit{X}(\mathit{tb})$ that the method obtains.

eb
The argument value eb has prototype
     Vector &eb
and size n. The input value of its elements does not matter. On output, it contains an estimate for the error in the approximation xb. It is assumed (locally) that the error bound in this approximation nearly equal to $\mathit{K}(\mathit{tb}-\mathit{ta}{)}^{\mathit{m}}$ where K is a fixed constant and m is the corresponding argument to CodeControl.

Nan
If any element of the vector eb or xb are not a number nan, the current step is considered to large. If this happens with the current step size equal to smin, OdeErrControl returns with xf and ef as vectors of nan.

order
If m is size_t, the object method must also support the following syntax
     m = method.order()
The return value m is the order of the error estimate; i.e., there is a constant K such that if $\mathit{ti}\le \mathit{ta}\le \mathit{tb}\le \mathit{tf}$ , $$|\mathit{eb}(\mathit{tb})|\le \mathit{K}|\mathit{tb}-\mathit{ta}{|}^{\mathit{m}}$$ where ta, tb, and eb are as in method.step(ta, tb, xa, xb, eb)

ti
The argument ti has prototype
     const Scalar &ti
It specifies the initial time for the integration of the differential equation.

tf
The argument tf has prototype
     const Scalar &tf
It specifies the final time for the integration of the differential equation.

xi
The argument xi has prototype
     const Vector &xi
and size n. It specifies value of $\mathit{X}(\mathit{ti})$ .

smin
The argument smin has prototype
     const Scalar &smin
The step size during a call to method is defined as the corresponding value of $\mathit{tb}-\mathit{ta}$ . If $\mathit{tf}-\mathit{ti}\le \mathit{smin}$ , the integration will be done in one step of size tf - ti. Otherwise, the minimum value of tb - ta will be $\mathit{smin}$ except for the last two calls to method where it may be as small as $\mathit{smin}/2$ .

smax
The argument smax has prototype
     const Scalar &smax
It specifies the maximum step size to use during the integration; i.e., the maximum value for $\mathit{tb}-\mathit{ta}$ in a call to method. The value of smax must be greater than or equal smin.

scur
The argument scur has prototype
     Scalar &scur
The value of scur is the suggested next step size, based on error criteria, to try in the next call to method. On input it corresponds to the first call to method, in this call to OdeErrControl (where $\mathit{ta}=\mathit{ti}$ ). On output it corresponds to the next call to method, in a subsequent call to OdeErrControl (where ta = tf).

eabs
The argument eabs has prototype
     const Vector &eabs
and size n. Each of the elements of eabs must be greater than or equal zero. It specifies a bound for the absolute error in the return value xf as an approximation for $\mathit{X}(\mathit{tf})$ . (see the error criteria discussion below).

erel
The argument erel has prototype
     const Scalar &erel
and is greater than or equal zero. It specifies a bound for the relative error in the return value xf as an approximation for $\mathit{X}(\mathit{tf})$ (see the error criteria discussion below).

ef
The argument value ef has prototype
     Vector &ef
and size n. The input value of its elements does not matter. On output, it contains an estimated bound for the absolute error in the approximation xf; i.e., $${\mathit{ef}}_{\mathit{i}}>|\mathit{X}(\mathit{tf}{)}_{\mathit{i}}-{\mathit{xf}}_{\mathit{i}}|$$ If on output ef contains not a number nan, see the discussion of step .

maxabs
The argument maxabs is optional in the call to OdeErrControl. If it is present, it has the prototype
     Vector &maxabs
and size n. The input value of its elements does not matter. On output, it contains an estimate for the maximum absolute value of $\mathit{X}(\mathit{t})$ ; i.e., $$\mathit{maxabs}[\mathit{i}]\approx \max \left\{|\mathit{X}(\mathit{t}{)}_{\mathit{i}}|:\mathit{t}\in [\mathit{ti},\mathit{tf}]\right\}$$
nstep
The argument nstep is optional in the call to OdeErrControl. If it is present, it has the prototype
     size_t &nstep
Its input value does not matter and its output value is the number of calls to method.step used by OdeErrControl.

Error Criteria Discussion
The relative error criteria erel and absolute error criteria eabs are enforced during each step of the integration of the ordinary differential equations. In addition, they are inversely scaled by the step size so that the total error bound is less than the sum of the error bounds. To be specific, if $\tilde{\mathit{X}}(\mathit{t})$ is the approximate solution at time $\mathit{t}$ , ta is the initial step time, and tb is the final step time, $$\left|\tilde{\mathit{X}}(\mathit{tb}{)}_{\mathit{j}}-\mathit{X}(\mathit{tb}{)}_{\mathit{j}}\right|\le \frac{\mathit{tf}-\mathit{ti}}{\mathit{tb}-\mathit{ta}}\left[\mathit{eabs}[\mathit{j}]+\mathit{erel}|\tilde{\mathit{X}}(\mathit{tb}{)}_{\mathit{j}}|\right]$$ If $\mathit{X}(\mathit{tb}{)}_{\mathit{j}}$ is near zero for some $\mathit{tb}\in [\mathit{ti},\mathit{tf}]$ , and one uses an absolute error criteria $\mathit{eabs}[\mathit{j}]$ of zero, the error criteria above will force OdeErrControl to use step sizes equal to smin for steps ending near $\mathit{tb}$ . In this case, the error relative to maxabs can be judged after OdeErrControl returns. If ef is to large relative to maxabs, OdeErrControl can be called again with a smaller value of smin.

Scalar
The type Scalar must satisfy the conditions for a NumericType type. The routine CheckNumericType will generate an error message if this is not the case. In addition, the following operations must be defined for Scalar objects a and b:

Operation	Description
a <= b	returns true (false) if a is less than or equal (greater than) b.
a == b	returns true (false) if a is equal to b.
log(a)	returns a Scalar equal to the logarithm of a
exp(a)	returns a Scalar equal to the exponential of a

Vector
The type Vector must be a SimpleVector class with elements of type Scalar . The routine CheckSimpleVector will generate an error message if this is not the case.

Example
The files OdeErrControl.cpp and OdeErrMaxabs.cpp contain examples and tests of using this routine. They return true if they succeed and false otherwise.

Theory
Let $\mathit{e}(\mathit{s})$ be the error as a function of the step size $\mathit{s}$ and suppose that there is a constant $\mathit{K}$ such that $\mathit{e}(\mathit{s})=\mathit{K}{\mathit{s}}^{\mathit{m}}$ . Let $\mathit{a}$ be our error bound. Given the value of $\mathit{e}(\mathit{s})$ , a step of size $\mathrm{\lambda }\mathit{s}$ would be ok provided that $$\begin{array}{ccc}\hfill \mathit{a}& \hfill \ge \hfill & \mathit{e}(\mathrm{\lambda }\mathit{s})(\mathit{tf}-\mathit{ti})/(\mathrm{\lambda }\mathit{s})\hfill \\ \hfill \mathit{a}& \hfill \ge \hfill & \mathit{K}{\mathrm{\lambda }}^{\mathit{m}}{\mathit{s}}^{\mathit{m}}(\mathit{tf}-\mathit{ti})/(\mathrm{\lambda }\mathit{s})\hfill \\ \hfill \mathit{a}& \hfill \ge \hfill & {\mathrm{\lambda }}^{\mathit{m}-1}{\mathit{s}}^{\mathit{m}-1}(\mathit{tf}-\mathit{ti})\mathit{e}(\mathit{s})/{\mathit{s}}^{\mathit{m}}\hfill \\ \hfill \mathit{a}& \hfill \ge \hfill & {\mathrm{\lambda }}^{\mathit{m}-1}(\mathit{tf}-\mathit{ti})\mathit{e}(\mathit{s})/\mathit{s}\hfill \\ \hfill {\mathrm{\lambda }}^{\mathit{m}-1}& \hfill \le \hfill & \frac{\mathit{a}}{\mathit{e}(\mathit{s})}\frac{\mathit{s}}{\mathit{tf}-\mathit{ti}}\hfill \end{array}$$ Thus if the right hand side of the last inequality is greater than or equal to one, the step of size $\mathit{s}$ is ok.

Source Code
The source code for this routine is in the file cppad/ode_err_control.hpp.

---

Input File: cppad/ode_err_control.hpp