def testScaleBoundsMatForce(self):
"""
for pentane, set a target distance for the 1-5 distance, and generate conformers with changing weights for (all) the atom pair distance restraints,
the conformer with the stronger weight for the atom pairs will always have a 1-5 distance closer to the target value than that with the weaker weight.
"""
target = 4
for i in range(5):
ps = rdDistGeom.EmbedParameters()
ps.randomSeed = i
ps.useBasicKnowledge = True
ps.useRandomCoords = False
m1 = Chem.MolFromSmiles("CCCCC")
bm1 = rdDistGeom.GetMoleculeBoundsMatrix(m1)
bm1[0,4] = target
bm1[4,0] = target
DG.DoTriangleSmoothing(bm1)
ps.boundsMatForceScaling = 0.1
ps.SetBoundsMat(bm1)
self.assertEqual(rdDistGeom.EmbedMolecule(m1,ps),0)
m2 = Chem.MolFromSmiles("CCCCC")
ps = rdDistGeom.EmbedParameters()
ps.randomSeed = i
ps.useBasicKnowledge = True
ps.useRandomCoords = False
ps.boundsMatForceScaling = 10
ps.SetBoundsMat(bm1)
self.assertEqual(rdDistGeom.EmbedMolecule(m2,ps),0)
conf1 = m1.GetConformer()
conf2 = m2.GetConformer()
self.assertTrue(abs((conf2.GetAtomPosition(4)-conf2.GetAtomPosition(0)).Length() - target) < abs((conf1.GetAtomPosition(4)-conf1.GetAtomPosition(0)).Length() - target))
def testProvidingCPCI(self):
"""
test for a ring molecule, repeated generating a conformer with and without enforcing
an additional +ve interaction between a pair of non-bonded atoms (termed CPCI,
custom pairwise charge-like interaciton), in every iteration, applying CPCI should
yield a conformer where this pair of atoms are further apart.
"""
for i in range(5):
ps = rdDistGeom.EmbedParameters()
ps.randomSeed = i
ps.useBasicKnowledge = True
ps.useRandomCoords = False
m1 = Chem.MolFromSmiles("C1CCCC1C")
self.assertEqual(rdDistGeom.EmbedMolecule(m1, ps), 0)
m2 = Chem.MolFromSmiles("C1CCCC1C")
ps = rdDistGeom.EmbedParameters()
ps.randomSeed = i
ps.useRandomCoords = False
ps.useBasicKnowledge = True
ps.SetCPCI({(0, 3): 0.9})
self.assertEqual(rdDistGeom.EmbedMolecule(m2, ps), 0)
conf1 = m1.GetConformer()
conf2 = m2.GetConformer()
self.assertTrue(
(conf2.GetAtomPosition(3) -
conf2.GetAtomPosition(0)).Length() >
(conf1.GetAtomPosition(3) - conf1.GetAtomPosition(0)).Length())
def test1Small(self):
#writer = Chem.SDWriter("test.sdf")
# single double and tripple atoms cases should not fail
mol = Chem.MolFromSmiles('O')
rdDistGeom.EmbedMolecule(mol, 10, 1)
conf = mol.GetConformer()
self.assertTrue(lstEq(conf.GetAtomPosition(0), [0.0, 0.0, 0.0]))
#writer.write(mol)
mol = Chem.MolFromSmiles('CO')
rdDistGeom.EmbedMolecule(mol, 10, 1)
conf = mol.GetConformer()
self.assertTrue(lstEq(conf.GetAtomPosition(0), [0.69192, 0.0, 0.0]))
self.assertTrue(lstEq(conf.GetAtomPosition(1), [-0.69192, 0.0, 0.0]))
#writer.write(mol)
mol = Chem.MolFromSmiles('CCC')
rdDistGeom.EmbedMolecule(mol, 10, 1)
conf = mol.GetConformer()
self.assertTrue(
lstEq(conf.GetAtomPosition(0), [-1.21676, -0.2989, 0.0]))
self.assertTrue(
lstEq(conf.GetAtomPosition(1), [-0.00604, 0.59337, 0.0]))
self.assertTrue(
lstEq(conf.GetAtomPosition(2), [1.22281, -0.29446, 0.0]))
#writer.write(mol)
mol = Chem.MolFromSmiles('O=C=O')
rdDistGeom.EmbedMolecule(mol, 10, 1)
conf = mol.GetConformer()
#writer.write(mol)
self.assertTrue(
lstEq(conf.GetAtomPosition(0), [-1.2180, -0.06088, 0.0]))
self.assertTrue(
lstEq(conf.GetAtomPosition(1), [-0.00408, 0.12116, 0.0]))
self.assertTrue(
lstEq(conf.GetAtomPosition(2), [1.22207, -0.060276, 0.0]))
mol = Chem.MolFromSmiles('C=C=C=C')
rdDistGeom.EmbedMolecule(mol, 10, 1)
conf = mol.GetConformer()
#writer.write(mol)
d1 = computeDist(conf.GetAtomPosition(0), conf.GetAtomPosition(1))
self.assertTrue(feq(d1, 1.31, 0.01))
d2 = computeDist(conf.GetAtomPosition(0), conf.GetAtomPosition(2))
self.assertTrue(feq(d2, 2.59, 0.05))
d3 = computeDist(conf.GetAtomPosition(0), conf.GetAtomPosition(3))
self.assertTrue(feq(d3, 3.84, 0.1))
d4 = computeDist(conf.GetAtomPosition(1), conf.GetAtomPosition(2))
self.assertTrue(feq(d4, 1.29, 0.01))
d5 = computeDist(conf.GetAtomPosition(1), conf.GetAtomPosition(3))
self.assertTrue(feq(d5, 2.54, 0.1))
d6 = computeDist(conf.GetAtomPosition(2), conf.GetAtomPosition(3))
self.assertTrue(feq(d6, 1.31, 0.01))
def test7MMFFO3A(self):
" make sure we generate an error if parameters are missing (github issue 158) "
m1 = Chem.MolFromSmiles('c1ccccc1Cl')
rdDistGeom.EmbedMolecule(m1)
m2 = Chem.MolFromSmiles('c1ccccc1B(O)O')
rdDistGeom.EmbedMolecule(m1)
self.assertRaises(ValueError, lambda: rdMolAlign.GetO3A(m1, m2))
self.assertRaises(ValueError, lambda: rdMolAlign.GetO3A(m2, m1))
def test7MMFFO3A(self):
" make sure we generate an error if parameters are missing (github issue 158) "
sdf = os.path.join(RDConfig.RDBaseDir,'Code','GraphMol',
'MolAlign', 'test_data', 'ref_e2.sdf')
m1 = Chem.MolFromSmiles('c1ccccc1Cl')
rdDistGeom.EmbedMolecule(m1)
m2 = Chem.MolFromSmiles('c1ccccc1B(O)O')
rdDistGeom.EmbedMolecule(m1)
self.failUnlessRaises(ValueError,lambda :rdMolAlign.GetO3A(m1, m2))
self.failUnlessRaises(ValueError,lambda :rdMolAlign.GetO3A(m2, m1))
def testIncludeOnly(self):
cfac = ChemicalFeatures.BuildFeatureFactory(
os.path.join(RDConfig.RDBaseDir, 'Code', 'GraphMol', 'MolChemicalFeatures', 'test_data',
'featDef.txt'))
self.failUnless(cfac.GetNumFeatureDefs() == 2)
mol = Chem.MolFromSmiles("COCN")
rdDistGeom.EmbedMolecule(mol)
self.failUnless(cfac.GetNumMolFeatures(mol, includeOnly="HBondAcceptor") == 2)
self.failUnless(cfac.GetNumMolFeatures(mol, includeOnly="HBondDonor") == 1)
self.failUnless(cfac.GetNumMolFeatures(mol, includeOnly="Bogus") == 0)
self.failUnlessRaises(IndexError, lambda: cfac.GetMolFeature(mol, 1, includeOnly="HBondDonor"))
self.failUnlessRaises(IndexError,
lambda: cfac.GetMolFeature(mol, 2, includeOnly="HBondAcceptor"))
f = cfac.GetMolFeature(mol, 0, includeOnly="HBondDonor")
self.failUnless(f.GetFamily() == 'HBondDonor')
feats = cfac.GetFeaturesForMol(mol, includeOnly="HBondAcceptor")
self.failUnless(len(feats) == 2)
feats = cfac.GetFeaturesForMol(mol, includeOnly="HBondDonor")
self.failUnless(len(feats) == 1)
feats = cfac.GetFeaturesForMol(mol, includeOnly="Bogus")
self.failUnless(len(feats) == 0)
def saveimg(smile, pltnm):
atorvastatin = Chem.MolFromSmiles(smile)
mh = Chem.AddHs(atorvastatin)
rdDistGeom.EmbedMolecule(mh)
_, res = rdEHTTools.RunMol(mh)
static_chgs = res.GetAtomicCharges()[:atorvastatin.GetNumAtoms()]
d = Draw.MolDraw2DCairo(400, 400)
SimilarityMaps.GetSimilarityMapFromWeights(atorvastatin,
list(static_chgs),
draw2d=d)
d.FinishDrawing()
thing = show_png(d.GetDrawingText())
name = "http://localhost:5006/fol/static/" + pltnm + ".png"
thing.save(
"C:\\Users\\patil.py\\Documents\\11F-Drive\\PFastWebLocalApp\\FlavorTool\\fol\\static\\"
+ pltnm + ".png")
p = figure(x_range=(0, 1),
y_range=(0, 1),
toolbar_location=None,
plot_width=200,
plot_height=200)
p.xgrid.grid_line_color = None
p.ygrid.grid_line_color = None
p.axis.visible = False
thing = WheelZoomTool()
p.add_tools(thing)
p.toolbar.active_scroll = thing
p.image_url(url=[name], x=0, y=1, w=1, h=1)
return p
def testProvidingBoundsMatrix(self):
m1 = Chem.MolFromSmiles("C1CCC1C")
bm1 = rdDistGeom.GetMoleculeBoundsMatrix(m1)
bm1[0, 3] = 1.21
bm1[3, 0] = 1.20
bm1[2, 3] = 1.21
bm1[3, 2] = 1.20
bm1[4, 3] = 1.21
bm1[3, 4] = 1.20
DG.DoTriangleSmoothing(bm1)
ps = rdDistGeom.EmbedParameters()
ps.useRandomCoords = True
ps.SetBoundsMat(bm1)
ps.randomSeed = 0xf00d
self.assertEqual(rdDistGeom.EmbedMolecule(m1, ps), 0)
conf = m1.GetConformer()
self.assertAlmostEqual(
(conf.GetAtomPosition(3) - conf.GetAtomPosition(0)).Length(),
1.2,
delta=0.05)
self.assertAlmostEqual(
(conf.GetAtomPosition(3) - conf.GetAtomPosition(2)).Length(),
1.2,
delta=0.05)
self.assertAlmostEqual(
(conf.GetAtomPosition(3) - conf.GetAtomPosition(4)).Length(),
1.2,
delta=0.05)
def test12CrippenO3A(self):
" test CrippenO3A with constraints "
#we superimpose two identical coplanar 4-phenylpyridines:
#1) the usual way
#2) forcing the pyridine nitrogen to match with the para
# carbon of the phenyl ring
m = Chem.MolFromSmiles('n1ccc(cc1)-c1ccccc1')
m1 = Chem.AddHs(m)
rdDistGeom.EmbedMolecule(m1)
mp = ChemicalForceFields.MMFFGetMoleculeProperties(m1)
ff = ChemicalForceFields.MMFFGetMoleculeForceField(m1, mp)
ff.Minimize()
sub1 = m1.GetSubstructMatch(Chem.MolFromSmarts('nccc-cccc'))
nIdx = sub1[0]
cIdx = sub1[-1]
dihe = sub1[2:6]
rdMolTransforms.SetDihedralDeg(m1.GetConformer(), dihe[0], dihe[1],
dihe[2], dihe[3], 0)
m2 = copy.copy(m1)
rdMolAlign.RandomTransform(m2)
m3 = copy.copy(m2)
pyO3A = rdMolAlign.GetCrippenO3A(m2, m1)
pyO3A.Align()
d = m2.GetConformer().GetAtomPosition(cIdx). \
Distance(m1.GetConformer().GetAtomPosition(cIdx))
self.assertAlmostEqual(d, 0, 0)
pyO3A = rdMolAlign.GetCrippenO3A(m3, m1, constraintMap=[[cIdx, nIdx]])
pyO3A.Align()
d = m3.GetConformer().GetAtomPosition(cIdx). \
Distance(m1.GetConformer().GetAtomPosition(cIdx))
self.assertAlmostEqual(d, 7, 0)
def testGithub2057(self):
# ensure that ETKDG is the default Embedder
mol = Chem.AddHs(Chem.MolFromSmiles('OCCC'))
fn = os.path.join(RDConfig.RDBaseDir, 'Code', 'GraphMol', 'DistGeomHelpers', 'test_data',
'simple_torsion.etkdg.mol')
ref = Chem.MolFromMolFile(fn, removeHs=False)
self.assertEqual(rdDistGeom.EmbedMolecule(mol, randomSeed=42), 0)
self._compareConfs(mol, ref, 0, 0)
def test10ETKDGv2(self):
mol = Chem.AddHs(Chem.MolFromSmiles('n1cccc(C)c1ON'))
fn = os.path.join(RDConfig.RDBaseDir, 'Code', 'GraphMol', 'DistGeomHelpers', 'test_data',
'torsion.etkdg.v2.mol')
ref = Chem.MolFromMolFile(fn, removeHs=False)
params = rdDistGeom.ETKDGv2()
params.randomSeed = 42
self.assertEqual(rdDistGeom.EmbedMolecule(mol, params), 0)
self._compareConfs(mol, ref, 0, 0)
def testOptimizeMolecule(self):
m = Chem.AddHs(Chem.MolFromSmiles("CCCO"))
self.assertIsNotNone(m)
self.assertEqual(rdDistGeom.EmbedMolecule(m), 0)
mp = ChemicalForceFields.MMFFGetMoleculeProperties(m)
ff = ChemicalForceFields.MMFFGetMoleculeForceField(m, mp)
before = ff.CalcEnergy()
self.assertEqual(
ChemicalForceFields.OptimizeMolecule(ff, maxIters=200), 0)
after = ff.CalcEnergy()
self.assertLess(after, before)
def test9EmbedParams(self):
mol = Chem.AddHs(Chem.MolFromSmiles('OCCC'))
fn = os.path.join(RDConfig.RDBaseDir, 'Code', 'GraphMol',
'DistGeomHelpers', 'test_data',
'simple_torsion.dg.mol')
ref = Chem.MolFromMolFile(fn, removeHs=False)
params = rdDistGeom.EmbedParameters()
params.randomSeed = 42
self.assertEqual(rdDistGeom.EmbedMolecule(mol, params), 0)
self._compareConfs(mol, ref, 0, 0)
fn = os.path.join(RDConfig.RDBaseDir, 'Code', 'GraphMol',
'DistGeomHelpers', 'test_data',
'simple_torsion.etdg.mol')
ref = Chem.MolFromMolFile(fn, removeHs=False)
params = rdDistGeom.EmbedParameters()
params.randomSeed = 42
params.useExpTorsionAnglePrefs = True
self.assertEqual(rdDistGeom.EmbedMolecule(mol, params), 0)
self._compareConfs(mol, ref, 0, 0)
fn = os.path.join(RDConfig.RDBaseDir, 'Code', 'GraphMol',
'DistGeomHelpers', 'test_data',
'simple_torsion.etkdg.mol')
ref = Chem.MolFromMolFile(fn, removeHs=False)
params = rdDistGeom.EmbedParameters()
params.randomSeed = 42
params.useExpTorsionAnglePrefs = True
params.useBasicKnowledge = True
self.assertEqual(rdDistGeom.EmbedMolecule(mol, params), 0)
self._compareConfs(mol, ref, 0, 0)
fn = os.path.join(RDConfig.RDBaseDir, 'Code', 'GraphMol',
'DistGeomHelpers', 'test_data',
'simple_torsion.kdg.mol')
ref = Chem.MolFromMolFile(fn, removeHs=False)
params = rdDistGeom.EmbedParameters()
params.randomSeed = 42
params.useBasicKnowledge = True
self.assertEqual(rdDistGeom.EmbedMolecule(mol, params), 0)
self._compareConfs(mol, ref, 0, 0)
def test14Github385(self):
""" test github issue 385:
O3A code generating incorrect results for multiconformer molecules
"""
def _multiConfFromSmiles(smiles, nConfs=10, maxIters=500):
"""Adds hydrogens to molecule and optimises a chosen number of conformers. Returns the optimised RDKit mol."""
idea = Chem.MolFromSmiles(smiles)
idea = Chem.AddHs(idea)
confs = rdDistGeom.EmbedMultipleConfs(idea, nConfs)
for conf in confs:
opt = ChemicalForceFields.MMFFOptimizeMolecule(
idea, confId=conf, maxIters=maxIters)
return idea
def _confsToAlignedMolsList(multiConfMol):
"""Input is a multiconformer RDKit mol. Output is an aligned set of conformers as a list of RDKit mols."""
rdMolAlign.AlignMolConformers(multiConfMol)
ms = []
cids = [x.GetId() for x in multiConfMol.GetConformers()]
for cid in cids:
newmol = Chem.Mol(multiConfMol)
for ocid in cids:
if ocid == cid:
continue
newmol.RemoveConformer(ocid)
ms.append(newmol)
return ms
reference = Chem.MolFromSmiles("c1ccccc1N2CCC(NS(=O)(=O)C(F)(F)F)CC2")
reference = Chem.AddHs(reference)
rdDistGeom.EmbedMolecule(reference)
idea1 = _multiConfFromSmiles("c1ccccc1C2CCCCC2", 10)
idea1_mols = _confsToAlignedMolsList(idea1)
cids = [x.GetId() for x in idea1.GetConformers()]
refParams = ChemicalForceFields.MMFFGetMoleculeProperties(reference)
prbParams = ChemicalForceFields.MMFFGetMoleculeProperties(idea1)
for i in range(len(cids)):
o3a1 = rdMolAlign.GetO3A(idea1_mols[i], reference, prbParams,
refParams)
score1 = o3a1.Score()
o3a2 = rdMolAlign.GetO3A(idea1,
reference,
prbParams,
refParams,
prbCid=cids[i])
score2 = o3a2.Score()
self.assertAlmostEqual(score1, score2, 3)
def embed_bounds_matrix(mol: Mol,
bounds_matrix: np.ndarray,
seed: int = 42) -> int:
DistanceGeometry.DoTriangleSmoothing(bounds_matrix)
ps = rdDistGeom.EmbedParameters()
ps.numThreads = 0 # max number of threads supported by the system will be used
ps.useRandomCoords = True # recommended for larger molecules
ps.clearConfs = False
ps.randomSeed = seed
ps.SetBoundsMat(bounds_matrix)
return rdDistGeom.EmbedMolecule(mol, ps)
def test_mols():
mols = []
all_smiles = [
'CN=C=O', 'Cc1ccccc1', 'CC1=CC2CC(CC1)O2', 'CCCCCCCCCCCCCCCC'
]
for smiles in all_smiles:
mol = rdmolfiles.MolFromSmiles(smiles)
mol = rdmolops.AddHs(mol, addCoords=True)
rdDistGeom.EmbedMolecule(mol, rdDistGeom.ETKDG())
mol = rdmolops.RemoveHs(mol)
mol.SetProp('Fitness', str(np.random.rand(1)[0]))
mols.append(mol)
return mols
def test7ConstrainedEmbedding(self):
ofile = os.path.join(RDConfig.RDBaseDir, 'Code', 'GraphMol',
'DistGeomHelpers', 'test_data', 'constrain1.sdf')
suppl = Chem.SDMolSupplier(ofile)
ref = next(suppl)
probe = copy.deepcopy(ref)
cMap = {}
for i in range(5):
cMap[i] = ref.GetConformer().GetAtomPosition(i)
ci = rdDistGeom.EmbedMolecule(probe, coordMap=cMap, randomSeed=23)
self.assertTrue(ci > -1)
algMap = list(zip(range(5), range(5)))
ssd = rdMolAlign.AlignMol(probe, ref, atomMap=algMap)
self.assertTrue(ssd < 0.1)
def template_embed_optimize(molecule_embed,molecule,mol_1,args,log):
#assigning and embedding onto the core
num_atom_match = molecule_embed.GetSubstructMatch(mol_1)
#add H's to molecule
molecule_embed = Chem.AddHs(molecule_embed)
#definition of coordmap, the coreconfID(the firstone =-1)
coordMap = {}
coreConfId=-1
randomseed=-1
force_constant=10000
# This part selects which atoms from molecule are the atoms of the core
try:
coreConf = mol_1.GetConformer(coreConfId)
except:
pass
for k, idxI in enumerate(num_atom_match):
core_mol_1 = coreConf.GetAtomPosition(k)
coordMap[idxI] = core_mol_1
ci = rdDistGeom.EmbedMolecule(molecule_embed, coordMap=coordMap, randomSeed=randomseed)
if ci < 0:
log.write('Could not embed molecule.')
coordMap = None
algMap = None
if ci >= 0:
GetFF = Chem.UFFGetMoleculeForceField(molecule_embed,confId=-1)
#algin molecule to the core
algMap = [(k, l) for l, k in enumerate(num_atom_match)]
for k, idxI in enumerate(num_atom_match):
for l in range(k + 1, len(num_atom_match)):
idxJ = num_atom_match[l]
d = coordMap[idxI].Distance(coordMap[idxJ])
GetFF.AddDistanceConstraint(idxI, idxJ, d, d, force_constant)
GetFF.Initialize()
GetFF.Minimize(maxIts=args.opt_steps_RDKit)
# rotate the embedded conformation onto the core_mol:
rdMolAlign.AlignMol(molecule_embed, mol_1, atomMap=algMap,reflect=True,maxIters=100)
return molecule_embed, coordMap, algMap, ci
def testBasic(self):
cfac = ChemicalFeatures.BuildFeatureFactory(
os.path.join(RDConfig.RDBaseDir, 'Code', 'GraphMol',
'MolChemicalFeatures', 'test_data', 'featDef.txt'))
self.failUnless(cfac.GetNumFeatureDefs() == 2)
fNames = cfac.GetFeatureFamilies()
self.failUnless(len(fNames) == 2)
self.failUnless(fNames[0] == 'HBondDonor')
self.failUnless(fNames[1] == 'HBondAcceptor')
mol = Chem.MolFromSmiles("COCN")
rdDistGeom.EmbedMolecule(mol,
30,
100,
useExpTorsionAnglePrefs=False,
useBasicKnowledge=False)
self.failUnless(cfac.GetNumMolFeatures(mol) == 3)
for i in range(cfac.GetNumMolFeatures(mol)):
self.failUnless(cfac.GetMolFeature(mol, i))
# check that the recompute argument works:
self.failUnless(cfac.GetMolFeature(mol, 0))
for i in range(cfac.GetNumMolFeatures(mol)):
self.failUnless(cfac.GetMolFeature(mol, i, "", False))
self.failUnlessRaises(IndexError, lambda: cfac.GetMolFeature(mol, 3))
feats = cfac.GetFeaturesForMol(mol)
self.failUnless(len(feats) == 3)
fTypes = ['HBondDonor', 'HBondAcceptor', 'HBondAcceptor']
positions = [[1.3041, -0.6079, 0.0924], [-0.7066, 0.5994, 0.1824],
[1.3041, -0.6079, 0.0924]]
targetAids = [[3], [1], [3]]
for i, feat in enumerate(feats):
self.assertEqual(feat.GetFamily(), fTypes[i])
pos = list(feat.GetPos())
aids = list(feat.GetAtomIds())
self.assertEqual(aids, targetAids[i])
self.assertTrue(lstFeq(pos, positions[i]))
nmol = feat.GetMol()
self.assertEqual(Chem.MolToSmiles(nmol), "COCN")
ncfac = feat.GetFactory()
self.assertEqual(ncfac.GetNumFeatureDefs(), 2)
self.assertEqual(feat.GetActiveConformer(), -1)
def testBasic(self):
cfac = ChemicalFeatures.BuildFeatureFactory(
os.path.join(RDConfig.RDBaseDir, 'Code', 'GraphMol',
'MolChemicalFeatures', 'test_data', 'featDef.txt'))
self.failUnless(cfac.GetNumFeatureDefs() == 2)
fNames = cfac.GetFeatureFamilies()
self.failUnless(len(fNames) == 2)
self.failUnless(fNames[0] == 'HBondDonor')
self.failUnless(fNames[1] == 'HBondAcceptor')
mol = Chem.MolFromSmiles("COCN")
rdDistGeom.EmbedMolecule(mol, 30, 100)
self.failUnless(cfac.GetNumMolFeatures(mol) == 3)
for i in range(cfac.GetNumMolFeatures(mol)):
self.failUnless(cfac.GetMolFeature(mol, i))
# check that the recompute argument works:
self.failUnless(cfac.GetMolFeature(mol, 0))
for i in range(cfac.GetNumMolFeatures(mol)):
self.failUnless(cfac.GetMolFeature(mol, i, "", False))
self.failUnlessRaises(IndexError, lambda: cfac.GetMolFeature(mol, 3))
feats = cfac.GetFeaturesForMol(mol)
self.failUnless(len(feats) == 3)
fTypes = ['HBondDonor', 'HBondAcceptor', 'HBondAcceptor']
positions = [[1.3215, -0.6284, 0.0967], [-0.7136, 0.6241, 0.1862],
[1.3215, -0.6284, 0.0967]]
targetAids = [[3], [1], [3]]
i = 0
for feat in feats:
self.failUnless(feat.GetFamily() == fTypes[i])
pos = list(feat.GetPos())
aids = list(feat.GetAtomIds())
self.failUnless(aids == targetAids[i])
self.failUnless(lstFeq(pos, positions[i]))
nmol = feat.GetMol()
self.failUnless(Chem.MolToSmiles(nmol) == "COCN")
ncfac = feat.GetFactory()
self.failUnless(ncfac.GetNumFeatureDefs() == 2)
i += 1
def compareWithOld(smilesFile, sdFile):
smiSup = Chem.SmilesMolSupplier(smilesFile, ",", 0, -1)
sdsup = Chem.SDMolSupplier(sdFile)
im = 0
for mol in smiSup:
cid = rdDistGeom.EmbedMolecule(mol, 10, 1)
omol = sdsup[im]
assert cid == 0
conf = mol.GetConformer(0)
oconf = omol.GetConformer()
nat = mol.GetNumAtoms()
for i in range(nat):
#atm = mol.GetAtomWithIdx(i)
#oatm = omol.GetAtomWithIdx(i)
pos = conf.GetAtomPosition(i)
opos = oconf.GetAtomPosition(i)
if not lstEq(pos, opos):
return 0
im += 1
return 1
def testIssue231(self):
fdefs = """
DefineFeature HDonor1 [N,O;!H0]
Family HBondDonor
Weights 1.0
EndFeature
DefineFeature HAcceptor1 [N,O;H0]
Family HBondAcceptor
Weights 1.0
EndFeature
"""
cfac = ChemicalFeatures.BuildFeatureFactoryFromString(fdefs)
m = Chem.MolFromSmiles('O=CCCN')
rdDistGeom.EmbedMolecule(m)
feats = cfac.GetFeaturesForMol(m)
for feat in feats:
feat.GetPos()
m = None
for feat in feats:
feat.GetPos()
def convertimplicttosdf(imol, sdffile):
if check_implicit_hydrogens(imol) or not imol.GetConformer().Is3D():
msg = ''
rdDistGeom.EmbedMolecule(imol)
if rdForceFieldHelpers.MMFFHasAllMoleculeParams(imol):
res = rdForceFieldHelpers.MMFFOptimizeMolecule(imol)
if res < 0:
raise Geometry3DGenerationError(
'Cannot generate 3D coordinates')
elif res > 0:
msg = 'WARNING: Optimitzation has not converged.'
elif rdForceFieldHelpers.UFFHasAllMoleculeParams(imol):
res = rdForceFieldHelpers.UFFOptimizeMolecule(imol)
if res < 0:
raise Geometry3DGenerationError(
'Cannot generate 3D coordinates')
elif res > 0:
msg = 'WARNING: Optimitzation has not converged.'
return (imol, msg)
def FormatConversion(
inputmol: Chem.Mol,
method='AM1',
version='7.1',
outfile=None,
outdir=None,
sdf=False,
) -> Tuple[str, str]:
"""Prepare a molecule to be optimized by MOPAC.
The preparation goes as follows:
1. all hydrogens are made explicit,
2. a 3D conformer is generated from RDKit's stochastic search,
based on distance geometry and exerimental crystallographic knowledge,
Wang S., J. Chem. Inf. Model. (2020), 60(4),2044-2058.
3. the conformer is converted to a first MOPAC input file with OpenBabel,
4. semi-empirical method and MOPAC version is added to the MOPAC input file.
A SDF can also be written to disk from the generated conformer to ease debugging.
:param method: MOPAC semi-empirical method to be used for molecular geometry oprimization
:param version: version of MOPAC to use
:param outfile: name of the output the MOPAC input file
:param outdir: directory where to create the MOPAC input file
If not specified, a temporary directory is created but
THE USER MUST REMOVE IT THEMSELVES USING GeOpt.Dispose.
:param sdf: whether a sdf file should also be created for easier debugging.
:return: the directory where the MOPAC input file was created
"""
# Ensure method and MOPAC version are compatible
if not IsMethodSupportedByMOPAC(method, version):
raise ValueError(
f'Method {method} is not supported by MOPAC {version}.')
# Step 1: add Hs
inputmol = Chem.AddHs(inputmol)
# Step 2: generate conformer
rdDistGeom.EmbedMolecule(inputmol, rdDistGeom.ETKDGv3())
pybelmol = pybel.readstring('sdf', Chem.MolToMolBlock(inputmol))
running_dir = tempfile.mkdtemp() if outdir is None else outdir
mpo_name = 'temp' if outfile is None else outfile
if sdf:
outputmol = pybel.Outputfile('sdf',
os.path.join(running_dir,
f'{mpo_name}.sdf'),
overwrite=True)
outputmol.write(pybelmol)
outputmol.close()
# Step 3: create first MOPAC input file
outputmol = pybel.Outputfile('mop',
os.path.join(running_dir, f'{mpo_name}.dat'),
overwrite=True)
outputmol.write(pybelmol)
outputmol.close()
# Step 4: add additional information to MOPAC input file
with open(os.path.join(running_dir, f'{mpo_name}.dat'), 'r') as f:
data = f.readlines()
data[0] = method + (' PRTCHAR \n' if version == '2016' else ' \n')
with open(os.path.join(running_dir, f'{mpo_name}.dat'), 'w') as f:
f.write("".join(data))
return running_dir, f'{mpo_name}.dat'
def test6Chirality(self):
# turn on chirality and we should get chiral volume that is pretty consistent and
# positive
tgtVol = 13.0
smiles = "Cl[C@](C)(F)Br"
mol = Chem.MolFromSmiles(smiles)
cids = rdDistGeom.EmbedMultipleConfs(mol,
30,
maxAttempts=30,
randomSeed=100)
self.assertTrue(len(cids) == 30)
for cid in cids:
conf = mol.GetConformer(cid)
vol = computeChiralVol(conf.GetAtomPosition(0),
conf.GetAtomPosition(2),
conf.GetAtomPosition(3),
conf.GetAtomPosition(4))
self.assertTrue(abs(vol - tgtVol) < 1)
# turn of chirality and now we should see both chiral forms
smiles = "ClC(C)(F)Br"
mol = Chem.MolFromSmiles(smiles)
cids = rdDistGeom.EmbedMultipleConfs(mol,
30,
maxAttempts=30,
randomSeed=120)
self.assertTrue(len(cids) == 30)
nPos = 0
nNeg = 0
for cid in cids:
conf = mol.GetConformer(cid)
vol = computeChiralVol(conf.GetAtomPosition(0),
conf.GetAtomPosition(2),
conf.GetAtomPosition(3),
conf.GetAtomPosition(4))
self.assertTrue(abs(vol - tgtVol) < 1 or abs(vol + tgtVol) < 1)
if vol < 0:
nNeg += 1
else:
nPos += 1
self.assertTrue(nPos > 0)
self.assertTrue(nNeg > 0)
tgtVol = 5.0
for i in range(10):
smiles = "Cl[C@H](F)Br"
mol = Chem.MolFromSmiles(smiles)
ci = rdDistGeom.EmbedMolecule(mol, 30, (i + 1) * 10)
conf = mol.GetConformer(ci)
vol = computeChiralVol(conf.GetAtomPosition(0),
conf.GetAtomPosition(1),
conf.GetAtomPosition(2),
conf.GetAtomPosition(3))
self.assertTrue(abs(vol - tgtVol) < 1, "%s %s" % (vol, tgtVol))
tgtVol = 3.5
expected = [
-3.62, -3.67, -3.72, 3.91, 3.95, 3.98, 3.90, 3.94, 3.98, 3.91
]
nPos = 0
nNeg = 0
for i in range(30):
smiles = "ClC(F)Br"
mol = Chem.MolFromSmiles(smiles)
ci = rdDistGeom.EmbedMolecule(mol, 30, (i + 1) * 10)
conf = mol.GetConformer(ci)
vol = computeChiralVol(conf.GetAtomPosition(0),
conf.GetAtomPosition(1),
conf.GetAtomPosition(2),
conf.GetAtomPosition(3))
self.assertTrue(abs(vol - tgtVol) < 1 or abs(vol + tgtVol) < 1)
if vol < 0:
nNeg += 1
else:
nPos += 1
self.assertTrue(nPos > 0)
self.assertTrue(nNeg > 0)
smiles = "Cl[C@H](F)Br"
m = Chem.MolFromSmiles(smiles)
mol = Chem.AddHs(m)
cids = rdDistGeom.EmbedMultipleConfs(mol,
10,
maxAttempts=30,
randomSeed=100)
self.assertTrue(len(cids) == 10)
tgtVol = 10.5
for cid in cids:
conf = mol.GetConformer(cid)
vol = computeChiralVol(conf.GetAtomPosition(0),
conf.GetAtomPosition(2),
conf.GetAtomPosition(3),
conf.GetAtomPosition(4))
self.assertTrue(abs(vol - tgtVol) < 2.)
# let's try a little more complicated system
expectedV1 = -2.0
expectedV2 = -2.9
for i in range(5):
smi = "C1=CC=C(C=C1)[C@H](OC1=C[NH]N=C1)C(=O)[NH]C[C@H](Cl)C1=CC=NC=C1"
mol = Chem.MolFromSmiles(smi)
ci = rdDistGeom.EmbedMolecule(mol, randomSeed=(i + 1) * 15)
self.assertTrue(ci >= 0)
ff = ChemicalForceFields.UFFGetMoleculeForceField(mol, 10.0, ci)
ff.Minimize()
conf = mol.GetConformer(ci)
vol1 = computeChiralVol(conf.GetAtomPosition(6),
conf.GetAtomPosition(3),
conf.GetAtomPosition(7),
conf.GetAtomPosition(13))
self.assertTrue(
abs(vol1 - expectedV1) < 1 or abs(vol1 + expectedV1) < 1)
if vol1 < 0:
nNeg += 1
else:
nPos += 1
vol2 = computeChiralVol(conf.GetAtomPosition(17),
conf.GetAtomPosition(16),
conf.GetAtomPosition(18),
conf.GetAtomPosition(19))
self.assertTrue(
abs(vol2 - expectedV2) < 1 or abs(vol2 + expectedV2) < 1)
# remove the chiral specification and we should see other chiral
# forms of the compound
expectedV1 = 2.0 #[-2.30, -2.31, -2.30, 2.30, -1.77]
expectedV2 = 2.8 #[2.90, 2.89, 2.69, -2.90, -2.93]
self.assertTrue(nPos > 0)
self.assertTrue(nNeg > 0)
for i in range(5):
smi = "C1=CC=C(C=C1)C(OC1=C[NH]N=C1)C(=O)[NH]CC(Cl)C1=CC=NC=C1"
mol = Chem.MolFromSmiles(smi)
ci = rdDistGeom.EmbedMolecule(mol, 30, (i + 1) * 10)
ff = ChemicalForceFields.UFFGetMoleculeForceField(mol, 10.0, ci)
ff.Minimize()
conf = mol.GetConformer(ci)
vol1 = computeChiralVol(conf.GetAtomPosition(6),
conf.GetAtomPosition(3),
conf.GetAtomPosition(7),
conf.GetAtomPosition(13))
vol2 = computeChiralVol(conf.GetAtomPosition(17),
conf.GetAtomPosition(16),
conf.GetAtomPosition(18),
conf.GetAtomPosition(19))
self.assertTrue(abs(abs(vol1) - expectedV1) < 1.0)
self.assertTrue(abs(abs(vol2) - expectedV2) < 1.0)
#print("({}, {}) {} < x < {}".format(i, j, bm[j, i], bm[i, j]))
if bm[i, j] < bm[j, i]:
print(
" ***** Assertion failed !! (Before smoothing) *****"
)
assert (bm[i, j] >= bm[j, i])
if DG.DoTriangleSmoothing(bm) == False:
print("Smoothing failed")
for i in range(len(bm)):
for j in range(i + 1, len(bm)):
#print("({}, {}) {} < x < {}".format(i, j, bm[j, i], bm[i, j]))
if bm[i, j] < bm[j, i]:
print(
" ***** Assertion failed !! (After smoothing) *****")
assert (bm[i, j] >= bm[j, i])
ps = rdDistGeom.EmbedParameters()
ps.useRandomCoords = True
ps.SetBoundsMat(bm)
ps.randomSeed = 0xf00d
try:
rdDistGeom.EmbedMolecule(mol, ps)
except:
print("Failed to generate coordinates")
ps = rdDistGeom.ETKDG()
ps.useRandomCoords = True
ps.randomSeed = 0xf00d
rdDistGeom.EmbedMolecule(mol, ps)
w.write(mol)
def construct_pos_matrix(mol: rdchem.Mol,
out_size: Optional[int] = -1) -> np.ndarray:
"""Construct relative positions from each atom within the molecule.
Params:
-------
mol: rdkit.Chem.rdchem.Mol
Molecule of interest.
out_size: int, optional, default=-1
The size of the returned array. If this option is negative, it
does not take any effect. Otherwise, it must be larger than or
equal to the number of atoms in the input molecule. If so, the
end of the array is padded with zeros.
Returns:
--------
pos_matrix: np.ndarray, shape=(n,n,3)
Relative position (XYZ) coordinates from one atom the others in
the mol.
Examples:
---------
```python
>>> from rdkit import Chem
>>> from rdkit.Chem import AllChem
>>> smiles = 'N[C@@]([H])([C@]([H])(O2)C)C(=O)N[C@@]([H])(CC(=O)N)C(=O)N[C@@]([H])([C@]([H])' \
'(O)C)C(=O)N[C@@]([H])(Cc1ccc(O)cc1)C(=O)2'
>>> mol = Chem.MolFromSmiles(smiles)
>>> mol = Chem.AddHs(mol, addCoords=True)
>>> AllChem.EmbedMolecule(mol, AllChem.ETKDG())
>>> mol = Chem.RemoveHs(mol)
>>> pos_matrix = construct_pos_matrix(mol, out_size=-1)
>>> pos_matrix.shape
(34,34,3)
>>> pos_matrix = construct_pos_matrix(mol, out_size=49)
>>> pos_matrix.shape
(49,49,3)
```
"""
# Obtain initial distance geometry between atoms, if unavilable
if mol.GetNumConformers() == 0:
mol = rdmolops.AddHs(mol, addCoords=True)
rdDistGeom.EmbedMolecule(mol, rdDistGeom.ETKDG())
mol = rdmolops.RemoveHs(mol)
coords = mol.GetConformer().GetPositions() # shape=(N,3)
N = mol.GetNumAtoms()
# Determine appropiate output size to generate feature matrix of same size for all mols.
if out_size < 0:
size = N
elif out_size >= N:
size = out_size
else:
raise ValueError(
'`out_size` (N={}) is smaller than number of atoms in mol (N={})'.
format(out_size, N))
pos_matrix = np.zeros(shape=(size, size, 3), dtype=np.float)
for atom_idx in range(N):
atom_pos = coords[atom_idx] # central atom of interest
for neighbor_idx in range(N):
neigh_pos = coords[neighbor_idx] # neighboring atom
pos_matrix[
atom_idx,
neighbor_idx] = atom_pos - neigh_pos # dist between neighbor -> center
return pos_matrix
parents = ','.join(
['parent="%s"' % x for x in residues.keys()])
cmd = 'SetProperty atom %s: select=on' % parents
tmp = self.doc.DoCommand(cmd)
if showSurface:
# create the surface:
self.doc.DoCommand('Surface')
obj = Displayable(self.doc)
self.displayables[name] = obj
self.doc.DoCommand('SetProperty surface id="*":RD_Visual=%d' %
obj.id)
self.doc.DoCommand('UnSelectAll')
self.SetDisplayUpdate(True)
def Redraw(self):
self.SetDisplayUpdate(True)
if __name__ == '__main__':
from rdkit import Chem
from rdkit.Chem import rdDistGeom, rdForceFieldHelpers
m = Chem.MolFromSmiles('c1cccc2c1cccc2')
rdDistGeom.EmbedMolecule(m)
rdForceFieldHelpers.UFFOptimizeMolecule(m)
s = MolViewer()
s.ShowMol(m)
def sample_mol():
mol = rdmolfiles.MolFromSmiles('CN=C=O')
mol = rdmolops.AddHs(mol, addCoords=True)
rdDistGeom.EmbedMolecule(mol, rdDistGeom.ETKDG())
return rdmolops.RemoveHs(mol)
