Finding nodes in Anopheles gambiae pathways with IUPAC names

Hypothesis: Anopheles gambiae pathways in WikiPathways have DataNode’s with labels containing IUPAC names which can be tagged as type Metabolite.

Start date: 2014-08-24 End date: 2014-08-24

Description: WikiPathways entries in GPML have DataNode objects and Label objects. It was found before [no published] that metabolites can be encoded in pathways is Label objects and therefore not machine-readable as Metabolite-type DataNode and unable to have a database identifier. As such, these metabolites are unusable for pathway analysis of metabolomics data.

By processing these GPML files (they are XML-based) and iterating over all Label’s we can attempt to convert this label into chemical structure with OPSIN. This goes under the assumption that if OPSIN can parse the label into a structure, it is one. This label will be recorded along with the pathway identifier for manual inspection. For each structure it will also look up a ChemSpider identifier.


  • Download the GPML files from WikiPathways
  • Get a working Bioclipse development version (hard) with the OPSIN, InChI, and ChemSpider extensions
  • A Groovy script to iterate over the GPML, find <Label> elements
  • Each <Label> is parsed with OPSIN and if successful, generate an InChI
  • Use the InChIs to find ChemSpider identifiers
  • Output all as a text file and open metabolites in a Structure table



Twelve WikiPathways for Anopheles gambiae were downloaded part of the analysis collection. In the future, uncurated pathways can also be included, anticipating to have more metabolites not annotated as Metabolite type. A custom Groovy script for Bioclipse was used, based on a previous similar script available from The updated script has been made available on too. The results of running this script are visible in the above screenshot.

Key calls to Bioclipse managers used in this script, in addition to using the Groovy XMLParser, are:

  • cdk.createMoleculeList()
  • opsin.parseIUPACName(name)
  • structureList.add(molecule)
  • inchi.generate(molecule)
  • chemspider.resolve(inchiKey)

Four metabolites were found, in one pathway (WP1230):

Ag_One_Carbon_Metabolism_WP1230_68447.gpml: node b93 -> Serine -> MTCFGRXMJLQNBG-UHFFFAOYSA-N -> CSID: [597]
Ag_One_Carbon_Metabolism_WP1230_68447.gpml: node ff7 -> Glycine -> DHMQDGOQFOQNFH-UHFFFAOYSA-N -> CSID: [730]
Ag_One_Carbon_Metabolism_WP1230_68447.gpml: node c8c -> Deoxythymidine monophosphate -> WVNRRNJFRREKAR-UHFFFAOYSA-N -> CSID: [315142]
Ag_One_Carbon_Metabolism_WP1230_68447.gpml: node a47 -> Deoxyuridine monophosphate -> JSRLJPSBLDHEIO-UHFFFAOYSA-N -> CSID: [21537275, 668, 21230588]

Three metabolites have a single ChemSpider identifier, whereas one has three ChemSpider identifiers.

Visual inspection of WP1230 (revision 68447) confirms our hypothesis:


Conclusion: Anopheles gambiae pathways indeed also include metabolites encoded in GPML <Label> elements.

Exposing more Jena functionality in Bioclipse

Hypothesis: Jena functionality for triple set comparison can be exposed via Bioclipse script

Start date: 2014-08-20 End date: 2014-08-20

Description: Bioclipse in the development branch mostly uses Jena for handling RDF data. The “rdf” manager already exposes various features of Jena. We here wish to expose the functionality of Jena to make unions, intersections, and differences of two triple stores (“Model”s in Jena terms) and to use the experimental shortest path method from the OntTool class.


  • start with a Eclipse development environment including the bioclipse.cheminformatics repository
  • define additional methods in the IRDFManager interface with the proper code
  • write implementations of these methods in the RDFManager class
  • publish the patches

Report While I still had a development environment from this step, Bioclipse no longer properly booted. Between that experiment and this one various things happened:

  1. Bioclipse had a new target platform
  2. I moved to a 64bit operating system
  3. I only reinstalled Java8

For resetting the target platform the normal protocol was used, though I had to repeat it a few times to get fully working. As usual, I first had to ask Arvid in Uppsala before it really started working (#overlyhonestmethods). There may have been a confounding issue with not having the proper javax.xml.soap version in my installation, and Arvid’s suggestion to manually remove the java.xml plugin from the target platform, via the Content tab.

A further issue was found in using Java8 which has a different provider for the JavaScript extension. As a result, the Bioclipse JavaScript console did not start. Apparently, my Java 8_11 installation in Eclipse does not provide any scripting environment (tested by asking the ScriptEngineManager for all engines; none were reported). Because the nashorn.jar that contains the implementation was provided by Oracle as a separate jar, containing an open source JavaScript engine originally by Mozilla, now provided via OpenJDK, I could include this jar in the Bioclipse plugin, solving these issues. Along with a few other patches, these tweaks are available in this branch on GitHub. These patches are not pushed for inclusion in the Bioclipse development branch.

The test suite was not extended and not run as “JUnit Plug-in Test” using Eclipse, because my development environment is not able to properly run these at this moment. Instead, the functionality was tested using the rdf manager from the JavaScript console with this script:

store = rdf.createInMemoryStore()

secondStore = rdf.createInMemoryStore();

unionStore = rdf.union(store, secondStore);
diffStore = rdf.difference(store, secondStore);
intersectStore = rdf.intersection(store, secondStore);

This showed expected results, with the exception that the Jena code makes default triples more visible. That is, converting the store to Turtle shows two triples, even though it has an additional 39~ish additional triples from the RDF and RDF Schema specifications. Weirdly, making a union of the store and secondStore, the number of triples increases to about 150 and converting this to Turtle does serialize all those RDF and RDF Schema triples. I have been unable to work around this feature.

The above three methods are easily wrapped, but the shortest path functionality requires an additional step: the OntTool return value is a toolkit specific type (Path) and the rdf manager was designed to convert this to a java.util.List of Strings. This functionality too was tested via the JavaScriptConsole:

store = rdf.createInMemoryStore()



The manager provides two variants at this moment of this shortestPath() method: the above exemplified version and one that takes a fourth parameter, being a String representation of an URI matching the only predicate that can be part of the path. Both methods were found to work as expected based on the above code. No application to larger data sets have been tried.

Resulting patches have been provided as a pull request.

Conclusion: Exposing the additional functionality yielded an more functional rdf manager with interesting new features.

Updating Bioclipse with OPSIN 1.6.0

Hypothesis: Bioclipse works just as well with OPSIN 1.6.0 as it does with 1.5.0.

Start date: 2014-07-20 End date: 2014-07-21

Description: Bioclipse in the development branch has OPSIN 1.5.0 exposed with the opsin manager. The intention of this experiment is to update Bioclipse with OPSIN 1.6.0, keeping the opsin manager methods working.


  • start with a Eclipse development environment including the bioclipse.cheminformatics repository
  • update the OPSIN version
  • test with the test suite
  • publish the patches


I still had a working development environment around. As I installed Eclipse 4.4 a few days earlier, I opened the Eclipse workspace with this version, which triggered an irreversible upgrade of the workspace so that I cannot return to Eclipse 4.3. The test suite was run as “JUnit Plug-in Test” using Eclipse, defined by the AllOpsinManagerPluginTests class. This shows two fails in the APITest test class, related to @TestClass and @TestMethod annotation. Annotation was added and committed as a patch to ensure no fails were reported.

Then the opsin-1.6.0-excludingInChI-jar-with-dependencies.jar was downloaded from the OPSIN download page. This version was selected because the 1.5.0 version excluded the InChI bits too and these is already available from other Bioclipse plugins. The new jar was copied into the net.bioclipse.opsin’s jar/ folder and .classpatch, MANIFEST.MF, and were updated accordingly.

The result was successfully testing using the aforementioned AllOpsinManagerPluginTests class and by running Bioclipse itself and using the opsin manager from the JavaScript console with the command“benzene”)).

The two patches were made available as pull request 46.

Bioclipse with OPSIN 1.6.0


No special updated were needed and Bioclipse works with OPSIN 1.6.0 just as it did with OPSIN 1.5.0.

Pathway analysis for Malaria research

A recurrent theme in my blog is that an easy way to support Open Science is to just join the show. You do not have to contribute a lot to have some impact. Of course, sometimes what you do has more impact than other times. Sometimes something with initially little impact gets high impact later. This is hard to predict, but maybe as well as the stock exchange. In the past I have contributed effort to many Open projects, often small bits, some things never get noticed (like my Ant man page in Debian which is more than 10 years old :).

One project I have long wanted to contribute to, is the Open Source Malaria project, which is brilliantly led by Matt Todd. I had two principle ideas:

  1. use Bioclipse to run the Decision Support against the OSM compounds
  2. do pathway analysis on malaria data
  3. use the AMBIT-JS to put all the OSM compounds online as a HTML page
The first and third I still have not gotten around to finishing. The first is a very simple way for you to contribute. The key question here is just to see how the compounds can be made less toxic / have less side effects. And Bioclipse can visualize this easily, based on various toxicity models, among all those from OpenTox. Really, a four hour job.

PCA results from
for the four sample groups.
The other task is more difficult, and I am really happy that Patricia Zaandam started a ten week internship with me to work on this task. She has been blogging her progress, and I strongly invite you to read her blog and comment (ask questions, post ideas, give criticism), as Open projects are driven by Open communication. Because WikiPathways has most pathways for human, Patricia looking at human expression data. And in five weeks time, she did the preprocessing of the raw data using and did the pathways analysis using PathVisio, resulting in this shortlist of pathways. And now the hard part starts: biological and methodological validation of her approach.

There is plenty of room for feedback. I am not at all a malaria expert, and learning a lot from her study. Some questions we welcome expert input in (as independent test set validation, so to say):
  • what key pathways and genes do we expect to see for treated-versus-ill malaria patients
  • what transcriptomics/proteomics/metabolomics data do you like us to consider too
Etc, etc...

Revisited: Handling SD files with JavaScript in Bioclipse

After asking on the Bioclipse users list it turns out there was an unpublished manager method to trigger parsing of the SDF properties (Arvid++), allowing to simplify creation of the index and not needed parsing of the chemical structures into a CDK molecule model.

That simplifies my earlier code to:

  hmdbIndex =
  props = new java.util.HashSet();
  molTable.parseProperties(hmdbIndex, props);
  idIndex = new java.util.HashMap();
  molCount = hmdbIndex.getNumberOfMolecules();
  for (i=0; i<molCount; i++) {
    hmdbID = hmdbIndex.getPropertyFor(i, "HMDB_ID")
    idIndex.put(hmdbID, i);

The next step in my use case is process some input (WikiPathways GPML files to be precise), detect what HMDB identifier is used, extract the SD file entry for that identifier and append it to a new SD file (using a new ui.append() method):

  hmdbCounter = idIndex.get(idStr)
  sdEntry = hmdbIndex.getRecord(hmdbCounter)
  sdEntry = sdEntry.substring(0, sdEntry.indexOf("M  END"))
  ui.append("/WikiPathways/db.sdf", sdEntry);
  ui.append("/WikiPathways/db.sdf", "M  END\n");
  ui.append("/WikiPathways/db.sdf", "> <WPM>\n");
  ui.append("/WikiPathways/db.sdf", "WPM" + (Integer.toString(wpmId)).substring(1) + "\n");
  ui.append("/WikiPathways/db.sdf", "\n");
  ui.append("/WikiPathways/db.sdf", "\$\$\$\$\n");

This code actually does a bit more than copying the SD file entry: it also removes all previous SD fields and replace this with a new, internal identifier. Using that identifier, I track some metadata on this metabolite.

Now, there are a million ways of implementing this workflow. If you really want to know, I chose this one because HMDB identifiers is a more prominent ID used in WikiPathways, and for this one, as well as ChEBI, I can use a SD file. For ChemSpider and PubChem identifiers, however, I plan to use the matching Bioclipse client code to pull in MDL molfiles. Bioclipse has functionality for all these needs available as extensions. 

Handling SD files with JavaScript in Bioclipse

I finally got around to continuing with a task to create an SD file for WikiPathways. The problem is more finding the time, than doing it, and the tasks are basically:
  1. iterating over all metabolites in the GPML files
  2. extract the Xref's database and database identifier (see previous link)
  3. extract the molfile from the database SD file
  4. give the WikiPathways metabolite a unique identifier
  5. record that WikiPathways metabolite has a molfile
  6. append that molfile along with the new WikiPathways metabolite ID in a new SD file
It turns out that I can use Uppsala's excellent SD functionality in Bioclipse (using indexing, it opens 2 GB SD files for me) is also available from the JavaScript command line:

  hmdbIndex = molTable.createSDFIndex(
  idIndex = new java.util.HashMap();
  molCount = hmdbIndex.getNumberOfMolecules();
  for (i=0; i<molCount; i++) {
    mol = hmdbIndex.getMoleculeAt(i);
    if (mol != null) {
      hmdbID = mol.getAtomContainer().getProperty(
      idIndex.put(hmdbID, i);

Using this approach, I can create an index by HMDB identifier of molfiles in the HMDB SD file extract just those molfiles which are found in WikiPathways, and create a new WikiPathways dedicated SD file. When I have the HMDB identifiers done, ChEBI, PubChem, and ChemSpider will follow.

Looking for a PhD and a Postdoc to work on Open Science Nanosafety

I am happy that I got my first research grant awarded (EU FP7), which should start after all the contracts are signed etc, somewhere early 2014. The project is about setting up data needs for the analysis of nanosafety studies. And for this, I have the below two position vacancies available now. If you are keen on doing Open Science (CDK, Bioclipse, OpenTox, WikiPathways, ..., ...), working within the European NanoSafety Cluster, and have an affinity with understanding the systems biology of nanomaterials, then you may be interested in applying. Click the screenshots for full details.

PhD position

Postdoc position

New Google+ communities: Bioclipse, Cheminformatics, Semantic MediaWiki

After spending countless hours on Google+, I have realized how useful their new group feature is, for sharing/finding interesting stuff happening around different technologies. It's nice handling of previews of movies, images, webpages etc makes it so much easier to spot interesting stuff. IMO it works FAR better than e.g. twitter, for this.

E.g. by subscribing to groups for the topics you are interested in (I have over 50...), I get tons of interesting stuff on your Google+ home page all the time.

While Google+ groups definitely don't replace mailing lists and IRC, which are superior for discussions, it is a great complement for sharing interesting stuff happening around a technology.

With this in mind, during the last week or so, I've tried to make sure that a few of my favourite softwares and topics have groups, which resulted in a few new ones:

... so make sure to join those of these that you like, and post some interesting stuff there! :)

read more

Why I still prefer CML (was: #ACSIndy formats session)

At the #ACSIndy meeting there was a session one chemical formats (I hope the slides will all come online). Some key tweets (thanx to Tony for the coverage):

But I am still fan of the Chemical Markup Language. In fact, I started using this when XML was not even standardized yet. Even CML has a SGML background. Well, fairly, only months before XML made it into a recommendation, and CML followed. CML is flexible, which to some is a downside; to me it is a big advantage, as it allows me to easily extend it. It support ontologies to do this, and is therefore one of the most machine readable chemical formats.

Of course, a lot depends on the libraries that you are using. For reading, there are various approaches I have taken. Originally, I wrote a library (Willighagen2011) that supported the convention idea in CML, which is a pain to many. This feature is still actively used in Bioclipse and the CDK! Of course, many cheminformaticians do not care too much about explicit semantics, and the community standard is MDL molfile V2000 (someone has exact numbers?), even though the improved V3000 update is already 30 years old (see the first tweet!).

Of  course, browsing through all tweets, I think the session nicely showed some of the newer requirements, many required the extensions presented in this session. These extension may have been part of the original specification (is there an overview of specification documents of all industry standards?), but in many cases these will also be conventions. E.g. a common convention used by cheminformaticians is to use the bond order type 4 in MDL V2000 molfiles to reflect aromaticity, even though the specification defines it differently.

I hope all specifications of these updates and conventions will find their way to the web, with at least the rights to redistribute, allowing independent tools to properly implement these standards. (The right of modification is debatable for standards.)

Willighagen, E. L., 2001. Processing CML conventions in java. Internet Journal of Chemistry 4, 4+.

Next Bioclipse-OpenTox Workshop gig: Mainz, September 30

Ola and I will be giving a Bioclipse-OpenTox workshop in Mainz on Monday 30 September, during the OpenTox EU 2013 meeting. Places are filling up quickly (really :), so sign up now if you like to learn your way around in interactively accessing chemical liabilities.

The focus will likely be on the graphical user decision support interface, so here's what you would be able to do with scripting:

This workshop would also be great if you like to learn on how we use RDF for all of thise!