IMP logo
IMP Reference Guide  2.10.1
The Integrative Modeling Platform
modeller/__init__.py
1 # This file was automatically generated by SWIG (http://www.swig.org).
2 # Version 3.0.10
3 #
4 # Do not make changes to this file unless you know what you are doing--modify
5 # the SWIG interface file instead.
6 
7 # This wrapper is part of IMP,
8 # Copyright 2007-2018 IMP Inventors. All rights reserved.
9 
10 from __future__ import print_function, division, absolute_import
11 
12 
13 
14 
15 from sys import version_info as _swig_python_version_info
16 if _swig_python_version_info >= (2, 7, 0):
17  def swig_import_helper():
18  import importlib
19  pkg = __name__.rpartition('.')[0]
20  mname = '.'.join((pkg, '_IMP_modeller')).lstrip('.')
21  try:
22  return importlib.import_module(mname)
23  except ImportError:
24  return importlib.import_module('_IMP_modeller')
25  _IMP_modeller = swig_import_helper()
26  del swig_import_helper
27 elif _swig_python_version_info >= (2, 6, 0):
28  def swig_import_helper():
29  from os.path import dirname
30  import imp
31  fp = None
32  try:
33  fp, pathname, description = imp.find_module('_IMP_modeller', [dirname(__file__)])
34  except ImportError:
35  import _IMP_modeller
36  return _IMP_modeller
37  if fp is not None:
38  try:
39  _mod = imp.load_module('_IMP_modeller', fp, pathname, description)
40  finally:
41  fp.close()
42  return _mod
43  _IMP_modeller = swig_import_helper()
44  del swig_import_helper
45 else:
46  import _IMP_modeller
47 del _swig_python_version_info
48 try:
49  _swig_property = property
50 except NameError:
51  pass # Python < 2.2 doesn't have 'property'.
52 
53 try:
54  import builtins as __builtin__
55 except ImportError:
56  import __builtin__
57 
58 def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
59  if (name == "thisown"):
60  return self.this.own(value)
61  if (name == "this"):
62  if type(value).__name__ == 'SwigPyObject':
63  self.__dict__[name] = value
64  return
65  method = class_type.__swig_setmethods__.get(name, None)
66  if method:
67  return method(self, value)
68  if (not static):
69  object.__setattr__(self, name, value)
70  else:
71  raise AttributeError("You cannot add attributes to %s" % self)
72 
73 
74 def _swig_setattr(self, class_type, name, value):
75  return _swig_setattr_nondynamic(self, class_type, name, value, 0)
76 
77 
78 def _swig_getattr(self, class_type, name):
79  if (name == "thisown"):
80  return self.this.own()
81  method = class_type.__swig_getmethods__.get(name, None)
82  if method:
83  return method(self)
84  raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))
85 
86 
87 def _swig_repr(self):
88  try:
89  strthis = "proxy of " + self.this.__repr__()
90  except __builtin__.Exception:
91  strthis = ""
92  return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
93 
94 
95 def _swig_setattr_nondynamic_method(set):
96  def set_attr(self, name, value):
97  if (name == "thisown"):
98  return self.this.own(value)
99  if hasattr(self, name) or (name == "this"):
100  set(self, name, value)
101  else:
102  raise AttributeError("You cannot add attributes to %s" % self)
103  return set_attr
104 
105 
106 try:
107  import weakref
108  weakref_proxy = weakref.proxy
109 except __builtin__.Exception:
110  weakref_proxy = lambda x: x
111 
112 
113 class IMP_MODELLER_SwigPyIterator(object):
114  """Proxy of C++ swig::IMP_MODELLER_SwigPyIterator class."""
115 
116  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
117 
118  def __init__(self, *args, **kwargs):
119  raise AttributeError("No constructor defined - class is abstract")
120  __repr__ = _swig_repr
121  __swig_destroy__ = _IMP_modeller.delete_IMP_MODELLER_SwigPyIterator
122  __del__ = lambda self: None
123 
124  def value(self):
125  """value(IMP_MODELLER_SwigPyIterator self) -> PyObject *"""
126  return _IMP_modeller.IMP_MODELLER_SwigPyIterator_value(self)
127 
128 
129  def incr(self, n=1):
130  """
131  incr(IMP_MODELLER_SwigPyIterator self, size_t n=1) -> IMP_MODELLER_SwigPyIterator
132  incr(IMP_MODELLER_SwigPyIterator self) -> IMP_MODELLER_SwigPyIterator
133  """
134  return _IMP_modeller.IMP_MODELLER_SwigPyIterator_incr(self, n)
135 
136 
137  def decr(self, n=1):
138  """
139  decr(IMP_MODELLER_SwigPyIterator self, size_t n=1) -> IMP_MODELLER_SwigPyIterator
140  decr(IMP_MODELLER_SwigPyIterator self) -> IMP_MODELLER_SwigPyIterator
141  """
142  return _IMP_modeller.IMP_MODELLER_SwigPyIterator_decr(self, n)
143 
144 
145  def distance(self, x):
146  """distance(IMP_MODELLER_SwigPyIterator self, IMP_MODELLER_SwigPyIterator x) -> ptrdiff_t"""
147  return _IMP_modeller.IMP_MODELLER_SwigPyIterator_distance(self, x)
148 
149 
150  def equal(self, x):
151  """equal(IMP_MODELLER_SwigPyIterator self, IMP_MODELLER_SwigPyIterator x) -> bool"""
152  return _IMP_modeller.IMP_MODELLER_SwigPyIterator_equal(self, x)
153 
154 
155  def copy(self):
156  """copy(IMP_MODELLER_SwigPyIterator self) -> IMP_MODELLER_SwigPyIterator"""
157  return _IMP_modeller.IMP_MODELLER_SwigPyIterator_copy(self)
158 
159 
160  def next(self):
161  """next(IMP_MODELLER_SwigPyIterator self) -> PyObject *"""
162  return _IMP_modeller.IMP_MODELLER_SwigPyIterator_next(self)
163 
164 
165  def __next__(self):
166  """__next__(IMP_MODELLER_SwigPyIterator self) -> PyObject *"""
167  return _IMP_modeller.IMP_MODELLER_SwigPyIterator___next__(self)
168 
169 
170  def previous(self):
171  """previous(IMP_MODELLER_SwigPyIterator self) -> PyObject *"""
172  return _IMP_modeller.IMP_MODELLER_SwigPyIterator_previous(self)
173 
174 
175  def advance(self, n):
176  """advance(IMP_MODELLER_SwigPyIterator self, ptrdiff_t n) -> IMP_MODELLER_SwigPyIterator"""
177  return _IMP_modeller.IMP_MODELLER_SwigPyIterator_advance(self, n)
178 
179 
180  def __eq__(self, x):
181  """__eq__(IMP_MODELLER_SwigPyIterator self, IMP_MODELLER_SwigPyIterator x) -> bool"""
182  return _IMP_modeller.IMP_MODELLER_SwigPyIterator___eq__(self, x)
183 
184 
185  def __ne__(self, x):
186  """__ne__(IMP_MODELLER_SwigPyIterator self, IMP_MODELLER_SwigPyIterator x) -> bool"""
187  return _IMP_modeller.IMP_MODELLER_SwigPyIterator___ne__(self, x)
188 
189 
190  def __iadd__(self, n):
191  """__iadd__(IMP_MODELLER_SwigPyIterator self, ptrdiff_t n) -> IMP_MODELLER_SwigPyIterator"""
192  return _IMP_modeller.IMP_MODELLER_SwigPyIterator___iadd__(self, n)
193 
194 
195  def __isub__(self, n):
196  """__isub__(IMP_MODELLER_SwigPyIterator self, ptrdiff_t n) -> IMP_MODELLER_SwigPyIterator"""
197  return _IMP_modeller.IMP_MODELLER_SwigPyIterator___isub__(self, n)
198 
199 
200  def __add__(self, n):
201  """__add__(IMP_MODELLER_SwigPyIterator self, ptrdiff_t n) -> IMP_MODELLER_SwigPyIterator"""
202  return _IMP_modeller.IMP_MODELLER_SwigPyIterator___add__(self, n)
203 
204 
205  def __sub__(self, *args):
206  """
207  __sub__(IMP_MODELLER_SwigPyIterator self, ptrdiff_t n) -> IMP_MODELLER_SwigPyIterator
208  __sub__(IMP_MODELLER_SwigPyIterator self, IMP_MODELLER_SwigPyIterator x) -> ptrdiff_t
209  """
210  return _IMP_modeller.IMP_MODELLER_SwigPyIterator___sub__(self, *args)
211 
212  def __iter__(self):
213  return self
214 IMP_MODELLER_SwigPyIterator_swigregister = _IMP_modeller.IMP_MODELLER_SwigPyIterator_swigregister
215 IMP_MODELLER_SwigPyIterator_swigregister(IMP_MODELLER_SwigPyIterator)
216 
217 
218 _value_types=[]
219 _object_types=[]
220 _raii_types=[]
221 _plural_types=[]
222 
223 IMP_DEBUG = _IMP_modeller.IMP_DEBUG
224 IMP_RELEASE = _IMP_modeller.IMP_RELEASE
225 IMP_SILENT = _IMP_modeller.IMP_SILENT
226 IMP_PROGRESS = _IMP_modeller.IMP_PROGRESS
227 IMP_TERSE = _IMP_modeller.IMP_TERSE
228 IMP_VERBOSE = _IMP_modeller.IMP_VERBOSE
229 IMP_MEMORY = _IMP_modeller.IMP_MEMORY
230 IMP_NONE = _IMP_modeller.IMP_NONE
231 IMP_USAGE = _IMP_modeller.IMP_USAGE
232 IMP_INTERNAL = _IMP_modeller.IMP_INTERNAL
233 IMP_KERNEL_HAS_LOG4CXX = _IMP_modeller.IMP_KERNEL_HAS_LOG4CXX
234 IMP_COMPILER_HAS_AUTO = _IMP_modeller.IMP_COMPILER_HAS_AUTO
235 IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_modeller.IMP_COMPILER_HAS_DEBUG_VECTOR
236 IMP_COMPILER_HAS_UNIQUE_PTR = _IMP_modeller.IMP_COMPILER_HAS_UNIQUE_PTR
237 IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_modeller.IMP_KERNEL_HAS_BOOST_RANDOM
238 IMP_KERNEL_HAS_GPERFTOOLS = _IMP_modeller.IMP_KERNEL_HAS_GPERFTOOLS
239 IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER = _IMP_modeller.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER
240 IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER = _IMP_modeller.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER
241 IMPKERNEL_SHOW_WARNINGS = _IMP_modeller.IMPKERNEL_SHOW_WARNINGS
242 
243 import sys
244 class _DirectorObjects(object):
245  """@internal Simple class to keep references to director objects
246  to prevent premature deletion."""
247  def __init__(self):
248  self._objects = []
249  def register(self, obj):
250  """Take a reference to a director object; will only work for
251  refcounted C++ classes"""
252  if hasattr(obj, 'get_ref_count'):
253  self._objects.append(obj)
254  def cleanup(self):
255  """Only drop our reference and allow cleanup by Python if no other
256  Python references exist (we hold 3 references: one in self._objects,
257  one in x, and one in the argument list for getrefcount) *and* no
258  other C++ references exist (the Python object always holds one)"""
259  objs = [x for x in self._objects if sys.getrefcount(x) > 3 \
260  or x.get_ref_count() > 1]
261 # Do in two steps so the references are kept until the end of the
262 # function (deleting references may trigger a fresh call to this method)
263  self._objects = objs
264  def get_object_count(self):
265  """Get number of director objects (useful for testing only)"""
266  return len(self._objects)
267 _director_objects = _DirectorObjects()
268 
269 class _ostream(object):
270  """Proxy of C++ std::ostream class."""
271 
272  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
273 
274  def __init__(self, *args, **kwargs):
275  raise AttributeError("No constructor defined")
276  __repr__ = _swig_repr
277 
278  def write(self, osa_buf):
279  """write(_ostream self, char const * osa_buf)"""
280  return _IMP_modeller._ostream_write(self, osa_buf)
281 
282 _ostream_swigregister = _IMP_modeller._ostream_swigregister
283 _ostream_swigregister(_ostream)
284 
285 IMP_COMPILER_HAS_OVERRIDE = _IMP_modeller.IMP_COMPILER_HAS_OVERRIDE
286 IMP_COMPILER_HAS_FINAL = _IMP_modeller.IMP_COMPILER_HAS_FINAL
287 IMP_HAS_NOEXCEPT = _IMP_modeller.IMP_HAS_NOEXCEPT
288 IMP_C_OPEN_BINARY = _IMP_modeller.IMP_C_OPEN_BINARY
289 import IMP
290 IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_modeller.IMP_CGAL_HAS_BOOST_FILESYSTEM
291 IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_modeller.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS
292 IMP_CGAL_HAS_BOOST_RANDOM = _IMP_modeller.IMP_CGAL_HAS_BOOST_RANDOM
293 IMP_CGAL_HAS_BOOST_SYSTEM = _IMP_modeller.IMP_CGAL_HAS_BOOST_SYSTEM
294 IMPCGAL_SHOW_WARNINGS = _IMP_modeller.IMPCGAL_SHOW_WARNINGS
295 import IMP.cgal
296 IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_modeller.IMP_ALGEBRA_HAS_IMP_CGAL
297 IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_modeller.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM
298 IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_modeller.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS
299 IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_modeller.IMP_ALGEBRA_HAS_BOOST_RANDOM
300 IMP_ALGEBRA_HAS_BOOST_SYSTEM = _IMP_modeller.IMP_ALGEBRA_HAS_BOOST_SYSTEM
301 IMP_ALGEBRA_HAS_CGAL = _IMP_modeller.IMP_ALGEBRA_HAS_CGAL
302 IMP_ALGEBRA_HAS_ANN = _IMP_modeller.IMP_ALGEBRA_HAS_ANN
303 IMPALGEBRA_SHOW_WARNINGS = _IMP_modeller.IMPALGEBRA_SHOW_WARNINGS
304 import IMP.algebra
305 IMP_DISPLAY_HAS_IMP_CGAL = _IMP_modeller.IMP_DISPLAY_HAS_IMP_CGAL
306 IMP_DISPLAY_HAS_BOOST_FILESYSTEM = _IMP_modeller.IMP_DISPLAY_HAS_BOOST_FILESYSTEM
307 IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS = _IMP_modeller.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS
308 IMP_DISPLAY_HAS_BOOST_RANDOM = _IMP_modeller.IMP_DISPLAY_HAS_BOOST_RANDOM
309 IMP_DISPLAY_HAS_BOOST_SYSTEM = _IMP_modeller.IMP_DISPLAY_HAS_BOOST_SYSTEM
310 IMP_DISPLAY_HAS_CGAL = _IMP_modeller.IMP_DISPLAY_HAS_CGAL
311 IMPDISPLAY_SHOW_WARNINGS = _IMP_modeller.IMPDISPLAY_SHOW_WARNINGS
312 import IMP.display
313 IMP_SCORE_FUNCTOR_HAS_IMP_CGAL = _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_IMP_CGAL
314 IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM = _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM
315 IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS = _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS
316 IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM = _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM
317 IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM = _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM
318 IMP_SCORE_FUNCTOR_HAS_CGAL = _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_CGAL
319 IMP_SCORE_FUNCTOR_HAS_HDF5 = _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_HDF5
320 IMPSCOREFUNCTOR_SHOW_WARNINGS = _IMP_modeller.IMPSCOREFUNCTOR_SHOW_WARNINGS
321 import IMP.score_functor
322 IMP_CORE_HAS_IMP_CGAL = _IMP_modeller.IMP_CORE_HAS_IMP_CGAL
323 IMP_CORE_HAS_IMP_KERNEL = _IMP_modeller.IMP_CORE_HAS_IMP_KERNEL
324 IMP_CORE_HAS_BOOST_FILESYSTEM = _IMP_modeller.IMP_CORE_HAS_BOOST_FILESYSTEM
325 IMP_CORE_HAS_BOOST_PROGRAMOPTIONS = _IMP_modeller.IMP_CORE_HAS_BOOST_PROGRAMOPTIONS
326 IMP_CORE_HAS_BOOST_RANDOM = _IMP_modeller.IMP_CORE_HAS_BOOST_RANDOM
327 IMP_CORE_HAS_BOOST_SYSTEM = _IMP_modeller.IMP_CORE_HAS_BOOST_SYSTEM
328 IMP_CORE_HAS_CGAL = _IMP_modeller.IMP_CORE_HAS_CGAL
329 IMP_CORE_HAS_HDF5 = _IMP_modeller.IMP_CORE_HAS_HDF5
330 IMPCORE_SHOW_WARNINGS = _IMP_modeller.IMPCORE_SHOW_WARNINGS
331 import IMP.core
332 IMP_MODELLER_HAS_IMP_ALGEBRA = _IMP_modeller.IMP_MODELLER_HAS_IMP_ALGEBRA
333 IMP_MODELLER_HAS_IMP_CGAL = _IMP_modeller.IMP_MODELLER_HAS_IMP_CGAL
334 IMP_MODELLER_HAS_IMP_DISPLAY = _IMP_modeller.IMP_MODELLER_HAS_IMP_DISPLAY
335 IMP_MODELLER_HAS_IMP_KERNEL = _IMP_modeller.IMP_MODELLER_HAS_IMP_KERNEL
336 IMP_MODELLER_HAS_IMP_SCORE_FUNCTOR = _IMP_modeller.IMP_MODELLER_HAS_IMP_SCORE_FUNCTOR
337 IMP_MODELLER_HAS_BOOST_FILESYSTEM = _IMP_modeller.IMP_MODELLER_HAS_BOOST_FILESYSTEM
338 IMP_MODELLER_HAS_BOOST_PROGRAMOPTIONS = _IMP_modeller.IMP_MODELLER_HAS_BOOST_PROGRAMOPTIONS
339 IMP_MODELLER_HAS_BOOST_RANDOM = _IMP_modeller.IMP_MODELLER_HAS_BOOST_RANDOM
340 IMP_MODELLER_HAS_BOOST_SYSTEM = _IMP_modeller.IMP_MODELLER_HAS_BOOST_SYSTEM
341 IMP_MODELLER_HAS_CGAL = _IMP_modeller.IMP_MODELLER_HAS_CGAL
342 IMP_MODELLER_HAS_HDF5 = _IMP_modeller.IMP_MODELLER_HAS_HDF5
343 IMP_MODELLER_HAS_PYTHON_IHM = _IMP_modeller.IMP_MODELLER_HAS_PYTHON_IHM
344 IMPMODELLER_SHOW_WARNINGS = _IMP_modeller.IMPMODELLER_SHOW_WARNINGS
345 
346 
347 import math
348 import imp
349 import os
350 import sys
351 import tempfile
352 import shutil
353 import IMP.atom
354 import IMP.container
355 import modeller.scripts
356 import modeller.optimizers
357 
358 class _TempDir(object):
359  """Make a temporary directory that is deleted when the object is."""
360 
361  def __init__(self):
362  self.tmpdir = tempfile.mkdtemp()
363 
364  def __del__(self):
365  shutil.rmtree(self.tmpdir, ignore_errors=True)
366 
367 
368 class IMPRestraints(modeller.terms.energy_term):
369  """A Modeller restraint which evaluates an IMP scoring function.
370  This can be used to incorporate IMP Restraints into an existing
371  comparative modeling pipeline, or to use Modeller optimizers or
372  protocols.
373  """
374 
375  _physical_type = modeller.physical.absposition
376 
377  def __init__(self, particles, scoring_function=None):
378  """Constructor.
379  @param particles A list of the IMP atoms (as Particle objects),
380  same order as the Modeller atoms.
381  @param scoring_function An IMP::ScoringFunction object that will
382  be incorporated into the Modeller score (molpdf).
383  @note since Modeller, unlike IMP, is sensitive to the ordering
384  of atoms, it usually makes sense to create the model in
385  Modeller and then use ModelLoader to load it into IMP,
386  since that will preserve the Modeller atom ordering in IMP.
387  """
388  modeller.terms.energy_term.__init__(self)
389  self._particles = particles
390  if scoring_function:
391  self._sf = scoring_function
392  else:
393  self._sf = particles[0].get_model()
394 
395  def eval(self, mdl, deriv, indats):
396  atoms = self.indices_to_atoms(mdl, indats)
397  _copy_modeller_coords_to_imp(atoms, self._particles)
398  if len(self._particles) == 0:
399  score = 0.
400  else:
401  score = self._sf.evaluate(deriv)
402  if deriv:
403  dvx = [0.] * len(indats)
404  dvy = [0.] * len(indats)
405  dvz = [0.] * len(indats)
406  _get_imp_derivs(self._particles, dvx, dvy, dvz)
407  return (score, dvx, dvy, dvz)
408  else:
409  return score
410 
411 
413  """An IMP restraint using all defined Modeller restraints.
414  This is useful if you want to use Modeller restraints with an IMP
415  optimizer, or in combination with IMP restraints.
416 
417  @note Currently only the coordinates of the atoms are translated
418  between Modeller and IMP; thus, a Modeller restraint which
419  uses any other attribute (e.g. charge) will not react if
420  this attribute is changed by IMP.
421  """
422 
423  def __init__(self, model, modeller_model, particles):
424  """Constructor.
425  @param model The IMP Model object.
426  @param modeller_model The Modeller model object.
427  @param particles A list of the IMP atoms (as Particle objects),
428  in the same order as the Modeller atoms.
429  @note since Modeller, unlike IMP, is sensitive to the ordering
430  of atoms, it usually makes sense to create the model in
431  Modeller and then use ModelLoader to load it into IMP,
432  since that will preserve the Modeller atom ordering in IMP.
433  """
434  def get_particle(x):
435  if hasattr(x, 'get_particle'):
436  return x.get_particle()
437  else:
438  return x
439  IMP.Restraint.__init__(self, model, "ModellerRestraints %1%")
440  self._modeller_model = modeller_model
441  self._particles = [get_particle(x) for x in particles]
442 
443  def unprotected_evaluate(self, accum):
444  atoms = self._modeller_model.atoms
445  sel = modeller.selection(self._modeller_model)
446  _copy_imp_coords_to_modeller(self._particles, atoms)
447  energies = sel.energy()
448  if accum:
449  _add_modeller_derivs_to_imp(atoms, self._particles, accum)
450 
451  return energies[0]
452 
453  def get_version_info(self):
454  return IMP.VersionInfo("IMP developers", "0.1")
455  def do_show(self, fh):
456  fh.write("ModellerRestraints")
457  def do_get_inputs(self):
458  return self._particles
459 
460 
461 def _copy_imp_coords_to_modeller(particles, atoms):
462  """Copy atom coordinates from IMP to Modeller"""
463  xkey = IMP.FloatKey("x")
464  ykey = IMP.FloatKey("y")
465  zkey = IMP.FloatKey("z")
466  for (num, at) in enumerate(atoms):
467  at.x = particles[num].get_value(xkey)
468  at.y = particles[num].get_value(ykey)
469  at.z = particles[num].get_value(zkey)
470 
471 
472 def _copy_modeller_coords_to_imp(atoms, particles):
473  """Copy atom coordinates from Modeller to IMP"""
474  xkey = IMP.FloatKey("x")
475  ykey = IMP.FloatKey("y")
476  zkey = IMP.FloatKey("z")
477  for (num, at) in enumerate(atoms):
478  particles[num].set_value(xkey, at.x)
479  particles[num].set_value(ykey, at.y)
480  particles[num].set_value(zkey, at.z)
481 
482 
483 def _add_modeller_derivs_to_imp(atoms, particles, accum):
484  """Add atom derivatives from Modeller to IMP"""
485  for (num, at) in enumerate(atoms):
486  xyz = IMP.core.XYZ(particles[num])
487  xyz.add_to_derivative(0, at.dvx, accum)
488  xyz.add_to_derivative(1, at.dvy, accum)
489  xyz.add_to_derivative(2, at.dvz, accum)
490 
491 
492 def _get_imp_derivs(particles, dvx, dvy, dvz):
493  """Move atom derivatives from IMP to Modeller"""
494  xkey = IMP.FloatKey("x")
495  ykey = IMP.FloatKey("y")
496  zkey = IMP.FloatKey("z")
497  for idx in range(0, len(dvx)):
498  dvx[idx] = particles[idx].get_derivative(xkey)
499  dvy[idx] = particles[idx].get_derivative(ykey)
500  dvz[idx] = particles[idx].get_derivative(zkey)
501 
502 
503 # Generators to create IMP UnaryFunction objects from Modeller parameters:
504 def _HarmonicLowerBoundGenerator(parameters, modalities):
505  (mean, stdev) = parameters
507  return IMP.core.HarmonicLowerBound(mean, k)
508 
509 def _HarmonicUpperBoundGenerator(parameters, modalities):
510  (mean, stdev) = parameters
512  return IMP.core.HarmonicUpperBound(mean, k)
513 
514 def _HarmonicGenerator(parameters, modalities):
515  (mean, stdev) = parameters
517  return IMP.core.Harmonic(mean, k)
518 
519 def _CosineGenerator(parameters, modalities):
520  (phase, force_constant) = parameters
521  (periodicity,) = modalities
522  return IMP.core.Cosine(force_constant, periodicity, phase)
523 
524 def _LinearGenerator(parameters, modalities):
525  (scale,) = parameters
526  return IMP.core.Linear(0, scale)
527 
528 def _SplineGenerator(parameters, modalities):
529  (open, low, high, delta, lowderiv, highderiv) = parameters[:6]
530  values = []
531  for v in parameters[6:]:
532  values.append(v)
533  if open < 0.0:
534  return IMP.core.ClosedCubicSpline(values, low, delta)
535  else:
536  return IMP.core.OpenCubicSpline(values, low, delta)
537 
538 #: Mapping from Modeller math form number to a unary function generator
539 _unary_func_generators = {
540  1: _HarmonicLowerBoundGenerator,
541  2: _HarmonicUpperBoundGenerator,
542  3: _HarmonicGenerator,
543  7: _CosineGenerator,
544  8: _LinearGenerator,
545  10: _SplineGenerator,
546 }
547 
548 # Generators to make IMP Restraint objects from Modeller features
549 def _DistanceRestraintGenerator(form, modalities, atoms, parameters):
550  unary_func_gen = _unary_func_generators[form]
551  return IMP.core.DistanceRestraint(atoms[0].get_model(),
552  unary_func_gen(parameters, modalities),
553  atoms[0], atoms[1])
554 
555 def _AngleRestraintGenerator(form, modalities, atoms, parameters):
556  unary_func_gen = _unary_func_generators[form]
557  return IMP.core.AngleRestraint(atoms[0].get_model(),
558  unary_func_gen(parameters, modalities),
559  atoms[0], atoms[1], atoms[2])
560 
561 def _MultiBinormalGenerator(form, modalities, atoms, parameters):
562  nterms = modalities[0]
563  if len(parameters) != nterms * 6:
564  raise ValueError("Incorrect number of parameters (%d) for multiple "
565  "binormal restraint - expecting %d (%d terms * 6)" \
566  % (len(parameters), nterms * 6, nterms))
567  r = IMP.core.MultipleBinormalRestraint(atoms[0].get_model(),
568  atoms[:4], atoms[4:8])
569  for i in range(nterms):
571  t.set_weight(parameters[i])
572  t.set_means((parameters[nterms + i * 2],
573  parameters[nterms + i * 2 + 1]))
574  t.set_standard_deviations((parameters[nterms * 3 + i * 2],
575  parameters[nterms * 3 + i * 2 + 1]))
576  t.set_correlation(parameters[nterms * 5 + i])
577  r.add_term(t)
578  return r
579 
580 def _DihedralRestraintGenerator(form, modalities, atoms, parameters):
581  if form == 9:
582  return _MultiBinormalGenerator(form, modalities, atoms, parameters)
583  unary_func_gen = _unary_func_generators[form]
584  return IMP.core.DihedralRestraint(atoms[0].get_model(),
585  unary_func_gen(parameters, modalities),
586  atoms[0], atoms[1], atoms[2], atoms[3])
587 
588 def _get_protein_atom_particles(protein):
589  """Given a protein particle, get the flattened list of all child atoms"""
590  atom_particles = []
591  for ichain in range(protein.get_number_of_children()):
592  chain = protein.get_child(ichain)
593  for ires in range(chain.get_number_of_children()):
594  residue = chain.get_child(ires)
595  for iatom in range(residue.get_number_of_children()):
596  atom = residue.get_child(iatom)
597  atom_particles.append(atom.get_particle())
598  return atom_particles
599 
600 def _load_restraints_line(line, atom_particles):
601  """Parse a single Modeller restraints file line and return the
602  corresponding IMP restraint."""
603  spl = line.split()
604  typ = spl.pop(0)
605  if typ == 'MODELLER5':
606  return
607  elif typ != 'R':
608  raise NotImplementedError("Only 'R' lines currently read from " + \
609  "Modeller restraints files")
610  form = int(spl.pop(0))
611  modalities = [int(spl.pop(0))]
612  features = [int(spl.pop(0))]
613 # Discard group
614  spl.pop(0)
615  natoms = [int(spl.pop(0))]
616  nparam = int(spl.pop(0))
617  nfeat = int(spl.pop(0))
618  for i in range(nfeat - 1):
619  modalities.append(int(spl.pop(0)))
620  features.append(int(spl.pop(0)))
621  natoms.append(int(spl.pop(0)))
622  atoms = [int(spl.pop(0)) for x in range(natoms[0])]
623  for i in range(len(atoms)):
624  atoms[i] = atom_particles[atoms[i] - 1]
625  parameters = [float(spl.pop(0)) for x in range(nparam)]
626  restraint_generators = {
627  1 : _DistanceRestraintGenerator,
628  2 : _AngleRestraintGenerator,
629  3 : _DihedralRestraintGenerator,
630  }
631  restraint_gen = restraint_generators[features[0]]
632  return restraint_gen(form, modalities, atoms, parameters)
633 
634 
635 def _load_entire_restraints_file(filename, protein):
636  """Yield a set of IMP restraints from a Modeller restraints file."""
637  atoms = _get_protein_atom_particles(protein)
638  fh = open(filename, 'r')
639  for line in fh:
640  try:
641  rsr = _load_restraints_line(line, atoms)
642  if rsr is not None:
643  yield rsr
644  except Exception as err:
645  print("Cannot read restraints file line:\n" + line)
646  raise
647 
648 
649 def _copy_residue(r, model):
650  """Copy residue information from modeller to imp"""
651 #print "residue "+str(r)
652  p=IMP.Particle(model)
654  r.index)
655  p.set_name(str("residue "+r.num));
656  return p
657 
658 
659 def _copy_atom(a, model):
660  """Copy atom information from modeller"""
661 #print "atom "+str(a)
662  p=IMP.Particle(model)
664  xyzd= IMP.core.XYZ.setup_particle(p, IMP.algebra.Vector3D(a.x, a.y, a.z))
665 # Alignment structures don't have charges or atom types; models do
666  if hasattr(a, 'charge'):
668  if hasattr(a, 'type'):
669  IMP.atom.CHARMMAtom.setup_particle(p, a.type.name)
670  ap.set_input_index(a.index)
671  return p
672 
673 def _copy_chain(c, model):
674  """Copy chain information from modeller"""
675 #print "atom "+str(a)
676  p=IMP.Particle(model)
677 #set the chain name
678  cp = IMP.atom.Chain.setup_particle(p,c.name)
679  return p
680 
681 def _get_forcefield(submodel):
682  if submodel == 3:
684  IMP.atom.get_data_path('top_heav.lib'),
685  IMP.atom.get_data_path('par.lib'))
686  else:
688  IMP.atom.get_data_path('top.lib'),
689  IMP.atom.get_data_path('par.lib'))
690  return ff
691 
692 def add_soft_sphere_radii(hierarchy, submodel, scale=1.0, filename=None):
693  """Add radii to the hierarchy using the Modeller radius library, radii.lib.
694  Each radius is scaled by the given scale (Modeller usually scales radii
695  by a factor of 0.82). submodel specifies the topology submodel, which is
696  the column in radii.lib to use."""
697  if filename is None:
698  filename = IMP.atom.get_data_path('radii.lib')
699  radii = {}
700  for line in open(filename):
701  if line.startswith('#'): continue
702  spl = line.split()
703  if len(spl) > 11:
704  radii[spl[0]] = float(spl[submodel])
705  atoms = IMP.atom.get_by_type(hierarchy, IMP.atom.ATOM_TYPE)
706  for a in atoms:
707  p = a.get_particle()
708  ct = IMP.atom.CHARMMAtom(p).get_charmm_type()
709  if ct in radii:
710  IMP.core.XYZR.setup_particle(p, radii[ct] * scale)
711 
712 
713 class ModelLoader(object):
714  """Read a Modeller model into IMP. After creating this object, the atoms
715  in the Modeller model can be loaded into IMP using the load_atoms()
716  method, then optionally any Modeller static restraints can be read in
717  with load_static_restraints() or load_static_restraints_file().
718 
719  This class can also be used to read Modeller alignment structures;
720  however, only load_atoms() will be useful in such a case (since
721  alignment structures don't have restraints or other information).
722 
723  """
724 
725  def __init__(self, modeller_model):
726  """Constructor.
727  @param modeller_model The Modeller model or alignment structure
728  object to read.
729  """
730  self._modeller_model = modeller_model
731 
732  def load_atoms(self, model):
733  """Construct an IMP::atom::Hierarchy that contains the same atoms as
734  the Modeller model or alignment structure.
735 
736  IMP atoms created from a Modeller model will be given charges and
737  CHARMM types, extracted from the model. Alignment structures don't
738  contain this information, so the IMP atoms won't either.
739 
740  @param model The IMP::Model object in which the hierarchy will be
741  created. The highest level hierarchy node is a PROTEIN.
742  @return the newly-created root IMP::atom::Hierarchy.
743  """
744  pp = IMP.Particle(model)
746  self._atoms = {}
747  for chain in self._modeller_model.chains:
748  cp = IMP.Particle(model)
749  hcp = IMP.atom.Chain.setup_particle(cp, chain.name)
750 # We don't really know the type yet
751  hpp.add_child(hcp)
752  for residue in chain.residues:
753  rp = _copy_residue(residue, model)
754  hrp = IMP.atom.Hierarchy(rp)
755  hcp.add_child(hrp)
756  for atom in residue.atoms:
757  ap = _copy_atom(atom, model)
758  hap = IMP.atom.Hierarchy(ap)
759  hrp.add_child(hap)
760  self._atoms[atom.index] = ap
761  lastres = hrp
762  self._modeller_hierarchy = hpp
763  return hpp
764 
765  def _get_nonbonded_list(self, atoms, pair_filter, edat, distance):
766  nbl = IMP.container.ClosePairContainer(atoms, distance,
767  edat.update_dynamic)
768 
769 # Exclude the same sets of atoms as Modeller
770  if pair_filter is None:
771  pair_filter = IMP.atom.StereochemistryPairFilter()
772  if edat.excl_local[0]:
773  pair_filter.set_bonds(list(self.load_bonds()))
774  if edat.excl_local[1]:
775  pair_filter.set_angles(list(self.load_angles()))
776  if edat.excl_local[2]:
777  pair_filter.set_dihedrals(list(self.load_dihedrals()))
778  nbl.add_pair_filter(pair_filter)
779  return nbl
780 
781  def load_bonds(self):
782  """Load the Modeller bond topology into the IMP model. Each bond is
783  represented in IMP as an IMP::atom::Bond, with no defined length
784  or stiffness. These bonds are primarily useful as input to
785  IMP::atom::StereochemistryPairFilter, to exclude bond interactions
786  from the nonbonded list. Typically the contribution to the scoring
787  function from the bonds is included in the Modeller static restraints
788  (use load_static_restraints() or load_static_restraints_file() to
789  load these). If you want to regenerate the stereochemistry in IMP,
790  do not use these functions (as then stereochemistry scoring terms
791  and exclusions would be double-counted) and instead use the
792  IMP::atom::CHARMMTopology class.
793 
794  You must call load_atoms() prior to using this function.
795  @see load_angles(), load_dihedrals(), load_impropers()
796  @return A generator listing all of the bonds.
797  """
798  if not hasattr(self, '_modeller_hierarchy'):
799  raise ValueError("Call load_atoms() first.")
800  for (maa, mab) in self._modeller_model.bonds:
801  pa = self._atoms[maa.index]
802  pb = self._atoms[mab.index]
804  ba= IMP.atom.Bonded(pa)
805  else:
808  bb= IMP.atom.Bonded(pb)
809  else:
811  yield IMP.atom.create_bond(ba, bb,
812  IMP.atom.Bond.SINGLE).get_particle()
813 
814  def load_angles(self):
815  """Load the Modeller angle topology into the IMP model.
816  See load_bonds() for more details."""
817  return self._internal_load_angles(self._modeller_model.angles,
819 
820  def load_dihedrals(self):
821  """Load the Modeller dihedral topology into the IMP model.
822  See load_bonds() for more details."""
823  return self._internal_load_angles(self._modeller_model.dihedrals,
825 
826  def load_impropers(self):
827  """Load the Modeller improper topology into the IMP model.
828  See load_bonds() for more details."""
829  return self._internal_load_angles(self._modeller_model.impropers,
831 
832  def _internal_load_angles(self, angles, angle_class):
833  if not hasattr(self, '_modeller_hierarchy'):
834  raise ValueError("Call load_atoms() first.")
835  for modeller_atoms in angles:
836  imp_particles = [self._atoms[x.index] for x in modeller_atoms]
837  p = IMP.Particle(imp_particles[0].get_model())
838  a = angle_class.setup_particle(p,
839  *[IMP.core.XYZ(x) for x in imp_particles])
840  yield a.get_particle()
841 
842  def load_static_restraints_file(self, filename):
843  """Convert a Modeller static restraints file into equivalent
844  IMP::Restraints. load_atoms() must have been called first to read
845  in the atoms that the restraints will act upon.
846  @param filename Name of the Modeller restraints file. The restraints
847  in this file are assumed to act upon the model read in by
848  load_atoms(); no checking is done to enforce this.
849  @return A Python generator of the newly-created IMP::Restraint
850  objects.
851  """
852  if not hasattr(self, '_modeller_hierarchy'):
853  raise ValueError("Call load_atoms() first.")
854  return _load_entire_restraints_file(filename, self._modeller_hierarchy)
855 
856 
858  """Convert the current set of Modeller static restraints into equivalent
859  IMP::Restraints. load_atoms() must have been called first to read
860  in the atoms that the restraints will act upon.
861  @return A Python generator of the newly-created IMP::Restraint
862  objects.
863  """
864  class _RestraintGenerator(object):
865  """Simple generator wrapper"""
866  def __init__(self, gen):
867  self._gen = gen
868  def __iter__(self, *args, **keys):
869  return self
870  def close(self, *args, **keys):
871  return self._gen.close(*args, **keys)
872  def next(self):
873  return next(self._gen)
874  __next__ = next
875  def send(self, *args, **keys):
876  return self._gen.send(*args, **keys)
877  def throw(self, *args, **keys):
878  return self._gen.throw(*args, **keys)
879 # Write current restraints into a temporary file
880  t = _TempDir()
881  rsrfile = os.path.join(t.tmpdir, 'restraints.rsr')
882  self._modeller_model.restraints.write(file=rsrfile)
883 # Read the file back in
884  gen = self.load_static_restraints_file(rsrfile)
885  wrap = _RestraintGenerator(gen)
886 # Ensure that tmpdir remains until we're done with the generator
887  wrap._tempdir = t
888  return wrap
889 
890  def load_dynamic_restraints(self, pair_filter=None):
891  """Convert Modeller dynamic restraints into IMP::Restraint objects.
892 
893  For each currently active Modeller dynamic restraint
894  (e.g. soft-sphere, electrostatics) an equivalent IMP::Restraint
895  is created.
896  load_atoms() must have been called first to read
897  in the atoms that the restraints will act upon.
898 
899  If pair_filter is given, it is an IMP::PairFilter object to exclude
900  pairs from the nonbonded lists used by the dynamic restraints.
901  Otherwise, an IMP::atom::StereochemistryPairFilter object is created
902  to exclude Modeller bonds, angles and dihedrals, as specified by
903  edat.excl_local. (Note that this calls load_bonds(), load_angles()
904  and load_dihedrals(), so will create duplicate lists of bonds if
905  those methods are called manually as well.)
906 
907  @note Currently only soft-sphere, electrostatic and Lennard-Jones
908  restraints are loaded.
909  @return A Python generator of the newly-created IMP::Restraint
910  objects.
911  """
912  if not hasattr(self, '_modeller_hierarchy'):
913  raise ValueError("Call load_atoms() first.")
914  edat = self._modeller_model.env.edat
915  libs = self._modeller_model.env.libs
916  atoms = IMP.atom.get_leaves(self._modeller_hierarchy)
917  m = atoms[0].get_model()
919 
920  if edat.dynamic_sphere:
921 # Note: cannot use Modeller's cutoff distance, as that is
922 # center-to-center; IMP's is sphere surface-surface
923  nbl = self._get_nonbonded_list(atoms, pair_filter, edat, 0.)
924 # No way to get Modeller radii, so we have to reassign them
925  add_soft_sphere_radii(self._modeller_hierarchy,
926  libs.topology.submodel, edat.radii_factor)
927  k = \
931  yield IMP.container.PairsRestraint(ps, nbl)
932 
933  if edat.dynamic_lennard or edat.dynamic_coulomb:
934 # 3.0 is roughly the max. atom diameter
935  d = max(edat.contact_shell - 3.0, 0.0)
936  nbl = self._get_nonbonded_list(atoms, pair_filter, edat, d)
937  ff = _get_forcefield(libs.topology.submodel)
938  ff.add_radii(self._modeller_hierarchy)
939 
940  if edat.dynamic_lennard:
941  ff.add_well_depths(self._modeller_hierarchy)
942  sf = IMP.atom.ForceSwitch(edat.lennard_jones_switch[0],
943  edat.lennard_jones_switch[1])
945  yield IMP.container.PairsRestraint(ps, nbl)
946 
947  if edat.dynamic_coulomb:
948  sf = IMP.atom.ForceSwitch(edat.coulomb_switch[0],
949  edat.coulomb_switch[1])
951  ps.set_relative_dielectric(edat.relative_dielectric)
952  yield IMP.container.PairsRestraint(ps, nbl)
953 
954 
955 
956 def get_module_version():
957  """get_module_version() -> std::string const"""
958  return _IMP_modeller.get_module_version()
959 
960 def get_example_path(fname):
961  """get_example_path(std::string fname) -> std::string"""
962  return _IMP_modeller.get_example_path(fname)
963 
964 def get_data_path(fname):
965  """get_data_path(std::string fname) -> std::string"""
966  return _IMP_modeller.get_data_path(fname)
967 
968 from . import _version_check
969 _version_check.check_version(get_module_version())
970 __version__ = get_module_version()
971 
972 
973 
static CHARMMAtom setup_particle(Model *m, ParticleIndex pi, String charmm_type)
Definition: CHARMMAtom.h:37
static Charged setup_particle(Model *m, ParticleIndex pi, Float charge)
Definition: Charged.h:46
Lower bound harmonic function (non-zero when feature < mean)
def load_static_restraints
Convert the current set of Modeller static restraints into equivalent IMP::Restraints.
std::string get_example_path(std::string file_name)
Return the full path to one of this module's example files.
def load_bonds
Load the Modeller bond topology into the IMP model.
A Modeller restraint which evaluates an IMP scoring function.
Coulomb (electrostatic) score between a pair of particles.
static Atom setup_particle(Model *m, ParticleIndex pi, Atom other)
Definition: atom/Atom.h:242
Various classes to hold sets of particles.
Upper bound harmonic function (non-zero when feature > mean)
static XYZR setup_particle(Model *m, ParticleIndex pi)
Definition: XYZR.h:48
A decorator for a particle which has bonds.
def load_impropers
Load the Modeller improper topology into the IMP model.
Make CGAL functionality available to IMP.
Cosine function.
Definition: Cosine.h:22
std::string get_data_path(std::string file_name)
Return the full path to one of this module's data files.
Dihedral restraint between four particles.
def load_static_restraints_file
Convert a Modeller static restraints file into equivalent IMP::Restraints.
The type of an atom.
A score on the distance between the surfaces of two spheres.
Return all close unordered pairs of particles taken from the SingletonContainer.
static Residue setup_particle(Model *m, ParticleIndex pi, ResidueType t, int index, int insertion_code)
Definition: Residue.h:157
A single binormal term in a MultipleBinormalRestraint.
def load_dynamic_restraints
Convert Modeller dynamic restraints into IMP::Restraint objects.
Distance restraint between two particles.
static XYZ setup_particle(Model *m, ParticleIndex pi)
Definition: XYZ.h:51
Composable functors to implement scores via compile-time composition.
An IMP restraint using all defined Modeller restraints.
CHARMM force field parameters.
Bond create_bond(Bonded a, Bonded b, Bond o)
Connect the two wrapped particles by a custom bond.
def load_dihedrals
Load the Modeller dihedral topology into the IMP model.
static Float get_k_from_standard_deviation(Float sd, Float t=297.15)
Return the k to use for a given Gaussian standard deviation.
Definition: core/Harmonic.h:62
Angle restraint between three particles.
static Hierarchy setup_particle(Model *m, ParticleIndex pi, ParticleIndexesAdaptor children=ParticleIndexesAdaptor())
Create a Hierarchy of level t by adding the needed attributes.
ParticleIndexPairs get_indexes(const ParticlePairsTemp &ps)
Lennard-Jones score between a pair of particles.
A particle that describes an angle between three particles.
The standard decorator for manipulating molecular structures.
Store a list of ParticleIndexes.
static Bonded setup_particle(Model *m, ParticleIndex pi)
The type for a residue.
def load_atoms
Construct an IMP::atom::Hierarchy that contains the same atoms as the Modeller model or alignment str...
Version and module information for Objects.
Definition: VersionInfo.h:28
A decorator for a particle with x,y,z coordinates.
Definition: XYZ.h:30
Modeller-style multiple binormal (phi/psi) restraint.
Linear function
Definition: Linear.h:19
def add_soft_sphere_radii
Add radii to the hierarchy using the Modeller radius library, radii.lib.
A particle that describes a dihedral angle between four particles.
def load_angles
Load the Modeller angle topology into the IMP model.
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...
static bool get_is_setup(const IMP::ParticleAdaptor &p)
virtual VersionInfo get_version_info() const
Get information about the module and version of the object.
Definition: Object.h:173
VectorD< 3 > Vector3D
Definition: VectorD.h:395
A filter that excludes bonds, angles and dihedrals.
Read a Modeller model into IMP.
Class to handle individual particles of a Model object.
Definition: Particle.h:41
std::string get_data_path(std::string file_name)
Return the full path to one of this module's data files.
Smooth interaction scores by switching the derivatives (force switch).
Output IMP model data in various file formats.
Functionality for loading, creating, manipulating and scoring atomic structures.
static Chain setup_particle(Model *m, ParticleIndex pi, std::string id)
Definition: Chain.h:81
Hierarchies get_leaves(const Selection &h)
Applies a PairScore to each Pair in a list.
virtual ModelObjectsTemp do_get_inputs() const =0
Closed cubic spline function.
A decorator for an atom that has a defined CHARMM type.
Definition: CHARMMAtom.h:24
A restraint is a term in an IMP ScoringFunction.
Definition: Restraint.h:54
Harmonic function (symmetric about the mean)
Definition: core/Harmonic.h:24