rdkit.Chem.Pharm2D.Utils module

utility functionality for the 2D pharmacophores code

See Docs/Chem/Pharm2D.triangles.jpg for an illustration of the way pharmacophores are broken into triangles and labelled.

See Docs/Chem/Pharm2D.signatures.jpg for an illustration of bit numbering

rdkit.Chem.Pharm2D.Utils.BinsTriangleInequality(d1, d2, d3)

checks the triangle inequality for combinations of distance bins.

the general triangle inequality is:

d1 + d2 >= d3

the conservative binned form of this is:

d1(upper) + d2(upper) >= d3(lower)

rdkit.Chem.Pharm2D.Utils.CountUpTo(nItems, nSlots, vs, idx=0, startAt=0)
Figures out where a given combination of indices would

occur in the combinatorial explosion generated by _GetIndexCombinations_

Arguments

  • nItems: the number of items to distribute

  • nSlots: the number of slots in which to distribute them

  • vs: a sequence containing the values to find

  • idx: used in the recursion

  • startAt: used in the recursion

Returns

an integer

rdkit.Chem.Pharm2D.Utils.GetAllCombinations(choices, noDups=1, which=0)

Does the combinatorial explosion of the possible combinations of the elements of _choices_.

Arguments

  • choices: sequence of sequences with the elements to be enumerated

  • noDups: (optional) if this is nonzero, results with duplicates, e.g. (1,1,0), will not be generated

  • which: used in recursion

Returns

a list of lists

>>> GetAllCombinations([(0, ), (1, ), (2, )])
[[0, 1, 2]]
>>> GetAllCombinations([(0, ), (1, 3), (2, )])
[[0, 1, 2], [0, 3, 2]]

>>> GetAllCombinations([(0, 1), (1, 3), (2, )])
[[0, 1, 2], [0, 3, 2], [1, 3, 2]]
rdkit.Chem.Pharm2D.Utils.GetIndexCombinations(nItems, nSlots, slot=0, lastItemVal=0)
Generates all combinations of nItems in nSlots without including

duplicates

Arguments

  • nItems: the number of items to distribute

  • nSlots: the number of slots in which to distribute them

  • slot: used in recursion

  • lastItemVal: used in recursion

Returns

a list of lists

rdkit.Chem.Pharm2D.Utils.GetPossibleScaffolds(nPts, bins, useTriangleInequality=True)

gets all realizable scaffolds (passing the triangle inequality) with the given number of points and returns them as a list of tuples

rdkit.Chem.Pharm2D.Utils.GetTriangles(nPts)

returns a tuple with the distance indices for triangles composing an nPts-pharmacophore

rdkit.Chem.Pharm2D.Utils.GetUniqueCombinations(choices, classes, which=0)

Does the combinatorial explosion of the possible combinations of the elements of _choices_.

rdkit.Chem.Pharm2D.Utils.GetUniqueCombinations_new(choices, classes, which=0)

Does the combinatorial explosion of the possible combinations of the elements of _choices_.

rdkit.Chem.Pharm2D.Utils.NumCombinations(nItems, nSlots)

returns the number of ways to fit nItems into nSlots

We assume that (x, y) and (y, x) are equivalent, and (x, x) is allowed.

General formula is, for N items and S slots:

res = (N+S-1)! / ( (N-1)! * S! )

rdkit.Chem.Pharm2D.Utils.OrderTriangle(featIndices, dists)

put the distances for a triangle into canonical order

It’s easy if the features are all different:

>>> OrderTriangle([0, 2, 4], [1, 2, 3])
([0, 2, 4], [1, 2, 3])

It’s trickiest if they are all the same:

>>> OrderTriangle([0, 0, 0], [1, 2, 3])
([0, 0, 0], [3, 2, 1])
>>> OrderTriangle([0, 0, 0], [2, 1, 3])
([0, 0, 0], [3, 2, 1])
>>> OrderTriangle([0, 0, 0], [1, 3, 2])
([0, 0, 0], [3, 2, 1])
>>> OrderTriangle([0, 0, 0], [3, 1, 2])
([0, 0, 0], [3, 2, 1])
>>> OrderTriangle([0, 0, 0], [3, 2, 1])
([0, 0, 0], [3, 2, 1])

>>> OrderTriangle([0, 0, 1], [3, 2, 1])
([0, 0, 1], [3, 2, 1])
>>> OrderTriangle([0, 0, 1], [1, 3, 2])
([0, 0, 1], [1, 3, 2])
>>> OrderTriangle([0, 0, 1], [1, 2, 3])
([0, 0, 1], [1, 3, 2])
rdkit.Chem.Pharm2D.Utils.ScaffoldPasses(combo, bins=None)

checks the scaffold passed in to see if all contributing triangles can satisfy the triangle inequality

the scaffold itself (encoded in combo) is a list of binned distances

rdkit.Chem.Pharm2D.Utils.UniquifyCombinations(combos)

uniquifies the combinations in the argument

Arguments:

  • combos: a sequence of sequences

Returns

  • a list of tuples containing the unique combos