Systems Biology Format Converter (SBFC)

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

User Guide


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.


You can download the last version of SBFC including all the converters here:

The next section provides the user with all the links to the single converters.

You can also download all the converters as a package or separately 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:

sbfc-devel [at]


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

A list of scripts for converting between SBML levels and versions. Scripts for converting SBML model annotation from Miriam (urn) to (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.
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 Matlab
Matlab is a high-level language, primarily intended for numerical computations. It provides a convenient GUI and command line interface for solving linear and nonlinear problems numerically, and for performing other numerical experiments.
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.
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

Conversion jobs can be very demanding in term of CPU and memory, if you have large models or a large number of models to convert. Systems biology models can also be converted online using SBFC web service. This uses the SBFC in the background so only the converters already integrated in SBFC are available. We implemented two modes to convert models within SBFC web service:

  • via a web browser. In this case the conversion uses the cluster of computer machines at the EBI (European Bioinformatics Institute). Please, visit the web page: The user must specify the input and output model formats. Models can be converted via three input methods: multiple file upload, URL pointing, copy/paste. Once the conversion jobs are started, the results can be downloaded for 24 hours after the conversion finished. It is worth noting that neither the original nor the converted models are kept on the servers for a period longer than 24 hours for privacy purposes. As the web service uses SBFC in the background, 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.
UML class diagram shows how to use the class ConverterLink from command line
  • via the Java class ConverterLink. This class allows the user to run conversion job and get the converted model directly as the return value of a method. This is useful SBFC has to be integrated in an existing application. A UML class diagram for the class ConverterLink and how to use it is shown in Figure \ref{fig:UML class diagram for ConverterLink. Depending on user requirements, two types of methods for submitting conversion jobs can be selected within the class ConverterLink:
    • blocking calls: the methods submitAndGetResultFromURL() and submitAndGetResultFromString() start a conversion job and will wait until the model is converted and returned from the web server. For big models the conversion process can take several minutes.
    • non blocking calls: the methods submitJobFromURL() and submitJobFromString() start a conversion job and immediately return a ConversionId object. The status of the conversion can be check later on with the getJobStatus() method.

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


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:

sbfc-devel [at]

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 sbfc_core

### Source code for the SBFC web service 
svn co 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 [ 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].