1 from __future__
import print_function
9 from collections
import defaultdict
13 """A class to read RMF files and make a network contact map"""
14 def __init__(self,model,selections,cutoff,frequency_cutoff,
15 colors=
None,fixed=
None,pos=
None,proteomic_edges=
None,quantitative_proteomic_data=
None):
16 """Set up a new graphXL object
17 @param model The IMP model
18 @param selection_dict A dictionary containing component names.
20 values are either moleculename or start,stop,moleculename
21 @param cutoff The distance cutoff
22 @param frequency_cutoff The frequency cutoff
23 @param colors A dictionary of colors (HEX code,values) for subunits (keywords)
24 @param fixed A list of subunits that are kept fixed
25 @param pos A dictionary with positions (tuple, values) of subunits (keywords)
26 @param proteomic_edges A list edges to represent proteomic data
27 @param quantitative_proteomic_data A dictionary of edges to represent
28 quantitative proteomic data such as PE Scores, or genetic interactions
33 self.selections = selections
34 self.contact_counts={}
35 self.edges=defaultdict(int)
36 for (name1,name2)
in itertools.combinations(self.selections.keys(),2):
37 self.edges[tuple(sorted((name1,name2)))]=0
39 self.frequency_cutoff=frequency_cutoff
41 self.gcpf.set_distance(self.cutoff)
42 self.names = list(self.selections.keys())
46 self.proteomic_edges=proteomic_edges
47 self.quantitative_proteomic_data=quantitative_proteomic_data
56 """Add selections from an RMF file"""
57 print(
'reading from RMF file',rmf_fn)
58 rh = RMF.open_rmf_file_read_only(rmf_fn)
62 ps_per_component=defaultdict(list)
64 self.size_per_component=defaultdict(int)
69 all_particles_by_resolution = []
70 for name
in part_dict:
71 all_particles_by_resolution += part_dict[name]
73 for component_name
in self.selections:
74 for seg
in self.selections[component_name]:
77 elif type(seg) == tuple:
79 residue_indexes=range(seg[0], seg[1] + 1))
81 raise Exception(
'could not understand selection tuple '+str(seg))
82 parts = list(set(s.get_selected_particles()) & set(all_particles_by_resolution))
87 for n1,name1
in enumerate(self.names):
88 for name2
in self.names[n1+1:]:
89 ncontacts = len(self.gcpf.get_close_pairs(self.model,
90 ps_per_component[name1],
91 ps_per_component[name2]))
93 self.edges[tuple(sorted((name1,name2)))]+=1.0
97 def make_plot(self,groups,out_fn,quantitative_proteomic_data=False):
99 plot the interaction matrix
100 @param groups is the list of groups of domains, eg,
101 [["protA_1-10","prot1A_11-100"],["protB"]....]
102 it will plot a space between different groups
103 @param out_fn name of the plot file
104 @param quantitative_proteomic_data plot the quantitative proteomic data
107 import matplotlib.pyplot
as plt
108 from matplotlib
import cm
111 ax.set_aspect(
'equal',
'box')
112 ax.xaxis.set_major_locator(plt.NullLocator())
113 ax.yaxis.set_major_locator(plt.NullLocator())
122 xoffset=squaredistance
123 yoffset=squaredistance
129 for subgroup
in group:
132 for domain
in subgroup:
133 domain_xlocations[domain]=xoffset
134 domain_ylocations[domain]=yoffset
140 xoffset+=squaredistance
141 yoffset+=squaredistance
143 for edge,count
in self.edges.items():
145 if quantitative_proteomic_data:
147 maxqpd=max(self.quantitative_proteomic_data.values())
148 minqpd=min(self.quantitative_proteomic_data.values())
149 if edge
in self.quantitative_proteomic_data:
150 value=self.quantitative_proteomic_data[edge]
151 elif (edge[1],edge[0])
in self.quantitative_proteomic_data:
152 value=self.quantitative_proteomic_data[(edge[1],edge[0])]
156 density=(1.0-(value-minqpd)/(maxqpd-minqpd))
158 density=(1.0-float(count)/self.num_rmf)
159 color=(density,density,1.0)
160 x=domain_xlocations[edge[0]]
161 y=domain_ylocations[edge[1]]
162 if x>y: xtmp=y; ytmp=x; x=xtmp; y=ytmp
163 rect = plt.Rectangle([x - squaresize / 2, y - squaresize / 2], squaresize, squaresize,
164 facecolor=color, edgecolor=
'Gray', linewidth=0.1)
166 rect = plt.Rectangle([y - squaresize / 2, x - squaresize / 2], squaresize, squaresize,
167 facecolor=color, edgecolor=
'Gray', linewidth=0.1)
175 def make_graph(self,out_fn):
178 print(
'num edges',len(self.edges))
179 for edge,count
in self.edges.items():
181 if float(count)/self.num_rmf>self.frequency_cutoff:
184 weights.append(count)
185 for nw,w
in enumerate(weights):
186 weights[nw]=float(weights[nw])/max(weights)
187 IMP.pmi.output.draw_graph(edges,
188 node_size=dict(self.size_per_component),
189 node_color=self.colors,
196 validation_edges=self.proteomic_edges)
200 def draw_component_composition(DegreesOfFreedom, max=1000, draw_pdb_names=False,show=True):
201 """A function to plot the representation on the sequence
202 @param DegreesOfFreedom input a IMP.pmi.dof.DegreesOfFreedom instance"""
203 import matplotlib
as mpl
205 from matplotlib
import pyplot
206 from operator
import itemgetter
210 movers_mols_res=IMP.pmi.tools.OrderedDict()
211 for mv
in DegreesOfFreedom.movers_particles_map:
212 hs=DegreesOfFreedom.movers_particles_map[mv]
223 while not is_molecule:
227 if not mv
in movers_mols_res:
228 movers_mols_res[mv]=IMP.pmi.tools.OrderedDict()
229 movers_mols_res[mv][name]=IMP.pmi.tools.Segments(res)
231 if not name
in movers_mols_res[mv]:
232 movers_mols_res[mv][name]=IMP.pmi.tools.Segments(res)
234 movers_mols_res[mv][name].add(res)
239 for mv
in movers_mols_res:
246 srb_movers.append(mv)
250 for mol
in movers_mols_res[mv]:
251 for i
in movers_mols_res[mv][mol].get_flatten():
252 for mv_rb
in rb_movers:
254 movers_mols_res[mv_rb][mol].remove(i)
259 rgb_colors=[(240,163,255),(0,117,220),
260 (153,63,0),(76,0,92),(25,25,25),
261 (0,92,49),(43,206,72),(255,204,153),
262 (128,128,128),(148,255,181),(143,124,0),
263 (157,204,0),(194,0,136),(0,51,128),(255,164,5),
264 (255,168,187),(66,102,0),(255,0,16),(94,241,242),
265 (0,153,143),(224,255,102),(116,10,255),(153,0,0),
266 (255,255,128),(255,255,0),(255,80,5)]
267 colors=[(float(c0)/255,float(c1)/255,float(c2)/255)
for (c0,c1,c2)
in rgb_colors]
269 for mv
in movers_mols_res:
273 if not mv
in mvrb_color:
274 color=colors[len(mvrb_color.keys())]
276 for mol
in movers_mols_res[mv]:
277 if not mol
in elements: elements[mol]=[]
278 for seg
in movers_mols_res[mv][mol].segs:
280 elements[mol].append((seg[0],seg[-1],
" ",
"pdb",mvrb_color[mv]))
285 for mol
in movers_mols_res[mv]:
286 if not mol
in elements: elements[mol]=[]
287 for seg
in movers_mols_res[mv][mol].segs:
288 elements[mol].append((seg[0],seg[-1],
" ",
"bead"))
294 elements[mol].sort(key=
lambda tup: tup[0])
295 elements[mol].append((elements[mol][-1][1],elements[mol][-1][1],
" ",
"end"))
297 for name
in elements:
299 tmplist = sorted(elements[name], key=itemgetter(0))
301 endres = tmplist[-1][1]
303 print(
"draw_component_composition: missing information for component %s" % name)
305 fig = pyplot.figure(figsize=(26.0 * float(endres) / max + 2, 2))
306 ax = fig.add_axes([0.05, 0.475, 0.9, 0.15])
311 norm = mpl.colors.Normalize(vmin=5, vmax=10)
315 for n, l
in enumerate(tmplist):
319 if bounds[-1] != l[0]:
320 colors.append(
"white")
323 colors.append(
"#99CCFF")
325 colors.append(
"white")
327 colors.append(
"#33CCCC")
329 bounds.append(l[1] + 1)
334 colors.append(
"white")
336 colors.append(
"#33CCCC")
338 bounds.append(l[1] + 1)
340 if bounds[-1] - 1 == l[0]:
344 colors.append(
"white")
347 bounds.append(bounds[-1])
348 colors.append(
"white")
349 cmap = mpl.colors.ListedColormap(colors)
350 cmap.set_over(
'0.25')
351 cmap.set_under(
'0.75')
353 norm = mpl.colors.BoundaryNorm(bounds, cmap.N)
354 cb2 = mpl.colorbar.ColorbarBase(ax, cmap=cmap,
360 spacing=
'proportional',
361 orientation=
'horizontal')
370 mid = 1.0 / endres * float(l[0])
375 l[2], xy=(mid, 1), xycoords=
'axes fraction',
376 xytext=(mid + 0.025, float(npdb - 1) / 2.0 + 1.5), textcoords=
'axes fraction',
377 arrowprops=dict(arrowstyle=
"->",
378 connectionstyle=
"angle,angleA=0,angleB=90,rad=10"),
380 extra_artists.append(t)
383 title = ax.text(-0.005, 0.5, k, ha=
"right", va=
"center", rotation=90,
386 extra_artists.append(title)
388 labels = len(bounds) * [
" "]
389 ax.set_xticklabels(labels)
390 mid = 1.0 / endres * float(bounds[0])
391 t = ax.annotate(bounds[0], xy=(mid, 0), xycoords=
'axes fraction',
392 xytext=(mid - 0.01, -0.5), textcoords=
'axes fraction',)
393 extra_artists.append(t)
394 offsets = [0, -0.5, -1.0]
396 for n
in range(1, len(bounds)):
397 if bounds[n] == bounds[n - 1]:
399 mid = 1.0 / endres * float(bounds[n])
400 if (float(bounds[n]) - float(bounds[n - 1])) / max <= 0.01:
402 offset = offsets[nclashes % 3]
408 bounds[n], xy=(mid, 0), xycoords=
'axes fraction',
409 xytext=(mid, -0.5 + offset), textcoords=
'axes fraction')
412 bounds[n], xy=(mid, 0), xycoords=
'axes fraction',
413 xytext=(mid, -0.5 + offset), textcoords=
'axes fraction', arrowprops=dict(arrowstyle=
"-"))
414 extra_artists.append(t)
416 cb2.add_lines(bounds, [
"black"] * len(bounds), [1] * len(bounds))
static bool get_is_setup(const IMP::ParticleAdaptor &p)
A class to read RMF files and make a network contact map.
static bool get_is_setup(const IMP::ParticleAdaptor &p)
A decorator to associate a particle with a part of a protein/DNA/RNA.
atom::Hierarchies create_hierarchies(RMF::FileConstHandle fh, Model *m)
Modify the transformation of a rigid body.
def make_plot
plot the interaction matrix
Move continuous particle variables by perturbing them within a ball.
def add_rmf
Add selections from an RMF file.
static bool get_is_setup(Model *m, ParticleIndex pi)
A decorator for keeping track of copies of a molecule.
ParticleIndexPairs get_indexes(const ParticlePairsTemp &ps)
Ints get_index(const ParticlesTemp &particles, const Subset &subset, const Subsets &excluded)
def deprecated_method
Python decorator to mark a method as deprecated.
def __init__
Set up a new graphXL object.
void load_frame(RMF::FileConstHandle file, RMF::FrameID frame)
Load the given RMF frame into the state of the linked objects.
def get_particles_at_resolution_one
Get particles at res 1, or any beads, based on the name.
Tools for clustering and cluster analysis.
Find all nearby pairs by testing all pairs.
Classes for writing output files and processing them.
A decorator for a residue.
The general base class for IMP exceptions.
int get_copy_index(Hierarchy h)
Walk up the hierarchy to find the current copy index.
Python classes to represent, score, sample and analyze models.
Functionality for loading, creating, manipulating and scoring atomic structures.
A decorator for a molecule.
Select hierarchy particles identified by the biological name.
Support for the RMF file format for storing hierarchical molecular data and markup.