Open Babel

Problem​: In computational chemistry, molecules can be represented in various formats, each encoding different levels of information. A fundamental distinction exists between one-dimensional (1D) representations, such as SMILES strings, which encode only the molecular topology (atoms and connectivity), and three-dimensional (3D) formats, like SDF, which also include the spatial coordinates of each atom.

The Open Babel library uses a generic container, the OBMol object, to represent molecules internally, regardless of the input file format. Understanding how OBMol handles data from different sources is crucial for tasks involving 3D structure generation and conformer searching.

Your task is to write a Python script using the Open Babel library to investigate this difference. You will be provided with two test cases:

1. A molecule defined by a 1D SMILES string.
2. A molecule defined by a string in the 3D SDF format, containing explicit atomic coordinates.

For each case, your script must:

1. Create an OBMol object and populate it with the molecular data from the provided string.
2. Inspect the resulting OBMol object to determine whether it contains valid 3D atomic coordinates. Open Babel provides a specific method, Has3D(), for this purpose.

Test Cases

Case 1: 1D SMILES String The SMILES string for ethanol is:

Case 2: 3D SDF String The SDF string for ethanol with 3D coordinates is:

Output Format

Your program may output any necessary information to stdout/stderr for debugging purposes, but the last line of stdout must be the result, containing a comma-separated list of boolean values enclosed in square brackets. The first boolean corresponds to Case 1 (SMILES), and the second to Case 2 (SDF). A value of True indicates the presence of 3D coordinates, and False indicates their absence. For example: [False, True].

Problem​: The ability to interconvert between different chemical file formats and line notations is a fundamental skill in cheminformatics. Open Babel is a powerful library designed for this purpose. In this problem, you will use the Open Babel Python bindings to perform a direct, in-memory conversion of chemical identifiers.

Your task is to write a Python program that takes a list of International Chemical Identifier (InChI) strings and converts each one into its corresponding canonical Simplified Molecular Input Line Entry System (SMILES) string. This conversion must be performed entirely in memory, without creating any intermediate files on disk.

The core of your solution should rely on the openbabel.OBConversion class. You need to configure an instance of this class to read input in the 'inchi' format and write output in the 'smi' (SMILES) format. A critical requirement is that the generated SMILES strings must be canonical​. Open Babel's SMILES writer provides an option to ensure canonical output, which you must utilize.

Your program should process the provided test suite of InChI strings and collect the resulting canonical SMILES strings into a list.

Test Suite

The following InChI strings represent different molecules and should be used as test cases:

1. Ethanol​: InChI=1S/C2H6O/c1-2-3/h3H,2H2,1H3
2. Aspirin​: InChI=1S/C9H8O4/c1-6(10)13-8-5-3-2-4-7(8)9(11)12/h2-5H,1H3,(H,11,12)
3. L-Alanine (with stereochemistry): InChI=1S/C3H7NO2/c1-2(4)3(5)6/h2H,4H2,1H3,(H,5,6)/t2-/m0/s1

Output Format

Your program must output a single line to stdout representing the list of generated canonical SMILES strings. The format should be a standard Python list of strings. For example: ['SMILES_string_1', 'SMILES_string_2', 'SMILES_string_3'].

Problem​: In cheminformatics, substructure searching is a powerful technique for finding molecules that contain a specific chemical pattern. The SMARTS (SMILES Arbitrary Target Specification) language is a widely used standard for defining these patterns. A fundamental aspect of SMARTS is the distinction between aliphatic and aromatic atoms, which is indicated by the case of the atomic symbol.

Your task is to use the Open Babel library to demonstrate this distinction by performing substructure searches on a benzene ring.

The target molecule is benzene​, which can be represented by the SMILES string c1ccccc1. In this representation, the lowercase 'c' indicates that the carbon atoms are part of an aromatic system.

You need to construct two different SMARTS patterns:

1. A pattern that specifically matches a single aromatic carbon atom.
2. A pattern that specifically matches a single aliphatic carbon atom.

Write a Python program using the Open Babel library that performs the following steps:

1. Creates an Open Babel molecule object representing benzene from its SMILES string.
2. Defines the two SMARTS patterns described above.
3. Performs a substructure search on the benzene molecule for the aromatic carbon pattern and counts the total number of matches.
4. Performs a substructure search on the benzene molecule for the aliphatic carbon pattern and counts the total number of matches.

Your program must output a single line to stdout containing a Python list with two integers: the count of matches for the aromatic pattern, followed by the count of matches for the aliphatic pattern.

For example, the output should be in the format: [num_aromatic_matches, num_aliphatic_matches].

Problem​: In cheminformatics, assessing the structural similarity between molecules is a fundamental task, often used in virtual screening to find novel compounds with similar properties to known active ligands. A common approach is to represent molecules as numerical fingerprints and then calculate a similarity metric between these fingerprints.

Molecular fingerprints are binary vectors (sequences of 0s and 1s) where each bit represents the presence or absence of a specific structural feature or substructure. Open Babel, a powerful chemical toolbox, provides several types of fingerprints, including FP2​, which is a path-based fingerprint that indexes linear fragments of the molecule up to a certain length.

To quantify the similarity between two binary fingerprints, the Tanimoto coefficient (also known as the Jaccard index) is widely used. For two fingerprints $A$ and $B$, the Tanimoto similarity $T(A, B)$ is defined as:

$T(A, B) = \frac{N_{A \cap B}}{N_A + N_B - N_{A \cap B}}$

Where:

• $N_A$ is the count of bits set to 1 in fingerprint $A$.
• $N_B$ is the count of bits set to 1 in fingerprint $B$.
• $N_{A \cap B}$ is the count of bits set to 1 in both fingerprints $A$ and $B$ (the intersection).

The Tanimoto coefficient ranges from 0.0 (no bits in common) to 1.0 (all bits are identical).

Your task is to create a Python script that uses the Open Babel library to calculate the Tanimoto similarity between pairs of molecules.

Requirements:

1. The script must use the Open Babel library's Python bindings (e.g., the pybel module) to handle molecular data.
2. It must define a procedure to accept two molecules specified by their SMILES strings.
3. For each molecule, generate its FP2 fingerprint.
4. Calculate the Tanimoto similarity coefficient between the two generated fingerprints. You should use the efficient, built-in methods provided by Open Babel's fingerprint objects for this calculation, which implements the formula described above.
5. The script must process the following test suite of molecule pairs:
   • Pair 1 (Identical): Benzene (c1ccccc1) and Benzene (c1ccccc1)
   • Pair 2 (Similar): Ethanol (CCO) and Propanol (CCCO)
   • Pair 3 (Similar): Acetic acid (CC(=O)O) and Acetamide (CC(=O)N)
   • Pair 4 (Dissimilar): Water (O) and Cholesterol (C[C@H]1CCCC[C@@]12CC[C@H]3[C@H]([C@@H]2CC=C4C3=CC[C@H](C4)O)C)
6. The final output must be a single line to stdout, containing a list of the calculated Tanimoto coefficients for each pair in the order they are listed. Each coefficient must be rounded to 4 decimal places​. The format must be [val1, val2, val3, val4].