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 "configvariable_interface.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 -5 : // only used in daskr
 207         {
 208             // There were repeated failures in the evaluation
 209             // or processing of the preconditioner (in JAC).
 210             sciprint(_("Cannot evaluate the preconditioner.\n"));
 211             return 1;
 212         }
 213         case -6 : //Repeated error test failures on the last attempted step.
 214         {
 215             if (getWarningMode())
 216             {
 217                 sciprint(_("A singularity in the solution may be present.\n"));
 218             }
 219             return 2;
 220         }
 221         case -7 : //The corrector could not converge.
 222         {
 223             if (getWarningMode())
 224             {
 225                 sciprint(_("May be inaccurate or ill-conditioned JACOBIAN.\n"));
 226             }
 227             return 2;
 228         }
 229         case -8 : //The matrix of partial derivatives is singular.
 230         {
 231             sciprint(_("Singular partial derivatives matrix (may be redundant equations).\n"));
 232             return 1;
 233         }
 234         case -9 : //The corrector could not converge.
 235         {
 236             //There were repeated error test failures in this step.
 237             if (getWarningMode())
 238             {
 239                 sciprint(_("Either ill-posed problem or discontinuity or singularity encountered.\n"));
 240             }
 241             return 2;
 242         }
 243         case -10 :
 244         {
 245             if (getWarningMode())
 246             {
 247                 sciprint(_("External ''res'' return many times with ires=-1.\n"));
 248             }
 249             return 2;
 250         }
 251         case -11 : //IRES equal to -2 was encountered and
 252         {
 253             //control is being returned to the calling program.
 254             sciprint(_("Error in external ''res''.\n"));
 255             return 1;
 256         }
 257         case -12 : //DDASSL, dasrt or daskr failed to compute the initial YPRIME.
 258         {
 259             sciprint(_("failed to compute the initial Ydot.\n"));
 260             return 1;
 261         }
 262         case -13 : // only used in daskr
 263         {
 264             // An unrecoverable error was encountered inside the user's PSOL routine,
 265             // and control is being returned to the calling program.
 266             sciprint(_("Error in external psol.\n"));
 267             return 1;
 268         }
 269         case -14 : // only used in daskr
 270         {
 271             // The Krylov linear system solver could not achieve convergence.
 272             sciprint(_("The Krylov linear system did not converge.\n"));
 273             return 1;
 274         }
 275         case -33 :
 276         {
 277             //The code has encountered trouble from which
 278             //it cannot recover. A message is printed
 279             //explaining the trouble and control is returned
 280             //to the calling program. For example, this occurs
 281             //when invalid input is detected.
 282             if (getWarningMode())
 283             {
 284                 sciprint(_("encountered trouble.\n"));
 285             }
 286             return 2;
 287         }
 288     }
 289
 290     return 1;
 291 }
 292