def get_reference_frames_from_chain_alignment(reference_rbs, reference_index,
rbs_to_align, index_to_align):
"""
Align the rigid bodies rbs_to_align to the the reference frames of
reference_rbs. The rb with index_to_align is aligned to the reference rb
with reference_index. The function returns the reference frames to
apply to the rbs_to_align.
"""
ref_coords = \
[m.get_coordinates()
for m in reference_rbs[reference_index].get_members()]
coords = [m.get_coordinates()
for m in rbs_to_align[index_to_align].get_members()]
if(len(coords) != len(ref_coords)):
raise ValueError(
"Mismatch in the number of members. Reference %d Aligned %d " % (
len(ref_coords), len(coords)))
T = alg.get_transformation_aligning_first_to_second(coords, ref_coords)
new_refs = []
for rb in rbs_to_align:
# log.debug("aligning ... %s",rb)
t = rb.get_reference_frame().get_transformation_to()
new_t = alg.compose(T, t)
new_refs.append(alg.ReferenceFrame3D(new_t))
return new_refs
def align_centroids_using_pca(ref_frames, ref_frames_reference):
"""
Align the centroids of 2 sets of rigid bodyes using PCA using their
reference frames. returns the best rmsd and the ref_frames to get it.
"""
if(len(ref_frames) != len(ref_frames_reference)):
raise ValueError("The number of reference frames must be the same")
Ts1 = [r.get_transformation_to() for r in ref_frames]
vs1 = [T.get_translation() for T in Ts1]
Ts2 = [r.get_transformation_to() for r in ref_frames_reference]
vs2 = [T.get_translation() for T in Ts2]
# align with PCA
pc1 = alg.get_principal_components(vs1)
pc2 = alg.get_principal_components(vs2)
pcTs = alg.get_alignments_from_first_to_second(pc1, pc2)
best_refs = []
best_rmsd = 1e5
for j, pcT in enumerate(pcTs):
new_Ts1 = [alg.compose(pcT, T) for T in Ts1]
new_vs1 = [T.get_translation() for T in new_Ts1]
r = atom.get_rmsd(new_vs1, vs2)
if(r < best_rmsd):
best_rmsd = r
best_refs = [alg.ReferenceFrame3D(T) for T in new_Ts1]
return best_rmsd, best_refs
def move_xlinks(self, ):
"""
Function equivalent to move_one_xlink() for the case where there
are more than one cross-link restraints available.
Puts the ligand residues as close as possible to the receptor
residues
"""
rec_coords = []
lig_coords = []
for xl in self.xlinks_list:
c = self.get_residue_coordinates(self.h_receptor, xl.first_chain,
xl.first_residue)
rec_coords.append(c)
c = self.get_residue_coordinates(self.h_ligand, xl.second_chain,
xl.second_residue)
lig_coords.append(c)
log.debug("Receptor residues before moving %s", rec_coords)
log.debug("Ligand residues before moving %s", lig_coords)
ref = self.rb_ligand.get_reference_frame()
Tr = alg.get_transformation_aligning_first_to_second(
lig_coords, rec_coords)
T = ref.get_transformation_to()
newT = alg.compose(Tr, T)
self.rb_ligand.set_reference_frame(alg.ReferenceFrame3D(newT))
moved_lig_coords = []
for xl in self.xlinks_list:
c = self.get_residue_coordinates(self.h_ligand, xl.second_chain,
xl.second_residue)
moved_lig_coords.append(c)
log.debug("Ligand residues after moving %s", moved_lig_coords)
def get_restraints_for_native(self, restraints_names):
"""
Get values of the restraints for the native structure
@param restraints_names Names of the restraints requested
@return a list with the values of all scores, and the total score
"""
saved = [rb.get_reference_frame() for rb in self.components_rbs]
# Set the state of the model to native
for rb, rn in zip(self.components_rbs, self.native_rbs):
# remove sub-rigid bodies
rb_members = [m for m in rb.get_members()
if not core.RigidBody.get_is_setup(m.get_particle())]
rn_members = [m for m in rn.get_members()
if not core.RigidBody.get_is_setup(m.get_particle())]
rb_coords = [m.get_coordinates() for m in rb_members]
rn_coords = [m.get_coordinates() for m in rn_members]
# align and put rb in the position of rn
if len(rn_coords) != len(rb_coords):
raise ValueError("Mismatch in the number of members. "
"Reference %d Aligned %d " % (len(rn_coords), len(rb_coords)))
T = alg.get_transformation_aligning_first_to_second(rb_coords,
rn_coords)
t = rb.get_reference_frame().get_transformation_to()
new_t = alg.compose(T, t)
rb.set_reference_frame(alg.ReferenceFrame3D(new_t))
scores = []
for name in restraints_names:
scores.append(self.restraints[name].evaluate(False))
total_score = sum(scores)
representation.set_reference_frames(self.components_rbs, saved)
return scores, total_score
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 get_docked_reference_frames(relative_transforms, rb_lig):
Tinitial = rb_lig.get_reference_frame().get_transformation_to()
docked_ref_frames = []
for Trelative in relative_transforms:
Tdock = alg.compose(Trelative, Tinitial)
docked_rf = alg.ReferenceFrame3D(Tdock)
docked_ref_frames.append(docked_rf)
return docked_ref_frames
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 set_rb_states(self, rb, transformations):
"""
Add a set of reference frames as possible states for a rigid body
@param rb The rigid body
@param transformations Transformations are used to build the
reference frames for the rigid body.
"""
log.info("Set rigid body states for %s", rb.get_name())
RFs = [alg.ReferenceFrame3D(T) for T in transformations]
for st in RFs:
log.debug("%s", st)
rb_states = domino.RigidBodyStates(RFs)
self.rb_states_table.set_particle_states(rb, rb_states)
st = self.rb_states_table.get_particle_states(rb)
log.info("RigidBodyStates created %s",
st.get_number_of_particle_states())
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 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 __init__(self, text, delimiter="|"):
TextToTransformation3D.__init__(self, text, delimiter)
self.ref = alg.ReferenceFrame3D(self.get_transformation())
