**What is it?**

*et al*: [1], [3] or in this blog post by me.

The java implementation of this algorithm is a collaboration between Lars Carlsson (who wrote a C++ version) and me (who ported this version to java). However, I was also influenced by my previous attempt at a port from the c implementation by Faulon's group. There is an online service for using their program called "sscan" here. It also deals with stereochemistry.

**What is it used for?**

So, what can be done with all this new code? Here are some possibilities:

- Smiles-like canonical strings that represent molecules. Note that signatures are considerably longer than smiles, but are guaranteed to work for cuneane, and indeed a broad range of graphs.
- As with HOSE-codes (which can describe molecule connectivity up to different 'spheres') signatures can vary in height. Practically, this means an atom's environment can be described with different levels of detail.
- Due to the canonisation of the structure, the core algorithm can be used to give a canonical labelling of the structure, which can be useful for atom-atom mapping of isomorphic structures.
- Calculating signatures for all atoms of a molecule produces a partition of the atoms into sets of equivalent positions. This is useful for a variety of analyses of a molecule's graph structure.

**How do you use it?**

The

`MoleculeSignature`class is a wrapper around an instance of an`IMolecule`and provides several useful methods, many of them from the base class`AbstractGraphSignature`. For example:IMolecule thiazole = MoleculeFactory.makeThiazole();

MoleculeSignature moleculeSignature = new MoleculeSignature(thiazole);

System.out.println(moleculeSignature.toCanonicalString());

// Result = "[C](=[C]([N](=[C,0]))[S]([C,0]))"

This is the canonical signature for the whole molecule. To get this, canonical signatures are made for each atom, and the canonical one from the list is returned. To get all the signatures - rather, the equivalance classes (or 'orbits') - use the

`calculateOrbits`method like this:

which gives this output (the 'makeQuinone' method makes 1,4-benzoquinone:

MoleculeSignature moleculeSignature = new MoleculeSignature(MoleculeFactory.makeQuinone());

for (Orbit orbit : moleculeSignature.calculateOrbits()) {

System.out.println(orbit);

}

which tells us that the two oxygen atoms ([0, 7]) are in the same orbit, as are the carbons attached to them, and that the other four are in another orbit. I have written about more complex examples of orbits : in C60 or in other fullerenes or in some other regular graphs. In practice, most chemicals will have automorphism partitions that are (nearly) discrete.

[O](=[C]([C](=[C]([C,0](=[O])))[C](=[C]([C,0])))) [0, 7]

[C]([C](=[C]([C,0](=[O])))[C](=[C]([C,0]))=[O]) [1, 4]

[C](=[C]([C]([C,0]=[O]))[C]([C](=[C,0])=[O])) [2, 3, 5, 6]

So, finally, an example of how to get the canonical labelling of a graph:

MoleculeSignature moleculeSignature =which gives "[0, 3, 2, 1]" - essentially this is the permutation which gives a canonical arrangement of atoms.

new MoleculeSignature(MoleculeFactory.makeCyclobutadiene());

System.out.println(Arrays.toString(moleculeSignature.getCanonicalLabels()));

**Non-CDK implementations?**

There are other chemistry projects other than the CDK, and it should be fairly easy to make a mychemlib.MoleculeSignature by subclassing signature.AbstractGraphSignature (and similarly for AtomSignature/AbstractVertexSignature). All the concrete classes need do is tell its superclass about the underlying molecule graph - getVertexCount, getConnected - and the MoleculeSignature has to act as a factory for the concrete AtomSignature instances via getSignatureForVertex.

The signature project is on github and has some of the maven machinery for building/testing/packaging. There are a couple of 'toy' implementations for chemicals and simple (mathematical) graphs.

Any feedback, suggestions, and so on are welcome. I am also happy to help with other people's implementations in the form of code or just hints. Enjoy!

## Comments