JME is the most popular molecule structure editor on the web. We can integrate it to any web pages or Java applications. Now, we’re going to integrate JME into .Net applications via IKVM.NET .

Method

Although JME can be obtained at no cost, it’s still a private software as it’s not open source. Any port method at source code level would not work on JME. The only way is work with JME Java byte-code.

IKVM.NET is an implementation of Java for Mono and the Microsoft .NET Framework.To be brief, IKVM.NET is a JVM for .Net. With IKVM.NET, we’re able to run Java byte-code on .Net Framework. IKVM.NET has uncomplete support for AWT and Swing.

With several simple steps listed below, you’re able to integrate JME into your VB.Net or C# applications.

1. Download IKVM.Net and compile JME.jar into .Net assembly.
2. Wrap JME applet into a Java Swing container JWindow.
3. Popup the JWindow.

Let’s have a look at how we can do it.

Compiling JME into .Net assembly

Under the directory of IKVM.NET executables, this command below can simply covert JME from Java byte-code into .Net IL code.

C:\ikvm-0.40.0.1\bin>ikvmc.exe -target:library JME.jar
Note IKVMC0002: output file is "JME.dll"

Add JME.dll and other IKVM.NET dependencies into your Visual Studio project as reference and then you can access JME class in C#.

Display JME

JME applet = new JME();
JWindow floatingWindow = new JWindow();
floatingWindow.setSize(300, 300);
floatingWindow.setLayout(new GridLayout(1, 1));
floatingWindow.add(applet);
applet.init();
applet.start();
floatingWindow.setVisible(true);

With this code snippet you can display JME in C# applications and invoke the applet’s Java methods in C#.

In my last post, I doubted the accuracy of fingerprint based substructure search and pointed out sometimes fingerprint loosed hits. In fact, something went wrong in my code. As I was reading from SDF directly, while IteratingMDLReader does not percieve atom type or detect aromaticity automatically. This cause the incorrect matchings of UniversalIsomorphismTester, sorry for the incorrect post. I’ve run the test again, using the SMILES provided by Guha as input. The groovy script is also attached here.

#	Query	Subgraph Isomorphism	Entended CDK	Missing	Extra
1		20	24	0	4
2		7	103	0	96
3		69	100	0	31
4		6	10	0	4
5		31	41	0	10
6		23	23	0	0
7		7	75	0	68

Well, CDK fingerprint is OK.

Abstract: Doubting on the accuracy of fingerprint based molecule substructure search, I did a test between different fingerprints implemented in CDK and subgraph isomorphism. The result is very interesting, CDK fingerprints should never be used alone in substructure search, but combine CDK fingerprints and subgraph isomorphism, we can have a balance between speed and accuracy.

Backgournd

Guha wrote a post about benchmarking of different type of fingerprints with benchmarking strategies described by Bender & Glen and Godden et al. The benchmark is based on Tanimoto similarity, which is the foundation of most chemistry database’s similar structure search. Another impo

rtant feature of molecule structure search is substructure, currently, subgraph isomorphism and fingerprint are both used in substructure search. Adel Golovin and Kim Henrick’s article Chemical Substructure Search in SQL provides a pure SQL subgraph isomorphism strategies, Rich Apodaca’s post fingerprint based MySQL substructure search in MySQL also found a solution with limited binary operation in MySQL.

Fingerprint is obviously faster as it’s much less consuming than subgraph isomorphism. But the real question is, does the fingerprint method really find all the substructures? Are there any hits misjudged as substructure?

Method

Using DrugBank small molecule drugs as test dataset, several hand-draw structures of different types as queries, I performed substructure search using subgraph isomorphism and fingerprints implemented in CDK. If a hit in search results of fingerprint method is also found in search results of subgraph isomorphism method, I count this hit as a correct hit, other wise the hit will be counted as a incorrect hit.

All fingerprints implemented in CDK are tested, generated using Fingerprinter, ExtendedFingerprinter, GraphOnlyFingerprinter, SubstructureFingerprinter, MACCSFingerprinter and EStateFingerprinter. All parameters are kept default.

To test the accuracy of queries with different complexity, I drew several structures, as listed below.

Result

The result is listed below. The result is listed in the format of “A/B”. A represents current hits, i.e. hits also founded by subgraph isomorphism method. B represents incurrent hits. For example, 31/49 stands for 31 current hits and 49 incurrent hits are found. Higher A and lower B is better.

#	Query	Subgraph Isomorphism	EState	MACCS	Standard CDK	Entended CDK	Graphonly CDK FIngerpint	Substructure Fingerprint
1		31	0/0	0/43	31/49	31/54	31/574	0/0
2		54	0/0	0/1	21/95	18/84	54/1512	11/30
3		29	0/0	0/20	29/74	29/83	29/1793	0/5
4		3	0/0	0/85	3/6	3/3	3/36	0/4
5		31	0/0	29/93	31/14	31/13	31/1593	27/53
6		23	0/0	0/0	23/0	23/0	23/23	0/0
7		9	0/0	0/0	8/83	8/63	9/237	5/40

Conclusions & Questions

As we can see from the table, MACCS, Estate and Substructure Fingerprint  perform very bad, they found very little hit, sometimes no hit at all. They are not designed to do this task, it’s not amazing to see this result.

For standard and extended CDK fingerprint, sometimes standard one works better(Maybe I should use longer extended fingerprint rather than the default length, as discussed in Guha’s post). On queries of complex ring system, extended CDK fingerprint works better, but not a obvious advantage.

But I wonder why hashed fingerprint still miss some result, (see query 2 and query 7)? Why the superstructure doesn’t share the same bits with substructure? Is this because the structure is too simple?

As many incurrent hits are found, CDK fingerprints should never be used alone in substructure search. But please consider combine CDK fingerprints and subgraph isomorphism, do fingerprint search first, we can avoid performing the consuming subgraph isomorphism match on all targets, thus we can have a balance between speed and accuracy in that way.

OK. Let’s go and see how does this works.

NOTE: I choose MySQL as the development platform, SQL statements may need a little change to work on other RDBMSs. But I’m sure SQL statements for other platform will be included in the final release, as my goal is support all major RDBMSs including MySQL, PostgreSQL, Microsoft SQL Server, Oracle and IBM DB2(if possible).

If we had a database named “a_chemical_database” and a table named “molecules”.

mysql> use a_chemical_database;
mysql> SELECT * FROM molecules;
+----+-----------+-----------+-----------+
| id | smiles    | property1 | property2 |
+----+-----------+-----------+-----------+
|  1 | Cc1ccccc1 | 84        | liquid    |
|  2 | CCC       | 36        | gas       |
+----+-----------+-----------+-----------+
2 rows in set (0.00 sec)

In the table “molecules” structure information, the “smiles” column, and other properties exist. There’s nothing different between this table and common SQL tables, i.e. you don’t need to specially design your SQL tables to do structure search.

We want our search engine to know where the modification occurs if someone changed the data. It’s possible to monitor the “molecules” data directly intermittently, but this will be a very consuming task if you have a really big table. With triggers, we can know which kind of modification(INSERT, UPDATE or DELETE) is performed on which row exactly. Before we can create triggers, a table to log the modifications needs to be created.

mysql> CREATE TABLE `syncs` (
    ->   `id` int(11) NOT NULL auto_increment,
    ->   `mod_action` varchar(10) default NULL,
    ->   `prim_key` int(11) default NULL,
    ->   PRIMARY KEY  (`id`)
    -> );

In the table “syncs”, we can store which the type of modification(column “mod_action”) and the row (column “prim_key”).

If data in the “molecules” table is changed, we expect a new record inserted into the “syncs” table, for example,

mysql> SELECT * FROM syncs ;
+----+------------+----------+
| id | mod_action | prim_key |
+----+------------+----------+
|  1 | INSERT     |        2 |
|  2 | UPDATE     |        2 |
|  3 | DELETE     |        1 |
+----+------------+----------+

Now we create triggers.

CREATE TRIGGER molecules_insert AFTER INSERT ON molecules
FOR EACH ROW INSERT INTO syncs(mod_action,prim_key) VALUES('INSERT',NEW.id);
CREATE TRIGGER molecules_update AFTER UPDATE ON molecules
FOR EACH ROW
BEGIN
IF  NOT(OLD.smiles LIKE NEW.smiles)  THEN
INSERT INTO syncs(mod_action,prim_key) VALUES('UPDATE',NEW.id));
END IF;
END;
CREATE TRIGGER molecules_delete AFTER DELETE ON molecules
FOR EACH ROW INSERT INTO syncs(mod_action,prim_key) VALUES('DELETE', OLD.id);

Here we’ve done. Let’s do something on the “molecules” table and see what happens.

mysql> INSERT INTO molecules(smiles) VALUES("CC=CCN");
mysql> UPDATE molecules SET smiles='CC1CCC1' WHERE id=2;
mysql> DELETE FROM molecules WHERE id=3;

mysql> SELECT * FROM syncs;
+----+------------+----------+
| id | mod_action | prim_key |
+----+------------+----------+
|  6 | DELETE     |        3 |
|  5 | UPDATE     |        2 |
|  4 | INSERT     |        3 |
+----+------------+----------+
3 rows in set (0.00 sec)

The trigger successfully monitored the modifications.

Today, I got something to show you.

Have a look at renderer and editor demo here.

You can click the first two buttons to load a demo structure with different sizes, and you can read a demo molecule. You can move your mouse on atoms, drag the editor on atoms and in white space to see what happened. If you’re using IE, especially IE6, the dragging process may not be so smooth, as IE is famous for its super slow JavaScript engine.

OK, what happened after you clicked the buttons. The buttons for loading editor have a onClick attribute with JavaScript below.
initEditor('editor1',500,300);
And behind this function is:
function initEditor(divID,width, height){
if(window.__initEditor){
document.getElementById(divID).innerHTML="";
__initEditor(divID,width, height);
}else{
document.getElementById(divID).style.width=width+"px";
document.getElementById(divID).style.height=height+"px";
document.getElementById(divID).innerHTML="Loading...";
setTimeout(function(){initEditor(divID,width, height);}, 1000);
}
}

And this in GWT Java code:

private static native void injectJSMethods()/*-{
$wnd.__readMolFile =function(divID,fileContent){
@com.chemhack.jsMolEditor.client.Editor::readMolFile(Ljava/lang/String;Ljava/lang/String;)(divID,fileContent);
};

I think Rich’s problem has been partly solved as this proves how we can cross the boundary between hand-written JavaScript and GWT generated JavaScript. If you’d like to make the whole library exposed to JavaScript world, just write a wrapper for each Java method you’d like to call. GWT code generator may be a good helper.

I call this molecule editor jsMolEditor, and I plan to release its first fully functional Alpha version in two or three weeks. jsMolEditor will be released under GPL license as its code mainly came from MX-GWT and JChemPaint.

So how about JMol in javascript? This demo shows that it’s not a mission impossible, but we have a long way to go.

I promise to release the first Alpha in two or three weeks and also keep you informed how is the work going with at least two posts per week.

As we all know, when we search for similar structures, our judgement of similarity is based on Tanimoto coefficient. If variable ‘a’ stands for the number of all TRUE bits in one fingerprint, ‘b’ stands for another, and ‘c’ stands for the number of TRUE bits they both have, we can define Tanimoto coefficient as c/(a+b-c). If we want to find some fingerprints with a minimum Tanimoto coefficient λ, we are saying c/(a+b-c) > λ. As c is the number of TRUE bits they have in common, c is absolutely not greater than a or b. Then we get b*λ<a<b/λ and a*λ<b<a/λ. 

With this inequality in hand, we don’t need to iterate all the fingerprints to do a similar structure search. If we sort all the fingerprints in their number of all TRUE bits, we can significantly reduce the range of database we need to screen.

 Here is the distribution of fingerprint darkness of my database of 80000 commercial compounds. 

And here is the search time after new search method is applied.

Extremely fast!

As default output of CDK fingerprint, java.util.BitSet with Serializable interface is perfect data format of fingerprint data storage. Java itself provides several collections such as ArrayList, LinkedList, Vector class in package java.util. To provide web access to the search engine, thread unsafe ArrayList and LinkedList have to be kicked out. How about Vector? Once all the fingerprint data is well prepared, the collection  function we need to do similarity search is just iteration. No add, no delete. So, a light weight array is enough.

Most of the molecule information is stored in MySQL database, so we are going to map fingerprint to corresponding row in data table. Here is the MolDFData class, we use a long variable to store corresponding primary key in data table.

public class MolDFData implements Serializable {
    private long id;
    private BitSet fingerprint;

    public MolDFData(long id, BitSet fingerprint) {
        this.id = id;
        this.fingerprint = fingerprint;
    }
    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public BitSet getFingerprint() {
        return fingerprint;
    }

    public void setFingerprint(BitSet fingerprint) {
        this.fingerprint = fingerprint;
    }
}

This is how we storage our fingerprints.

private MolFPData[] arrayData;

No big deal with similarity search. Just calculate the Tanimoto coefficient, if it’s bigger than minimal  similarity you set, add this one into result.

    public List searchTanimoto(BitSet bt, float minSimlarity) {
        List resultList = new LinkedList();
        int i;
        for (i = 0; i < arrayData.length; i++) {
            MolDFData aListData = arrayData[i];
            try {
                float coefficient = Tanimoto.calculate(aListData.getFingerprint(), bt);
                if (coefficient > minSimlarity) {
                    resultList.add(new SearchResultData(aListData.getId(), coefficient));
                }
            } catch (CDKException e) {

            }
            Collections.sort(resultList);
        }
        return resultList;
    }

Pretty ugly code?  Maybe. But it really works, at a acceptable speed. Tests were done using the code blow on a macbook(Intel Core Due 1.83 GHz, 2G RAM).

                long t3 = System.currentTimeMillis();
                List<SearchResultData> listResult = se.searchTanimoto(bs, 0.8f);
                long t4 = System.currentTimeMillis();
                System.out.println("Thread: Search done in " + (t4 - t3) + " ms.");

In my database of 87364 commercial compounds, it takes 335 ms.