rdkit.Chem.rdMolDescriptors module

rdkit.Chem.rdMolDescriptors module

Module containing functions to compute molecular descriptors

class rdkit.Chem.rdMolDescriptors.AtomPairsParameters((object)arg1) → None :

Bases: Boost.Python.instance

C++ signature :

void __init__(_object*)

atomTypes = <rdkit.rdBase._vectj object>

codeSize = 9

numAtomPairFingerprintBits = 23

numBranchBits = 3

numChiralBits = 2

numPathBits = 5

numPiBits = 2

numTypeBits = 4

version = '1.1.0'

rdkit.Chem.rdMolDescriptors.CalcAUTOCORR2D((Mol)mol[, (str)CustomAtomProperty='']) → list :

Returns 2D Autocorrelation descriptors vector

C++ signature :

boost::python::list CalcAUTOCORR2D(RDKit::ROMol [,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >=’‘])

rdkit.Chem.rdMolDescriptors.CalcAUTOCORR3D((Mol)mol[, (int)confId=-1[, (str)CustomAtomProperty='']]) → list :

Returns 3D Autocorrelation descriptors vector

C++ signature :

boost::python::list CalcAUTOCORR3D(RDKit::ROMol [,int=-1 [,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >=’‘]])

rdkit.Chem.rdMolDescriptors.CalcAsphericity((Mol)mol[, (int)confId=-1[, (bool)useAtomicMasses=True[, (bool)force=True]]]) → float :

C++ signature :

double CalcAsphericity(RDKit::ROMol [,int=-1 [,bool=True [,bool=True]]])

rdkit.Chem.rdMolDescriptors.CalcChi0n((Mol)mol[, (bool)force=False]) → float :

C++ signature :

double CalcChi0n(RDKit::ROMol [,bool=False])

rdkit.Chem.rdMolDescriptors.CalcChi0v((Mol)mol[, (bool)force=False]) → float :

C++ signature :

double CalcChi0v(RDKit::ROMol [,bool=False])

rdkit.Chem.rdMolDescriptors.CalcChi1n((Mol)mol[, (bool)force=False]) → float :

C++ signature :

double CalcChi1n(RDKit::ROMol [,bool=False])

rdkit.Chem.rdMolDescriptors.CalcChi1v((Mol)mol[, (bool)force=False]) → float :

C++ signature :

double CalcChi1v(RDKit::ROMol [,bool=False])

rdkit.Chem.rdMolDescriptors.CalcChi2n((Mol)mol[, (bool)force=False]) → float :

C++ signature :

double CalcChi2n(RDKit::ROMol [,bool=False])

rdkit.Chem.rdMolDescriptors.CalcChi2v((Mol)mol[, (bool)force=False]) → float :

C++ signature :

double CalcChi2v(RDKit::ROMol [,bool=False])

rdkit.Chem.rdMolDescriptors.CalcChi3n((Mol)mol[, (bool)force=False]) → float :

C++ signature :

double CalcChi3n(RDKit::ROMol [,bool=False])

rdkit.Chem.rdMolDescriptors.CalcChi3v((Mol)mol[, (bool)force=False]) → float :

C++ signature :

double CalcChi3v(RDKit::ROMol [,bool=False])

rdkit.Chem.rdMolDescriptors.CalcChi4n((Mol)mol[, (bool)force=False]) → float :

C++ signature :

double CalcChi4n(RDKit::ROMol [,bool=False])

rdkit.Chem.rdMolDescriptors.CalcChi4v((Mol)mol[, (bool)force=False]) → float :

C++ signature :

double CalcChi4v(RDKit::ROMol [,bool=False])

rdkit.Chem.rdMolDescriptors.CalcChiNn((Mol)mol, (int)n[, (bool)force=False]) → float :

C++ signature :

double CalcChiNn(RDKit::ROMol,unsigned int [,bool=False])

rdkit.Chem.rdMolDescriptors.CalcChiNv((Mol)mol, (int)n[, (bool)force=False]) → float :

C++ signature :

double CalcChiNv(RDKit::ROMol,unsigned int [,bool=False])

rdkit.Chem.rdMolDescriptors.CalcCrippenDescriptors((Mol)mol[, (bool)includeHs=True[, (bool)force=False]]) → tuple :

returns a 2-tuple with the Wildman-Crippen logp,mr values

C++ signature :

boost::python::tuple CalcCrippenDescriptors(RDKit::ROMol [,bool=True [,bool=False]])

rdkit.Chem.rdMolDescriptors.CalcEEMcharges((Mol)mol[, (int)confId=-1]) → list :

Returns EEM atomic partial charges

C++ signature :

boost::python::list CalcEEMcharges(RDKit::ROMol {lvalue} [,int=-1])

rdkit.Chem.rdMolDescriptors.CalcEccentricity((Mol)mol[, (int)confId=-1[, (bool)useAtomicMasses=True[, (bool)force=True]]]) → float :

C++ signature :

double CalcEccentricity(RDKit::ROMol [,int=-1 [,bool=True [,bool=True]]])

rdkit.Chem.rdMolDescriptors.CalcExactMolWt((Mol)mol[, (bool)onlyHeavy=False]) → float :

returns the molecule’s exact molecular weight

C++ signature :

double CalcExactMolWt(RDKit::ROMol [,bool=False])

rdkit.Chem.rdMolDescriptors.CalcFractionCSP3((Mol)mol) → float :

returns the fraction of C atoms that are SP3 hybridized

C++ signature :

double CalcFractionCSP3(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcGETAWAY((Mol)mol[, (int)confId=-1[, (float)precision=2[, (str)CustomAtomProperty='']]]) → list :

Returns the GETAWAY descriptors vector

C++ signature :

boost::python::list CalcGETAWAY(RDKit::ROMol [,int=-1 [,double=2 [,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >=’‘]]])

rdkit.Chem.rdMolDescriptors.CalcHallKierAlpha((Mol)mol[, (AtomPairsParameters)atomContribs=None]) → float :

C++ signature :

double CalcHallKierAlpha(RDKit::ROMol [,boost::python::api::object=None])

rdkit.Chem.rdMolDescriptors.CalcInertialShapeFactor((Mol)mol[, (int)confId=-1[, (bool)useAtomicMasses=True[, (bool)force=True]]]) → float :

C++ signature :

double CalcInertialShapeFactor(RDKit::ROMol [,int=-1 [,bool=True [,bool=True]]])

rdkit.Chem.rdMolDescriptors.CalcKappa1((Mol)mol) → float :

C++ signature :

double CalcKappa1(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcKappa2((Mol)mol) → float :

C++ signature :

double CalcKappa2(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcKappa3((Mol)mol) → float :

C++ signature :

double CalcKappa3(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcLabuteASA((Mol)mol[, (bool)includeHs=True[, (bool)force=False]]) → float :

returns the Labute ASA value for a molecule

C++ signature :

double CalcLabuteASA(RDKit::ROMol [,bool=True [,bool=False]])

rdkit.Chem.rdMolDescriptors.CalcMORSE((Mol)mol[, (int)confId=-1[, (str)CustomAtomProperty='']]) → list :

Returns Molecule Representation of Structures based on Electron diffraction descriptors

C++ signature :

boost::python::list CalcMORSE(RDKit::ROMol [,int=-1 [,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >=’‘]])

rdkit.Chem.rdMolDescriptors.CalcMolFormula((Mol)mol[, (bool)separateIsotopes=False[, (bool)abbreviateHIsotopes=True]]) → str :

returns the molecule’s formula

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > CalcMolFormula(RDKit::ROMol [,bool=False [,bool=True]])

rdkit.Chem.rdMolDescriptors.CalcNPR1((Mol)mol[, (int)confId=-1[, (bool)useAtomicMasses=True[, (bool)force=True]]]) → float :

C++ signature :

double CalcNPR1(RDKit::ROMol [,int=-1 [,bool=True [,bool=True]]])

rdkit.Chem.rdMolDescriptors.CalcNPR2((Mol)mol[, (int)confId=-1[, (bool)useAtomicMasses=True[, (bool)force=True]]]) → float :

C++ signature :

double CalcNPR2(RDKit::ROMol [,int=-1 [,bool=True [,bool=True]]])

rdkit.Chem.rdMolDescriptors.CalcNumAliphaticCarbocycles((Mol)mol) → int :

returns the number of aliphatic (containing at least one non-aromatic bond) carbocycles for a molecule

C++ signature :

unsigned int CalcNumAliphaticCarbocycles(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcNumAliphaticHeterocycles((Mol)mol) → int :

returns the number of aliphatic (containing at least one non-aromatic bond) heterocycles for a molecule

C++ signature :

unsigned int CalcNumAliphaticHeterocycles(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcNumAliphaticRings((Mol)mol) → int :

returns the number of aliphatic (containing at least one non-aromatic bond) rings for a molecule

C++ signature :

unsigned int CalcNumAliphaticRings(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcNumAmideBonds((Mol)mol) → int :

returns the number of amide bonds in a molecule

C++ signature :

unsigned int CalcNumAmideBonds(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcNumAromaticCarbocycles((Mol)mol) → int :

returns the number of aromatic carbocycles for a molecule

C++ signature :

unsigned int CalcNumAromaticCarbocycles(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcNumAromaticHeterocycles((Mol)mol) → int :

returns the number of aromatic heterocycles for a molecule

C++ signature :

unsigned int CalcNumAromaticHeterocycles(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcNumAromaticRings((Mol)mol) → int :

returns the number of aromatic rings for a molecule

C++ signature :

unsigned int CalcNumAromaticRings(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcNumAtomStereoCenters((Mol)mol) → int :

Returns the total number of atomic stereocenters (specified and unspecified)

C++ signature :

unsigned int CalcNumAtomStereoCenters(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcNumBridgeheadAtoms((Mol)mol[, (AtomPairsParameters)atoms=None]) → int :

Returns the number of bridgehead atoms (atoms shared between rings that share at least two bonds)

C++ signature :

unsigned int CalcNumBridgeheadAtoms(RDKit::ROMol [,boost::python::api::object=None])

rdkit.Chem.rdMolDescriptors.CalcNumHBA((Mol)mol) → int :

returns the number of H-bond acceptors for a molecule

C++ signature :

unsigned int CalcNumHBA(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcNumHBD((Mol)mol) → int :

returns the number of H-bond donors for a molecule

C++ signature :

unsigned int CalcNumHBD(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcNumHeteroatoms((Mol)mol) → int :

returns the number of heteroatoms for a molecule

C++ signature :

unsigned int CalcNumHeteroatoms(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcNumHeterocycles((Mol)mol) → int :

returns the number of heterocycles for a molecule

C++ signature :

unsigned int CalcNumHeterocycles(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcNumLipinskiHBA((Mol)mol) → int :

returns the number of Lipinski H-bond acceptors for a molecule

C++ signature :

unsigned int CalcNumLipinskiHBA(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcNumLipinskiHBD((Mol)mol) → int :

returns the number of Lipinski H-bond donors for a molecule

C++ signature :

unsigned int CalcNumLipinskiHBD(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcNumRings((Mol)mol) → int :

returns the number of rings for a molecule

C++ signature :

unsigned int CalcNumRings(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcNumRotatableBonds((Mol)mol, (bool)strict) → int :

returns the number of rotatable bonds for a molecule.

strict = NumRotatableBondsOptions.NonStrict - Simple rotatable bond definition. strict = NumRotatableBondsOptions.Strict - (default) does not count things like

amide or ester bonds

strict = NumRotatableBondsOptions.StrictLinkages - handles linkages between ring

systems. - Single bonds between aliphatic ring Cs are always rotatable. This

means that the central bond in CC1CCCC(C)C1-C1C(C)CCCC1C is now considered rotatable; it was not before

• Heteroatoms in the linked rings no longer affect whether or not the linking bond is rotatable

• the linking bond in systems like Cc1cccc(C)c1-c1c(C)cccc1 is now

  considered non-rotatable

C++ signature :

unsigned int CalcNumRotatableBonds(RDKit::ROMol,bool)

CalcNumRotatableBonds( (Mol)mol [, (NumRotatableBondsOptions)strict=rdkit.Chem.rdMolDescriptors.NumRotatableBondsOptions.Default]) -> int :

returns the number of rotatable bonds for a molecule.

strict = NumRotatableBondsOptions.NonStrict - Simple rotatable bond definition. strict = NumRotatableBondsOptions.Strict - (default) does not count things like

amide or ester bonds

strict = NumRotatableBondsOptions.StrictLinkages - handles linkages between ring

systems. - Single bonds between aliphatic ring Cs are always rotatable. This

means that the central bond in CC1CCCC(C)C1-C1C(C)CCCC1C is now considered rotatable; it was not before

• Heteroatoms in the linked rings no longer affect whether or not the linking bond is rotatable

• the linking bond in systems like Cc1cccc(C)c1-c1c(C)cccc1 is now

  considered non-rotatable

C++ signature :

unsigned int CalcNumRotatableBonds(RDKit::ROMol [,RDKit::Descriptors::NumRotatableBondsOptions=rdkit.Chem.rdMolDescriptors.NumRotatableBondsOptions.Default])

rdkit.Chem.rdMolDescriptors.CalcNumSaturatedCarbocycles((Mol)mol) → int :

returns the number of saturated carbocycles for a molecule

C++ signature :

unsigned int CalcNumSaturatedCarbocycles(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcNumSaturatedHeterocycles((Mol)mol) → int :

returns the number of saturated heterocycles for a molecule

C++ signature :

unsigned int CalcNumSaturatedHeterocycles(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcNumSaturatedRings((Mol)mol) → int :

returns the number of saturated rings for a molecule

C++ signature :

unsigned int CalcNumSaturatedRings(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcNumSpiroAtoms((Mol)mol[, (AtomPairsParameters)atoms=None]) → int :

Returns the number of spiro atoms (atoms shared between rings that share exactly one atom)

C++ signature :

unsigned int CalcNumSpiroAtoms(RDKit::ROMol [,boost::python::api::object=None])

rdkit.Chem.rdMolDescriptors.CalcNumUnspecifiedAtomStereoCenters((Mol)mol) → int :

Returns the number of unspecified atomic stereocenters

C++ signature :

unsigned int CalcNumUnspecifiedAtomStereoCenters(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcPBF((Mol)mol[, (int)confId=-1]) → float :

Returns the PBF (plane of best fit) descriptor (https://doi.org/10.1021/ci300293f)

C++ signature :

double CalcPBF(RDKit::ROMol [,int=-1])

rdkit.Chem.rdMolDescriptors.CalcPMI1((Mol)mol[, (int)confId=-1[, (bool)useAtomicMasses=True[, (bool)force=True]]]) → float :

C++ signature :

double CalcPMI1(RDKit::ROMol [,int=-1 [,bool=True [,bool=True]]])

rdkit.Chem.rdMolDescriptors.CalcPMI2((Mol)mol[, (int)confId=-1[, (bool)useAtomicMasses=True[, (bool)force=True]]]) → float :

C++ signature :

double CalcPMI2(RDKit::ROMol [,int=-1 [,bool=True [,bool=True]]])

rdkit.Chem.rdMolDescriptors.CalcPMI3((Mol)mol[, (int)confId=-1[, (bool)useAtomicMasses=True[, (bool)force=True]]]) → float :

C++ signature :

double CalcPMI3(RDKit::ROMol [,int=-1 [,bool=True [,bool=True]]])

rdkit.Chem.rdMolDescriptors.CalcRDF((Mol)mol[, (int)confId=-1[, (str)CustomAtomProperty='']]) → list :

Returns radial distribution fonction descriptors (RDF)

C++ signature :

boost::python::list CalcRDF(RDKit::ROMol [,int=-1 [,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >=’‘]])

rdkit.Chem.rdMolDescriptors.CalcRadiusOfGyration((Mol)mol[, (int)confId=-1[, (bool)useAtomicMasses=True[, (bool)force=True]]]) → float :

C++ signature :

double CalcRadiusOfGyration(RDKit::ROMol [,int=-1 [,bool=True [,bool=True]]])

rdkit.Chem.rdMolDescriptors.CalcSpherocityIndex((Mol)mol[, (int)confId=-1[, (bool)force=True]]) → float :

C++ signature :

double CalcSpherocityIndex(RDKit::ROMol [,int=-1 [,bool=True]])

rdkit.Chem.rdMolDescriptors.CalcTPSA((Mol)mol[, (bool)force=False[, (bool)includeSandP=False]]) → float :

returns the TPSA value for a molecule

C++ signature :

double CalcTPSA(RDKit::ROMol [,bool=False [,bool=False]])

rdkit.Chem.rdMolDescriptors.CalcWHIM((Mol)mol[, (int)confId=-1[, (float)thresh=0.001[, (str)CustomAtomProperty='']]]) → list :

Returns the WHIM descriptors vector

C++ signature :

boost::python::list CalcWHIM(RDKit::ROMol [,int=-1 [,double=0.001 [,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >=’‘]]])

rdkit.Chem.rdMolDescriptors.CustomProp_VSA_((Mol)mol, (str)customPropName, (AtomPairsParameters)bins[, (bool)force=False]) → list :

C++ signature :

boost::python::list CustomProp_VSA_(RDKit::ROMol,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,boost::python::api::object [,bool=False])

rdkit.Chem.rdMolDescriptors.GetAtomPairAtomCode((Atom)atom[, (int)branchSubtract=0[, (bool)includeChirality=False]]) → int :

Returns the atom code (hash) for an atom

C++ signature :

unsigned int GetAtomPairAtomCode(RDKit::Atom const* [,unsigned int=0 [,bool=False]])

rdkit.Chem.rdMolDescriptors.GetAtomPairCode((int)atom1Code, (int)atom2Code, (int)distance[, (bool)includeChirality=False]) → int :

Returns the atom-pair code (hash) for a pair of atoms separated by a certain number of bonds

C++ signature :

unsigned int GetAtomPairCode(unsigned int,unsigned int,unsigned int [,bool=False])

rdkit.Chem.rdMolDescriptors.GetAtomPairFingerprint((Mol)mol[, (int)minLength=1[, (int)maxLength=30[, (AtomPairsParameters)fromAtoms=0[, (AtomPairsParameters)ignoreAtoms=0[, (AtomPairsParameters)atomInvariants=0[, (bool)includeChirality=False[, (bool)use2D=True[, (int)confId=-1]]]]]]]]) → IntSparseIntVect :

Returns the atom-pair fingerprint for a molecule as an IntSparseIntVect

C++ signature :

RDKit::SparseIntVect<int>* GetAtomPairFingerprint(RDKit::ROMol [,unsigned int=1 [,unsigned int=30 [,boost::python::api::object=0 [,boost::python::api::object=0 [,boost::python::api::object=0 [,bool=False [,bool=True [,int=-1]]]]]]]])

rdkit.Chem.rdMolDescriptors.GetConnectivityInvariants((Mol)mol[, (bool)includeRingMembership=True]) → list :

Returns connectivity invariants (ECFP-like) for a molecule.

C++ signature :

boost::python::list GetConnectivityInvariants(RDKit::ROMol [,bool=True])

rdkit.Chem.rdMolDescriptors.GetFeatureInvariants((Mol)mol) → list :

Returns feature invariants (FCFP-like) for a molecule.

C++ signature :

boost::python::list GetFeatureInvariants(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.GetHashedAtomPairFingerprint((Mol)mol[, (int)nBits=2048[, (int)minLength=1[, (int)maxLength=30[, (AtomPairsParameters)fromAtoms=0[, (AtomPairsParameters)ignoreAtoms=0[, (AtomPairsParameters)atomInvariants=0[, (bool)includeChirality=False[, (bool)use2D=True[, (int)confId=-1]]]]]]]]]) → IntSparseIntVect :

Returns the hashed atom-pair fingerprint for a molecule as an IntSparseIntVect

C++ signature :

RDKit::SparseIntVect<int>* GetHashedAtomPairFingerprint(RDKit::ROMol [,unsigned int=2048 [,unsigned int=1 [,unsigned int=30 [,boost::python::api::object=0 [,boost::python::api::object=0 [,boost::python::api::object=0 [,bool=False [,bool=True [,int=-1]]]]]]]]])

rdkit.Chem.rdMolDescriptors.GetHashedAtomPairFingerprintAsBitVect((Mol)mol[, (int)nBits=2048[, (int)minLength=1[, (int)maxLength=30[, (AtomPairsParameters)fromAtoms=0[, (AtomPairsParameters)ignoreAtoms=0[, (AtomPairsParameters)atomInvariants=0[, (int)nBitsPerEntry=4[, (bool)includeChirality=False[, (bool)use2D=True[, (int)confId=-1]]]]]]]]]]) → ExplicitBitVect :

Returns the atom-pair fingerprint for a molecule as an ExplicitBitVect

C++ signature :

ExplicitBitVect* GetHashedAtomPairFingerprintAsBitVect(RDKit::ROMol [,unsigned int=2048 [,unsigned int=1 [,unsigned int=30 [,boost::python::api::object=0 [,boost::python::api::object=0 [,boost::python::api::object=0 [,unsigned int=4 [,bool=False [,bool=True [,int=-1]]]]]]]]]])

rdkit.Chem.rdMolDescriptors.GetHashedMorganFingerprint((Mol)mol, (int)radius[, (int)nBits=2048[, (AtomPairsParameters)invariants=[][, (AtomPairsParameters)fromAtoms=[][, (bool)useChirality=False[, (bool)useBondTypes=True[, (bool)useFeatures=False[, (AtomPairsParameters)bitInfo=None]]]]]]]) → UIntSparseIntVect :

Returns a hashed Morgan fingerprint for a molecule

C++ signature :

RDKit::SparseIntVect<unsigned int>* GetHashedMorganFingerprint(RDKit::ROMol,int [,int=2048 [,boost::python::api::object=[] [,boost::python::api::object=[] [,bool=False [,bool=True [,bool=False [,boost::python::api::object=None]]]]]]])

rdkit.Chem.rdMolDescriptors.GetHashedTopologicalTorsionFingerprint((Mol)mol[, (int)nBits=2048[, (int)targetSize=4[, (AtomPairsParameters)fromAtoms=0[, (AtomPairsParameters)ignoreAtoms=0[, (AtomPairsParameters)atomInvariants=0[, (bool)includeChirality=False]]]]]]) → LongSparseIntVect :

Returns the hashed topological-torsion fingerprint for a molecule as a LongIntSparseIntVect

C++ signature :

RDKit::SparseIntVect<long>* GetHashedTopologicalTorsionFingerprint(RDKit::ROMol [,unsigned int=2048 [,unsigned int=4 [,boost::python::api::object=0 [,boost::python::api::object=0 [,boost::python::api::object=0 [,bool=False]]]]]])

rdkit.Chem.rdMolDescriptors.GetHashedTopologicalTorsionFingerprintAsBitVect((Mol)mol[, (int)nBits=2048[, (int)targetSize=4[, (AtomPairsParameters)fromAtoms=0[, (AtomPairsParameters)ignoreAtoms=0[, (AtomPairsParameters)atomInvariants=0[, (int)nBitsPerEntry=4[, (bool)includeChirality=False]]]]]]]) → ExplicitBitVect :

Returns the topological-torsion fingerprint for a molecule as an ExplicitBitVect

C++ signature :

ExplicitBitVect* GetHashedTopologicalTorsionFingerprintAsBitVect(RDKit::ROMol [,unsigned int=2048 [,unsigned int=4 [,boost::python::api::object=0 [,boost::python::api::object=0 [,boost::python::api::object=0 [,unsigned int=4 [,bool=False]]]]]]])

rdkit.Chem.rdMolDescriptors.GetMACCSKeysFingerprint((Mol)mol) → ExplicitBitVect :

Returns the MACCS keys for a molecule as an ExplicitBitVect

C++ signature :

ExplicitBitVect* GetMACCSKeysFingerprint(RDKit::ROMol)

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]]]]]]]) → UIntSparseIntVect :

Returns a Morgan fingerprint for a molecule

C++ signature :

RDKit::SparseIntVect<unsigned int>* GetMorganFingerprint(RDKit::ROMol,int [,boost::python::api::object=[] [,boost::python::api::object=[] [,bool=False [,bool=True [,bool=False [,bool=True [,boost::python::api::object=None]]]]]]])

rdkit.Chem.rdMolDescriptors.GetMorganFingerprintAsBitVect((Mol)mol, (int)radius[, (int)nBits=2048[, (AtomPairsParameters)invariants=[][, (AtomPairsParameters)fromAtoms=[][, (bool)useChirality=False[, (bool)useBondTypes=True[, (bool)useFeatures=False[, (AtomPairsParameters)bitInfo=None]]]]]]]) → ExplicitBitVect :

Returns a Morgan fingerprint for a molecule as a bit vector

C++ signature :

ExplicitBitVect* GetMorganFingerprintAsBitVect(RDKit::ROMol,int [,unsigned int=2048 [,boost::python::api::object=[] [,boost::python::api::object=[] [,bool=False [,bool=True [,bool=False [,boost::python::api::object=None]]]]]]])

rdkit.Chem.rdMolDescriptors.GetTopologicalTorsionFingerprint((Mol)mol[, (int)targetSize=4[, (AtomPairsParameters)fromAtoms=0[, (AtomPairsParameters)ignoreAtoms=0[, (AtomPairsParameters)atomInvariants=0[, (bool)includeChirality=False]]]]]) → LongSparseIntVect :

Returns the topological-torsion fingerprint for a molecule as a LongIntSparseIntVect

C++ signature :

RDKit::SparseIntVect<long>* GetTopologicalTorsionFingerprint(RDKit::ROMol [,unsigned int=4 [,boost::python::api::object=0 [,boost::python::api::object=0 [,boost::python::api::object=0 [,bool=False]]]]])

rdkit.Chem.rdMolDescriptors.GetUSR((Mol)mol[, (int)confId=-1]) → list :

Returns a USR descriptor for one conformer of a molecule

C++ signature :

boost::python::list GetUSR(RDKit::ROMol [,int=-1])

rdkit.Chem.rdMolDescriptors.GetUSRCAT((Mol)mol[, (AtomPairsParameters)atomSelections=None[, (int)confId=-1]]) → list :

Returns a USRCAT descriptor for one conformer of a molecule

C++ signature :

boost::python::list GetUSRCAT(RDKit::ROMol [,boost::python::api::object=None [,int=-1]])

rdkit.Chem.rdMolDescriptors.GetUSRDistributions((AtomPairsParameters)coords[, (AtomPairsParameters)points=None]) → list :

Returns the four USR distance distributions for a set of coordinates

C++ signature :

boost::python::list GetUSRDistributions(boost::python::api::object [,boost::python::api::object=None])

rdkit.Chem.rdMolDescriptors.GetUSRDistributionsFromPoints((AtomPairsParameters)coords, (AtomPairsParameters)points) → list :

Returns the USR distance distributions for a set of coordinates and points

C++ signature :

boost::python::list GetUSRDistributionsFromPoints(boost::python::api::object,boost::python::api::object)

rdkit.Chem.rdMolDescriptors.GetUSRFromDistributions((AtomPairsParameters)distances) → list :

Returns the USR descriptor from a set of distance distributions

C++ signature :

boost::python::list GetUSRFromDistributions(boost::python::api::object)

rdkit.Chem.rdMolDescriptors.GetUSRScore((AtomPairsParameters)descriptor1, (AtomPairsParameters)descriptor2[, (AtomPairsParameters)weights=[]]) → float :

Returns the USR score for two USR or USRCAT descriptors

C++ signature :

double GetUSRScore(boost::python::api::object,boost::python::api::object [,boost::python::api::object=[]])

rdkit.Chem.rdMolDescriptors.MQNs_((Mol)mol[, (bool)force=False]) → list :

C++ signature :

boost::python::list MQNs_(RDKit::ROMol [,bool=False])

rdkit.Chem.rdMolDescriptors.MakePropertyRangeQuery((str)name, (float)min, (float)max) → PropertyRangeQuery :

Generates a Range property for the specified property, between min and max query = MakePropertyRangeQuery(‘exactmw’, 0, 500) query.Match( mol )

C++ signature :

Queries::RangeQuery<double, RDKit::ROMol const&, true>* MakePropertyRangeQuery(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,double,double)

class rdkit.Chem.rdMolDescriptors.NumRotatableBondsOptions

Bases: Boost.Python.enum

Options for generating rotatble bonds NonStrict - standard loose definitions Strict - stricter definition excluding amides, esters, etc StrictLinkages - adds rotors between rotatable bonds Default - Current RDKit default

Default = rdkit.Chem.rdMolDescriptors.NumRotatableBondsOptions.Default

NonStrict = rdkit.Chem.rdMolDescriptors.NumRotatableBondsOptions.NonStrict

Strict = rdkit.Chem.rdMolDescriptors.NumRotatableBondsOptions.Strict

StrictLinkages = rdkit.Chem.rdMolDescriptors.NumRotatableBondsOptions.StrictLinkages

names = {'Default': rdkit.Chem.rdMolDescriptors.NumRotatableBondsOptions.Default, 'NonStrict': rdkit.Chem.rdMolDescriptors.NumRotatableBondsOptions.NonStrict, 'Strict': rdkit.Chem.rdMolDescriptors.NumRotatableBondsOptions.Strict, 'StrictLinkages': rdkit.Chem.rdMolDescriptors.NumRotatableBondsOptions.StrictLinkages}

values = {-1: rdkit.Chem.rdMolDescriptors.NumRotatableBondsOptions.Default, 0: rdkit.Chem.rdMolDescriptors.NumRotatableBondsOptions.NonStrict, 1: rdkit.Chem.rdMolDescriptors.NumRotatableBondsOptions.Strict, 2: rdkit.Chem.rdMolDescriptors.NumRotatableBondsOptions.StrictLinkages}

rdkit.Chem.rdMolDescriptors.PEOE_VSA_((Mol)mol[, (AtomPairsParameters)bins=[][, (bool)force=False]]) → list :

C++ signature :

boost::python::list PEOE_VSA_(RDKit::ROMol [,boost::python::api::object=[] [,bool=False]])

class rdkit.Chem.rdMolDescriptors.Properties((object)arg1) → None :

Bases: Boost.Python.instance

Property computation and registry system. To compute all registered properties: mol = Chem.MolFromSmiles(‘c1ccccc1’) properties = rdMolDescriptors.Properties() for name, value in zip(properties.GetPropertyNames(), properties.ComputeProperties(mol)):

print(name, value)

To compute a subset properties = rdMolDescriptors.Properties([‘exactmw’, ‘lipinskiHBA’]) for name, value in zip(properties.GetPropertyNames(), properties.ComputeProperties(mol)):

print(name, value)

C++ signature :

void __init__(_object*)

__init__( (object)arg1, (_vectNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE)arg2) -> None :

C++ signature :

void __init__(_object*,std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >)

AnnotateProperties((Properties)arg1, (Mol)mol) → None :

Annotate the molecule with the computed properties. These properties will be available as SDData or from mol.GetProp(prop)

C++ signature :

void AnnotateProperties(RDKit::Descriptors::Properties {lvalue},RDKit::ROMol {lvalue})

ComputeProperties((Properties)arg1, (Mol)mol[, (bool)annotateMol=False]) → _vectd :

Return a list of computed properties, if annotateMol==True, annotate the molecule with the computed properties.

C++ signature :

std::vector<double, std::allocator<double> > ComputeProperties(RDKit::Descriptors::Properties {lvalue},RDKit::ROMol [,bool=False])

static GetAvailableProperties() → _vectNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE :

Return all available property names that can be computed

C++ signature :

std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > GetAvailableProperties()

static GetProperty((str)propName) → PropertyFunctor :

Return the named property if it exists

C++ signature :

boost::shared_ptr<RDKit::Descriptors::PropertyFunctor> GetProperty(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

GetPropertyNames((Properties)arg1) → _vectNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE :

Return the property names computed by this instance

C++ signature :

std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > GetPropertyNames(RDKit::Descriptors::Properties {lvalue})

static RegisterProperty((PropertyFunctor)propertyFunctor) → int :

Register a new property object (not thread safe)

C++ signature :

int RegisterProperty(RDKit::Descriptors::PropertyFunctor*)

class rdkit.Chem.rdMolDescriptors.PropertyFunctor

Bases: Boost.Python.instance

Property computation class stored in the property registry. See rdkit.Chem.rdMolDescriptor.Properties.GetProperty and rdkit.Chem.Descriptor.Properties.PropertyFunctor for creating new ones

Raises an exception This class cannot be instantiated from Python

GetName((PropertyFunctor)arg1) → str :

Return the name of the property to calculate

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > GetName(RDKit::Descriptors::PropertyFunctor {lvalue})

GetVersion((PropertyFunctor)arg1) → str :

Return the version of the calculated property

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > GetVersion(RDKit::Descriptors::PropertyFunctor {lvalue})

class rdkit.Chem.rdMolDescriptors.PropertyRangeQuery

Bases: Boost.Python.instance

Property Range Query for a molecule. Match(mol) -> true if in range

Raises an exception This class cannot be instantiated from Python

Match((PropertyRangeQuery)arg1, (Mol)arg2) → bool :

C++ signature :

bool Match(Queries::RangeQuery<double, RDKit::ROMol const&, true> {lvalue},RDKit::ROMol)

class rdkit.Chem.rdMolDescriptors.PythonPropertyFunctor((object)arg1, (object)arg2, (str)arg3, (str)arg4) → None :

Bases: rdkit.Chem.rdMolDescriptors.PropertyFunctor

C++ signature :

void __init__(_object*,_object*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

rdkit.Chem.rdMolDescriptors.SMR_VSA_((Mol)mol[, (AtomPairsParameters)bins=[][, (bool)force=False]]) → list :

C++ signature :

boost::python::list SMR_VSA_(RDKit::ROMol [,boost::python::api::object=[] [,bool=False]])

rdkit.Chem.rdMolDescriptors.SlogP_VSA_((Mol)mol[, (AtomPairsParameters)bins=[][, (bool)force=False]]) → list :

C++ signature :

boost::python::list SlogP_VSA_(RDKit::ROMol [,boost::python::api::object=[] [,bool=False]])