IMP logo
IMP Reference Guide  2.10.1
The Integrative Modeling Platform
Edit on GitHub version 2.10.1
ProteinLocalizationRestraint.h
Go to the documentation of this file.
1 /**
2  * \file IMP/npc/ProteinLocalizationRestraint.h
3  * \brief protein localization restraints
4  *
5  * Restrict max distance between at least one pair of particles of any
6  * two distinct types. It also handles multiple copies of the same particles.
7  *
8  * Copyright 2007-2018 IMP Inventors. All rights reserved.
9  *
10  */
11 
12 #ifndef IMPNPC_PROTEIN_LOCALIZATION_RESTRAINT_H
13 #define IMPNPC_PROTEIN_LOCALIZATION_RESTRAINT_H
14 
15 #include <IMP/Pointer.h>
16 #include <IMP/Restraint.h>
17 #include <IMP/npc/npc_config.h>
18 #include <IMP/SingletonContainer.h>
19 
20 IMPNPC_BEGIN_NAMESPACE
21 
22 //! Restrain particles by their z coordinate
23 /** Each particle's z coordinate is harmonically restrained to lie between
24  the given lower and upper bounds.
25  */
26 class IMPNPCEXPORT ZAxialPositionRestraint : public Restraint
27 {
28  IMP::PointerMember<IMP::SingletonContainer> sc_;
29  double lower_bound_;
30  double upper_bound_;
31  double sigma_;
32  bool consider_radius_;
33 public:
34  ZAxialPositionRestraint(Model *m, SingletonContainerAdaptor sc,
35  double lower_bound, double upper_bound, bool consider_radius, double sigma=1);
36  ZAxialPositionRestraint(Model *m,
37  double lower_bound, double upper_bound, bool consider_radius, double sigma=1);
38 
39 #ifndef IMP_DOXYGEN
40  void add_particle(Particle *p);
41  void add_particles(const ParticlesTemp &ps);
42  void set_particles(const ParticlesTemp &ps);
43 #endif
44 
45  double unprotected_evaluate(IMP::DerivativeAccumulator *accum) const;
46  ModelObjectsTemp do_get_inputs() const;
47 
48  IMP_OBJECT_METHODS(ZAxialPositionRestraint);;
49 };
50 
51 //! Restrain particles by their z coordinate
52 /** Each particle's z coordinate is harmonically restrained to lie above
53  the given lower bound.
54  */
55 class IMPNPCEXPORT ZAxialPositionLowerRestraint : public Restraint
56 {
57  IMP::PointerMember<IMP::SingletonContainer> sc_;
58  double lower_bound_;
59  double sigma_;
60  bool consider_radius_;
61 public:
62  ZAxialPositionLowerRestraint(Model *m, SingletonContainerAdaptor sc,
63  double lower_bound, bool consider_radius, double sigma=1);
64  ZAxialPositionLowerRestraint(Model *m,
65  double lower_bound, bool consider_radius, double sigma=1);
66 
67 #ifndef IMP_DOXYGEN
68  void add_particle(Particle *p);
69  void add_particles(const ParticlesTemp &ps);
70  void set_particles(const ParticlesTemp &ps);
71 #endif
72 
73  double unprotected_evaluate(IMP::DerivativeAccumulator *accum) const;
74  ModelObjectsTemp do_get_inputs() const;
75 
76  IMP_OBJECT_METHODS(ZAxialPositionLowerRestraint);;
77 };
78 
79 //! Restrain particles by their z coordinate
80 /** Each particle's z coordinate is harmonically restrained to lie below
81  the given upper bound.
82  */
83 class IMPNPCEXPORT ZAxialPositionUpperRestraint : public Restraint
84 {
85  IMP::PointerMember<IMP::SingletonContainer> sc_;
86  double upper_bound_;
87  double sigma_;
88  bool consider_radius_;
89 public:
90  ZAxialPositionUpperRestraint(Model *m, SingletonContainerAdaptor sc,
91  double upper_bound, bool consider_radius, double sigma=1);
92  ZAxialPositionUpperRestraint(Model *m,
93  double upper_bound, bool consider_radius, double sigma=1);
94 
95 #ifndef IMP_DOXYGEN
96  void add_particle(Particle *p);
97  void add_particles(const ParticlesTemp &ps);
98  void set_particles(const ParticlesTemp &ps);
99 #endif
100 
101  double unprotected_evaluate(IMP::DerivativeAccumulator *accum) const;
102  ModelObjectsTemp do_get_inputs() const;
103 
104  IMP_OBJECT_METHODS(ZAxialPositionUpperRestraint);;
105 };
106 
107 
108 //! Restrain particles by their y coordinate
109 /** Each particle's y coordinate is harmonically restrained to lie between
110  the given lower and upper bounds.
111  */
112 class IMPNPCEXPORT YAxialPositionRestraint : public Restraint
113 {
114  IMP::PointerMember<IMP::SingletonContainer> sc_;
115  double lower_bound_;
116  double upper_bound_;
117  double sigma_;
118  bool consider_radius_;
119 public:
120  YAxialPositionRestraint(Model *m, SingletonContainerAdaptor sc,
121  double lower_bound, double upper_bound, bool consider_radius, double sigma=1);
122  YAxialPositionRestraint(Model *m,
123  double lower_bound, double upper_bound, bool consider_radius, double sigma=1);
124 
125 #ifndef IMP_DOXYGEN
126  void add_particle(Particle *p);
127  void add_particles(const ParticlesTemp &ps);
128  void set_particles(const ParticlesTemp &ps);
129 #endif
130 
131  double unprotected_evaluate(IMP::DerivativeAccumulator *accum) const;
132  ModelObjectsTemp do_get_inputs() const;
133 
134  IMP_OBJECT_METHODS(YAxialPositionRestraint);;
135 };
136 
137 //! Restrain particles by their y coordinate
138 /** Each particle's y coordinate is harmonically restrained to lie above
139  the given lower bound.
140  */
141 class IMPNPCEXPORT YAxialPositionLowerRestraint : public Restraint
142 {
143  IMP::PointerMember<IMP::SingletonContainer> sc_;
144  double lower_bound_;
145  double sigma_;
146  bool consider_radius_;
147 public:
148  YAxialPositionLowerRestraint(Model *m, SingletonContainerAdaptor sc,
149  double lower_bound, bool consider_radius, double sigma=1);
150  YAxialPositionLowerRestraint(Model *m,
151  double lower_bound, bool consider_radius, double sigma=1);
152 
153 #ifndef IMP_DOXYGEN
154  void add_particle(Particle *p);
155  void add_particles(const ParticlesTemp &ps);
156  void set_particles(const ParticlesTemp &ps);
157 #endif
158 
159  double unprotected_evaluate(IMP::DerivativeAccumulator *accum) const;
160  ModelObjectsTemp do_get_inputs() const;
161 
162  IMP_OBJECT_METHODS(YAxialPositionLowerRestraint);;
163 };
164 
165 //! Restrain particles by their y coordinate
166 /** Each particle's y coordinate is harmonically restrained to lie below
167  the given upper bound.
168  */
169 class IMPNPCEXPORT YAxialPositionUpperRestraint : public Restraint
170 {
171  IMP::PointerMember<IMP::SingletonContainer> sc_;
172  double upper_bound_;
173  double sigma_;
174  bool consider_radius_;
175 public:
176  YAxialPositionUpperRestraint(Model *m, SingletonContainerAdaptor sc,
177  double upper_bound, bool consider_radius, double sigma=1);
178  YAxialPositionUpperRestraint(Model *m,
179  double upper_bound, bool consider_radius, double sigma=1);
180 
181 #ifndef IMP_DOXYGEN
182  void add_particle(Particle *p);
183  void add_particles(const ParticlesTemp &ps);
184  void set_particles(const ParticlesTemp &ps);
185 #endif
186 
187  double unprotected_evaluate(IMP::DerivativeAccumulator *accum) const;
188  ModelObjectsTemp do_get_inputs() const;
189 
190  IMP_OBJECT_METHODS(YAxialPositionUpperRestraint);;
191 };
192 
193 
194 //! Restrain particles by their distance from the z axis in the xy plane
195 /** Each particle's distance to the z axis is harmonically restrained to
196  lie between the given lower and upper bounds.
197  */
198 class IMPNPCEXPORT XYRadialPositionRestraint : public Restraint
199 {
200  IMP::PointerMember<IMP::SingletonContainer> sc_;
201  double lower_bound_;
202  double upper_bound_;
203  double sigma_;
204  bool consider_radius_;
205 public:
206  XYRadialPositionRestraint(Model *m, SingletonContainerAdaptor sc,
207  double lower_bound, double upper_bound, bool consider_radius, double sigma=1);
208  XYRadialPositionRestraint(Model *m,
209  double lower_bound, double upper_bound, bool consider_radius, double sigma=1);
210 
211 #ifndef IMP_DOXYGEN
212  void add_particle(Particle *p);
213  void add_particles(const ParticlesTemp &ps);
214  void set_particles(const ParticlesTemp &ps);
215 #endif
216 
217  double unprotected_evaluate(IMP::DerivativeAccumulator *accum) const;
218  ModelObjectsTemp do_get_inputs() const;
219 
220  IMP_OBJECT_METHODS(XYRadialPositionRestraint);;
221 };
222 
223 //! Restrain particles by their distance from the z axis in the xy plane
224 /** Each particle's distance to the z axis is harmonically restrained to
225  lie above the given lower bound.
226  */
227 class IMPNPCEXPORT XYRadialPositionLowerRestraint : public Restraint
228 {
229  IMP::PointerMember<IMP::SingletonContainer> sc_;
230  double lower_bound_;
231  double sigma_;
232  bool consider_radius_;
233 public:
234  XYRadialPositionLowerRestraint(Model *m, SingletonContainerAdaptor sc,
235  double lower_bound, bool consider_radius, double sigma=1);
236  XYRadialPositionLowerRestraint(Model *m,
237  double lower_bound, bool consider_radius, double sigma=1);
238 
239 #ifndef IMP_DOXYGEN
240  void add_particle(Particle *p);
241  void add_particles(const ParticlesTemp &ps);
242  void set_particles(const ParticlesTemp &ps);
243 #endif
244 
245  double unprotected_evaluate(IMP::DerivativeAccumulator *accum) const;
246  ModelObjectsTemp do_get_inputs() const;
247 
248  IMP_OBJECT_METHODS(XYRadialPositionLowerRestraint);;
249 };
250 
251 //! Restrain particles by their distance from the z axis in the xy plane
252 /** Each particle's distance to the z axis is harmonically restrained to
253  lie below the given upper bound.
254  */
255 class IMPNPCEXPORT XYRadialPositionUpperRestraint : public Restraint
256 {
257  IMP::PointerMember<IMP::SingletonContainer> sc_;
258  double upper_bound_;
259  double sigma_;
260  bool consider_radius_;
261 public:
262  XYRadialPositionUpperRestraint(Model *m, SingletonContainerAdaptor sc,
263  double upper_bound, bool consider_radius, double sigma=1);
264  XYRadialPositionUpperRestraint(Model *m,
265  double upper_bound, bool consider_radius, double sigma=1);
266 
267 #ifndef IMP_DOXYGEN
268  void add_particle(Particle *p);
269  void add_particles(const ParticlesTemp &ps);
270  void set_particles(const ParticlesTemp &ps);
271 #endif
272 
273  double unprotected_evaluate(IMP::DerivativeAccumulator *accum) const;
274  ModelObjectsTemp do_get_inputs() const;
275 
276  IMP_OBJECT_METHODS(XYRadialPositionUpperRestraint);;
277 };
278 
279 
280 //! Try to keep all particle surfaces in contact
281 /** The particles (each of which should be a core::XYZR) are harmonically
282  restrained such that each particle's sphere surface is in contact
283  with every other surface.
284  */
285 class IMPNPCEXPORT ProteinContactRestraint : public Restraint
286 {
287  IMP::PointerMember<IMP::SingletonContainer> sc_;
288  double tolerance_factor_;
289  double sigma_;
290 public:
291  ProteinContactRestraint(Model *m, SingletonContainerAdaptor sc,
292  double tolerance_factor, double sigma=0.1);
293  ProteinContactRestraint(Model *m,
294  double tolerance_factor, double sigma=0.1);
295 
296 #ifndef IMP_DOXYGEN
297  void add_particle(Particle *p);
298  void add_particles(const ParticlesTemp &ps);
299  void set_particles(const ParticlesTemp &ps);
300 #endif
301 
302  double unprotected_evaluate(IMP::DerivativeAccumulator *accum) const;
303  ModelObjectsTemp do_get_inputs() const;
304 
305  IMP_OBJECT_METHODS(ProteinContactRestraint);;
306 };
307 
308 
309 //! Try to keep particle surfaces in contact in a chain
310 /** The particles (each of which should be a core::XYZR) are harmonically
311  restrained such that each particle's sphere surface is in contact
312  with the surface of the previous particle.
313  */
314 class IMPNPCEXPORT ProteinChainRestraint : public Restraint
315 {
316  IMP::PointerMember<IMP::SingletonContainer> sc_;
317  double sigma_;
318 public:
319  ProteinChainRestraint(Model *m, SingletonContainerAdaptor sc,
320  double sigma=0.1);
321  ProteinChainRestraint(Model *m,
322  double sigma=0.1);
323 
324 #ifndef IMP_DOXYGEN
325  void add_particle(Particle *p);
326  void add_particles(const ParticlesTemp &ps);
327  void set_particles(const ParticlesTemp &ps);
328 #endif
329 
330  double unprotected_evaluate(IMP::DerivativeAccumulator *accum) const;
331  ModelObjectsTemp do_get_inputs() const;
332 
333  IMP_OBJECT_METHODS(ProteinChainRestraint);;
334 };
335 
336 
337 //! Try to keep particles localized on a membrane surface
338 /** The membrane is defined in this case to be a half torus in the xy
339  plane with center at the origin.
340  */
341 class IMPNPCEXPORT MembraneSurfaceLocationRestraint : public Restraint
342 {
343  IMP::PointerMember<IMP::SingletonContainer> sc_;
344  double R_;
345  double r_;
346  double sigma_;
347  double thickness_;
348 public:
349  MembraneSurfaceLocationRestraint(Model *m, SingletonContainerAdaptor sc,
350  double R, double r, double thickness, double sigma=2);
351  MembraneSurfaceLocationRestraint(Model *m,
352  double R, double r, double thickness, double sigma=2);
353 
354 #ifndef IMP_DOXYGEN
355  void add_particle(Particle *p);
356  void add_particles(const ParticlesTemp &ps);
357  void set_particles(const ParticlesTemp &ps);
358 #endif
359 
360  double unprotected_evaluate(IMP::DerivativeAccumulator *accum) const;
361  ModelObjectsTemp do_get_inputs() const;
362 
363  IMP_OBJECT_METHODS(MembraneSurfaceLocationRestraint);;
364 };
365 
366 
367 //! Try to keep one set of particles localized on a membrane surface
368 /** The membrane is defined in this case to be a half torus in the xy
369  plane with center at the origin. One of the two sets of particles
370  (whichever is closer) is restrained to the membrane surface.
371  */
372 class IMPNPCEXPORT MembraneSurfaceLocationConditionalRestraint : public Restraint
373 {
374  IMP::PointerMember<IMP::SingletonContainer> sc1_;
375  IMP::PointerMember<IMP::SingletonContainer> sc2_;
376  double R_;
377  double r_;
378  double sigma_;
379  double thickness_;
380 public:
381  MembraneSurfaceLocationConditionalRestraint(Model *m, SingletonContainerAdaptor sc1, SingletonContainerAdaptor sc2,
382  double R, double r, double thickness, double sigma=2);
383  MembraneSurfaceLocationConditionalRestraint(Model *m,
384  double R, double r, double thickness, double sigma=2);
385 
386 #ifndef IMP_DOXYGEN
387  void add_particle1(Particle *p);
388  void add_particle2(Particle *p);
389  void add_particles1(const ParticlesTemp &ps);
390  void add_particles2(const ParticlesTemp &ps);
391  void set_particles1(const ParticlesTemp &ps);
392  void set_particles2(const ParticlesTemp &ps);
393 #endif
394 
395  double unprotected_evaluate(IMP::DerivativeAccumulator *accum) const;
396  ModelObjectsTemp do_get_inputs() const;
397 
398  IMP_OBJECT_METHODS(MembraneSurfaceLocationConditionalRestraint);;
399 };
400 
401 
402 //! Try to keep particles away from a membrane
403 /** The membrane is defined in this case to be a half torus in the xy
404  plane with center at the origin.
405  */
406 class IMPNPCEXPORT MembraneExclusionRestraint : public Restraint
407 {
408  IMP::PointerMember<IMP::SingletonContainer> sc_;
409  double R_;
410  double r_;
411  double sigma_;
412  double thickness_;
413 public:
414  MembraneExclusionRestraint(Model *m, SingletonContainerAdaptor sc,
415  double R, double r, double thickness, double sigma=2);
416  MembraneExclusionRestraint(Model *m,
417  double R, double r, double thickness, double sigma=2);
418 
419 #ifndef IMP_DOXYGEN
420  void add_particle(Particle *p);
421  void add_particles(const ParticlesTemp &ps);
422  void set_particles(const ParticlesTemp &ps);
423 #endif
424 
425  double unprotected_evaluate(IMP::DerivativeAccumulator *accum) const;
426  ModelObjectsTemp do_get_inputs() const;
427 
428  IMP_OBJECT_METHODS(MembraneExclusionRestraint);;
429 };
430 
431 
432 //! Try to keep particles on the pore side of a membrane
433 /** The membrane is defined in this case to be a half torus in the xy
434  plane with center at the origin.
435  */
436 class IMPNPCEXPORT PoreSideVolumeLocationRestraint : public Restraint
437 {
438  IMP::PointerMember<IMP::SingletonContainer> sc_;
439  double R_;
440  double r_;
441  double sigma_;
442  double thickness_;
443  bool consider_radius_;
444 public:
445  PoreSideVolumeLocationRestraint(Model *m, SingletonContainerAdaptor sc,
446  double R, double r, double thickness, bool consider_radius, double sigma=2);
447  PoreSideVolumeLocationRestraint(Model *m,
448  double R, double r, double thickness, bool consider_radius, double sigma=2);
449 
450 #ifndef IMP_DOXYGEN
451  void add_particle(Particle *p);
452  void add_particles(const ParticlesTemp &ps);
453  void set_particles(const ParticlesTemp &ps);
454 #endif
455 
456  double unprotected_evaluate(IMP::DerivativeAccumulator *accum) const;
457  ModelObjectsTemp do_get_inputs() const;
458 
459  IMP_OBJECT_METHODS(PoreSideVolumeLocationRestraint);;
460 };
461 
462 
463 //! Try to keep particles on the perinuclear side of a membrane
464 /** The membrane is defined in this case to be a half torus in the xy
465  plane with center at the origin.
466  */
467 class IMPNPCEXPORT PerinuclearVolumeLocationRestraint : public Restraint
468 {
469  IMP::PointerMember<IMP::SingletonContainer> sc_;
470  double R_;
471  double r_;
472  double sigma_;
473  double thickness_;
474  bool consider_radius_;
475 public:
476  PerinuclearVolumeLocationRestraint(Model *m, SingletonContainerAdaptor sc,
477  double R, double r, double thickness, bool consider_radius, double sigma=2);
478  PerinuclearVolumeLocationRestraint(Model *m,
479  double R, double r, double thickness, bool consider_radius, double sigma=2);
480 
481 #ifndef IMP_DOXYGEN
482  void add_particle(Particle *p);
483  void add_particles(const ParticlesTemp &ps);
484  void set_particles(const ParticlesTemp &ps);
485 #endif
486 
487  double unprotected_evaluate(IMP::DerivativeAccumulator *accum) const;
488  ModelObjectsTemp do_get_inputs() const;
489 
490  IMP_OBJECT_METHODS(PerinuclearVolumeLocationRestraint);;
491 };
492 
493 
494 //! Restrain two interparticle distances to be the same
495 /** This restraint must be given 4 particles. They are restrained to
496  be symmetric, by enforcing a harmonic penalty on the difference
497  between the distance between the first 2 particles and the distance
498  between the last two.
499  */
500 class IMPNPCEXPORT AssemblySymmetryByDistanceRestraint : public Restraint
501 {
502  IMP::PointerMember<IMP::SingletonContainer> sc_;
503  double sigma_;
504 public:
505  AssemblySymmetryByDistanceRestraint(Model *m, SingletonContainerAdaptor sc,
506  double sigma=4);
507  AssemblySymmetryByDistanceRestraint(Model *m,
508  double sigma=4);
509 
510 #ifndef IMP_DOXYGEN
511  void add_particle(Particle *p);
512  void add_particles(const ParticlesTemp &ps);
513  void set_particles(const ParticlesTemp &ps);
514 #endif
515 
516  double unprotected_evaluate(IMP::DerivativeAccumulator *accum) const;
517  ModelObjectsTemp do_get_inputs() const;
518 
519  IMP_OBJECT_METHODS(AssemblySymmetryByDistanceRestraint);;
520 };
521 
522 
523 //! Restrain two interparticle dihedrals to be the same
524 /** This restraint must be given 8 particles. They are restrained to
525  be symmetric, by enforcing a harmonic penalty on the difference
526  between the dihedral angle between the first 4 particles and the dihedral
527  between the last 4.
528  */
529 class IMPNPCEXPORT AssemblySymmetryByDihedralRestraint
530  : public Restraint
531 {
532  IMP::PointerMember<IMP::SingletonContainer> sc_;
533  double sigma_;
534 public:
535  AssemblySymmetryByDihedralRestraint(Model *m, SingletonContainerAdaptor sc,
536  double sigma=0.1);
537  AssemblySymmetryByDihedralRestraint(Model *m,
538  double sigma=0.1);
539 
540 #ifndef IMP_DOXYGEN
541  void add_particle(Particle *p);
542  void add_particles(const ParticlesTemp &ps);
543  void set_particles(const ParticlesTemp &ps);
544 #endif
545 
546  double unprotected_evaluate(IMP::DerivativeAccumulator *accum) const;
547  ModelObjectsTemp do_get_inputs() const;
548 
549  IMP_OBJECT_METHODS(AssemblySymmetryByDihedralRestraint);;
550 };
551 
552 //! Restrain a set of particles to be proximate to each other
553 /** Each particle is harmonically restrained to be no more than
554  `max_dist` away from every other particle.
555  */
556 class IMPNPCEXPORT ProteinProximityRestraint
557  : public Restraint
558 {
559  IMP::PointerMember<IMP::SingletonContainer> sc_;
560  double sigma_;
561  double max_dist_;
562 public:
563  ProteinProximityRestraint(Model *m, SingletonContainerAdaptor sc,
564  double max_dist, double sigma=0.1);
565  ProteinProximityRestraint(Model *m,
566  double max_dist, double sigma=0.1);
567 
568 #ifndef IMP_DOXYGEN
569  void add_particle(Particle *p);
570  void add_particles(const ParticlesTemp &ps);
571  void set_particles(const ParticlesTemp &ps);
572 #endif
573 
574  double unprotected_evaluate(IMP::DerivativeAccumulator *accum) const;
575  ModelObjectsTemp do_get_inputs() const;
576 
577  IMP_OBJECT_METHODS(ProteinProximityRestraint);;
578 };
579 
580 
581 
582 IMPNPC_END_NAMESPACE
583 
584 #endif /* IMPNPC_PROTEIN_LOCALIZATION_RESTRAINT_H */
IMP::npc::PerinuclearVolumeLocationRestraint
Try to keep particles on the perinuclear side of a membrane.
Definition: ProteinLocalizationRestraint.h:467
IMP::npc::ZAxialPositionUpperRestraint
Restrain particles by their z coordinate.
Definition: ProteinLocalizationRestraint.h:83
IMP::rmf::add_particles
void add_particles(RMF::FileHandle fh, const ParticlesTemp &hs)
SingletonContainer.h
A container for Singletons.
IMP::npc::AssemblySymmetryByDihedralRestraint
Restrain two interparticle dihedrals to be the same.
Definition: ProteinLocalizationRestraint.h:529
IMP_OBJECT_METHODS
#define IMP_OBJECT_METHODS(Name)
Define the basic things needed by any Object.
Definition: object_macros.h:25
IMP::npc::YAxialPositionUpperRestraint
Restrain particles by their y coordinate.
Definition: ProteinLocalizationRestraint.h:169
IMP::npc::XYRadialPositionRestraint
Restrain particles by their distance from the z axis in the xy plane.
Definition: ProteinLocalizationRestraint.h:198
IMP::rmf::add_particle
void add_particle(RMF::FileHandle fh, Particle *hs)
IMP::npc::PoreSideVolumeLocationRestraint
Try to keep particles on the pore side of a membrane.
Definition: ProteinLocalizationRestraint.h:436
IMP::npc::MembraneSurfaceLocationConditionalRestraint
Try to keep one set of particles localized on a membrane surface.
Definition: ProteinLocalizationRestraint.h:372
IMP::npc::ZAxialPositionRestraint
Restrain particles by their z coordinate.
Definition: ProteinLocalizationRestraint.h:26
IMP::npc::AssemblySymmetryByDistanceRestraint
Restrain two interparticle distances to be the same.
Definition: ProteinLocalizationRestraint.h:500
IMP::npc::ProteinContactRestraint
Try to keep all particle surfaces in contact.
Definition: ProteinLocalizationRestraint.h:285
IMP::Model
Class for storing model, its restraints, constraints, and particles.
Definition: Model.h:72
IMP::npc::MembraneExclusionRestraint
Try to keep particles away from a membrane.
Definition: ProteinLocalizationRestraint.h:406
IMP::npc::ProteinChainRestraint
Try to keep particle surfaces in contact in a chain.
Definition: ProteinLocalizationRestraint.h:314
IMP::npc::XYRadialPositionLowerRestraint
Restrain particles by their distance from the z axis in the xy plane.
Definition: ProteinLocalizationRestraint.h:227
IMP::npc::MembraneSurfaceLocationRestraint
Try to keep particles localized on a membrane surface.
Definition: ProteinLocalizationRestraint.h:341
Pointer.h
A nullptr-initialized pointer to an IMP Object.
IMP::npc::ProteinProximityRestraint
Restrain a set of particles to be proximate to each other.
Definition: ProteinLocalizationRestraint.h:556
IMP::Particle
Class to handle individual particles of a Model object.
Definition: Particle.h:41
Restraint.h
Abstract base class for all restraints.
IMP::npc::ZAxialPositionLowerRestraint
Restrain particles by their z coordinate.
Definition: ProteinLocalizationRestraint.h:55
IMP::npc::XYRadialPositionUpperRestraint
Restrain particles by their distance from the z axis in the xy plane.
Definition: ProteinLocalizationRestraint.h:255
IMP::npc::YAxialPositionLowerRestraint
Restrain particles by their y coordinate.
Definition: ProteinLocalizationRestraint.h:141
IMP::ModelObject::do_get_inputs
virtual ModelObjectsTemp do_get_inputs() const =0
IMP::DerivativeAccumulator
Class for adding derivatives from restraints to the model.
Definition: DerivativeAccumulator.h:25
IMP::npc::YAxialPositionRestraint
Restrain particles by their y coordinate.
Definition: ProteinLocalizationRestraint.h:112
IMP::Restraint
A restraint is a term in an IMP ScoringFunction.
Definition: Restraint.h:54