Frank Bergmann

SED-ML Nested Simulation Proposal v2

2012-01-18T23:16:00.001-08:00

With the start of the new year it is time to get the Nested Simulation Proposal for SED-ML ready for wide-spread adoption. I believe nested simulations are vital for SED-ML so that we can cover a much larger variety of simulation experiments. I think it is especially important NOT to create a new simulation class for every single different simulation we perform on a model. By just defining two simulation classes:

One Step: which brings the model to the next desired output step.
Nested Simulation: which allows running over another simulation task, while changing multiple models parameters with computed values from ranges.

it is possible to construct a large number of simulations that are currently carried out. I’ve taken these past weeks to fully flesh out all the details and the document is now available from Nature Proceedings:

http://precedings.nature.com/documents/4257/version/2

The new version describes in detail all attributes and elements and features a number of examples (see below)

All features have been implemented in libSedML. The major change is that internally libSedMLRunner no longer produces a simple 2d array of data, but a NuML result set.

NOTE: This proposal only covers the generation of the data, not the visualization. In other words this proposal allows to generate n-dimensional data sets, while currently our DataGenerators can not access the values. I believe the two issues should be handled in different proposals.

Examples

Just a brief overview of the examples:

Steady state scan
Pulsing a parameter during a simulation
Multiple Stochastic Traces
Timecourse scan
2D Steady State scan

Availability

As indicated above, the proposal is implemented in libSedML, a also released a new version of the SED-ML Web Tools, that can simulate all of the above examples.

Just for completeness sake: here the link to the old version:

Doc: http://precedings.nature.com/documents/4257/version/1
Examples: http://frank-fbergmann.blogspot.com/2010/03/nested-simulation-experiments.html

FBC Package & SBMLToolbox 4.1.0 Getting Started

2012-01-18T10:27:00.001-08:00

Today the SBML Team released version 4.1.0 of the SBML Toolbox. The news? It can be used with the SBML Level 3 Flux package. So what do you need to get it set up?

Grab the beta FBC package for your system from:
- Windows / OSX we have binaries for you: http://sourceforge.net/projects/sbml/files/libsbml/5.3.0/experimental/binaries/
- Linux: unfortunately we don’t have binaries as the matlab versions on linux are highly subjective to your libc / libstdc++. Instead please grab the source package: http://sourceforge.net/projects/sbml/files/libsbml/5.3.0/experimental/src/ , and configure using CMake (the key points to watch out is to pass along the parameters: ENABLE_FBC=ON, WITH_MATLAB=ON, after that simply make the dependencies happy, I believe you need to pass along the MATLAB_ROOT_PATH). After the installation the only thing I had to do on my machine is to set the environment variable LD_PRELOAD=<location of your systems libstdc++> and then it works all right.
Grab SBML Toolbox 4.1.0: http://sourceforge.net/projects/sbml/files/SBMLToolbox/4.1.0/
unzip / start Matlab / change into the toolbox directory, run the ‘install’ command.
run the tests to be sure all is working fine for you:
```
cd Test
RunTest
```

Please let us know how things are going for you!

LibSBML 5.3.0 Released & SBML Render Package

2011-12-23T19:49:00.001-08:00

Just in time for Christmas we have just released LibSBML 5.3.0. The essentials are:

like for the 5.2.0 release we again provided an alternative source archive that contains updated snapshots of all currently available SBML Level 3 Packages:

Layout (updated)
Flux Balance Constraints (updated)
Rendering (new)
Hierarchical Model Composition (updated)
Spatial Processes (updated)
Groups
Required Elements

SBML Rendering Package

The newest addition is a port of Ralph Gauges libSBML 4 implementation patch to the libSBML 5 package API. It supports both serialization as SBML Level 3 package and Level 2 annotation. However, there were some minor changes along the way:

Most changes involve the plugin API, instead of directly accessing the render information from the Layout objects, you use the plugin API:

  Model* model = doc->getModel();
  
  LayoutModelPlugin *plugin = (LayoutModelPlugin*) model->getPlugin ("layout");
  
  if (plugin == NULL || plugin->getNumLayouts() == 0)
  {
    cerr << "The loaded model contains no layout information, please add these first." << endl;
    return 3;
  }
  
  RenderListOfLayoutsPlugin *lolPlugin = (RenderListOfLayoutsPlugin*) plugin->getListOfLayouts()->getPlugin("render");
  if (lolPlugin != NULL && lolPlugin->getNumGlobalRenderInformationObjects() > 0)
  {
    cout << "The loaded model contains global Render information. " << endl;    
  }

the the plugin classes then have all the elements you would need. The Render Extension extends three classes:

ListOfLayouts: Entry point for the ListOfGlobalRenderInformation

Layout: Entry point for the ListOfRenderInformation

GraphicalObject: allows to set the role of a graphical object in order to pin a specific render style to it.

There also is a minor change with the way that the XML is written out. Each attribute defined in the Render specification, is written out as belonging to the “render” namespace. With one exception, while reading through the Render specification I could not find one different between the BoundingBox defined in the Layout extension and the one used by the Render LineEndings. So rather than re-implementing another BoundingBox in a different namespace, I made the LineEndings reuse the layout bounding box.

Let me know how the extension is working for you.

SBW goes Portable

2011-12-11T15:13:00.001-08:00

Portable Applications, are applications that you can easily take with you on your USB stick. This allows to use your applications on all Windows machines by simply plugging in the stick. I’m pleased to announce a first prototype that will make the Systems Biology Workbench available for the portableapps.com framework. Here the download:

http://sourceforge.net/projects/sbw/files/sbw/portable/

To install, simply launch portable apps, and then click on “Install a new App”:

It will install the following applications:

While the launcher only exposes: JDesigner,Jarnac, JarnacLite, the Simulation Tool, SBML Translator, SBML Layout Viewer, AutoLayout and the C# Inspector, the full SBW installation is available.

If you need custom launchers for more applications, let me know (Possible candidates: BioModels Importer, Jacobian Viewer, Convert SBML, Shutdown SBW).

Please let me know whether this is working for you.

BAD NEWS:

Unfortunately we won’t be able to have SBW be part of the Portable Apps dictionary since some SBW components use .NET and portable apps do not consider .NET widely enough spread. (Even though it appears that it was on 90% of Windows machines in 2010, and is now part of windows update, and thus *everyone* updating their machine is likely to have it installed.) But there goes me rambling …

New SBML Translator Application online!

2011-11-13T21:52:00.001-08:00

As second application I’m glad to announce the new SBML Translator application:

http://sysbioapps.dyndns.org/Translator

The application is a major redesign from the basic version. Its features:

multiple file upload (with drag & drop for chrome and firefox)
translation of files via URL
pasting of SBML
Syntax Highlighting of the result
downloading of translation with proper mime-type / extension

The translators have been updated to ensure that assignment rules are sorted correctly in the translation (an issue that seems to have caused problems in the past). As soon as the SBFC project comes along I plan to include their translators as well. As always a screencast says more than words:

Unable to display content. Adobe Flash is required.

As always I’d love to hear any feedback that you have!

libSBML 5.2.0 released

2011-11-12T10:45:00.001-08:00

This morning Sarah sent the announcement that a new version of libSBML is available for download from:
http://sf.net/projects/sbml/files/libsbml/5.2.0/
New this time around is that we also provide binaries for all the SBML Level 3 Extension packages. So if you are interested in providing software support for:

FBC
COMP
LAYOUT
GROUPS
REQ
SPATIAL

you can simply download your favorite binaries (including language bindings) from the experimental directory.

New Features

There are two new features I want to bring to your attention, that is the facility for custom validators and converters. By inheriting form SBMLConverter or SBMLValidator it is now possible for your application to quickly check for specific aspects of documents that is important to you.

Here just one example on how you could check that your SBML model does not contain Algebraic Rules or Fast reactions if your application does not support them.

/**    2:  * Declares a custom validator to be called. This allows you to validate 
 * any aspect of an SBML Model that you want to be notified about. You could 
 * use this to notify your application that a model contains an unsupported 
 * feature of SBML (either as warning). 
 * 
 * In this example the validator will go through the model and test for the 
 * presence of 'fast' reactions and algebraic rules. If either is used a 
 * warning will be added to the error log. 
 */
class MyCustomValidator : public SBMLValidator
{
public:
  MyCustomValidator() : SBMLValidator() {}
  MyCustomValidator(const MyCustomValidator& orig) : SBMLValidator(orig) {
  
  }
  virtual ~MyCustomValidator() {}
  
  virtual SBMLValidator* clone() const { return new MyCustomValidator(*this); }
  
  virtual unsigned int validate() {
    // if we don't have a model we don't apply this validator.
    if (getDocument() == NULL || getModel() == NULL)
      return 0;
  
    // if we have no rules and reactions we don't apply this validator either
    if (getModel()->getNumReactions() == 0 && getModel()->getNumRules() == 0)
      return 0;
  
    unsigned int numErrors = 0;
    // test for algebraic rules
    for (unsigned int i = 0; i < getModel()->getNumRules(); i++)
    {
      if (getModel()->getRule(i)->getTypeCode() == SBML_ALGEBRAIC_RULE) {
        
        getErrorLog()->add(SBMLError(99999, 3, 1, 
          "This model uses algebraic rules, however this application does not support them.",
          0, 0, 
          LIBSBML_SEV_WARNING, // or LIBSBML_SEV_ERROR if you want to stop
          LIBSBML_CAT_SBML // or whatever category you prefer
          ));
        
        numErrors++;
      }
    }
  
    // test for fast reactions
    for (unsigned int i = 0; i < getModel()->getNumReactions(); i++)
    {
      // test whether value is set, and true
      if (getModel()->getReaction(i)->isSetFast() && 
          getModel()->getReaction(i)->getFast()) {
  
        getErrorLog()->add(SBMLError(99999, 3, 1, 
          "This model uses fast reactions, however this application does not support them.",
          0, 0, 
          LIBSBML_SEV_WARNING, // or LIBSBML_SEV_ERROR if you want to stop
          LIBSBML_CAT_SBML // or whatever category you prefer
          ));
  
        numErrors++;
  
      }
    }
  
    return numErrors;
  }
  
  
};
  
  
int
main (int argc, char *argv[])
{
  if (argc != 2)
  {
    cout << endl << "Usage: addCustomValidator filename" << endl << endl;
    return 1;
  }
  
  const char* filename   = argv[1];
  
  // read the file name
  SBMLDocument* document = readSBML(filename);
  
  // add a custom validator
  document->addValidator(new MyCustomValidator());
  
  // check consistency like before
  int numErrors = document->checkConsistency();
  
  // print errors and warnings
  document->printErrors();
  
  // return number of errors
  return  numErrors;
  
}

Linux Packages

For this release we provide again DEB and RPM files with binaries compiled on CentOS 4.6 and Ubuntu 8. This means they use a libc version that is reasonably old and will not cause problems on newer distributions.

Listening to feedback from our users the default install prefix has been changed to /usr. And we also include language bindings in them.

The plan was to use the OpenBuildService (OBS), but unfortunately I was not yet able to create binaries with language bindings for all different distributions. I hope we can sort this out for the next release.

Introducing sysbioapps/Layout

2011-11-05T19:48:00.001-07:00

Ever since the SBW applications have been pulled from sys-bio.org and are only available via IP I am working on a new version for each of these applications. Today I’ve made the new version of my Layout web application available:

http://sysbioapps.dyndns.org/Layout

See it live:

Unable to display content. Adobe Flash is required.

Features

The new application has the same basic features as the old one:

upload of an SBML file
displaying SBML Layout / SBML Render Format
displaying JDesigner / JDesigner 2 / CellDesigner annotation
generating a layout
exporting images / SVG / PDF

New in this version:

multiple file support
Chrome / Firefox: upload multiple files
Chrome / Firefox: drag and drop files onto the web site to upload
support for SBGN-ML

Implementation

The new version has been implemented using ASP.NET MVC3 and JQuery / JQueryUI. The actual heavy lifting is performed by the SBML Layout Library. The PDF export is made possible through sbml2tikz, followed by a compilation by pdflatex.

As always any feedback is welcome.

SED-ML Web Tools & KISAO

2011-10-08T20:40:00.001-07:00

SED-ML uses KISAO to annotate simulation algorithms with information of what kind of simulation should be performed. Until today the SED-ML Web Tools only displayed the term identifier. This has changed, now the terms will be resolved and displayed:

To make this work I’ve modified LibSedML to resolve all KISAO terms found. This is now part of the Algorithm object, and can be accessed through the Term property.

Unfortunately KISAO is now only available in OWL format. This means people have to ‘reason’ over the document in order to find out even the most basic things. While the EBI provides a ‘libKISAO’, this library is only available for Java.

In the end I’ve decided to convert the OWL file periodically in a more readable format:

 <term id='KISAO:0000377' 
        name='one-step method'>
   <definition> <![CDATA[A numerical method 
     for differential equations which uses one 
     starting value at each step.]]>
   </definition>

   <similarTo>KISAO:0000020</similarTo>
   ...
   <similarTo>KISAO:0000031</similarTo>




   <ancestor>KISAO:0000000</ancestor>

   <descendent>KISAO:0000261</descendent>
   <descendent>KISAO:0000380</descendent>
   <descendent>KISAO:0000064</descendent>
   <descendent>KISAO:0000286</descendent>
 </term>

I will update that file periodically and have it compiled into libSedML, if you would like to have a look at it, you can access it here:

kisao.xml

sys-bio.org web applications down

2011-10-07T18:52:00.001-07:00

The web site of the Saurolab was moved to a different machine the domain sys-bio.org has been transferred to that machine. As a result, all applications that previously ran on sys-bio.org are no longer available via their old URLs. The old server is still available via its IP:

http://128.208.17.26/

That web site also still hosts the web applications:

Layout: http://128.208.17.26/Layout/
Simulation: http://128.208.17.26/Simulation2005/
Translation: http://128.208.17.26/SBMLTranslator/
Web Services: http://128.208.17.26/SbwWebServiceCreatorInterface/

In the coming weeks I will update these applications and move them over to http://sysbioapps.dyndns.org.

LibSBML 5.1.0 (beta) Language Bindings with Packages

2011-09-05T08:39:00.001-07:00

COMBIN2011 is in full swing, a great meeting! I have heard from several people that they would like to play with the language bindings in different programming languages. With CMAKE it really is easy to create those bindings, so the archive below includes the Windows 32 bit bindings for:

Java
C#
Python (2.7)

Of the following beta packages:

comp
fbc
groups
layout
req
spatial

For more information of these packages please see the SBML Community wiki.

The bindings are build with libxml2 and compression libraries statically linked in, and the static MSVC bindings, so they won’t need any further dependencies. So without further ado, here the link:

http://cl.ly/1K3i07323y2e14103d3J

Please let me know about any problems with these bindings.

SBGN-ML Render Comparison

2011-08-25T15:12:00.001-07:00

SBGN-ML, the markup language developed as part of the libSBGN project, is nearing it’s Milestone 2 release. The SBML Layout library currently fully implements the Process Diagram notation of SBGN-ML. (Work on implementing Activity Flow / Entity Relationship diagrams has started but is not anywhere close to ready.)

This is to announce a new online application:

http://sysbioapps.dyndns.org/RenderComparison/

This is how the page looks:

The site displays all current SBGN files from ProcessDiagram, ActivityFlow and EntityRelationship. Only the SBMLLayout column will be rendered every time. Information from PathVisio and SBGN-ED are cached and updated periodically.

You can change the directory, that is being displayed by selecting the Customize button on the top of the page, these options are available:

Where a different URL can be chosen (you could for example display the examples from Milestone 1 or the general examples). You also can display or hide individual columns.

As last option you can directly upload or point to any URL of an SBGN file that should be rendered.

More at COMBINE …

Release of libSBML 5.1.0 (b0)

2011-08-25T11:24:00.001-07:00

And another release done in time for ICSB and COMBINE. This latest release of libSBML not only contains a number of bug fixes and general improvements, such as:

the ability to obtain elements via getElementBySId() and getElementByMetaId()
a better way to build Matlab bindings
Release Announcement
Downloads

But also a new Conversion API.

Conversion API

So what is so special about it, and how would you use it? Previously we had a number of additional functions such as:

setLevelAndVersion
expandFunctionDefinitions
expandInitialAssignments

on the SBMLDocument. This meant that the document had to know how to do all these operations. Now we went ahead and introduced just one more level of abstraction:

SBMLDocument::convert(ConversionOptions options)

When called this function will look through a registry and find the best converter that matches the options (uhm … or none, if that might be the case, in which case the conversion would fail). Then that converter runs on the document to change it. And reports the status.

We have created converters for the tasks mentioned above: setLevelAndVersion, expandFunctionsDefinitions, expandInitialAssignments and also stripPackage (which removes a specific SBML L3 package from the current document).

Registry

The biggest advantage of course is that all these converters are available from a registry, that means:

it is possible to replace existing converters
and to add new ones!

I have started with a first flattening converter (not complete yet) for the COMP package. So this might be something that package writers might want to consider, perhaps they would like their package to serialize to a Level 2 annotation or some such thing!

More on this at COMBINE, I hope to see you there.

SBW 2.8.3 Released

2011-08-23T23:37:00.001-07:00

Just before the ICSB, here a new release of the Systems Biology Workbench. Exciting for me, lots of updates on the standard support:

improved support for SBGN-ML
improved support for SED-ML
(some fixes for SBRML)

There also is a brand new JDesigner and Jarnac available, with lots of goodies. So please grab the new version from SourceForge before it gets cold:

SBW 2.8.3

Some of you might wonder what happened to the Linux and OSX release. I’m afraid it did not get done in time. Even though all modules and code has been updated to compile fine on 32 bit and 64bit Linux. So where is the holdup? As it turns out the latest distro’s don’t come with Mono 2.10, so I figured I wait a bit longer to make that release.

If someone needs those binaries sooner let me know and I upload them.

Release of the new SBML Online Validator

2011-08-10T18:02:00.001-07:00

I’m pleased to announce that the new SBML online validator is now available for use:

http://sbml.org/Facilities/Validator/

The new validator has a number of new features, the most prominent:

it allows to queue longer running validations
it allows SBML models to be directly pasted
it also looks better thanks to JQuery / JQueryUI

Of course it is still possible to use the validator remotely. For this we provide a REST API as before:

http://sbml.org/Facilities/Documentation/Validator_Web_API

and additionally it is also possible to use the service via a W3C web service. Here the link to the WSDL:

http://sbml-validator.caltech.edu:8888/validator_ws/services/LibSBML?wsdl

SBML Software Index on http://sysbioapps.dyndns.org

2011-07-31T15:22:00.001-07:00

I’ve spend the weekend to update the sysbioapps website. It does provide a bit more information now and I’ve also fixed a minor issue with testing the SED-ML web services. Most notably however, I have placed the SBML Software Index online:

http://sysbioapps.dyndns.org/SoftwareMatrix

The Software Index provides the information from the SBML Software Survey (that collects information about available software that supports SBML) using the PivotViewer. This makes it possible to ask specific questions about the software and find the information much faster than it would be possible with the static matrix / summary information that was available until now.

I am well aware of the fact that many in the Systems Biology community do not consider Silverlight to be a viable platform: I have been told to rewrite the solution in Flash or JavaScript to make it possible to run it on more devices. However, I lack the time to do so at this moment, and so provide this information in the hopes that it will be of use to some.

How to use the Index

On the left hand side you will find a panel with the available categories:

Where you can simply search for specific information, or select options from the categories (in the screenshot above: Category, Dependencies, … SBML Import/Export) you are interested in. Each category contains several options (above we see Import and Export listed for the SBML Import / Export category). According to the pivot guidelines options within a category are supposed to be orthogonal. Unfortunately that is not the case for SBML software (as there are packages that support Import and Export for example). I still chose to place them together into one category (otherwise the number of categories would have become unwieldy). The consequence of this is that when you select both checkboxes, queries will be of the form:

SELECT TOOLS WITH EITHER SBML IMPORT _ O R _ SBML EXPORT

rather than

SELECT TOOLS WITH EITHER SBML IMPORT _ A N D _ SBML EXPORT.

With this in mind I believe it is still possible to query the data easily (although I’m aware of at least 2 people that would disagree with this statement). I will revisit this as soon as Silverlight 5 is released this promises a modification of that behavior.

I also would like to attract your attention to the controls on the top of the control:

this allows to configure how the information is displayed. You can choose to display the information either tiled to see all selected tools at a glance:

Or as a bar graph, which makes it easy to compare specific aspects of the tools (such as which tools are available on which platform):

I will continue to update the index whenever new entries are submitted.

KNOWN ISSUES

Unfortunately at the time of this writing it was not possible to run the site using Moonlight. I know that the mono team is working tirelessly and so hope that this will be resolved in due time. Until then the index is only available on OSX and Windows. I’m sorry for the inconvenience.

SED-ML Web Service

2011-07-23T18:16:00.001-07:00

With the latest version of the SED-ML Web Services I also released a first version of a web service. It is online here:

http://sysbioapps.dyndns.org/SED-ML%20Web%20Tools/Services/SedMLService.asmx

For the WSDL use:

http://sysbioapps.dyndns.org/SED-ML%20Web%20Tools/Services/SedMLService.asmx?WSDL

Current functionality includes converting between SED-ML and SED-ML script, validating SED-ML and to generate SED-ML from scratch.

You can access the methods using SOAP as well as REST (HTTP GET / HTTP POST) requests.

Updated SED-ML Web Tools (now with editing of SED-ML descriptions)

2011-07-23T16:34:00.001-07:00

I’ve just released a new version of the SED-ML Web Tools they as always available from:

http://sysbioapps.dyndns.org/SED-ML Web Tools/Home/

The new version allows to edit the loaded model either by directly manipulating the XML, or by altering the model using the SED-ML Script Language.

Here a simple tutorial of creating a new SED-ML description from an SBML model and then modifying it using SED-ML Script.

Unable to display content. Adobe Flash is required.

As always I look forward to your feedback. To make it easier to collect I’ve signed up with idea informer, so there is now an orange feedback button right there on the page. That makes it easy to request your feature requests:

Creating SED-ML for SBML models

2011-07-03T18:09:00.001-07:00

I have just released a new version of the SED-ML Web Tools. This version creates SED-ML models for SBML files. Have a look here:

http://sysbioapps.dyndns.org/SED-ML%20Web%20Tools/Home/Create

All that is needed is to fill out this form:

After that the SED-ML description can be executed, or downloaded. More advanced options (such as creating SED-ML descriptions for CellML models) is available in the SED-ML Script Editor:

sf.net/projects/libsedml/files/

SED-ML Web Tools, SED-ML Script Editor & CellML Simulation Support

2011-06-26T19:49:00.001-07:00

I’ve just upgraded the SED-ML Web Tools to a newer version.

http://sysbioapps.dyndns.org/SED-ML%20Web%20Tools/Home/

This version includes several bug fixes, as well as an experimental version of CellML simulation support. The CellML simulation support is thanks to an executable based on the CellML API provided by David Nickerson.

To accommodate this there have been several changes to the LibSedML API, where previously the API would have properties like .SBML or functions like GetSBMLId(), now these functions are hidden behind a native interface IModelingLanguage that will be populated based on the Model source URN as provided in the SED-ML file. This should make it easy to provide support for other languages such as NeuroML and VCellML as well.

I have also released a new version of the SED-ML Script editor. It now allows to open SBML or CellML files directly, for which then a rudimentary SED-ML file will be generated. Later it can be modified for more complex experiments. It also provides SED-ML validation capabilities. This time it is a windows only release (since I only have the CellML simulator as windows binary). It is available from SourceForge:

sf.net/projects/libsedml/files/

Introducing the SED-ML Web Tools

2011-06-12T18:56:00.001-07:00

I’ve spend the weekend working on a new set of tools for simulating and Validating SED-ML files. They are online now under:

http://sysbioapps.dyndns.org/SED-ML Web Tools

Let us first take a brief tour around the site:

Unable to display content. Adobe Flash is required.

Let me point just a couple of things.

Simulation

The current implementation will only simulate SBML files, using RoadRunner. As soon as I find time to update it I will add additional simulators. Currently 3D plots won’t work either. And of course simulation will only work if the model files are either:

accessible via URNs
accessible via WEB
included in the archive.

Simulation already implements the Nested Simulation Proposal.

Validation

The new thing about the validation is that it also provides an option to fix common errors. This feature can be used to upgrade SED-ML files that were created before SED-ML L1V1 was released! Simply click on ‘Fix common errors’, and then download the file again.

Stay tuned for further updates, the next steps will be to Create and Edit simulation experiment descriptions. Also planned are web services that make it easy to create SED-ML files!

Flux Balance Constraints for libSBML 5.0.0

2011-04-20T21:30:00.001-07:00

In time for todays session on SBML at HARMONY 2011 below a set of windows binaries that include libSBML 5.0.0 with the first beta version of the Flux Balance Constraints package. This time the package is implemented using the libSBML 5 extension API, which allows easy interaction with SBML Level 3 extensions.

For more information about the Flux Balance Constraints package, please have a look at the proposal page. On that page you find a detailed description about the current proposal, as well as links to examples.

Below you find full installers (including C#, Java, Perl and Python bindings) as well as python bindings for specific versions of Python.

If you don’t use Windows and still would like to try out the FBC package on your platform, I have a source package. In order to use this, download the libSBML 5 source distribution, as well as the fbc-package, then extract the fbc-package into the libsbml 5 source tree. Next, use CMake to configure the program to your needs, ensuring to set ENABLE_FBC=ON (or in the UI check the ENABLE_FBC option).

Please let me know how the package is working for you.

Support for SBGN-ML

2011-03-18T08:51:00.001-07:00

The recent release of SBW 2.8.2 adds support for SBGN-ML to the Systems Biology Workbench. This has been implemented using the SBML Layout Library, a .NET library that reads layout and rendering information from SBML models. This library is available separately and is used in many projects for example:

Of course it can also be used directly in any .NET application. The easiest way to get started is this:

install SBW (this will install the latest version of the layout lib)
start Visual Studio
add a reference to the SBMLExtension.dll as can be found in C:\Program Files (x86)\KGI\SBW\Layout to a new project (any .net language can be used).

Before we get started let us make sure we have some SBGN-ML files available, so at this point you would download a couple .sbgn files from the SBGN-ML repository.

The SBML Layout library converts all layout annotation it understands into the SBML Layout and Rendering Annotations. This is done by using:

var layout = Util.readLayoutFromFile(@”path/filename”);

where the filename could be an SBML file with layout annotations (JDesigner / JDesigner 2 annotations, SBML Layout / SBML Rendering information, CellDesigner annotations (experimental)) or an SBGN-ML file.

So if you wanted to convert SBGN-ML to a PNG file all you would need is a bit of code like this:

var layout = Util.readLayoutFromFile(filename);
var name = Path.GetFileNameWithoutExtension(filename);
var outname = Path.Combine(outDir, name + ".png");
layout.ToImage().Save(outname);

Limitations

At this point the library does not allow to write out SBGN-ML, if that is a feature that is important to you, please let me know.

Systems Biology Workbench (SBW) 2.8.2 Released

2011-03-18T00:13:00.001-07:00

We are pleased to announce the a release of the Systems Biology Workbench 2.8.2, available from:

http://sys-bio.org

The Systems Biology Workbench (SBW), is a software framework that allows heterogeneous application components-written in diverse programming languages and running on different platforms - to communicate and use each other's capabilities via a fast binary encoded-message system. Our goal was to create a simple, high performance, open-source software infrastructure which is easy to implement and understand. SBW enables applications (potentially running on separate, distributed computers) to communicate via a simple network protocol.

The interfaces to the system are encapsulated in client-side libraries that we provide for different programming languages.

Major changes in this release:

Updated JDesigner
Improved event support in RoadRunner,
Support of SBGN-ML (from SBML Layout)
Support of SED-ML L1V1 (from the Simulation Tool)

For a full list of changes see:

http://sys-bio.org/changelog.

As always we appreciate any feedback from users send to:

sbwteam@gmail.com

Enjoy

- Frank

Writing Plug-ins for the Simulation Tool – Part 2 – Setup - MonoDevelop

2010-08-09T10:04:00.001-07:00

MonoDevelop

MonoDevelop is a free IDE by Novell, that is available on all operating systems. IT does not feature a visual designer and has no advanced debugging facilities as we see them in Visual Studio but it still is quite good. So let us try and create a project by hand that would create the above plug-in. To make this authentic I add screenshots from doing it on OS X 10.6.

First let us start MonoDevelop and create a new Project:

Next let us load all the required libraries (I’ve copied the files from the SBW Installation, which is either in /Application/SBW/lib or ~/SBW/lib on Linux):

don’t forget to add System.Drawing and System.Windows.Forms from the GAC. The result should look like this:

(I went ahead and already copied some code for a plug-in into my project)

When this is loaded let us modify the project settings:

Here we can change the default namespace:

and the target machine (x86):

And the output directory:

The output directory should *for now* be the SBW lib directory (that is where all the C# assemblies are). Under Linux that would be:

~/SBW/lib

and on OSX it is /Applications/SBW/lib.

for now this should be the same as the SBW one.

All this has been saved in this project:

https://sourceforge.net/downloads/sbwsimtool/mono-sample-project/v1/

(It already uses the output directory /Application/SBW/lib as needed for OS X 10.6)

Unfortunately, similarly to Visual Studio Express there is no debugging support for Libraries … thus after a build you will need to start the simulation tool manually. (for example by double clicking on the Simulation Tool in /Applications/SBW (on OS X), or by launching ~/SBW/Simulation Tool … or if the SBW/bin is in the path by starting sbw_simultool.

if you test it with ‘oscli.xml’ you see this:

Writing Plug-ins for the Simulation Tool – Part 3 – Setup – Command Line

2010-08-05T13:49:00.003-07:00

Command Line

for the command line compilation 1st ensure that you have mono installed (http://mono-project.com/Downloads) (or on windows .NET 3.5 has to be installed). Next download the project we created above:

https://sourceforge.net/downloads/sbwsimtool/mono-sample-project/v1/

once extracted you can compile those files from the command line using:

gmcs *.cs -r:3rdParty/Microsoft.ComponentModel.Composition.Diagnostics.dll -r:3rdParty/SimulationToolAPI.dll -r:3rdParty/System.ComponentModel.Composition.dll -r:3rdParty/ZedGraph.dll -r:System.Windows.Forms -r:System.Drawing -target:library -platform:x86 -out:SimulationToolPlugin1.dll

on mono or:

\Windows\Microsoft.NET\Framework\v3.5\csc.exe -r:3rdParty/Microsoft.ComponentModel.Composition.Diagnostics.dll -r:3rdParty/SimulationToolAPI.dll -r:3rdParty/System.ComponentModel.Composition.dll -r:3rdParty/ZedGraph.dll -target:library -platform:x86 -out:SimulationToolPlugin1.dll *.cs

using microsofts compiler.

next you copy the resulting SimulationToolPlugin1.dll into the SBW directory:

~/SBW/lib on linux

/Applications/SBW/lib on OS X

c:\program files\KGI\SBW\roadrunner on win32 and

C:\Program Files (x86)\KGI\SBW\roadrunner on win64.

Now if you start the simulation tool you again should see the newly build plug-in in an unnamed category.

Writing Plug-ins for the Simulation Tool – Part 1 – Setup - Visual Studio

2010-08-05T13:49:00.001-07:00

With the release 2.8.1 of the Systems Biology Workbench the Simulation Tool now has a plug-in system based on MEF. This enabled me to enhance the simulation tool by both new layouts (changing the look and feel) as well as include new Simulation Experiments (like the Signal Injection plug-in). But now that we have this new plug-in API it also allows Y O U to write for it. And I’m excited to see Y O U R contributions. (I’m preparing a online repository for plug-ins). So how do you write these plug-ins? In this series I show you how to set up the IDE, so that you can start writing plug-ins, and then give a couple of examples of simple plug-ins one could write.

There are three ways that I envision people would write plug-ins:

using Visual Studio (2010 / 2008 / Express (free))
using MonoDevelop (http://monodevelop.com/)
using the command line (either on windows / posix)

Visual Studio

Visual Studio is my tool of choice when it comes to programming. Luckily most universities have contracts with microsoft, so ask your IT department for a copy (ours had 2010 Ultimate!). If they don’t you still have the option of getting a full version at dreamspark:

https://www.dreamspark.com/

Or of course the express editions will work:

http://www.microsoft.com/express/Default.aspx.

In the following I use screenshots from Visual Studio 2010, but the same will apply to Visual Studio 2008 and Express editions.

In order to ease the process of writing plug-ins I have created Visual Studio Templates. You can download them from:

http://sourceforge.net/downloads/sbwsimtool/visual-studio-templates/v1

simply download the Zip files and place them into:

C:\Users\fbergmann\Documents\Visual Studio 2010\Templates\ProjectTemplates\Visual C#

(just replace fbergmann with whatever your user name is). The same templates also work for Visual Studio 2008 where you place them into:

C:\Users\fbergmann\Documents\Visual Studio 2008\Templates\ProjectTemplates\Visual C#

Once this is done start Visual Studio and create a new project. Now in the template wizard you can simply select the SimulationToolPlugin template:

Once you confirm the new project will be created and loaded. The code already implements a simple plug-in. So let us set up the properties, so that we can run it. For this go to

Project\SimulationTool1Plugin Properties

Here you want to change the ‘Assembly Information’ to provide a short description of your plug-in an set your Copyright information. Next you might want to change the Default Namespace and the Assembly Name. My recommendation is to use the same name for both. The Assembly Name controls what the name of the resulting .DLL will be.

Next let us flip to the Build tab:

The key elements here are: The platform target: make sure to select x86 (as the simulation tool uses native libraries that are compiled for 32bit only). The output path:

you want to set this one *for now* to the directory of the Simulation Tool:

C:\Program Files (x86)\KGI\SBW\roadrunner

on 64-bit systems and:

C:\Program Files\KGI\SBW\roadrunner

on 32 bit systems.

Finally, let us set up how to start the debug session:

we want to start an external program:

C:\Program Files (x86)\KGI\SBW\roadrunner\SimDriverNET.exe or

C:\Program Files\KGI\SBW\roadrunner\SimDriverNET.exe

and we want to set the working directory to:

C:\Program Files (x86)\KGI\SBW\roadrunner or

C:\Program Files\KGI\SBW\roadrunner

(One note for express users: you won’t be able to start an external program in the express edition … I suggest you choose a Post Build Event to start the SimDriverNET executable by adding:

cd C:\Program Files\KGI\SBW\roadrunner && SimDriverNET.exe

as post build event now after every build you see the simdriver loaded with the new plugin, alas no debugging support.)

THAT IS IT … now we are ready to test our plug-in! close the property tab and press RUN. Our new plug-in is in an unnamed category so you can easily find it:

And when you load a model you can perform time course scans by entering values into it. Here a screenshot for the ‘oscli.xml’ file:

This is it you are all set up and ready to play with the plug-in.

Graphical Initializer for CompuCell 3D

2010-08-05T06:29:00.001-07:00

Currently, I’m with Herbert at the Indiana University, giving our SBW / CompuCell course. Over dinner we talked about how cumbersome it is to manually edit the Potts Initialization Files (PIF). This made me launch a new open source project, dubbed PifDesigner. I’ve put together a first prototype for 2D initializations, by either drawing, or initializing from images. The project is:

http://pifdesigner.sf.net

And here a screenshot of the new website.

Systems Biology Workbench (SBW) 2.8.1 Released

2010-07-31T00:29:00.001-07:00

We are pleased to announce the a release of the Systems Biology Workbench 2.8.1, available from:

http://sys-bio.org

The Systems Biology Workbench (SBW), is a software framework that allows heterogeneous application components-written in diverse programming languages and running on different platforms – to communicate and use each others' capabilities via a fast binary encoded-message system. Our goal was to create a simple, high performance, open-source software infrastructure which is easy to implement and understand. SBW enables applications (potentially running on separate, distributed computers) to communicate via a simple network protocol.

The interfaces to the system are encapsulated in client-side libraries that we provide for different programming languages.

There are a number of significant changes in this release:

The SBW Simulation Tool has been largely rewritten to allow for a variety of interactive simulation experiments. Thanks to a new plug-in mechanism it is easy to extend the Simulation Tool.
The script based modeling tool JarnacLite has been enhanced to make it easier to select Kinetic Laws to use.
RoadRunner now supports SBML Level 3 (with the same restrictions that applied to Level 2, i.e.: no algebraic rules, no delays, no fast flag).
Numerous bug fixes and usability improvements (such as a favorites menu bar, that allows to quickly edit / simulate SBML models in most applications).

For a full list of changes see: http://sys-bio.org/changelog.

With SBW 2.8.1 we have a new full release, with binaries for Windows, OSX (10.6) and Linux (tested with openSUSE 10.2 and Ubuntu Lucid). We are well aware that there are many more platforms available out there and regret not having the manpower to provide binaries for additional platforms. For this reason we have created a set of Virtual Machine (VMware/VirtualBox & Xen), hard drive image, and Live CD image (running openSUSE 11.2). For all of these the username is ‘sbw’ and password is ‘linux’.

For a list of modules included with the Systems Biology Workbench and a description of what they do please have a look at

http://jdesigner.sourceforge.net/

More details can also be found on my blog at:

http://frank-fbergmann.blogspot.com/

In case you are interested in instruction in how to use the Systems Biology Workbench join our tutorial at this year's ICSB.

As always we appreciate any feedback from users send to:

sbwteam@gmail.com

JarnacLite – Helping with Kinetics!

2010-07-30T21:43:00.001-07:00

The new version of JarnacLite, that is distributed with SBW 2.8.1 finally helps out in the arduous task of entering the kinetics. By using a customizable list of kinetic rate laws, it is now rather easy to construct models in this simple script format.

There are two steps to using this assistance:

Enter the reaction scheme: In order to be able to filter the available rate laws, a reaction scheme needs to be present. Special note should be given to the reversible notation:

S1 –> S2

would mean that a species S1 is converted to S2, while

S1 => S2

would mean that this reaction is reversible. Different kinetics will be suggested.
Once the reaction scheme is entered, pressing CTRL+SPACE or clicking the ‘Edit kinetic’ button will bring up the rate law selection dialog.
All that is left to do after selecting a rate law is to adjust the parameters.

And here an example of how this looks in practice:

The SBW Simulation Tool – Part 4 – Parameter Scanning

2010-07-30T21:33:00.001-07:00

It was always a bit cumbersome to perform parameter scans with our tools. Thus, with the new release of SBW a new plug-in was written that makes performing 1 or 2d parameter scans a snap. Be it steady state, or time course scans it should be easy to do. We support ranges (varying a parameter from a min to a max value in a number of steps), logarithmic ranges, or even just entering of specific parameter values to be used.

In order to be able to plot the scan results we interface with Gnuplot and allow users to tweak the gnuplot scripts. Resulting figures can then be exported as PDF or image.

Below a demonstration of the feature:

As you can see towards the end instead of just the floating species a wealth of output options is available.

The SBW Simulation Tool – Part 3 – The Script Plug-in

2010-07-30T21:18:00.003-07:00

The new SBW Simulation Tool also features a script plug-in. By embedding IronPython, the popular python scripting language is available to power users. The script plug-in has access to the currently active Simulator (i.e.: RoadRunner) in its current state. Via simple programming one can influence all model variables and perform all kind of perturbation experiments. Also exposed are a Gillespie Simulator, the LibStructural Library. Of course access is granted to the host application, the plug-in itself and the graph panel. Finally, it is possible to programmatically access the BioModels database.

Admittedly the current implemented console is no substitute for a real Python editor, however, it is suited for inspections of the current state. For advanced use we recommend writing Python scripts in a separate editor and executing these scripts from the python console.

Below a short introduction to the script console. More documentation about the available methods is to come soon!

The SBW Simulation Tool – Part 2 – Signal Injection

2010-07-30T21:18:00.001-07:00

The new simulation tool also comes with a couple of new interactive simulation experiments. The first one to be described here is the Signal injection plug-in as seen below.

It couldn’t be simpler to use. Simply load the model you want to experiment with, click the ‘add signal’ button, and choose parameter and signal type. Immediately the signal will be displayed in the graphing window and can be moved about with the mouse allowing you to directly see the influence this has.

For the sine (or square wave) signal type it is possible to change the angular frequency by holding down the CTRL key and moving the mouse.

Here a video demonstrating this feature:

The SBW Simulation Tool – Part 1 – Look And Feel

2010-07-30T21:17:00.001-07:00

The new release of the Systems Biology Workbench brings with it a largely rewritten version of the SBW Simulation Tool. Based on a new plug-in system, the Simulation Tool is now easily extendable. This allows not just to add new interactive simulation experiments, but also change the visual aspect of the Simulation Tool.

Changing the Look and Feel

By allowing the layout of the Simulation Tool customized by plug-ins it is now possible to find a layout that suits everyone. Here a the inbuilt examples:

But of course it would be easy to extend it … say by using a ribbon layout on windows:

I wonder what the simulation tool will look like tomorrow :)

In order to change the layout a user simply selects one of the options from the menu:

RoadRunner & Java (!?)

2010-04-29T12:43:00.001-07:00

Darren Wilkinson is here this week early for the Hackathon this weekend. One of his projects is CaliBayes, which addresses the issue of estimating parameters of kinetic laws. CaliBayes uses Java, and until now using RoadRunner required to go through the SBW Java bindings, to the SBW Broker to RoadRunner. It seems apparent, that this won’t deliver the best possible performance.

A couple of weeks ago I first dabbled in embedding the mono runtime for use of RoadRunner in C++. So it seemed clear, that this could be extended to the JNI world.

A prototype was quickly written and tested on OSX (10.6, using a 32bit JVM) and verified to work on Ubuntu 9.10 (32 bit). So far the version is not working in 64bit Linux. Mainly because all our libraries are not yet available for 64bit. Oh well … but it is a start …

The Ubuntu version is now online on the source forge project, source code an all:

http://sourceforge.net/projects/roadrunner/files/

SED-ML in Pictures

2010-04-28T14:36:00.001-07:00

Today a question came up on the sbml-discuss list on freely available software for simulating BioModels 139 and BioModel 140. Someone tried to reproduce the simulation results with these models and failed to do so. In the future of course SED-ML will help us out in these cases, by essentially encoding the simulation experiment directly.

So I went ahead and created some SED-ML examples for these models. You will find them below. Admittedly, so far only our tools seem to support the format, but other groups are showing interest. To give it a try, you could download the latest version of the Systems Biology Workbench. Once it is installed, start the ‘Simulation Tool’. Which now comes with an experimental support for SED-ML, and there you can open and run SED-ML files from the ‘SED-ML’ tab.

Here is how it looks for the BioModel 139:

And here the result for BioModel 140:

Of course SED-ML is still in its infancy, but as you can see, there is a need for it now. So don’t wait for the final version, start implementing it in your tools now! Or if you don’t develop for a software package yourself, ask the authors of your favorite tool to do so!

BioModel 139:

BioModel 140:

Getting Started with LibSedML (on linux)

2010-03-08T19:22:00.001-08:00

A couple of days ago I announced the LibSedML sourceforge project, a library for reading / writing SED-ML files. However, what was missing so far is information on how one would start using the library. (If you feel lucky, I provided a binary at the end of this post!)

Preparing the Virtual Machine

In the following, I’ll describe how to set up an OpenSuse 11.2 Virtual Machine, in order to run SED-ML Simulation Experiments:

Actually, we are not setting up the virtual machine, but instead take the one provided by the Mono team. Simply download the VMware image from:

http://mono-project.com/Downloads

unzip and start the Virtual Machine. It will automatically log in as user ‘rupert’
The first thing we might want to do is to get SBW started. While not strictly necessary … it will help us later on, when we just copy the binary libraries for LibSedMLRunner to execute the simulations. The Latest SBW version for linux can be found here:

http://sourceforge.net/projects/jdesigner/files/Systems%20Biology%20Workbench/2.7.10/SBW-2.7.10-linux-installer.bin/download

The file is simply installed by making it executable (chmod +x SBW-*bin) and executing the binary installer.
Next we might want to install a fresh copy of LibSBML, which is easily done by checking out libsbml from SVN:

svn co http://sbml.svn.sourceforge.net/svnroot/sbml/trunk/libsbml libsbml

the virtual machine at this point has no g++ so we get one by going to a root shell (root password is ‘mono’) and installing:

zypper install gcc-c++
zypper install libxml2-devel

(i also installed additional packages like ‘lapack’ but I’m not sure they are necessary)
Next we get the latest SWIG from http://www.swig.org/download.html, I just downloaded the 1.3.40 version, unpacked it with tar zxf, ran:

./configure && make && sudo make install

which installes SWIG into /usr/local
Now we can compile and run libsbml:

./configure --with-libxml=/usr --with-swig=/usr/local --with-csharp --enable-layout=no && make

which will compile libsbml and create the bindings in the src/bindings/csharp folder

Compiling LibSedML

So far for the prerequisites. The remaining could not be simpler. Here the whole session:

Directory: /home/rupert/Desktop
Tue Mar  9 02:35:51 UTC 2010
rupert@linux:~/Desktop> cd
rupert@linux:~> cd Development/
rupert@linux:~/Development> l
stotal 12
drwxr-xr-x  3 rupert users 4096 2010-03-08 20:20 ./
drwxr-xr-x 33 rupert users 4096 2010-03-08 22:21 ../
drwxr-xr-x  8 rupert users 4096 2010-03-08 20:21 sbwbuild/
rupert@linux:~/Development> svn co http://libsedml.svn.sourceforge.net/svnroot/libsedml/trunk LibSedML
A    LibSedML/ICON_MIASE.ico
A    LibSedML/SEDML.sln
A    LibSedML/libSedMLScript
A    LibSedML/libSedMLScript/HelperFunctions.py
A    LibSedML/libSedMLScript/libSedMLScript.csproj
A    LibSedML/libSedMLScript/SedMLPythonConverter.cs
A    LibSedML/libSedMLScript/ITextImporter.cs
A    LibSedML/libSedMLScript/ITextExporter.cs
A    LibSedML/libSedMLScript/Properties
A    LibSedML/libSedMLScript/Properties/AssemblyInfo.cs
A    LibSedML/libSedMLScript/Properties/Resources.resx
A    LibSedML/libSedMLScript/Properties/Resources.Designer.cs
A    LibSedML/libSedMLScript/SedMLScript.cs
A    LibSedML/SedMLWeb
A    LibSedML/SedMLWeb/Default.aspx.designer.cs
A    LibSedML/SedMLWeb/MasterASPX.master
A    LibSedML/SedMLWeb/SedMLWeb.csproj
A    LibSedML/SedMLWeb/Web.config
A    LibSedML/SedMLWeb/Default.aspx.cs
A    LibSedML/SedMLWeb/_sysbiostyles.css
A    LibSedML/SedMLWeb/MasterASPX.master.cs
A    LibSedML/SedMLWeb/SysBio_MasterASPX.master
A    LibSedML/SedMLWeb/KGI0717_MasterASPX.master
A    LibSedML/SedMLWeb/Properties
A    LibSedML/SedMLWeb/Properties/AssemblyInfo.cs
A    LibSedML/SedMLWeb/SysBio_MasterASPX.master.cs
A    LibSedML/SedMLWeb/Default.aspx
A    LibSedML/SedMLWeb/KGI0717_MasterASPX.master.cs
A    LibSedML/Samples
A    LibSedML/Samples/model1.xml
A    LibSedML/Samples/sedmltest.txt
A    LibSedML/Samples/curien.xml
A    LibSedML/Samples/EllowitzRepressilator.miase
A    LibSedML/Samples/lorenz.txt
A    LibSedML/Samples/BIOMD0000000021.xml
A    LibSedML/Samples/miaseTest.xml
A    LibSedML/Samples/sedmlCurienJWS.xml
A    LibSedML/Samples/JanaWolf.miase
A    LibSedML/Samples/miaseBioModels21.xml
A    LibSedML/Samples/brusselator.miase
A    LibSedML/Samples/brusselator.xml
A    LibSedML/Samples/lorenz.miase
A    LibSedML/Samples/lorenz.xml
A    LibSedML/Samples/sedMLBIOM21.miase
A    LibSedML/Samples/sedMLBIOM21.xml
A    LibSedML/libSedMLRunner
A    LibSedML/libSedMLRunner/SedMLRunner.cs
A    LibSedML/libSedMLRunner/libSedMLRunner.csproj
A    LibSedML/libSedMLRunner/RunResult.cs
A    LibSedML/libSedMLRunner/SimpleRunner.cs
A    LibSedML/libSedMLRunner/Properties
A    LibSedML/libSedMLRunner/Properties/AssemblyInfo.cs
A    LibSedML/SedMLConsole
A    LibSedML/SedMLConsole/ICON_MIASE.ico
A    LibSedML/SedMLConsole/Web References
A    LibSedML/SedMLConsole/Web References/BioModels
A    LibSedML/SedMLConsole/Web References/BioModels/Reference.cs
A    LibSedML/SedMLConsole/Web References/BioModels/BioModelsWebServices.wsdl
A    LibSedML/SedMLConsole/Web References/BioModels/Reference.map
A    LibSedML/SedMLConsole/Web References/MIRIAM
A    LibSedML/SedMLConsole/Web References/MIRIAM/Reference.cs
A    LibSedML/SedMLConsole/Web References/MIRIAM/MiriamWebServices.wsdl
A    LibSedML/SedMLConsole/Web References/MIRIAM/Reference.map
A    LibSedML/SedMLConsole/SedMLConsole.csproj.user
A    LibSedML/SedMLConsole/app.config
A    LibSedML/SedMLConsole/SedMLConsole.csproj
A    LibSedML/SedMLConsole/Resources
A    LibSedML/SedMLConsole/Resources/ICON_MIASE.ico
A    LibSedML/SedMLConsole/Program.cs
A    LibSedML/SedMLConsole/Properties
A    LibSedML/SedMLConsole/Properties/AssemblyInfo.cs
A    LibSedML/SedMLConsole/Properties/Settings.settings
A    LibSedML/SedMLConsole/Properties/Settings.Designer.cs
A    LibSedML/SedMLConsole/Properties/Resources.resx
A    LibSedML/SedMLConsole/Properties/Resources.Designer.cs
A    LibSedML/3rdParty
A    LibSedML/3rdParty/Microsoft.Scripting.ExtensionAttribute.dll
A    LibSedML/3rdParty/LibRoadRunner.dll
A    LibSedML/3rdParty/Microsoft.Scripting.dll
A    LibSedML/3rdParty/IronPython.dll
A    LibSedML/3rdParty/ICSharpCode.SharpZipLib.dll
A    LibSedML/3rdParty/mathLibrary.dll
A    LibSedML/3rdParty/CompareData.dll
A    LibSedML/3rdParty/IronPython.Modules.dll
A    LibSedML/3rdParty/ZedGraph.Web.dll
A    LibSedML/3rdParty/Microsoft.Dynamic.dll
A    LibSedML/3rdParty/SBMLSupport.dll
A    LibSedML/3rdParty/libsbmlcsP.dll
A    LibSedML/3rdParty/SBWCSharp.dll
A    LibSedML/3rdParty/Microsoft.Scripting.Core.dll
A    LibSedML/3rdParty/LibStructuralCSharp.dll
A    LibSedML/3rdParty/Microsoft.Scripting.Debugging.dll
A    LibSedML/3rdParty/ZedGraph.dll
A    LibSedML/SedMLScript
A    LibSedML/SedMLScript/ICON_MIASE.ico
A    LibSedML/SedMLScript/MainForm.resx
A    LibSedML/SedMLScript/SedMLScriptTest.csproj
A    LibSedML/SedMLScript/MainForm.Designer.cs
A    LibSedML/SedMLScript/Program.cs
A    LibSedML/SedMLScript/icons
A    LibSedML/SedMLScript/icons/run.png
A    LibSedML/SedMLScript/MainForm.cs
A    LibSedML/SedMLScript/Properties
A    LibSedML/SedMLScript/Properties/AssemblyInfo.cs
A    LibSedML/SedMLScript/Properties/Settings.settings
A    LibSedML/SedMLScript/Properties/Settings.Designer.cs
A    LibSedML/SedMLScript/Properties/Resources.resx
A    LibSedML/SedMLScript/Properties/Resources.Designer.cs
A    LibSedML/libSedML
A    LibSedML/libSedML/Report.cs
A    LibSedML/libSedML/Util.cs
A    LibSedML/libSedML/ModelStore.cs
A    LibSedML/libSedML/UniformTimeCourse.cs
A    LibSedML/libSedML/TaskStore.cs
A    LibSedML/libSedML/DataGenerator.cs
A    LibSedML/libSedML/Parameter.cs
A    LibSedML/libSedML/SedMLInfo.cs
A    LibSedML/libSedML/Simulation.cs
A    LibSedML/libSedML/Variable.cs
A    LibSedML/libSedML/Change.cs
A    LibSedML/libSedML/libSedML.csproj
A    LibSedML/libSedML/Properties
A    LibSedML/libSedML/Properties/AssemblyInfo.cs
A    LibSedML/libSedML/DataGeneratorStore.cs
A    LibSedML/libSedML/SedMLBase.cs
A    LibSedML/libSedML/Output.cs
A    LibSedML/libSedML/Model.cs
A    LibSedML/libSedML/SimulationStore.cs
A    LibSedML/libSedML/Task.cs
A    LibSedML/libSedML/Plot2D.cs
A    LibSedML/IronPythonScript
Checked out revision 4.
rupert@linux:~/Development> cd LibSedML/
rupert@linux:~/Development/LibSedML> ls
3rdParty          libSedML        Samples       SEDML.sln
ICON_MIASE.ico    libSedMLRunner  SedMLConsole  SedMLWeb
IronPythonScript  libSedMLScript  SedMLScript
rupert@linux:~/Development/LibSedML> mdtool build -c:Release
MonoDevelop Build Tool
Loading solution: ./SEDML.sln
   Loading solution: ./SEDML.sln
      Loading projects ..
Building: SEDML (Release)
   Building Solution SEDML
      Building: libSedML (Release)
         Performing main compilation...
         /usr/bin/gmcs /noconfig
         "/out:/home/rupert/Development/LibSedML/bin/libSedML.dll"
         "/r:/home/rupert/Development/LibSedML/3rdParty/CompareData.dll"
         "/r:/home/rupert/Development/LibSedML/3rdParty/ICSharpCode.SharpZipLib.
         dll" "/r:/home/rupert/Development/LibSedML/3rdParty/libsbmlcsP.dll"
         "/r:/home/rupert/Development/LibSedML/3rdParty/mathLibrary.dll"
         "/r:/home/rupert/Development/LibSedML/3rdParty/SBMLSupport.dll"
         "/r:/home/rupert/Development/LibSedML/3rdParty/SBWCSharp.dll"
         "/r:System.dll" "/r:System.Data.dll" "/r:System.Xml.dll" /nologo
         /warn:4 /optimize+ /codepage:utf8 /platform:x86 "/define:TRACE" 
         /t:library "/home/rupert/Development/LibSedML/libSedML/Change.cs"
         "/home/rupert/Development/LibSedML/libSedML/DataGenerator.cs"
         "/home/rupert/Development/LibSedML/libSedML/DataGeneratorStore.cs"
         "/home/rupert/Development/LibSedML/libSedML/SedMLBase.cs"
         "/home/rupert/Development/LibSedML/libSedML/SedMLInfo.cs"
         "/home/rupert/Development/LibSedML/libSedML/Model.cs"
         "/home/rupert/Development/LibSedML/libSedML/ModelStore.cs"
         "/home/rupert/Development/LibSedML/libSedML/Output.cs"
         "/home/rupert/Development/LibSedML/libSedML/Parameter.cs"
         "/home/rupert/Development/LibSedML/libSedML/Plot2D.cs"
         "/home/rupert/Development/LibSedML/libSedML/Properties/AssemblyInfo.cs"
          "/home/rupert/Development/LibSedML/libSedML/Report.cs"
         "/home/rupert/Development/LibSedML/libSedML/Simulation.cs"
         "/home/rupert/Development/LibSedML/libSedML/SimulationStore.cs"
         "/home/rupert/Development/LibSedML/libSedML/Task.cs"
         "/home/rupert/Development/LibSedML/libSedML/TaskStore.cs"
         "/home/rupert/Development/LibSedML/libSedML/UniformTimeCourse.cs"
         "/home/rupert/Development/LibSedML/libSedML/Util.cs"
         "/home/rupert/Development/LibSedML/libSedML/Variable.cs" 
         Compilation succeeded - 1 warning(s)
         
         /home/rupert/Development/LibSedML/libSedML/Util.cs(307,18): warning
         CS0219: The variable `length' is assigned but its value is never used
         
         
         Build complete -- 0 errors, 1 warning
      Building: libSedMLRunner (Release)
         Performing main compilation...
         /usr/bin/gmcs /noconfig
         "/out:/home/rupert/Development/LibSedML/bin/libSedMLRunner.dll"
         "/r:/home/rupert/Development/LibSedML/3rdParty/CompareData.dll"
         "/r:/home/rupert/Development/LibSedML/3rdParty/LibRoadRunner.dll"
         "/r:/home/rupert/Development/LibSedML/3rdParty/LibStructuralCSharp.dll"
          "/r:System.dll" "/r:System.Data.dll" "/r:System.Drawing.dll"
         "/r:System.Windows.Forms.dll" "/r:System.Xml.dll"
         "/r:/home/rupert/Development/LibSedML/3rdParty/ZedGraph.dll"
         "/r:/home/rupert/Development/LibSedML/bin/libSedML.dll" /nologo
         /warn:4 /optimize+ /codepage:utf8 /platform:x86 "/define:TRACE" 
         /t:library
         "/home/rupert/Development/LibSedML/libSedMLRunner/SedMLRunner.cs"
         "/home/rupert/Development/LibSedML/libSedMLRunner/Properties/AssemblyIn
         fo.cs" "/home/rupert/Development/LibSedML/libSedMLRunner/RunResult.cs"
         "/home/rupert/Development/LibSedML/libSedMLRunner/SimpleRunner.cs" 
         Build complete -- 0 errors, 0 warnings
      Building: SedMLConsole (Release)
         Performing main compilation...
         Compiling resource
         /home/rupert/Development/LibSedML/SedMLConsole/Properties/Resources.res
         x with /usr/bin/resgen2
         /usr/bin/gmcs /noconfig
         "/out:/home/rupert/Development/LibSedML/bin/SedMLConsole.exe"
         "/r:/home/rupert/Development/LibSedML/3rdParty/CompareData.dll"
         "/r:System.dll" "/r:System.Drawing.dll"
         "/r:System.EnterpriseServices.dll" "/r:System.Web.Services.dll"
         "/r:System.Windows.Forms.dll" "/r:System.Data.dll" "/r:System.Xml.dll"
         "/r:/home/rupert/Development/LibSedML/3rdParty/ZedGraph.dll"
         "/r:/home/rupert/Development/LibSedML/bin/libSedMLRunner.dll"
         "/r:/home/rupert/Development/LibSedML/bin/libSedML.dll" /nologo
         /warn:4 /optimize+
         "/win32icon:/home/rupert/Development/LibSedML/SedMLConsole/ICON_MIASE.i
         co" /codepage:utf8 /platform:x86 "/define:TRACE"  /t:winexe
         "/home/rupert/Development/LibSedML/SedMLConsole/Program.cs"
         "/home/rupert/Development/LibSedML/SedMLConsole/Properties/AssemblyInfo
         .cs"
         "/home/rupert/Development/LibSedML/SedMLConsole/Properties/Resources.De
         signer.cs"
         "/home/rupert/Development/LibSedML/SedMLConsole/Properties/Settings.Des
         igner.cs" "/home/rupert/Development/LibSedML/SedMLConsole/Web
         References/BioModels/Reference.cs"
         "/home/rupert/Development/LibSedML/SedMLConsole/Web
         References/MIRIAM/Reference.cs"
         "/res:/home/rupert/Development/LibSedML/SedMLConsole/Properties/Resourc
         es.resources,SedMLConsole.Properties.Resources.resources" 
         Compilation succeeded - 1 warning(s)
         
         /home/rupert/Development/LibSedML/SedMLConsole/Program.cs(64,29):
         warning CS0169: The private method
         `SedMLConsole.Program.CreateSedMLProgramatically()' is never used
         
         
         Build complete -- 0 errors, 1 warning
      Building: libSedMLScript (Release)
         Performing main compilation...
         Compiling resource
         /home/rupert/Development/LibSedML/libSedMLScript/Properties/Resources.r
         esx with /usr/bin/resgen2
         /usr/bin/gmcs /noconfig
         "/out:/home/rupert/Development/LibSedML/bin/libSedMLScript.dll"
         "/r:/home/rupert/Development/LibSedML/3rdParty/IronPython.dll"
         "/r:/home/rupert/Development/LibSedML/3rdParty/Microsoft.Scripting.dll"
         
         "/r:/home/rupert/Development/LibSedML/3rdParty/Microsoft.Scripting.Core
         .dll" "/r:System.dll" "/r:System.Core.dll" "/r:System.Xml.Linq.dll"
         "/r:System.Data.DataSetExtensions.dll" "/r:System.Data.dll"
         "/r:System.Xml.dll"
         "/r:/home/rupert/Development/LibSedML/bin/libSedML.dll" /nologo
         /warn:4 /optimize+ /codepage:utf8 "/define:TRACE"  /t:library
         "/home/rupert/Development/LibSedML/libSedMLScript/ITextExporter.cs"
         "/home/rupert/Development/LibSedML/libSedMLScript/ITextImporter.cs"
         "/home/rupert/Development/LibSedML/libSedMLScript/Properties/Resources.
         Designer.cs"
         "/home/rupert/Development/LibSedML/libSedMLScript/SedMLPythonConverter.
         cs" "/home/rupert/Development/LibSedML/libSedMLScript/SedMLScript.cs"
         "/home/rupert/Development/LibSedML/libSedMLScript/Properties/AssemblyIn
         fo.cs"
         "/res:/home/rupert/Development/LibSedML/libSedMLScript/Properties/Resou
         rces.resources,libSedMLScript.Properties.Resources.resources" 
         Build complete -- 0 errors, 0 warnings
      Building: SedMLScriptTest (Release)
         Performing main compilation...
         WARNING: Assembly 'System.Deployment' not found. Make sure that the
         assembly exists in disk. If the reference is required to build the
         project you may get compilation errors.
         Compiling resource
         /home/rupert/Development/LibSedML/SedMLScript/MainForm.resx with
         /usr/bin/resgen2
         Compiling resource
         /home/rupert/Development/LibSedML/SedMLScript/Properties/Resources.resx
          with /usr/bin/resgen2
         /usr/bin/gmcs /noconfig
         "/out:/home/rupert/Development/LibSedML/bin/SedMLScriptTest.exe"
         "/r:System.dll" "/r:System.Core.dll" "/r:System.Xml.Linq.dll"
         "/r:System.Data.DataSetExtensions.dll" "/r:System.Data.dll"
         "/r:System.Drawing.dll" "/r:System.Windows.Forms.dll"
         "/r:System.Xml.dll"
         "/r:/home/rupert/Development/LibSedML/bin/libSedMLRunner.dll"
         "/r:/home/rupert/Development/LibSedML/bin/libSedMLScript.dll"
         "/r:/home/rupert/Development/LibSedML/bin/libSedML.dll" /nologo
         /warn:4 /optimize+
         "/win32icon:/home/rupert/Development/LibSedML/SedMLScript/ICON_MIASE.ic
         o" /codepage:utf8 /platform:x86 "/define:TRACE" 
         /main:SedMLScriptTest.Program /t:winexe
         "/home/rupert/Development/LibSedML/SedMLScript/MainForm.cs"
         "/home/rupert/Development/LibSedML/SedMLScript/MainForm.Designer.cs"
         "/home/rupert/Development/LibSedML/SedMLScript/Program.cs"
         "/home/rupert/Development/LibSedML/SedMLScript/Properties/AssemblyInfo.
         cs"
         "/res:/home/rupert/Development/LibSedML/SedMLScript/MainForm.resources,
         SedMLScriptTest.MainForm.resources"
         "/res:/home/rupert/Development/LibSedML/SedMLScript/Properties/Resource
         s.resources,SedMLScriptTest.Properties.Resources.resources"
         "/home/rupert/Development/LibSedML/SedMLScript/Properties/Resources.Des
         igner.cs"
         "/home/rupert/Development/LibSedML/SedMLScript/Properties/Settings.Desi
         gner.cs" 
         Build complete -- 0 errors, 1 warning
      Building: SedMLWeb (Release)
         Generating CodeBehind members...
         Waiting for project type database to finish updating...
Object reference not set to an instance of an object
rupert@linux:~/Development/LibSedML> cd bin
rupert@linux:~/Development/LibSedML/bin> ls
CompareData.dll              Microsoft.Dynamic.dll
ICSharpCode.SharpZipLib.dll  Microsoft.Scripting.Core.dll
IronPython.dll               Microsoft.Scripting.Debugging.dll
LibRoadRunner.dll            Microsoft.Scripting.dll
libsbmlcsP.dll               Microsoft.Scripting.ExtensionAttribute.dll
libSedML.dll                 SBMLSupport.dll
libSedMLRunner.dll           SBWCSharp.dll
libSedMLScript.dll           SedMLConsole.exe
LibStructuralCSharp.dll      SedMLScriptTest.exe
mathLibrary.dll              ZedGraph.dll
rupert@linux:~/Development/LibSedML/bin> cp ~/Development/sbwbuild/cvs-dl/libsbml/src/bindings/csharp/libsbmlcs* . 
rupert@linux:~/Development/LibSedML/bin> ls
CompareData.dll              mathLibrary.dll
ICSharpCode.SharpZipLib.dll  Microsoft.Dynamic.dll
IronPython.dll               Microsoft.Scripting.Core.dll
LibRoadRunner.dll            Microsoft.Scripting.Debugging.dll
libsbmlcs.la                 Microsoft.Scripting.dll
libsbmlcsP.dll               Microsoft.Scripting.ExtensionAttribute.dll
libsbmlcs.snk                SBMLSupport.dll
libsbmlcs.so                 SBWCSharp.dll
libSedML.dll                 SedMLConsole.exe
libSedMLRunner.dll           SedMLScriptTest.exe
libSedMLScript.dll           ZedGraph.dll
LibStructuralCSharp.dll
rupert@linux:~/Development/LibSedML/bin> cp ~/SBW-2.7.10/CSharp/libcvode*.so . 
rupert@linux:~/Development/LibSedML/bin> cp ~/SBW-2.7.10/CSharp/libNleqLib.so . 
rupert@linux:~/Development/LibSedML/bin> cp ~/SBW-2.7.10/CSharp/lib
libblas.so           libcvode.so          libLibLA.so
libblas.so.3         libg2c.so            libLibStructural.so
libblas.so.3.0       libg2c.so.0          libNleqLib.so
libblas.so.3.0.3     libg2c.so.0.0.0      libsbl2SBML.dll
libbz2.so            liblapack.so         libsbmlcsP.dll
libbz2.so.1          liblapack.so.3       libsbmlcs.so
libbz2.so.1.0.2      liblapack.so.3.0     libsbml.so
libcvodedll.so       liblapack.so.3.0.3   libSBW.so
rupert@linux:~/Development/LibSedML/bin> cp ~/SBW-2.7.10/CSharp/libLib*.so . 
rupert@linux:~/Development/LibSedML/bin> ls
CompareData.dll              libSedMLRunner.dll
ICSharpCode.SharpZipLib.dll  libSedMLScript.dll
IronPython.dll               LibStructuralCSharp.dll
libcvodedll.so               mathLibrary.dll
libcvode.so                  Microsoft.Dynamic.dll
libLibLA.so                  Microsoft.Scripting.Core.dll
libLibStructural.so          Microsoft.Scripting.Debugging.dll
libNleqLib.so                Microsoft.Scripting.dll
LibRoadRunner.dll            Microsoft.Scripting.ExtensionAttribute.dll
libsbmlcs.la                 SBMLSupport.dll
libsbmlcsP.dll               SBWCSharp.dll
libsbmlcs.snk                SedMLConsole.exe
libsbmlcs.so                 SedMLScriptTest.exe
libSedML.dll                 ZedGraph.dll
rupert@linux:~/Development/LibSedML/bin> mono ./SedMLConsole.exe ../Samples/lorenz.miase

The Results

This will result in the Lorenz Attractor simulated, and you should see:

I hope this gave a little over view in how to compile the library at this stage. I’ve archived the resulting binary and uploaded it to SF:

http://sourceforge.net/projects/libsedml/files/test

Nested Simulation Experiments

2010-03-08T11:32:00.001-08:00

A couple of days ago, I posted a proposal for a Nested Simulation Experiment for SED-ML. There I proposed that instead of defining a new Simulation class for each experiment you’d like to run, it would be better for implementers and modelers alike to be able to compose simulation experiments out of primitives. That is instead of defining:

a TimeCourse Simulation experiment like this:

<timeCourse id="s1" name="time course definition" algorithm="KiSAO:0000019">
<uniformRange start="0" end="100" numberOfPoints="10" />
</timeCourse>
and next like this:

<timeCourse id="s1" name="time course definition" algorithm="KiSAO:0000019">
<vectorRange>
<value> 1 </value>
<value> 4 </value>
<value> 10 </value>
<value> 23 </value>
<value> 42 </value>
</vectorRange>
</timeCourse>

one could compose these same experiments with primitives. (Just as an aside, note that in the cases above a simulator supporting the simulation experiment would have to implement a different set of operations).

The Primitives

I would envision three primitives:

OneStep: this calculates one further output step for the model from its current state. Note that this does NOT have to mean one integration step. The simulator is allowed to take as many steps as needed, all that has to be fulfilled with this simulation class, is that, at the end, the desired output time is reached.
SteadyState: This brings the model from its current state to a steady state. This simulation class will also just provide one output row for attached data generators, the state of the model at steady state.
SetValue: This is not a simulation class, but rather a convenience function, to change a model variable/parameter. In this way it is akin to ChangeMath / ChangeAttribute / ChangeXML we would have to discuss the actual syntax of it.

These primitives then are used in a nested simulation experiment to describe virtually any simulation experiment. Through the nested class construct. This construct allows to refer to:

A task object, which defines the model and simulation experiment to be called repeatedly,
A range object, which defines how often the simulation task above is to be called,
A SetValue construct describing how model variables are to be changed. Note:that the SetValue construct will have to be able to refer to the ranges current value.

Additionally, flags would indicate, whether the model is supposed to be reset after each run or not.

Examples

So far the proposal, so how would this look in an example. Lets go through each one and make up some examples as we go along.

OneStep: This is a simulation class, causing the model time variable to be adapted from the current time with a given step (that determines where the desired output point is):

<listOfSimulations>
<oneStep id="s1" algorithm="KiSAO:0000019" step="0.1"/>
</listOfSimulations>

when used in a task, this simulation task simulates the model from 0 to 0.1. The data generators are supposed to be calculated to yield the desired outputs for time point 0.1.
SteadyState: This is another simulation class, so we would define it as such. Unfortunately KISAO does not currently describe any steady state solvers and instead mostly integrators. So suppose in the following that:

KISAO:0000099 = steady state solver (it would probably somewhere below KISAO:0000018)

<listOfSimulations>
<steadyState id="s2" algorithm="KiSAO:0000099" />
</listOfSimulations>

when used in a task, this simulation task brings the model to steady state. Once finished the data generators are supposed to be calculated to yield the desired output points for the model variables at steady state.
NestedSimulation: So how would this now look in a nested simulation experiment:

<listOfSimulations>
    <nestedSimulation id="s3" algorithm="KiSAO:0000019"
                         resetModel="false" originalTask="task1">
    <vectorRange>
         <value> 1 </value>
        <value> 4 </value>
        <value> 10 </value>
    </vectorRange>
    <setValue target="/sbml/model/listOfParameters/parameter[@id='w']">
     <listOfVariables>
         <variable id="current" name="current range value" target="#current" />
     <listOfVariables/>
     <math>
         <ci>current</ci>
     </math>
    </setValue>
   </nestedSimulation>
</listOfSimulations>

The nested simulation above, would carry out task1 3 times. Each time the value of a model parameter ‘w’ is varied by applying one of the three values. If task1 specifies a steady state primitive, then this snippet produces the steady state values for w=1, w=4 and w=10.

Or we could have used a uniform range to sweep the parameter. Or a functional range, to vary the parameter in logScale for example.

If task1 would refer to a uniformTimeCourse Simulation then this would actually perform a simulation, where a parameter is changed in steps. After each time we would see how the model reacts to this discrete parameter change.

Note that you could even define a uniform time course simulation using this approach. Here task1 refers to a ‘oneStep’ simulation task. We would just vary the models time each time:

<listOfSimulations>
    <nestedSimulation id="s3" algorithm="KiSAO:0000019"
                         resetModel="false" originalTask="task1">
    <uniformRange start="0" end="100" numberOfPoints="10" />
    <setValue target="#time">
     <listOfVariables>
         <variable id="current" name="current range value" target="#current" />
     <listOfVariables/>
     <math>
         <ci>current</ci>
     </math>
    </setValue>
   </nestedSimulation>
</listOfSimulations>

You could even think about nesting the nestedSimulation experiments in order to for example perform 2D parameter scans or what have you.

Conclusions

Defining simulation experiments through these primitives will open up SED-ML and make it really useful. These primitives are easy to implement. In fact they are already implemented in available simulators. They are what is needed to implement the proposed Range construct anyway.

So let us not be shackled by having to each time define a new simulation class. The nested approach here will be what is needed to define most simulation experiments. By adding new primitives later on it can be easily extended.

I’m perfectly happy to open it up further. What one could envision would be multiple <setValue> elements to change multiple parameters. or even multiple ranges, though then each would have to have an id, to be used in the SetValue constructs. But I’m sure it could be sorted out.

Supporting SED-ML

2010-03-03T12:40:00.001-08:00

SED-ML, the Simulation Experiment Description – Markup Language, offers the possibility to exchange simulation experiments. That is, instead of receiving a model and wondering how you can make it do what it is supposed to do, you would simply run the accompanying SED-ML document and see the figures reproduced.

As with any new standards initiative, it will only be taken up if there are computational resources, that make it easy to use, and of course if the standard can be helpful. Currently, with SED-ML in a very early stage it is already possible to exchange time course simulation experiments, but not much more. However, it could be extended easily, such as by using a Nested Simulation Experiment, as described at the link below.

But what about computational resources? As it so happens, I’ve created a new project:

LibSedML - libsedml.sourceforge.net/

There, I provide three libraries:

LibSedML – a .NET library for reading and writing SED-ML
LibSedMLRunner – a library on top of LibSedML, that schedules and runs simulation experiments.
LibSedMLScript – a utility library, turning a human readable script format into SED-ML.

Three applications support these libraries so far:

SED-ML Script: This application provides an easy way to define new Simulation Experiments using the human readable script format. No more struggling with API calls or XML, a simple script defines a simulation experiment. It can also be readily tested right then and there.
A web application provides the same functionality and provides a test bed, without having to download any software.
A plug-in for the SBW Simulation Tool, allows to run SED-ML files directly from it and provides capabilities for saving simple simulation experiments. (screenshot at beginning of this post)

The libraries and tools have been implemented using .NET, and have been confirmed to run fine on Windows, Linux and OS X!

Bergmann, Frank. A Simple Nested Simulation for SED-ML. Available from Nature Precedings <http://dx.doi.org/10.1038/npre.2010.4257.1> (2010)

RoadRunner & C++/CLI vs. Embedding the MONO Runtime

2010-02-13T12:01:00.001-08:00

RoadRunner, our simulation main simulation engine in the Systems Biology Workbench, has been written in C#. This allows RoadRunner to be used in scripting scenarios with languages like IronPython, or even from the csharp-shell or Windows PowerShell. But what if you wanted to use RoadRunner from plain old C / C++?

C++ / CLI

On Windows operating systems the obvious choice would probably be C++/CLI. And really, the task could not be easier. Just add the RoadRunner reference to the application include the RoadRunner namespace and you are good to go:

        1: // RoadRunnerCLI.cpp : main project file.

       2:  

       3: #include "stdafx.h"

       4:  

       5: using namespace System;

       6: using namespace CSharpSimulator;

       7:  

       8: static void PrintResult(cli::array<double, 2>^ data)

       9:     {

        for (int i = 0; i < data->GetLength(0); i++)

        {

            for (int j = 0; j < data->GetLength(1); j++)

            {

                Console::Write(data[i,j]);

                Console::Write("\t");

            }

            Console::WriteLine();

        }

    }

  

int main(array<System::String ^> ^args)

{

 

    sbwInterface roadRunnerInstance;

  

    roadRunnerInstance.loadSBMLFromFile

        (L"C:\\Users\\fbergmann\\Documents\\SBML Models\\BorisEJB.xml");

    roadRunnerInstance.setTimeStart(0.0);

    roadRunnerInstance.setTimeEnd(100.0);

    roadRunnerInstance.setNumPoints(11);

    

    cli::array<double, 2>^ result = roadRunnerInstance.simulate();

  

    PrintResult(result);

  

    return 0;

}

The only drawback would be that this will not work on Linux or OS X.

MONO Embedding

So what about MONO Embedding? Or in other words, writing a C++ application, that would embed the MONO Runtime. This enables the C++ application to directly reference RoadRunner. The idea is basically the same as when using any SBW Module. First we get a hold of the RoadRunner module, or in this case an instance of the RoadRunner class:

       1: mono_set_dirs(NULL, NULL);

       2: domain = mono_jit_init ("LibRoadRunner.dll");

       3: mono_set_dirs(NULL, NULL);

       4: mono_config_parse(NULL);

       5: assembly = mono_domain_assembly_open (domain, "LibRoadRunner.dll");

       6: if (assembly == NULL)

       7:     cout << "Couldn't load RR assembly" << endl;

       8: image = mono_assembly_get_image (assembly);

       9: rr_class = mono_class_from_name (image, "CSharpSimulator", "sbwInterface");

      10: if (rr_class == NULL)

      11:     cout << "Couldn't get hold of the RoadRunner class" << endl;

      12:  

      13: // create new roadRunner instance

      14: rr_instance = mono_object_new (domain, rr_class);   

      15: // call constructor

      16: mono_runtime_object_init (rr_instance);

Next one would get hold of all the method one would like to call, as in:

       1: // get the loadSBML 

       2: methodLoadSBML = mono_class_get_method_from_name(rr_class, "loadSBML", -1);

       3: if (methodLoadSBML == NULL) 

       4:     cout << "Couldn't get loadSBML" << endl;

       5:

finally for calling the method all that’s needed is to wrap the arguments into arguments that MONO would understand:

       1: void HostRR::LoadSBML(const char* model)

       2: {

       3:     MonoString *str = mono_string_new (domain, model);

       4:     void *args[1]; args[0] = str; 

       5:     MonoObject *exception = NULL;

       6:     mono_runtime_invoke(methodLoadSBML, rr_instance, args, &exception);

       7:     if (exception != NULL)

       8:     {

       9:         PrintException("Error while loading SBML", exception);

      10:     }

      11: }

continuing like that for the remaining methods that have to be available for C++. For a client calling into RoadRunner the result would look like this:

       1: #include "HostRR.h"

       2: #include <iostream>

       3: #include <iomanip>

       4:  

       5: using namespace std;

       6:  

       7: void PrintResult(double** data, int numRows, int numCols)

       8: {

       9:     if (data == NULL) return;

  

    for (int y = 0; y < numRows; y++) 

    {

        for (int x = 0; x < numCols; x++) 

        {

            cout << setiosflags(ios::fixed) 

                 << setw(7) << setprecision(2) << setfill(' ') 

                 <<  data[y][x] << "\t";

        }

        cout << endl;

    }

    cout << endl;

}

  

int main(int argc, char* argv[])

{

    HostRR instance;

    

    instance.LoadSBMLFromFile("BorisEJB.xml");

  

    instance.SetTimeStart(0.0);

    instance.SetTimeEnd(1100.0);

    instance.SetNumPoints(100);

    

    int numRows; int numCols;

    double** result = instance.Simulate(&numRows,&numCols);

    

    PrintResult(result, numRows, numCols);

    

    return 0;

}

And the advantage? It runs like a charm on Linux and OS X. However I did struggle a bit with getting it compiled. After all one draws several dependencies when embedding mono, the most troublesome for me proved to be glib2 and OS X. At the end the problem turned out to be that Snow Leopard liked the executable to be 64bit by default, but the glib libraries were only available for 32bit and ppc. Since I have Qt installed on all my systems, I used a qmake project, to generate the make files (or Xcode projects as the case may be). So here is what worked for me:

       1:  

       2: TEMPLATE = app

       3: CONFIG = console

       4: TARGET = HostRR

       5: DEPENDPATH += .

       6: INCLUDEPATH += . 

       7:  

       8: mac { 

       9: CONFIG += x86 

      10: CFLAGS += -arch i386

      11: INCLUDEPATH += /Library/Frameworks/Mono.framework/Versions/2.6.1/include/mono-1.0 /sw/include/glib-2.0 /sw/lib/glib-2.0/include

      12: LIBS += -L/Library/Frameworks/Mono.framework/Versions/2.6.1/lib -L/sw/lib -pthread -lmono -lpthread -lm -lgthread-2.0 -lglib-2.0 -lintl

      13: }

      14:  

      15: unix { 

      16: DEFINES +=_REENTRANT -pthread 

      17: INCLUDEPATH += /usr/include/mono-1.0 /usr/include/glib-2.0 /usr/lib/glib-2.0/include

      18: LIBS += -Wl,--export-dynamic -pthread -lmono -ldl -lpthread -lm -lgthread-2.0 -lrt -lglib-2.0 

      19: }

      20:  

      21: win32 {

      22: INCLUDEPATH += "C:\Program Files (x86)\Mono-2.6\include\glib-2.0"  "C:\Program Files (x86)\Mono-2.6\lib\glib-2.0\include" "C:\Program Files (x86)\Mono-2.6\include\mono-1.0"

      23: LIBS +=  -L"." -lmono

      24: }

      25:  

      26: # Input

      27: HEADERS += HostRR.h

      28: SOURCES += HostRR.cpp main.cpp

      29:

If you’d like to give it a try, I’ve posted all the source to sourceforge. The results are right here:

http://jdesigner.svn.sourceforge.net/viewvc/jdesigner/trunk/csharp/HostRR/

Conclusions

We’ve seen, that accessing a .NET assembly from C/C++ is really no issue at all. C++/CLI is a great language it provides access to all of the .NET framework in a snap, however it will lock you in to the Windows world. With MONO Embedding, it is easy to break out! Given the reflection capabilities of .NET I believe the way to go forward would be to have a wrapper generator, that would just write the wrapper code.

Going forward if I were to use C++ to interact with RoadRunner, I’d probably combine the best of two worlds by falling back to C++/CLI on Windows systems and Mono embedding on Linux / OS X. But this might be a personal preference.

Computational Tools for the Annotation of SBML Models

2010-02-09T11:44:00.001-08:00

I was asked to give a brief talk for the Semantic Web in Biomedicine Seminar, on computational tools that make the task of using all the great ontologies (like MIRIAM, SBO, ChEBI, UniProt, KEGG) that we have come to love easier.

I will add the full presentation below. However, as always without all too much text, thus I’m going to continue below.

Computational Tools For The Annotation of SBML Models

View more presentations from Frank Bergmann.

I’m deeply involved with the Systems Biology Workbench (SBW), a lightweight framework that enables applications to share their functionality regardless of operating system or programming language. With SBW we also deliver a full toolset for modeling, simulating and analyzing SBML models. About five years back we started to get involved with SBGN. So today it would be great if we could automatically generate SBGN diagrams out of our SBML models. What is needed for that are annotations. Not just any annotations but annotations in the form of SBO ( the material entity branch) would be perfect. Unfortunately this is not quite enough. Additional MIRIAM annotations are needed for example to describe complexes in more detail.

I’ve been looking at this for some time and there are a couple of interesting developments to mention, of course first and foremost the EBI Web Services. They certainly make the work much easier. I introduce the:

BioModels Web Service
SBO Web Service
MIRIAM Web Service
Ontology Lookup Web Service

Each web service is briefly tested, using a Generic Soap Client, as this will allow to show the sort of information that is being provided first hand.

Of course it would be great if one would not have to hunt each Web Service down and it would seem that others had the same idea. I mention libAnnotationSBML first, a neat Java library that promises to provide a unified interface for a whole list of web services:

(photo grabbed from Neil’s presentation on Slideshare). The only drawback I could find with it is that the library is IMHO not quite ready to use by non Java geniuses. Everyone hearing me: If you are developing a library … especially a library for Java / .NET or any of the other cross platform virtual machines … please please provide a binary for people to use. It’s been a while that I worked with Java, and an ant build script that won’t work is trouble for me. As it turned out the build failed because just of a couple of missing jar files and a test failure due to changes in the SBO. Still at the end of it all I ended up with a jar file and no instructions on what to do with it. I’ve seen great demos of libAnnoationSBML with the SBMLReactionBalancer for example. This could be made available online as binary as is …

The presentation will go on to introduce SAINT: a lightweight integration environment for model annotation. It follows the same great idea as in libAnnoationSBML of hunting down the individual web services for annotations of your SBML file. However, whereas libAnnotationSBML is a Java library, SAINT is nifty web application based on the Google Web Toolkit(GWT). As such it really brings a long a snappy AJAX UI. SAINT has a lot of potential, but again it would seem I was out of luck, I could not manage to get a model annotated. Here is what went wrong: a) no upload button, but that is fine copying the SBML to clipboard and pasting it was not all that hard b) once I clicked “Annotate” however a whole bunch of Asynchronous worker bee's must have been sent out in order to fetch all my new Annotations. But when they came back they brought along a whole list of annotations I had no interested in:

The above image represents all the results found for “glucose”. And while it is great to find so many Pathway Commons Identifiers, the link to Pathway Commons lead to 404. The trick seems to be for me to disable the “New Reactions” checkbox in advanced options. Then I received a couple of SBO terms for my model, however not much more. But SBO terms are a good start, so from here I went to the “Get Annotated Model Code” tab, but try as I might I was never able to actually retrieve my annotated model.

Looking at other currently available software tools like CellDesigner and COPASI, both tools that support MIRIAM annotations I am not sure whether users of the tools will take full advantage of the Annotation process. Thus I end the presentation with a couple of screenshots of software tools using the EBI Web Services, to interact with the BioModels Database, resolve the publication citation and visualize the annotations in a way better suited to the community.

Why should we just display the ChEBI identifiers, when we could just as well show a formula, or the name, with a click revealing the full set of annotations.

RoadRunner and the new test suite

2010-01-19T12:05:00.001-08:00

Yesterday the SBML team announced a new release of test data for the SBML Test suite. So of course I had to check how roadRunner fares in it. A re-run of the test suite with only SBML Algebraic Rules and the ‘fast’ flag disabled gives the expected result of:

All green! Just as it was meant to be. I really should make a new release of SBW soon! Lots of new things up and coming the highlights for roadRunner will include acronyms like SED-ML and SBRML …

Stay tuned!

Matlab Export Anyone?

2009-11-14T11:50:00.001-08:00

SBW for a long time had facilities for exporting SBML models to Matlab and a slew of other formats. I have to admit I never really used the Matlab Export before, and so it came as a surprise when I heard that the export of SBML Assignment rules was broken. But good news, at least this export is now working just fine.

So let us look at some examples on how we would use it. For this let us construct a very simple model, a 3 step linear chain:

Here we set Node0 and Node2 to be a Boundary (fixed) Species, as they are not really part of the system. And we want Node0 to be controlled by an Assignment Rule, which sets the value of Node0 to ‘5’ starting at 1 second for 2 seconds. Outside this window Node0 should be close to zero (and I say close to zero and not zero so that the integrators will pick up the change). So this translates into a piecewise function:

Node0 = 5 if 1 < time < 3 and 0.1 otherwise

in SBML infix speak this translates into:

Node0 = piecewise(5, and(geq(time,1), leq(time, 3)), 0.1)

here of course piecewise, stands for the piecewise operation, note that you can have as many pieces as you’d want … for every piece you would add two terms, the value and a Boolean expression. The Boolean expressions supported are:

Name	Argument type	Explanation
and	n-ary	n-ary and like in the example above, it is 1iff all arguments are 1
xor	n-ary	n-ary xor, is 1 iff not all arguments are 1 or all arguments are 0
or	n-ary	n-ary or, is 1 if at least one of the arguments is 1
not	unary	is 1 if argument is 0 and 0 otherwise
gt(a,b)	binary	greater: is 1 if a > b
lt(a,b)	binary	less than: is 1 if a < b
geq(a,b)	binary	greater or equal: is 1 if a >= b
leq(a,b)	binary	less or equal: is 1 if a <= b
eq(a,b)	binary	equal: is 1 iff a == b
neq(a,b)	binary	not equal: is 1 iff a != b
piecewise( value, condition, otheriwse)	n-ary	piecewise function: each piece is defined with a value, condition pair and concluded with an value for the otherwise clause. all values and conditions can of course be function expressions as well.

So let us look at the complete model in the JarnacLite language (this will allow you to just paste it into JarnacLite without you having to download the SBML model):

p = defn AsssignmentExport

var Node1;
ext Node0,Node2;

J0: Node0 -> Node1; J0_k*Node0;
J1: Node1 -> Node2; J1_k*Node1;

Node0 = piecewise(5, and(geq(time,1), leq(time, 3)), 0.1);

end;

p.Node0 = 0;
p.Node1 = 0;
p.Node2 = 0;
p.J0_k = 0.1;
p.J1_k = 0.1;

When in JarnacLite, a click on SBW\Translate SBML –> Any will bring up the SBML Translators, and a click on the Matlab tab shows you the newly translated model:

As you can see this model is complete with instructions on how to use it in Matlab. And here the good news it works in Octave as well! (you’d just download ode23.m and put it in the same directory and you should be good to go!) So all that is left is to save the file as .. say … AsssignmentExport.m into your Matlab work directory and run:

x0 = AsssignmentExport
[t, x] = ode23s(@AssignmentExport, [0 20], AssignmentExport);
plot(t,x);

and you should see a graph like this:

And here the disclaimer, I do know that you’d normally implement these sort of things as SBML Events, but so far we don’t export SBML events to Matlab, but you can always use roadRunner to have them simulated correctly.

So if you want to give this new version of the Matlab export a try, download a new Installer, or select Systems Biology Workbench\Utilities\Update SBW from an existing SBW installation.

Changing Initial Concentrations the easy way

2009-11-06T16:52:00.001-08:00

It’s been some time since I updated the SBW Simulation Tool, just to jog the Memory the SBW Simulation Tool, is the application, that will interact with all SBW enabled Simulators and makes it a snap to perform simulation experiments (be it time course simulations, steady state computations, pulse or scan experiments or even Frequency Analysis). Especially neat, if you ask me, is the Options\Slider feature, which basically attaches a handle to all parameters / boundary conditions of a model and allows you to quickly modify the current value and see what effect it has on the simulation you were performing.

Changing parameters and boundary conditions was great, but what about initial concentrations of all the floating species. Of course that is an operation that should have been there in the first place, and so *drum roll* here finally a version that makes it a snap to modify those values as well. So lets try it, lets take a simple bi-stable model like this one:

p = defn Bistable

var S1, S2;

$X0 => S1; k1*(1+x)/(1+k2*pow(S2,2));
$X0 => S2; k3/(1+k4*pow(S1,2));

S1 => $X0; k0*S1;
S2 => $X0; k0*S2;

end;
// initialize Parameters
p.k1 = 1; p.k2 = 1; p.k3 = 1; p.k4 = 1; p.k0 = 0.1;

// and initial conditions
p.S1 = 5; p.S2 = 5;

You’d paste the model above simply into JarnacLite and then click SBW\Simulation Tool: RoadRunner to get it into the simulator. And then select Options\Sliders … and now if you vary the initial conditions of S2 you see how the behavior changes … amazing, isn’t it?

Here the result for S1 = 4

and S1 = 6

Neat … just as an aside … remember to check the “Fix Y Axis” Checkbox! otherwise the experience is limited, as the graph will scroll the whole time to adapt to the values.

Systems Biology Workbench / Linux made easy

2009-11-02T09:27:00.001-08:00

I’m just back from the monospace event, which by the way was really amazing. In his keynote Miguel presented SUSE studio, which makes it very easy to put together a Linux live cd, VMware image or USB images with your favorite Linux app.

Given the huge number of support requests I received for the SBW Linux versions, i thought it would make a good test case to put together a live CD for the last SBW version. Here the download links:

The Linux distribution is openSUSE (11.1) and automatic login is set up for user ‘sbw’ with password ‘linux’ which is also the admin password.

And here a screen cast of what the experience is like (For this i just downloaded the VMware Image above, extracted the archive (using for example WinRAR) and next started the VMware Image using VMware Workstation (a free VMware player is also available)):

Now admittedly, this is not yet working as smoothly as possible, I will polish the build process in time for the next SBW release and then all the remaining GUI glitches will be gone.

Debugging the Systems Biology Workbench

2009-09-14T14:03:00.001-07:00

Work on an SBW and JSim integration is in full progress. However the other day I came across a minor snag with the SBW Java bindings, for the life of me I couldn’t find out why we could not send a model from one application to another. On any other platform (OSX, Ubuntu, Windows), I would just have started the SBW Inspector, and called the methods from the UI, or I would have used PowerShell, or the CSharp interactive shell, or even IronPython to code against the SBW object model. However I was out of luck, I did not have the mono runtime available on that system. So it dawned to me that really there should be some sort of simple debugging tools available. Given that on the system the only thing I had available was Java, I went and wrote the simplest Java SBW modules to narrow down the process. I figured in case others have the same problem I might as well put them up here for grabs.

So how would you use those java classes:

Download the SBWtest.tar.gz file
Extract with: tar zxf SBWtest.tar.gz
change to the directory: cd SBWtest

at this point you will find two jar files (SBWCore.jar and SBWCore-debug.jar). Those jar files are the SBW Java bindings. All the following commands will assume that you include them in your classpath. There are two jar files, the SBWCore.jar will silently do its work and SBWCore-debug.jar will work just the same but add tons of debugging information for when it is really needed. Usually you’d just use the SBWCore.jar, and only switch to the other one if something fishy is going on. Let us have a brief look at the java classes included in the archive:

ListModules	This all this simple class does, is to connect to SBW, and get a list of registered modules and print them to stdout. Use with: java –cp SBWCore.jar:. ListModules This will print a list of module names, you will have the ‘unique’ module name, followed by an equals sign and then the human readable name.
ListRunningModules	This class connects to SBW and lists all currently running SBW modules. Use with: java –cp SBWCore.jar:. ListRunningModules
StartModule	A simple java class, that will just start another SBW module, it expects one argument, the ‘unique’ name of an SBW module (the name before the equals sign in the ListModules output). Start with: java –cp SBWCore.jar:. StartModule <moduleName> for example: java –cp SBWCore.jar:. StartModule edu.caltech.NOM to start the SBML support module.
Analyzer	The Analyzer class represents a simple SBW module by itself. It belongs to the ‘/Analysis’ category, and as such will when registered appear in the SBW module. It has one method, ‘void doAnalysis(string)’ which will take a string (usually an SBML model, when called through the SBW menu) and print it to the command line. As with all SBW modules, it takes one argument, either ‘-sbwmodule’ in which case it is launched as module, or ‘-sbwregister’ in which case it registers with the Broker (and it should be displayed with a call to ListModules as ‘testAnalyzer’). Use with: java –cp SBWCore.jar:. Analyzer –sbwregister to register, or with: java –cp SBWCore.jar:. Analyzer –sbwmodule to run it as module.
CallAnalyzer	Finally there is CallAnalyzer, a simple class, that takes two arguments, the first is a ‘unique’ SBW module name (as given by ListModules) and the other is a fileName of a SBML file, which is read and passed to the SBW module. This basically mimics what will happen if an SBW analyzer is called from the SBW menu. Use with: java –cp SBWCore.jar:. CallAnalyzer <moduleName> <fileName> as in: java –cp SBWCore.jar:. Analzer ~/SBML\ Models/BorisEJB.xml

I hope they will be useful for someone else … btw … turns out that the only thing that was not working as planned, was that the module in question was registered as SELF_MANAGED module instead of a UNIQUE one … so all is well with the bindings …

SBW FluxBalance Module – Step 2

2009-09-09T16:02:00.001-07:00

Some time ago I’ve implemented a basic FluxBalance SBW Module. It never was that useful really, all one could do was to load an SBML file and to define a couple of constraints and objectives. So while Brett Olivier is visiting Seattle, we sat together and came up with a scheme to store this sort of Information. This resulted in the next version of the FluxBalance tool:

This new version does not do much more than it did before, however now at least it stores the constraint and objective function in an SBML compliant annotation (which hopefully later on becomes an official SBML Level 3 package for flux balance analysis).

There is a new Windows Installer, that you can try right away …

RoadRunner and Events

2009-09-08T15:59:00.001-07:00

Finally I’m back from this years ICSB. In discussions at the SBML Forum I noticed that the timing of events in roadRunner could be improved. RoadRunner is of course our high performance simulator, which is also available as web application on our home page. I’ve just finished the modifications on roadRunner and ran through the test suite again:

And while roadRunner still won’t support Algebraic Rules, the ‘fast’ flag on SBML Reactions or Delay Differential Equations, we now pass all other tests. (You might wonder about the isolated four points that in red scream that the event timing would be off. For full disclosure those are the test cases 408, 428, 684 and 849. In discussions with the COPASI team and Chris Myers from iBioSim it would seem that it is the test cases that are to blame.)

Windows users can get the new roadRunner installed from here, or by choosing “Systems Biology Workbench\Utilities\Update SBW” from the Start menu of an existing SBW 2.7.10 release. A new Linux and OSX release will be made later in the month, or early next month, when we hopefully have SBML Level 3.

SBW 2.7.10 Released

2009-08-19T12:38:00.001-07:00

Finally, the new version of SBW is released, just in time for this years ICSB. Here the full release announcement:

We are pleased to announce the a release of the Systems Biology Workbench 2.7.10,

available from:

http://sys-bio.org

The Systems Biology Workbench (SBW), is a software framework that allows heterogeneous application components-written in diverse programming languages and running on different platforms - to communicate and use each others' capabilities via a fast binary encoded-message system. Our goal was to create a simple, high performance, open-source software infrastructure which is easy to implement and understand. SBW enables applications (potentially running on separate, distributed computers) to communicate via a simple network protocol.

The interfaces to the system are encapsulated in client-side libraries that we provide for different programming languages.

There are a number of significant changes in this release:

Event support in Jarnac Lite, improved event support in roadRunner (and support for delayed events), improved display of discrete events in the Simulation Tool.
Improved support for SBML Layout and proposed Render Extension, changes in auto layout module, adding of a SBGN style sheet based on SBO terms.
Numerous bug fixes and usability improvements

For a full list of changes see: http://sys-bio.org/changelog

For a list of modules included with the Systems Biology Workbench and a description of what they do please have a look at http://jdesigner.sourceforge.net/

In case you are interested in instruction in how to use the Systems Biology Workbench join our tutorial at this year’s ICSB, for more information see: http://www.sys-bio.org/sbwWiki/tutorials/icsb2009

As always we appreciate any feedback from users send to: sbwteam@gmail.com

Thanks
- Frank (for the SBW Development Team)

Almost there – Next SBW Release

2009-08-17T18:42:00.001-07:00

I’m finally in the final phase of testing the next SBW installer. Here the list of operating systems tested so far: Win 2000, Win XP, Vista, Windows 7, Windows Server 2003, Windows Server 2008, Fedora 11, Centos 4.6, Centos 5, Debian 5.0, Ubuntu 5, Ubuntu 9.04, openSUSE 11.1, Slackware 12.2 and of course OS X 10.5. All seems to be well and ready to go.

So here the links to the current installers let me know if things need to change:

Of course things go sometimes horribly wrong, especially with … shall we say … not quite up-to-date linux installations. So here a couple of things to keep in mind:

get a new-ish MONO, it will help a lot the current version of MONO 2.4.2 is just amazing and it seems to be feature complete. Thus there is no real reason not to use it. Alas, for some distros it is really hard to get to a working MONO installation. If your system belongs to this category, have a look here, and download the 1.9.2 binary installer.
Some linux distros forsake a good and working Java installation with a gnu compiler, unfortunately our java modules do not play nice with it, in fact the post installation step is likely to fail if you have it as first java in your path. You’d be better of getting a nice JDK, like the one from SUN, or even the OpenJDK from your linux distro.
If you still have trouble with the post installation step, you don’t have to uninstall SBW, just run the post installation step manually as in:

<sbw-2.7.10 dir>/register.sh <full path to sbw 2.7.10 dir> or

./register.sh /home/fbergmann/SBW-2.7.10

that usually works and if a step takes too long a friendly ps-ef followed by a kill –9, or even simply a

killall –9 java, killall –9 mono, killall –9

Broker works wonders.

Cheers and on to more testing.

Re-release of SBW 2.7.9

2009-03-16T13:14:00.001-07:00

Just a follow up on last weeks entry about Installation Problem of SBW 2.7.9 on Windows XP machines. The problem has now been resolved (by recompiling all C++ modules using VS 2003). And SBW 2.7.9 R2 is available for download from SourceForge.

Here the full change log:

Changes in Version 2.7.9 R2
===========================

This release is a re-release of SBW 2.7.9, that was necessary because some windows machines
had problems running the new version due to problems with the C++ Runtime. In this version:

- all C++ modules and libraries have been recompiled with MSVC7

- JacobianViewer: The JacobianViewer was recompiled to run on 64bit systems in the 32bit
sub system.
- C# Inspector: BugFix: some UI-controls would not align properly when the window was resized.

FluxBalance Analysis with SBW

2009-03-16T12:56:00.001-07:00

Herbert came across the LPsolve, a LPGL library for solving linear programming questions. Steady state flux balance analysis can be stated as linear programming question. This is what the new SBW FluxBalance module does:

You can load an SBML file, specify all flux constraints and your objective that is to be minimized / maximized and the module will solve the LP problem.

The prototype is available for download. In the near future this functionality will also be included in LibStructural.

Installation problems of SBW 2.7.9 on Windows XP

2009-03-08T19:35:00.001-07:00

While away on conference I have heard of several issues installing SBW 2.7.9. I’m terribly sorry for the problem. A new installer will be issued end of next week, this will give me time to sort out the issue.

In order to make the current SBW 2.7.9 working all that is needed is to install the Visual Studio 2008 SP1 Runtime in fact the installer is attempting to install the runtime, but in the cases where the installation fails, this obviously did not work. To use this version of SBW 2.7.9 :

Install the Visual Studio 2008 SP1 Runtime
Uninstall SBW 2.7.9 (or delete \Program Files\KGI\SBW)
Reinstall SBW 2.7.9

Again I’m sorry for the inconvenience. The new version next week, will re-use an older version of the runtime, resulting in some loss of functionality, however it does not require the separate runtime installation.

Join us at SIGCSE 2009

2009-03-03T12:00:00.001-08:00

I’ll be presenting new developments for the Systems Biology Workbench, as well as Athena, our CAD / CAM Software for Synthetic Biology at the 40th ACM Technical Symposium on Computer Science Education or short SIGCSE 2009. You can find us in Exhibit Hall A, at the Microsoft booth #201.

Systems Biology Workbench 2.7.9 released

2009-03-03T11:50:00.001-08:00

We finally have a new release of the Systems Biology Workbench. Here the release announcement:

We are pleased to announce a release of the Systems Biology Workbench 2.7.9,

available from:

http://sys-bio.org

The Systems Biology Workbench (SBW), is a software framework that allows heterogeneous application components-written in diverse programming languages and running on different platforms - to communicate and use each others' capabilities via a fast binary encoded -message system. Our goal was to create a simple, high performance, open -source software infrastructure which is easy to implement and understand. SBW enables applications (potentially running on separate, distributed computers) to communicate via a simple network protocol.

The interfaces to the system are encapsulated in client-side libraries that we provide for different programming languages.

Of primary focus for this release was to improve performance for core SBW components. Now roadRunner as well as all AutoLayout procedures are much faster than before. The ‘Simulation Tool’ now also allows performing frequency analysis experiments. Much effort has gone into making sure that this release works on the Win64 architecture. This release includes also fixes for Jarnac, JDesigner and most other applications we deliver with the framework.

For this Windows release we switched to a new compiler. Thus it is recommended to uninstall the previous version of SBW prior to installing this release. It is also recommended to install the compiler runtime components from: http://shrinkster.com/14xc

For a full list of changes see: http://sys-bio.org/research/sbwChangelog.htm

As always we appreciate any feedback from users send to: sbwteam@gmail.com

Thanks

- the SBW Development Team

Frequency Analysis integrated …

2009-02-28T11:43:00.001-08:00

For a long time now roadRunner has the capability to calculate the frequency response for the currently loaded model. Of course the functionality was never used, as it was not exposed in any of our interfaces. So for the upcoming release of SBW 2.7.9 I have integrated a Frequency Analysis Control with the ‘Simulation Tool’. What is different from previous applications that we had, is that now it is integrated with the environment, that is now it is possible to change the parameters, and interactively explore the frequency response. Of course the values can be exported directly to Excel (or your favorite CSV viewer), or printed. You could try it out in the release candidate to SBW 2.7.9.

What you see on the picture is that the simple linear chain model that we include with the SBW installation acts as a low pass, that is it will let a signal with low frequencies through, but not signals with high frequencies.

Simplifying Bifurcation Analysis

2009-02-28T11:25:00.001-08:00

All tools for Bifurcation analysis have always been a bit difficult to use. This was the motivation for a new frontend to Auto 2000. Below a screenshot showing the stability of BioModel #203. All that was needed was to load the model, set the Parameter to ‘A’, change the End value to ‘100’, as i wanted to sweep the range [0:100] and then to press run. In the output i noticed that the value never quite reached ‘100’ and thus i increased the number of points. All in all, really easy to use.

Of course it needs more testing, if you are interested in it you can download it. As always it will require SBW to be installed. The program also works nicely on Linux (tested with Ubuntu 8.10), you need to drop me a line, and i can wrap that up. So far I did not have much luck getting it to run on OS X.