COMPUTATIONAL TOOLS FOR MODELING PROTEIN NETWORKS
Frank T. Bergmann
Ravishankar R. Vallabhajosyula
Herbert M. Sauro
Keck Graduate Institute
535 Watson Drive
Claremont, CA 91711, U.S.A.
ABSTRACT
There are a large number of software packages available, both commercial and academic, to assist researchers in modeling
protein networks. In this paper, we briefly review some of the more commonly used tools and focus on the current state of the
Systems Biology Workbench (SBW), a modular framework that connects modeling and analysis applications, enabling them
to reuse each other‟s capabilities. We describe how users and developers perceive SBW and then describe the currently available SBW modules.
1
INTRODUCTION
Cellular networks are by nature highly dynamic structures where proteins, metabolites and expression levels are constantly
changing and adjusting to internal and external influences. Protein networks in particular provide some of the critical computational capacity that cells need to respond coherently to external signals (Sauro and Kholodenko, 2004). In recent years there
has been a growing interest in understanding how protein networks behave dynamically since ultimately it is dynamics that
generates the phenotype. Due to the large number of components and nonlinear nature of protein interactions, the study of
protein network dynamics invariably involves simulation and mathematical analysis coupled with experimentation (Tyson et.
al. 2001; Neves and Iyengar, 2002; Geva-Zatorsky, 2006; Kholodenko, 2006).
Simulating biochemical networks has a long history dating back to at least the 1940s (Chance, 1943). In the early days simulation relied on building either mechanical or electrical analogs of biochemical networks. It was only in the 1960s, with the
advent of digital computers that the ability to simulate biochemical networks became more widely available with the development of specialized software tools (Garkinkel, 1968). In recent years there has been a plethora of tools made available to
the budding systems biologist. The quality and user friendliness of these tools is highly variable. Many tools are open source,
that is, the source code is available for free which to some degree can ensure its survival even when the original author looses
interest. Some tools are commercial such as SimBio for Matlab (Mathworks, 2006).
This article will be concerned with the software tools for simulating and analyzing protein networks. We will start with a
brief review of existing methodologies and tools and then focus on our own tool set, the Systems Biology Workbench (Sauro
et. al., 2003).
1.1 Modeling
There are many reviews and books that now cover the art and science of building models of biochemical networks (Klipp, et
al, 2005), therefore only a brief survey is given here.
There are a number of mathematical formalisms that can be used to represent protein networks. The most common is to use
ordinary differential equations to describe the rate of change of each protein species in the model. Such an approach assumes
that concentrations can be described using continuous variables and ignores the fact that proteins are particulate and change
in a discrete manner. However, if the protein concentrations are sufficiently high (say > 200 molecules) then the continuity
Bergmann, Vallabhajosyula and Sauro
Page 2 of 21
assumption is reasonably good. In eukaryotic cells, the level of protein in networks such as the MAPK pathway, is present in
the ten of thousands of molecules (Blüthgen, et al, 2006) and the use of differential equations to model protein networks is
not unreasonable. The alternative to this approach is to use stochastic modeling (Gillespie, 1976) but this technique should
only be used when particle numbers are very low. A useful middle ground is to add noise to a continuous approach by using
chemical Langevin equations (Gillespie, 2000). Many of the software tools support all three modeling approaches - continuous, stochastic and Langevin.
1.2 Standards
While software tools have a vital role in the study of biochemical networks,, the external representation of these networks as
computational models is also an important consideration. The most tedious and potentially error prone approach when describing a model is to write the system equations manually. Many authors for example still publish their models as lists of
differential equations, usually down in an appendix. Although the raw system equations represent the model precisely, the
process of generating the equations looses important biological information such as stoichiometry. Moreover reverse engineering the equations to recover the original biological network is often very difficult. As a result of these issues, many software writers prefer to enter models in a more biologically relevant notation. These representations can be simple text based
lists of reactions together with their rate laws, or more elaborate cartoon diagrams representing the network.
Prior to the year 2000, all simulation software tools used their own formats to export models, usually these were some form
of text based representation. This meant it was difficult if not impossible in some cases to move models from one software
tool to another. As a result, a group of modelers, computer scientists and biologists came together to formulate a common
standard for exchanging computational models. This resulted in the publication of SBML, the systems biology markup language (Hucka, et al, 2003). A similar process was discussed in the physiology community for modeling physiological
processes with the outcome being the publication of CellML (Hedley et. al., 2001; Lloyd et. al., 2004). Since the publication
of these standards, most, if not all software tools now have the capability to import and export either SBML or CellML,
though SBML tends to be the more common format used due to its greater simplicity.
1.3 Software Tools
In the last ten years or so, numerous software applications have been written to support modeling of biochemical processes.
Table 1 lists some of the tools that we ourselves use or have used on occasion. In many cases we use alternative tools because
our own software may not have the required capabilities, at other times we use other tools to compare their simulation results
against our own simulations. Some of the more advanced software applications are very complex and given the nature of
software development in academia, where funding tends to be sporadic and uncertain, it is always wise to compare results
across different applications.
All the tools listed in Table 1 can import and export SBML and a few can exchange CellML. All those listed are actively
maintained, some sporadically, but most have some sort of active community which is important for receiving feedback on
bugs, usability or functionality issues. Most of the tools run on multiple platform (Windows, Linux, Mac) and most, with the
exception of one or two, are open source though under varying licenses. Some run only under Linux which severely limits
their user base. Roughly two-thirds have automated setup programs which make it extremely simple for anyone to install
them on a personal computer. Some of the Linux and Java based tools require technical skills of varying degrees and are best
used by experienced technical users. Some of the tools are extensible, that is new functionality can be added by a user. Often
this is accomplished through scripting languages. This aspect is still largely undeveloped and in practice few users seem to
exploit this powerful feature. Most have some form of documentation, including tutorials but documentation tends to be
patchy. When in doubt it is best to contact the authors who are usually more than willing to help out with any problems and
often welcome such contact. Given that we are also developers of simulation tools it would be unfair for us to do a detailed
comparison of the different applications, instead we refer interested readers to the recent independent review by Alves et al,
2006.
We will comment briefly on some tools that supplement our own software applications. Although not on the list, we should
first mention Matlab as an excellent numerical and data analysis application. Matlab is an application which we frequently
use for complex data analysis. Other tools that are particularly important, though do require further development, are bifurcation analysis software. Bifurcation analysis, the study of model behavior as a function of parameters is probably one of the
most important analysis methods available and we include in this list XPP and Oscill8 as good candidates. Other tools that
Bergmann, Vallabhajosyula and Sauro
Page 3 of 21
we use include Copasi (http://www.copasi.org) and PySCeS (Olivier et. al., 2005) for testing purposes, both these tools are
developed by long standing researchers in the field and we consider their tools to be reliable. For most of our work we use
SBW, with Jarnac and JDesigner being the most important tools in this category. Every research group will have their favorites and our own particular choices are biased according to our own interests and needs.
Software Tool
CellDesigner
Copasi
Dynetica
E-Cell
Hy3S
Jarnac
JDesigner
JigCell
JSim
MathSBML
Oscill8
PySCeS
SBML-PET
Sysbio ToolBox
VCell
XPP
User Interface
Visual
GUI
GUI
Scripts
Scripts
Scripts
Visual
GUI
GUI/Scripts
Scripts
GUI/Scripts
Scripts
Scripts
Scripts
GUI/Scripts
GUI/Scripts
Comments
Implements a proposed visual representation
Parameter Optimization
One of the few hybrid simulators
SBW Compatible, extensible
SBW Compatible, extensible
Includes a comprehensive model manager
Especially good at physiological modeling
Mathematica tool
Bifurcation Analysis, uses AUTO
Excellent Python based tool
Parameter Optimizer, supports SBML events
Comprehensive Matlab Tool
Internet based spatial modeling workbench
Bifurcation Analysis, uses AUTO
Table 1: A variety of software tools for modeling protein networks. Web links to these and other related software tools can
be found at www.sbml.org
In the remainder of this article we will describe our own simulation tool kit, the Systems Biology Workbench (Hucka et
al. 2002; Sauro et. al., 2003). The philosophy of the SBW is that instead of developing a monolithic application, we take a
modular approach that supports distributed computing. Our development focuses on a platform/language independent framework of loosely coupled applications: the Systems Biology Workbench. This allows newly developed applications to reuse
functionality from existing applications, rather than re-implement them. For example, rather than implementing a new simulator for a new project, we simply take advantage of an existing SBW-enabled one. There are other approaches to implementing a modular architecture, in particular we should mention BioSPICE and Cytoscape as alternative approaches to building
modular applications. .
The BioSPICE (Garvey et al. 2003) approach is to “wrap” applications into analyzer objects with specified input and
output behavior. These analyzers can then be used within a graphical interface to create workflows between applications.
While this approach works for applications that do not require user input at runtime, it does not work well for a modeling
process. A modeling process requires more flexibility than a workflow can provide. In SBW, flow between „analyzers‟ is
nonlinear and dependent on the whim of the modeler.
Finally, Cytoscape (Shannon et. al. 2003) uses a traditional plugin approach, a technique popularized by Photoshop. Plugins are small software libraries that can integrate into the main application at runtime thereby adding new functionality
without requiring a recompilation of the main application. The main application exposes a programming interface which
third-party developers can exploit. The technique is quite successful, however the main drawback is that plugins have to be
written in the computer language that the main application is written in. Thus in the case of Cytoscape, plugins must be written in Java. To Java writers this is not an issue, but to developers of other languages it is a problem. SBW circumvents this
problem by integrating „plugins‟ through a language independent broker.
1.4 Architecture
The Systems Biology Workbench (SBW) is a resource-sharing framework based on a broker architecture. SBW uses a message based system that employs binary formatted messages sent over TCP/IP (Sauro et al. 2003). This basic architecture was
chosen with regard to performance, portability, simplicity, and language-neutrality. We also considered XML-RPC, Java
RMI (Sun Microsystems 2006), and CORBA (OMG 2006) but ultimately favored a simple peer-to-peer technique.
Binding libraries, provided for most programming languages, allow applications to become SBW-enabled. This means
that the application can make use of functionality provided by other SBW-enabled applications or provide functionality for
Bergmann, Vallabhajosyula and Sauro
Page 4 of 21
other applications. The binding libraries are written to fit the natural pattern of the programming language of choice. SBWenabled applications are called modules. Each module in turn will provide one or more services and each service will have
one or more methods. Each method is defined by its unique signature and help string. Help strings are also available at the
service and module level. Help strings provide a degree of internal documentation to the SBW interface and are useful in a
number of situations (see SBW add-on). Services are also classified into categories, which allow the discovery of modules
not only by name but also by functionality. Example categories include simulators (with various levels), SBML translators, or
a simple analyzer category. The convention is that every service belonging to a certain category implements specific method
signatures that allow the services to be exchanged at a later time.
At the core of SBW stands the SBW Broker. The Broker negotiates communication between SBW modules. Its main
function is to provide other modules with events such as the startup/shutdown of applications, a system shutdown, or advertising newly registered modules. The Broker also allows the user to find SBW modules either by name or by category. While
the broker is most often used to negotiate communications between local modules, it can also communicate with remote brokers. Furthermore, SBW allows all SBW modules to be available as Web Services (W3C 2006). This communication flow
can be summarized as in Figure 1.
Figure 1: SBW Communication Flow
SBW can be used in a hosting environment where it provides analysis support for SBML models. This has been done by
BioSPICE, BioUML (Kolpakov 2002), CellDesigner (Kitano et al. 2005), and JDesigner (Sauro et al. 2003). BioSPICE allows integrating SBW modules as analyzers into the generated workflow. A simpler way of integration has been done in
CellDesigner and JDesigner by incorporating a SBW menu.
As shown with PySCeS (Olivier, Rohwer, and Hofmeyr 2005) scripting can be a powerful tool for researchers. We developed a set of scripts that allow SBW to be used in the Python interactive mode. Users will be notified of every module
startup and are able to access all SBW modules from the shell. Similarly, users can access SBW via scripting from Matlab
(Wellock et al. 2005).
A more detailed description of the inner workings of SBW can be found in (Hucka et al. 2002) and (Sauro et al. 2003).
2
SBW FROM A USER’S PERSPECTIVE
A user of an SBW-enabled application will probably never perceive SBW working at all. For a user, SBW is a collection of
loosely coupled applications, all of which support SBML. One example would be the use of an SBW-enabled model editor
such as JDesigner, which is a program that allows the user to load or construct a biochemical model and then analyze the
model. When loading a model created by another software tool, JDesigner will ask another SBW module to generate a layout
for the loaded model. As JDesigner has no inherent simulation capabilities, the model is handed over to a SBW module that
Bergmann, Vallabhajosyula and Sauro
Page 5 of 21
can perform the simulation. The results from the simulation are then handed back to JDesigner, via SBW, allowing them to
be displayed according to user specifications. Similarly, if a user performs structural analysis on the model, JDesigner will
acquire this information via SBW from Metatool (Pfeiffer et al. 1999).
JDesigner (and CellDesigner) also feature an SBW menu. This menu is populated dynamically on startup and lists all
SBW modules implementing the SBW analysis category. When the user selects a program from this menu, the SBW-enabled
program is invoked, the model is passed to it, and the program performs further analysis on the model. There is a wide variety of modules available, such as bifurcation analysis, frequency analysis, (stochastic) simulation, and 3D Visualization.
Because the SBW menu is shared between many applications, users now have a new option for moving between these
applications. A user working on an SBML model in one program, can switch to another SBW module by selecting it through
the SBW menu, thereby transferring the model to the next program where it can be further analyzed. This “hopping” between
programs is rather different from the usual export/import scenario and allows users to efficiently use many tools.
3
SBW FROM A DEVELOPER'S PERSPECTIVE
SBW is a modular framework that gives developers tools for basic modeling and analysis tasks such as interrogating models,
simulating models, and analyzing models (such as structural or stoichiometry analysis). Therefore, the developer of a new
software application can use these tools as a foundation and focus on novel tasks instead of re-inventing the wheel. It should
be noted that the basic analysis tools are exchangeable, so that, for example, one simulator can easily be replaced by another
one.
Similarly, an existing application written in any supported programming language can be modified to interact with SBW
with minimal programming overhead. This enables other applications to use its functionality.
3.1 Language Bindings
Native SBW language bindings are available for the most common programming languages such as C/C++, Java, .NET languages, Python, Delphi/Kylix, and Matlab. Other languages, such as FORTRAN, would use the C libraries to access SBW.
Other languages can be supported; the only requirement is that the programming language provides string handling routines
and IP socket access.
The language bindings encapsulate all communication with SBW making remote communication to another module as
simple as any other method call. A default method call will result in the application blocking until a result comes back. Alternatively, asynchronous methods can be implemented. Should a call to another SBW module result in failure, exceptions will
be thrown in a language dependent way. In other words, for languages that support exception handling (such as C++, Java, or
the .NET languages) the caller will receive a proper exception, otherwise error flags have to be checked (for older languages
such as C or FORTRAN).
It should be noted that the binding libraries only support simple data types such as bytes, characters, complex numbers,
floating point numbers, and strings. Furthermore, one- and two-dimensional regular arrays of these types are supported. More
complex data types can be constructed by the use of lists. Lists are recursively defined and can therefore contain any combination of other types. With this set of types, any other data type can be represented.
3.2 SBW Visual Studio Add-on
In order to call a method with SBW, the following four steps must be executed: First, the chosen SBW module must be selected; second, the SBW Service containing the method has to be found; third, the method to execute needs to be selected;
finally, a call has to be made. This procedure is approximately the same for all program languages. For example, these steps
could be written in C# as follows:
// get module instance of a "simulator"
Module oSimulator = new Module("simulator");
// obtain simulation service by category lookup
Service oSimService = oSimulator.findServicesByCategory("simService");
// get a method handle
Method oSimulate = oSimService.getMethod("double[][] simulate()");
// finally call the method
Bergmann, Vallabhajosyula and Sauro
Page 6 of 21
oSimulate.Call();
The code shown above must be repeated, at least in part, for every method that an application wishes to use. For any given
module there may be tens or possibly hundreds of method calls. As a result we have devised an add-on to the Microsoft Visual Studio programming environment (Microsoft 2006b) that allows any SBW module to be automatically wrapped ready for
use. The add-on can generate interface code for Visual Basic (.NET), C# (.NET), and C++ (unmanaged). The developer
simply selects the SBW module and service to be wrapped, along with several options, and a wrapper file will be created and
added to the current project. The programming language will be detected from the current project. Possible options that modify the behavior of the wrapper include optimization options that influence when and how the methods are acquired and an option to automatically restart an application, in case it was closed by someone else and is still needed.
Once this is completed, the SBW module will look like any other static class in the current project. For the example
above, this means we can replace the four lines of code with a single call:
Sim.simulate();
Furthermore, as soon as the model service name is typed in the Visual Studio editor (“simService” in the example
above), the developer will be presented with a complete list of available methods, including help strings that explain the purpose of the method.
3.3 SBW Web Service Interface
Another useful tool for developers is the SBW Web Service Interface. The Web Service Interface allows other SBW modules
to be wrapped into a Web Service (W3C 2006). Once an SBW module and service are selected, the generator will wrap every
method in this service into a proper web method signature. Method and service help strings are used to populate web method
help fields. In this way they appear in the WSDL as wsdl:documentation in the corresponding wsdl:operation.
Special care has to be given to the data types. All simple types have direct correspondents in web methods. The same holds
for one-dimensional arrays. Two-dimensional regular arrays have to be represented as jagged arrays. Finally, the SBW lists
are represented as “ArrayOfAnyType”.
The web services created in this way can be hosted with Microsoft‟s IIS (Microsoft 2006a) (provided ASP.NET is available) or with Mono‟s XSP (Mono-Project 2006) implementation (which can also be integrated into Apache). This allows web
service hosting on all supported platforms (WIN32, Linux, and OS X) and hence presents an easy way to make legacy applications (e.g., applications written in FORTRAN or C) available as a Web Service.
A sample implementation can be found on the author‟s website. There, a web service can be created for any installed
SBW module / service and tested. (Created Web Services will only be available for a limited amount of time.)
4
AVAILABLE SBW MODULES
Since the publication of the initial description of SBW (Hucka et al. 2002) considerable progress has been made in module
development.
4.1 SBW Utility Modules
The following SBW modules provide the core functionality for SBML analysis. They provide the capability to read any version of SBML and SBML layout annotations. Furthermore, basic mathematical analysis can be performed with them. It
should be noted once again that any of these modules can be called from any language supported by SBW. Of course, they
also can be wrapped up as a Web Service and so can be easily used in more dynamic environments.
Network Object Model (NOM): This module provides a unified SBW interface around libSBML (Bornstein et al. 2006).
By creating another layer on top of libSBML we will be able to support future versions of SBML (Finney and Hucka 2003)
with the same interface. libSBML provides platform independent SBML reading and writing capabilities for many programming languages and thus is an indispensable tool for application developers supporting SBML. The NOM performs a slightly
different role. In its current version, it supports mainly SBML reading, validation, and conversion capabilities. Furthermore,
the NOM allows several SBW modules working together on an analysis to share an SBML model in a clipboard-like manner.
Instead of the SBML model being parsed repeatedly, this task has to be performed only once, which can improve the overall
runtime.
SBW CLAPACK: This module provides a wrapper around the functions of CLAPACK, which is the C version of the
commonly used Linear Algebra PACKage (Netlib 2006). Since many analysis tools in systems biology need to compute ei-
Bergmann, Vallabhajosyula and Sauro
Page 7 of 21
genvalues or singular values for a given matrix, or to perform matrix factorizations or inversions, we generated an SBW
module that performs these tasks. This module supports matrices with both real and complex elements, and additional capabilities can easily be added when such a need arises in future.
SBMLLayoutModule: For the upcoming third version of SBML, the SBML community decided on a layout extension
(Gauges et al. 2006). This extension will allow the overall layout (i.e., the position and dimensions of species/compartments
as well as the way reactions are drawn) to be stored in a SBML model. Until level three of SBML is finalized, this SBML extension will be stored in an annotation in current models. Based on this layout extension we developed a rendering extension
that specifies all rendering information (i.e., color, font, gradients, and grouping information). We implemented the
SBMLLayoutModule so that all SBW modules can take advantage of a unified layout interface. This module allows reading
and modifying a given layout, or generating a new layout from scratch. The module also supports the generation of a bitmap
containing the layout for use in another program. We also embedded this SBW module in a Web Application on the authors‟
website (Bergmann 2006). Finally, since the SBML Layout Extension is not yet widely adopted, the module provides separate support for JDesigner and CellDesigner models, as they are the most commonly used graphical model editors.
DrawNetwork: Since many available SBML models do not contain any layout information, the next logical step was to
develop an auto-layout SBW module. This has been done with DrawNetwork. This SBW module uses various force-directed
layout algorithms based on work by (Fruchterman et al. 1991). Optionally the user of the module can decide to generate alias
nodes (i.e., multiple copies of one species that refer to the same element in the SBML); this simplifies the generated layout
immensely. The module can be used in server or interactive mode. In server mode, it listens for SBW calls and serves them.
In interactive mode the user can manually modify the generated layout, moving or locking certain species or alias species individually. Figure 2 displays the generated layout (with aliasing) of BioModel # 14 (from SBML model repository at
www.biomodels.net).
Figure 2: Autolayout of BioModel #14 (From Model Repository at www.biomodels.net)
Translators: SBML Translators: SBW features a number of SBML translator modules that convert SBML into XPP-,
Matlab-, Simulink-, Java-, Jarnac-files and others. These translators take SBML as input and generate the translated code in
the user chosen format. All the translator modules support a standard translation category, which other applications such as
JDesigner can exploit. Here, we detail the process of translation for the Matlab translator, which converts the SBML model
into a function that can be called by Matlab integrators (for example ode23s) to simulate the model. The SBW Matlab translator is probably the only Matlab translator that supports SBML compartments. The translator checks the SBML declarations
for each of the species and converts them internally to amounts, which are then integrated. Conversions between concentrations and amounts are taken care of automatically during the simulation. The output from the translator is in units of amounts
(or mass, equivalently), which the user should then modify to concentrations by dividing each species output value by its
compartment volume.
Bergmann, Vallabhajosyula and Sauro
Page 8 of 21
Another important member of this family of tools is the SBML to XPP translator, which is used by Oscill8, an analysis
tool that can be used to study the effect of parameter changes and their corresponding bifurcation patterns. While the XPP
translator is similar to the Matlab translator in functionality, a key difference lies in the elimination of dependent species from
the model. This is achieved by calling the Structural Analysis Module, described under the analysis tools section, to evaluate
the correct conservation laws for the given SBML model. This step is essential in order to compute a non-singular Jacobian
which is required for the bifurcation analysis carried out by Oscill8. This approach allows the model dimension to be reduced, as only the equations for the independent species are needed, while those for the dependent species can be constructed
from computed values of the independent species. This model reduction is also implemented by the other translators, namely
SBML to C, C# and Java translators. Figure 3 shows a simplified flow diagram describing the translators.
Figure 3: Flow diagram for SBML translations with elimination of dependent species equations using conservation analysis
In the case of compiled languages, such as C, C# and Java, the translator generates two files, one which encapsulates the
model, and another that can simulate the model by means of a basic implementation of the 4th order fixed step Runge-Kutta
integrator. Users can easily interface the model file with other solvers for more complex systems, since the model implements
a method named modelfcn(int neq, double time, double x[], double dxdt[]) whose arguments conform to
most standard solvers. Here neq is the number of equations, time is the current simulation time, x[] is the array containing
the values of all the input variables, and dxdt[] is the vector containing all the right hand side evaluations in the original
system equation. The model file also includes two methods for numerical evaluation of the Jacobian. These are, a 2nd order
method (JacobianOrder2) and a 4th order method (JacobianOrder4) for evaluating the elements of the Jacobian using
finite differences of the 2nd and 4th order respectively. The file containing the model is named „model‟ (with a .c extension in
case of C Translator, .cs in case of C# Translator, and .java in the case of Java Translator). The other file can be obtained by
calling the method getHostingApp() in the translator API. No arguments are required to generate this file. It can be saved as
hostingApp.c (or .cs or .java based on the translator used). Since C# and Java support object-oriented data structures, the
model is stored as a class, which is instantiated in the hosting application. The purpose of separating the model from its simulation environment (for C, C# and Java Translators) is to enable the user to modify the model as desired without having to
change the simulation settings.
4.2 SBW Simulators
The dynamic behavior of biochemical networks is one of the main interests of researchers in systems biology. This has resulted in a multitude of simulators becoming available. While in some cases the need exists to devise specialized simulators
for certain areas, in most cases it will be enough to consider existing simulators.
Jarnac: Jarnac (see ref Sauro, (2000)) is more than just a simulator. It is a complete scripting environment combining
stochastic and ODE simulation capabilities with a powerful control language including a fairly complete matrix library. One
unique aspect of the matrix manipulation is that rows and columns are labeled. This allows the position of species and reactions to be easily tracked when rows and columns are swapped during analyses. Jarnac allows users to build models using a
shorthand notation as well as analyzing the models and graphing the results. For ODE simulations, Jarnac uses the popular
Bergmann, Vallabhajosyula and Sauro
Page 9 of 21
integrators CVODE (Cohen and Hindmarch 1996) or LSODA (Hindmarch 1983) which can be individually selected by the
user. Also included is an implementation of a simple 4 th order fixed step Runge-Kutta. Stochastic simulations are performed
using an implementation of the Gillespie algorithm (Gillespie 1976). The shorthand language of Jarnac (see Figure 4) can
easily be converted into SBML and vice versa. It should be noted that some features of SBML Version 2 have not been implemented, such as events or delay equations. However, these features can be implemented with functions written in JarnacScript. Acting as an SBW module, Jarnac provides its simulation capabilities or analysis routines to any other SBW module.
Probably the greatest shortcoming of Jarnac is that it was written for WIN32 systems only. To make Jarnac‟s functionality
available on other systems, we devised a new SBW module called JarnacLite. This module has been written for the sole purpose of quickly transforming SBML into Jarnac-Script and vice versa, allowing for modifications in the useful shorthand and
then letting other modules analyze the model by transforming it back into SBML. As JarnacLite was written using the .NET
language C#, it runs under WIN32 as well as all operating systems supported by Mono.
p = defn plos_1_model
var OCT4, SOX2, NANOG, OCT4_SOX2, Protein;
ext OCT4_Gene, NANOG_Gene, SOX2_Gene, targetGene, degradation;
J0:
J1:
J2:
J3:
$OCT4_Gene -> OCT4;
(k1*A + a1*OCT4_SOX2*SOX2 + ep1 + m1*OCT4_SOX2)/(1 + ep1/f +
(alpha2 + a1/1000)*OCT4_SOX2*SOX2 +
k2*A+(alpha3+m1/1000)*OCT4_SOX2);
OCT4 -> degradation; g1*OCT4;
NANOG_Gene -> NANOG;
(a2*OCT4_SOX2*SOX2 + ep2 + k3*A + m2*OCT4_SOX2)/(1 +
ep2/f + b2*OCT4_SOX2*SOX2 + k4*A + n2*OCT4_SOX2);
NANOG -> degradation; g2*NANOG;
J4: OCT4 + NANOG -> OCT4_SOX2;
J5:
OCT4_SOX2 -> degradation;
J4_k1*OCT4*NANOG - J4_k2*OCT4_SOX2;
J5_k*OCT4_SOX2;
J6:
(a3*OCT4_SOX2*SOX2 + m3*OCT4_SOX2+ep3)/(1 + ep3/f
+ (0.0009+a3/1000)*OCT4_SOX2*SOX2 + beta*p53
+ (0.00099+m3/1000)*OCT4_SOX2);
J7:
J8:
J9:
SOX2_Gene -> SOX2;
SOX2 -> degradation;
g3*SOX2;
targetGene -> Protein;
(p1*OCT4_SOX2 + ep4)/(1 + ep4/1000 +
b4*OCT4_SOX2*SOX2 + p2*OCT4_SOX2);
Protein -> degradation; g4*Protein;
end;
p.OCT4_Gene = 0; p.NANOG_Gene = 0; p.SOX2_Gene = 0;
p.targetGene = 0; p.degradation = 0;
p.OCT4 = 0.01;
p.OCT4_SOX2 = 0.01;
p.k1 = 1;
p.m1 = 0.01;
p.alpha3 = 0.00099;
p.k3 = 1;
p.n2 = 0.001;
p.J5_k = 5;
p.beta = 0.01;
p.ep4 = 0.0001;
p.SOX2 = 0.01;
p.NANOG = 0.01;
p.targetGene = 0.01; p.Protein = 0;
p.A = 0;
p.f = 1000;
p.g1 = 1;
p.m2 = 0.01;
p.g2 = 1;
p.a3 = 0.1;
p.p53 = 0;
p.b4 = 1;
p.a1 = 0.2;
p.alpha2 = 0.0005;
p.a2 = 0.2;
p.b2 = 0.0007;
p.J4_k1 = 0.05;
p.m3 = 0.005;
p.g3 = 1;
p.p2 = 0.001;
p.ep1 = 0.0001;
p.k2 = 0.0011;
p.ep2 = 0.0001;
p.k4 = 0.0011;
p.J4_k2 = 0.001;
p.ep3 = 0.0001;
p.p1 = 0.1;
p.g4 = 0.01;
Figure 4: Example Jarnac script from the work by Chickarmane et al., 2006. The script illustrates the shorthand language for describing reactions, rate laws and initial conditions. The reaction description uses a familiar chemical notation with reactants on the left side and products on the right. The rate law is specified after the reaction. Reactions can be
named which makes it possible to reference the reaction rates in later analyses. Jarnac scripts can be easily translated to
and from SBML using JarnacLite by simply dragging and dropping the scripts over the application.
roadRunner: In an effort to create a fully SBML compliant simulator we have also developed a new simulator called
roadRunner. Instead of interpreting model equations, roadRunner compiles the model equations dynamically, resulting in
significant improvements in performance when compared with traditional simulators. roadRunner uses the integrator
Bergmann, Vallabhajosyula and Sauro
Page 10 of 21
CVODE and NLEQ (ZIB 2003) for steady state analysis. To further speed up the simulation, the model is separated into a
system of independent and dependent variables. This separation process is described in detail in (Vallabhajosyula et al.
2006). roadRunner has been written completely in C#. Provided that CVODE and NLEQ are available for a given operating
system, roadRunner will run on that operating system. Thus, all major operating systems are supported.
Dizzy: A further collection of simulators has been developed by Stephen Ramsey at the Institute for Systems Biology
(Ramsey 2006). Dizzy allows for stochastic simulations using Gillespie, Gibson-Bruck, or Tau-Leap algorithms. Dizzy can
be called via the SBW menu in model editors such as JDesigner or CellDesigner.
Oscill8: Developed by Emery Conrad (Conrad 2006), Oscill8 is used for bifurcation analysis and time-course simulations. Oscill8 provides a user-friendly interface around AUTO (Doedel 1981), allowing for one and two parameter bifurcation diagrams (Figure 5) or bifurcation searches. For SBW, it provides a simulation service and additionally is available
through the SBW menu to perform bifurcation analysis. Oscill8 is available for WIN32, Linux, and OS X. The front-end requires a .NET implementation such as the .NET Runtime or Mono.
Figure 5: One parameter bifurcation-diagram generated by Oscill8
Stochastic Simulators: An alternative to the deterministic approach is the Gillespie algorithm (Gillespie, 1977), which
makes it feasible to carry out stochastic simulations. This algorithm provides an exact numerical approximation to the master
equation which provides a complete description of the system.
In the following we describe a new analysis tool for stochastic simulation of biochemical networks, which interfaces
with the stochastic simulator to generate data runs, and performs statistical data analysis and frequency analysis to aid in understanding the complexity of biological networks. This involves computation of ensemble statistics – namely, the population
means and variances of the species numbers, followed by the construction of correlation functions. Probability distribution
functions of the species are also generated. The computation of correlations involves both, auto and cross-correlations for all
the species participating in the network. When converted into the frequency domain with the help of Fast Fourier Transforms,
these are known as Power Spectral Densities and provide important information such as frequencies at which the network can
oscillate. Such an example is shown in the Figure 6, which shows results from a stochastic simulation of a small network involving two interacting sets of mRNA (M1, M2) and proteins (P1, P2). The introduction of negative feedback via inhibition
of M1 by P2 causes the power spectral density of P2 to peak, and can be inferred by the onset of oscillations in the numbers
of P2, P1, M1 and M2. This is a result of noise at the input being shifted to higher frequencies by the negative feedback
(Simpson et. al., 2003).
Computation of the power spectral densities of all the species, along with the cross-spectral densities (from crosscorrelations) allows the computation of transfer functions between selected inputs and outputs. However, in the case of biochemical networks, since boundaries are assumed to stay constant, this tool allows users to select the boundary nodes that
should be treated as noise sources, and then modifying the input SBML to convert those nodes to floating type for the dura-
Bergmann, Vallabhajosyula and Sauro
Page 11 of 21
tion of the simulation. This allows the construction of transfer functions, for example, between receptor and an internal protein state. These features make this tool very useful for biochemical network design, analogous to electrical circuit design.
Figure 6: Auto-Correlation and Power Spectral Density plots for a small network involving two mRNAs (M1,M2) and two
proteins (P1,P2), with negative feedback from P2 to M1.
SimDriver: To implement a unified user-interface to interact with all these simulators, we wrote the SimDriver. There
are several implementations of this module available. For non-WIN32 operating systems, we use a Java implementation. On
WIN32 systems, we use a .NET version of the SimDriver (Figure 7) with additional functionality such as steady state analysis, continuous time-course simulations, and modifications to parameter values. The SimDriver works for all simulators implementing one of the SBW simulator API‟s (Sauro and Bergmann 2006). There are several levels of this API with an increasing number of features. The user interface will disable all controls not supported by the selected simulator. The
SimDriver also supports stochastic simulators and therefore provides additional facilities to aid the analysis of stochastic
models, in particular, probability density function estimation, frequency analysis, and noise injection at selected nodes.
Figure 7: Time-course Simulation Using the SimDriver
Bergmann, Vallabhajosyula and Sauro
Page 12 of 21
3D Visualization Tool: Traditionally, simulation results are available as either data tables or X-Y plots. Data tables are helpful for further processing by other computational tools. X-Y plots, on the other hand, tend to get complex even for a limited
number of species. In creating a new visualization tool, we had two goals in mind. The first goal was to strongly tie the simulation results to the model. The other goal was to be able to view the simulation in real time to refine or broaden it where necessary. These goals have been realized in the form of a 3D Time-course Visualization module. The layout of an SBML model, as obtained by the SBMLLayoutModule, or generated by the auto layout module, implements the basis of the 3D
visualization tool and is projected onto a 3D plane. Furthermore, all positions of species are recognized and rendered as columns on top of the 3D plane. The height of the columns, representing the current species concentration, will vary during the
time-course simulation (Figure 8). This way, interesting dynamic behaviors of the models can easily be seen. Since the time
course simulation will be performed continuously, it is possible to dynamically change time-steps to focus on certain aspects
of the model.
Figure 8: 3D Time-course Simulation of Jana Wolf's Glycolysis Model (Ruoff et al. 2003)
4.3 SBW Analysis Tools
Structural Analysis Module: The main feature of the structural analysis module is its ability to compute the conservation
laws for a given model in a very robust manner. This is made possible by the implementation of a Householder QR based algorithm for computing the dependent rows of the stoichiometry matrix. This implementation is numerically very robust, especially for very large systems containing thousand or more species and reactions. While it is possible to compute these dependencies with other methods such as Gaussian Elimination, the numerical errors arising from truncation and round-off
errors accumulate faster, ultimately resulting in erroneous results. The accuracy of this analysis step is crucial, since incorrect
computation of conservation laws can result in a singular Jacobian, where as, a non-singular Jacobian is essential for other
analysis tools such as those carrying out bifurcation studies. The details pertaining to the implementation of the Householder
QR algorithm can be found in Vallabhajosyula et. al. (2006). Here we describe the capabilities of this analysis tool, which
along with its graphical user interface, can perform and store results for structural analysis studies on a number of models.
Screen shots of this application, both in the normal and in the visual mode are shown in Figure 9.
In addition to performing conservation analysis, this tool also allows users to obtain all the relevant matrices that are part
of a structural analysis study on any biochemical model. These include vectors such as Si (independent species), Sd (dependent species) and T (conserved sums) and matrices such as NR (independent part of the stoichiometry matrix N),
N0(dependent part of N), L (Link matrix), L0 (Link-zero matrix), (Conservation matrix), K (dependencies in the fluxes)
Bergmann, Vallabhajosyula and Sauro
Page 13 of 21
and K0 matrix. Further, all these matrices can easily be accessed by other tools via the API provided through an SBW interface. The use of this tool can be seen in the implementation of the translators, and in particular, that of the XPP translator.
Another important example is that of the high-performance simulator roadRunner, where the dependent species are eliminated by identifying the conserved moieties following which a reduced model can be constructed.
(a) Graphical Interface to Structural Analysis Module, showing the list of models, conservation matrices, and results.
(b) Stoichiometry matrix shown in visual Model. Positive values
have a blue color, while negative values have a red color.
Figure 9: The graphical user interface that accompanies the structural analysis tool.
This tool can also perform a conservation analysis using LU partial pivoting as well as LU full pivoting of the stoichiometry
matrix. However, especially for large systems, the conservation laws generated by LU factorization can have errors, arising
from numerical stability issues. As can be seen from the above discussion, the accuracy of the results obtained from the
Structural Analysis module is critical to many other applications. Therefore the results from the analysis are validated by performing five tests and thereby ensuring that the results that pass them can be trusted. If a model (or its LU version) fails any
of these tests, it is highlighted with an orange background in the panel listing the models, allowing for easy identification of
models that fail the tests. These tests involve (a) Verification to check if the conserved moieties obtained are indeed constant
(b) Checking the rank of the stoichiometry matrix obtained by QR factorization against that obtained by a SVD decomposition (c) Checking the rank of the NR matrix (d) Checking the eigen-values of the sub-matrix obtained from QR factorization
and (e) Verification of the L0 matrix. For additional details about the tests, we refer the interested reader to the paper by Vallabhajosyula et al. (2006). Here we compare the results for some large whole genome models. These are SBML models for
iCS291 for H. pylori (Schilling et al., 2002), iJE660a for E. coli (available from the in Silico organisms website at UCSD
http://gcrg.ucsd.edu/organisms/), iJR904 for E. coli (Reed et. al., 2003) and iND750 for S. cerevisiae (Duarte et. al., 2004).
Table 2 lists the number of conservation laws obtained by different methods for these models.
Model Name
Number of (Species, Reactions)
Householder QR
LU (with full pivoting)
LU (with partial pivoting)
PySCeS (Olivier et. al. 2005)
Jarnac (Sauro, 2000)
COPASI
iCS291
(396, 381)
36
36
36
36
36
31
iJE660a
(537, 739)
19
19
19
19
19
16
iJR904
(764, 931)
43
43
42*
43
41
36
iND750
(1072,1149)
100
100
100*
100
98
89
Table 2: Number of conservation laws obtained by various methods for large whole-genome models. (* Note that for models
iJR904 and iND750, the results from LU partial pivoting failed the validation tests. More details including timing data comparing QR, LU full and partial pivoting methods can be found in Vallabhajosyula et. al., (2006))
Bergmann, Vallabhajosyula and Sauro
Page 14 of 21
Metatool, by Stefan Schuster (Pfeiffer et al. 1999), is a command line tool for the calculation of conservation vectors,
elementary modes, and the null-space and stoichiometry matrix. This tool has been wrapped up as an SBW menu. This module has been tightly integrated into JDesigner in order to highlight the modes in the graphical model.
The Bifurcation Discovery Tool is an SBW module that can perform a parameter scan of the given SBML model to
search for interesting behavior such as switching and oscillation. The Bifurcation Discovery Tool is available through the
SBW menu or supports loading SBML files directly. It has no simulation capabilities on its own but will use one of the SBW
simulators to perform time course simulations and steady state analysis in order to perform the parameter scan. The parameter
scan is implemented using a genetic algorithm with elitism, which evaluates slightly modified models in the parameter space.
A detailed description is available in (Chickarmane et al. 2005).
The Frequency Analysis Module allows the user to select a parameter and a species of an SBML model and generates
the corresponding frequency response. It is available through the SBW menu.
We also developed a suite of optimizers within the BioSPICE project. These optimizers fit experimental data to an
SBML model. Five different algorithms were implemented for this purpose: a genetic algorithm with tournament selection, a
hybrid algorithm combining a genetic algorithm with the simplex algorithm, the Levenberg-Marquardt algorithm, a hybrid
combining simulated annealing and simplex, and finally the Nelder and Mead Simplex Algorithm. These algorithms have
been implemented in Matlab and are accessible via the SBW-Matlab Bridge (Wellock, Chickarmane, and Sauro 2005), which
allows Matlab scripts to be wrapped into SBW modules.
4.4 SBW Modeling Environments
JDesigner is a graphical modeling environment for creating and editing biochemical reaction networks. It permits a user to
draw a protein network on screen and assign appropriate kinetic laws from a wide selection of rate laws or to define new rate
laws. The notation that is used to depict protein networks is generic in that no particular style is enforced. Given that there is
currently a wide variety of styles available for drawing pathways it was felt at this stage to make the visual elements flexible.
JDesigner incorporates a „molecule‟ designer which permits great flexibility in visual depiction. Figure 10 illustrates some
possible designs that may be employed. Note that multimetric proteins, both heterologous as well as homologous may be depicted. In addition a special facility is provided to depict covalent states. Color and shapes can be adjusted as necessary. Note
that the visual depiction does not effect the underlying computer model and is used purely to aid identification for humans.
Figure 10: A sample of possible „protein‟ cartoons generated with the molecule editor.
In addition to protein species, JDesigner permits a variety of binding and transformation interactions. Again, like the species
depiction, interactions are generic in the sense they can represent any kind of interaction, be it simple mass-action, kinase activity or more complex regulatory effects. In the current version nine different visual representations are permitted, uni-uni,
uni-bi, bi-uni, bi-bi, uni-tri, tri-uni, bi-tri, tri-bi, and tri-tri. These options are shown in Figure 11. Rate laws can be associated
with reactions, either from the built-in list of rate laws or by creating a user defined rate law.
Bergmann, Vallabhajosyula and Sauro
Page 15 of 21
Figure 11: Selection of nine reaction types for connecting species nodes together. The stoichiometries of the individual reactions can be further modified if necessary. Reaction curves can either be based on Bezier curves or simple straight lines
(segmented or single) offering greater flexibility when depicting protein networks..
Figure 12: Regulatory interactions between species and reactions.
If a pathway includes effector interactions, these are indicated by either activatory, inhibitory or modifier regulatory lines, as
shown in Figure 12.
Figure 13: Compartments are depicted as bounded rectangles. Species can be moved from one compartment to another by
dragging the species from one compartment to another.
Bergmann, Vallabhajosyula and Sauro
Page 16 of 21
Compartments with differing volumes can be represented in JDesigner by using compartment rectangles, as shown in Figure
13 which illustrates two compartments. Moving species from one compartment to another can be accomplished by dragging
species. Compartments can also be moved in which case the enclosed species will follow.
A problem that frequently occurs in complex networks is that some species are involved in many reactions. Such species can
cause a network to look unwieldy and complex. In some cases it is not necessary to explicitly show these connections, for example ATP and phosphate are frequently used in protein phosphorylations. JDesigner allows a user to define aliases of species, permitting layout simplification. In a given network one species is designated the master species, and from this aliases
are generated. The aliases are equivalent to the master species and can therefore be used as a substitute, thereby improving
the layout. Figure 17 shows a model of glycolysis where alias species have been created for ATP, ADP, NAD and NADH.
This permits networks to be simplified.
A full range of cut/paste, alignment tools and zoom features are available in the application. A recent feature added to JDesigner is the auto layout capability. Many models, for example those from the biomodels.net repository have no layout information, thus in previous versions of JDesigner, these models would appear as a random network on the screen. The newly
developed layout tool allows a random graph to be arranged in a more organized fashion. Thus JDesigner, via SBW, can call
upon the layout module if no layout information is present (See Figure 2).
Export of images can be in the form of bitmaps (BMP, PNG, JPEG), metafiles, graphML and HTML image maps. All export
formats use high resolution for publication quality. Future plans include additional export options such as SVG and PDF.
Once a model has been specified using JDesigner, the model can be saved as SBML so that it can be loaded into other tools,
such as Copasi. The model can be translated to another format, such as a Matlab function, XPP, Java, Jarnac script, etc. The
user can elect to view the model equations (See below for an example), and finally, the user can engage SBW and pass the
model to another tool such as Oscill8 or roadrunner.
// Reaction Rates:
v[J0] = J0_V1*MKKK/((1+pow(MAPK_PP/J0_Ki,J0_n))*(J0_K1+MKKK))
v[J1] = J1_V2*MKKK_P/(J1_KK2+MKKK_P)
v[J2] = J2_k3*MKKK_P*MKK/(J2_KK3+MKK)
v[J3] = J3_k4*MKKK_P*MKK_P/(J3_KK4+MKK_P)
v[J4] = J4_V5*MKK_PP/(J4_KK5+MKK_PP)
v[J5] = J5_V6*MKK_P/(J5_KK6+MKK_P)
v[J6] = J6_k7*MKK_PP*MAPK/(J6_KK7+MAPK)
v[J7] = J7_k8*MKK_PP*MAPK_P/(J7_KK8+MAPK_P)
v[J8] = J8_V9*MAPK_PP/(J8_KK9+MAPK_PP)
v[J9] = J9_V10*MAPK_P/(J9_KK10+MAPK_P)
// Differential Equations:
dMKKK/dt = - J0 + J1
dMKK/dt = - J2 + J5
dMKK_P/dt = + J2 - J3 + J4 - J5
dMAPK/dt = - J6 + J9
dMAPK_P/dt = + J6 - J7 + J8 - J9
dMKKK_P/dt = + J0 - J1
dMKK_PP/dt = + J3 - J4
dMAPK_PP/dt = + J7 - J8
//
1:
2:
3:
Conservation Laws:
MKKK + MKKK_P
MKK + MKK_P + MKK_PP
MAPK + MAPK_P + MAPK_PP
Figure 14: Model equations can be generated directly from JDesigner. The figure illustrates the equations generated for the
MAPK oscillatory model (Kholodenko, 2000) and includes the rate laws, differential equations and any conservation laws
that the network may have.
Bergmann, Vallabhajosyula and Sauro
Page 17 of 21
A frequent user request is the ability for a model to have multiple parameter sets. That is, a single model may exhibit different behaviors depending on the parameter values. It is convenient to be able to store these model variants in one file. At an y
time, a user can take a snapshots of the model, which means that the current state of the model is stored along with the model.
Such snapshots can be named and annotated with notes.
JDesigner is the module that probably profits the most from SBW. Via the previously described auto-layout and SBML
layout extension modules, it is able to render any SBML file. Using the SBW menu, it can pass the loaded model to a wide
variety of analysis tools. Time-course simulation and steady state analysis can be performed by either roadRunner or Jarnac.
Furthermore, it uses Metatool for structural analysis. Finally, it dynamically finds modules from the SBML exporter category
at runtime so the model can be exported into a variety of file formats including Matlab, Java, or XPP.
Figure 15: Two examples of protein networks drawn with JDesigner, such networks can either be exported in standard
SBML or simulated by SBW. JDesigner permits the representation of multmeric proteins, binding and transformation reactions, covalent states, and regulatory interactions. JDesigner can also be used to generate camera-ready copy for publication.
Figure 16: Screen-shot illustrating the simulation of the Oscillatory model of MAPK pathway (Kholodenko, 2000).
Bergmann, Vallabhajosyula and Sauro
Page 18 of 21
Figure 16 demonstrates the analysis capabilities of JDesigner. The pane on the bottom shows the time-course behavior
of the model. The drawing area in the middle displays a generated layout for the model.
CellDesigner, a graphical modeling environment developed by the Systems Biology Institute, Tokyo, Japan, also features the SBW menu. While JDesigner uses the model of hyper-graphs to visualize the biochemical network, CellDesigner
uses the Process Diagram (Kitano et al. 2005) notation (i.e., a state diagram). CellDesigner has been written in Java and is
available for most operating systems.
Figure 17: JDesigner analyzing the Jan Wolf model BioModel #12 (From Model Repository at www.biomodels.net)
5
FUTURE DIRECTIONS
Until recently SBW development has been primarily WIN32-centric. While the binding libraries were available for most operating systems, all of our modules were mainly developed for WIN32. As SBW nears its third version, we face new possibilities. Finally, open source alternatives to the .NET runtime (Mono-Project 2006) are stable enough for daily use. We will
therefore dedicate more time to make SBW more useful on non-WIN32 systems. Secondly there are now very good graphical user interface libraries such a QT from TrollTech which provide high quality graphics which would be needed to port
JDesigner to other platforms.
Additions to the SBW core will include more metadata to allow SBW modules to negotiate their data types in a more sophisticated way. This will resolve ambiguity of data types such as strings, which could represent a filename, an SBML model, or any other string. This will also allow for more interesting user interfaces.
We will also spend more time with the development of additional categories, possibly even with an enforcement policy
that ensures that the methods of the category are implemented. Categories proved immensely effective as we have seen with
the SBW menu and the SBML Exporter category.
6
SUMMARY
SBW represents a flexible framework allowing the integration of software components in a language-neutral way. The core
framework is available for many operating systems, among them WIN32, Linux, and OS X. Binding libraries are available
Bergmann, Vallabhajosyula and Sauro
Page 19 of 21
for the most common programming languages: C/C++, the .NET languages, Delphi, Java, Python, and Matlab. Other programming languages can be supported by calling the C bindings.
7
AVAILBILITY
The growing collection of SBW-enabled applications are available for analyzing, modeling, simulating, and visualization
of SBML models. SBW is stableopen source and free downloads are available from the project website at
<http://www.sys-bio.org>.
ACKNOWLEDGMENTS
The initial work has been funded by the Japan Science and Technology Corporation under the ERATO Kitano Systems Biology Project. Funded through the generous support of ERATO, DARPA (contract number MIPR 03-M296-01) and the DOE
(under Grant No. DE-FG02-04ER63804, “Computational Resources for GTL”). Original Program Investigators: Hiroaki Kitano, John Doyle, in collaboration with Hamid Bolouri, Andrew Finney, and Mike Hucka.
We wish to acknowledge in particular the authors of BioSPICE, CellDesigner, COPASI, Dizzy, Oscill8, and Virtual
Cell, as well as the SBML community for their support. We also thank Anastasia Deckard, Klaus Maier and Sri Rama Krishna Paladugu. Finally we would like to thank our user-base for their support and feedback.
REFERENCES
Alves R, Antunes F, Salvador A. (2006) Tools for kinetic modeling of biochemical networks. Nat Biotechnol., 24.6: 667-72.
Bergmann, Frank T. (2006). SBML Layout Viewer. <http://sys-bio.org/Layout/> [accessed May 26, 2006].
Bornstein, B. J., Keating, S., and Finney, A. (2006). libSBML. <http://sbml.org/software/libsbml/> [accessed May
26, 2006].
Blüthgen, N., Bruggeman, F.J., Legewie, S., Herzel, H., Westerhoff, H.V., Kholodenko, B.N. (2006) Effects of sequestration
on signal transduction cascades. FEBS Journal, 273(5): 895-906.
Chance, B. (1943) The kinetics of the enzyme-substrate compound of peroxidase. J. Biol. Chem. 151, 553-577.
Chickarmane, Vijay, Sri Rama Krishna Paladugu, Frank T. Bergmann, and Herbert M. Sauro. 2005. Bifurcation discovery
tool. Bioinformatics 21.18: 3688-3690.
Chickarmane, V, Troein, C Ulrike, Nuber A, Sauro HM, and Peterson C, (2006), PLoS Comp Bio, 2(9), Transcriptional
Dynamics of the Embryonic Stem Cell Switch
Cohen, S. D., and A. C. Hindmarch. 1996. CVODE, a stiff/nonstiff ODE solver in C. Computers in Physics 10.2: 138-143.
Conrad, Emery. 2006. Oscill8. <http://oscill8 .sourceforge.net> [accessed May 26, 2006].
Doedel, E. J. 1981. AUTO: a program for the automatic bifurcation analysis of autonomous systems. Proceedings of the 10th
Manitoba Conference on Numerical Mathematics and Computing, 265-284.
Duarte, N.C., Herrgard, M.J., and Palsson, B.O. (2004) Reconstruction and validation of Saccharomyces cerevisiae iND750,
a Fully Compartmentalized genome-scale Metabolic Model, Genome Research, 14, No.7, 1298-1309.
Finney, Andrew, and Michael Hucka. 2003. Systems biology markup language: level 2 and beyond. Biochemical Society
Transactions 31.6 (2003): 1472-1473.
Fruchterman, T. M. J., and E. M. Reingold. 1991. Graph drawing by force-directed placement. Software - Practice and
Experience 21.11: 1129-1164.
Garkinkel, D. (1968). A machine-independent language for the simulation of complex chemical and biochemical systems.
Comput. Biomed. Res. 2, 31–44.
Garvey, Thomas D., Patrick Lincoln, Charles John Pedersen, David Martin, and Mark Johnson. 2003. BioSPICE: access to
the most current computational tools for biologists. OMICS 7.4: 411-420.
Gauges, Ralph, Ursula Rost, Sven Sahle, and Katja Wegner. 2006. A model diagram layout extension for SBML.
Bioinformatics (to appear).
Gibson, M. A. and J. Bruck. 1999. Efficient exact stochastic simulation of chemical systems with many species and many
channels. Journal of Physical Chemistry A 104:1876-1889.
Gillespie, D. T. 1976. A general method for numerically simulating the stochastic time evolution of coupled chemical
species. Journal of Computational Physics 22: 403-434.
Gillespie, D. T. 2000. The chemical Langevin equation. The Journal of Chemical Physics 113.1: 297-306.
Bergmann, Vallabhajosyula and Sauro
Page 20 of 21
Hedley, W.J., Nelson, M.R., Bullivant, D.P. and Nielsen, P.F. 2001. A short introduction to CellML. Phil. Trans. Roy. Soc.
A: Math. Phys. Engrg. Sci. 359.1783: 1073-1089.
Hindmarch, A. C. 1983. ODEPACK: a systematized collection of ODE solvers. Scientific Computing.
Hucka, Michael, Andrew Finney, Herbert M. Sauro, Hamid Bolouri, John C .Doyle, and Hiroaki Kitano. 2003. The systems
biology markup language (SBML): a medium for representation and exchange of biochemical network models.
Bioinformatics 19.4: 524-531.
Hucka, Michael, Andrew Finney, Herbert M. Sauro, John C. Doyle, and Hiroaki Kitano. 2002. The ERATO Systems Biology
Workbench: enabling interaction and exchange between software tools for computational biology. Pacific Symposium on
Biocomputing. 450-261.
E Klipp, R Herwig, A Kowald, C Wierling, and H Lehrach. Systems Biology in Practice. Wiley-VCH: 2005. ISBN 3-52731078-9.
Geva-Zatorsky, N., Rosenfeld, N., Itzkovitz, S., Milo, R., Sigal, A., Dekel, E., Yarnitzky, T., Liron, Y., Polak, P., Lahav, G.,
and Alon, U. (2006) Oscillations and Variability in the p53 system. Molecular Systems Biology, 2, 1-13.
Kholodenko, B.N. (2000) Negative feedback and ultrasensitivity can bring about oscillations in the mitogen-activated protein
kinase cascades. Eur. J. Biochem., 267: 1583-1588.
Kholodenko, B.N. (2006) Cell-signalling dynamics in time and space. Nat. Rev. Mol. Cell Bio., 7: 165-176.
Kitano, Hiroaki. 2005. International alliances for quantitative modeling in systems biology. Molecular Systems Biology.
Kitano, Hiroaki, Akira Funahashi, Yuhiko Matsuoka, and Kanae Oda. 2005. Using process diagrams for the graphical
representation of biochemical networks. Nature Biotechnology 23.8: 961-966.
Kolpakov, F. A. 2002. BioUML - framework for visual modeling and simulation of biological systems. Proceedings of the
International Conference on Bioinformatics of Genome Regulation and Structure.
Le Novere, Nicholas, et al. 2005. BioModels Database: a free, centralized database of curated, published, quantitative kinetic
models of biochemical and cellular systems. Nucleic Acids Research 34: 689-691.
Lloyd, C.M., Halstead, M.D.B. and Nielsen, P.F. 2004. CellML: Its future, present and past. Progress in Biophysics and
Molecular Biology. 85.2-3:433-450.
Mathworks, The. 2006. MATLAB and Simulink for Technical Computing. <http://www mathworks.com/>
[accessed May 26, 2006].
Microsoft. 2006a. Internet Information Services.
<http://www.microsoft.com/Windows
Server2003/iis/default.mspx> [accessed May 26, 2006].
Microsoft. 2006b. Visual Studio 2005. <http://msdn.microsoft.com/vstudio/> [accessed May 26, 2006].
Mono-Project. 2005. ASP.NET-Mono. <http://www.mono-project.com/ ASP.NET> [accessed May 26, 2006].
Netlib. 2006. LAPACK - Linear Algebra PACKage. <http://www.netlib.org/lapack/> [accessed May 26,
2006].
Neves, S.R. and Iyengar, R. 2002. Modeling of signaling networks. BioEssays, 24.2: 1110-1117.
Olivier, Brett G., Johann M. Rohwer, and Jan-Hendrik S. Hofmeyr. 2005. Modelling cellular systems with PySCeS.
Bioinformatics 21.4: 560-561.
OMG. The OMG's CORBA website. 2006. <http://www.omg.org/corba/> [accessed May 26, 2006].
Pfeiffer, T., I. Sanchey-Valdenebro, J. C. Nuno, F. Montero, and S. Schuster. 1999. METATOOL: for studying metabolic
networks. Bioinformatics 15.3: 251-257.
Ramsey, S., D. Orrell, and H. Bolouri. 2005. Dizzy: stochastic simulation of large-scale genetic regulatory networks. Journal
of Bioinformatics and Computational Biology 3.2: 415-36.
Reed, J.L., Vo, T.D., Schilling, C.H., and Palsson, B.O. (2003) An expanded genome-scale model of Escherichia coli K-12
(iJR904 GSM/GPR), Genome Biology, 4 No.9, R54.1-R54.12.
Ruoff, P., M. K. Christensen, J. Wolf, and R. Heinrich. 2003. Temperature dependency and temperature compensation in a
model of yeast glycolytic oscillations. Biophysical Chemistry 106.2: 179-192.
Sauro, H.M. (2000) Jarnac: A System for interactive metabolic analysis. Animating the cellular map. Intl. BioThermoKinetics
Meeting, Eds. Hofmeyr, J-H.S., Rohwer, J.M. and Snoep, J.L., Stellenbosch Univeristy Press. Chapter 33, 221-228.
Sauro, Herbert M., et al. (2003). Next Generation Simulation Tools: the Systems Biology Workbench and BioSPICE
integration. OMICS, 7.4: 35-372.
Sauro, H.M. and Kholodenko, B.N. (2004) Quantitative analysis of signaling networks. Prog. Biophys. Mol. Biol., 86: 5-43.
Sauro, Herbert M., and Frank T. Bergmann. (2006). SBW simulation API. <http://sbw.kgi.edu/ downloads/SimAPI.pdf>
[accessed May 26, 2006].
Schilling, C.H., Covert, M.W., Famili, I., Church, G.M., Edwards, J.S., and Plasson, B. (2002) Genome-scale metabolic
model of Helicobacter pylori 26695. J. Bacteriology, 184, No.16, 4582-4593.
Bergmann, Vallabhajosyula and Sauro
Page 21 of 21
Shannon, P., Markiel, A., Ozier, O., Baliga, N.S., Wang, J.T., Ramage, D., Amin, N., Schwikowski, B. and Ideker, T. (2003)
Cytoscape: A software environment for integrated models of biomolecular interaction networks. Genome Research. 13:
2498-2504.
Simpson, M., Cox, C. D. and Sayler, G. S. (2003) Frequency domain analysis of noise in autoregulated gene circuits. PNAS,
100.8 : 4551-4556.
Somogyi, R. and Greller, L.D. (2001). The dynamics of molecular networks: applications to therapeutic discovery. Drug
Discovery Today, 6.24:1267-1277.
Sun Microsystems, Inc. (2006). Java RMI over IIOP. <http://java.sun.com/products/rmi-iiop/> [accessed
May 26, 2006].
Tyson, J.J., Chen, K. and Novak, B. (2001). Network dynamics and Cell physiology. Nature Reviews on Molecular and Cell.
Biology, 2:908-916.
Vallabhajosyula, Ravishankar Rao, Vijay Chickarmane, and Herbert M. Sauro. (2006). Conservation analysis of large
biochemical networks. Bioinformatics 22.3: 346-353.
W3C. 2006. Web Services. <http://www.w3.org/ 2002/ws/> [accessed May 26, 2006].
Wellock, Cameron, V. Chickarmane, and H. M. Sauro. 2005. The SBW-MATLAB interface. Bioinformatics 21.6: 823-824.
ZIB (Zuse Institute Berlin). 2003. Affin-invariant Newton Techniques (ANT) - NLEQ2.
<http://www.
zib.de/Numerik/numsoft/ANT/nleq2.en.html> [accessed May 26, 2006]