DASP3 Solver by Gustaf Söderlind (1980-10-22). Originally published in,:

```
DASP3 - A Program for the Numerical Integration of Partitioned:
Stiff Ode:s and Differential-Algebraic Systems.
By, Gustaf Söderlind, Department of Numerical Analysis, and
Computing Science, The Royal Institute of Technology, 1980.
Stockholm, Sweden.
```

DASP3 solves system on the form,

\frac{\mathrm{d}y}{\mathrm{d}t} &= f(t,y,z) \;\;\; \text{(N equations)} \\ \varepsilon\frac{\mathrm{d}z}{\mathrm{d}t} &= G(t,y,z)\;\;\; \text{(M equations)}

If is assumed that the first system is non-stiff and that the stiffness of the second system is due to the parameter epsilon, possibly a diagonal matrix.

- State events (root funtions) : False
- Step events (completed step) : False
- Time events : True

Import the solver together with the correct problem:

```
from assimulo.solvers import DASP3ODE
from assimulo.problem import SingPerturbed_Problem
```

Define the problem, such as:

```
def rhs_slow(t,y,z): #Note that y and z are 1-D numpy arrays.
return N.array([1.0]) #Note that the return must be numpy array, NOT a scalar.
def rhs_fast(t,y,z): #Note that y and z are 1-D numpy arrays.
return N.array([1.0]) #Note that the return must be numpy array, NOT a scalar.
yy0 = [1.0]
zz0 = [1.0]
t0 = 1.0
```

Create a problem instance:

```
mod = SingPerturbed_Problem(rhs_slow, rhs_fast, yy0, zz0, t0)
```

Note

For complex problems, it is recommended to check the available *examples* and the documentation in the problem class, `SingPerturbed_Problem`

. It is also recommended to define your problem as a subclass of `SingPerturbed_Problem`

.

Warning

When subclassing from a problem class, the function for calculating the right-hand-side (for ODEs) must be named *rhs* and in the case with a residual function (for DAEs) it must be named *res*.

Create a solver instance:

```
sim = DASP3ODE(mod)
```

Modify (optionally) the solver parameters.

Parameters:

`atol`

Defines the absolute tolerance(s) that is to be used by the solver.`backward`

Specifies if the simulation is done in reverse time.`clock_step`

Specifies if the elapsed time of an integrator step should be timed or not.`display_progress`

This option actives output during the integration in terms of that the current integration is periodically printed to the stdout.`num_threads`

This options specifies the number of threads to be used for those solvers that supports it.`report_continuously`

This options specifies if the solver should report the solution continuously after steps.`rtol`

Defines the relative tolerance that is to be used by the solver.`store_event_points`

This options specifies if the solver should save additional points at the events, t_e^-, t_e^+.`time_limit`

This option can be used to limit the time of an integration.`verbosity`

This determines the level of the output.

Simulate the problem:

Information:

`DASP3ODE.get_options()`

Returns the current solver options.`DASP3ODE.get_supports()`

Returns the functionality which the solver supports.`DASP3ODE.get_statistics()`

Returns the run-time statistics (if any).`DASP3ODE.get_event_data()`

Returns the event information (if any).`DASP3ODE.print_event_data()`

Prints the event information (if any).`DASP3ODE.print_statistics()`

Prints the run-time statistics for the problem.