Axial chirality isn't the first thing most chemists come up with when they think of indole. Yet a recent J. Org. Chem. article by Kamikawa et al. describes not only axially chiral indoles, but an enantioselective method for their synthesis.

Axial chirality has been largely ignored by the cheminformatics community. There was once a time when the phenomenon was esoteric enough that it could be reasonably ignored. However, that time has long since passed, as the Kamikawa study, and many others demonstrate.

Several years ago, Andreas Dietz proposed a conceptual framework for solving this problem. More recently, it was put into practice in the FlexMol language and the Octet framework. These may not represent the best solutions to the axial chirality problem, but they clearly demonstrate that a practical solution, fully compatible with modern information technologies, does exists.

Axially chiral molecules like those in the Kamikawa study will increasingly find their way into chemical databases as they continue to become more synthetically accessible. When this happens, users will want to be able to distinguish stereoisomers, just as they wanted (and got) this capability for tetrahedral chirality ten to twenty years ago. When the inevitable request to distinguish axially-chiral stereoisomers in your database comes, how will you respond?

-Vivekananda Vrudhula, Bireshwar Dasgupta, Jingfang Qian-Cutrone, Edward Kozlowski, Christopher Boissard, Steven Dworetzky, Dedong Wu, Qi Gao, Roy Kimura, Valentin Gribkoff, and John Starrett, Jr., J. Med. Chem.

Yet another case of axial chirality in the recent literature comes in the form of ion channel openers described by Vrudhula et al. A previous Depth-First article illustrated how most popular cheminformatics tools are incapable of distinguishing axially chiral enantiomers such as those shown above. If your application suddenly needed to do so, could it cope?

FlexMol is an XML language designed to solve the molecular representation problems of today and, hopefully, those of tomorrow. Some of its capabilities have already been introduced:

• planar chirality
• square-planar isomerism
• axially chiral amides
• axially chiral biaryls
• tetrahedral chirality
• alkene geometrical isomerism
• multiatom bonding in metallocenes

Given the two previous articles on axial chirality, it should be clear how to represent the two enantiomers enantiomers of the structure shown above using FlexMol. What is far from clear at this point is how to bring this capability to chemists. For example, no 2-D structure editor I'm aware of can systematically encode axial chirality. Likewise, no 2-D rendering toolkit can draw it. FlexMol and languages like it are important first steps to solving these problems, but they are by no means the last.

Postscript: the two structures depicted above are actually identical! You can prove this to yourself by verifying that the phenol oxygen points into the plane of your screen and the chlorine atom points out of the plane in both structures. Clearly the authors intended for the phenyl ring to be flipped by 180 degrees, but they hand-placed the wedges on the wrong side of the benzene ring. The fact that this error appears in none other than J. Med. Chem. further underscores the need for tools that understand axial chirality.

An XML language is only as useful as the software tools that take advantage of it. Previous articles have discussed how the XML language FlexMol can solve a variety of molecular representation problems ranging from the multiatom bonding of metallocenes to the axial chirality of biaryls. Octet is a framework written in Java that speaks FlexMol natively. In this article, I'll show how Octet can be used to read a sample FlexMol document.

Prerequisites

For this tutorial, you'll need Ruby Java Bridge (RJB). Previous articles have discussed the installation and use of RJB on Windows and Linux.

A Sample Molecule

A recent article disused a FlexMol representation of the chiral natural product monolaterol. Using a slightly modified numbering system for this molecule (shown above), we can construct a complete FlexMol representation. In this case, we simply start numbering at index zero, subtracting one from every index in the previous example to match the zero-based indices used in Octet.

A Demonstration Package

To illustrate the process of reading a FlexMol document, I've prepared a small package (demo-20070131.tar.gz) that can be downloaded from SourceForge. In it, you'll find an Octet jarfile (octet-0.8.2.jar), a FlexMol representation of monolaterol (s_monolaterol.xml), a Ruby library (reader.rb), and some Ruby test code (test.rb). Inflate this archive and make it your working directory.

A Simple Test

The following sequence of commands will run the test included with the demonstration package:

$ export CLASSPATH=./octet-0.8.2.jar
$ ruby test.rb

You should see several lines of output terminated with the line:

The exact mass of monolaterol is 276.115029755.

You can get more hands-on experience with loading and processing the monolaterol FlexMol document using interactive Ruby (irb). For example:

$ irb
irb(main):001:0> require 'reader'
=> true
irb(main):002:0> r=Reader.new
=> #:0x2b9ab1736690>, @handler=#<#:0x2b9ab1736e10>, @builder=#<#:0x2b9ab1736b90>>
irb(main):003:0> mol=r.read_file 's_monolaterol.xml'
=> #<#:0x2b9ab172cd48>
irb(main):004:0> mol.countAtoms
=> 21
irb(main):005:0> mol.countBondingSystems
=> 24

Of course, this is just scratching the surface of what can be done once a FlexMol document has been loaded by Octet.

Conclusions

Octet makes it possible to convert FlexMol documents into Java object representations that can be accessed through Ruby. With an object representation, the possibilities are limitless. Some simple examples have been provided here. Future articles will illustrate more advanced uses.

If applications are hard to design and toolkits are harder, then frameworks are hardest of all. A framework designer gambles that one architecture will work for all applications in the domain. Any substantive change to the framework's design would reduce its benefits considerably, since the framework's main contribution to an application is the architecture it defines. Therefore it's imperative to design the framework to be as flexible and extensible as possible.

-Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides- Design Patterns

One of the most important considerations when building an application is the choice of framework. As the quote from the Gang of Four implies, there's much more to frameworks than just a collection of re-usable code. At their best, frameworks provide a foundation for thinking about a problem domain and a language for communicating with other developers about it. In this article, I'll introduce Octet, an object-oriented framework for molecular representation.

The Molecular Representation Problem

Isn't molecular representation a solved problem? After all, don't SMILES, Molfile, InChI, and CML adequately represent any molecule the average software developer is likely to see?

As previously discussed, molecular representation technologies have stagnated while the molecules chemists themselves now routinely make and use have continued to become more and more "exotic." Developers are now faced with the thorny problem that a variety of common structural motifs in chemistry can't be adequately represented with industry-standard cheminformatics tools.

This point is so important, I'll repeat it: cheminformatics has fallen behind chemistry in the kinds of molecules it can work with. Quick fixes only allow the problem to fester; what's needed is a comprehensive solution. This is Octet's problem domain.

Every framework is bounded by a specific problem domain. Although the size of the domain can vary, a framework provides a comprehensive solution within it. For complex and poorly standardized domains (such as molecular representation), a good framework can greatly accelerate application development.

A good frameworks stays within its problem domain. One of the most important reasons is to prevent featuritis, the root of much software evil. Keeping a framework focused on its core mission makes it much more likely that it can remain documented, tested, extensible, and efficient.

By intention, a variety of features fall outside Octet's problem domain and so will never be directly supported. For example, rendering 2-D structure diagrams is a common problem in cheminformatics that has nothing to do with solving the molecular representation problem. Similarly, reading and writing SMILES strings and Molfiles are supported by many toolkits, but not by Octet directly. After all, it's the inherent limitations of these languages that Octet is trying to overcome.

Higher-level functionality such as legacy language support and 2-D rendering, although not part of Octet itself, can be developed with Octet as a foundation. For example, two Octet add-on frameworks specifically address these problems. They are called Rosetta and Structure, respectively.

About This Series

This article is the first in a series discussing Octet. Future articles will describe in detail Octet's design, implementation, and use. Although Octet has come a long way, it's far from finished. My motivation for writing these articles is to hear what you have to say about Octet, so please feel free to contact me.

Although Octet is written in Java, code examples discussed here will be written in Ruby. I've taken the same approach in discussing the Chemistry Development Kit (CDK) and Structure-CDK. Ruby's brevity and comfortable syntax make it ideal for both writing and discussing code.

Ruby Java Bridge (RJB) is the magic technology that makes this possible. Previous articles have discussed the installation and use of RJB on Windows and Linux.

A Simple Test

Assuming you've installed Ruby, RubyGems and Ruby Java Bridge, you can perform a simple demonstration of Octet in Ruby:

require 'rubygems'
require_gem 'rjb'
require 'rjb'

BasicMoleculeBuilder = Rjb::import('net.sf.octet.builder.BasicMoleculeBuilder')
RepresentationKit = Rjb::import('net.sf.octet.util.RepresentationKit')
MoleculeKit = Rjb::import('net.sf.octet.util.MoleculeKit')
System = Rjb::import('java.lang.System')

builder = BasicMoleculeBuilder.new

RepresentationKit.buildHexane(builder)

molecule = builder.releaseMolecule

MoleculeKit.printMolecule(molecule, System.out)

$ export CLASSPATH=./octet-0.8.2.jar
$ ruby test.rb
**Molecule Properties**

Atom Count: 6, Bonding System Count: 5

Atoms:
atom: C[0] (2nu 0e, 0or, 0.0fc, 1bs, 1n, 4.0val, 3ih )
atom: C[1] (2nu 0e, 0or, 0.0fc, 2bs, 2n, 4.0val, 2ih )
atom: C[2] (2nu 0e, 0or, 0.0fc, 2bs, 2n, 4.0val, 2ih )
atom: C[3] (2nu 0e, 0or, 0.0fc, 2bs, 2n, 4.0val, 2ih )
atom: C[4] (2nu 0e, 0or, 0.0fc, 2bs, 2n, 4.0val, 2ih )
atom: C[5] (2nu 0e, 0or, 0.0fc, 1bs, 1n, 4.0val, 3ih )

No non-natural isotopic distributions specified.

No Orbitals specified.

Bonding Systems:
bonding system:  ( 2be, 0abe, 2a, 1ap ) [ (0, 1) ]
bonding system:  ( 2be, 0abe, 2a, 1ap ) [ (1, 2) ]
bonding system:  ( 2be, 0abe, 2a, 1ap ) [ (2, 3) ]
bonding system:  ( 2be, 0abe, 2a, 1ap ) [ (3, 4) ]
bonding system:  ( 2be, 0abe, 2a, 1ap ) [ (4, 5) ]

Atom Pairs:
atom pair: (0, 1) (1.0 bo)
atom pair: (1, 2) (1.0 bo)
atom pair: (2, 3) (1.0 bo)
atom pair: (3, 4) (1.0 bo)
atom pair: (4, 5) (1.0 bo)

No Atomic Configurations specified.
No Conformation specified.

As you can see, Octet shares the same concepts and vocabulary as FlexMol. We'll drill down into the meaning of the output in later articles. The important thing to remember is that we can print out a report like the one above for any Molecule, no matter how complex.

Conclusions

Octet is an object-oriented framework designed to solve the molecular representation problem and serve as a solid foundation for a variety of cheminformatics applications. Of course, there's much more to Octet than the simple example shown here. Future articles will describe in greater detail the design and use of Octet through illustrative examples.

Models of structure and bonding play a critical role in guiding chemical research. These models also define the scope and limitations of any cheminformatics system. Within the last several years, the gap between the structure and bonding models used by chemical information systems and by the chemists who use them has been widening. On this front, chemistry is moving much faster than cheminformatics. Sooner or later the difference must be reconciled.

A Looming Problem

Models of structure and bonding in cheminformatics, although adequate for organic chemistry in the 1970s, are outdated today. As recently discussed, some of the most interesting molecules in organic chemistry can't be adequately represented by 99% of the available cheminformatics tools. This may not be a problem if your clients never work with these molecules (but they probably are already). It may not be a problem if your system never interacts with the outside world where these molecules are prevalent (but it will eventually). A quick fix is likely to produce even bigger problems down the road. What's needed is a comprehensive solution.

FlexMol is a molecular language designed to solve this problem. For example, recent articles have demonstrated how FlexMol is capable of representing some of today's most difficult structural motifs: metallocenes; biaryl axial chirality; non-biaryl axial chirality; planar chirality; and non-tetrahedral stereochemical configuration.

Although FlexMol handles these tough cases, it's not merely a specialty language for "weird" molecules. Rather, FlexMol provides a basic set of elements and principles that can be applied to any molecule, regardless of its peculiarities or lack thereof. For example, FlexMol defines a clean system for the representation for alkene geometry. This basic level of functionality is not even provided by the industry-standard Molfile format, which requires 2-D atom coordinates.

In this demonstration, we'll turn our attention to one of the most basic problems in cheminformatics - the representation of tetrahedral chirality. Using an example molecule from the recent literature, we'll see how the principles outlined in previous FlexMol examples also apply to stereogenic carbons.

Conformation or Configuration?

We need to answer a basic question before we can represent tetrahedral chirality: should we use configuration or conformation? Following the simple principle that isomers interconvertible by bond rotation are conformational isomers and all others are configurational isomers, it's clear that we'll be using configuration. More rigorous definitions are offered by Dietz.

An Example

A recent paper describes the isolation of the plant natural product Monolaterol and the assignment of its absolute configuration. Using the structure and atom numbering system shown above, we can construct a complete FlexMol representation of Monolaterol. Rather than reproduce it here, let's just consider the stereochemically-relevant part:

<!-- snip -->
<configuration>
  <configurationWheel>
    <atomPair source="15" target="16"></atomPair>
    <halfPlane>
      <lower atom="14"></lower>
    </halfPlane>
    <halfPlane></halfPlane>
    <halfPlane></halfPlane>
    <halfPlane>
      <lower atom="12"></lower>
    </halfPlane>
  </configurationWheel>
  <configurationWheel>
    <atomPair source="15" target="12"></atomPair>
    <halfPlane>
      <lower atom="16"></lower>
    </halfPlane>
    <halfPlane></halfPlane>
    <halfPlane></halfPlane>
    <halfPlane>
      <lower atom="14"></lower>
    </halfPlane>
  </configurationWheel>
  <configurationWheel>
    <atomPair source="15" target="14"></atomPair>
    <halfPlane>
      <lower atom="12"></lower>
    </halfPlane>
    <halfPlane></halfPlane>
    <halfPlane></halfPlane>
    <halfPlane>
      <lower atom="16"></lower>
    </halfPlane>
  </configurationWheel>
</configuration>
<!-- snip -->

Notice that three configurationWheels are defined. As in the case of representing the configuration of square-planar species, each substituent of the chiral center is in turn placed along a wheel's axis, giving three wheels in total for Monolaterol. The relationships among atoms, planes, and axes is represented in the following cartoon:

Notice also that there are two empty half-planes in each conformationWheel. Half-planes occur in pairs spaced 180 degrees apart. Given that there are two neighboring atoms to place into half-planes, two half-planes will be empty. We nevertheless must include them as placeholders. Notice that virtual hydrogens (those hydrogens not explicitly defined as part of the atoms element) are not placed into half-planes.

It should be clear that the FlexMol representation of Monolaterol's (R)-enantiomer is distinguishable by visual inspection or by software. Each configurationWheel would be enantiomeric. As a result, the ordering of half-planes about their respective axes would be inverted.

So What?

Most cheminformatics tools can represent tetrahedral chirality. In nearly every case, this is accomplished with stereodescriptors, atom parities, or chiral flags. Extending these systems to non-tetrahedral chirality requires more templates - a difficult, if not impossible, task in most cases. Worse still, such systems are often based on poorly-documented conventions, resulting in a great deal of confusion when writing software implementations.

FlexMol takes a completely different approach by actually describing the chiral environment around an atom in terms of a simple system of axes and planes. The rules governing these elements are applied regardless of the kind of chirality being represented. This results in a system that works consistently for known forms of chirality, and which can be extended as new forms of chirality are encountered.

A Software Implementation

Any new molecular language requires a software implementation. For FlexMol, that implementation is provided by the Octet Framework. Octet is open source software written in Java that provides a FlexMol reader, a FlexMol writer, and many tools for working with molecular representations.

Conclusions

Although not often discussed, models of bonding and structure figure prominently in the ability of cheminformatics software to solve relevant problems. This is especially true in the increasingly important area of molecular chirality. In this area, FlexMol offers a system with unprecedented flexibility; it works just as well with stereogenic carbon as with numerous, less common forms of chirality.