Now, the first principle was about the need for access to data (McPrinciple #1). This principle goes without saying, one would think, but is not widely accepted yet. This is why Open Data promotion is still needed. For example, data in papers still is not freely redistributable, as Peter points out once again.
Anyway, this post is not about McPrinciple #1, but about the second principle.
Molecular Chemometrics Principles #2: In order to reproduce cheminformatics studies you need to be able to understand the input data.
Readers of my blog will surely recognize this theme. Clearly this theme explains my past fetish for the Chemical Markup Language, and my more recent work on the Resource Description Framework.
And it is so easy to jump to conclusions. Easy to make mistakes. And this is not just at the received side; the sending person may have accidentally made a mistake, or left something accidentally unclear, causing incorrect assumptions, and therefore errors in the cheminformatics computation. Now, if the data was semantically (clearly) annotated, and the meaning was clear, it was also trivial to see when a mistake had sneaked in. Think of it as a check bit.
“Well, isn’t this a bit exaggerated,” you might say. Perhaps, perhaps not. An simple, recent example. We all know SMILES, right? And we all know that lower case element symbols indicate aromaticity, right? That is, c1ccccc1 is aromatic, right? So, what’s the problem then?
Now, consider the SMILES string c1ccc1. Lower case carbon element symbols, so aromatic, right? Oh, wait…
Therefore, be clear in what you mean. It saves us from a lot of trouble.
Further reading:
I haven’t actually gotten around to fiddling with Java, but ran Strigi against it to extract RDF, while having the Strigi-Chemistry plugins installed. This is part of the RDF that came out:
<example-doc.docx>
<http://freedesktop.org/standards/xesam/1.0/core#title>
"acetic acid",
"(8R,9S,10R,13S,14S,17S)- 17-hydroxy-10,13-dimethyl- 1,2,6,7,8,9,11,12,14,15,16,17-dodecahydrocyclopenta[a] phenanthren-3-one",
"testosterone";
<http://freedesktop.org/standards/xesam/1.0/core#version>
"2",
"2";
<http://rdf.openmolecules.net/0.9#atomCount>
"8",
"49";
<http://rdf.openmolecules.net/0.9#bondCount>
"7",
"52";
<http://rdf.openmolecules.net/0.9#molecularFormula>
"C2H4O2",
"C19H28O2";
I believe there is quite some room for improvement, but it’s a start :) Thanx to Joe for posting the public domain test file, so that other projects can start play with the exiting new technology. I should note, however, that I am not running a Microsoft OS nor MS-Word, and the saved documents source are the only way I have access to the CML right now.
]]>Below is the CMLRSS feed of Chemical blogspace.
Of course, publishers can take advantage of such modules, using the XML Namespaces technology. The best practices uses that for a Dublin Core and a PRISM extension. The here discussed CML extension is another one, but the point is, that you can basically plug in any module.
]]>Peter had a detailed blog about why he joined the editorial board:
I take this position with some trepidation as I have grave reservations about the current practice of cheminformatics. It suffers from closed data, closed source and closed standards, and thereby generally poor experimental design, poor metrics and almost always irreproducible results and conclusions which are based on subjective opinions.
I strongly agree with this observation, and have discussed my view on this in my thesis (send me an email if you want a copy).
So, what has the journal to say about this (see Instructions to the Author, emphasis mine):
Journal of Cheminformatics recommends, but does not require, that the source code of the software should be made available under a suitable open-source license that will entitle other researchers to further develop and extend the software if they wish to do so.
Regarding data, they even less revolutionary; recommended figures formats (EPS, PDF, PNG) focus on nice graphics instead of reuse of data. I also note that I cannot upload data in the Open Document Format, or, hey, let’s really push things, in RDF. Well, not according to the Instructions. And surely, I can put the [O|R]DF in the supplementary information, anyway. It would also be nice if I could use Jmol as an applet to enrich the graphics, and improve data reusability of the paper, like the RSC recently started to allow .
Regarding the supplementary information, there is a section on additional files, which, unconveniently are capped at 20MB size. No mention of chemical formats at all, neither any recommendation on semantic formats like CML (I wonder when this was discussed with the Editorial Board, and where Peter was at the time). How am I going to put online my 500 molecular structure CML file now? (Though it’s good to know it is virus scanned ;)
So, why do I vent my concerns about these limitations? I had not blogged about the launch of the journal earlier, because I have not made up my mind about it. On one side, I am happy to see a journal that promotes (scientific) use of papers, and a journal that allows me to keep copyright on the material. However, on the other side, what the current Instructions suggest, the data I could use from the papers is available only in an old-fashion way. That’s a lost opportunity and could have killed competition for sure. Instead, the unique selling point is now restricted to using an open access license. Nature Chemistry, on the other hand, chose data rich publishing as a selling point (though in competition with things done at the RSC).
The other thing I want to mention about the journal is the following. Rajarshi blogged about Bachrach’s paper on Chemistry publication - making the revolution (DOI:10.1186/1758-2946-1-2). Firstly, by adding a link like that for the DOI I just gave, Chemical blogspace can pick it up; we need this later. Secondly, the paper actually suggests that “[b]y publishing lots of data, available for ready re-use by all scientists, we can radically change the way science is communicated and ultimately performed”; this is in strong contrast to what I have seen in the Instructions so far.
Rich replied to Rajarshi about the requirement to log in before someone could make a comment, which he did not like. He suggested alternative ways to prevent SPAM and sorts. The choice for this commenting approach may also originate from having an Open discussion, where everyone takes responsibility for what he says. The use of OpenID, as Rich suggests would only partially address that; on the other hand, setting up a fake email address is quite common in the blogosphere too.
If Rajarshi would have used the DOI to link to the Steven’s paper, as said, Chemical blogspace would have recognized it. Instead, he chose to link directly to the PDF. This is a typical case of hamburgers in action. However, others did when they discussed the first research paper in the journal (DOI:10.1186/1758-2946-1-3). These blogs were picked up by Cb and are listed on this page.
Now, I only need to remind you of Userscripts for the Life Sciences (DOI:10.1186/1471-2105-8-487) that we have the methods to link these comments back to the journal website. The Quotes from Chemical Blogspace and Postgenomic script in particular, does the hard work (needs GreaseMonkey, the script can be downloaded here; see also Noel’s original post). This way, we can read the comments when we visit the papers homepage:
Now, the script has not yet been updated for the new journal (Noel, can you please upload the revision?), so you need
to edit the source right now and add http://*.jcheminf.com/* to the list of website the script acts on:
So, I set up XMPP services for QSAR descriptor calculation, 2D diagram and 3D geometry calculations and a few more, using the CDK. Chemical Markup Language has been my primary choice for some 10 years now (see Peter’s blog) as it allows me to do things I cannot do in other formats.
Now, our XMPP services publish themselves what data types the allow as input and what they output in return. They do this by publishing XML Schema to describe the input and output types. My CDK services use CML, so they return the CML schema. Johannes’ xws4j implementation of the IO-DATA specification has an add on that can build bindings to the schema on the fly. Now, CML comes with a good XOM-based binding (called CMLXOM) so this is not strictly necessary, but for less common schemata it is worthwhile: you can always create bindings for brand new schemata, for older versions, for whatever. Services can even create their own local schemata, and people will still be able to easily use them. This is to me a big plus for this architecture.
Anyway, while CMLXOM exists, we wanted to show that the on-the-fly creation of bindings works, even for large schemata, such as CML. However, one of the older flavours had an small error in a regular expression in a data type CML defines. Johannes therefore asked me to test building bindings for the CML schema version used in my services. He adviced me to use scomp for this, which is a command line utility around the XMLBeans library used for the binding generation.
As I am running Ubuntu, I preferred installing the packaged version instead of installing the binary provided by XMLBeans. Now, after I did this, I noticed that this .deb did not install the scomp utility, so I filled a wishlist bug report. Earlier this week I already encountered another bug, but this package being Java, I had a good idea on how to fix the bug.
And so I implemented my own wishlist. I’m sure there is room for improvement, as my .deb packaging skills are a bit rusty (a very long time ago I have been in the Debian New Maintainers queue, but by the time they solved the long queue delays, I was too occupied with other things. Yes, this was a long time ago already :). Anyway, Ubuntu’s LaunchPad has a nice feature, called the Personal Package Archives. This service will, after I have finished hacking on the packaging specs in the famous debian/ folder and tested the .debs build from it, will rebuild it and put the resulting package up for download.
Conclusion: a perfect opportunity to finally gives this a try. The learning curve was surprisingly shallow, and the result can be seen in my personal package archive:
Now, you can easily imagine that I will soon work on packaging stuff I did in the past too, such as update libcdk-java and now that OpenJDK in main can run Jmol reasonably, finally package Jmol for main. I just hope I remember my Alioth account, so that I can properly contribute to the debichem project.
Getting back to running scomp on the CML scheme, it works with one minor problem:
$ scomp -src . -d . cml.xsd
/home/egonw/tmp/cml/cml.xsd:10098:9: warning: p-props-correct.2.2: maxOccurs must be greater than or equal to 1.
Time to build schema type system: 1.792 seconds
Time to generate code: 3.297 seconds
Time to compile code: 9.658 seconds
The problem is reflected by line 10098 which goes like:
<xsd:sequence minOccurs="0" maxOccurs="0">
which can be traced down to line 23 in schema2/trunk/elements/tableHeaderCell.xsd. I filled a bug report about this.
]]>So, when Peter and Henry put their first documents online about the Chemical Markup Language (CML), I was thrilled, even though is actually was still SGML when I encountered it. The work predates the XML recommendation. As I recently blogged , in ‘99 I wrote patches for Jmol and JChemPaint to support CML, which were published as preprint in the Chemical Preprint Server in a paper in 2000 in the Internet Journal of Chemistry. Neither of the two has survived.
Anyway, the Chemistry Development Kit makes heavy use of CML, and Bioclipse supports it too. Now, Bioclipse is based on the Eclipse Rich Client Platform architecture, for which there exist quite a few XML tools in the Web Tools Platform (WTP). Among these, a validation, content assisting XML editor. This means, I get red markings when I make my XML document not-well-formed or invalid. Just a quick recap: well-formedness means that the XML document has a proper syntax: one root node, properly closed tags, quotes around attribute values, etc. Validness, however, means that the document is well-formed, but also hierarchically organized according to some specification.
Enter CML. CML is such a specification, first with DTDs, but after the introduction of XML Namespaces with XML Schema (see There can be only one (namespace)). The WTP can use this XML Schema for validation, and this is of great help learning the CML language. Pressing Ctrl-space in Bioclipse will now show you what allowed content can be added at the current character position.
Yes, Bioclipse can do this now (in SVN, at least). This has been on my wishlist for at least two years now, but never really found the right information. Now, three days ago David wrote about End of Year Cramps in which he describes some of his work on the WTP for autocomplete for XPath queries. He see[s] a brighter future for XML at eclipse over the next year. I hope that those in the eclipse and XML community will help to continue to improve the basic support, so that first class commercial quality applications that leverage this support can continue to be built.
That was enough statement for me to ask in the comments
on how to make the WTP XML editor aware of the CML XML Schema. It already picked up XML Schema’s with
xsi:schemaLocation, but I needed something to worked without such statements in the XML document itself.
David explained that me that I could use the org.eclipse.wst.xml.catalog extension.
This was really easy, and commited to Bioclipse SVN as:
<extension
point="org.eclipse.wst.xml.core.catalogContributions">
<catalogContribution>
<uri name="http://www.xml-cml.org/schema"
uri="schema24/schema.xsd"/>
</catalogContribution>
</extension>
However, that does not make the WTP XML editor available in the Bioclipse application yet. Not ever in the “Open With”… So, I set up a CML Feature. After a follow up question, it turned out that the CML content type of Bioclipse was already a sub type of the XML type (see ):
<extension
point="org.eclipse.core.runtime.contentTypes">
<content-type
base-type="org.eclipse.core.runtime.xml"
id="net.bioclipse.contenttypes.cml"
name="Chemical Markup Language (CML)"
file-extensions="cml,xml"
priority="normal">
</content-type>
</extension>
So, the only remaining problem was to actually get the WTP XML editor as part of the Bioclipse application. The new CML Feature takes care of that (I hope the export and building the update site work too, but that’s yet untested), by important the relevant plugins and features. Last night, however, I ended up with one stacktrace which gave me little clue on which plugin I was still missing.
Therefore, I headed to #eclipse and actually met David of the blog that started this again. He asked nitind to think about it too, and they helped me pin down the issue. This relevant bit of the stacktrace turned out to be:
Caused by: java.lang.IllegalStateException
at org.eclipse.core.runtime.Platform.getPluginRegistry(Platform.java:774)
at org.eclipse.wst.common.componentcore.internal.impl.WTPResourceFactoryRegistry$ResourceFactoryRegistryReader.(WTPResourceFactoryRegistry.java:275)
at org.eclipse.wst.common.componentcore.internal.impl.WTPResourceFactoryRegistry.(WTPResourceFactoryRegistry.java:61)
at org.eclipse.wst.common.componentcore.internal.impl.WTPResourceFactoryRegistry.(WTPResourceFactoryRegistry.java:55)
... 37 more
This refered to this bit of code of Eclipse’ Platform.java:
Bundle compatibility = InternalPlatform.getDefault()
.getBundle(CompatibilityHelper.PI_RUNTIME_COMPATIBILITY);
if (compatibility == null)
throw new IllegalStateException();
So, the plugin I turned to to have missing was org.eclipse.core.runtime.compatibility. Apparently, some parts of the WTP that the XMLEditor is using, still uses Eclipse2.x technology.
This screenshot shows the WTP XMLEditor in action in Bioclipse on a CML file. It shows the document contents with the ‘Design’ tab, which also shows allowed content, as derived from the XML Schema for CML. Also, note that the Outline and Properties view automatically come for free, which allows more detail and navigation of the content.
This screenshot shows the ‘Source’ tab for the same file, where I deliberately changed the value of the @id attribute of the first atom. The value does not validate against the regular expression defined in the CML schema for @id attribute values. It also shows the content assisting in action. At any location in the CML file, I can hit Ctrl-Space, and the editor will show me which content I can add at that location.
This makes Bioclipse a perfect tool to craft CML documents and learn the language.
]]>Anyway, the key thing which ONS and CDK and Jmol share, is that they use an Open Notebook. Not every Open Source or Open Data project does. Actually, many scientific Open Source are not open Projects! They are more like the Cathedral than the wished-for Bazaar (see The Cathedral and the Bazaar). So, Open Source (science) projects are certainly not ONS projects by default!
Now, the CDK actually is ONS, it is a Bazaar. The notebooks we use include:
What more would you wish for? That’s not a rhetorical question. Remember that every reader of this blog is in my advisory board !
Unfortunately, I do not create work at a workbench myself, so I do not produce new knowledge myself, other than extracted from existing data. That’s really a shame, and I really do hope that Jean-Claude or Cameron will send me a box to measure solubilities (see here, here, and here, here for first data exploration), even though I cannot participate in the challenge. (hint, hint :)
One Cathedral we ran into with Bioclipse was BioCatalogue, which will serve as website where people can annotate and categorize (web) services. While the project has been around for a while, the website was rather uninformative. Fortunately, the projects is going to open up, and be more Bazaar-like. For example, they now started a wiki and a mailing list. I hope these efforts will continue, so that I can contribute from my point of view!
The EMBRACE Registry is a project with similar goals and a rather nice outcome (which I learned about on Monday ). It is actually anticipate to be replaced by or merge with BioCatalogue. So, all data I entered, cheminformatics workflows (look, no ‘o’ ), will later be available from BioCatalogue too. That is already my first contribution to BioCatalogue. One enormously interesting feature of the Registry, is that is allows uploading of code to test the service. This will mean the Registry will not only poll if the service is still online (by checking the WSDL file), it will also test if the service behaves properly. Now, immediate thoughts are mashups with MyExperiment. Each WSDL entry in the Registry points to MyExperiment workflows that use them, and the workflow page would indicate the status of all used WDSL services. This integration was already anticipated long before I thought about it, as the involved Cathedrals were nicely located in the same floor in Manchester.
Below is a screenshot from the EMBRACE Registry for the ChemSpider WDSL entry for a workspace I uploaded about a year ago to MyExperiment:
BTW, ChemSpider has an Advisory Board of which I am member, but it is also a classical (and intentional) Cathedral project. We do share common interests though, which makes us collaborate.
One recurrent theme in Open Source is given enough eyeballs, all bugs are shallow. This surely applies to science as well. The difference between the two is that in current science the eyes only inspect with a delay of at least 6 months. Current practice is that research is finished (delay), and when decided publishable written up a paper (delay, and loosing valuable information in the process, as you can read in my blog all the time), and published (even more delay). ONS changes that, and so do Bazaar-like open source projects, such as the CDK, Jmol and Bioclipse. They bugs are present, whether we like it or not, not just in source code, but in science too. Theories get overthrown, but why should we like the long delays current scientific good practice? Hate it! Work around it. Use the Bazaar. Use ONS!
Now, ONS actually needs Open Source, allowing them to deal effectively with the data they produce; to allow extraction of new scientific knowledge from the measurements. If Rajarshi and Pierre would not have made their efforts, other could not easily join in, leading to those much hated delays. Bugs should be shallow, and openness allows us to make those bugs visible. We can prove that there is a bug, without having to reproduce data ourselves, leading to those nasty delays again. Just copy the data, compare it to your own, do your analysis.
One recent project in open source chemistry dealing with making bugs visible, is the web page set up by Andreas Tille for the DebiChem project. His page summarizes the bugs listed for the chemistry in Debian (which includes the Blue Obelisk projects Avogadro, BODR, CDK, Chemical MIME Data, Kalzium and OpenBabel):
This data analysis helps the projects being analyzed.
This brings me to a last topic, for this blog: packaging using Open Standards. In order to allow those eyeballs to spot bugs, it is of the utmost importance to package your results in Open Standards, and not just one, but likely many. For Open Source projects this ultimately means Distribution Packages (deb or rpm). If that goal has been achieved, you know your results can be read by anyone. Software should be installable (make, ant, cmake, etc), and Data should be readable (no PDF, but RDF, XML, JSON, or whatever standard). Preferably not Excel, as this is too free format (as Rajarshi also indicated), but with some added conventions it may do well. Blue Obelisk project are generally doing well in terms of packaging.
For the CDK, which already is reasonably well packaged, I am currently working on Eclipse and Maven2 packages. The former is already being used by Bioclipse, while the second aims at Jumbo (which has just seen a new release. Jim, I’m happy to see the CMLDOM/Jumbo split!), CDK-Taverna, and possibly a third (Paula, what for do you plan to use it?). The POM export is not fully working yet, but with four research sites involved in this Open Project, I’m sure we’ll work it out.
The bottom line is, scientific progress would benefit so much from a Bazaar approach. And the key thing is not collaboration; that’s something you can do in a Cathedral-like fashion too. No, the key thing is to be Open and allow anyone, even your worst nightmare, to comment on what you do. Let him prove you wrong, openly, that is.
OK, there it is. My open notebook entry for this week. Now you know what I have been up to this week.
]]>dimethylether = cdk.fromSMILES( "COC" );
cdk.addExplicitHydrogens( dimethylether );
cdk.generate3dCoordinates( dimethylether );
// save as CML
cdk.saveCML( dimethylether, "/Virtual/dimethylether.cml" );
ui.open( "/Virtual/dimethylether.cml" ); // this should open a JmolEditor
jmol.minimize();
You can see four of my favorite cheminformatics tools integrated: CDK is used to convert a SMILES into connection table with add explicit hydrogens, and to create initial 3D coordinates (with the code from Christian Hoppe, and thanx to Stefan for fixing that code in the CDK 1.1.x branch!). Then, CMLDOM is used to create and save a CML document, which is then opened into a Jmol editor in Bioclipse.
A variation of this script is visible in the following screenshot:
This and other Bioclipse2 scripts I will post in Gist, a sort of pastebin supporting version history, and I’ll tag them with bioclipse gist on delicious, so that you can always browse them, comment on them, or add your own gists at http://delicious.com/tag/bioclipse+gist.
]]>X-Mozilla-Status: 1011
X-Mozilla-Status2: 00000000
Message-ID: <372ECD5E.53A49584@ice.mpg.de>
Date: Tue, 04 May 1999 12:35:10 +0200
From: Christoph Steinbeck
Reply-To: steinbeck@ice.mpg.de
Organization: Max-Planck-Institute of Chemical Ecology
X-Mailer: Mozilla 4.51 [en] (WinNT; I)
X-Accept-Language: en
MIME-Version: 1.0
To: Egon Willighagen
Subject: Re: Participating in JChemPaint
References: <000701be9613$34cf52e0$8e74ae83@catv6142.extern.kun.nl>
Content-Type: text/plain; charset=us-ascii
Content-Transfer-Encoding: 7bit
> Egon Willighagen wrote:
>
> Dear Christoph Steinbeck,
>
> Yesterday I visited your site on JChemPaint. I like to contribute some
> of my expertise on
> Java and CML (1).
>
> CML is a markup language that is able to contain chemical information.
> It can contain for example physical properties, for which I use CML in
> my Dictionary on Organic Chemistry (2).
> But is also might contain spectra, bibliographic references etc. And
> of course 2D and 3D
> structural information.
>
> Therefore I propose to write both CML-input and -output procedures for
> the JChemPaint project.
>
> I hope to hear from you soon.
>
> Yours sincerely,
>
> Egon Willighagen
>
> 1. http://www.xml-cml.org/
> 2. http://www.sci.kun.nl/sigma/Chemisch/Woordenboek/
Dear Egon,
thanks very much for your mail and your offer to write CML-input and
output routines for JChemPaint.
That really sounds great to me and I will give you access to our CVS
tree as soon as we have discussed the details.
Cheers,
Chris
--C. S.
Dr. Christoph Steinbeck (http://www.ice.mpg.de/~stein)
MPI of Chemical Ecology, Tatzendpromenade 1a, 07745 Jena, Germany
Tel: +49(0)3641 643644 - MoPho: +49(0)177 8236510 - Fax: +49(0)3641
643665
What is man but that lofty spirit - that sense of enterprise.
.. Kirk, "I, Mudd," stardate 4513.3..
Now, my email must have been triggered by the announcement of JChemPaint on FreshMeat.net, which is the oldest public record of JChemPaint I have found so far:
#!/usr/bin/bsh
import java.io.File;
import java.io.FileReader;
import java.io.BufferedReader;
import org.openscience.cdk.*;
import org.openscience.cdk.exception.*;
import org.openscience.cdk.inchi.*;
import org.openscience.cdk.interfaces.*;
import org.openscience.cdk.io.CMLWriter;
import org.openscience.cdk.libio.cml.Convertor;
import org.xmlcml.cml.element.CMLReaction;
import net.sf.jniinchi.INCHI_RET;
InChIGeneratorFactory factory = new InChIGeneratorFactory();
// Get InChIToStructure
File file = new File("inchi.ugi.txt"); // five inchis expected, last being the product
BufferedReader reader = new BufferedReader(new FileReader(file));
String first = reader.readLine();
String second = reader.readLine();
String third = reader.readLine();
String fourth = reader.readLine();
String product = reader.readLine();
System.out.println("First: " + first);
IMolecule firstAC;
{
InChIToStructure intostruct = factory.getInChIToStructure(first, DefaultChemObjectBuilder.getInstance());
INCHI_RET ret = intostruct.getReturnStatus();
if (ret == INCHI_RET.WARNING) {
// Structure generated, but with warning message
System.out.println("InChI warning: " + intostruct.getMessage());
} else if (ret != INCHI_RET.OKAY) {
// Structure generation failed
throw new CDKException("Structure generation failed failed: " + ret.toString()
+ " [" + intostruct.getMessage() + "]");
}
firstAC = new Molecule(intostruct.getAtomContainer());
}
System.out.println("Second: " + second);
IMolecule secondAC;
{
InChIToStructure intostruct = factory.getInChIToStructure(second, DefaultChemObjectBuilder.getInstance());
INCHI_RET ret = intostruct.getReturnStatus();
if (ret == INCHI_RET.WARNING) {
// Structure generated, but with warning message
System.out.println("InChI warning: " + intostruct.getMessage());
} else if (ret != INCHI_RET.OKAY) {
// Structure generation failed
throw new CDKException("Structure generation failed failed: " + ret.toString()
+ " [" + intostruct.getMessage() + "]");
}
secondAC = new Molecule(intostruct.getAtomContainer());
}
System.out.println("Third: " + third);
IMolecule thirdAC;
{
InChIToStructure intostruct = factory.getInChIToStructure(third, DefaultChemObjectBuilder.getInstance());
INCHI_RET ret = intostruct.getReturnStatus();
if (ret == INCHI_RET.WARNING) {
// Structure generated, but with warning message
System.out.println("InChI warning: " + intostruct.getMessage());
} else if (ret != INCHI_RET.OKAY) {
// Structure generation failed
throw new CDKException("Structure generation failed failed: " + ret.toString()
+ " [" + intostruct.getMessage() + "]");
}
thirdAC = new Molecule(intostruct.getAtomContainer());
}
System.out.println("Fourth: " + fourth);
IMolecule fourthAC;
{
InChIToStructure intostruct = factory.getInChIToStructure(fourth, DefaultChemObjectBuilder.getInstance());
INCHI_RET ret = intostruct.getReturnStatus();
if (ret == INCHI_RET.WARNING) {
// Structure generated, but with warning message
System.out.println("InChI warning: " + intostruct.getMessage());
} else if (ret != INCHI_RET.OKAY) {
// Structure generation failed
throw new CDKException("Structure generation failed failed: " + ret.toString()
+ " [" + intostruct.getMessage() + "]");
}
fourthAC = new Molecule(intostruct.getAtomContainer());
}
System.out.println("Product: " + product);
IMolecule productAC;
{
InChIToStructure intostruct = factory.getInChIToStructure(product, DefaultChemObjectBuilder.getInstance());
INCHI_RET ret = intostruct.getReturnStatus();
if (ret == INCHI_RET.WARNING) {
// Structure generated, but with warning message
System.out.println("InChI warning: " + intostruct.getMessage());
} else if (ret != INCHI_RET.OKAY) {
// Structure generation failed
throw new CDKException("Structure generation failed failed: " + ret.toString()
+ " [" + intostruct.getMessage() + "]");
}
productAC = new Molecule(intostruct.getAtomContainer());
}
IReaction ugiReaction = new Reaction();
ugiReaction.addReactant(firstAC);
ugiReaction.addReactant(secondAC);
ugiReaction.addReactant(thirdAC);
ugiReaction.addReactant(fourthAC);
ugiReaction.addProduct(productAC);
StringWriter stringWriter = new StringWriter();
CMLWriter cmlWriter = new CMLWriter(stringWriter);
cmlWriter.write(ugiReaction);
cmlWriter.close();
System.out.println(stringWriter.toString());
My apologies for the code duplication, but never tried inline functions in BeanShell yet… You can monitor the efforts at Google Docs.
]]>