a6c3d1306a76b558f0699dd963d0d2ac87aef8ba
[scilab.git] / scilab / modules / xcos / help / fr_FR / solvers / 4-RKImplicite.xml
1 <?xml version="1.0" encoding="UTF-8"?>
2 <!--
3  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
4  * Copyright (C) Scilab Enterprises - 2012 - Paul Bignier
5  *
6  * This file must be used under the terms of the CeCILL.
7  * This source file is licensed as described in the file COPYING, which
8  * you should have received as part of this distribution.
9  * The terms are also available at
10  * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
11  -->
12 <refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg"  xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org" xml:lang="fr_FR" xml:id="RKImp">
13     <refnamediv>
14         <refname>Implicit Runge-Kutta 4(5)</refname>
15         <refpurpose>
16             <emphasis>Implicit Runge-Kutta</emphasis> est un solveur numérique fournissant une méthode implicite efficace et stable pour résoudre des Problèmes à Valeur Initiale d'Equations Différentielles Ordinarires (EDOs). Called by <link linkend="xcos">xcos</link>.
17         </refpurpose>
18     </refnamediv>
19     <refsection>
20         <title>Description</title>
21         <para>
22             <emphasis>Runge-Kutta</emphasis> est un solveur numérique fournissant une méthode explicite efficace pour résoudre des Problèmes à Valeur Initiale de la forme :
23         </para>
24         <para>
25             <latex>
26                 \begin{eqnarray}
27                 \dot{y} = f(t,y), \hspace{3 mm} y(t_0) = y_0, \hspace{3 mm} y \in R^N
28                 \end{eqnarray}
29             </latex>
30         </para>
31         <para>
32             <emphasis>CVode</emphasis> et <emphasis>IDA</emphasis> utilisent un pas variable dans l'intégration.
33         </para>
34         <para>
35             Le défaut de cela est l'imprévisibilité du temps de calcul. Avec <emphasis>Runge-Kutta</emphasis>, on ne s'adapte pas à la complexité du problème, mais on garantit un temps de calcul stable.
36         </para>
37         <para>
38             Cette méthode étant implicite, elle peut être utilisée sur des problèmes raides.
39         </para>
40         <para>
41             C'est une amélioration de la méthode d'Euler implicite, qui approxime 
42             <emphasis>
43                 y<subscript>n+1</subscript>
44             </emphasis>
45             en calculant 
46             <emphasis>
47                 f(t<subscript>n</subscript>+h, y<subscript>n+1</subscript>)
48             </emphasis>
49             et tronquant le développement de Taylor.
50         </para>
51         <para>
52             Le schéma implémenté est inspiré de "Low-Dispersion Low-Dissipation Implicit Runge-Kutta Scheme" (lien en bas de page).
53         </para>
54         <para>
55             Par convention, pour utiliser des pas fixes, le programme commence par calculer un pas <emphasis>h</emphasis> qui approche le paramère de simulation <link linkend="Simulatemenu_Menu_entries">max step size</link>.
56         </para>
57         <para>
58             Une différence notable de <emphasis>Runge-Kutta implicite</emphasis> par rapport à <emphasis>Sundials</emphasis> est qu'il calcule jusqu'à la dérivée quatrième de <emphasis>y</emphasis>, alors que les autres n'utilisent que des combinaisons linéaires de <emphasis>y</emphasis> et <emphasis>y'</emphasis>.
59         </para>
60         <para>
61             Ici, la valeur suivante est déterminée par la valeur actuelle 
62             <emphasis>
63                 y<subscript>n</subscript>
64             </emphasis>
65             plus la moyenne pondérée de trois increments, où chaque incrément est le produit du pas, <emphasis>h</emphasis>, et une estimation de la pente spécifiée par la fonction <emphasis>f(t,y)</emphasis>. Ils sont distribués de manière à peu près égale sur l'intervalle.
66             <itemizedlist>
67                 <listitem>
68                     <emphasis>k1</emphasis> est l'incrément basé sur la pente au début de l'intervalle, utilisant 
69                     <emphasis>
70                         y<subscript>n</subscript>+ a11*h*k1,
71                     </emphasis>
72                     ,
73                 </listitem>
74                 <listitem>
75                     <emphasis>k2</emphasis> est l'incrément basé sur la pente près du milieu de l'intervalle, utilisant 
76                     <emphasis>
77                         y<subscript>n</subscript> + a21*h*k1 + a22*h*k2,
78                     </emphasis>
79                     ,
80                 </listitem>
81                 <listitem>
82                     <emphasis>k3</emphasis> est l'incrément basé sur la pente trois quarts de l'intervalle, utilisant 
83                     <emphasis>
84                         y<subscript>n</subscript> + a31*h*k1 + a32*h*k2 + a33*h*k3.
85                     </emphasis>
86                 </listitem>
87             </itemizedlist>
88         </para>
89         <para>
90             On peut voir que le calcul d'un <emphasis>ki</emphasis> requiert <emphasis>ki</emphasis>, nécéssitant ainsi l'utilisation d'un solveur non linéraire (ici, itérations point-fixes).
91         </para>
92         <para>
93             D'abord, on initialise 
94             <emphasis>
95                 k0 = h * f(t<subscript>n</subscript>, y<subscript>n</subscript>)
96             </emphasis>
97             comme première estimation pour tous les <emphasis>ki</emphasis>, pour obtenir de nouveaux <emphasis>ki</emphasis> et une première valeur pour 
98             <emphasis>
99                 y<subscript>n+1</subscript>
100             </emphasis>
101             .
102         </para>
103         <para>
104             Ensuite, on sauve les valeurs et on recalcule 
105             <emphasis>
106                 y<subscript>n+1</subscript>
107             </emphasis>
108             avec ces nouveaux <emphasis>ki</emphasis>.
109         </para>
110         <para>
111             Puis on compare les deux 
112             <emphasis>
113                 y<subscript>n+1</subscript>
114             </emphasis>
115             et on le recalcule jusqu'à ce que son écart avec le dernier soit inférieur au paramètre de simulation <emphasis>reltol</emphasis>.
116         </para>
117         <para>
118             Ce processus ajoute un temps de calcul significatif à la méthode, mais améliore grandement la stabilité.
119         </para>
120         <para>
121             On peut voir qu'avec les <emphasis>ki</emphasis>, on progresse dans les dérivées de 
122             <emphasis>
123                 y<subscript>n</subscript>
124             </emphasis>
125             . Donc avec <emphasis>k3</emphasis>, on approxime 
126             <emphasis>
127                 y<superscript>(3)</superscript><subscript>n</subscript>
128             </emphasis>
129             , faisant donc une erreur en 
130             <emphasis>
131                 O(h<superscript>4</superscript>)
132             </emphasis>
133             . Mais un choix judicieux des coefficients du calcul des <emphasis>ki</emphasis> (notamment 
134             <emphasis>
135                 a<subscript>ij</subscript>
136             </emphasis>
137             ) nous fait gagner un order, produisant ainsi une erreur par pas de temps en 
138             <emphasis>
139                 O(h<superscript>5</superscript>)
140             </emphasis>
141             .
142         </para>
143         <para>
144             L'erreur totale est donc 
145             <emphasis>
146                 nombre de pas * O(h<superscript>5</superscript>)
147             </emphasis>
148             . Et puisque par définition <emphasis>nombre de pas = taille de l'intervalle / h</emphasis>, l'erreur totale est en 
149             <emphasis>
150                 O(h<superscript>4</superscript>)
151             </emphasis>
152             .
153         </para>
154         <para>
155             Cette analyse d'erreur a baptisé la méthode <emphasis>Runge-Kutta Implicite 4(5)</emphasis>: 
156             <emphasis>
157                 O(h<superscript>5</superscript>)
158             </emphasis>
159             par pas, 
160             <emphasis>
161                 O(h<superscript>4</superscript>)
162             </emphasis>
163             au total.
164         </para>
165         <para>
166             Bien que le solveur fonctionne bien pour <link linkend="Simulatemenu_Menu_entries">max step size</link> jusqu'à 
167             <emphasis>
168                 10<superscript>-3</superscript>
169             </emphasis>
170             , es erreurs d'arrondi surviennent parfois quand l'on approche 
171             <emphasis>
172                 4*10<superscript>-4</superscript>
173             </emphasis>
174             . En effet, le scindage de l'intervalle ne peut pas être effectué correctement et l'on obtient des résultats imprévisibles.
175         </para>
176     </refsection>
177     <refsection>
178         <title>Examples</title>
179         <para>
180             <link type="scilab" linkend="scilab.xcos/xcos/examples/solvers/ODE_Example.zcos">
181                 <inlinemediaobject>
182                     <imageobject>
183                         <imagedata align="center" fileref="../../../examples/solvers/ODE_Example.zcos" valign="middle"/>
184                     </imageobject>
185                 </inlinemediaobject>
186             </link>
187             <scilab:image><![CDATA[
188 loadScicos();
189 loadXcosLibs();
190 importXcosDiagram(SCI + "/modules/xcos/examples/solvers/ODE_Example.zcos");
191 scs_m.props.tol(2) = 10^-5;
192 scs_m.props.tol(6) = 7;
193 scs_m.props.tol(7) = 10^-2;
194 try xcos_simulate(scs_m, 4); catch disp(lasterror()); end
195 ]]></scilab:image>
196         </para>
197         <para>
198             Le bloc intégrale retourne son état continu, on peut l'évaluer avec <emphasis>RK implicite</emphasis> en lançant l'exemple :
199         </para>
200         <para>
201             <programlisting language="example"><![CDATA[
202       // Import du diagramme et réglage du temps final
203       loadScicos();
204       loadXcosLibs();
205       importXcosDiagram("SCI/modules/xcos/examples/solvers/ODE_Example.zcos");
206       scs_m.props.tf = 5000;
207
208       // Sélection de RK implicite et réglage de la précision
209       scs_m.props.tol(2) = 10^-10;
210       scs_m.props.tol(6) = 7;
211       scs_m.props.tol(7) = 10^-2;
212
213       // Lancement du chrono, de la simulation et affichage du temps
214       tic();
215       try xcos_simulate(scs_m, 4); catch disp(lasterror()); end
216       t = toc();
217       disp(t, "Temps pour Runge-Kutta implicite :");
218       ]]></programlisting>
219         </para>
220         <para>
221             La console Scilab affiche :
222             <screen><![CDATA[
223 Temps pour Runge-Kutta implicite :
224  8.911
225             ]]></screen>
226         </para>
227         <para>
228             Maintenant, dans le script suivant, on compare la différence de temps entre <emphasis>RK implicite</emphasis> et <emphasis>CVode</emphasis> en lançant l'exemple avec les cinq solveurs tour à tour :
229             <link type="scilab" linkend ="scilab.scinotes/xcos/examples/solvers/integImpRK.sce">
230                 Ouverture du script
231             </link>
232         </para>
233         <para>
234             <screen><![CDATA[
235 Temps pour BDF / Newton :
236  18.894
237
238 Temps pour BDF / Functional :
239  18.382
240
241 Temps pour Adams / Newton :
242  10.368
243
244 Temps pour Adams / Functional :
245  9.815
246
247 Temps pour Runge-Kutta implicite :
248  6.652
249             ]]></screen>
250         </para>
251         <para>
252             Ces résultats montrent que pour un problème non-raide, pour à peu près la même précision demandée et en forçant la même taille de pas, <emphasis>RK implicite</emphasis> est plus rapide.
253         </para>
254     </refsection>
255     <refsection>
256         <title>Voir Aussi</title>
257         <simplelist type="inline">
258             <member>
259                 <link linkend="LSodar">LSodar</link>
260             </member>
261             <member>
262                 <link linkend="CVode">CVode</link>
263             </member>
264             <member>
265                 <link linkend="IDA">IDA</link>
266             </member>
267             <member>
268                 <link linkend="RK">Runge-Kutta 4(5)</link>
269             </member>
270             <member>
271                 <link linkend="DoPri">Dormand-Prince 4(5)</link>
272             </member>
273             <member>
274                 <link linkend="DDaskr">DDaskr</link>
275             </member>
276             <member>
277                 <link linkend="Comparaisons">Comparaisons</link>
278             </member>
279             <member>
280                 <link linkend="ode_discrete">ode_discrete</link>
281             </member>
282             <member>
283                 <link linkend="ode_root">ode_root</link>
284             </member>
285             <member>
286                 <link linkend="odedc">odedc</link>
287             </member>
288             <member>
289                 <link linkend="impl">impl</link>
290             </member>
291         </simplelist>
292     </refsection>
293     <refsection>
294         <title>Bibliographie</title>
295         <para>
296             Journal of Computational Physics, Volume 233, Janvier 2013, Pages 315-323 <ulink url="http://dl.acm.org/citation.cfm?id=2397727.2397975&amp;coll=DL&amp;dl=GUIDE&amp;CFID=295003167&amp;CFTOKEN=37159263">A low-dispersion and low-dissipation implicit Runge-Kutta scheme</ulink>
297         </para>
298         <para>
299             <ulink url="https://computation.llnl.gov/casc/sundials/documentation/documentation.html">Documentation Sundials</ulink>
300         </para>
301     </refsection>
302     <refsection>
303         <title>Histoire</title>
304         <revhistory>
305             <revision>
306                 <revnumber>5.4.1</revnumber>
307                 <revdescription>Runge-Kutta Implicite 4(5) ajouté</revdescription>
308             </revision>
309         </revhistory>
310     </refsection>
311 </refentry>