16663ad4c67a8a324e58f3676b360bf4dac8deed
[scilab.git] / scilab / modules / xcos / help / fr_FR / solvers / 1-CVode.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="CVode">
13     <refnamediv>
14         <refname>CVode</refname>
15         <refpurpose>
16             <emphasis>CVode</emphasis> (abréviation de "C-language Variable-coefficients ODE solver") est un solveur numérique fournissant une méthode efficace et stable pour résoudre des Problèmes à Valeur Initiale d'Equations Différentielles Ordinarires (EDOs). Il utilise <emphasis>BDF</emphasis> ou <emphasis>Adams</emphasis> comme méthode d'intégration, et des itérations <emphasis>fonctionnelles</emphasis> ou de <emphasis>Newton</emphasis>.
17         </refpurpose>
18     </refnamediv>
19     <refsection>
20         <title>Description</title>
21         <para>
22             Appelé par <link linkend="xcos">xcos</link>, <emphasis>CVode</emphasis>  (abréviation de "C-language Variable-coefficients ODE solver") est un solveur numérique fournissant une méthode efficace et stable 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             Partant de 
33             <emphasis>
34                 y<subscript>0</subscript>
35             </emphasis>
36             , <emphasis>CVode</emphasis> approxime 
37             <emphasis>
38                 y<subscript>n+1</subscript>
39             </emphasis>
40             grâce à la formule :
41         </para>
42         <para>
43             <latex>
44                 \begin{eqnarray}
45                 \sum_{i=0}^{K_1} \alpha_{n,i} y_{n-i} + h_n\sum_{i=0}^{K_2} \beta_{n,i} \dot{y}_{n-i} = 0,\hspace{10 mm} (1)
46                 \end{eqnarray}
47             </latex>
48             <para>
49                 &#160; avec 
50                 <emphasis>
51                     y<subscript>n</subscript>
52                 </emphasis>
53                 l'approximation de 
54                 <emphasis>
55                     y(t<subscript>n</subscript>)
56                 </emphasis>
57                 , et 
58                 <emphasis>
59                     h<subscript>n</subscript>
60                 </emphasis>
61                 =
62                 <emphasis>
63                     t<subscript>n</subscript> - t<subscript>n-1</subscript>
64                 </emphasis>
65                 la taille du pas de temps.
66             </para>
67         </para>
68         <para>
69             Ces méthodes implicites sont caractérisées par leur order <emphasis>q</emphasis>, qui indique le nombre de points intermédiaires requis pour le calcul de 
70             <emphasis>
71                 y<subscript>n+1</subscript>
72             </emphasis>
73             .
74         </para>
75         <para>
76             C'est ici qu'intervient la différence entre <emphasis>BDF</emphasis> et <emphasis>Adams</emphasis> ("<emphasis>Backward Differentiation Formula</emphasis>" et "<emphasis>Adams-Moulton formula</emphasis>"):
77         </para>
78         <para>
79             <caution>
80                 Si le problème est raide, il est préférable d'utiliser <emphasis>BDF</emphasis> :
81             </caution>
82         </para>
83         <itemizedlist>
84             <listitem>
85                 <emphasis>q</emphasis>, l'ordre de la méthode, est initialisé entre 1 et 5 (automatique),
86             </listitem>
87             <listitem>
88                 <emphasis>K1 = q</emphasis> et <emphasis>K2 = 0</emphasis>.
89             </listitem>
90         </itemizedlist>
91         <para>
92             Dans le cas non-raide, on préferera <emphasis>Adams</emphasis> :
93         </para>
94         <itemizedlist>
95             <listitem>
96                 <emphasis>q</emphasis> est initialisé entre 1 et 12 (automatique),
97             </listitem>
98             <listitem>
99                 <emphasis>K1 = 1</emphasis> et <emphasis>K2 = q</emphasis>.
100             </listitem>
101         </itemizedlist>
102         <para>
103             Les coefficients sont fixes, déterminés uniformément par le type de méthode, son ordre, les pas de temps et la normalisation 
104             <emphasis>
105                 &#x3B1;<subscript>n, 0</subscript> = -1
106             </emphasis>
107             .
108         </para>
109         <para>
110             Quelque soit le choix et à chaque pas, injecter cette intégration dans <emphasis>(1)</emphasis> donne le système non-linéaire:
111         </para>
112         <para>
113             <latex scilab:localized="true">
114                 G(y_n)\equiv y_n-h_n\beta_{n,0}f(t_n,y_n)-a_n=0, \hspace{2 mm} où \hspace{2 mm} a_n\equiv \sum_{i>0} (\alpha_{n,i} y_{n-i} + h_n\beta_{n,i}\dot{y}_{n-i})
115             </latex>
116         </para>
117         <para>
118             Ce système peut être résolu par des itérations <emphasis>fonctionnelles</emphasis> ou de <emphasis>Newton</emphasis>, décrites ci-après.
119         </para>
120         <para>
121             Dans les deux cas suivants, le 
122             <emphasis>
123                 y<subscript>n(0)</subscript>
124             </emphasis>
125             initial "prédit" est calculé explicitement grâce aux valeurs passées, en ajoutant des dérivées.
126         </para>
127         <itemizedlist>
128             <para>  </para>
129             <listitem>
130                 <emphasis role="bold">Fonctionnelles :</emphasis> cette méthode n'implique que des évaluations de <emphasis>f</emphasis>, elle calcule 
131                 <emphasis>
132                     y<subscript>n(0)</subscript>
133                 </emphasis>
134                 simplement en itérant la formule :
135                 <para>
136                     <latex>
137                         y_{n(m+1)} = h_n &#x3B2;_{n,0} f(t_n,y_{n(m)}) + a_n
138                     </latex>
139                     <latex scilab:localized="true">
140                         où \hspace{2 mm} a_n\equiv \sum_{i>0} (\alpha_{n,i} y_{n-i} + h_n\beta_{n,i}\dot{y}_{n-i})
141                     </latex>
142                 </para>
143             </listitem>
144             <para>  </para>
145             <listitem>
146                 <emphasis role="bold">Newton :</emphasis> ici, nous utilisons un solveur direct dense sur le système linéaire :
147                 <para>
148                     <latex scilab:localized="true">
149                         M[y_{n(m+1)}-y_{n(m)}]=-G(y_{n(m)}), \hspace{4 mm} M \approx I-\gamma J, \hspace{2 mm} J=\frac{\partial f}{\partial y}, \hspace{2 mm} et \hspace{2 mm} \gamma = h_n\beta_{n,0}
150                     </latex>
151                 </para>
152             </listitem>
153         </itemizedlist>
154         <para>
155             Dans les deux cas, <emphasis>CVode</emphasis> se sert des valeurs passées pour contrôler l'erreur locale 
156             <emphasis>
157                 y<subscript>n(m)</subscript> - y<subscript>n(0)</subscript>
158             </emphasis>
159             et recalcule 
160             <emphasis>
161                 h<subscript>n</subscript>
162             </emphasis>
163             si l'erreur n'est pas satisfaisante.
164         </para>
165         <para>
166             <emphasis role="bold">
167                 Les choix recommandés sont <emphasis>BDF / Newton</emphasis> pour les problèmes raides et <emphasis>Adams / Functional</emphasis> pour les non-raides.
168             </emphasis>
169         </para>
170         <para>
171             La fonction est appelée entre les activations, parce-qu'une activation est susceptible de modifier le système.
172         </para>
173         <para>
174             Suivant la criticalité de l'événement (son effet sur le problème continu), soit le solveur poursuit avec temps initial et final différents comme si rien ne s'était passé, soit, si le système a été modifié, il faut "réinitialiser à froid" le solveur et le relancer.
175         </para>
176         <para>
177             En moyenne, <emphasis>CVode</emphasis> accepte des tolérances jusqu'à 10<superscript>-16</superscript>. Au-delà, il retourne l'erreur <emphasis>Trop de précision demandée</emphasis>.
178         </para>
179     </refsection>
180     <refsection>
181         <title>Exemples</title>
182         <para>
183             <link type="scilab" linkend="scilab.xcos/xcos/examples/solvers/ODE_Example.zcos">
184                 <inlinemediaobject>
185                     <imageobject>
186                         <imagedata align="center" fileref="../../../examples/solvers/ODE_Example.zcos" valign="middle"/>
187                     </imageobject>
188                 </inlinemediaobject>
189             </link>
190             <scilab:image><![CDATA[
191 loadScicos();
192 loadXcosLibs();
193 importXcosDiagram(SCI + "/modules/xcos/examples/solvers/ODE_Example.zcos");
194 scs_m.props.tol(6) = 1;
195 try xcos_simulate(scs_m, 4); catch disp(lasterror()); end
196 ]]></scilab:image>
197         </para>
198         <para>
199             Le bloc intégrale retourne son état continu, on peut l'évaluer avec <emphasis>BDF / Newton</emphasis> en lançant l'exemple :
200         </para>
201         <para>
202             <programlisting language="example"><![CDATA[
203       // Import du diagramme et réglage du temps final
204       loadScicos();
205       loadXcosLibs();
206       importXcosDiagram("SCI/modules/xcos/examples/solvers/ODE_Example.zcos");
207       scs_m.props.tf = 5000;
208
209       // Sélection de BDF / Newton
210       scs_m.props.tol(6) = 1;
211
212       // Lancement du chrono, de la simulation et affichage du temps
213       tic();
214       try xcos_simulate(scs_m, 4); catch disp(lasterror()); end
215       t = toc();
216       disp(t, "Temps pour BDF / Newton :");
217       ]]></programlisting>
218         </para>
219         <para>
220             La console Scilab affiche :
221             <screen><![CDATA[
222 Temps pour BDF / Newton:
223  13.438
224             ]]></screen>
225         </para>
226         <para>
227             Maintenant, dans le script suivant, on compare la différence de temps entre les méthodes en lançant l'exemple avec les quatre solveurs tour à tour :
228             <link type="scilab" linkend ="scilab.scinotes/xcos/examples/solvers/integCVode.sce">
229                 Ouveture du script
230             </link>
231         </para>
232         <para>
233             Résultats :
234             <screen language="example"><![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             ]]></screen>
247         </para>
248         <para>
249             Les résultats montrent que pour un problème continu non-raide simple, <emphasis>Adams / Functional</emphasis> est le plus rapide.
250         </para>
251     </refsection>
252     <refsection>
253         <title>Voir Aussi</title>
254         <simplelist type="inline">
255             <member>
256                 <link linkend="LSodar">LSodar</link>
257             </member>
258             <member>
259                 <link linkend="RK">Runge-Kutta 4(5)</link>
260             </member>
261             <member>
262                 <link linkend="DoPri">Dormand-Prince 4(5)</link>
263             </member>
264             <member>
265                 <link linkend="RKImp">Runge-Kutta Implicit 4(5)</link>
266             </member>
267             <member>
268                 <link linkend="IDA">IDA</link>
269             </member>
270             <member>
271                 <link linkend="DDaskr">DDaskr</link>
272             </member>
273             <member>
274                 <link linkend="Comparaisons">Comparaisons</link>
275             </member>
276             <member>
277                 <link linkend="ode">ode</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             <ulink url="https://computation.llnl.gov/casc/sundials/documentation/documentation.html">Documentation Sundials</ulink>
297         </para>
298     </refsection>
299 </refentry>