def set_relative_movers(self, max_translation, max_rotation): """ Generate the relative models form the transfors. The transforms is a list with triplets [id1, id2, transform_file] @param max_translation Maximum translation distance allowed for the moves @param nax_rotation Maximum rotation angle allowed for the moves """ log.info("Setting relative movers") self.movers = [] relative_movers = [] relative_names = [] for d in self.dock_transforms: rb_id = representation.get_rb_name(d[1]) if rb_id not in relative_names: log.debug("Checking for %s", rb_id) rb_lig = representation.get_rigid_body(self.rbs, rb_id) mv = em2d.RelativePositionMover(rb_lig, max_translation, max_rotation) relative_movers.append(mv) relative_names.append(rb_id) log.debug("added a RelativePositionMover for %s",rb_id) i = relative_names.index(rb_id) relative_movers[i].set_random_move_probability( self.non_relative_move_prob) rb_rec = representation.get_rigid_body(self.rbs, representation.get_rb_name(d[0])) log.debug("Reference added for %s: %s. ref. frame %s ", rb_id, rb_rec.get_name(), rb_rec) Tis = io.read_transforms(d[2]) relative_movers[i].add_internal_transformations(rb_rec, Tis) # add regular movers for the rigid bodies that are neither moved # anchored nor moved relative to others regular_movers = [] for is_anchored, rb in zip(self.anchored, self.rbs): if(not is_anchored): name =rb.get_name() if(not name in relative_names): log.debug("adding a RigidBodyMover for %s",name) mv = core.RigidBodyMover(rb, max_translation, max_rotation) regular_movers.append(mv) self.movers = regular_movers self.movers += relative_movers
def set_not_optimized(self, name): """ Set a part of the model as not optimized (it does not move during the model optimization) @param name of the component to optimized """ if name not in self.names: raise ValueError("DominoModel: There is not component " \ "in the assembly with this name") rb_name = representation.get_rb_name(name) self.not_optimized_rbs.append(rb_name)
def create_dockings_from_xlinks(exp): """ Perform dockings that satisfy the cross-linking restraints. 1) Based on the number of restraints, creates an order for the docking between pairs of subunits, favouring the subunits with more crosslinks to be the "receptors" 2) Moves the subunits that are going to be docked to a position that satisfies the x-linking restraints. There is no guarantee that this position is correct. Its purpose is to help the docking algorithm with a clue of the proximity/orientation between subunits 3) Performs docking between the subunits 4) Filters the results of the docking that are not consistent with the cross-linking restraints 5) Computes the relative transformations between the rigid bodies of the subunits that have been docked @param exp Class with the parameters for the experiment """ log.info("Creating initial assembly from xlinks and docking") import docking_related as dock import buildxlinks as bx m = DominoModel.DominoModel() m.set_assembly_components(exp.fn_pdbs, exp.names) set_xlink_restraints(exp, m) order = bx.DockOrder() order.set_xlinks(m.xlinks) docking_pairs = order.get_docking_order() if hasattr(exp, "have_hexdock"): if not exp.have_hexdock: return for rec, lig in docking_pairs: pair_xlinks = m.xlinks.get_xlinks_for_pair((rec,lig)) log.debug("Xlinks for the pair %s %s %s",rec, lig, pair_xlinks) h_receptor = representation.get_component(m.assembly, rec) h_ligand = representation.get_component(m.assembly, lig) rb_receptor = representation.get_rigid_body(m.components_rbs, representation.get_rb_name(rec)) rb_ligand = representation.get_rigid_body(m.components_rbs, representation.get_rb_name(lig)) initial_ref = rb_ligand.get_reference_frame() # move to the initial docking position mv = bx.InitialDockingFromXlinks() mv.set_xlinks(pair_xlinks) mv.set_hierarchies(h_receptor, h_ligand) mv.set_rigid_bodies(rb_receptor, rb_ligand) mv.move_ligand() fn_initial_docking = "%s-%s_initial_docking.pdb" % (rec,lig) mv.write_ligand(fn_initial_docking) # dock hex_docking = dock.HexDocking() receptor_index = exp.names.index(rec) fn_transforms = "hex_solutions_%s-%s.txt" % (rec, lig) fn_docked = "%s-%s_hexdock.pdb" % (rec, lig) hex_docking.dock(exp.fn_pdbs[receptor_index], fn_initial_docking, fn_transforms, fn_docked, False) sel = atom.ATOMPDBSelector() new_m = IMP.Model() # After reading the file with the initial solution, the reference frame # for the rigid body of the ligand is not necessarily the same one # that it had when saved. # Thus reading the file again ensures consisten results when # using the HEXDOCK transforms new_h_ligand = atom.read_pdb(fn_initial_docking, new_m, sel) new_rb_ligand = atom.create_rigid_body(new_h_ligand) Tlig = new_rb_ligand.get_reference_frame().get_transformation_to() fn_filtered = "hex_solutions_%s-%s_filtered.txt" % (rec, lig) # h_ligand contains the coordinates of the ligand after moving it # to the initial position for the docking dock.filter_docking_results(h_receptor, new_h_ligand, pair_xlinks, fn_transforms, fn_filtered) # transforms to apply to the ligand as it is in the file # fn_initial_docking Thex = dock.read_hex_transforms(fn_filtered) Trec = rb_receptor.get_reference_frame().get_transformation_to() Tinternal = [] for i,T in enumerate(Thex): Tdock = alg.compose(T, Tlig) ref = alg.ReferenceFrame3D(Tdock) new_rb_ligand.set_reference_frame(ref) # internal transformation. The relationship is Tdock = Trec * Ti Ti = alg.compose(Trec.get_inverse(), Tdock) Tinternal.append(Ti) fn_relative = "relative_positions_%s-%s.txt" % (rec, lig) io.write_transforms(Tinternal, fn_relative) rb_ligand.set_reference_frame(initial_ref)