def set_position_from_matrix(self, pos_mat, conformer=-1):
"""
Set atomic positions of the molecule to those in `pos_mat`.
Parameters
----------
pos_mat : :class:`numpy.ndarray`
The matrix holds the coordinates on which the atoms of the
molecule should be placed.
The shape of the matrix is ``[3, n]``. Each column of
`pos_mat` represents the coordinates of a single atom. The
1st column sets the coordinates of the atom with id of 0.
The next column sets the coordinates of the atom with id 1,
and so on.
conformer : :class:`int`, optional
The id of the conformer to be used.
Returns
-------
None : :class:`NoneType`
"""
conf = self.mol.GetConformer(conformer)
for i, coord_mat in enumerate(pos_mat.T):
coord = rdkit_geo.Point3D(coord_mat.item(0), coord_mat.item(1),
coord_mat.item(2))
conf.SetAtomPosition(i, coord)
def testPickle(self):
ffeat = ChemicalFeatures.FreeChemicalFeature(
"HBondDonor", "HBondDonor1", geom.Point3D(1.0, 2.0, 3.0), 123)
pkl = cPickle.dumps(ffeat)
ffeat2 = cPickle.loads(pkl, encoding='bytes')
self.assertTrue(ffeat2.GetId() == ffeat.GetId())
self.assertTrue(ffeat2.GetFamily() == ffeat.GetFamily())
self.assertTrue(ffeat2.GetType() == ffeat.GetType())
self.assertTrue(ptFeq(ffeat2.GetPos(), ffeat.GetPos()))
# Check that the old pickled versions have not been broken
inF = open(
os.path.join(RDConfig.RDBaseDir,
'Code/ChemicalFeatures/Wrap/testData/feat.pkl'), 'rb')
ffeat2 = cPickle.load(inF, encoding='bytes')
# this version (1.0) does not have an id in the byte stream
self.assertTrue(ffeat2.GetFamily() == ffeat.GetFamily())
self.assertTrue(ffeat2.GetType() == ffeat.GetType())
self.assertTrue(ptFeq(ffeat2.GetPos(), ffeat.GetPos()))
# Test the new version also has the id and works as expected
# uncomment the following to generate (overrwrite) new version of pickled
# data file
#cPickle.dump(ffeat,file(os.path.join(RDConfig.RDBaseDir, 'Code/ChemicalFeatures/Wrap/testData/featv2.pkl'),'wb+'))
inF = open(
os.path.join(RDConfig.RDBaseDir,
'Code/ChemicalFeatures/Wrap/testData/featv2.pkl'),
'rb')
ffeat2 = cPickle.load(inF, encoding='bytes')
self.assertTrue(ffeat2.GetId() == ffeat.GetId())
self.assertTrue(ffeat2.GetFamily() == ffeat.GetFamily())
self.assertTrue(ffeat2.GetType() == ffeat.GetType())
self.assertTrue(ptFeq(ffeat2.GetPos(), ffeat.GetPos()))
def test4GridPickles(self):
grd = geom.UniformGrid3D(10.0, 9.0, 8.0, 0.5)
self.assertTrue(grd.GetNumX() == 20)
self.assertTrue(grd.GetNumY() == 18)
self.assertTrue(grd.GetNumZ() == 16)
grd.SetSphereOccupancy(geom.Point3D(-2.0, -2.0, 0.0), 1.5, 0.25)
grd.SetSphereOccupancy(geom.Point3D(-2.0, 2.0, 0.0), 1.5, 0.25)
grd.SetSphereOccupancy(geom.Point3D(2.0, -2.0, 0.0), 1.5, 0.25)
grd.SetSphereOccupancy(geom.Point3D(2.0, 2.0, 0.0), 1.5, 0.25)
self.assertTrue(geom.TanimotoDistance(grd, grd) == 0.0)
grd2 = pickle.loads(pickle.dumps(grd))
self.assertTrue(grd2.GetNumX() == 20)
self.assertTrue(grd2.GetNumY() == 18)
self.assertTrue(grd2.GetNumZ() == 16)
self.assertTrue(geom.TanimotoDistance(grd, grd2) == 0.0)
def test3UniformGrid(self):
ugrid = geom.UniformGrid3D(20, 18, 15)
self.failUnless(ugrid.GetNumX() == 40)
self.failUnless(ugrid.GetNumY() == 36)
self.failUnless(ugrid.GetNumZ() == 30)
dvect = ugrid.GetOccupancyVect()
ugrid = geom.UniformGrid3D(20, 18, 15, 0.5,
DataStructs.DiscreteValueType.TWOBITVALUE)
dvect = ugrid.GetOccupancyVect()
self.failUnless(
dvect.GetValueType() == DataStructs.DiscreteValueType.TWOBITVALUE)
grd = geom.UniformGrid3D(10.0, 10.0, 10.0, 0.5)
grd.SetSphereOccupancy(geom.Point3D(-2.0, -2.0, 0.0), 1.5, 0.25)
grd.SetSphereOccupancy(geom.Point3D(-2.0, 2.0, 0.0), 1.5, 0.25)
grd.SetSphereOccupancy(geom.Point3D(2.0, -2.0, 0.0), 1.5, 0.25)
grd.SetSphereOccupancy(geom.Point3D(2.0, 2.0, 0.0), 1.5, 0.25)
geom.WriteGridToFile(grd, "junk.grd")
grd2 = geom.UniformGrid3D(10.0, 10.0, 10.0, 0.5)
grd2.SetSphereOccupancy(geom.Point3D(-2.0, -2.0, 0.0), 1.5, 0.25)
grd2.SetSphereOccupancy(geom.Point3D(-2.0, 2.0, 0.0), 1.5, 0.25)
grd2.SetSphereOccupancy(geom.Point3D(2.0, -2.0, 0.0), 1.5, 0.25)
dist = geom.TanimotoDistance(grd, grd2)
self.failUnless(dist == 0.25)
dist = geom.ProtrudeDistance(grd, grd2)
self.failUnless(dist == 0.25)
dist = geom.ProtrudeDistance(grd2, grd)
self.failUnless(dist == 0.0)
grd2 = geom.UniformGrid3D(10.0, 10.0, 10.0, 0.5,
DataStructs.DiscreteValueType.FOURBITVALUE)
grd2.SetSphereOccupancy(geom.Point3D(-2.0, -2.0, 0.0), 1.5, 0.25, 3)
grd2.SetSphereOccupancy(geom.Point3D(-2.0, 2.0, 0.0), 1.5, 0.25, 3)
grd2.SetSphereOccupancy(geom.Point3D(2.0, -2.0, 0.0), 1.5, 0.25, 3)
self.failUnlessRaises(ValueError,
lambda: geom.TanimotoDistance(grd, grd2))
grd2 = geom.UniformGrid3D(10.0, 10.0, 10.0, 1.0)
self.failUnlessRaises(ValueError,
lambda: geom.TanimotoDistance(grd, grd2))
grd2 = geom.UniformGrid3D(11.0, 10.0, 10.0, 1.0)
self.failUnlessRaises(ValueError,
lambda: geom.TanimotoDistance(grd, grd2))
def testBasic(self):
ffeat = ChemicalFeatures.FreeChemicalFeature()
ffeat.SetId(123)
pos = ffeat.GetId()
self.assertTrue(pos == 123)
ffeat.SetFamily("HBondDonor")
self.assertTrue(ffeat.GetFamily() == "HBondDonor")
ffeat.SetPos(geom.Point3D(1.0, 2.0, 3.0))
pos = ffeat.GetPos()
self.assertTrue(ptFeq(pos, geom.Point3D(1.0, 2.0, 3.0)))
ffeat.SetType("HBondDonor1")
self.assertTrue(ffeat.GetType() == "HBondDonor1")
ffeat = ChemicalFeatures.FreeChemicalFeature("HBondDonor", "HBondDonor1", geom.Point3D(1.0, 2.0,
3.0))
self.assertTrue(ffeat.GetId() == -1)
self.assertTrue(ffeat.GetFamily() == "HBondDonor")
self.assertTrue(ffeat.GetType() == "HBondDonor1")
ffeat = ChemicalFeatures.FreeChemicalFeature("HBondDonor", "HBondDonor1",
geom.Point3D(1.0, 2.0, 3.0), id=123)
self.assertTrue(ffeat.GetId() == 123)
self.assertTrue(ffeat.GetFamily() == "HBondDonor")
self.assertTrue(ffeat.GetType() == "HBondDonor1")
pos = ffeat.GetPos()
self.assertTrue(ptFeq(pos, geom.Point3D(1.0, 2.0, 3.0)))
ffeat = ChemicalFeatures.FreeChemicalFeature(id=123, type="HBondDonor1", family="HBondDonor",
loc=geom.Point3D(1.0, 2.0, 3.0))
self.assertTrue(ffeat.GetId() == 123)
self.assertTrue(ffeat.GetFamily() == "HBondDonor")
self.assertTrue(ffeat.GetType() == "HBondDonor1")
pos = ffeat.GetPos()
self.assertTrue(ptFeq(pos, geom.Point3D(1.0, 2.0, 3.0)))
def def_point(x, y, z):
"""Define a 3D point in RDKIT
"""
point = rdGeometry.Point3D()
point.x = x
point.y = y
point.z = z
return point
def testPointPickles(self):
pt = geom.Point3D(2.0, -3.0, 1.0)
pt2 = cPickle.loads(cPickle.dumps(pt))
self.failUnless(feq(pt.x, pt2.x, 1e-6))
self.failUnless(feq(pt.y, pt2.y, 1e-6))
self.failUnless(feq(pt.z, pt2.z, 1e-6))
pt = geom.Point2D(2.0, -4.0)
pt2 = cPickle.loads(cPickle.dumps(pt))
self.failUnless(feq(pt.x, pt2.x, 1e-6))
self.failUnless(feq(pt.y, pt2.y, 1e-6))
def testPointPickles(self):
pt = geom.Point3D(2.0, -3.0, 1.0)
pt2 = pickle.loads(pickle.dumps(pt))
self.assertTrue(feq(pt.x, pt2.x, 1e-6))
self.assertTrue(feq(pt.y, pt2.y, 1e-6))
self.assertTrue(feq(pt.z, pt2.z, 1e-6))
pt = geom.Point2D(2.0, -4.0)
pt2 = pickle.loads(pickle.dumps(pt))
self.assertTrue(feq(pt.x, pt2.x, 1e-6))
self.assertTrue(feq(pt.y, pt2.y, 1e-6))
def testSymmetry(self):
grd = geom.UniformGrid3D(10.0, 10.0, 10.0, 0.5)
grd.SetSphereOccupancy(geom.Point3D(-2.2, -2.0, 0.0), 1.65, 0.25)
grd.SetSphereOccupancy(geom.Point3D(2.2, -2.0, 0.0), 1.65, 0.25)
bPt1 = geom.Point3D(-4.0, -2.0, -2.0)
bPt2 = geom.Point3D(4.0, -2.0, -2.0)
for k in range(8):
bPt1 += geom.Point3D(0.0, 0.0, 0.5)
bPt2 += geom.Point3D(0.0, 0.0, 0.5)
for j in range(8):
bPt1 += geom.Point3D(0.0, 0.5, 0.0)
bPt2 += geom.Point3D(0.0, 0.5, 0.0)
for i in range(8):
bPt1 += geom.Point3D(0.5, 0.0, 0.0)
bPt2 -= geom.Point3D(0.5, 0.0, 0.0)
self.assertTrue(grd.GetValPoint(bPt1) == grd.GetValPoint(bPt2))
bPt1.x = -4.0
bPt2.x = 4.0
bPt1.y = -2.0
bPt2.y = -2.0
def result(self, del_atoms):
"""
Creates the molecule after all reactions have been done.
This method will also update all the functional groups
passed with :meth:`react` calls. It will update the atom
ids to account for the fact that atoms have been deleted.
Parameters
----------
del_atoms : :class:`bool`
Toggles if deleter atoms should be removed from the
product molecule.
Returns
-------
:class:`rdkit.Mol`
The product molecule.
"""
# If new atoms were added, update the positions in the
# conformer.
if self.new_atom_coords:
self.mol = self.emol.GetMol()
conf = self.mol.GetConformer()
for atom_id, coord in self.new_atom_coords:
point3d = rdkit_geo.Point3D(*coord)
conf.SetAtomPosition(atom_id, point3d)
self.emol = rdkit.EditableMol(self.mol)
if del_atoms:
# Needs to be sorted for fg.remove_deleters.
deleters = sorted(self.deleters)
# Go in reverse order else atom ids change during loop.
for atom_id in reversed(deleters):
self.emol.RemoveAtom(atom_id)
# Update all the functional groups to account for the fact
# that atoms have been removed.
for fg in self.func_groups:
fg.remove_deleters(deleters)
return self.emol.GetMol()
def test1Canonicalization(self):
mol = Chem.MolFromSmiles("C")
conf = Chem.Conformer(1)
conf.SetAtomPosition(0, (4.0, 5.0, 6.0))
mol.AddConformer(conf, 1)
conf = mol.GetConformer()
pt = rdmt.ComputeCentroid(conf)
self.failUnless(ptEq(pt, geom.Point3D(4.0, 5.0, 6.0)))
fileN = os.path.join(RDConfig.RDBaseDir, 'Code', 'GraphMol',
'MolTransforms', 'test_data', '1oir.mol')
m = Chem.MolFromMolFile(fileN)
cpt = rdmt.ComputeCentroid(m.GetConformer())
trans = rdmt.ComputeCanonicalTransform(m.GetConformer(), cpt)
trans2 = rdmt.ComputeCanonicalTransform(m.GetConformer())
for i in range(4):
for j in range(4):
self.failUnless(feq(trans[i, j], trans2[i, j]))
rdmt.TransformConformer(m.GetConformer(), trans2)
m2 = Chem.MolFromMolFile(fileN)
rdmt.CanonicalizeConformer(m2.GetConformer())
nats = m.GetNumAtoms()
cnf1 = m.GetConformer()
cnf2 = m2.GetConformer()
for i in range(nats):
p1 = list(cnf1.GetAtomPosition(i))
p2 = list(cnf2.GetAtomPosition(i))
self.failUnless(feq(p1[0], p2[0]))
self.failUnless(feq(p1[1], p2[1]))
self.failUnless(feq(p1[2], p2[2]))
m3 = Chem.MolFromMolFile(fileN)
rdmt.CanonicalizeMol(m3)
cnf1 = m.GetConformer()
cnf2 = m3.GetConformer()
for i in range(nats):
p1 = list(cnf1.GetAtomPosition(i))
p2 = list(cnf2.GetAtomPosition(i))
self.failUnless(feq(p1[0], p2[0]))
self.failUnless(feq(p1[1], p2[1]))
self.failUnless(feq(p1[2], p2[2]))
def test5GridOps(self):
grd = geom.UniformGrid3D(10, 10, 10)
grd.SetSphereOccupancy(geom.Point3D(-2.0, -2.0, 0.0), 1.0, 0.25)
grd.SetSphereOccupancy(geom.Point3D(-2.0, 2.0, 0.0), 1.0, 0.25)
grd2 = geom.UniformGrid3D(10, 10, 10)
grd2.SetSphereOccupancy(geom.Point3D(2.0, -2.0, 0.0), 1.0, 0.25)
grd2.SetSphereOccupancy(geom.Point3D(2.0, 2.0, 0.0), 1.0, 0.25)
self.assertTrue(geom.TanimotoDistance(grd, grd) == 0.0)
self.assertTrue(geom.TanimotoDistance(grd, grd2) == 1.0)
grd3 = copy.deepcopy(grd)
grd3 |= grd2
self.assertTrue(geom.TanimotoDistance(grd3, grd) == .5)
self.assertTrue(geom.TanimotoDistance(grd3, grd2) == .5)
grd3 = copy.deepcopy(grd)
grd3 += grd2
self.assertTrue(geom.TanimotoDistance(grd3, grd) == .5)
self.assertTrue(geom.TanimotoDistance(grd3, grd2) == .5)
grd3 -= grd
self.assertTrue(geom.TanimotoDistance(grd3, grd) == 1.0)
self.assertTrue(geom.TanimotoDistance(grd3, grd2) == 0)
grd4 = geom.UniformGrid3D(10, 10, 10)
grd4.SetSphereOccupancy(geom.Point3D(-2.0, -2.0, 0.0), 1.0, 0.25)
grd4.SetSphereOccupancy(geom.Point3D(-2.0, 2.0, 0.0), 1.0, 0.25)
grd4.SetSphereOccupancy(geom.Point3D(2.0, -2.0, 0.0), 1.0, 0.25)
self.assertTrue(feq(geom.TanimotoDistance(grd4, grd), .3333))
self.assertTrue(feq(geom.TanimotoDistance(grd4, grd2), .75))
grd4 &= grd2
self.assertTrue(feq(geom.TanimotoDistance(grd4, grd), 1.0))
self.assertTrue(feq(geom.TanimotoDistance(grd4, grd2), .5))
def test6Dihedrals(self):
p1 = geom.Point3D(1, 0, 0)
p2 = geom.Point3D(0, 0, 0)
p3 = geom.Point3D(0, 1, 0)
p4 = geom.Point3D(.5, 1, .5)
ang = geom.ComputeDihedralAngle(p1, p2, p3, p4)
self.assertAlmostEqual(ang, math.pi / 4, 4)
ang = geom.ComputeSignedDihedralAngle(p1, p2, p3, p4)
self.assertAlmostEqual(ang, -math.pi / 4, 4)
p4 = geom.Point3D(-.5, 1, .5)
ang = geom.ComputeDihedralAngle(p1, p2, p3, p4)
self.assertAlmostEqual(ang, 3 * math.pi / 4, 4)
ang = geom.ComputeSignedDihedralAngle(p1, p2, p3, p4)
self.assertAlmostEqual(ang, -3 * math.pi / 4, 4)
p4 = geom.Point3D(.5, 1, -.5)
ang = geom.ComputeDihedralAngle(p1, p2, p3, p4)
self.assertAlmostEqual(ang, math.pi / 4, 4)
ang = geom.ComputeSignedDihedralAngle(p1, p2, p3, p4)
self.assertAlmostEqual(ang, math.pi / 4, 4)
p4 = geom.Point3D(-.5, 1, -.5)
ang = geom.ComputeDihedralAngle(p1, p2, p3, p4)
self.assertAlmostEqual(ang, 3 * math.pi / 4, 4)
ang = geom.ComputeSignedDihedralAngle(p1, p2, p3, p4)
self.assertAlmostEqual(ang, 3 * math.pi / 4, 4)
p4 = geom.Point3D(0, 1, 1)
ang = geom.ComputeDihedralAngle(p1, p2, p3, p4)
self.assertAlmostEqual(ang, math.pi / 2, 4)
ang = geom.ComputeSignedDihedralAngle(p1, p2, p3, p4)
self.assertAlmostEqual(ang, -math.pi / 2, 4)
p4 = geom.Point3D(0, 1, -1)
ang = geom.ComputeDihedralAngle(p1, p2, p3, p4)
self.assertAlmostEqual(ang, math.pi / 2, 4)
ang = geom.ComputeSignedDihedralAngle(p1, p2, p3, p4)
self.assertAlmostEqual(ang, math.pi / 2, 4)
p4 = geom.Point3D(1, 1, 0)
ang = geom.ComputeDihedralAngle(p1, p2, p3, p4)
self.assertAlmostEqual(ang, 0, 4)
ang = geom.ComputeSignedDihedralAngle(p1, p2, p3, p4)
self.assertAlmostEqual(ang, 0, 4)
p4 = geom.Point3D(-1, 1, 0)
ang = geom.ComputeDihedralAngle(p1, p2, p3, p4)
self.assertAlmostEqual(ang, math.pi, 4)
ang = geom.ComputeSignedDihedralAngle(p1, p2, p3, p4)
self.assertAlmostEqual(ang, math.pi, 4)
def amine3_with_amine3(mol, del_atoms, fg1, fg2):
"""
Crates bonds between functional groups.
Parameters
----------
mol : :class:`rdkit.Chem.rdchem.Mol`
A molecule being assembled.
del : :class:`bool`
Toggles if atoms with the ``'del'`` property are deleted.
fg1 : :class:`int`
The id of the first functional group which
is to be joined, as given by the 'fg_id' property.
fg2 : :class:`int`
The id of the second functional group which
is to be joined, as given by the 'fg_id' property.
Returns
-------
:class:`tuple`
The first element is an :class:`rdkit.Chem.rdchem.Mol`. It is
the molecule with bonds added between the functional groups.
The second element is a :class:`int`. It is the number
of bonds added.
"""
fgs = {fg1, fg2}
atoms1, atoms2 = {}, {}
deleters = []
for a in mol.GetAtoms():
if not a.HasProp('fg_id') or a.GetIntProp('fg_id') not in fgs:
continue
if a.HasProp('bonder') and a.GetIntProp('fg_id') == fg1:
atoms1[a.GetSymbol()] = a.GetIdx()
if a.HasProp('bonder') and a.GetIntProp('fg_id') == fg2:
atoms2[a.GetSymbol()] = a.GetIdx()
if a.HasProp('del'):
deleters.append(a.GetIdx())
conf = mol.GetConformer()
n1_pos = np.array([*conf.GetAtomPosition(atoms1['N'])])
n2_pos = np.array([*conf.GetAtomPosition(atoms2['N'])])
c1_pos = np.array([*conf.GetAtomPosition(atoms1['C'])])
c2_pos = np.array([*conf.GetAtomPosition(atoms2['C'])])
emol = rdkit.EditableMol(mol)
n_joiner = emol.AddAtom(rdkit.Atom(6))
n_joiner_pos = (n1_pos + n2_pos) / 2
nh1 = emol.AddAtom(rdkit.Atom(1))
nh1_pos = n_joiner_pos + np.array([0, 0, 1])
nh2 = emol.AddAtom(rdkit.Atom(1))
nh2_pos = n_joiner_pos + np.array([0, 0, -1])
nc_joiner1 = emol.AddAtom(rdkit.Atom(6))
nc_joiner1_pos = (c1_pos + n2_pos) / 2
nc1h1 = emol.AddAtom(rdkit.Atom(1))
nc1h1_pos = nc_joiner1_pos + np.array([0, 0, 1])
nc1h2 = emol.AddAtom(rdkit.Atom(1))
nc1h2_pos = nc_joiner1_pos + np.array([0, 0, -1])
nc_joiner2 = emol.AddAtom(rdkit.Atom(6))
nc_joiner2_pos = (c2_pos + n1_pos) / 2
nc2h1 = emol.AddAtom(rdkit.Atom(1))
nc2h1_pos = nc_joiner2_pos + np.array([0, 0, 1])
nc2h2 = emol.AddAtom(rdkit.Atom(1))
nc2h2_pos = nc_joiner2_pos + np.array([0, 0, -1])
single = rdkit.rdchem.BondType.SINGLE
emol.AddBond(atoms1['N'], n_joiner, single)
emol.AddBond(atoms2['N'], n_joiner, single)
emol.AddBond(n_joiner, nh1, single)
emol.AddBond(n_joiner, nh2, single)
emol.AddBond(atoms1['C'], nc_joiner1, single)
emol.AddBond(atoms2['N'], nc_joiner1, single)
emol.AddBond(nc_joiner1, nc1h1, single)
emol.AddBond(nc_joiner1, nc1h2, single)
emol.AddBond(atoms2['C'], nc_joiner2, single)
emol.AddBond(atoms1['N'], nc_joiner2, single)
emol.AddBond(nc_joiner2, nc2h1, single)
emol.AddBond(nc_joiner2, nc2h2, single)
mol = emol.GetMol()
conf = mol.GetConformer()
conf.SetAtomPosition(n_joiner, rdkit_geo.Point3D(*n_joiner_pos))
conf.SetAtomPosition(nh1, rdkit_geo.Point3D(*nh1_pos))
conf.SetAtomPosition(nh2, rdkit_geo.Point3D(*nh2_pos))
conf.SetAtomPosition(nc_joiner1, rdkit_geo.Point3D(*nc_joiner1_pos))
conf.SetAtomPosition(nc1h1, rdkit_geo.Point3D(*nc1h1_pos))
conf.SetAtomPosition(nc1h2, rdkit_geo.Point3D(*nc1h2_pos))
conf.SetAtomPosition(nc_joiner2, rdkit_geo.Point3D(*nc_joiner2_pos))
conf.SetAtomPosition(nc2h1, rdkit_geo.Point3D(*nc2h1_pos))
conf.SetAtomPosition(nc2h2, rdkit_geo.Point3D(*nc2h2_pos))
if del_atoms:
emol = rdkit.EditableMol(mol)
for a in reversed(deleters):
emol.RemoveAtom(a)
mol = emol.GetMol()
return mol, 6
def test1aPoint3D(self):
pt = geom.Point3D()
self.assertTrue(feq(pt.x, 0.0))
self.assertTrue(feq(pt.y, 0.0))
self.assertTrue(feq(pt.z, 0.0))
pt = geom.Point3D(3., 4., 5.)
self.assertTrue(feq(pt.x, 3.0))
self.assertTrue(feq(pt.y, 4.0))
self.assertTrue(feq(pt.z, 5.0))
self.assertTrue(feq(pt[0], 3.0))
self.assertTrue(feq(pt[1], 4.0))
self.assertTrue(feq(pt[2], 5.0))
self.assertTrue(feq(pt[-3], 3.0))
self.assertTrue(feq(pt[-2], 4.0))
self.assertTrue(feq(pt[-1], 5.0))
lst = list(pt)
self.assertTrue(feq(lst[0], 3.0))
self.assertTrue(feq(lst[1], 4.0))
self.assertTrue(feq(lst[2], 5.0))
pt2 = geom.Point3D(1., 1., 1.)
pt3 = pt + pt2
self.assertTrue(feq(pt3.x, 4.0))
self.assertTrue(feq(pt3.y, 5.0))
self.assertTrue(feq(pt3.z, 6.0))
pt += pt2
self.assertTrue(feq(pt.x, 4.0))
self.assertTrue(feq(pt.y, 5.0))
self.assertTrue(feq(pt.z, 6.0))
pt3 = pt - pt2
self.assertTrue(feq(pt3.x, 3.0))
self.assertTrue(feq(pt3.y, 4.0))
self.assertTrue(feq(pt3.z, 5.0))
pt -= pt2
self.assertTrue(feq(pt.x, 3.0))
self.assertTrue(feq(pt.y, 4.0))
self.assertTrue(feq(pt.z, 5.0))
pt *= 2.0
self.assertTrue(feq(pt.x, 6.0))
self.assertTrue(feq(pt.y, 8.0))
self.assertTrue(feq(pt.z, 10.0))
pt /= 2
self.assertTrue(feq(pt.x, 3.0))
self.assertTrue(feq(pt.y, 4.0))
self.assertTrue(feq(pt.z, 5.0))
self.assertTrue(feq(pt.Length(), 7.0711))
self.assertTrue(feq(pt.LengthSq(), 50.0))
pt.Normalize()
self.assertTrue(feq(pt.Length(), 1.0))
pt1 = geom.Point3D(1.0, 0.0, 0.0)
pt2 = geom.Point3D(2.0 * math.cos(math.pi / 6),
2.0 * math.sin(math.pi / 6), 0.0)
ang = pt1.AngleTo(pt2)
self.assertTrue(feq(ang, math.pi / 6))
prod = pt1.DotProduct(pt2)
self.assertTrue(feq(prod, 2.0 * math.cos(math.pi / 6)))
pt3 = pt1.CrossProduct(pt2)
self.assertTrue(feq(pt3.x, 0.0))
self.assertTrue(feq(pt3.y, 0.0))
self.assertTrue(feq(pt3.z, 1.0))
def test1Shape(self):
fileN = os.path.join(RDConfig.RDBaseDir, 'Code', 'GraphMol',
'ShapeHelpers', 'test_data', '1oir.mol')
m = Chem.MolFromMolFile(fileN)
rdmt.CanonicalizeMol(m)
dims1, offset1 = rdshp.ComputeConfDimsAndOffset(m.GetConformer())
grd = geom.UniformGrid3D(30.0, 16.0, 10.0)
rdshp.EncodeShape(m, grd, 0)
ovect = grd.GetOccupancyVect()
self.failUnless(ovect.GetTotalVal() == 9250)
m = Chem.MolFromMolFile(fileN)
trans = rdmt.ComputeCanonicalTransform(m.GetConformer())
dims, offset = rdshp.ComputeConfDimsAndOffset(m.GetConformer(),
trans=trans)
dims -= dims1
offset -= offset1
self.failUnless(feq(dims.Length(), 0.0))
self.failUnless(feq(offset.Length(), 0.0))
grd1 = geom.UniformGrid3D(30.0, 16.0, 10.0)
rdshp.EncodeShape(m, grd1, 0, trans)
ovect = grd1.GetOccupancyVect()
self.failUnless(ovect.GetTotalVal() == 9250)
grd2 = geom.UniformGrid3D(30.0, 16.0, 10.0)
rdshp.EncodeShape(m, grd2, 0)
fileN2 = os.path.join(RDConfig.RDBaseDir, 'Code', 'GraphMol',
'ShapeHelpers', 'test_data', '1oir_conf.mol')
m2 = Chem.MolFromMolFile(fileN2)
rmsd = rdMolAlign.AlignMol(m, m2)
self.failUnless(feq(rdshp.ShapeTanimotoDist(m, m2), 0.2813))
dist = rdshp.ShapeTanimotoDist(mol1=m,
mol2=m2,
confId1=0,
confId2=0,
gridSpacing=0.25,
stepSize=0.125)
self.failUnless(feq(dist, 0.3021))
m = Chem.MolFromMolFile(fileN)
cpt = rdmt.ComputeCentroid(m.GetConformer())
dims, offset = rdshp.ComputeConfDimsAndOffset(m.GetConformer())
grd = geom.UniformGrid3D(dims.x, dims.y, dims.z, 0.5,
DataStructs.DiscreteValueType.TWOBITVALUE,
offset)
dims -= geom.Point3D(13.927, 16.97, 9.775)
offset -= geom.Point3D(-4.353, 16.829, 2.782)
self.failUnless(feq(dims.Length(), 0.0))
self.failUnless(feq(offset.Length(), 0.0))
rdshp.EncodeShape(m, grd, 0)
ovect = grd.GetOccupancyVect()
self.failUnless(ovect.GetTotalVal() == 9275)
geom.WriteGridToFile(grd, '1oir_shape.grd')
m = Chem.MolFromMolFile(fileN)
lc, uc = rdshp.ComputeConfBox(m.GetConformer())
rdmt.CanonicalizeMol(m)
lc1, uc1 = rdshp.ComputeConfBox(m.GetConformer())
lc2, uc2 = rdshp.ComputeUnionBox((lc, uc), (lc1, uc1))
lc -= geom.Point3D(-4.353, 16.829, 2.782)
uc -= geom.Point3D(9.574, 33.799, 12.557)
self.failUnless(feq(lc.Length(), 0.0))
self.failUnless(feq(uc.Length(), 0.0))
lc1 -= geom.Point3D(-10.7519, -6.0778, -3.0123)
uc1 -= geom.Point3D(8.7163, 5.3279, 3.1621)
self.failUnless(feq(lc1.Length(), 0.0))
self.failUnless(feq(uc1.Length(), 0.0))
lc2 -= geom.Point3D(-10.7519, -6.0778, -3.01226)
uc2 -= geom.Point3D(9.574, 33.799, 12.557)
self.failUnless(feq(lc2.Length(), 0.0))
self.failUnless(feq(uc2.Length(), 0.0))
def test8InitPoint2DFromPoint3D(self):
p3 = geom.Point3D(1., 2., 3.)
p2 = geom.Point2D(p3)
self.assertEqual(p2.x, p3.x)
self.assertEqual(p2.y, p3.y)
def shift(self, shift, conformer=-1):
"""
Shifts the coordinates of all atoms.
This does not modify the molecule. A modified copy is returned.
Parameters
----------
shift : :class:`numpy.ndarray`
A numpy array holding the value of the shift along each
axis.
conformer : :class:`int`, optional
The id of the conformer to use.
Returns
-------
:class:`rdkit.Mol`
A copy of the molecule where the coordinates have been
shifted by `shift`.
"""
# The function does not modify the existing conformer, as a
# result a new instance is created and used for modification.
conf = rdkit.Conformer(self.mol.GetConformer(conformer))
# For each atom, get the atomic positions from the conformer
# and shift them. Create a new geometry instance from these new
# coordinate values. The geometry instance is used by rdkit to
# store the coordinates of atoms. Finally, set the conformers
# atomic position to the values stored in this newly generated
# geometry instance.
for atom in self.mol.GetAtoms():
# Remember the id of the atom you are currently using. It
# is used to change the position of the correct atom at the
# end of the loop.
atom_id = atom.GetIdx()
# `atom_position` in an instance holding in the x, y and z
# coordinates of an atom in its 'x', 'y' and 'z'
# attributes.
atom_position = np.array(conf.GetAtomPosition(atom_id))
# Inducing the shift.
new_atom_position = atom_position + shift
# Creating a new geometry instance.
new_coords = rdkit_geo.Point3D(*new_atom_position)
# Changes the position of the atom in the conformer to the
# values stored in the new geometry instance.
conf.SetAtomPosition(atom_id, new_coords)
# Create a new copy of the rdkit molecule instance representing
# the molecule - the original instance is not to be modified.
new_mol = rdkit.Mol(self.mol)
# The new rdkit molecule was copied from the one held in the
# `mol` attribute, as result it has a copy of its conformer. To
# prevent the rdkit molecule from holding multiple conformers
# the `RemoveAllConformers` method is run first. The shifted
# conformer is then given to the rdkit molecule, which is
# returned.
new_mol.RemoveAllConformers()
new_mol.AddConformer(conf)
return new_mol
