1 """@namespace IMP.EMageFit.buildxlinks
2 Utility functions to handle cross links.
16 from sets
import Set
as set
18 log = logging.getLogger(
"buildxlinks")
24 Class defining a cross-link
27 def __init__(self, id1, chain1, residue1,
28 id2, chain2, residue2,
32 @param[in] id1 Id of the first component of the cross-link
33 @param[in] chain1 Chain of the first component
34 @param[in] residue1 Residue cross-linked in the first component
35 @param[in] id2 Id of the second component of the cross-link
36 @param[in] chain2 chain1 Chain of the second component
37 @param[in] residue2 Residue cross-linked in the second component
38 @param[in] distance Maximum distance
41 self.first_chain = chain1
42 self.first_residue = residue1
44 self.second_chain = chain2
45 self.second_residue = residue2
46 self.distance = distance
49 xl =
Xlink(self.first_id, self.first_chain, self.first_residue,
50 self.second_id, self.second_chain, self.second_residue,
54 def __eq__(self, other):
55 if self.first_id != other.first_id
or \
56 self.second_id != other.second_id
or \
57 self.first_chain != other.first_chain
or \
58 self.second_chain != other.second_chain
or \
59 self.first_residue != other.first_residue
or \
60 self.second_residue != other.second_residue
or \
61 abs(other.distance - self.distance) > 0.01:
67 swaps the order of the residues in the restraint
69 self.first_id, self.second_id = self.second_id, self.first_id
70 self.first_residue, self.second_residue = \
71 self.second_residue, self.first_residue
72 self.first_chain, self.second_chain = \
73 self.second_chain, self.first_chain
76 s =
"Cross Link: %s %s %d - %s %s %d. Distance %f" % (
77 self.first_id, self.first_chain, self.first_residue,
78 self.second_id, self.second_chain, self.second_residue,
84 Generate a unique name for the restraint.
85 @note: The name cannot start with a number, upsets sqlite
87 name =
"cl_%s_%s%d_%s_%s%d" % (self.first_id, self.first_chain,
88 self.first_residue, self.second_id,
89 self.second_chain, self.second_residue)
95 Build a set of nodes and edges from the set of crosslinking
97 @param xlinks_dict a XlinksDict class
102 for key
in xlinks_dict.keys():
105 edge = sorted([key[0], key[1]])
106 if edge
not in edges:
108 log.debug(
"Subunits %s", subunits)
109 log.debug(
"Edges %s", edges)
110 return subunits, edges
116 Description of crosslinking restraints as a python
118 The keys are a pair with the ids of the cross-linked subunits.
119 Note: The pairs are considered in alphabetic order
124 Add a xlink. It is ensured that the id of the first element is
125 is lower that the second
127 if xlink.second_id < xlink.first_id:
129 key = (xlink.first_id, xlink.second_id)
130 if key
not in self.keys():
132 self[key].append(xlink)
136 @param pair_ids Ids for the subunits that are cross-linked
139 xlinks_list = self[pair_ids]
140 ys = [xl.clone()
for xl
in xlinks_list]
144 xlinks_list = self[(pair_ids[1], pair_ids[0])]
145 ys = [xl.clone()
for xl
in xlinks_list]
150 except KeyError
as e:
156 return self[pair_ids]
158 print pair_ids,"NOT FOUND, swapping to",(pair_ids[1], pair_ids[0])
159 # If not found, invert the pair
160 xlinks_list = self[(pair_ids[1], pair_ids[0])]
161 # swap the xlinks, so the first element of the pair corresponds
162 # to the first id in the xlink
163 for xl in xlinks_list:
165 for xl in xlinks_list:
174 Compute the order of the docking experiments. The order is derived
175 from the cross-linking restraints:
176 1) The subunit with the highest number of cross-links with others
177 works as the first receptor (A)
178 2) All the subunits cross-linked with A are docked into A.
179 3) The next receptor (B) is the subunit that has the highest number of
181 4) All the subunits cross-linked to B are docked into B (except A)
182 5) The procedure is repeated until there are no more cross-links
190 Instead of setting the xlink restraints, init the graph directly
191 Example of what to pass with the structure in 3sfd
192 G.add_nodes_from(["A", "B", "C", "D"])
193 G.add_edges_from([("B","C"), ("B","A"), ("B","D"), ("C","D")])
194 ("B","C") means that there are cross-links between B and C
196 self.G.add_nodes_from(subunits)
197 self.G.add_edges_from(edges)
201 Sets the xlinks used for computing the docking order
202 @param xlinks_dict XlinksDict class
208 """ return the order to dock components from the cross links """
210 degs = self.G.degree(self.G.nodes())
211 log.debug(
"Degrees: %s", degs)
212 sorted_degrees = sorted(((v, k)
for (k, v)
in dict(degs).items()),
215 receptors_considered = []
216 for degree, node
in sorted_degrees:
217 for n
in self.G.neighbors(node):
218 if n
not in receptors_considered:
219 docking_pairs.append((node, n))
220 receptors_considered.append(node)
221 log.info(
"The suggested order for the docking pairs is %s",
229 Puts two subunits together using the Xlinkins restraints. The solutions
230 offered by this class are just an initial position of the components
234 def clear_xlinks(self):
235 self.xlinks_list = []
239 Sets the xlinks used for the computation for the initial rough
241 @param xlinks_list A list of Xlink classes
242 residue1 belongs to the receptor and residue2 belongs to the ligand
244 self.xlinks_list = xlinks_list
248 Set the name of the PDB files of the receptor and the ligand
254 self.h_receptor = atom.read_pdb(fn_receptor, self.m_receptor, sel)
256 self.h_ligand = atom.read_pdb(fn_ligand, self.m_ligand, sel)
260 Set the hierarchies (atom.Hierarchy objects) for the receptor and
265 self.h_receptor = h_receptor
266 self.h_ligand = h_ligand
270 Sets the rigid bodies (core.RigidBody objects) for the receptor and
275 self.rb_receptor = rb_receptor
276 self.rb_ligand = rb_ligand
280 Movest the ligand close to the receptor based on the xlinks
281 provided by set_xlinks()
283 log.debug(
"Moving ligand close to the receptor using the xlinks")
284 n = len(self.xlinks_list)
292 Get the particle representing a residue in a hierarchy
293 @param h atom.Hierarchy containing the residue
294 @param ch The chain id
295 @param res index of the residue
298 return s.get_selected_particles()[0]
302 Get the coordinates for a residue in a molecular hierarchy
303 @param h atom.Hierarchy object
304 @param ch The chain id
305 @param res Residue index
308 return core.XYZ(p).get_coordinates()
312 Write a pdb file the coordinates of the ligand
315 atom.write_pdb(self.h_ligand, fn)
319 Put the residues in a random distance between 0 and the maximum
320 cross-linkin distance
322 xl = self.xlinks_list[0]
325 sph = alg.Sphere3D(center, xl.distance)
326 v = alg.get_random_vector_in(sph)
327 ref = self.rb_ligand.get_reference_frame()
328 coords = ref.get_transformation_to().get_translation()
329 R = ref.get_transformation_to().get_rotation()
332 log.debug(
"Ligand residue before moving %s", lig)
333 displacement = v - lig
334 T = alg.Transformation3D(R, coords + displacement)
335 self.rb_ligand.set_reference_frame(alg.ReferenceFrame3D(T))
337 self.h_ligand, xl.second_chain,
339 log.debug(
"ligand after moving %s", new_coords)
343 Function equivalent to move_one_xlink() for the case where there
344 are more than one cross-link restraints available.
345 Puts the ligand residues as close as possible to the receptor
350 for xl
in self.xlinks_list:
357 log.debug(
"Receptor residues before moving %s", rec_coords)
358 log.debug(
"Ligand residues before moving %s", lig_coords)
359 ref = self.rb_ligand.get_reference_frame()
360 Tr = alg.get_transformation_aligning_first_to_second(lig_coords,
362 T = ref.get_transformation_to()
363 newT = alg.compose(Tr, T)
364 self.rb_ligand.set_reference_frame(alg.ReferenceFrame3D(newT))
366 moved_lig_coords = []
367 for xl
in self.xlinks_list:
370 moved_lig_coords.append(c)
371 log.debug(
"Ligand residues after moving %s", moved_lig_coords)
def write_ligand
Write a pdb file the coordinates of the ligand.
def move_ligand
Movest the ligand close to the receptor based on the xlinks provided by set_xlinks() ...
def set_pdbs
Set the name of the PDB files of the receptor and the ligand.
Class defining a cross-link.
def get_name
Generate a unique name for the restraint.
Class for storing model, its restraints, constraints, and particles.
Select all non-alternative ATOM records.
def set_xlinks
Sets the xlinks used for the computation for the initial rough docking solution.
def set_xlinks
Sets the xlinks used for computing the docking order.
Compute the order of the docking experiments.
def build_xlinks_graph
Build a set of nodes and edges from the set of crosslinking restraints.
def __init__
Initialize the class.
A decorator for a particle with x,y,z coordinates.
def get_residue_particle
Get the particle representing a residue in a hierarchy.
def get_docking_order
return the order to dock components from the cross links
std::ostream & show(Hierarchy h, std::ostream &out=std::cout)
Print the hierarchy using a given decorator to display each node.
Description of crosslinking restraints as a python dictionary.
Basic functionality that is expected to be used by a wide variety of IMP users.
General purpose algebraic and geometric methods that are expected to be used by a wide variety of IMP...
def swap
swaps the order of the residues in the restraint
def set_components_and_connections
Instead of setting the xlink restraints, init the graph directly Example of what to pass with the str...
def move_one_xlink
Put the residues in a random distance between 0 and the maximum cross-linkin distance.
def set_rigid_bodies
Sets the rigid bodies (core.RigidBody objects) for the receptor and the ligand.
Functionality for loading, creating, manipulating and scoring atomic structures.
def get_residue_coordinates
Get the coordinates for a residue in a molecular hierarchy.
Select hierarchy particles identified by the biological name.
def set_hierarchies
Set the hierarchies (atom.Hierarchy objects) for the receptor and the ligand.
Puts two subunits together using the Xlinkins restraints.
def move_xlinks
Function equivalent to move_one_xlink() for the case where there are more than one cross-link restrai...