Package: rebop
reboprebop is a fast stochastic simulator for well-mixed chemical
reaction networks.Performance and ergonomics are taken very seriously.  For this reason,
two independent APIs are provided to describe and simulate reaction
networks:a macro-based DSL implemented by [define_system], usually the
most efficient, but that requires to compile a rust program;a function-based API implemented by the module [gillespie], also
available through Python bindings.  This one does not require a rust
compilation and allows the system to be defined at run time.  It is
typically 2 or 3 times slower than the macro DSL, but still faster
than all other software tried.The macro DSLIt currently only supports reaction rates defined by the law of mass
action.  The following macro defines a dimerization reaction network
naturally:userebop::define_system;define_system!{r_txr_tlr_dimr_decay_mRNAr_decay_prot;Dimers{gene,mRNA,protein,dimer}transcription:gene=>gene+mRNA@r_txtranslation:mRNA=>mRNA+protein@r_tldimerization:2protein=>dimer@r_dimdecay_mRNA:mRNA=>@r_decay_mRNAdecay_protein:protein=>@r_decay_prot}To simulate the system, put this definition in a rust code file and
instanciate the problem, set the parameters, the initial values, and
launch the simulation:letmutproblem=Dimers::new();problem.r_tx=25.0;problem.r_tl=1000.0;problem.r_dim=0.001;problem.r_decay_mRNA=0.1;problem.r_decay_prot=1.0;problem.gene=1;problem.advance_until(1.0);println!("t = {}: dimer = {}",problem.t,problem.dimer);Or for the classic SIR example:userebop::define_system;define_system!{r_infr_heal;SIR{S,I,R}infection:S+I=>2I@r_infhealing:I=>R@r_heal}fnmain(){letmutproblem=SIR::new();problem.r_inf=1e-4;problem.r_heal=0.01;problem.S=999;problem.I=1;println!("time,S,I,R");fortin0..250{problem.advance_until(tasf64);println!("{},{},{},{}",problem.t,problem.S,problem.I,problem.R);}}which can produce an output similar to this one:Python bindingsThis API shines through the Python bindings which allow one to
define a model easily:importrebopsir=rebop.Gillespie()sir.add_reaction(1e-4,['S','I'],['I','I'])sir.add_reaction(0.01,['I'],['R'])print(sir)df=sir.run({'S':999,'I':1},tmax=250,nb_steps=250)You can test this code by installingrebopfrom PyPI withpip install rebop. To build the Python bindings from source,
the simplest is to clone this git repository and usematurin develop.The traditional APIThe function-based API underlying the Python package is also available
from Rust, if you want to be able to define models at run time (instead
of at compilation time with the macro DSL demonstrated above).
The SIR model is defined as:userebop::gillespie::{Gillespie,Rate};letmutsir=Gillespie::new([999,1,0]);//                           [  S, I, R]// S + I => 2 I with rate 1e-4sir.add_reaction(Rate::lma(1e-4,[1,1,0]),[-1,1,0]);// I => R with rate 0.01sir.add_reaction(Rate::lma(0.01,[0,1,0]),[0,-1,1]);println!("time,S,I,R");fortin0..250{sir.advance_until(tasf64);println!("{},{},{},{}",sir.get_time(),sir.get_species(0),sir.get_species(1),sir.get_species(2));}PerformancePerformance is taken very seriously, and as a result, rebop
outperforms every other package and programming language that we
tried.Disclaimer: Most of this software currently contains much more
features than rebop (e.g. spatial models, custom reaction rates,
etc.).  Some of these features might have required them to make
compromises on speed.  Moreover, as much as we tried to keep the
comparison fair, some return too much or too little data, or write
them on disk.  The baseline that we tried to approach for all these
programs is the following:the model was just modified, we want
to simulate itNtimes and print regularly spaced measurement
points.  This means that we always include initialization or
(re-)compilation time if applicable.  We think that it is the most
typical use-case of a researcher who works on the model.  This
benchmark methods allows to record both the initialization time
(y-intercept) and the simulation time per simulation (slope).Many small benchmarks on toy examples are tracked to guide the
development.  To compare the performance with other software,
we used a real-world model of low-medium size (9 species and 16
reactions): the Vilar oscillator (Mechanisms of noise-resistance
in genetic oscillators, Vilar et al., PNAS 2002).  Here, we
simulate this model fromt=0tot=200, reporting the state at
time intervals of1time unit.We can see that rebop's macro DSL is the fastest of all, both in
time per simulation, and with compilation time included.  The second
fastest is rebop's traditional API invoked by convenience through
the Python bindings.Features to comecompartment volumesarbitrary reaction ratesother SSA algorithmstau-leapingadaptive tau-leapinghybrid models (continuous and discrete)SBMLCLI interfaceparameter estimationlocal sensitivity analysisparallelizationFeatures probably not to comeeventsspace (reaction-diffusion systems)rule modellingBenchmark ideasDSMTSpurely decoupled exponentialsringToggle switchLacZ, LacY/LacZ (from STOCKS)Lotka Volterra, Michaelis--Menten, Network (from StochSim)G protein (from SimBiology)Brusselator / Oregonator (from Cellware)GAL, repressilator (from Dizzy)Similar softwareMaintainedGillesPy2STEPSSimBiologyCopasiBioNetGenVCellSmoldynKaSimStochPyBioSimulator.jlDiffEqJump.jlGillespie.jlGillespieSSA2CayenneSeem unmaintainedDizzyCellwareSTOCKSStochSimSystems biology toolboxStochKit(successor: GillesPy2)SmartCellNFsimLicense: MIT