Module Ida

module Ida: sig .. end
Variable-step solution of DAE initial value problems with zero-crossing detection.

This module solves numerically problems of the form $F(t, y, \dot{y})=0$, $y(t_0) = y_0$, $\dot{y}(t_0)=\dot{y}_0$.

This documented interface is structured as follows.

  1. Linear solvers
  2. Tolerances
  3. Initialization
  4. Solution
  5. Modifying the solver
  6. Querying the solver
  7. Additional root finding functions
  8. Exceptions

Author(s): Timothy Bourke (Inria/ENS), Jun Inoue (Inria/ENS), Marc Pouzet (UPMC/ENS/Inria)
Version: 2.7.0

type ('d, 'k) session = ('d, 'k) session 
A session with the IDA solver.

An example session with Ida (ida_skel.ml):

(* 1. Define a residual function. *)
let resf t v v' r =
  r.{0} <- v.{2}  -. v'.{0};
  r.{1} <- v.{3}  -. v'.{1};
  r.{2} <- v'.{2} -. v.{4} *. v.{0};
  r.{3} <- v'.{3} -. v.{4} *. v.{1} +. 9.81;
  r.{4} <- v.{2}*.v.{2} +. v'.{2}*.v.{0} +. v.{3}*.v'.{1} +. v'.{3}*.v.{1}

(* 2. Optionally define a root function. *)
let g t v v' gout = gout.{0} <- v.{0} -. v.{1} *. 0.5774

(* 3. Set vector of initial values.
      The length of this vector determines the problem size. *)
let vd = Sundials.RealArray.of_list [ 0.9848; 0.1736; 0.0; 0.0; 0.0 ]
let v  = Nvector_serial.wrap vd
let v' = Nvector_serial.make 5 0.0

(* 4. Create and initialize a solver session.
      This will initialize a specific linear solver and the root-finding
      mechanism, if necessary. *)
let s = Ida.(init (Dls.dense ())
                  (SStolerances (1e-9, 1e-9))
                  resf ~roots:(1, g) 0.0 v v');;

(* 5. Set optional inputs, e.g.,
      call [set_*] functions to change solver parameters. *)
Ida.set_stop_time s 10.0;
Ida.set_all_root_directions s Sundials.RootDirs.Decreasing;;

(* 6. Correct initial values *)
let vids = Nvector_serial.make 5 Ida.VarId.differential;;
(Nvector_serial.unwrap vids).{4} <- Ida.VarId.algebraic;

Ida.set_suppress_alg s ~varid:vids true;
Ida.calc_ic_ya_yd' s ~y:v ~y':v' 0.1;;

(* 7. Advance the solution in time,
      by repeatedly calling [solve_normal] or [solve_one_step]. *)
let rec go (t, r) =
  Printf.printf "% .10e\t% .10e\t% .10e\t% .10e\t% .10e\t% .10e\n"
                t vd.{0} vd.{1} vd.{2} vd.{3} vd.{4};
  match r with
  | Ida.Success -> go (Ida.solve_normal s (t +. 0.05) v v')
  | Ida.RootsFound -> begin
         vd.{2} <- -. 0.5 *. vd.{2};
         vd.{3} <- -. 0.5 *. vd.{3};
         Ida.reinit s t v v';
         Ida.calc_ic_ya_yd' ~y:v ~y':v' s ~varid:vids (t +. 0.05);
          go (t, Ida.Success)
      end
  | Ida.StopTimeReached -> ();;

Printf.printf "time\tx\ty\tx'\ty'\tp\n";;
go (0.0, Ida.Success);;

(* 8. Get optional outputs,
      call the [get_*] functions to examine solver statistics. *)
let ns = Ida.get_num_steps s
    

See sundials: Skeleton of main program
type [> Nvector_serial.kind ] serial_session = (Sundials.RealArray.t, [> Nvector_serial.kind ] as 'a) session 
Alias for sessions based on serial nvectors.

Linear solvers


type ('data, 'kind) linear_solver = ('data, 'kind) linear_solver 
Linear solvers used by Ida.
See sundials: Linear Solver Specification Functions
type [> Nvector_serial.kind ] serial_linear_solver = (Nvector_serial.data, [> Nvector_serial.kind ] as 'a) linear_solver 
Alias for linear solvers that are restricted to serial nvectors.
type 'd double = 'd * 'd 
Workspaces with two temporary vectors.
type 'd triple = 'd * 'd * 'd 
Workspaces with three temporary vectors.
type ('t, 'd) jacobian_arg = ('t, 'd) jacobian_arg = {
   jac_t : float; (*
The independent variable.
*)
   jac_y : 'd; (*
The dependent variable vector.
*)
   jac_y' : 'd; (*
The derivative vector (i.e. $\frac{\mathrm{d}y}{\mathrm{d}t}$).
*)
   jac_res : 'd; (*
The current value of the residual vector.
*)
   jac_coef : float; (*
The coefficient $c_j$ in $J = \frac{\partial F}{\partial y} + c_j \frac{\partial F}{\partial\dot{y}}$.
*)
   jac_tmp : 't; (*
Workspace data.
*)
}
Arguments common to Jacobian callback functions.
See sundials: IDADlsDenseJacFn
See sundials: IDADlsBandJacFn
See sundials: IDASpilsJacTimesVecFn
See sundials: IDASpilsPrecSolveFn
See sundials: IDASpilsPrecSetupFn
type bandrange = bandrange = {
   mupper : int; (*
The upper half-bandwidth.
*)
   mlower : int; (*
The lower half-bandwidth.
*)
}
The range of nonzero entries in a band matrix.
module Dls: sig .. end
Direct Linear Solvers operating on dense and banded matrices.
module Sls: sig .. end
Sparse Linear Solvers.
module Spils: sig .. end
Scaled Preconditioned Iterative Linear Solvers.
module Alternate: sig .. end
Alternate Linear Solvers.

Tolerances


type 'data error_weight_fun = 'data -> 'data -> unit 
Functions that set the multiplicative error weights for use in the weighted RMS norm. The call efun y ewt takes the dependent variable vector y and fills the error-weight vector ewt with positive values or raises Sundials.NonPositiveEwt. Other exceptions are eventually propagated, but should be avoided (efun is not allowed to abort the solver).
type ('data, 'kind) tolerance = 
| SStolerances of float * float (*
(rel, abs) : scalar relative and absolute tolerances.
*)
| SVtolerances of float * ('data, 'kind) Nvector.t (*
(rel, abs) : scalar relative and vector absolute tolerances.
*)
| WFtolerances of 'data error_weight_fun (*
Set the multiplicative error weights for the weighted RMS norm.
*)
Tolerance specifications.
val default_tolerances : ('data, 'kind) tolerance
A default relative tolerance of 1.0e-4 and absolute tolerance of 1.0e-8.

Initialization


type 'd resfn = float -> 'd -> 'd -> 'd -> unit 
Residual functions that define a DAE problem. They are passed four * arguments: Within the function, raising a Sundials.RecoverableFailure exception indicates a recoverable error. Any other exception is treated as an unrecoverable error.

y, y', and r should not be accessed after the function returns.

See sundials: IDAResFn
type 'd rootsfn = float -> 'd -> 'd -> Sundials.RealArray.t -> unit 
Called by the solver to calculate the values of root functions. These ‘zero-crossings’ are used to detect significant events. The function is passed four arguments:
y, y', and gout should not be accessed after the function has returned.

See sundials: IDARootFn
val init : ('d, 'kind) linear_solver ->
('d, 'kind) tolerance ->
'd resfn ->
?varid:('d, 'kind) Nvector.t ->
?roots:int * 'd rootsfn ->
float ->
('d, 'kind) Nvector.t -> ('d, 'kind) Nvector.t -> ('d, 'kind) session
Creates and initializes a session with the solver. The call
init linsolv tol f ~varid:varid ~roots:(nroots, g) t0 y0 y'0
has as arguments: This function does everything necessary to initialize a session, i.e., it makes the calls referenced below. The Ida.solve_normal and Ida.solve_one_step functions may be called directly.
See sundials: IDACreate/IDAInit
See sundials: IDARootInit
See sundials: Linear solvers
See sundials: IDASStolerances
See sundials: IDASVtolerances
See sundials: IDAWFtolerances
See sundials: IDAEwtFn
See sundials: IDASetId
val no_roots : int * 'd rootsfn
A convenience value for signalling that there are no roots to monitor.

Initial Condition Calculation


module VarId: sig .. end
Symbolic names for constants used when calculating initial values or supressing local error tests.
val set_id : ('d, 'k) session -> ('d, 'k) Nvector.t -> unit
Class components of the state vector as either algebraic or differential. These classifications are required by Ida.calc_ic_ya_yd' and Ida.set_suppress_alg. See also Ida.VarId.
See sundials: IDASetId
val set_suppress_alg : ('d, 'k) session -> ?varid:('d, 'k) Nvector.t -> bool -> unit
Indicates whether or not to ignore algebraic variables in the local error test. When ignoring algebraic variables (true), a varid vector must be specified either in the call or by a prior call to Ida.init or Ida.set_id. Suppressing local error tests for algebraic variables is discouraged for DAE systems of index 1 and encouraged for systems of index 2 or more.
See sundials: IDASetId
See sundials: IDASetSuppressAlg
val calc_ic_y : ('d, 'k) session -> ?y:('d, 'k) Nvector.t -> float -> unit
Computes the initial state vector for certain index-one problems. All components of $y$ are computed, using $\dot{y}$, to satisfy the constraint $F(t_0, y_0, \dot{y}_0) = 0$. If given, the ~y vector is filled with the corrected values. The last argument is the first vale of $t$ at which a solution will be requested. A Ida.reinit is required before calling this function after Ida.solve_normal or Ida.solve_one_step.
Raises IdNotSet Variable ids have not been set (see Ida.set_id).
See sundials: IDACalcIC (IDA_Y_INIT)
See sundials: IDAGetConsistentIC
val calc_ic_ya_yd' : ('d, 'k) session ->
?y:('d, 'k) Nvector.t ->
?y':('d, 'k) Nvector.t -> ?varid:('d, 'k) Nvector.t -> float -> unit
Computes the algebraic components of the initial state and derivative vectors for certain index-one problems. The elements of $y$ and $\dot{y}$ marked as algebraic are computed, using $\dot{y}$, to satisfy the constraint $F(t_0, y_0, \dot{y}_0) = 0$. The variable ids must be given in ~varid or by a prior call to Ida.init or Ida.set_id. If given, the ~y and ~y' vectors are filled with the corrected values. The last argument is the first vale of $t$ at which a solution will be requested. A Ida.reinit is required before calling this function after Ida.solve_normal or Ida.solve_one_step.
Raises IdNotSet Variable ids have not been set (see Ida.set_id).
See sundials: IDACalcIC (IDA_YA_YDP_INIT)
See sundials: IDASetId
See sundials: IDAGetConsistentIC
val set_nonlin_conv_coef_ic : ('d, 'k) session -> float -> unit
Specifies the positive constant in the nonlinear convergence test of the initial condition calculation.
See sundials: IDASetNonlinConvCoefIC
See sundials: IDACalcIC
val set_max_num_steps_ic : ('d, 'k) session -> int -> unit
Specifies the maximum number of steps taken in attempting to reach a given output time in the initial condition calculation.
See sundials: IDASetMaxNumStepsIC
See sundials: IDACalcIC (IDA_YA_YDP_INIT)
val set_max_num_jacs_ic : ('d, 'k) session -> int -> unit
Specifies the maximum number of approximate Jacobian or preconditioner evaluations allowed when the Newton iteration appears to be slowly converging.
See sundials: IDASetMaxNumJacsIC
See sundials: IDACalcIC
val set_max_num_iters_ic : ('d, 'k) session -> int -> unit
Specifies the maximum number of Newton iterations allowed in any one attempt to calculate initial conditions.
See sundials: IDASetMaxNumItersIC
See sundials: IDACalcIC
val set_max_backs_ic : ('d, 'k) session -> int -> unit
Specifies the maximum number of linesearch backtracks allowed in any Newton iteration, when solving the initial conditions calculation problem.
Since 2.7.0
Raises Sundials.NotImplementedBySundialsVersion Feature not available.
See sundials: IDASetMaxBacksIC
See sundials: IDACalcIC
val set_line_search_ic : ('d, 'k) session -> bool -> unit
Enables (true) or disables (false) the linesearch algorithm in the initial condition calculation.
See sundials: IDASetLineSearchOffIC
See sundials: IDACalcIC
val set_step_tolerance_ic : ('d, 'k) session -> float -> unit
Specifies a positive lower bound on the Newton step in the initial condition calculation.
See sundials: IDASetStepToleranceIC
See sundials: IDACalcIC
val get_num_backtrack_ops : ('d, 'k) session -> int
Returns the number of backtrack operations during Ida.calc_ic_ya_yd' or Ida.calc_ic_y.
See sundials: IDAGetNumBacktrackOps

Solution


type solver_result = 
| Success (*
The solution was advanced. (IDA_SUCCESS)
*)
| RootsFound (*
A root was found. See Ida.get_root_info. (IDA_ROOT_RETURN)
*)
| StopTimeReached (*
The stop time was reached. See Ida.set_stop_time. (IDA_TSTOP_RETURN)
*)
Values returned by the step functions. Failures are indicated by exceptions.
See sundials: IDASolve
val solve_normal : ('d, 'k) session ->
float ->
('d, 'k) Nvector.t -> ('d, 'k) Nvector.t -> float * solver_result
Integrates a DAE system over an interval. The call tret, r = solve_normal s tout yout y'out has as arguments It returns tret, the time reached by the solver, which will be equal to tout if no errors occur, and, r, a Ida.solver_result.
Raises
See sundials: IDASolve (IDA_NORMAL)
val solve_one_step : ('d, 'k) session ->
float ->
('d, 'k) Nvector.t -> ('d, 'k) Nvector.t -> float * solver_result
Like Ida.solve_normal but returns after one internal solver step.
See sundials: IDASolve (IDA_ONE_STEP)
val get_dky : ('d, 'k) session -> ('d, 'k) Nvector.t -> float -> int -> unit
Returns the interpolated solution or derivatives. get_dky s dky t k computes the kth derivative of the function at time t, i.e., $\frac{d^\mathtt{k}y(\mathtt{t})}{\mathit{dt}^\mathtt{k}}$, and stores it in dky. The arguments must satisfy $t_n - h_u \leq \mathtt{t} \leq t_n$—where $t_n$ denotes Ida.get_current_time and $h_u$ denotes Ida.get_last_step,— and $0 \leq \mathtt{k} \leq q_u$—where $q_u$ denotes Ida.get_last_order.

This function may only be called after a successful return from either Ida.solve_normal or Ida.solve_one_step.

Raises
See sundials: IDAGetDky
val reinit : ('d, 'k) session ->
?linsolv:('d, 'k) linear_solver ->
?roots:int * 'd rootsfn ->
float -> ('d, 'k) Nvector.t -> ('d, 'k) Nvector.t -> unit
Reinitializes the solver with new parameters and state values. The values of the independent variable, i.e., the simulation time, the state variables, and the derivatives must be given. If the argument ~linsolv is not given, the current linear solver remains unchanged. The argument ~roots works similarly; pass Ida.no_roots to disable root finding.
See sundials: IDAReInit

Modifying the solver (optional input functions)


val set_tolerances : ('d, 'k) session -> ('d, 'k) tolerance -> unit
Set the integration tolerances.
See sundials: IDASStolerances
See sundials: IDASVtolerances
See sundials: IDAWFtolerances
See sundials: IDAEwtFn
val set_error_file : ('d, 'k) session -> Sundials.Logfile.t -> unit
Configure the default error handler to write messages to a file. By default it writes to Sundials.Logfile.stderr.
See sundials: IDASetErrFile
val set_err_handler_fn : ('d, 'k) session -> (Sundials.error_details -> unit) -> unit
Specifies a custom function for handling error messages. The handler must not fail: any exceptions are trapped and discarded.
See sundials: IDASetErrHandlerFn
See sundials: IDAErrHandlerFn
val clear_err_handler_fn : ('d, 'k) session -> unit
Restores the default error handling function.
See sundials: IDASetErrHandlerFn
val set_max_ord : ('d, 'k) session -> int -> unit
Specifies the maximum order of the linear multistep method.
See sundials: IDASetMaxOrd
val set_max_num_steps : ('d, 'k) session -> int -> unit
Specifies the maximum number of steps taken in attempting to reach a given output time.
See sundials: IDASetMaxNumSteps
val set_init_step : ('d, 'k) session -> float -> unit
Specifies the initial step size.
See sundials: IDASetInitStep
val set_max_step : ('d, 'k) session -> float -> unit
Specifies an upper bound on the magnitude of the step size.
See sundials: IDASetMaxStep
val set_stop_time : ('d, 'k) session -> float -> unit
Limits the value of the independent variable t when solving. By default no stop time is imposed.
See sundials: IDASetStopTime
val set_max_err_test_fails : ('d, 'k) session -> int -> unit
Specifies the maximum number of error test failures permitted in attempting one step.
See sundials: IDASetMaxErrTestFails
val set_max_nonlin_iters : ('d, 'k) session -> int -> unit
Specifies the maximum number of nonlinear solver iterations permitted per step.
See sundials: IDASetMaxNonlinIters
val set_max_conv_fails : ('d, 'k) session -> int -> unit
Specifies the maximum number of nonlinear solver convergence failures permitted during one step.
See sundials: IDASetMaxConvFails
val set_nonlin_conv_coef : ('d, 'k) session -> float -> unit
Specifies the safety factor used in the nonlinear convergence test.
See sundials: IDASetNonlinConvCoef
See sundials: IVP Solution
val set_constraints : ('d, 'k) session -> ('d, 'k) Nvector.t -> unit
Specifies a vector defining inequality constraints for each component of the solution vector u. See Sundials.Constraint.
See sundials: IDASetConstraints

Querying the solver (optional output functions)


val get_work_space : ('d, 'k) session -> int * int
Returns the sizes of the real and integer workspaces.
Returns (real_size, integer_size)
See sundials: IDAGetWorkSpace
val get_num_steps : ('d, 'k) session -> int
Returns the cumulative number of internal solver steps.
See sundials: IDAGetNumSteps
val get_num_res_evals : ('d, 'k) session -> int
Returns the number of calls to the residual function.
See sundials: IDAGetNumResEvals
val get_num_lin_solv_setups : ('d, 'k) session -> int
Returns the number of calls made to the linear solver's setup function.
See sundials: IDAGetNumLinSolvSetups
val get_num_err_test_fails : ('d, 'k) session -> int
Returns the number of local error test failures that have occurred.
See sundials: IDAGetNumErrTestFails
val get_last_order : ('d, 'k) session -> int
Returns the integration method order used during the last internal step.
See sundials: IDAGetLastOrder
val get_current_order : ('d, 'k) session -> int
Returns the integration method order to be used on the next internal step.
See sundials: IDAGetCurrentOrder
val get_last_step : ('d, 'k) session -> float
Returns the integration step size taken on the last internal step.
See sundials: IDAGetLastStep
val get_current_step : ('d, 'k) session -> float
Returns the integration step size to be attempted on the next internal step.
See sundials: IDAGetCurrentStep
val get_actual_init_step : ('d, 'k) session -> float
Returns the the value of the integration step size used on the first step.
See sundials: IDAGetActualInitStep
val get_current_time : ('d, 'k) session -> float
Returns the the current internal time reached by the solver.
See sundials: IDAGetCurrentTime
val get_tol_scale_factor : ('d, 'k) session -> float
Returns a suggested factor by which the user's tolerances should be scaled when too much accuracy has been requested for some internal step.
See sundials: IDAGetTolScaleFactor
val get_err_weights : ('d, 'k) session -> ('d, 'k) Nvector.t -> unit
Returns the solution error weights at the current time.
See sundials: IDAGetErrWeights
See sundials: IVP solution (W_i)
val get_est_local_errors : ('d, 'k) session -> ('d, 'k) Nvector.t -> unit
Returns the vector of estimated local errors.
See sundials: IDAGetEstLocalErrors
type integrator_stats = {
   num_steps : int; (*
Cumulative number of internal solver steps.
*)
   num_res_evals : int; (*
Number of calls to the residual function.
*)
   num_lin_solv_setups : int; (*
Number of setups calls to the linear solver.
*)
   num_err_test_fails : int; (*
Number of local error test failures.
*)
   last_order : int; (*
Integration method order used in the last internal step.
*)
   current_order : int; (*
Integration method order to be used in the next internal step.
*)
   actual_init_step : float; (*
Integration step sized used on the first step.
*)
   last_step : float; (*
Integration step size of the last internal step.
*)
   current_step : float; (*
Integration step size to attempt on the next internal step.
*)
   current_time : float; (*
Current internal time reached by the solver.
*)
}
Summaries of integrator statistics.
val get_integrator_stats : ('d, 'k) session -> integrator_stats
Returns the integrator statistics as a group.
See sundials: IDAGetIntegratorStats
val print_integrator_stats : ('d, 'k) session -> Pervasives.out_channel -> unit
Prints the integrator statistics on the given channel.
See sundials: IDAGetIntegratorStats
val get_num_nonlin_solv_iters : ('d, 'k) session -> int
Returns the number of nonlinear (functional or Newton) iterations performed.
See sundials: IDAGetNumNonlinSolvIters
val get_num_nonlin_solv_conv_fails : ('d, 'k) session -> int
Returns the number of nonlinear convergence failures that have occurred.
See sundials: IDAGetNumNonlinSolvConvFails
val get_nonlin_solv_stats : ('d, 'k) session -> int * int
Returns both the numbers of nonlinear iterations performed nniters and nonlinear convergence failures nncfails.
Returns (nniters, nncfails)
See sundials: IDAGetNonlinSolvStats

Additional root-finding functions


val set_root_direction : ('d, 'k) session -> Sundials.RootDirs.d array -> unit
set_root_direction s dir specifies the direction of zero-crossings to be located and returned. dir may contain one entry for each root function.
See sundials: IDASetRootDirection
val set_all_root_directions : ('d, 'k) session -> Sundials.RootDirs.d -> unit
Like Ida.set_root_direction but specifies a single direction for all root functions.
See sundials: IDASetRootDirection
val set_no_inactive_root_warn : ('d, 'k) session -> unit
Disables issuing a warning if some root function appears to be identically zero at the beginning of the integration.
See sundials: IDASetNoInactiveRootWarn
val get_num_roots : ('d, 'k) session -> int
Returns the number of root functions.
val get_root_info : ('d, 'k) session -> Sundials.Roots.t -> unit
Fills an array showing which functions were found to have a root.
See sundials: IDAGetRootInfo
val get_num_g_evals : ('d, 'k) session -> int
Returns the cumulative number of calls made to the user-supplied root function g.
See sundials: IDAGetNumGEvals

Exceptions


exception IllInput
Raised on missing or illegal solver inputs. Also raised if an element of the error weight vector becomes zero during time stepping, or the linear solver initialization function failed, or a root was found both at t and very near t.
See sundials: IDA_ILL_INPUT
exception TooMuchWork
The requested time could not be reached in mxstep internal steps. See Ida.set_max_num_steps
See sundials: IDA_TOO_MUCH_WORK
exception TooMuchAccuracy
The requested accuracy could not be satisfied.
See sundials: IDA_TOO_MUCH_ACC
exception ErrFailure
Too many error test failures within a step. See Ida.set_max_err_test_fails.
See sundials: IDA_ERR_FAIL
exception ConvergenceFailure
Too many convergence test failures within a step, or Newton convergence failed. See Ida.set_max_conv_fails.
See sundials: IDA_CONV_FAIL
exception LinearInitFailure
Linear solver initialization failed.
See sundials: IDA_LINIT_FAIL
exception LinearSetupFailure
Linear solver setup failed in an unrecoverable manner.
See sundials: IDA_LSETUP_FAIL
exception LinearSolveFailure
Linear solver solution failed in an unrecoverable manner.
See sundials: IDA_LSOLVE_FAIL
exception ResFuncFailure
The residual function failed in an unrecoverable manner.
See sundials: IDA_RES_FAIL
exception FirstResFuncFailure
The residual function had a recoverable error when first called.
See sundials: IDA_FIRST_RES_FAIL
exception RepeatedResFuncFailure
Too many convergence test failures, or unable to estimate the initial step size, due to repeated recoverable errors in the residual function.
See sundials: IDA_REP_RES_ERR
exception RootFuncFailure
The rootfinding function failed.
See sundials: IDA_RTFUNC_FAIL
exception ConstraintFailure
No solution satisfying the inequality constraints could be found.
See sundials: IDA_CONSTR_FAIL
exception LinesearchFailure
Linesearch could not find a solution with a step larger than steptol in weighted RMS norm.
See sundials: IDA_LINESEARCH_FAIL
exception NoRecovery
A recoverable error occurred in a callback but no recovery was possible.
See sundials: IDA_NO_RECOVERY
exception BadEwt
A component of the error weight vector, either for the input value or a corrected value, is zero.
See sundials: IDA_BAD_EWT
exception BadK
Raised by Ida.get_dky for invalid order values.
See sundials: IDAGetDky (IDA_BAD_K)
exception BadT
Raised by Ida.get_dky for invalid time values.
See sundials: IDAGetDky (IDA_BAD_T)
exception IdNotSet
Variable ids are required but not set. See Ida.set_id.