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