v2.2.0

Version 2.2.0 of libroadrunner has a variety of updates, including:

• Now uses LLVM13, providing faster compilation and execution of models.
  • In addition to the old MCJit system, we provide support for an entirely new Jit system called LLJit which uses llvm-13's Orc Jit v2 api. LLJit has user configurable optimization flags "none", "less", 'default" and "aggressive". Aggressive optimization provides faster Jit compiled sbml models, but takes longer to compile whereas bypassing optimizations with "none" compiles faster but simulates slower.
  • The LLJit system in our hands has proved faster than the previous MC-JIT. MC-JIT is still the default, but switching to ORC-JIT can be enabled in the options; in future releases, ORC-JIT will likely become the new default, once we're sure that no unexpected problems emerge. When this happens, we will deprecate the MCJit and eventually remove it. Meanwhile, we have constructed the switchable jit compiler feature using dependency injection which makes for easier additions of new jit engines in future, such as lazy compilation.
• Various speedups have been incorporated to increase the speed of model loading, including streamlined parsing of the SBML, and using a new version of libSBML for model access for some functions.
• It is now possible to parallelize roadrunner without data races since critical sections are locked with std::mutex.
• A hashmap-like container called RoadRunnerMap has been built for handling parallel model loading, which is the most computationally intensive part of roadrunner. Parallelism is abstracted away from the user and is presented with a dict-like interface in python #925 .
• Roadrunner objects in Python are now picklable, enabling users to use roadrunner with python parallel processing libraries like multiprocessing.
• Support for sbml distrib package
• Support for integrating models at user specified specific time points, rather than needing to simulate at regular intervals.
• The model saving/loading feature is now more robust. The save state version is connected to roadrunner's version, which allows users to load and save state from roadrunner versions with the different micro versions, but not major or minor versions.
• A bug was fixed (#910) where the calculated Jacobian would sometimes be incorrect if the initial compartment volumes were changed.
• A bug was fixed where roadrunner would incorrectly refuse to calculate certain elasticities.
• A bug in the install tree was fixed, whereby missing header files prevented using roadrunner as a C++ library.

v2.1.3

Bugfix release! New since 2.1.1:

• NamedArray working better in Python
• The 'simulate' function no longer retains extra information from previous calls, particularly the 'times' vector argument.

v2.1.2

Fixed problem with NamedArray repr vs str.

v2.1.1 experimental

Experimental release of roadrunner v2.1.1

Changes since 2.1.0:

• Bug fix: conversion of NamedArray more robust.

v2.1.1

Roadrunner v2.1.1 full release

Changes since 2.1.0:

• Bug Fix: conversion of NamedArray more robust.

v2.1.0

Full release of roadrunner. The new features since the experimental 2.0.10 release include:

• Ability to pickle the roadrunner object.
• Save state in memory as well as to file whereas before you could only save state to file.
• New argument 'times' to the 'simulate' function for requested output times.
• More complete support for SBML L3v2 (particularly the use of empty objects and use of boolean values in numeric contexts, and visa versa).
• Can set/get the id and name of the model from the roadrunner object.
• Allow negative start times in 'simulate'.
• Re-introduce rrplugins that had been dropped when the new plugin system was devised.
• Add set/getHasOnlySubstanceUnits to the roadrunner objects for species.
• Functions that had been marked as 'deprecated' are no longer marked as such.
• Implemented two new steady state solvers, newton and linesearch which use sundials library.
• Implemented support for time series sensitivities.

Bug fix highlights:

• NamedArray objects more robust.
• Various memory leaks fixed.
• Clean up Gillespie simulation options.
• 'reset' and 'resetAll' now function as expected: 'reset' only resets variables changed by reactions and rate rules; 'resetAll' now resets all variables. Both use current 'init(x)' values, if they were changed from model load. 'resetToOrigin' continues to work as before, resetting everything back to its initially-loaded state.

v2.0.10

This release is basically the same as v2.0.9 but with a fix to the roadrunner.testing subpackage in that we now also package and distribute the TestModelFactory binary.

v2.0.9

In order of implementation, here are the list of additions in v2.0.9

• More unit tests for C++ API using conventional Googletest

• More unit tests for Python API using conventional unittests module

• Added developers documentation

• Refactoring of IntegratorFactory and SteadyStateSolverFactory. Their logic is identical and so there is no need for duplicated code. The logic was refactored into a superclass RegistrationFactory and Integrator/SteadyStateSolver Factories now derive from them. SensitivitySolverFactory was added in a similar fashion.

• Removal of the "Registrar" system. Until now each Solver class needed a side class classed SolverRegistrar. They all do the same thing. This is not only requires twice as many classes but also required static and non-static version of the same methods in the Solver classes. The problem was resolved by introducing a Registrable interface which is a superclass of Solver. The registration system is the same, but the implementation is more elegant (extendable, maintainable etc.). Furthermore, there used to be a manager SolverFactoryMgr class. This was found to be superfluous (and abuse of abstraction/encapsulation concepts of OOP) - the job of constructing instances of Solver objects has been transferred to the RegistrationFactorys themselves.

• Implemented a rr::Matrix<T> template type, which is derived from the ls::Matrix type. The issue is that roadrunners main data type for results is a type from rr-libstruct in the dependencies package. However, we need to be able to maintain/extend/tweak this type. Instead of moving rr-libstruct from the dependencies package, this release implements a type rr:Matrix<T> that derives from ls::Matrix<T> and extends it to include operations such as comparison operators (operator== and operator!=) as well as an almostEquals for floating point comparisons and sorting rows/columns by row and column names.

• Implemented a rr::Matrix3D<IndexType, DataType> type. This was mainly implemented for storing results of a time series sensitivity analysis, which is a 3D matrix, but has been generalized so that any data type can be stored and any data type can be used as an index. Since time series sensitivities requires rr::Matrix3D<double, double>, this is the main data type that the Matrix3D has been tested with at this time. The IndexType is used to store time whereas the DataType is used to store sensitivity data at each time point.

• Bugfix in CVODEIntegrator where initial concentrations were always 0 and not updated inside CVODEIntegrator but instead by the RoadRunner class. This caused a bug whereby the CVODEIntegrator could not be used as a stand alone class.

• Implemented a new set of interfaces for SensitivitySolver that derives from Solver and distinguishes between TimeSeriesSensitivitySolver and SteadyStateSensitivitySolver. The main difference between these interfaces is that the return types of the main solve methods are either 3D or 2D matrices respectively. Note - SteadyStateSensitivitySolver is just a stub to be implemented in a future version.

• Implemented a ForwardSensitivitySolver class that implements the TimeSeriesSensitivitySolver interface. This class uses sundials cvodes for both integrating the model and for solving the sensitivity equations at each time step. One option for the design is to inherit from Solver (via TimeSeriesSensitivitySolver and SensitivitySolver) and from CVODEIntegrator. This works but requires changing solver types to use virtual inheritance because of the introduced diamond inheritance problem. Instead, we opt to use composition instead of inheritance and use the CVODEIntegrator for the main integration routines for code reuse. Options for ForwardSensitivitySolver include choosing parameters for sensitivity analysis (vs all model variables), choosing the nonlinear solver (newton vs fixed point), choosing finite difference approx method (central or forward) and choosing the method of computing sensitivities (either simultaneous or staggered).

• Implemented a typemap in roadrunner's swig-Python bindings for converting rr::Matrix3D<double, double> to a 3D numpy.ndarray. The actual return type is a 4-tuple: (1d time array, 3d results array, rownames, column names). The NamedArray type was not used because it is Python wizardry.

• Added some interfaces to the TestModelFactory test suite so that we can test structural properties, jabobians, mca and eigenvalues using this test suite. These are swigged so that we can implement the same tests from both C++ and Python. Python test suits have been added that use unittest and they are built in such a way that requires minimal effort to add a test case (developers would add a new TestModel to TestModelFactory, implement the desired interfaces and then the relevant test methods should already work.

• Modified Azure pipelines so that the "other" Python tests are actually executed. We make use pytest to easily find and run roadrunner-python tests in a Python standard way.

• Solver types have a number of methods inside RoadRunner class. They are: getSolver, getSolverByName, makeSolver, getExistingSolverNames, getRegisteredSolverNames, setSolver, SolverExists, replacing solver with either Integrator, SteadyState or Sensitivity. These have been added for Sensitivity solver and the missing ones added for SteadyState solvers. Notably, there is a lot of duplicated logic here, it should be the subject of future efforts to abstract this logic and to implement it in a generalized way.

• Added an "Examples" section to the documentation, which is populated only by sensitivity examples at this time.

v2.0.8

This is an experimental release. It contains several big changes, including support for kinsol steady state solver (basic newton and linesearch strategies). Other changes are backend only and shouldnt be noticed by the user

2.0.1

Small updates to v2.0.0 to facilitate compilation on MacOSX 10.9