def anchor_assembly(components_rbs, anchored):
"""
"Anchor" a set of rigid bodies, by setting the position of one of them
at the origin (0,0,0).
@param components_rbs Rigid bodies of the components
@param anchored - List of True/False values indicating if the components
of the assembly are anchored. The function sets the FIRST anchored
component in the (0,0,0) coordinate and moves the other
components with the same translation. If all the values are False, the
function does not do anything
"""
if True in anchored:
anchored_rb = None
for a, rb in zip(anchored, components_rbs):
if a:
anchored_rb = rb
break
center = anchored_rb.get_coordinates()
log.info("Anchoring assembly at (0,0,0)")
for rb in components_rbs:
T = rb.get_reference_frame().get_transformation_to()
t = T.get_translation()
R = T.get_rotation()
log.debug("%s: Rerefence frame BEFORE %s",
rb.get_name(), rb.get_reference_frame())
T2 = alg.Transformation3D(R, t - center)
rb.set_reference_frame(alg.ReferenceFrame3D(T2))
log.debug("%s Rerefence frame AFTER %s",
rb.get_name(), rb.get_reference_frame())
def __init__(self, text, delimiter="|"):
vals = [float(x) for x in text.split(delimiter)]
if (len(vals) != 7):
raise ValueError("The text is not a transformation", vals)
R = alg.Rotation3D(vals[0], vals[1], vals[2], vals[3])
t = alg.Vector3D(vals[4], vals[5], vals[6])
self.t = alg.Transformation3D(R, t)
def parse_relative_transform(row):
"""
Returns an relative transform with the conventions used by IMP.
row - A list containing a splitted line from the relative output file
"""
euler = [-float(x) for x in row[8:11]]
xyz = [float(x) for x in row[5:8]]
R = alg.get_rotation_from_fixed_zyz(*euler)
R = R.get_inverse()
t = alg.Vector3D(*xyz)
return alg.Transformation3D(R, t)
def test_sampling_schema(self):
"""
Test
"""
subunits = ["subunitA", "subunitB", "subunitC", "subunitD"]
anchored = [False, False, False, False]
fixed = [False, False, False, False]
n_transformations = 50
db = database.Database2()
fn = 'temp.db'
db.create(fn, overwrite=True)
db.connect(fn)
transformations = []
table_name = "results"
db.create_table(table_name, ["reference_frames"], [str])
for i in range(n_transformations):
Ts = []
for j in range(len(subunits)):
center = alg.Vector3D(0, 0, 0)
T = alg.Transformation3D(
alg.get_random_rotation_3d(),
alg.get_random_vector_in(alg.Sphere3D(center, 34)))
Ts.append(T)
transformations.append(Ts)
data = []
for Ts in transformations:
text = [io.Transformation3DToText(T).get_text() for T in Ts]
text = "/".join(text)
data.append([
text,
])
db.store_data(table_name, data)
db.close()
sch = sampling.SamplingSchema(4, fixed, anchored)
sch.read_from_database(fn)
for i in range(len(transformations)):
for j in range(len(subunits)):
T = transformations[i][j]
t = T.get_translation()
q = T.get_rotation().get_quaternion()
pos = sch.transformations[j][i].get_translation()
ori = sch.transformations[j][i].get_rotation().get_quaternion()
for k in range(3):
self.assertAlmostEqual(pos[k], t[k])
for k in range(4):
self.assertAlmostEqual(q[k], ori[k])
os.remove(fn)
def apply_rotation_around_centroid(rb, rot):
"""
Rotates the reference frame of a rigid body around the centroid
"""
c = rb.get_coordinates()
ref = rb.get_reference_frame()
R = ref.get_transformation_to().get_rotation()
R2 = alg.compose(rot, R)
T = alg.Transformation3D(R2, c)
ref = alg.ReferenceFrame3D(T)
rb.set_reference_frame(ref)
def apply_random_transform(rb, max_trans=100):
"""
Apply a random transformation to the rigid body and change the reference
frame
"""
bb = alg.BoundingBox3D(alg.Vector3D(-max_trans, -max_trans, -max_trans),
alg.Vector3D(max_trans, max_trans, max_trans))
Trand = alg.Transformation3D(alg.get_random_rotation_3d(),
alg.get_random_vector_in(bb))
ref = rb.get_reference_frame()
Tr = ref.get_transformation_to()
T = alg.compose(Trand, Tr)
rb.set_reference_frame(alg.ReferenceFrame3D(T))
def __init__(self, model, rigid_bodies, anchored):
log.info("Setting MonteCarloRelativeMoves")
self.model = model
self.rbs = rigid_bodies
self.components = []
self.best_models = []
self.anchored = anchored
self.parent_rbs = []
# triplets with the information to build a relative mover using the
# results from docking with HEX
self.dock_transforms = None
self.non_relative_move_prob = 0.1
log.debug("Anchored components %s", self.anchored)
T = alg.Transformation3D(alg.get_identity_rotation_3d(),
alg.Vector3D(0., 0., 0.))
origin = alg.ReferenceFrame3D(T)
for rb in self.rbs:
rb.set_reference_frame(origin)
def read_from_database(self,
fn_database,
fields=["reference_frames"],
max_number=False,
orderby=False):
"""
Read orientations and positions from a database file.
self.anchored and self.fixed overwrite
the positions and orientations read from the database
"""
if not os.path.exists(fn_database):
raise IOError(
"read_from_database: Database file not found. "
"Are you perhaps trying to run the DOMINO optimization without "
"having the database yet?")
db = solutions_io.ResultsDB()
db.connect(fn_database)
data = db.get_solutions(fields, max_number, orderby)
db.close()
self.transformations = [[] for T in range(self.n_components)]
# Each record contains a reference frame for each of the
# components. But here the states considered make sense as columns.
# Each rigidbody is considered to have all the states in a column.
for d in data:
texts = d[0].split("/")
for i, t in zip(range(self.n_components), texts):
T = io.TextToTransformation3D(t).get_transformation()
self.transformations[i].append(T)
# Set the anchored components
for i in range(self.n_components):
if self.anchored[i]:
origin = alg.Transformation3D(alg.get_identity_rotation_3d(),
alg.Vector3D(0.0, 0.0, 0.))
self.transformations[i] = [origin]
# If fixed, only the first state is kept
for i in range(self.n_components):
if self.fixed[i]:
if len(self.transformations[i]) == 0:
raise ValueError("There are positions to keep fixed")
self.transformations[i] = [self.transformations[i][0]]
def get_random_transformation(max_distance, max_angle, seed=-1):
"""
Return a random transformation
@param distance Maximum translation allowed
@param max_angle Maximum rotation angle allowed
"""
if seed == -1:
random.seed()
else:
random.seed(seed)
phi = random.uniform(-max_angle, max_angle)
theta = random.uniform(-max_angle, max_angle)
psi = random.uniform(-max_angle, max_angle)
trans_x = random.uniform(-max_distance, max_distance)
trans_y = random.uniform(-max_distance, max_distance)
trans_z = random.uniform(-max_distance, max_distance)
trns = alg.Vector3D(trans_x, trans_y, trans_z)
rot = alg.get_rotation_from_fixed_zyz(phi, theta, psi)
transformation = alg.Transformation3D(rot, trns)
return transformation
def move_one_xlink(self):
"""
Put the residues in a random distance between 0 and the maximum
cross-linkin distance
"""
xl = self.xlinks_list[0]
center = self.get_residue_coordinates(self.h_receptor, xl.first_chain,
xl.first_residue)
sph = alg.Sphere3D(center, xl.distance)
v = alg.get_random_vector_in(sph)
ref = self.rb_ligand.get_reference_frame()
coords = ref.get_transformation_to().get_translation()
R = ref.get_transformation_to().get_rotation()
lig = self.get_residue_coordinates(self.h_ligand, xl.second_chain,
xl.second_residue)
log.debug("Ligand residue before moving %s", lig)
displacement = v - lig
T = alg.Transformation3D(R, coords + displacement)
self.rb_ligand.set_reference_frame(alg.ReferenceFrame3D(T))
new_coords = self.get_residue_coordinates(self.h_ligand,
xl.second_chain,
xl.second_residue)
log.debug("ligand after moving %s", new_coords)
def test__rigid_bodies_drms(self):
""" Test drms measure taking into account rigid bodies"""
m = IMP.kernel.Model()
sel = atom.CAlphaPDBSelector()
prot1 = atom.read_pdb(self.open_input_file("mini.pdb"), m, sel)
prot2 = atom.read_pdb(self.open_input_file("mini.pdb"), m, sel)
hchains1 = atom.get_by_type(prot1, atom.CHAIN_TYPE)
hchains2 = atom.get_by_type(prot2, atom.CHAIN_TYPE)
xyzs1 = core.XYZs(atom.get_leaves(prot1))
xyzs2 = core.XYZs(atom.get_leaves(prot2))
x = 0
ranges = []
for h in hchains1:
ls1 = (atom.get_leaves(h))
y = x + len(ls1)
ranges.append((x, y))
x = y
drms = atom.get_drms(xyzs1, xyzs2)
rb_drms = atom.get_rigid_bodies_drms(xyzs1, xyzs2, ranges)
self.assertAlmostEqual(rb_drms, 0)
self.assertAlmostEqual(
drms,
rb_drms,
delta=1e-3,
msg="rb_drms != drms")
# Same thing after transformation of each of the chains
for h in hchains2:
R = alg.get_random_rotation_3d()
v = alg.get_random_vector_in(alg.get_unit_bounding_box_3d())
T = alg.Transformation3D(R, v)
ls = atom.get_leaves(h)
for l in ls:
core.transform(l.get_as_xyz(), T)
drms = atom.get_drms(xyzs1, xyzs2)
rb_drms = atom.get_rigid_bodies_drms(xyzs1, xyzs2, ranges)
self.assertAlmostEqual(drms, rb_drms, delta=0.3, msg="rb_drms != drms")
