def normalize_pts(pts1, pts2):
#print pts1
A = pts1[:, 0:2]
B = pts2[:, 0:2]
assert len(A) == len(B)
N = A.shape[0] # total points
# find centroids
centroid_A = rmsd.centroid(A)
centroid_B = rmsd.centroid(B)
# centre the points
AA = A - centroid_A
BB = B - centroid_B
#get optimal rotation matrix
R = rmsd.kabsch(AA, BB)
# Apply transformation
AA1 = np.dot(AA, R)
angle1 = math.atan2(R[1][0], R[1][1])
#try flippin' it
AA[:, 1] *= -1
#get optimal rotation matrix
R = rmsd.kabsch(AA, BB)
# Apply transformation
AA2 = np.dot(AA, R)#get optimal rotation matrix
angle2 = math.atan2(R[1][0], R[1][1])
#go with whichever one is better
a2diff = np.abs(pts2[:,2]-(pts1[:,2]-angle2))
a1diff = np.abs(pts2[:,2]-(pts1[:,2]+angle1))
#angle differences are fun!
for i in range(0, len(a1diff)):
while (a2diff[i] > np.pi):
a2diff[i] -= 2*np.pi
while (a1diff[i] > np.pi):
a1diff[i] -= 2*np.pi
print np.degrees(a2diff), np.degrees(a1diff)
if (np.sum(np.abs(a1diff)) > np.sum(np.abs(a2diff))):
pts1[:, 0:2] = AA2 + centroid_B
# rotate the rotations (backwards, since we mirrored the thing)
pts1[:, 2] -= angle2
return rmsd.rmsd(AA2, BB)
else:
pts1[:, 0:2] = AA1 + centroid_B
# rotate the rotations
pts1[:, 2] += angle1
return rmsd.rmsd(AA1, BB)
def rmsd_distance(atoms_list,
coordinates_list,
translation=False,
rotation=False):
N = len(atoms_list)
kernel = np.zeros((N, N))
# Lower triangular
for i in range(N):
for j in range(i):
coord_i = coordinates_list[i]
coord_j = coordinates_list[j]
# unique pairs
if translation:
coord_i = coord_i - rmsd.centroid(coord_i)
coord_j = coord_j - rmsd.centroid(coord_j)
if rotation:
kernel[i, j] = rmsd.kabsch_rmsd(coord_i, coord_j)
else:
kernel[i, j] = rmsd.rmsd(coord_i, coord_j)
kernel[j, i] = kernel[i, j]
# np.fill_diagonal(kernel, 0.0)
# iu2 = np.triu_indices(N, 1)
# il2 = np.tril_indices(N, -1)
# kernel[iu2] = kernel[il2]
return kernel
def compute_similarity(site_a, site_b):
"""
Compute the similarity between two given ActiveSite instances.
Input: two ActiveSite instances
Output: the similarity between them (a floating point number)
"""
site_a_coords = []
#unpack the ActiveSite class to extract the atom coords of interest
for i in range(0, len(site_a.residues)): #loop through all residues
for j in range(
0, len(site_a.residues[i].atoms)
): #I chose to loop through all atoms instead of the backbone atoms because all atoms improved the shilhouette mean score
a = site_a.residues[i].atoms[j].coords
site_a_coords.append(a)
site_b_coords = []
#unpack the site_b and save the coords
for i in range(0, len(site_b.residues)):
for j in range(0, len(site_b.residues[i].atoms)):
b = site_b.residues[i].atoms[j].coords
site_b_coords.append(b)
#compute the Root-mean-square deviation
#low RMSD values (close to 0) are similar structures, compared to higher RMSD values (>>1) are dissimilar
#RMSD values are never negative
#Generally, the RMSD calculation is the square root of the standard deviation
#in atomic structures, the RMSD calculation is the square root of the distance between two atoms with x,y,z coords
#the package implemented here performs rotations to find the lowest RMSD
similarity = rmsd.rmsd(site_a_coords, site_b_coords)
return similarity
def test_network(nwtype, restrplt):
pdb = path.join(curdir, "data", "networks", "%s.pdb" % (restrplt))
pose = next(privileged_residues.util.models_from_pdb(pdb))
selector = pyrosetta.rosetta.core.select.residue_selector.ChainSelector(
"A")
pres = privileged_residues.PrivilegedResidues()
ref_sel = pyrosetta.rosetta.core.select.residue_selector.ChainSelector("X")
selected = ref_sel.apply(pose)
ref_res = pose.residue(list(selected).index(True))
ref_coords = np.stack([
ref_res.atom(n).xyz()
for n in chemical.functional_groups[ref_res.name()].atoms
])
min_rmsd = 1000.
for (hash, p) in pres.search(pose, [nwtype], selector):
res = p.residue(1)
coords = np.stack([
res.atom(n).xyz()
for n in chemical.functional_groups[res.name()].atoms
])
RMSD = rmsd(ref_coords, coords)
if (RMSD < min_rmsd):
min_rmsd = RMSD
if (RMSD < 0.25):
return
print("Minimum RMSD across matched structures: %.3f" % min_rmsd)
assert (False)
def get_mappings(ref, structure):
n = len(structure)
cs = itertools.permutations(range(n), 3)
keeps = {}
for c in cs:
Q = rmsd.kabsch(ref[:3], structure[list(c)]).T
assert np.linalg.det(Q) > 0.5
rotated = np.dot(structure, Q.T)
ds = scipy.spatial.distance.cdist(rotated, ref)
_, res = scipy.optimize.linear_sum_assignment(ds)
res = invert_array(res)
obj = rmsd.rmsd(rotated[res], structure)
if obj > 1E-3:
continue
key = tuple(res)
if key not in keeps:
keeps[key] = Q
return keeps
def test_pdb(example_path="examples", threshold=0.001):
"""
A simple test for the PDB functionality
:return: True if all test passed
"""
p_atoms, P = rmsd.get_coordinates(example_path+'/ci2_1.pdb', 'pdb')
q_atoms, Q = rmsd.get_coordinates(example_path+'/ci2_2.pdb', 'pdb')
n_rmsd = rmsd.rmsd(P, Q)
Pc = rmsd.centroid(P)
Qc = rmsd.centroid(Q)
P -= Pc
Q -= Qc
k_rmsd = rmsd.kabsch_rmsd(P, Q)
q_rmsd = rmsd.quaternion_rmsd(P, Q)
if abs(n_rmsd - 26.975) > threshold:
print('Failed to calculate normal RMSD, result: {0}'.format(n_rmsd))
return False
if abs(k_rmsd - 11.777) > threshold:
print('Failed to calculate Kabsch RMSD, result: {0}'.format(k_rmsd))
return False
if abs(q_rmsd - 11.777) > threshold:
print('Failed to calculate quaternion RMSD, result: {0}'.format(q_rmsd))
return False
if abs(q_rmsd - k_rmsd) > threshold ** 2:
print('Failed to yield similar Kabsch and quaternion RMSD, result: {0} vs {1}'.format(k_rmsd, q_rmsd))
return False
return True
def rms(config, compare: Tuple[str, str], out: click.File):
"""Calculate the root mean squared deviation between two structures using quaternions.
Based on a Fortran implementation by Chaok Seok, Evangelos
Coutsias, and Ken Dill."""
from rmsd import rmsd
mol1 = ksr.constructMolecule(geometry=compare[0])
nat1 = mol1.get_number_of_atoms()
mol2 = ksr.constructMolecule(geometry=compare[1])
nat2 = mol2.get_number_of_atoms()
# for RMSD comparison both coordinates need the same atom count
if nat1 != nat2:
click.echo(
"Error: number of atoms do not match in {} and in {}".format(
compare[0], compare[1]
),
file=out, # type: ignore
)
errorbye(out)
coord1 = mol1.get_positions()
coord2 = mol2.get_positions()
# get RMSD error and rotation matrix u
error, u = rmsd(nat1, coord1, coord2)
verbosePrinter(config.verbose, "RMSD {} Angstrom".format(error), out)
verbosePrinter(config.verbose, "Rotation Matrix", out)
click.echo(u, file=out) # type: ignore
return error, u
def normalize_pts(self, pts1, pts2):
#print pts1
A = pts1[:, 0:2]
B = pts2[:, 0:2]
assert len(A) == len(B)
N = A.shape[0] # total points
# find centroids
centroid_A = rmsd.centroid(A)
centroid_B = rmsd.centroid(B)
# centre the points
AA = A - centroid_A
BB = B - centroid_B
#get optimal rotation matrix
R = rmsd.kabsch(AA, BB)
# Apply transformation
AA1 = np.dot(AA, R)
angle1 = math.atan2(R[1][0], R[1][1])
pts1[:, 0:2] = AA1 + centroid_B
# rotate the rotations
pts1[:, 2] -= angle1
return rmsd.rmsd(AA1, BB)
def alin(A,B): A -= rmsd.centroid(A) B -= rmsd.centroid(B) #print (B) U = rmsd.kabsch(A, B) A = np.dot(A, U) return A, B, rmsd.rmsd(A,B)
def run(self, residues1: SetOfResidues, residues2: SetOfResidues,
get_centered_c_alpha_coords: GetCenteredCAlphaCoords,
get_rotation_matrix: GetRotationMatrix) -> float:
P, Q = map(get_centered_c_alpha_coords, (residues1, residues2))
# following code from rmsd.kabsch_rmsd()
P = np.dot(P, get_rotation_matrix(residues1, residues2))
return rmsd.rmsd(P, Q)
def crmsd_kabsch(A, B):
# Translate
A -= rmsd.centroid(A)
B -= rmsd.centroid(B)
# Rotate
U = rmsd.kabsch(A, B)
A = np.dot(A, U)
return rmsd.rmsd(A, B)
def test_rmsd_pdb():
filename_1 = pathlib.PurePath(RESOURCE_PATH, "ci2_1.pdb")
filename_2 = pathlib.PurePath(RESOURCE_PATH, "ci2_2.pdb")
p_atoms, p_coord = rmsd.get_coordinates_pdb(filename_1)
q_atoms, q_coord = rmsd.get_coordinates_pdb(filename_2)
pure_rmsd = rmsd.rmsd(p_coord, q_coord)
np.testing.assert_almost_equal(26.9750, pure_rmsd, decimal=3)
def test_rmsd_xyz():
filename_1 = pathlib.PurePath(RESOURCE_PATH, "ethane.xyz")
filename_2 = pathlib.PurePath(RESOURCE_PATH, "ethane_mini.xyz")
p_atoms, p_coord = rmsd.get_coordinates_xyz(filename_1)
q_atoms, q_coord = rmsd.get_coordinates_xyz(filename_2)
pure_rmsd = rmsd.rmsd(p_coord, q_coord)
np.testing.assert_almost_equal(0.33512, pure_rmsd, decimal=3)
def test_arbitrary_shuffles():
"""Given an original geometry and a shuffled geometry derived
from the original one, the Hungarian method should be able to
fully reconstruct the original order of atoms."""
benz, _ = get_geoms()
coords_by_type, inds_by_type = benz.coords_by_type
atom_num = len(benz.atoms)
initial_order = np.arange(atom_num)
atom_arr = np.array(benz.atoms)
c3d = benz.coords3d.copy()
for i in range(10):
shuffled_geom = shuffle_geometry(benz)
org_rmsd = rmsd.rmsd(benz.coords3d, shuffled_geom.coords3d)
matched_geom = match_geom_atoms(benz, shuffled_geom, hydrogen=True)
matched_rmsd = rmsd.rmsd(benz.coords3d, matched_geom.coords3d)
print(f"RMSD(shuffled) {org_rmsd:.2f} "
f"RMSD(matched) {matched_rmsd:.2f}")
assert np.allclose(matched_rmsd, 0.0)
def calc_rmsd(self):
"""
Calculate normal, translated, and rotated RMSD.
"""
tmp_1, tmp_2 = self.coord_1.copy(), self.coord_2.copy()
self.rmsd_normal = rmsd.rmsd(self.coord_1, self.coord_2)
# Manipulate recenter
self.coord_1 -= rmsd.centroid(self.coord_1)
self.coord_2 -= rmsd.centroid(self.coord_2)
self.rmsd_translate = rmsd.rmsd(self.coord_1, self.coord_2)
# Rotate
rotation_matrix = rmsd.kabsch(self.coord_1, self.coord_2)
self.coord_1 = np.dot(self.coord_1, rotation_matrix)
self.rmsd_rotate = rmsd.rmsd(self.coord_1, self.coord_2)
self.coord_1, self.coord_2 = tmp_1, tmp_2
def test_match(dummy, selector):
pr = PrivilegedResidues(path.join(path.dirname(__file__), "data/DUMMY.zarr/"))
res = dummy.residue(2)
expected_coords = np.array([res.xyz(atom) for atom in rsd_to_fxnl_grp[res.name3()].atoms])
for (_, match) in pr.search(dummy, selector, groups=["sc_bb"]):
rmatch = match.residue(1)
coords = np.array([rmatch.xyz(atom) for atom in functional_groups[rmatch.name()].atoms])
if (rmsd(coords, expected_coords) < 0.1):
return
assert()
def calculate_rmsd(mol_id,
geometry_id1=None,
geometry_id2=None,
heavy_atoms_only=False):
# These cause circular import errors if we put them at the top of the file
from ._girder import GirderClient
from ._calculation import GirderMolecule
# Allow the user to pass in a GirderMolecule instead of an id
if isinstance(mol_id, GirderMolecule):
mol_id = mol_id._id
if geometry_id1 is None:
cjson1 = GirderClient().get('/molecules/%s/cjson' % mol_id)
else:
cjson1 = GirderClient().get('/molecules/%s/geometries/%s/cjson' %
(mol_id, geometry_id1))
if geometry_id2 is None:
cjson2 = GirderClient().get('/molecules/%s/cjson' % mol_id)
else:
cjson2 = GirderClient().get('/molecules/%s/geometries/%s/cjson' %
(mol_id, geometry_id2))
coords1 = cjson1['atoms']['coords']['3d']
coords1_triplets = zip(coords1[0::3], coords1[1::3], coords1[2::3])
A = np.array([x for x in coords1_triplets])
coords2 = cjson2['atoms']['coords']['3d']
coords2_triplets = zip(coords2[0::3], coords2[1::3], coords2[2::3])
B = np.array([x for x in coords2_triplets])
if heavy_atoms_only:
atomic_numbers = cjson1['atoms']['elements']['number']
heavy_indices = [i for i, n in enumerate(atomic_numbers) if n != 1]
A = A.take(heavy_indices, 0)
B = B.take(heavy_indices, 0)
# Translate
A -= rmsd.centroid(A)
B -= rmsd.centroid(B)
# Rotate
U = rmsd.kabsch(A, B)
A = np.dot(A, U)
return rmsd.rmsd(A, B)
def calc_rmsd(coords1, coords2):
"""Calculate root-mean square deviation.
Parameters
----------
coords1 : list(list(str,int,int,int))
The coordinates for the first
molecule (conformer).
coords2 : list(list(str,int,int,int))
The coordinates for the second
molecule (conformer).
Notes
-----
The coordinates are given as follows:
atom name, x coord, y coord, z coord
Example for carbon monoxide:
[[C, 0.0, 0.0, 0.0],[O, 1.0, 0.0, 0.0]]
The distances are in Angstroms.
Returns
-------
rmsd : float
The rmsd between two molecular
geometries. This rmsd is calculated
after applying centering and a
rotation matrix (calculated via
the Kabsch algorithm).
"""
# trivial check
assert len(coords1) == len(coords2)
# first turn lists into numpy arrays (otherwise
# cannot perform some rmsd operations)
# and excise atom names (not needed for rmsd)
mol1 = np.array([[coords1[i][1], coords1[i][2], coords1[i][3]] for i in range(len(coords1))])
mol2 = np.array([[coords2[i][1], coords2[i][2], coords2[i][3]] for i in range(len(coords2))])
# first center each molecule
mol1 -= rmsd.centroid(mol1)
mol2 -= rmsd.centroid(mol2)
# calculate the rotation matrix
rot_matrix = rmsd.kabsch(mol1, mol2)
# apply the rotation matrix
mol1 = np.dot(mol1, rot_matrix)
# finally get the rmsd
return rmsd.rmsd(mol1, mol2)
def set_metric(self,metric_type):
metric_type = metric_type.upper()
if (metric_type[:4] == 'RMSD'):
self.metric = rmsd.rmsd()
elif (metric_type[:4] == 'OGTO'):
if len(metric_type) > 4 :
sigma = float(metric_type[5:])
self.metric = ogto.ogto(sigma)
else :
self.metric = ogto.ogto()
elif (metric_type[:4] == 'SOAP'):
self.metric = soap.soap()
else:
print "!!! unknown metric type:",metric_type,"!!!"
sys.exit()
print "> metric type:",self.metric.tag()
sys.stdout.flush()
def find(structures, generators=None):
generators = np.array(generators)
structures = [structure[1:] for structure in structures]
ref = structures[0]
data = []
for j, structure in enumerate(structures):
for i, q in enumerate(generators):
U = quat_utils.quaternion_to_rotation_matrix(q)
rotated = np.dot(structure, U.T)
ds = scipy.spatial.distance.cdist(ref, rotated)
_, mapping = scipy.optimize.linear_sum_assignment(ds)
obj = rmsd.rmsd(ref, rotated[mapping])
if obj > 1E-3:
continue
data += [(i, j, mapping, q)]
indices, js, _, qs = zip(*sorted(data))
print js
assert indices == tuple(range(len(indices)))
for index, js, mapping, q in sorted(data):
mapping = [0] + list(np.array(mapping) + 1)
print "{" + ", ".join([str(e).rjust(2) for e in mapping]) + "},"#, q
_qs = []
for q in qs:
t = [1, 0.1, 0.01, 0.001]
if np.dot(-q, t) > np.dot(q, t):
q = -q
_qs += [(np.dot(q, t), tuple(q))]
_qs = sorted(_qs, reverse=True)
qs = np.array([e[1] for e in _qs])
for q in qs:
print "{" + ", ".join([("%.14f" % e).rjust(18) for e in q]) + "},"
def normalize_pts_old(pts1, pts2, win):
#print pts1
A = pts1[:, 0:2]
B = pts2[:, 0:2]
assert len(A) == len(B)
N = A.shape[0] # total points
# find centroids
centroid_A = rmsd.centroid(A)
centroid_B = rmsd.centroid(B)
# centre the points
AA = A - centroid_A
BB = B - centroid_B
#get optimal rotation matrix
R = rmsd.kabsch(AA, BB)
# Apply transformation
AA1 = np.dot(AA, R)
angle1 = math.atan2(R[1][0], R[1][1])
i=0
for pt in pts1:
pt_graphics = Point(int(pt[0]-centroid_A[0]+centroid_B[0]), int(pt[1]-centroid_A[1]+centroid_B[1]))
cir = Circle(pt_graphics, 8)
cir.setOutline('green')
cir.draw(win)
line = Line(pt_graphics, Point(pt_graphics.x+8*np.cos(-pt[2]), pt_graphics.y+8*np.sin(-pt[2])))
line.draw(win)
text = Text(pt_graphics, str(i))
i += 1
text.draw(win)
pts1[:, 0:2] = AA1 + centroid_B
# rotate the rotations
pts1[:, 2] -= angle1
return rmsd.rmsd(AA1, BB)
def main():
'''
Run the main function.
'''
# First, parse command line arguments
pdbpath, xtcpath = parse_arguments()
# Get numpy array of coordinates for trajectory
# Again, note the pdb files must be 'go'models and not full-atom models
coordinates = xtc2numpyarray(xtcpath, pdbpath)
# Get numpy array of coordinates for reference structure
ref_coordinates = pdb2numpyarray(pdbpath)
# Iterate through the frames of the trajectory and calculate the RMS
# deviation relative to the ref_coordinates
rmsd_list = []
for frame in coordinates:
# This module is from the rmsd.py script that must be in the same directory
# as this script
r = rmsd.rmsd(frame, ref_coordinates)
rmsd_list.append(r)
numpy.savetxt("rmsd.txt", rmsd_list)
def filter_clash_minimize(pose,
hits,
clash_cutoff=35.0,
rmsd_cutoff=0.5,
sfx=None,
mmap=None,
limit=0):
"""Filter match output for clashes, then minimize the remaining
structures against the target pose.
Parameters
----------
pose : pyrosetta.Pose
Target structure.
hits : np.ndarray
Set of functional group matches against positions in the target.
clash_cutoff : float
Maximum tolerated increase in score terms during clash checking.
sfx : pyrosetta.rosetta.core.scoring.ScoreFunction, optional
Scorefunction to use during minimization. If left as None, a
default scorefunction is constructed.
mmap : pyrosetta.rosetta.protocols.minimization_packing.MinMover, optional
Movemap to use during minimization. If left as None, a default
movemap is constructed.
Yields
------
pyrosetta.Pose
Next target structure and matched functional group, minimized
and in complex.
"""
if (not sfx):
sfx = scoring.ScoreFunctionFactory.create_score_function("beta_nov16")
sfx.set_weight(scoring.hbond_bb_sc, 2.0)
sfx.set_weight(scoring.hbond_sc, 2.0)
if (not mmap):
mmap = MoveMap()
mmap.set_bb(False)
mmap.set_chi(False)
mmap.set_jump(1, True)
minmov = MinMover(mmap, sfx, "dfpmin_armijo_nonmonotone", 0.01, False)
for n, (hash, match) in enumerate(hits):
proto_pose = pose.clone()
proto_pose.append_pose_by_jump(match, len(proto_pose.residues))
sfx(proto_pose)
fa_rep = proto_pose.energies().total_energies()[scoring.fa_rep]
fa_elec = proto_pose.energies().total_energies()[scoring.fa_elec]
if (fa_rep + fa_elec > clash_cutoff):
continue
minmov.apply(proto_pose)
minimized = proto_pose.split_by_chain(proto_pose.num_chains())
ori_coords = np.array(
[atom.xyz() for res in match.residues for atom in res.atoms()])
min_coords = np.array(
[atom.xyz() for res in minimized.residues for atom in res.atoms()])
if (rmsd(ori_coords, min_coords) < rmsd_cutoff):
yield (hash, minimized)
if (limit and n + 1 >= limit):
break
return []
metric/s from Bartok's SOAP similarity measure
"""
import sys
import math
import os
import numpy as np
lib_path = os.path.abspath('..')
sys.path.append(lib_path)
import util
import soap
import rmsd
import ogto
###################################################################
d = soap.soap()
g = rmsd.rmsd()
o = ogto.ogto()
c1 = [[1.1, 1, 1],
[1, -1, -1],
[-1, 1, -1],
[-1, -1, 1]]
c1 = [[2.2, 2, 2],
[2, -2, -2],
[-2, 2, -2],
[-2, -2, 2]]
c2 = [[1.1, 1.1, 1.1],
[1.1, -1.1, -1.1],
[-1.1, 1.1, -1.1],
[-1.1, -1.1, 1.1]]
#-------------------------------
c1 = [[ 1.23, 1.43, 1.43],
[2.0, 1.5]])
# Same "molecule"
B = np.array([[1.0, 1.0],
[1.0, 2.0],
[2.0, 1.5]])
B *= 1.4
# Translate
B -= 3
# Rotate
B = np.dot(B, rotation_matrix(90))
print("Normal RMSD", rmsd.rmsd(A, B))
save_plot(A, B, "plot_beginning.png")
# Manipulate
A -= rmsd.centroid(A)
B -= rmsd.centroid(B)
print("Centered RMSD", rmsd.rmsd(A, B))
save_plot(A, B, "plot_centered.png")
U = rmsd.kabsch(A, B)
A = np.dot(A, U)
print("Translated RMSD", rmsd.rmsd(A, B))
save_plot(A, B, "plot_translated.png")
def getrmsd(mol1, mol2):
U_noH = rmsd.kabsch(mol1[2], mol2[2])
Temp_noH = np.dot(mol1[2], U_noH)
return rmsd.rmsd(Temp_noH, mol2[2])
def chainRMSD(self, chain_):
""" Calculates RMSD using https://github.com/charnley/rmsd
param chain_ : chain being compared
"""
return (rmsd.rmsd(self.getPosArray(), chain_.getPosArray()))
[2.0, 1.5]])
# Same "molecule"
B = np.array([[1.0, 1.0],
[1.0, 2.0],
[2.0, 1.5]])
B *= 1.4
# Translate
B -= 3
# Rotate
B = np.dot(B, rotation_matrix(90))
print("Normal RMSD", rmsd.rmsd(A, B))
save_plot(A, B, "plot_beginning")
# Manipulate
A -= rmsd.centroid(A)
B -= rmsd.centroid(B)
print("Translated RMSD", rmsd.rmsd(A, B))
save_plot(A, B, "plot_translated")
U = rmsd.kabsch(A, B)
A = np.dot(A, U)
print("Rotated RMSD", rmsd.rmsd(A, B))
save_plot(A, B, "plot_rotated")
def residue_dist(residue_a, residue_b):
a_coords = backbone_coords(residue_a)
b_coords = backbone_coords(residue_b)
dist = rmsd.rmsd(a_coords, b_coords)
return dist
f2 = np.array([0, 1, 0])
c3 = np.array([[1, 1, 1], [1, -1, -1.01], [-1, 1, -1], [-1, -1, 1]])
f3 = np.array([0, 0, 1])
c4 = np.array([[1, 2, 1], [1, -1, -1.01], [-1, 1, -1], [-1, -1, 1]])
f4 = np.array([1, 0, 1])
print "c1\n", c1
print "f1 ", f1
print "c2\n", c2
print "f2 ", f2
print "c3\n", c3
print "f3 ", f3
print "c4\n", c4
print "f4 ", f4
import rmsd
m = rmsd.rmsd()
[d12, R12] = m.distance(c1, c2)
[d13, R13] = m.distance(c1, c3)
[d14, R14] = m.distance(c1, c4)
[d23, R23] = m.distance(c2, c3)
[d24, R24] = m.distance(c2, c4)
[d34, R34] = m.distance(c3, c4)
Ds = np.array([[0, d12, d13, d14], [d12, 0, d23, d24], [d13, d23, 0, d34],
[d14, d24, d34, 0]])
print "using an inverse quadratic"
rbf = inverse_quadratic()
print "relative distances/adjacency matrix\n", Ds
fs = np.array([f1, f2, f3, f4])
print "(rotated) force values\n", fs
def calc_rmsd(acf):
"""
Calculate root mean squared displacement of atoms in complex, RMSD.
Parameters
----------
acf : list
Atomic labels and coordinates of full complex.
Returns
-------
rmsd_normal : int or float
Normal RMSD,
rmsd_translate : int or float
Translate RMSD (re-centered),
rmsd_rotate : int or float
Kabsch RMSD (rotated),
References
----------
https://github.com/charnley/rmsd
Examples
--------
>>> comp1.xyz
Fe 10.187300000 5.746300000 5.615000000
O 8.494000000 5.973500000 4.809100000
O 9.652600000 6.422900000 7.307900000
N 10.803800000 7.531900000 5.176200000
N 9.622900000 3.922100000 6.008300000
N 12.006500000 5.556200000 6.349700000
N 10.804600000 4.947100000 3.921900000
>>> comp2.xyz
Fe 12.093762780 2.450541280 3.420711630
O 12.960362780 2.295241280 1.728611630
O 13.487662780 1.618241280 4.423011630
N 12.852262780 4.317441280 3.989411630
N 10.930762780 0.769741280 2.931511630
N 10.787862780 2.298741280 5.107111630
N 10.677362780 3.796041280 2.542411630
>>> complex = [comp1, comp2] # comp1 and comp2 are lists of coordinates of two complex
>>> calc_rmsd(complex)
RMSD between two complexes
**************************
Normal RMSD : 5.015001
Re-centered RMSD : 2.665076
Rotated RMSD : 1.592468
"""
strct_1 = acf[0]
strct_2 = acf[1]
atom_strc_1, coord_strct_1 = strct_1
atom_strc_2, coord_strct_2 = strct_2
rmsd_normal = rmsd.rmsd(coord_strct_1, coord_strct_2)
# Manipulate recenter
coord_strct_1 -= rmsd.centroid(coord_strct_1)
coord_strct_2 -= rmsd.centroid(coord_strct_2)
rmsd_translate = rmsd.rmsd(coord_strct_1, coord_strct_2)
# Rotate
U = rmsd.kabsch(coord_strct_1, coord_strct_2)
coord_strct_1 = np.dot(coord_strct_1, U)
rmsd_rotate = rmsd.rmsd(coord_strct_1, coord_strct_2)
return rmsd_normal, rmsd_translate, rmsd_rotate
def connectRMSD(self, connect_):
return (rmsd.rmsd(self.getConnectPos(), connect_.getConnectPos()))
z_angle = np.pi / 5
R = euler2mat(x_angle, y_angle, z_angle, 'sxyz')
'''
a = np.array([0, 0, 0])
b = np.array([10, 10, 0])
c = np.array([20, 0, 0])
'''
A = 10 * np.random.rand(50, 3)
B = np.dot(A, R)
extra = 10*np.random.rand(10, 3)
#B = np.append(B, extra, axis = 0)
B += random.uniform(-10, 10)
#np.random.shuffle(B)
#A, B = generate_set(A, B)
plot3d(A, B)
print("Normal RMSD", rmsd.rmsd(A, B))
# Manipulate
A -= rmsd.centroid(A)
B -= rmsd.centroid(B)
plot3d(A, B)
print("Translated RMSD", rmsd.rmsd(A, B))
markA = A[0:3, :]
markB = B[0:3, :]
U = rmsd.kabsch(markA, markB)
A = np.dot(A, U)
plot3d(A, B)
print("Rotated RMSD", rmsd.rmsd(A, B))
import numpy as np
file1 = './opted_mols/2-Mn-OtBu_opted.xyz'
with open(file1, 'r') as f1:
n = int(f1.readline())
f1.readline()
coord = []
for _ in range(n):
coord.append(list(map(float, f1.readline().split()[1::])))
coord = np.array(coord)
coord2 = np.array([c + np.array([1, 1, 4]) for c in coord])
coord -= rmsd.centroid(coord)
coord2 -= rmsd.centroid(coord2)
print(rmsd.rmsd(coord, coord2))
phi, psi = pi / 10, pi / 4
coord3 = np.array([
np.array([
c[0] * (1), c[1] * cos(psi) + c[2] * sin(psi),
-c[1] * sin(psi) + c[2] * cos(psi)
]) for c in coord
])
coord3 -= rmsd.centroid(coord3)
rotate = rmsd.kabsch(coord3, coord)
coord3 = np.dot(coord3, rotate)
print(rmsd.rmsd(coord, coord3))
