News

April 20th, 2015, Release 1.3.2 (includes 1.3.1)

libRoadRunner 1.3.2 supports the following features (incorporates changes to 1.3.1)

  • Flag error if Gillespie generates negative amounts
  • Internal bug in Python wrapper that causes errors when setting  conservation flag
  • Fixed moiety conserved errors in the plugin bindings to prepare for release of bifurcation tool.

January 15th, 2015, Release 1.3 (includes 1.2.7)

libRoadRunner 1.3 supports the following features (incorporates changes to 1.2.7):

  • New Python ND array type which inherits from the numpy ndarray, contains row/column name info, and prints the row/col names in nicely formatted output.
  • Added row/column fields to DoubleMatrix, these are populated by a majority of RoadRunner methods.
  • Plotting compatibility between roadrunner and tellurium
  • DoubleMatrix correctly writes csv format to stream\
  • Update to libSBML 5.11
  • Add extra time steps in variable step mode to add timesteps at the exact point of event triggers, results in crisp vertical lines on plots.
  • C++, C and Python documentation updates.
  • New C++11 proxy classes to compile on OSX 10.9
  • Introduce new LLVM symbol caching optimization and scoped cache blocks for read combining results in SIGNIFICANT imporovments in both compile time and run time performance.
  • Memory leak fixes in numpy binding.
  • Code cleanup and new reset option to apply init assignment rules to global params
  • Added SBML version converter to optionaly version convert resulting sbml string  from getSBML and getCurrentSBML
  • Many RoadRunner objects are now properly a Dictionary and methods now accept a  Dictionary interface.
  • SteadyState solvers properly created by factory.
 Version 1.2.7
  • Made the NLEQ steadystate single threaded — it will block all other threads and only let one thread at a time be in the steadyState function.  The FORTRAN77 code that it was written in uses globals for everything, there was no possible way that it was ever thread safe.
  • NLEQ steadystate function now uses a static var to hold a pointer to the model object
  • Added getKMatrix() method to RoadRunner object, updated python and C++ docs to reflect this.
  • Added new ‘eigenr’ and ‘eigenc’ selections to get real and complex values of eigenvalues,  note, the existing ‘eigen’ is the same as ‘eigenr’ — will get real part of eigenvalue.
  • New rrtest testing file format.
  • Removed RoadRunner::getEigenvalues and replaced with getFullEigenValues and  getReducedEigenValues which return the eigenvalues for the respective Jacobians.
  • Support for ‘distrib’ SBML package for random distributions.

September 9th, 2014 , Release 1.2.6

New 1.2.6 final release is on SF.

  • Python dynamic properties are now on the RoadRunner instead of the RoadRunner.model object
  • Fixed bug in dynamic properties where they were not cleared when a new model is loaded.
  • Added boundary species to python dynamics properties
  • Redesign dynamic property generations – new code is much cleaner.
  • Testing files in roadrunner.testing are automatically enumerated and run from roadrunner.testing.test_files
  • Fix for ordering variables correctly when creating an SimulateOptions from a libSBML test suite txt file.
  • If model has comp extension, automatically flatten.- Note, libSBML comp extension has numerous memory issues, comp extension models *might* cause instability.
  • Upgrade to libSBML 5.10.2
  • All logging output is re-directed to the IPython socket when running in the QT IPython console. This allows allows logging messages to show up in the IPython console.
  • Support mixed mode arithmetic.
  • Workarounds for buggy MSVC stdlib functions.
  • Significantly improve error messages for mal-formed SBML models.

August 11th, 2014, Release 1.2.5

New 1.2.5 final release is on SF.

changes:

  • New parallel ensemble function and ‘roadrunner.stochastic’ python module.
  • Added new example files to python package.
  • New function in C API to create RRDataPtr directly from RoadRunner object,
  • RoadRunnerData C++ object is nearly expunged.
  • Conserved moiety species amounts and concentrations are directly mutable.
  • RoadRunner.reset is now very flexible, can reset a variety of values based on args.

August 1st, 2014, Release 1.2.4

  • Extended information such as git branch and last commit available via    getVersionStr()
  • Test case for reduced / full Jacobian in both amount and concentration mode.
  • Reduced Jacobian now works in either amount or concentration mode.
  • Added getFloatingSpeciesConcentrationRates() function to get rates of change    of floating species concentrations.
  • Made model reset smarter when resetting model with conserved moieties. If users    changes CMs, they will only be reset if users also changes init species cond.
  • Correctly display CM ids.
  • Major cleanup in handling temp dir path, added config value for specifying    tmp dir and log file path.
  • Added model checks to getCurrentSBML, fixes with CM is enabled.
  • Merged Alex’s documentation updates to C API.
  • Fixed bug with CM being displayed twice in items.
  • Fix bug when getting stoich matrix when CM is enabled.
  • New Runge-Kutta 4th order integrator, available via simulate using integrator=”rk4″.
  • Full Jacobian works in either concentration or amount mode.
  • Update make_docs.sh shell script to work with spaces in directory names.
  • More user proofing and robustness.
  • Experimental ARM chip based version of libRadoRunner

July 20, Release 1.2.3

  • Updates to Python API and C API online Docs.
  • Improvements to error and display messages.
  • Integrator state is NOT reset when changing integrators, i.e. if one does a

r.simulate(integrator=”gillepsie”)
r.simulate(integrator=”cvode”)
r.simulate(integrator=”gillepsie”)

the state of the integrators (including the random number stream) continues from
the previous state.

  • The ‘seed’ keyword argument to simulate resets the RNG to the given seed. All subsequent calls to simulate pick up the RNG in its current state. The RNG is ONLY reset when the ‘seed’ keyword argument is given.
  • Integrators now implement the dictionary protocol. For example, when using the Gillespie integrator, it supports the following keys:

r.getIntegrator().keys()
[‘seed’, ‘rand’]

  • The ‘rand’ value grabs the next random number from the stream, and the ‘seed’ resets the RNG to the given seed.
  • User specifiable RNG seed. The seed can be specified either via an optional ‘seed’ argument to  simulate, i.e.

r.simulate(0, 10, seed=23)

Or, can be specified via the SimulateOptions object, either with a new one, or the
existing one:

o = SimulateOptions()
o.start = 0
o.end = 10
o.integrator = SimulateOptions.GILLESPIE
o[‘seed’] = 23 # SimulatOptions behaves as a dictionary, any new integrator specific

values # can be added here.

r.simulate(o)

Or, the existing one can be modified:

r.simulateOptions[‘seed’] = 23

To get back to the default behavior of using the system time, just delete this value from the  existing object:

del r.simulatOptions[‘seed’]

  • Fixed an issue with conserved moieties not being calculated correctly with multi-compartment models.
  • Added getFullStoichiometryMatrix() and getReducedStochiometryMatrix() methods to RoadRunner object.
  • Cleanup in steady state solver, introduced new configuration parameters for steady state solver:

STEADYSTATE_RELATIVE,
STEADYSTATE_MAXIMUM_NUM_STEPS,
STEADYSTATE_MINIMUM_DAMPING

  • Initial value assignment rules now access the present value of parameters rather than their initial value.
  • Memory leak fixes in libSBML.
  • Added support for global parameter rates via selections if the global parameter has a rate rule.
  • Fixed atanh function on Windows.
  • Fixed bug with incorrect model resetting when changing integrators.
  • Fixed row/column major bug with Python API.
  • python RoadRunner simulate returns (optionally) a copy of the simulation result.

June, Release 1.2.2

  • Fixed bug in Python simulate method not accepting 4’th position argument in certain cases.
  • Added LLVM info to version info
  • Added methods to Compiler interface to get info about current JIT processor and system.
  • Added support for compiling with LLVM 3.5, we now support LLVM version 3.1 – 3.5

May 28, Release 1.2.1

This is a point update that includes some fixes and additional functionality that was exposed from 1.2.0. The bulk of these changes were carried out by Andy Somogyi.

The main highlight is the introduction of a Gillespie solver that support both the common variable step size behavior of Gillespie and grid (or fixed step size) based solutions (See the textbook Essentials of Biochemical Modeling for details).

  • New function in the roadrunner.testing package to enumerate testing data files.
  • Clean up of SBML warning messages (thanks Lucian
  • Fixed major bug with how absolute and relative tolerances are handled (major thanks to Matthias Koenig)
  • Added support for reading values of reaction rates inside the model (identified by Matthias)
  • Event status is not available as a selection, i.e. r.model[“my_event_id”] will return 1 or -1  depending on whether or not the event is triggered.
  • The plot method no longer tries to parse labels from SBML ids as LaTeX.
  • Made structuredResult behavior backward compatible (some users like the structured result).
  • Major revamp of the Python simulate method, it now accepts a variety of positional and named  arguments.
  • Fix bug when compiling with clang3.4 in c++ 11 mode (identified by Andrew Millspaugh)
  • Gillespie integrator now supports fixed and variable time step mode.
  • Variable time step mode fixes with deterministic solver.

May 12, Release 1.2.0

Download binaries and Python bindings from here.

The pure Windows binaries suitable for linking to other applications are in the file:

cpplibroadrunner-1.2.0-msvc2010-win_32.zip

The Windows version of roadrunner that can be run using Python is in the file:

pylibroadrunner-1.2.0-win_32.zip

Changes from 1.1.0 to 1.2.0:

  •  Enabled mutable initial conditions when conserved moieties are used, fixed bug in Jacobian  calculation when conserved moieties are used.
  •  Fixed all known memory leaks related to how CVODE is used.
  •  Fixed bugs with stiff solver not being selected
  •  New getValue / setValue methods on SimulationOptions to set arbitrary settings, will be used by  future integrators.
  • Prototype Gillespie stochastic integrator – stell beta
  •  Added missing init amount method to python API
  • Clean up IL code generation
  • Structured result disabled by default
  • New parameters in simulate and plot methods,   simulate now accepts all SimulateOptions field names as keywords and has plot option,  i.e. simulate(plot=True)
  • Raise exception on invalid selection strings
  • Removed superfluous bool return value on exception raising methods.
  • All instance variables in public classes moved to private internal struct — result is that we  can now add and remove instance variables and never break binary compatibility. Relevant to C++  users.
  • Future versions may accept more complex types for configuration settings, API is set up never to break binary compatibility as features are added.
  • Continuous documentation updates and enhancements.

March 31, Release 1.1.0

Changes from 1.0.1 to 1.1.0:

  • Config system. RoadRunner can now read and write most default configuration parameters from / to a config file
  • Fixed memory leak in moiety conservation converter
  • New colored logging
  • Upgraded to standard Poco 1.5 distribution. RoadRunner’s Poco is now linked directly to the official Poco git repository.
  • Lots of integrator tuning parameters are now accessible via the SimulateOptions object.
  • Can run the integrator in new MULTI_STEP mode where the integrator determines time step size.
  • New SBML events — users can register listeners for any sbml event. Whenever a SBML event is triggered or assigned, the user can be notified.
  • New integrator events — users can register listeners for integrator events such as when a time step completes or an event was detected.
  • Significantly improved integrator error handling.  Whenever CVODE encounters any error such as numeric instability, the error is written directly to the Roadrunner logging system with exact details about the error. Descriptive exceptions are now raised detailing the exact source of the error.
  • Cleanup of integrator code.
  • New distutils based python installation system. We now provide binaries for 32/64 bit Linux (intel), 64 bit Mac OSX and 32 bit Windows.
  • Documentation updated
  • Can read sbml files through http on all platforms. The RoadRunner constructor load methods are smart in that they accept a string which can be either:
  1. The contents of a sbml document
  2. A local file path, i.e. /home/andy/feedback.xml
  3. A full URI identifier that can be either a local file or a remote file,  this can even be a biomodels identifier, i.e.  r=roadrunner.RoadRunner(“http://www.ebi.ac.uk/biomodels-main/download?mid=BIOMD0000000275″)

January 24, Release of 1.0.1

New Windows Installers.

* We now have a single setup installer for Windows. This makes installation on Windows much easier.

Fixes and update to libRoadRunner

* Fixed bug where nested sbml functions were not handled properly. Now
it correctly reports when sbml functions are called with invalid
number of args.

* Fixed bug where where a log trace message incorrectly created.

* Display version info correctly in the command line rr program.

* Cache selection types and indices in model.getValue / setValue,
significant improvement in sbml symbol access times.

* Fixed memory leaks in Python API, performance improvements in
selections.

* New RoadRunner constructor which takes a URI and load options.

* Plugins moved to Tellurium project.

* Added getStateVectorRate and getStateVectorIds to ExecutableModel interface,
readily allows roadrunner to be used with external integrator

* SBML variable access performance improvements.