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