Voir la source de User Manual 4.6 Numerical ordinary differential equations

__NOTOC__
== Introduction ==
=== Scope ===
This library can compute solutions for ordinary differential equations, as numerical approximations.
The problems are usually in the form of :
Compute an estimate of y(t) from t=t0 to t=t1, knowing the derivative y'=f(t,y), and y(t0)=y0.

The library can also handle multiple discrete events detection based on the results of the ongoing estimation, which can be used to dynamically alter the conditions of the problem being solved, or even stop the integration (for instance : when the function y reaches an expected value, the value of t at this point being the information needed, there is no need to go on).

=== Javadoc ===
==== Integrators ====

The ODE integrators are provided in the following packages :

{| class="wikitable"
|-
! scope="col"| Library
! scope="col"| Javadoc
|-
|Patrius
|[{{JavaDoc4.6}}/fr/cnes/sirius/patrius/math/ode/package-summary.html Package fr.cnes.sirius.patrius.math.ode]
|-
|Patrius
|[{{JavaDoc4.6}}/fr/cnes/sirius/patrius/math/ode/nonstiff/package-summary.html Package fr.cnes.sirius.patrius.math.ode.nonstiff]
|-
|Patrius
|[{{JavaDoc4.6}}/fr/cnes/sirius/patrius/math/ode/sampling/package-summary.html Package fr.cnes.sirius.patrius.math.ode.sampling]
|}

==== Event handling ====

The events are managed in the following package :

{| class="wikitable"
|-
! scope="col"| Library
! scope="col"| Javadoc
|-
|Patrius
|[{{JavaDoc4.6}}/fr/cnes/sirius/patrius/math/ode/events/package-summary.html Package fr.cnes.sirius.patrius.math.ode.events]
|}

=== Links ===
None as of now.

=== Useful Documents ===
A general purpose explanation of this section can be found here :

[http://en.wikipedia.org/wiki/Numerical_ordinary_differential_equations http://en.wikipedia.org/wiki/Numerical_ordinary_differential_equations]

=== Package Overview ===
Integrators :

[[File:Integrators2.PNG|center]]

Events package :

[[File:PATRIMOINESIRIUSSUMDiagEvents.png|center]]

== Features Description ==
=== Integrators ===
The integrators providedinclude :
* the Classical Runge Kutta integrator,
* the Dormand Prince 8(5, 3) integrator,
* the Gragg Bulirsch Stoer integrator,
* the 6^^th^^ order Runge-Kutta integretor.

The ODE package documentation can be found [http://commons.apache.org/proper/commons-math/userguide/ode.html here ].

=== Events ===
Event handling during an integrator run is a core functionality of the math package,
therefore this is already well-documented in the Javadoc (please see the relevant section).
This here is a short summary of how event handling works.

==== How to monitor events ====
* '''create an EventHandler implementation''' <br> You need to create an EventHandler implementation for the event you want to trace.<br>The most important method here is the g() method :<br><code>double g(double t, double[] y) throws EventException;</code> <br>This method (which takes as input a solution of the integration problem at a given "time" t) should be designed so that '''when the event occurs, the sign of the method changes'''. It should also be continuous.<br>The other methods of the interface are : 
** <syntaxhighlight lang="java">int eventOccurred(double t, double[] y, boolean increasing, boolean forward) throws EventException</syntaxhighlight> <br> This method is called when an event happens. It should return :
*** STOP if the integration computation should stop
*** RESET_STATE if the event handler wants to change the state vector before the integration resumes (the resetState method will be called)
*** RESET_DERIVATIVES if the state vector's derivatives need to be recomputed before the integration resumes
*** CONTINUE if the integration should continue as if nothing happened
** <syntaxhighlight lang="java">void resetState(double t, double[] y) throws EventException</syntaxhighlight> <br> This method is called when eventOccured has returned RESET_STATE. This method should modify the y array, which will change the way the integration performs.
* '''add the EventHandler to an appropriate integrator''' <br>Using an EventHandler on a given integration problem is simple : just add it to the integrator instance before computing the solution.<br><syntaxhighlight lang="java">integrator.addEventHandler(eventHandler, maxCheckInterval, convergence, maxIterationCount);</syntaxhighlight> <br>Aside from the EventHandler itself, the other parameters are :<br>
** maxCheckInterval : Maximal time interval between events handler checks.
** convergence : precision needed for the event "time" value.
** iterationCount : maximum number of iterations to find the event "time" value when an event has been identified. Reaching this number means there is a problem with finding the event quickly enough (so, this counter is a way to interrupt an event search that takes too long, since finding an event should be fast if the g() function is continuous).

*'''run the integrator'''
Please see the relevant section.

==== About the EventState class ====
The EventState class is a very important class for event detection (one EventState instance is needed for each EventHandler to work), but since the integrator instantiates EventStates when needed, a regular user never needs to interact directy with an EventState object. Therefore, describing the EventState class is out of the scope of this document; all relevant information can be found in the Javadoc if needed.

== Getting Started ==


== Contents ==
=== Interfaces ===
{| class="wikitable"
|-
! scope="col"| Interface
! scope="col"| Summary
! scope="col"| Javadoc
|-
|'''FirstOrderIntegrator'''
|This interface represents a first order integrator for differential equations.
|[{{JavaDoc4.6}}/fr/cnes/sirius/patrius/math/ode/FirstOrderIntegrator.html ...]
|-
|'''ODEIntegrator'''
|This interface defines the common parts shared by integrators for first and second order differential equations.
|[{{JavaDoc4.6}}/fr/cnes/sirius/patrius/math/ode/ODEIntegrator.html ...]
|}

{| class="wikitable"
|-
! scope="col"| Interface
! scope="col"| Summary
! scope="col"| Javadoc
|-
|'''EventHandler'''
|This interface represents a handler for discrete events triggered during ODE integration.
|[{{JavaDoc4.6}}/fr/cnes/sirius/patrius/math/ode/events/EventHandler.html ...]
|}

=== Classes ===

{| class="wikitable"
|-
! scope="col"| Class
! scope="col"| Summary
! scope="col"| Javadoc
|-
|'''AbstractIntegrator'''
|Base class managing common boilerplate for all integrators.
|[{{JavaDoc4.6}}/fr/cnes/sirius/patrius/math/ode/AbstractIntegrator.html ...]
|-
|'''AdaptiveStepsizeIntegrator'''
|This abstract class holds the common part of all adaptive stepsize integrators for Ordinary Differential Equations.
|[{{JavaDoc4.6}}/fr/cnes/sirius/patrius/math/ode/nonstiff/AdaptiveStepsizeIntegrator.html ...]
|-
|'''ClassicalRungeKuttaIntegrator'''
|This class implements the classical fourth order Runge-Kutta integrator for Ordinary Differential Equations (it is the most often used Runge-Kutta method).
|[{{JavaDoc4.6}}/fr/cnes/sirius/patrius/math/ode/nonstiff/ClassicalRungeKuttaIntegrator.html ...]
|-
|'''RungeKutta6Integrator'''
|This class implements the sixth order Runge-Kutta integrator for Ordinary Differential Equations (it is used as the default Stela Integrator). This integrator currently has an second order interpolator.
|[{{JavaDoc4.6}}/fr/cnes/sirius/patrius/math/ode/nonstiff/RungeKutta6Integrator.html ...]
|-
|'''DormandPrince54Integrator'''
|This class implements the 5(4) Dormand-Prince integrator for Ordinary Differential Equations.
|[{{JavaDoc4.6}}/fr/cnes/sirius/patrius/math/ode/nonstiff/DormandPrince54Integrator.html ...]
|-
|'''DormandPrince853Integrator'''
|This class implements the 8(5,3) Dormand-Prince integrator for Ordinary Differential Equations.
|[{{JavaDoc4.6}}/fr/cnes/sirius/patrius/math/ode/nonstiff/DormandPrince853Integrator.html ...]
|-
|'''GraggBulirschStoerIntegrator'''
|This class implements a Gragg-Bulirsch-Stoer integrator for Ordinary Differential Equations.
|[{{JavaDoc4.6}}/fr/cnes/sirius/patrius/math/ode/nonstiff/GraggBulirschStoerIntegrator.html ...]
|-
|'''RungeKuttaIntegrator'''
|This class implements the common part of all fixed step Runge-Kutta integrators for Ordinary Differential Equations.
|[{{JavaDoc4.6}}/fr/cnes/sirius/patrius/math/ode/nonstiff/RungeKuttaIntegrator.html ...]
|}

{| class="wikitable"
|-
! scope="col"| Class
! scope="col"| Summary
! scope="col"| Javadoc
|-
|'''EventState'''
|This class handles the state for one EventHandler during integration steps.
|[{{JavaDoc4.6}}/fr/cnes/sirius/patrius/math/ode/events/EventState.html ...]
|}

[[Category:User_Manual_4.6_Mathematics]]