10 from __future__
import print_function, division, absolute_import
15 from sys
import version_info
16 if version_info >= (2, 6, 0):
17 def swig_import_helper():
18 from os.path
import dirname
22 fp, pathname, description = imp.find_module(
'_IMP_modeller', [dirname(__file__)])
28 _mod = imp.load_module(
'_IMP_modeller', fp, pathname, description)
32 _IMP_modeller = swig_import_helper()
33 del swig_import_helper
38 _swig_property = property
43 def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
44 if (name ==
"thisown"):
45 return self.this.own(value)
47 if type(value).__name__ ==
'SwigPyObject':
48 self.__dict__[name] = value
50 method = class_type.__swig_setmethods__.get(name,
None)
52 return method(self, value)
54 object.__setattr__(self, name, value)
56 raise AttributeError(
"You cannot add attributes to %s" % self)
59 def _swig_setattr(self, class_type, name, value):
60 return _swig_setattr_nondynamic(self, class_type, name, value, 0)
63 def _swig_getattr_nondynamic(self, class_type, name, static=1):
64 if (name ==
"thisown"):
65 return self.this.own()
66 method = class_type.__swig_getmethods__.get(name,
None)
70 return object.__getattr__(self, name)
72 raise AttributeError(name)
74 def _swig_getattr(self, class_type, name):
75 return _swig_getattr_nondynamic(self, class_type, name, 0)
80 strthis =
"proxy of " + self.this.__repr__()
83 return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
88 except AttributeError:
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)
102 raise AttributeError(
"You cannot add attributes to %s" % self)
108 weakref_proxy = weakref.proxy
110 weakref_proxy =
lambda x: x
113 class IMP_MODELLER_SwigPyIterator(object):
114 """Proxy of C++ swig::IMP_MODELLER_SwigPyIterator class."""
116 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
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
125 """value(IMP_MODELLER_SwigPyIterator self) -> PyObject *"""
126 return _IMP_modeller.IMP_MODELLER_SwigPyIterator_value(self)
131 incr(IMP_MODELLER_SwigPyIterator self, size_t n=1) -> IMP_MODELLER_SwigPyIterator
132 incr(IMP_MODELLER_SwigPyIterator self) -> IMP_MODELLER_SwigPyIterator
134 return _IMP_modeller.IMP_MODELLER_SwigPyIterator_incr(self, n)
139 decr(IMP_MODELLER_SwigPyIterator self, size_t n=1) -> IMP_MODELLER_SwigPyIterator
140 decr(IMP_MODELLER_SwigPyIterator self) -> IMP_MODELLER_SwigPyIterator
142 return _IMP_modeller.IMP_MODELLER_SwigPyIterator_decr(self, n)
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)
151 """equal(IMP_MODELLER_SwigPyIterator self, IMP_MODELLER_SwigPyIterator x) -> bool"""
152 return _IMP_modeller.IMP_MODELLER_SwigPyIterator_equal(self, x)
156 """copy(IMP_MODELLER_SwigPyIterator self) -> IMP_MODELLER_SwigPyIterator"""
157 return _IMP_modeller.IMP_MODELLER_SwigPyIterator_copy(self)
161 """next(IMP_MODELLER_SwigPyIterator self) -> PyObject *"""
162 return _IMP_modeller.IMP_MODELLER_SwigPyIterator_next(self)
166 """__next__(IMP_MODELLER_SwigPyIterator self) -> PyObject *"""
167 return _IMP_modeller.IMP_MODELLER_SwigPyIterator___next__(self)
171 """previous(IMP_MODELLER_SwigPyIterator self) -> PyObject *"""
172 return _IMP_modeller.IMP_MODELLER_SwigPyIterator_previous(self)
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)
181 """__eq__(IMP_MODELLER_SwigPyIterator self, IMP_MODELLER_SwigPyIterator x) -> bool"""
182 return _IMP_modeller.IMP_MODELLER_SwigPyIterator___eq__(self, x)
186 """__ne__(IMP_MODELLER_SwigPyIterator self, IMP_MODELLER_SwigPyIterator x) -> bool"""
187 return _IMP_modeller.IMP_MODELLER_SwigPyIterator___ne__(self, x)
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)
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)
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)
205 def __sub__(self, *args):
207 __sub__(IMP_MODELLER_SwigPyIterator self, ptrdiff_t n) -> IMP_MODELLER_SwigPyIterator
208 __sub__(IMP_MODELLER_SwigPyIterator self, IMP_MODELLER_SwigPyIterator x) -> ptrdiff_t
210 return _IMP_modeller.IMP_MODELLER_SwigPyIterator___sub__(self, *args)
214 IMP_MODELLER_SwigPyIterator_swigregister = _IMP_modeller.IMP_MODELLER_SwigPyIterator_swigregister
215 IMP_MODELLER_SwigPyIterator_swigregister(IMP_MODELLER_SwigPyIterator)
224 _IMP_modeller.IMP_DEBUG_swigconstant(_IMP_modeller)
225 IMP_DEBUG = _IMP_modeller.IMP_DEBUG
227 _IMP_modeller.IMP_RELEASE_swigconstant(_IMP_modeller)
228 IMP_RELEASE = _IMP_modeller.IMP_RELEASE
230 _IMP_modeller.IMP_SILENT_swigconstant(_IMP_modeller)
231 IMP_SILENT = _IMP_modeller.IMP_SILENT
233 _IMP_modeller.IMP_PROGRESS_swigconstant(_IMP_modeller)
234 IMP_PROGRESS = _IMP_modeller.IMP_PROGRESS
236 _IMP_modeller.IMP_TERSE_swigconstant(_IMP_modeller)
237 IMP_TERSE = _IMP_modeller.IMP_TERSE
239 _IMP_modeller.IMP_VERBOSE_swigconstant(_IMP_modeller)
240 IMP_VERBOSE = _IMP_modeller.IMP_VERBOSE
242 _IMP_modeller.IMP_MEMORY_swigconstant(_IMP_modeller)
243 IMP_MEMORY = _IMP_modeller.IMP_MEMORY
245 _IMP_modeller.IMP_NONE_swigconstant(_IMP_modeller)
246 IMP_NONE = _IMP_modeller.IMP_NONE
248 _IMP_modeller.IMP_USAGE_swigconstant(_IMP_modeller)
249 IMP_USAGE = _IMP_modeller.IMP_USAGE
251 _IMP_modeller.IMP_INTERNAL_swigconstant(_IMP_modeller)
252 IMP_INTERNAL = _IMP_modeller.IMP_INTERNAL
254 _IMP_modeller.IMP_KERNEL_HAS_LOG4CXX_swigconstant(_IMP_modeller)
255 IMP_KERNEL_HAS_LOG4CXX = _IMP_modeller.IMP_KERNEL_HAS_LOG4CXX
257 _IMP_modeller.IMP_COMPILER_HAS_AUTO_swigconstant(_IMP_modeller)
258 IMP_COMPILER_HAS_AUTO = _IMP_modeller.IMP_COMPILER_HAS_AUTO
260 _IMP_modeller.IMP_COMPILER_HAS_DEBUG_VECTOR_swigconstant(_IMP_modeller)
261 IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_modeller.IMP_COMPILER_HAS_DEBUG_VECTOR
263 _IMP_modeller.IMP_COMPILER_HAS_UNIQUE_PTR_swigconstant(_IMP_modeller)
264 IMP_COMPILER_HAS_UNIQUE_PTR = _IMP_modeller.IMP_COMPILER_HAS_UNIQUE_PTR
266 _IMP_modeller.IMP_KERNEL_HAS_BOOST_RANDOM_swigconstant(_IMP_modeller)
267 IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_modeller.IMP_KERNEL_HAS_BOOST_RANDOM
269 _IMP_modeller.IMP_KERNEL_HAS_GPERFTOOLS_swigconstant(_IMP_modeller)
270 IMP_KERNEL_HAS_GPERFTOOLS = _IMP_modeller.IMP_KERNEL_HAS_GPERFTOOLS
272 _IMP_modeller.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER_swigconstant(_IMP_modeller)
273 IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER = _IMP_modeller.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER
275 _IMP_modeller.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER_swigconstant(_IMP_modeller)
276 IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER = _IMP_modeller.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER
278 _IMP_modeller.IMPKERNEL_SHOW_WARNINGS_swigconstant(_IMP_modeller)
279 IMPKERNEL_SHOW_WARNINGS = _IMP_modeller.IMPKERNEL_SHOW_WARNINGS
282 class _DirectorObjects(object):
283 """@internal Simple class to keep references to director objects
284 to prevent premature deletion."""
287 def register(self, obj):
288 """Take a reference to a director object; will only work for
289 refcounted C++ classes"""
290 if hasattr(obj,
'get_ref_count'):
291 self._objects.append(obj)
293 """Only drop our reference and allow cleanup by Python if no other
294 Python references exist (we hold 3 references: one in self._objects,
295 one in x, and one in the argument list for getrefcount) *and* no
296 other C++ references exist (the Python object always holds one)"""
297 objs = [x
for x
in self._objects
if sys.getrefcount(x) > 3 \
298 or x.get_ref_count() > 1]
302 def get_object_count(self):
303 """Get number of director objects (useful for testing only)"""
304 return len(self._objects)
305 _director_objects = _DirectorObjects()
307 class _ostream(object):
308 """Proxy of C++ std::ostream class."""
310 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
312 def __init__(self, *args, **kwargs):
313 raise AttributeError(
"No constructor defined")
314 __repr__ = _swig_repr
316 def write(self, osa_buf):
317 """write(_ostream self, char const * osa_buf)"""
318 return _IMP_modeller._ostream_write(self, osa_buf)
320 _ostream_swigregister = _IMP_modeller._ostream_swigregister
321 _ostream_swigregister(_ostream)
324 _IMP_modeller.IMP_COMPILER_HAS_OVERRIDE_swigconstant(_IMP_modeller)
325 IMP_COMPILER_HAS_OVERRIDE = _IMP_modeller.IMP_COMPILER_HAS_OVERRIDE
327 _IMP_modeller.IMP_COMPILER_HAS_FINAL_swigconstant(_IMP_modeller)
328 IMP_COMPILER_HAS_FINAL = _IMP_modeller.IMP_COMPILER_HAS_FINAL
330 _IMP_modeller.IMP_HAS_NOEXCEPT_swigconstant(_IMP_modeller)
331 IMP_HAS_NOEXCEPT = _IMP_modeller.IMP_HAS_NOEXCEPT
334 _IMP_modeller.IMP_CGAL_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_modeller)
335 IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_modeller.IMP_CGAL_HAS_BOOST_FILESYSTEM
337 _IMP_modeller.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_modeller)
338 IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_modeller.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS
340 _IMP_modeller.IMP_CGAL_HAS_BOOST_RANDOM_swigconstant(_IMP_modeller)
341 IMP_CGAL_HAS_BOOST_RANDOM = _IMP_modeller.IMP_CGAL_HAS_BOOST_RANDOM
343 _IMP_modeller.IMP_CGAL_HAS_BOOST_SYSTEM_swigconstant(_IMP_modeller)
344 IMP_CGAL_HAS_BOOST_SYSTEM = _IMP_modeller.IMP_CGAL_HAS_BOOST_SYSTEM
346 _IMP_modeller.IMPCGAL_SHOW_WARNINGS_swigconstant(_IMP_modeller)
347 IMPCGAL_SHOW_WARNINGS = _IMP_modeller.IMPCGAL_SHOW_WARNINGS
350 _IMP_modeller.IMP_ALGEBRA_HAS_IMP_CGAL_swigconstant(_IMP_modeller)
351 IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_modeller.IMP_ALGEBRA_HAS_IMP_CGAL
353 _IMP_modeller.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_modeller)
354 IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_modeller.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM
356 _IMP_modeller.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_modeller)
357 IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_modeller.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS
359 _IMP_modeller.IMP_ALGEBRA_HAS_BOOST_RANDOM_swigconstant(_IMP_modeller)
360 IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_modeller.IMP_ALGEBRA_HAS_BOOST_RANDOM
362 _IMP_modeller.IMP_ALGEBRA_HAS_BOOST_SYSTEM_swigconstant(_IMP_modeller)
363 IMP_ALGEBRA_HAS_BOOST_SYSTEM = _IMP_modeller.IMP_ALGEBRA_HAS_BOOST_SYSTEM
365 _IMP_modeller.IMP_ALGEBRA_HAS_CGAL_swigconstant(_IMP_modeller)
366 IMP_ALGEBRA_HAS_CGAL = _IMP_modeller.IMP_ALGEBRA_HAS_CGAL
368 _IMP_modeller.IMP_ALGEBRA_HAS_ANN_swigconstant(_IMP_modeller)
369 IMP_ALGEBRA_HAS_ANN = _IMP_modeller.IMP_ALGEBRA_HAS_ANN
371 _IMP_modeller.IMPALGEBRA_SHOW_WARNINGS_swigconstant(_IMP_modeller)
372 IMPALGEBRA_SHOW_WARNINGS = _IMP_modeller.IMPALGEBRA_SHOW_WARNINGS
375 _IMP_modeller.IMP_DISPLAY_HAS_IMP_CGAL_swigconstant(_IMP_modeller)
376 IMP_DISPLAY_HAS_IMP_CGAL = _IMP_modeller.IMP_DISPLAY_HAS_IMP_CGAL
378 _IMP_modeller.IMP_DISPLAY_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_modeller)
379 IMP_DISPLAY_HAS_BOOST_FILESYSTEM = _IMP_modeller.IMP_DISPLAY_HAS_BOOST_FILESYSTEM
381 _IMP_modeller.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_modeller)
382 IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS = _IMP_modeller.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS
384 _IMP_modeller.IMP_DISPLAY_HAS_BOOST_RANDOM_swigconstant(_IMP_modeller)
385 IMP_DISPLAY_HAS_BOOST_RANDOM = _IMP_modeller.IMP_DISPLAY_HAS_BOOST_RANDOM
387 _IMP_modeller.IMP_DISPLAY_HAS_BOOST_SYSTEM_swigconstant(_IMP_modeller)
388 IMP_DISPLAY_HAS_BOOST_SYSTEM = _IMP_modeller.IMP_DISPLAY_HAS_BOOST_SYSTEM
390 _IMP_modeller.IMP_DISPLAY_HAS_CGAL_swigconstant(_IMP_modeller)
391 IMP_DISPLAY_HAS_CGAL = _IMP_modeller.IMP_DISPLAY_HAS_CGAL
393 _IMP_modeller.IMPDISPLAY_SHOW_WARNINGS_swigconstant(_IMP_modeller)
394 IMPDISPLAY_SHOW_WARNINGS = _IMP_modeller.IMPDISPLAY_SHOW_WARNINGS
397 _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_IMP_CGAL_swigconstant(_IMP_modeller)
398 IMP_SCORE_FUNCTOR_HAS_IMP_CGAL = _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_IMP_CGAL
400 _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_modeller)
401 IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM = _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM
403 _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_modeller)
404 IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS = _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS
406 _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM_swigconstant(_IMP_modeller)
407 IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM = _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM
409 _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM_swigconstant(_IMP_modeller)
410 IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM = _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM
412 _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_CGAL_swigconstant(_IMP_modeller)
413 IMP_SCORE_FUNCTOR_HAS_CGAL = _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_CGAL
415 _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_HDF5_swigconstant(_IMP_modeller)
416 IMP_SCORE_FUNCTOR_HAS_HDF5 = _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_HDF5
418 _IMP_modeller.IMPSCOREFUNCTOR_SHOW_WARNINGS_swigconstant(_IMP_modeller)
419 IMPSCOREFUNCTOR_SHOW_WARNINGS = _IMP_modeller.IMPSCOREFUNCTOR_SHOW_WARNINGS
422 _IMP_modeller.IMP_CORE_HAS_IMP_CGAL_swigconstant(_IMP_modeller)
423 IMP_CORE_HAS_IMP_CGAL = _IMP_modeller.IMP_CORE_HAS_IMP_CGAL
425 _IMP_modeller.IMP_CORE_HAS_IMP_KERNEL_swigconstant(_IMP_modeller)
426 IMP_CORE_HAS_IMP_KERNEL = _IMP_modeller.IMP_CORE_HAS_IMP_KERNEL
428 _IMP_modeller.IMP_CORE_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_modeller)
429 IMP_CORE_HAS_BOOST_FILESYSTEM = _IMP_modeller.IMP_CORE_HAS_BOOST_FILESYSTEM
431 _IMP_modeller.IMP_CORE_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_modeller)
432 IMP_CORE_HAS_BOOST_PROGRAMOPTIONS = _IMP_modeller.IMP_CORE_HAS_BOOST_PROGRAMOPTIONS
434 _IMP_modeller.IMP_CORE_HAS_BOOST_RANDOM_swigconstant(_IMP_modeller)
435 IMP_CORE_HAS_BOOST_RANDOM = _IMP_modeller.IMP_CORE_HAS_BOOST_RANDOM
437 _IMP_modeller.IMP_CORE_HAS_BOOST_SYSTEM_swigconstant(_IMP_modeller)
438 IMP_CORE_HAS_BOOST_SYSTEM = _IMP_modeller.IMP_CORE_HAS_BOOST_SYSTEM
440 _IMP_modeller.IMP_CORE_HAS_CGAL_swigconstant(_IMP_modeller)
441 IMP_CORE_HAS_CGAL = _IMP_modeller.IMP_CORE_HAS_CGAL
443 _IMP_modeller.IMP_CORE_HAS_HDF5_swigconstant(_IMP_modeller)
444 IMP_CORE_HAS_HDF5 = _IMP_modeller.IMP_CORE_HAS_HDF5
446 _IMP_modeller.IMPCORE_SHOW_WARNINGS_swigconstant(_IMP_modeller)
447 IMPCORE_SHOW_WARNINGS = _IMP_modeller.IMPCORE_SHOW_WARNINGS
450 _IMP_modeller.IMP_MODELLER_HAS_IMP_ALGEBRA_swigconstant(_IMP_modeller)
451 IMP_MODELLER_HAS_IMP_ALGEBRA = _IMP_modeller.IMP_MODELLER_HAS_IMP_ALGEBRA
453 _IMP_modeller.IMP_MODELLER_HAS_IMP_CGAL_swigconstant(_IMP_modeller)
454 IMP_MODELLER_HAS_IMP_CGAL = _IMP_modeller.IMP_MODELLER_HAS_IMP_CGAL
456 _IMP_modeller.IMP_MODELLER_HAS_IMP_DISPLAY_swigconstant(_IMP_modeller)
457 IMP_MODELLER_HAS_IMP_DISPLAY = _IMP_modeller.IMP_MODELLER_HAS_IMP_DISPLAY
459 _IMP_modeller.IMP_MODELLER_HAS_IMP_KERNEL_swigconstant(_IMP_modeller)
460 IMP_MODELLER_HAS_IMP_KERNEL = _IMP_modeller.IMP_MODELLER_HAS_IMP_KERNEL
462 _IMP_modeller.IMP_MODELLER_HAS_IMP_SCORE_FUNCTOR_swigconstant(_IMP_modeller)
463 IMP_MODELLER_HAS_IMP_SCORE_FUNCTOR = _IMP_modeller.IMP_MODELLER_HAS_IMP_SCORE_FUNCTOR
465 _IMP_modeller.IMP_MODELLER_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_modeller)
466 IMP_MODELLER_HAS_BOOST_FILESYSTEM = _IMP_modeller.IMP_MODELLER_HAS_BOOST_FILESYSTEM
468 _IMP_modeller.IMP_MODELLER_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_modeller)
469 IMP_MODELLER_HAS_BOOST_PROGRAMOPTIONS = _IMP_modeller.IMP_MODELLER_HAS_BOOST_PROGRAMOPTIONS
471 _IMP_modeller.IMP_MODELLER_HAS_BOOST_RANDOM_swigconstant(_IMP_modeller)
472 IMP_MODELLER_HAS_BOOST_RANDOM = _IMP_modeller.IMP_MODELLER_HAS_BOOST_RANDOM
474 _IMP_modeller.IMP_MODELLER_HAS_BOOST_SYSTEM_swigconstant(_IMP_modeller)
475 IMP_MODELLER_HAS_BOOST_SYSTEM = _IMP_modeller.IMP_MODELLER_HAS_BOOST_SYSTEM
477 _IMP_modeller.IMP_MODELLER_HAS_CGAL_swigconstant(_IMP_modeller)
478 IMP_MODELLER_HAS_CGAL = _IMP_modeller.IMP_MODELLER_HAS_CGAL
480 _IMP_modeller.IMP_MODELLER_HAS_HDF5_swigconstant(_IMP_modeller)
481 IMP_MODELLER_HAS_HDF5 = _IMP_modeller.IMP_MODELLER_HAS_HDF5
483 _IMP_modeller.IMPMODELLER_SHOW_WARNINGS_swigconstant(_IMP_modeller)
484 IMPMODELLER_SHOW_WARNINGS = _IMP_modeller.IMPMODELLER_SHOW_WARNINGS
486 BinormalTermList=list
487 _plural_types.append(
"BinormalTermList")
488 _value_types.append(
"BinormalTerm")
491 _object_types.append(
"MultipleBinormalRestraint")
494 def _object_cast_to_MultipleBinormalRestraint(o):
495 """_object_cast_to_MultipleBinormalRestraint(Object o) -> MultipleBinormalRestraint"""
496 return _IMP_modeller._object_cast_to_MultipleBinormalRestraint(o)
507 import modeller.scripts
508 import modeller.optimizers
510 class _TempDir(object):
511 """Make a temporary directory that is deleted when the object is."""
514 self.tmpdir = tempfile.mkdtemp()
517 shutil.rmtree(self.tmpdir, ignore_errors=
True)
521 """A Modeller restraint which evaluates an IMP scoring function.
522 This can be used to incorporate IMP Restraints into an existing
523 comparative modeling pipeline, or to use Modeller optimizers or
527 _physical_type = modeller.physical.absposition
529 def __init__(self, particles, scoring_function=None):
531 @param particles A list of the IMP atoms (as Particle objects),
532 same order as the Modeller atoms.
533 @param scoring_function An IMP::ScoringFunction object that will
534 be incorporated into the Modeller score (molpdf).
535 @note since Modeller, unlike IMP, is sensitive to the ordering
536 of atoms, it usually makes sense to create the model in
537 Modeller and then use ModelLoader to load it into IMP,
538 since that will preserve the Modeller atom ordering in IMP.
540 modeller.terms.energy_term.__init__(self)
541 self._particles = particles
543 self._sf = scoring_function
545 self._sf = particles[0].get_model()
547 def eval(self, mdl, deriv, indats):
548 atoms = self.indices_to_atoms(mdl, indats)
549 _copy_modeller_coords_to_imp(atoms, self._particles)
550 if len(self._particles) == 0:
553 score = self._sf.evaluate(deriv)
555 dvx = [0.] * len(indats)
556 dvy = [0.] * len(indats)
557 dvz = [0.] * len(indats)
558 _get_imp_derivs(self._particles, dvx, dvy, dvz)
559 return (score, dvx, dvy, dvz)
565 """An IMP restraint using all defined Modeller restraints.
566 This is useful if you want to use Modeller restraints with an IMP
567 optimizer, or in combination with IMP restraints.
569 @note Currently only the coordinates of the atoms are translated
570 between Modeller and IMP; thus, a Modeller restraint which
571 uses any other attribute (e.g. charge) will not react if
572 this attribute is changed by IMP.
575 def __init__(self, model, modeller_model, particles):
577 @param model The IMP Model object.
578 @param modeller_model The Modeller model object.
579 @param particles A list of the IMP atoms (as Particle objects),
580 in the same order as the Modeller atoms.
581 @note since Modeller, unlike IMP, is sensitive to the ordering
582 of atoms, it usually makes sense to create the model in
583 Modeller and then use ModelLoader to load it into IMP,
584 since that will preserve the Modeller atom ordering in IMP.
587 if hasattr(x,
'get_particle'):
588 return x.get_particle()
591 IMP.Restraint.__init__(self, model,
"ModellerRestraints %1%")
592 self._modeller_model = modeller_model
593 self._particles = [get_particle(x)
for x
in particles]
595 def unprotected_evaluate(self, accum):
596 atoms = self._modeller_model.atoms
597 sel = modeller.selection(self._modeller_model)
598 _copy_imp_coords_to_modeller(self._particles, atoms)
599 energies = sel.energy()
601 _add_modeller_derivs_to_imp(atoms, self._particles, accum)
607 def do_show(self, fh):
608 fh.write(
"ModellerRestraints")
610 return self._particles
613 def _copy_imp_coords_to_modeller(particles, atoms):
614 """Copy atom coordinates from IMP to Modeller"""
618 for (num, at)
in enumerate(atoms):
619 at.x = particles[num].get_value(xkey)
620 at.y = particles[num].get_value(ykey)
621 at.z = particles[num].get_value(zkey)
624 def _copy_modeller_coords_to_imp(atoms, particles):
625 """Copy atom coordinates from Modeller to IMP"""
629 for (num, at)
in enumerate(atoms):
630 particles[num].set_value(xkey, at.x)
631 particles[num].set_value(ykey, at.y)
632 particles[num].set_value(zkey, at.z)
635 def _add_modeller_derivs_to_imp(atoms, particles, accum):
636 """Add atom derivatives from Modeller to IMP"""
637 for (num, at)
in enumerate(atoms):
639 xyz.add_to_derivative(0, at.dvx, accum)
640 xyz.add_to_derivative(1, at.dvy, accum)
641 xyz.add_to_derivative(2, at.dvz, accum)
644 def _get_imp_derivs(particles, dvx, dvy, dvz):
645 """Move atom derivatives from IMP to Modeller"""
649 for idx
in range(0, len(dvx)):
650 dvx[idx] = particles[idx].get_derivative(xkey)
651 dvy[idx] = particles[idx].get_derivative(ykey)
652 dvz[idx] = particles[idx].get_derivative(zkey)
656 def _HarmonicLowerBoundGenerator(parameters, modalities):
657 (mean, stdev) = parameters
661 def _HarmonicUpperBoundGenerator(parameters, modalities):
662 (mean, stdev) = parameters
666 def _HarmonicGenerator(parameters, modalities):
667 (mean, stdev) = parameters
671 def _CosineGenerator(parameters, modalities):
672 (phase, force_constant) = parameters
673 (periodicity,) = modalities
676 def _LinearGenerator(parameters, modalities):
677 (scale,) = parameters
680 def _SplineGenerator(parameters, modalities):
681 (open, low, high, delta, lowderiv, highderiv) = parameters[:6]
683 for v
in parameters[6:]:
691 _unary_func_generators = {
692 1: _HarmonicLowerBoundGenerator,
693 2: _HarmonicUpperBoundGenerator,
694 3: _HarmonicGenerator,
697 10: _SplineGenerator,
701 def _DistanceRestraintGenerator(form, modalities, atoms, parameters):
702 unary_func_gen = _unary_func_generators[form]
704 unary_func_gen(parameters, modalities),
707 def _AngleRestraintGenerator(form, modalities, atoms, parameters):
708 unary_func_gen = _unary_func_generators[form]
710 unary_func_gen(parameters, modalities),
711 atoms[0], atoms[1], atoms[2])
713 def _MultiBinormalGenerator(form, modalities, atoms, parameters):
714 nterms = modalities[0]
715 if len(parameters) != nterms * 6:
716 raise ValueError(
"Incorrect number of parameters (%d) for multiple "
717 "binormal restraint - expecting %d (%d terms * 6)" \
718 % (len(parameters), nterms * 6, nterms))
720 atoms[:4], atoms[4:8])
721 for i
in range(nterms):
723 t.set_weight(parameters[i])
724 t.set_means((parameters[nterms + i * 2],
725 parameters[nterms + i * 2 + 1]))
726 t.set_standard_deviations((parameters[nterms * 3 + i * 2],
727 parameters[nterms * 3 + i * 2 + 1]))
728 t.set_correlation(parameters[nterms * 5 + i])
732 def _DihedralRestraintGenerator(form, modalities, atoms, parameters):
734 return _MultiBinormalGenerator(form, modalities, atoms, parameters)
735 unary_func_gen = _unary_func_generators[form]
737 unary_func_gen(parameters, modalities),
738 atoms[0], atoms[1], atoms[2], atoms[3])
740 def _get_protein_atom_particles(protein):
741 """Given a protein particle, get the flattened list of all child atoms"""
743 for ichain
in range(protein.get_number_of_children()):
744 chain = protein.get_child(ichain)
745 for ires
in range(chain.get_number_of_children()):
746 residue = chain.get_child(ires)
747 for iatom
in range(residue.get_number_of_children()):
748 atom = residue.get_child(iatom)
749 atom_particles.append(atom.get_particle())
750 return atom_particles
752 def _load_restraints_line(line, atom_particles):
753 """Parse a single Modeller restraints file line and return the
754 corresponding IMP restraint."""
757 if typ ==
'MODELLER5':
760 raise NotImplementedError(
"Only 'R' lines currently read from " + \
761 "Modeller restraints files")
762 form = int(spl.pop(0))
763 modalities = [int(spl.pop(0))]
764 features = [int(spl.pop(0))]
767 natoms = [int(spl.pop(0))]
768 nparam = int(spl.pop(0))
769 nfeat = int(spl.pop(0))
770 for i
in range(nfeat - 1):
771 modalities.append(int(spl.pop(0)))
772 features.append(int(spl.pop(0)))
773 natoms.append(int(spl.pop(0)))
774 atoms = [int(spl.pop(0))
for x
in range(natoms[0])]
775 for i
in range(len(atoms)):
776 atoms[i] = atom_particles[atoms[i] - 1]
777 parameters = [float(spl.pop(0))
for x
in range(nparam)]
778 restraint_generators = {
779 1 : _DistanceRestraintGenerator,
780 2 : _AngleRestraintGenerator,
781 3 : _DihedralRestraintGenerator,
783 restraint_gen = restraint_generators[features[0]]
784 return restraint_gen(form, modalities, atoms, parameters)
787 def _load_entire_restraints_file(filename, protein):
788 """Yield a set of IMP restraints from a Modeller restraints file."""
789 atoms = _get_protein_atom_particles(protein)
790 fh = open(filename,
'r')
793 rsr = _load_restraints_line(line, atoms)
796 except Exception
as err:
797 print(
"Cannot read restraints file line:\n" + line)
801 def _copy_residue(r, model):
802 """Copy residue information from modeller to imp"""
807 p.set_name(str(
"residue "+r.num));
811 def _copy_atom(a, model):
812 """Copy atom information from modeller"""
818 if hasattr(a,
'charge'):
820 if hasattr(a,
'type'):
822 ap.set_input_index(a.index)
825 def _copy_chain(c, model):
826 """Copy chain information from modeller"""
833 def _get_forcefield(submodel):
845 """Add radii to the hierarchy using the Modeller radius library, radii.lib.
846 Each radius is scaled by the given scale (Modeller usually scales radii
847 by a factor of 0.82). submodel specifies the topology submodel, which is
848 the column in radii.lib to use."""
852 for line
in open(filename):
853 if line.startswith(
'#'):
continue
856 radii[spl[0]] = float(spl[submodel])
857 atoms = IMP.atom.get_by_type(hierarchy, IMP.atom.ATOM_TYPE)
866 """Read a Modeller model into IMP. After creating this object, the atoms
867 in the Modeller model can be loaded into IMP using the load_atoms()
868 method, then optionally any Modeller static restraints can be read in
869 with load_static_restraints() or load_static_restraints_file().
871 This class can also be used to read Modeller alignment structures;
872 however, only load_atoms() will be useful in such a case (since
873 alignment structures don't have restraints or other information).
879 @param modeller_model The Modeller model or alignment structure
882 self._modeller_model = modeller_model
885 """Construct an IMP::atom::Hierarchy that contains the same atoms as
886 the Modeller model or alignment structure.
888 IMP atoms created from a Modeller model will be given charges and
889 CHARMM types, extracted from the model. Alignment structures don't
890 contain this information, so the IMP atoms won't either.
892 @param model The IMP::Model object in which the hierarchy will be
893 created. The highest level hierarchy node is a PROTEIN.
894 @return the newly-created root IMP::atom::Hierarchy.
899 for chain
in self._modeller_model.chains:
904 for residue
in chain.residues:
905 rp = _copy_residue(residue, model)
908 for atom
in residue.atoms:
909 ap = _copy_atom(atom, model)
912 self._atoms[atom.index] = ap
914 self._modeller_hierarchy = hpp
917 def _get_nonbonded_list(self, atoms, pair_filter, edat, distance):
922 if pair_filter
is None:
924 if edat.excl_local[0]:
925 pair_filter.set_bonds(list(self.
load_bonds()))
926 if edat.excl_local[1]:
928 if edat.excl_local[2]:
930 nbl.add_pair_filter(pair_filter)
934 """Load the Modeller bond topology into the IMP model. Each bond is
935 represented in IMP as an IMP::atom::Bond, with no defined length
936 or stiffness. These bonds are primarily useful as input to
937 IMP::atom::StereochemistryPairFilter, to exclude bond interactions
938 from the nonbonded list. Typically the contribution to the scoring
939 function from the bonds is included in the Modeller static restraints
940 (use load_static_restraints() or load_static_restraints_file() to
941 load these). If you want to regenerate the stereochemistry in IMP,
942 do not use these functions (as then stereochemistry scoring terms
943 and exclusions would be double-counted) and instead use the
944 IMP::atom::CHARMMTopology class.
946 You must call load_atoms() prior to using this function.
947 @see load_angles(), load_dihedrals(), load_impropers()
948 @return A generator listing all of the bonds.
950 if not hasattr(self,
'_modeller_hierarchy'):
951 raise ValueError(
"Call load_atoms() first.")
952 for (maa, mab)
in self._modeller_model.bonds:
953 pa = self._atoms[maa.index]
954 pb = self._atoms[mab.index]
964 IMP.atom.Bond.SINGLE).get_particle()
967 """Load the Modeller angle topology into the IMP model.
968 See load_bonds() for more details."""
969 return self._internal_load_angles(self._modeller_model.angles,
973 """Load the Modeller dihedral topology into the IMP model.
974 See load_bonds() for more details."""
975 return self._internal_load_angles(self._modeller_model.dihedrals,
979 """Load the Modeller improper topology into the IMP model.
980 See load_bonds() for more details."""
981 return self._internal_load_angles(self._modeller_model.impropers,
984 def _internal_load_angles(self, angles, angle_class):
985 if not hasattr(self,
'_modeller_hierarchy'):
986 raise ValueError(
"Call load_atoms() first.")
987 for modeller_atoms
in angles:
988 imp_particles = [self._atoms[x.index]
for x
in modeller_atoms]
990 a = angle_class.setup_particle(p,
992 yield a.get_particle()
995 """Convert a Modeller static restraints file into equivalent
996 IMP::Restraints. load_atoms() must have been called first to read
997 in the atoms that the restraints will act upon.
998 @param filename Name of the Modeller restraints file. The restraints
999 in this file are assumed to act upon the model read in by
1000 load_atoms(); no checking is done to enforce this.
1001 @return A Python generator of the newly-created IMP::Restraint
1004 if not hasattr(self,
'_modeller_hierarchy'):
1005 raise ValueError(
"Call load_atoms() first.")
1006 return _load_entire_restraints_file(filename, self._modeller_hierarchy)
1010 """Convert the current set of Modeller static restraints into equivalent
1011 IMP::Restraints. load_atoms() must have been called first to read
1012 in the atoms that the restraints will act upon.
1013 @return A Python generator of the newly-created IMP::Restraint
1016 class _RestraintGenerator(object):
1017 """Simple generator wrapper"""
1020 def __iter__(self, *args, **keys):
1022 def close(self, *args, **keys):
1023 return self._gen.close(*args, **keys)
1025 return next(self._gen)
1027 def send(self, *args, **keys):
1028 return self._gen.send(*args, **keys)
1029 def throw(self, *args, **keys):
1030 return self._gen.throw(*args, **keys)
1033 rsrfile = os.path.join(t.tmpdir,
'restraints.rsr')
1034 self._modeller_model.restraints.write(file=rsrfile)
1037 wrap = _RestraintGenerator(gen)
1043 """Convert Modeller dynamic restraints into IMP::Restraint objects.
1045 For each currently active Modeller dynamic restraint
1046 (e.g. soft-sphere, electrostatics) an equivalent IMP::Restraint
1048 load_atoms() must have been called first to read
1049 in the atoms that the restraints will act upon.
1051 If pair_filter is given, it is an IMP::PairFilter object to exclude
1052 pairs from the nonbonded lists used by the dynamic restraints.
1053 Otherwise, an IMP::atom::StereochemistryPairFilter object is created
1054 to exclude Modeller bonds, angles and dihedrals, as specified by
1055 edat.excl_local. (Note that this calls load_bonds(), load_angles()
1056 and load_dihedrals(), so will create duplicate lists of bonds if
1057 those methods are called manually as well.)
1059 @note Currently only soft-sphere, electrostatic and Lennard-Jones
1060 restraints are loaded.
1061 @return A Python generator of the newly-created IMP::Restraint
1064 if not hasattr(self,
'_modeller_hierarchy'):
1065 raise ValueError(
"Call load_atoms() first.")
1066 edat = self._modeller_model.env.edat
1067 libs = self._modeller_model.env.libs
1069 m = atoms[0].get_model()
1072 if edat.dynamic_sphere:
1075 nbl = self._get_nonbonded_list(atoms, pair_filter, edat, 0.)
1078 libs.topology.submodel, edat.radii_factor)
1085 if edat.dynamic_lennard
or edat.dynamic_coulomb:
1087 d = max(edat.contact_shell - 3.0, 0.0)
1088 nbl = self._get_nonbonded_list(atoms, pair_filter, edat, d)
1089 ff = _get_forcefield(libs.topology.submodel)
1090 ff.add_radii(self._modeller_hierarchy)
1092 if edat.dynamic_lennard:
1093 ff.add_well_depths(self._modeller_hierarchy)
1095 edat.lennard_jones_switch[1])
1099 if edat.dynamic_coulomb:
1101 edat.coulomb_switch[1])
1103 ps.set_relative_dielectric(edat.relative_dielectric)
1108 """Proxy of C++ IMP::modeller::MultipleBinormalRestraint class."""
1110 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
1113 """__init__(IMP::modeller::MultipleBinormalRestraint self, Model m, IMP::ParticleIndexQuad const & q1, IMP::ParticleIndexQuad const & q2) -> MultipleBinormalRestraint"""
1114 this = _IMP_modeller.new_MultipleBinormalRestraint(m, q1, q2)
1116 self.this.append(this)
1120 def add_term(self, term):
1121 """add_term(MultipleBinormalRestraint self, BinormalTerm term)"""
1122 return _IMP_modeller.MultipleBinormalRestraint_add_term(self, term)
1125 def do_get_inputs(self):
1126 """do_get_inputs(MultipleBinormalRestraint self) -> IMP::ModelObjectsTemp"""
1127 return _IMP_modeller.MultipleBinormalRestraint_do_get_inputs(self)
1130 def get_version_info(self):
1131 """get_version_info(MultipleBinormalRestraint self) -> VersionInfo"""
1132 return _IMP_modeller.MultipleBinormalRestraint_get_version_info(self)
1136 """__str__(MultipleBinormalRestraint self) -> std::string"""
1137 return _IMP_modeller.MultipleBinormalRestraint___str__(self)
1141 """__repr__(MultipleBinormalRestraint self) -> std::string"""
1142 return _IMP_modeller.MultipleBinormalRestraint___repr__(self)
1147 return _object_cast_to_MultipleBinormalRestraint(o)
1149 MultipleBinormalRestraint_swigregister = _IMP_modeller.MultipleBinormalRestraint_swigregister
1150 MultipleBinormalRestraint_swigregister(MultipleBinormalRestraint)
1153 """Proxy of C++ IMP::modeller::BinormalTerm class."""
1155 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
1158 """__init__(IMP::modeller::BinormalTerm self) -> BinormalTerm"""
1159 this = _IMP_modeller.new_BinormalTerm()
1161 self.this.append(this)
1165 def set_correlation(self, correlation):
1166 """set_correlation(BinormalTerm self, double correlation)"""
1167 return _IMP_modeller.BinormalTerm_set_correlation(self, correlation)
1170 def set_weight(self, weight):
1171 """set_weight(BinormalTerm self, double weight)"""
1172 return _IMP_modeller.BinormalTerm_set_weight(self, weight)
1175 def set_means(self, means):
1176 """set_means(BinormalTerm self, IMP::FloatPair means)"""
1177 return _IMP_modeller.BinormalTerm_set_means(self, means)
1180 def set_standard_deviations(self, stdevs):
1181 """set_standard_deviations(BinormalTerm self, IMP::FloatPair stdevs)"""
1182 return _IMP_modeller.BinormalTerm_set_standard_deviations(self, stdevs)
1185 def show(self, *args):
1187 show(BinormalTerm self, _ostream out)
1188 show(BinormalTerm self)
1190 return _IMP_modeller.BinormalTerm_show(self, *args)
1194 """__str__(BinormalTerm self) -> std::string"""
1195 return _IMP_modeller.BinormalTerm___str__(self)
1199 """__repr__(BinormalTerm self) -> std::string"""
1200 return _IMP_modeller.BinormalTerm___repr__(self)
1202 __swig_destroy__ = _IMP_modeller.delete_BinormalTerm
1203 __del__ =
lambda self:
None
1204 BinormalTerm_swigregister = _IMP_modeller.BinormalTerm_swigregister
1205 BinormalTerm_swigregister(BinormalTerm)
1208 def get_module_version():
1209 """get_module_version() -> std::string const"""
1210 return _IMP_modeller.get_module_version()
1213 """get_example_path(std::string fname) -> std::string"""
1214 return _IMP_modeller.get_example_path(fname)
1217 """get_data_path(std::string fname) -> std::string"""
1218 return _IMP_modeller.get_data_path(fname)
1220 from .
import _version_check
1221 _version_check.check_version(get_module_version())
1222 __version__ = get_module_version()
static CHARMMAtom setup_particle(Model *m, ParticleIndex pi, String charmm_type)
static Charged setup_particle(Model *m, ParticleIndex pi, Float charge)
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)
Various classes to hold sets of particles.
Upper bound harmonic function (non-zero when feature > mean)
static XYZR setup_particle(Model *m, ParticleIndex pi)
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.
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.
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)
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)
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.
A single binormal term in a MultipleBinormalRestraint.
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)
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.
A decorator for a particle with x,y,z coordinates.
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.
std::ostream & show(Hierarchy h, std::ostream &out=std::cout)
Print the hierarchy using a given decorator to display each node.
Modeller-style multiple binormal (phi/psi) restraint.
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.
A filter that excludes bonds, angles and dihedrals.
Read a Modeller model into IMP.
Class to handle individual model particles.
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)
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.
A restraint is a term in an IMP ScoringFunction.
Harmonic function (symmetric about the mean)