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