GetMorganFingerprint() Method in RDKit

Cheminformatics Tutorials - Herong's Tutorial Examples

∟GetMorganFingerprint() Method in RDKit

This section provides a quick introduction on the rdkit.Chem.rdMolDescriptors.GetMorganFingerprint() Method in the RDKit library.

GetMorganFingerprint(mol, radius) method is located in the rdkit.Chem.rdMolDescriptors module of the RDKit library. The same method is also packaged as rdkit.Chem.AllChem.GetMorganFingerprint() for easier access. It returns a collection of integer identifiers of atom node invariants updated with local structures at different radiuses.

Here is the definition of the method:

rdkit.Chem.rdMolDescriptors.GetMorganFingerprint((Mol)mol, 
  (int)radius[, 
  (AtomPairsParameters)invariants=[][, 
  (AtomPairsParameters)fromAtoms=[][, 
  (bool)useChirality=False[, 
  (bool)useBondTypes=True[, 
  (bool)useFeatures=False[, 
  (bool)useCounts=True[, 
  (AtomPairsParameters)bitInfo=None[, 
  (bool)includeRedundantEnvironments=False]]]]]]]]) 
-> UIntSparseIntVect

Descriptions of method arguments are:

mol: the molecule to use.
radius: the bond radius of the local substructure.
invariants (optional): a list of initial identifiers for each atom node in the molecule. This will override identifiers hashed from those predefined invariants on each atom node. Basically, you are providing the Morgan fingerprint for radius=0.
fromAtoms (optional): a sequence of atom node indices. If provided, only those atom nodes are encoded.
useChirality (optional): if set, node chirality will be encoded.
useBondTypes (optional): if set, bond types will be considered when updating identifiers with neighboring atom nodes.
useFeatures (optional): if set, feature invariants will be used instead of atom node invariants. This flags the generator to return FCFP fingerprints instead of ECFP fingerprints.
useCounts (optional): if set, counts of identifier duplications are included in the fingerprint.
bitInfo (optional): an empty dict. If provided, the result will contain a dict with identifiers as keys and corresponding atom with radius as values.
includeRedundantEnvironments (optional):

By default, GetMorganFingerprint() uses the "useFeatures=False" option to provide an implementation of the ECFP (Extended Connectivity Fingerprint) method as described in the "ECFP (Extended Connectivity Fingerprint) Method - 2000" section in this book.

Note that GetMorganFingerprint() returns a collection of identifiers of all atom nodes generated at different radiuses as the fingerprint of a given molecule.

If you want the fingerprint to be returned as a bit string, you can call the GetMorganFingerprintAsBitVect() method, as described in the "GetMorganFingerprintAsBitVect() Method in RDKit" section in this chapter.

Now let's verify its ECFP implementation with some simple tests.

1. Molecule "C" has a single non-hydrogen atom. So a single identifier will be generated at radius=0.

from rdkit.Chem import AllChem
from rdkit.DataStructs.cDataStructs import UIntSparseIntVect
radius = 0
bitInfo = {}
mol = AllChem.MolFromSmiles('C')
fp = AllChem.GetMorganFingerprint(mol, radius, bitInfo=bitInfo)
display(UIntSparseIntVect.GetLength(fp))
display(UIntSparseIntVect.GetNonzeroElements(fp))
display(UIntSparseIntVect.GetTotalVal(fp))
print(bitInfo)

# output: 
4294967295
{2246733040: 1}
1
{2246733040: ((0, 0),)}

Notes on this test:

"radius = 0" is used to generate identifiers for atom invariants only without any updates on local structures.
Output "GetLength(fp))=4294967295" indicates that the size of the sparse vector that contains final identifiers.
"GetNonzeroElements(fp))={2246733040: 1} indicates that the final identifier for the only atom C is 2246733040.
Output "bitInfo={2246733040: ((0, 0),)}" indicates that the only identifier is set by atom 0 with 0 radius.

2. Molecule with a 2 identical atoms: "CC", expressed in SMILES.

radius = 0
bitInfo = {}
mol = AllChem.MolFromSmiles('CC')
fp = AllChem.GetMorganFingerprint(mol, radius, bitInfo=bitInfo)
display(UIntSparseIntVect.GetLength(fp))
display(UIntSparseIntVect.GetNonzeroElements(fp))
display(UIntSparseIntVect.GetTotalVal(fp))
print(bitInfo)

# output:
4294967295
{2246728737: 2}
2
{2246728737: ((0, 0), (1, 0))}

The output shows 2 identical identifiers: one for atom 0 with radius 0, and one for atom 1 with radius 0.

3. Molecule with a 2 different atoms: "CO".

radius = 0
bitInfo = {}
mol = AllChem.MolFromSmiles('CO')
fp = AllChem.GetMorganFingerprint(mol, radius, bitInfo=bitInfo)
display(UIntSparseIntVect.GetLength(fp))
display(UIntSparseIntVect.GetNonzeroElements(fp))
display(UIntSparseIntVect.GetTotalVal(fp))
print(bitInfo)

# output:
4294967295
{864662311: 1, 2246728737: 1}
2
{864662311: ((1, 0),), 2246728737: ((0, 0),)}

Now we have 2 different identifiers: the first one is for atom 1 with radius 0, and the second one is for atom 0 with radius 0.

As you can see, the atom C of "CO" molecule in this test and atom C of "CC" molecule in the previous test has the same identifier: 2246728737. It tells us that "2246728737" identifies atom C with a single bond connected in any molecule.