correction equation in sci_daskr
[scilab.git] / scilab / modules / differential_equations / src / cpp / checkodeerror.cpp
1 /*
2 * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3 * Copyright (C) 2011 - DIGITEO - Cedric DELAMARRE
4 *
5 * This file must be used under the terms of the CeCILL.
6 * This source file is licensed as described in the file COPYING, which
7 * you should have received as part of this distribution.  The terms
8 * are also available at
9 * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
10 *
11 */
12 /*--------------------------------------------------------------------------*/
13
14 #include "checkodeerror.hxx"
15
16 extern "C"
17 {
18 #include "sciprint.h"
19 #include "localization.h"
20 #include "configvariable_interface.h"
21 }
22 // return 0 = ok, return 1 = error, return 2 = warning
23 int checkOdeError(int meth, int istate)
24 {
25     switch (meth)
26     {
27         case 0 : // lsoda
28         case 3 : // lsodar
29         {
30             if (istate == -7)
31             {
32                 sciprint(_("Work space insufficient to finish (see messages).\n"));
33                 return 1;
34             }
35         }
36         case 1 : // lsode | lsodi (adams)
37         case 2 : // lsode | lsodi (stiff)
38         {
39             if (istate == -1)
40             {
41                 sciprint(_("Excess work done on this call (perhaps wrong jacobian type).\n"));
42                 return 1;
43             }
44             else if (istate == -2)
45             {
46                 sciprint(_("Excess accuracy requested (tolerances too small).\n"));
47                 return 1;
48             }
49             else if (istate == -3)
50             {
51                 sciprint(_("Illegal input detected (see printed message).\n"));
52                 return 1;
53             }
54             else if (istate == -4)
55             {
56                 sciprint(_("Repeated error test failures (check all inputs).\n"));
57                 return 1;
58             }
59             else if (istate == -5)
60             {
61                 sciprint(_("Repeated convergence failures (perhaps bad jacobian supplied or wrong choice of jacobian type or tolerances).\n"));
62                 return 1;
63             }
64             else if (istate == -6)
65             {
66                 sciprint(_("Error weight became zero during problem. (solution component i vanished, and atol or atol(i) = 0.)\n"));
67                 return 1;
68             }
69             else if (istate == -7) // only used with impl (lsodi)
70             {
71                 sciprint(_("The user-supplied subroutine res set its error flag (ires = 3) despite repeated tries by lsodi to avoid that condition.\n"));
72                 return 1;
73             }
74             else if (istate == -8) // only used with impl (lsodi)
75             {
76                 sciprint(_("istate was 0 on input but lsodi was unable to compute the initial value of dy/dt.\n"));
77                 return 1;
78             }
79             break;
80         }
81         case 4 : // lsdisc (discrete)
82         {
83             if (istate < 0) // from lsdisc.f :
84             {
85                 // istate = 2 if lsdisc was successful, negative otherwise...
86                 return 1;
87             }
88             break;
89         }
90         case 5 : // lsrgk (rk)
91         {
92             if (istate == -1) // from lsrgk.f
93             {
94                 return 1;
95             }
96             break;
97         }
98         case 6 : // rkf45 (rkf)
99         {
100             switch (istate)
101             {
102                 case 3:
103                 {
104                     if (getWarningMode())
105                     {
106                         sciprint(_("Integration was not completed because relative error tolerance was too small. rerr has been increased appropriately for continuing.\n"));
107                     }
108                     return 2;
109                 }
110                 case 4:
111                 {
112                     if (getWarningMode())
113                     {
114                         sciprint(_("Integration was not completed because more than 3000 derivative evaluations were needed. This is approximately 500 steps.\n"));
115                     }
116                     return 2;
117                 }
118                 case 5:
119                 {
120                     sciprint(_("Integration was not completed because solution vanished making a pure relative error test impossible. Must use non-zero aerr to continue. Using the one-step integration mode for one step is a good way to proceed.\n"));
121                     return 1;
122                 }
123                 case 6:
124                 {
125                     sciprint(_("Integration was not completed because requested accuracy could not be achieved using smallest allowable stepsize. User must increase the error tolerance before continued integration can be attempted.\n"));
126                     return 1;
127                 }
128                 case 7:
129                 {
130                     sciprint(_("It is likely that rkf45 is inefficient for solving this problem. Too much output is restricting the natural stepsize choice. Use the one-step integrator mode.\n"));
131                     return 1;
132                 }
133                 case 8:
134                 {
135                     sciprint(_("invalid input parameters : atol and rtol must be greater than 0.\n"));
136                     return 1;
137                 }
138                 default :
139                     break;
140             }
141             break;
142         }
143         case 7 : // rksimp (fix)
144         {
145             if (istate == 3)
146             {
147                 return 1;
148             }
149             else if (istate == 4)
150             {
151                 sciprint(_("Inappropriate error tolerance.\n"));
152                 return 1;
153             }
154             break;
155         }
156     }
157     return 0;
158 }
159
160 int checkError(int idid, std::string strName)
161 {
162     switch (idid)
163     {
164         case 4 ://Only used in dasrt
165         {
166             //One or more root found at t
167             return 2;
168         }
169         case 3 ://The integration to TOUT was successfully completed (T=TOUT) by
170         {
171             //stepping past TOUT. Y,ydot are obtained by interpolation.
172             return 0;
173         }
174         case 2 : //The integration to TSTOP was successfully completed (T=TSTOP)
175         {
176             return 2;
177         }
178         case 1 : //A step was successfully taken in the intermediate-output mode.
179         {
180             //The code has not yet reached TOUT.
181             return 0;
182         }
183         case -1 : //A large amount of work has been expended (About 500 steps)
184         {
185             if (getWarningMode())
186             {
187                 sciprint(_("To many steps necessary to reached next required time discretization point. Change discretisation of time vector t or decrease accuracy.\n"));
188             }
189             return 2;
190         }
191         case -2 : //The error tolerances are too stringent.
192         {
193             sciprint(_("The error tolerances are too stringent.\n"));
194             return 1;
195         }
196         case -3 :
197         {
198             //The local error test cannot be satisfied because you specified
199             //a zero component in ATOL and the corresponding computed solution
200             //component is zero. Thus, a pure relative error test is impossible
201             //for this component.
202             if (getWarningMode())
203             {
204                 sciprint(_("Atol and computed test value are zero.\n"));
205             }
206             return 2;
207         }
208         case -5 : // only used in daskr
209         {
210             // There were repeated failures in the evaluation
211             // or processing of the preconditioner (in JAC).
212             sciprint(_("Cannot evaluate the preconditioner.\n"));
213             return 1;
214         }
215         case -6 : //Repeated error test failures on the last attempted step.
216         {
217             if (getWarningMode())
218             {
219                 sciprint(_("A singularity in the solution may be present.\n"));
220             }
221             return 2;
222         }
223         case -7 : //The corrector could not converge.
224         {
225             if (getWarningMode())
226             {
227                 sciprint(_("May be inaccurate or ill-conditioned JACOBIAN.\n"));
228             }
229             return 2;
230         }
231         case -8 : //The matrix of partial derivatives is singular.
232         {
233             sciprint(_("Singular partial derivatives matrix (may be redundant equations).\n"));
234             return 1;
235         }
236         case -9 : //The corrector could not converge.
237         {
238             //There were repeated error test failures in this step.
239             if (getWarningMode())
240             {
241                 sciprint(_("Either ill-posed problem or discontinuity or singularity encountered.\n"));
242             }
243             return 2;
244         }
245         case -10 :
246         {
247             if (getWarningMode())
248             {
249                 sciprint(_("External ''res'' return many times with ires=-1.\n"));
250             }
251             return 2;
252         }
253         case -11 : //IRES equal to -2 was encountered and
254         {
255             //control is being returned to the calling program.
256             sciprint(_("Error in external ''res''.\n"));
257             return 1;
258         }
259         case -12 : //DDASSL, dasrt or daskr failed to compute the initial YPRIME.
260         {
261             sciprint(_("failed to compute the initial Ydot.\n"));
262             return 1;
263         }
264         case -13 : // only used in daskr
265         {
266             // An unrecoverable error was encountered inside the user's PSOL routine,
267             // and control is being returned to the calling program.
268             sciprint(_("Error in external psol.\n"));
269             return 1;
270         }
271         case -14 : // only used in daskr
272         {
273             // The Krylov linear system solver could not achieve convergence.
274             sciprint(_("The Krylov linear system did not converge.\n"));
275             return 1;
276         }
277         case -33 :
278         {
279             //The code has encountered trouble from which
280             //it cannot recover. A message is printed
281             //explaining the trouble and control is returned
282             //to the calling program. For example, this occurs
283             //when invalid input is detected.
284             if (getWarningMode())
285             {
286                 sciprint(_("%s encountered trouble.\n"), strName.c_str());
287             }
288             return 2;
289         }
290     }
291
292     return 1;
293 }
294