Sundials.jl is a Julia package that interfaces to the Sundials library. Sundials (the C library and this package) provides the following:
- CVODE - for integration of ordinary differential equation systems (ODEs).
CVODE treats stiff and nonstiff ODE systems of the form
y' = f(t,y), y(t0) = y0
- CVODES - for integration and sensitivity analysis of ODEs.
CVODES treats stiff and nonstiff ODE systems of the form
y' = f(t,y,p), y(t0) = y0(p)
- IDA - for integration of differential-algebraic equation systems (DAEs).
IDA treats DAE systems of the form
F(t,y,y') = 0, y(t0) = y0, y'(t0) = y0'
- IDAS - for integration and sensitivity analysis of DAEs.
IDAS treats DAE systems of the form
F(t,y,y',p) = 0, y(t0) = y0(p), y'(t0) = y0'(p)
- KINSOL - for solution of nonlinear algebraic systems.
KINSOL treats nonlinear systems of the form
F(u) = 0
Julia is a fast, Matlab-like language that is well suited to modeling and simulations. It's particularly suited for use with Sundials because the functions representing the system will run at nearly the speed of C functions. Julia functions are compiled on the fly (JIT), so it is also possible to quickly recompile a system to model structural changes to the system.
I use Sundials in Sims, a Julia package to support equation-based modeling for simulations. Sims is like a lite version of Modelica. Sims can currently use Sundials or DASSL.
This package closely follows the Sundials C API. At a slightly higher level, many (but not all) Sundials.jl functions support passing Julia objects (like Arrays) instead of Sundials objects (like N_Vectors). See src/Sundials.jl for examples of how the higher-level interfacing works.
The Julia package Clang.jl was used to wrap Sundials. This directly uses Sundials' headers sort-of like SWIG. This is great work by Isaiah--it didn't take me much work to package a pretty complete interface to Sundials. For the wrapping code, see src/wrap_sundials.jl.
Because of Clang.jl, Sundials.jl provides good coverage of the Sundials library (the serial version).
Three functions kinsol
, ode
, and dae
are provided as high-level,
very simple functions. Here is an example for ode
:
using Sundials
function f(t, y, ydot)
ydot[1] = -0.04*y[1] + 1.0e4*y[2]*y[3]
ydot[3] = 3.0e7*y[2]*y[2]
ydot[2] = -ydot[1] - ydot[3]
end
t = [0.0, 4 * logspace(-1., 7., 9)]
res = Sundials.ode(f, [1.0, 0.0, 0.0], t)
Feedback on these simple functions is encouraged. Once Julia has keyword arguments for functions, it will be easier to add features to these basic functions.
See the examples directory.
Three-Body Problem is a notebook with a more thoroughly explained example.
Please note that this is a developer preview. There could be bugs, and everything is subject to change. Of note are:
- You must have the Sundials installed.
- The API that matches the Sundials C API should be stable.
- The simplified API is not stable.
- There is no documentation for this package. Please see the general C documentation for Sundials. The API should be identical.
- Macros like
DENSE_ELEM
are not available. - Nothing is (yet) exported from the module. You need to put
Sundials.
in front of everything. - Parts of the Sundials API that access C structures are difficult. One can use the StrPack package to read or write to these structures, but nothing is built into this package. See this CVODE example.
- The parallel versions of Sundials have been wrapped, but I doubt that they are useable from Julia. Julia doesn't have an MPI interface that I am aware of.
- More work could be done to provide a better interface to N_Vectors.