Systems Biology Format Converter (SBFC)

From System Biology Format Converter framework (SBFC)
(Redirected from Main Page)
Jump to: navigation, search

User Guide

Introduction

The Systems Biology Format Converter (SBFC) aims to provide a generic framework to convert a Systems Biology model format into another. Interoperability between formats is a recurring issue in Systems Biology. Although there are several tools available to convert models from one format to another, most of them have been independently developed and/or cannot be easily combined. The framework is written in Java and can be used as a standalone executable or as web service. The SBFC framework currently supports conversion from SBML to BioPAX Level 2 and Level3, XPP, Octave and Dot. It is also planned to add conversions from SBML to SBGN-ML, and from SBGN-ML to an SBGN enriched graphical representation designed for use in a web browser. SBFC is a collaborative project and we hope that developers will provide support for more formats by creating new converter modules.

The following sections present the list of currently available converters and the modes to execute SBFC. A separate Developer Guide can be found in the following chapter.


Download

You can download all the converters separately or as a package from the SBFC SourceForge Web Site.


In case you discover a bug within SBFC or request new features, please let us know. There are two dedicated trackers: bug reports or feature requests. If you need further help or support you can contact the team using the following e-mail address:

biomodels-net-support [at] lists.sourceforge.net


Converters

This section introduces the converters currently supported. For a more detailed description, click on the converter name.

SBML to SBML
A list of scripts for converting between SBML levels and versions. Scripts for converting SBML model annotation from Miriam (urn) to identifiers.org (url) and viceversa are also provided.
SBML to BioPax
The main objective of the BioPAX initiative is to develop a data exchange format for biological pathways that is flexible, extensible, optionally encapsulated and compatible with other standards and can be widely adopted in a timely manner.
SBML to SBGN-ML
The mission of the SBGN-ML project is to develop high quality, standard graphical languages for representing biological processes and interactions. [IN PROGRESS]
SBML to JSIM
[TODO]
SBML to Latex
[TODO]
SBML to Octave
GNU Octave is a high-level language, primarily intended for numerical computations. It provides a convenient command line interface for solving linear and nonlinear problems numerically, and for performing other numerical experiments using a language that is mostly compatible with Matlab.
SBML to XPP
XPP-Aut is a numerical analysis software. It permits to solve differential equations, difference equations, delay equations, functional equations, boundary value problems, and stochastic equations.
SBML to Dot
GraphViz is an open source graph visualization software. The language used to encode the graphics processed by GraphViz is called DOT. Note that a "dot" file can be used with other graphical software and you have the possibility to convert them to PNG, SVG, ..)


SBFC as web service

Systems biology models can also be converted online using a web service. Access to this service can be done via: http://www.ebi.ac.uk/compneur-srv/converters/. It uses the Systems Biology Format Converter (SBFC) in the background so only the converters already integrated in SBFC are available. Currently, it is in a beta release and is only tested on the latest versions of Firefox and Google Chrome, whereas the support for IE8 is still limited.


Other converters

Here is a list of converters that are not yet integrated with SBFC because they are either in an early stage of development or no longer maintained. Due to time constraints we focused our work on the converters listed above. Detailed descriptions for each of these converters can be found by clicking on the converter name.



Developer Guide

Introduction

This chapter illustrates how to develop new converters or add new features to SBFC.

If you wish to contribute with new converters or join the team, let us know using the following e-mail address:

biomodels-net-support [at] lists.sourceforge.net

We welcome new contributors, and your contributions can be included in the official SBFC and become publicly available.

The next sections describe the steps required for developing SBFC using Eclipse and getting the SBFC source code. A guide for creating new converters is also provided.


Configuration in Eclipse

The following links provide instructions to set up SBFC with Eclipse:


Get the source code

The source code for SBFC core (framework) and SBFC Online (web service) can be obtained from the Subversion repository in SourceForge:

### Source code for the SBFC framework
svn co https://sbfc.svn.sourceforge.net/svnroot/sbfc/trunk sbfc_core

### Source code for the SBFC web service 
svn co https://sbfc.svn.sourceforge.net/svnroot/sbfc/sbfcOnline sbfc_online


### The compiled java classes are included and some helper scripts are also there
### but if you make any changes to the code you need to compile the project.
### To do so, you just need to have [http://ant.apache.org/ Ant] installed.
### At the root of the project, just type :
ant jar

### Your changes should be integrated in the SBFC jar file now.


How to add a new converter

To facilitate the implementation of additional converters, SBFC was designed with an high degree of modularity. At the software core are:

  • the interface GeneralModel in the package org.sbfc.converter.models; and
  • the abstract class GeneralConverter in the package org.sbfc.converter.

The interface GeneralModel is used for data exchange and describes the services that every input or output computational model object must implement to interact with SBFC.

UML class diagram for the GeneralModel class hierarchy
/** Interface defining the specifications that each Model must implement. */
public interface GeneralModel {

  /**
   * Set the Model from a file in the file system.
   * @param fileName path to the file containing the model
   */
  public void setModelFromFile(String fileName);

  /**
   * Set the model from a String.
   * @param modelString Model
   */
  public void setModelFromString(String modelString);

  /**
   * Write the Model into a new file.
   * @param fileName path at which the new file will be created
   */
  public void modelToFile(String fileName);

  /**
   * Return the Model as a String.
   * @return Model
   */
  public String modelToString();

  /**
   * Return the model file type extension (ex: .xml for SBML, .owl for BIOPAX).
   * @return model type extension
   */
  public String getFileType();
}


The abstract class GeneralConverter represents the generic algorithm for converting one model into another.

UML class diagram for the GeneralConverter class hierarchy
/** Abstract class defining the specifications that each Converter must implement. */
public abstract class GeneralConverter {

  /** The options for the converter. Each option is defined as a pair (name, value). */
  protected Map<String, String> options;

  /**
   * Method to convert a GeneralModel into another.
   * @param model
   * @return GeneralModel
   */
  public abstract GeneralModel convert(GeneralModel model) throws ConverterException;

  /**
   * Return the extension of the Result file.
   * @return String
   */
  public abstract String getResultExtension();

  /**
   * Set the converter options.
   * @param options
   */
  public void setOptions(Map<String, String> options) {
    this.options = options;
  }
}

To add a new converter, a developer needs to extend the class GeneralConverter and implement the method GeneralModel convert(GeneralModel model), where the parameter model is the model to convert. The model type is an implementation of the interface GeneralModel. UML class diagrams for the GeneralModel and GeneralConverter class hierarchies are shown in the two figures, illustrating the model types and the converters currently implemented in SBFC.


SBFC also supports the creation of workflows enabling the use of multiple converters in a pipeline. For each intermediate conversion, the SBFC framework checks that the output format from the previous step is the same as the input format for the next step. If this is the case, SBFC exports the output model format as a string using the method modelToString() and then imports this string as input model format using the method setModelFromString(String). The general command line to launch a conversion job from the SBFC package is provided by the class Converter. The syntax is minimal:

java Converter [Class Input] [Converter Class] [input file].