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