IMP logo
IMP Reference Guide  2.9.0
The Integrative Modeling Platform
npc_restraints.py
1 import IMP.npc
3 
4 class XYRadialPositionRestraint(object):
5  """Create XYRadial Position Restraint
6  """
7  def __init__(self,
8  representation = None,
9  protein = None,
10  lower_bound = 0.0,
11  upper_bound = 0.0,
12  consider_radius = False,
13  sigma = 1.0,
14  term = 'C',
15  hier = None):
16  """Constructor
17  @param representation representation
18  """
19 
20  # PMI1/2 selection
21  if representation is None and hier is not None:
22  self.m = hier.get_model()
23  elif hier is None and representation is not None:
24  self.m = representation.prot.get_model()
25  else:
26  raise Exception("XYRadialPositionRestraint: must pass hier or representation")
27 
28  self.rs = IMP.RestraintSet(self.m, 'XYRadialPositionRestraint')
29  self.weight=1.0
30  self.label = "None"
31 
32  xyr = IMP.npc.XYRadialPositionRestraint(self.m, lower_bound, upper_bound, consider_radius, sigma)
33  #terminal_residue = IMP.pmi.tools.get_terminal_residue(representation, representation.hier_dict[protein], terminus="C")
34  residues = IMP.pmi.tools.select_by_tuple(representation, protein, resolution=1)
35  if (term == 'C'):
36  terminal = residues[-1]
37  #print (terminal, type(terminal))
38  xyr.add_particle(terminal)
39  elif (term == 'N'):
40  terminal = residues[0]
41  #print (terminal, type(terminal))
42  xyr.add_particle(terminal)
43  else:
44  for residue in residues:
45  #print (residue, type(residue))
46  xyr.add_particle(residue)
47  self.rs.add_restraint(xyr)
48 
49  def set_label(self, label):
50  self.label = label
51 
52  def add_to_model(self):
54 
55  def get_restraint(self):
56  return self.rs
57 
58  def set_weight(self, weight):
59  self.weight = weight
60  self.rs.set_weight(self.weight)
61 
62  def get_output(self):
63  self.m.update()
64  output = {}
65  score = self.weight * self.rs.unprotected_evaluate(None)
66  output["_TotalScore"] = str(score)
67  output["XYRadialPositionRestraint_" + self.label] = str(score)
68  return output
69 
70  def evaluate(self):
71  return self.weight * self.rs.unprotected_evaluate(None)
72 
74  """Create XYRadial Position Lower restraints
75  """
76  def __init__(self,
77  representation = None,
78  protein = None,
79  lower_bound = 0.0,
80  consider_radius = False,
81  sigma = 1.0,
82  hier = None):
83  """Constructor
84  @param representation representation
85  """
86 
87  # PMI1/2 selection
88  if representation is None and hier is not None:
89  self.m = hier.get_model()
90  elif hier is None and representation is not None:
91  self.m = representation.prot.get_model()
92  else:
93  raise Exception("XYRadialPositionLowerRestraint: must pass hier or representation")
94 
95  self.rs = IMP.RestraintSet(self.m, 'XYRadialPositionLowerRestraint')
96  self.weight=1.0
97  self.label = "None"
98 
99  xyr = IMP.npc.XYRadialPositionLowerRestraint(self.m, lower_bound, consider_radius, sigma)
100  #terminal_residue = IMP.pmi.tools.get_terminal_residue(representation, representation.hier_dict[protein], terminus="C")
101  residues = IMP.pmi.tools.select_by_tuple(representation, protein, resolution=1)
102  cterminal = residues[-1] #nterminal = residues[0]
103  #print (cterminal, type(cterminal))
104 
105  xyr.add_particle(cterminal)
106  self.rs.add_restraint(xyr)
107 
108  def set_label(self, label):
109  self.label = label
110 
111  def add_to_model(self):
112  IMP.pmi.tools.add_restraint_to_model(self.m, self.rs)
113 
114  def get_restraint(self):
115  return self.rs
116 
117  def set_weight(self, weight):
118  self.weight = weight
119  self.rs.set_weight(self.weight)
120 
121  def get_output(self):
122  self.m.update()
123  output = {}
124  score = self.weight * self.rs.unprotected_evaluate(None)
125  output["_TotalScore"] = str(score)
126  output["XYRadialPositionLowerRestraint_" + self.label] = str(score)
127  return output
128 
129  def evaluate(self):
130  return self.weight * self.rs.unprotected_evaluate(None)
131 
133  """Create XYRadial Position Upper restraints
134  """
135  def __init__(self,
136  representation = None,
137  protein = None,
138  upper_bound = 0.0,
139  consider_radius = False,
140  sigma = 1.0,
141  hier = None):
142  """Constructor
143  @param representation representation
144  """
145 
146  # PMI1/2 selection
147  if representation is None and hier is not None:
148  self.m = hier.get_model()
149  elif hier is None and representation is not None:
150  self.m = representation.prot.get_model()
151  else:
152  raise Exception("XYRadialPositionUpperRestraint: must pass hier or representation")
153 
154  self.rs = IMP.RestraintSet(self.m, 'XYRadialPositionUpperRestraint')
155  self.weight=1.0
156  self.label = "None"
157 
158  xyr = IMP.npc.XYRadialPositionUpperRestraint(self.m, upper_bound, consider_radius, sigma)
159  #terminal_residue = IMP.pmi.tools.get_terminal_residue(representation, representation.hier_dict[protein], terminus="C")
160  residues = IMP.pmi.tools.select_by_tuple(representation, protein, resolution=1)
161  cterminal = residues[-1] #nterminal = residues[0]
162  #print (cterminal, type(cterminal))
163 
164  xyr.add_particle(cterminal)
165  self.rs.add_restraint(xyr)
166 
167  def set_label(self, label):
168  self.label = label
169 
170  def add_to_model(self):
171  IMP.pmi.tools.add_restraint_to_model(self.m, self.rs)
172 
173  def get_restraint(self):
174  return self.rs
175 
176  def set_weight(self, weight):
177  self.weight = weight
178  self.rs.set_weight(self.weight)
179 
180  def get_output(self):
181  self.m.update()
182  output = {}
183  score = self.weight * self.rs.unprotected_evaluate(None)
184  output["_TotalScore"] = str(score)
185  output["XYRadialPositionUpperRestraint_" + self.label] = str(score)
186  return output
187 
188  def evaluate(self):
189  return self.weight * self.rs.unprotected_evaluate(None)
190 
191 
193  """Create Z-Axial Position restraints
194  """
195  def __init__(self,
196  representation = None,
197  protein = None,
198  lower_bound = 0.0,
199  upper_bound = 0.0,
200  consider_radius = False,
201  sigma = 1.0,
202  term = 'C',
203  hier = None):
204  """Constructor
205  @param representation representation
206  """
207 
208  # PMI1/2 selection
209  if representation is None and hier is not None:
210  self.m = hier.get_model()
211  elif hier is None and representation is not None:
212  self.m = representation.prot.get_model()
213  else:
214  raise Exception("ZAxialPositionRestraint: must pass hier or representation")
215 
216  self.rs = IMP.RestraintSet(self.m, 'ZAxialPositionRestraint')
217  self.weight=1.0
218  self.label = "None"
219 
220  zax = IMP.npc.ZAxialPositionRestraint(self.m, lower_bound, upper_bound, consider_radius, sigma)
221  #terminal_residue = IMP.pmi.tools.get_terminal_residue(representation, representation.hier_dict[protein], terminus="C")
222  residues = IMP.pmi.tools.select_by_tuple(representation, protein, resolution=1)
223  if term == 'C':
224  residues = residues[-1:]
225  elif term == 'N':
226  residues = residues[:1]
227  for residue in residues:
228  zax.add_particle(residue)
229 
230  self.dataset = None
231  if representation:
232  for p, state in representation._protocol_output:
233  p.add_zaxial_restraint(state, residues, lower_bound,
234  upper_bound, sigma, self)
235 
236  self.rs.add_restraint(zax)
237 
238  def set_label(self, label):
239  self.label = label
240 
241  def add_to_model(self):
242  IMP.pmi.tools.add_restraint_to_model(self.m, self.rs)
243 
244  def get_restraint(self):
245  return self.rs
246 
247  def set_weight(self, weight):
248  self.weight = weight
249  self.rs.set_weight(self.weight)
250 
251  def get_output(self):
252  self.m.update()
253  output = {}
254  score = self.weight * self.rs.unprotected_evaluate(None)
255  output["_TotalScore"] = str(score)
256  output["ZAxialPositionRestraint_" + self.label] = str(score)
257  return output
258 
259  def evaluate(self):
260  return self.weight * self.rs.unprotected_evaluate(None)
261 
263  """Create Z-Axial Position Lower restraints
264  """
265  def __init__(self,
266  representation = None,
267  protein = None,
268  lower_bound = 0.0,
269  consider_radius = False,
270  sigma = 1.0,
271  hier = None):
272  """Constructor
273  @param representation representation
274  """
275 
276  # PMI1/2 selection
277  if representation is None and hier is not None:
278  self.m = hier.get_model()
279  elif hier is None and representation is not None:
280  self.m = representation.prot.get_model()
281  else:
282  raise Exception("ZAxialPositionLowerRestraint: must pass hier or representation")
283 
284  self.rs = IMP.RestraintSet(self.m, 'ZAxialPositionLowerRestraint')
285  self.weight=1.0
286  self.label = "None"
287 
288  zax = IMP.npc.ZAxialPositionLowerRestraint(self.m, lower_bound, consider_radius, sigma)
289  #terminal_residue = IMP.pmi.tools.get_terminal_residue(representation, representation.hier_dict[protein], terminus="C")
290  residues = IMP.pmi.tools.select_by_tuple(representation, protein, resolution=1)
291  cterminal = residues[-1] #nterminal = residues[0]
292  #print (cterminal, type(cterminal))
293 
294  zax.add_particle(cterminal)
295  self.rs.add_restraint(zax)
296 
297  def set_label(self, label):
298  self.label = label
299 
300  def add_to_model(self):
301  IMP.pmi.tools.add_restraint_to_model(self.m, self.rs)
302 
303  def get_restraint(self):
304  return self.rs
305 
306  def set_weight(self, weight):
307  self.weight = weight
308  self.rs.set_weight(self.weight)
309 
310  def get_output(self):
311  self.m.update()
312  output = {}
313  score = self.weight * self.rs.unprotected_evaluate(None)
314  output["_TotalScore"] = str(score)
315  output["ZAxialPositionLowerRestraint_" + self.label] = str(score)
316  return output
317 
318  def evaluate(self):
319  return self.weight * self.rs.unprotected_evaluate(None)
320 
322  """Create Z-Axial Position Upper restraints
323  """
324  def __init__(self,
325  representation = None,
326  protein = None,
327  upper_bound = 0.0,
328  consider_radius = False,
329  sigma = 1.0,
330  hier = None):
331  """Constructor
332  @param representation representation
333  """
334 
335  # PMI1/2 selection
336  if representation is None and hier is not None:
337  self.m = hier.get_model()
338  elif hier is None and representation is not None:
339  self.m = representation.prot.get_model()
340  else:
341  raise Exception("ZAxialPositionUpperRestraint: must pass hier or representation")
342 
343  self.rs = IMP.RestraintSet(self.m, 'ZAxialPositionUpperRestraint')
344  self.weight=1.0
345  self.label = "None"
346 
347  zax = IMP.npc.ZAxialPositionUpperRestraint(self.m, upper_bound, consider_radius, sigma)
348  #terminal_residue = IMP.pmi.tools.get_terminal_residue(representation, representation.hier_dict[protein], terminus="C")
349  residues = IMP.pmi.tools.select_by_tuple(representation, protein, resolution=1)
350  cterminal = residues[-1] #nterminal = residues[0]
351  #print (cterminal, type(cterminal))
352 
353  zax.add_particle(cterminal)
354  self.rs.add_restraint(zax)
355 
356  def set_label(self, label):
357  self.label = label
358 
359  def add_to_model(self):
360  IMP.pmi.tools.add_restraint_to_model(self.m, self.rs)
361 
362  def get_restraint(self):
363  return self.rs
364 
365  def set_weight(self, weight):
366  self.weight = weight
367  self.rs.set_weight(self.weight)
368 
369  def get_output(self):
370  self.m.update()
371  output = {}
372  score = self.weight * self.rs.unprotected_evaluate(None)
373  output["_TotalScore"] = str(score)
374  output["ZAxialPositionUpperRestraint_" + self.label] = str(score)
375  return output
376 
377  def evaluate(self):
378  return self.weight * self.rs.unprotected_evaluate(None)
379 
380 
382  """Create Y-Axial Position restraints
383  """
384  def __init__(self,
385  representation = None,
386  protein = None,
387  lower_bound = 0.0,
388  upper_bound = 0.0,
389  consider_radius = False,
390  sigma = 1.0,
391  term = 'C',
392  hier = None):
393  """Constructor
394  @param representation representation
395  """
396 
397  # PMI1/2 selection
398  if representation is None and hier is not None:
399  self.m = hier.get_model()
400  elif hier is None and representation is not None:
401  self.m = representation.prot.get_model()
402  else:
403  raise Exception("YAxialPositionRestraint: must pass hier or representation")
404 
405  self.rs = IMP.RestraintSet(self.m, 'YAxialPositionRestraint')
406  self.weight=1.0
407  self.label = "None"
408 
409  yax = IMP.npc.YAxialPositionRestraint(self.m, lower_bound, upper_bound, consider_radius, sigma)
410  #terminal_residue = IMP.pmi.tools.get_terminal_residue(representation, representation.hier_dict[protein], terminus="C")
411  residues = IMP.pmi.tools.select_by_tuple(representation, protein, resolution=1)
412  if (term == 'C'):
413  terminal = residues[-1]
414  #print (terminal, type(terminal))
415  yax.add_particle(terminal)
416  elif (term == 'N'):
417  terminal = residues[0]
418  #print (terminal, type(terminal))
419  yax.add_particle(terminal)
420  else:
421  for residue in residues:
422  #print (residue, type(residue))
423  yax.add_particle(residue)
424  self.rs.add_restraint(yax)
425 
426  def set_label(self, label):
427  self.label = label
428 
429  def add_to_model(self):
430  IMP.pmi.tools.add_restraint_to_model(self.m, self.rs)
431 
432  def get_restraint(self):
433  return self.rs
434 
435  def set_weight(self, weight):
436  self.weight = weight
437  self.rs.set_weight(self.weight)
438 
439  def get_output(self):
440  self.m.update()
441  output = {}
442  score = self.weight * self.rs.unprotected_evaluate(None)
443  output["_TotalScore"] = str(score)
444  output["YAxialPositionRestraint_" + self.label] = str(score)
445  return output
446 
447  def evaluate(self):
448  return self.weight * self.rs.unprotected_evaluate(None)
449 
451  """Create Y-Axial Position Lower restraints
452  """
453  def __init__(self,
454  representation = None,
455  protein = None,
456  lower_bound = 0.0,
457  consider_radius = False,
458  sigma = 1.0,
459  hier = None):
460  """Constructor
461  @param representation representation
462  """
463 
464  # PMI1/2 selection
465  if representation is None and hier is not None:
466  self.m = hier.get_model()
467  elif hier is None and representation is not None:
468  self.m = representation.prot.get_model()
469  else:
470  raise Exception("YAxialPositionLowerRestraint: must pass hier or representation")
471 
472  self.rs = IMP.RestraintSet(self.m, 'YAxialPositionLowerRestraint')
473  self.weight=1.0
474  self.label = "None"
475 
476  yax = IMP.npc.YAxialPositionLowerRestraint(self.m, lower_bound, consider_radius, sigma)
477  #terminal_residue = IMP.pmi.tools.get_terminal_residue(representation, representation.hier_dict[protein], terminus="C")
478  residues = IMP.pmi.tools.select_by_tuple(representation, protein, resolution=1)
479  cterminal = residues[-1] #nterminal = residues[0]
480  #print (cterminal, type(cterminal))
481 
482  yax.add_particle(cterminal)
483  self.rs.add_restraint(yax)
484 
485  def set_label(self, label):
486  self.label = label
487 
488  def add_to_model(self):
489  IMP.pmi.tools.add_restraint_to_model(self.m, self.rs)
490 
491  def get_restraint(self):
492  return self.rs
493 
494  def set_weight(self, weight):
495  self.weight = weight
496  self.rs.set_weight(self.weight)
497 
498  def get_output(self):
499  self.m.update()
500  output = {}
501  score = self.weight * self.rs.unprotected_evaluate(None)
502  output["_TotalScore"] = str(score)
503  output["YAxialPositionLowerRestraint_" + self.label] = str(score)
504  return output
505 
506  def evaluate(self):
507  return self.weight * self.rs.unprotected_evaluate(None)
508 
510  """Create Y-Axial Position Upper restraints
511  """
512  def __init__(self,
513  representation = None,
514  protein = None,
515  upper_bound = 0.0,
516  consider_radius = False,
517  sigma = 1.0,
518  hier = None):
519  """Constructor
520  @param representation representation
521  """
522 
523  # PMI1/2 selection
524  if representation is None and hier is not None:
525  self.m = hier.get_model()
526  elif hier is None and representation is not None:
527  self.m = representation.prot.get_model()
528  else:
529  raise Exception("YAxialPositionUpperRestraint: must pass hier or representation")
530 
531  self.rs = IMP.RestraintSet(self.m, 'YAxialPositionUpperRestraint')
532  self.weight=1.0
533  self.label = "None"
534 
535  yax = IMP.npc.YAxialPositionUpperRestraint(self.m, upper_bound, consider_radius, sigma)
536  #terminal_residue = IMP.pmi.tools.get_terminal_residue(representation, representation.hier_dict[protein], terminus="C")
537  residues = IMP.pmi.tools.select_by_tuple(representation, protein, resolution=1)
538  cterminal = residues[-1] #nterminal = residues[0]
539  #print (cterminal, type(cterminal))
540 
541  yax.add_particle(cterminal)
542  self.rs.add_restraint(yax)
543 
544  def set_label(self, label):
545  self.label = label
546 
547  def add_to_model(self):
548  IMP.pmi.tools.add_restraint_to_model(self.m, self.rs)
549 
550  def get_restraint(self):
551  return self.rs
552 
553  def set_weight(self, weight):
554  self.weight = weight
555  self.rs.set_weight(self.weight)
556 
557  def get_output(self):
558  self.m.update()
559  output = {}
560  score = self.weight * self.rs.unprotected_evaluate(None)
561  output["_TotalScore"] = str(score)
562  output["YAxialPositionUpperRestraint_" + self.label] = str(score)
563  return output
564 
565  def evaluate(self):
566  return self.weight * self.rs.unprotected_evaluate(None)
567 
568 
570  """Create Membrane Surface Location Restraint
571  """
572  def __init__(self,
573  representation = None,
574  protein = None,
575  tor_R = 540.0,
576  tor_r = 127.5,
577  tor_th = 45.0,
578  sigma = 0.2,
579  resolution = 1,
580  hier = None):
581  """Constructor
582  @param representation representation
583  """
584 
585  # PMI1/2 selection
586  if representation is None and hier is not None:
587  self.m = hier.get_model()
588  elif hier is None and representation is not None:
589  self.m = representation.prot.get_model()
590  else:
591  raise Exception("MembraneSurfaceLocationRestraint: must pass hier or representation")
592 
593  self.rs = IMP.RestraintSet(self.m, 'MembraneSurfaceLocationRestraint')
594  self.weight=1.0
595  self.label = "None"
596 
597  msl = IMP.npc.MembraneSurfaceLocationRestraint(self.m, tor_R, tor_r, tor_th, sigma)
598  residues = IMP.pmi.tools.select_by_tuple(representation, protein, resolution=resolution)
599  for residue in residues:
600  #print (residue, type(residue))
601  msl.add_particle(residue)
602 
603  self.dataset = None
604  if representation:
605  for p, state in representation._protocol_output:
606  p.add_membrane_surface_location_restraint(
607  state, residues, tor_R, tor_r, tor_th, sigma, self)
608 
609  self.rs.add_restraint(msl)
610 
611  def set_label(self, label):
612  self.label = label
613 
614  def add_to_model(self):
615  IMP.pmi.tools.add_restraint_to_model(self.m, self.rs)
616 
617  def get_restraint(self):
618  return self.rs
619 
620  def set_weight(self, weight):
621  self.weight = weight
622  self.rs.set_weight(self.weight)
623 
624  def get_output(self):
625  self.m.update()
626  output = {}
627  score = self.weight * self.rs.unprotected_evaluate(None)
628  output["_TotalScore"] = str(score)
629  output["MembraneSurfaceLocationRestraint_" + self.label] = str(score)
630  return output
631 
632  def evaluate(self):
633  return self.weight * self.rs.unprotected_evaluate(None)
634 
635 
637  """Create Membrane Surface Location CONDITIONAL Restraint
638  for Nup120 ALPS Motifs - Mutually Exclusive from (135,152,'Nup120') and (197,216,'Nup120').
639  It returns a minimum penalty score from two potential ALPS motifs.
640  """
641  def __init__(self,
642  representation = None,
643  protein1 = None,
644  protein2 = None,
645  tor_R = 540.0,
646  tor_r = 127.5,
647  tor_th = 45.0,
648  sigma = 0.2,
649  resolution = 1,
650  hier = None):
651  """Constructor
652  @param representation representation
653  """
654 
655  # PMI1/2 selection
656  if representation is None and hier is not None:
657  self.m = hier.get_model()
658  elif hier is None and representation is not None:
659  self.m = representation.prot.get_model()
660  else:
661  raise Exception("MembraneSurfaceLocationConditionalRestraint: must pass hier or representation")
662 
663  self.rs = IMP.RestraintSet(self.m, 'MembraneSurfaceLocationConditionalRestraint')
664  self.weight=1.0
665  self.label = "None"
666 
667  msl = IMP.npc.MembraneSurfaceLocationConditionalRestraint(self.m, tor_R, tor_r, tor_th, sigma)
668  residues1 = IMP.pmi.tools.select_by_tuple(representation, protein1, resolution=resolution)
669  for residue in residues1:
670  #print (residue, type(residue))
671  msl.add_particle1(residue)
672  residues2 = IMP.pmi.tools.select_by_tuple(representation, protein2, resolution=resolution)
673  for residue in residues2:
674  #print (residue, type(residue))
675  msl.add_particle2(residue)
676  self.rs.add_restraint(msl)
677 
678  def set_label(self, label):
679  self.label = label
680 
681  def add_to_model(self):
682  IMP.pmi.tools.add_restraint_to_model(self.m, self.rs)
683 
684  def get_restraint(self):
685  return self.rs
686 
687  def set_weight(self, weight):
688  self.weight = weight
689  self.rs.set_weight(self.weight)
690 
691  def get_output(self):
692  self.m.update()
693  output = {}
694  score = self.weight * self.rs.unprotected_evaluate(None)
695  output["_TotalScore"] = str(score)
696  output["MembraneSurfaceLocationConditionalRestraint_" + self.label] = str(score)
697  return output
698 
699  def evaluate(self):
700  return self.weight * self.rs.unprotected_evaluate(None)
701 
702 
704  """Create Membrane Exclusion Restraint
705  """
706  def __init__(self,
707  representation = None,
708  protein = None,
709  tor_R = 540.0,
710  tor_r = 127.5,
711  tor_th = 45.0,
712  sigma = 0.2,
713  resolution = 1,
714  hier = None):
715  """Constructor
716  @param representation representation
717  """
718 
719  # PMI1/2 selection
720  if representation is None and hier is not None:
721  self.m = hier.get_model()
722  elif hier is None and representation is not None:
723  self.m = representation.prot.get_model()
724  else:
725  raise Exception("MembraneExclusionRestraint: must pass hier or representation")
726 
727  self.rs = IMP.RestraintSet(self.m, 'MembraneExclusionRestraint')
728  self.weight=1.0
729  self.label = "None"
730 
731  mex = IMP.npc.MembraneExclusionRestraint(self.m, tor_R, tor_r, tor_th, sigma)
732  residues = IMP.pmi.tools.select_by_tuple(representation, protein, resolution=resolution)
733  for residue in residues:
734  #print (residue, type(residue))
735  mex.add_particle(residue)
736  self.rs.add_restraint(mex)
737 
738  def set_label(self, label):
739  self.label = label
740 
741  def add_to_model(self):
742  IMP.pmi.tools.add_restraint_to_model(self.m, self.rs)
743 
744  def get_restraint(self):
745  return self.rs
746 
747  def set_weight(self, weight):
748  self.weight = weight
749  self.rs.set_weight(self.weight)
750 
751  def get_output(self):
752  self.m.update()
753  output = {}
754  score = self.weight * self.rs.unprotected_evaluate(None)
755  output["_TotalScore"] = str(score)
756  output["MembraneExclusionRestraint_" + self.label] = str(score)
757  return output
758 
759  def evaluate(self):
760  return self.weight * self.rs.unprotected_evaluate(None)
Create Z-Axial Position Upper restraints.
Restrain particles by their z coordinate.
Create Z-Axial Position restraints.
Restrain particles by their y coordinate.
Create Membrane Surface Location CONDITIONAL Restraint for Nup120 ALPS Motifs - Mutually Exclusive fr...
Restrain particles by their distance from the z axis in the xy plane.
Create Y-Axial Position restraints.
Try to keep one set of particles localized on a membrane surface.
Restrain particles by their z coordinate.
Create Membrane Surface Location Restraint.
Representation of the system.
Object used to hold a set of restraints.
Definition: RestraintSet.h:36
Create Y-Axial Position Lower restraints.
def add_restraint_to_model
Add a PMI restraint to the model.
Definition: tools.py:50
Try to keep particles away from a membrane.
Restrain particles by their distance from the z axis in the xy plane.
Try to keep particles localized on a membrane surface.
Create Y-Axial Position Upper restraints.
The general base class for IMP exceptions.
Definition: exception.h:49
Create Z-Axial Position Lower restraints.
Restraints designed for modeling the Nuclear Pore Complex (NPC)
Create XYRadial Position Lower restraints.
Create Membrane Exclusion Restraint.
Restrain particles by their z coordinate.
Restrain particles by their distance from the z axis in the xy plane.
Restrain particles by their y coordinate.
Create XYRadial Position Upper restraints.
Restrain particles by their y coordinate.