def save_aligned_conf_to_pdb(pdb_file, mol, conf_id=0):
"""Save mol conformer to PDB file."""
conf = mol.GetConformer(conf_id)
coords = np.array(
[conf.GetAtomPosition(i) for i in range(conf.GetNumAtoms())])
pca = sklearn.decomposition.PCA(2)
pca.fit(coords)
mean_coord = np.mean(coords, axis=0)
x = as_unit(pca.components_[0, :])
y = as_unit(pca.components_[1, :])
z = np.cross(x, y)
trans_mat = make_transform_matrix(mean_coord, y=y, z=z)
trans_coords = transform_array(trans_mat, coords)
for i in range(conf.GetNumAtoms()):
conf.SetAtomPosition(i, trans_coords[i, :])
writer = rdkit.Chem.rdmolfiles.PDBWriter(pdb_file)
writer.write(mol, conf_id)
writer.close()
# renumber atoms by atom_idx
lines = []
with open(pdb_file, "rU") as f:
lines = f.readlines()
with open(pdb_file, "w") as f:
i = 0
for line in lines:
if line.startswith("HETATM"):
elem = mol.GetAtomWithIdx(i).GetSymbol()
atom_name = (elem + "{:d} ".format(i + 1))[:4]
line = line[:13] + atom_name + line[17:]
i += 1
f.write(line)
return np.argsort(trans_coords[:, 0], )
def test_rot_matrix_vector_rotation_correct(self):
from e3fp.fingerprint.array_ops import make_rotation_matrix, \
as_unit
for i in range(2, 5):
u0 = as_unit(np.random.uniform(size=3))
u1 = as_unit(np.random.uniform(size=3))
rot = make_rotation_matrix(u0, u1)
np.testing.assert_array_almost_equal(u1, np.dot(rot, u0))
def get_disk_norm(vaxis, haxis, offset=0.):
norm = as_unit(vaxis)
rot1 = make_rotation_matrix(norm, np.array([0., 0., 1.]))
haxis2 = np.dot(rot1, haxis.reshape(3, 1)).T
rot2 = make_rotation_matrix(haxis2, np.array([1., 0., 0.]))
inv_rot = np.dot(rot2, rot1).T
ref_norm = as_unit(np.array([np.cos(offset), np.sin(offset), 0.]))
disk_norm = np.dot(inv_rot, ref_norm.reshape(3, 1)).T
return disk_norm
def test_rot_matrix_array_rotation_correct(self):
from e3fp.fingerprint.array_ops import make_rotation_matrix, \
as_unit
for i in range(1, 5):
u0 = as_unit(np.random.uniform(size=3))
arr = np.random.uniform(size=(i, 3))
v = arr[0, :]
rot = make_rotation_matrix(v, u0)
rot_arr = np.dot(rot, arr.T).T
u1 = as_unit(rot_arr[0, :])
np.testing.assert_array_almost_equal(u0.flatten(), u1.flatten())
def get_cgo_circle_obj(center,
norm,
rad,
start=None,
linespacing=0.,
color=[0., 0., 0.],
alpha=1.):
"""Get CGO parameters to create circle in PyMOL."""
if np.linalg.norm(norm - np.array([1., 0., 0.])) > 1e-7:
start = rad * as_unit(np.cross(np.array([1., 0., 0.]), norm)) + center
else:
start = rad * as_unit(np.cross(np.array([0., 1., 0.]), norm)) + center
return get_cgo_arc_obj(center, norm, start, 2 * np.pi, linespacing, color,
alpha)
def test_two_axis_transform_correct2(self):
from e3fp.fingerprint.array_ops import make_transform_matrix, \
as_unit, transform_array, \
Y_AXIS
for i in range(3, 8):
arr = np.random.uniform(size=(i, 3))
center = arr[0, :]
y = arr[1, :] - center
z = arr[2, :] - center
trans_mat = make_transform_matrix(center, y, z)
rot_arr = transform_array(trans_mat, arr)
c0 = rot_arr[0, :]
y0 = as_unit(rot_arr[1, :])
z0 = as_unit(rot_arr[2, :])
np.testing.assert_array_almost_equal(c0.flatten(), np.zeros(3))
np.testing.assert_array_almost_equal(y0.flatten(),
Y_AXIS.flatten())
self.assertAlmostEqual(z0[0], 0.)
def draw_shell_sphere(radius,
polar_cone_angle=np.pi / 36.,
axis0=np.array([0., 1., 0.]),
axis1=np.array([0., 0., 1.]),
linewidth=1,
linespacing=0.15,
alpha=0.35,
name=None):
"""Draw sphere and stereo regions at specified radius in PyMOL."""
center = np.array([0., 0., 0.], dtype=np.double)
obj = []
# draw sphere
obj.extend(
get_cgo_sphere_obj(center, radius, color=[1., 1., 1.], alpha=alpha))
cmd.load_cgo(obj, cmd.get_unused_name('sphere_{:.4f}'.format(radius)))
# draw polar circles
obj = []
obj.extend([BEGIN, LINES, COLOR] + [0., 0., 0.])
v_to_cone_center = radius * np.cos(polar_cone_angle) * axis0
cone_radius = radius * np.sin(polar_cone_angle)
obj.extend(
get_cgo_circle_obj(center + v_to_cone_center,
axis0,
cone_radius,
linespacing=linespacing))
obj.extend(
get_cgo_circle_obj(center - v_to_cone_center,
-axis0,
cone_radius,
linespacing=linespacing))
# draw equator
obj.extend(
get_cgo_circle_obj(center, axis0, radius, linespacing=linespacing))
# draw quadrant arcs
for i in (1, 3, 5, 7):
if i in (5, 7):
color = [.8, .8, .8]
else:
color = [0., 0., 0.]
disk_norm = get_disk_norm(axis0, axis1, i * np.pi / 4.)
arc_start = (cone_radius * as_unit(np.cross(disk_norm, axis0)) +
center + v_to_cone_center)
obj.extend(
get_cgo_arc_obj(center,
disk_norm,
arc_start,
np.pi - 2 * polar_cone_angle,
linespacing=linespacing,
color=color))
# draw axes
obj.append(END)
lname = cmd.get_unused_name('contours_{:.4f}'.format(radius))
cmd.load_cgo(obj, lname)
cmd.set("cgo_line_width", linewidth, lname)
def test_transform_matrix_rotation_only_correct(self):
from e3fp.fingerprint.array_ops import make_transform_matrix, \
as_unit, pad_array, \
unpad_array, Y_AXIS
for i in range(1, 5):
center = np.zeros(3, dtype=np.float)
arr = np.random.uniform(size=(i, 3)) + center
y = arr[0, :]
trans_mat = make_transform_matrix(center, y)
pad_arr = pad_array(arr)
rot_arr = unpad_array(np.dot(trans_mat, pad_arr.T).T)
y0 = as_unit(rot_arr[0, :])
np.testing.assert_array_almost_equal(y0.flatten(),
Y_AXIS.flatten())
def test_two_axis_transform_correct1(self):
from e3fp.fingerprint.array_ops import (
make_transform_matrix,
as_unit,
pad_array,
unpad_array,
Y_AXIS,
)
for i in range(3, 8):
arr = np.random.uniform(size=(i, 3))
center = arr[0, :]
y = arr[1, :] - center
z = arr[2, :] - center
trans_mat = make_transform_matrix(center, y, z)
pad_arr = pad_array(arr)
rot_arr = unpad_array(np.dot(trans_mat, pad_arr.T).T)
c0 = rot_arr[0, :]
y0 = as_unit(rot_arr[1, :])
z0 = as_unit(rot_arr[2, :])
np.testing.assert_array_almost_equal(c0.flatten(), np.zeros(3))
np.testing.assert_array_almost_equal(y0.flatten(),
Y_AXIS.flatten())
self.assertAlmostEqual(z0[0], 0.0)
def test_transform_matrix_with_translation_correct(self):
from e3fp.fingerprint.array_ops import make_transform_matrix, \
as_unit, pad_array, \
unpad_array, Y_AXIS
for i in range(2, 7):
arr = np.random.uniform(size=(i, 3))
center = arr[0, :]
y = arr[1, :] - center
trans_mat = make_transform_matrix(center, y)
pad_arr = pad_array(arr)
rot_arr = unpad_array(np.dot(trans_mat, pad_arr.T).T)
c0 = rot_arr[0, :]
y0 = as_unit(rot_arr[1, :])
np.testing.assert_array_almost_equal(c0.flatten(), np.zeros(3))
np.testing.assert_array_almost_equal(y0.flatten(),
Y_AXIS.flatten())
