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"""
115 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
117 def __init__(self, *args, **kwargs):
118 raise AttributeError(
"No constructor defined - class is abstract")
119 __repr__ = _swig_repr
120 __swig_destroy__ = _IMP_modeller.delete_IMP_MODELLER_SwigPyIterator
121 __del__ =
lambda self:
None
124 """value(IMP_MODELLER_SwigPyIterator self) -> PyObject *"""
125 return _IMP_modeller.IMP_MODELLER_SwigPyIterator_value(self)
130 incr(IMP_MODELLER_SwigPyIterator self, size_t n=1) -> IMP_MODELLER_SwigPyIterator
131 incr(IMP_MODELLER_SwigPyIterator self) -> IMP_MODELLER_SwigPyIterator
133 return _IMP_modeller.IMP_MODELLER_SwigPyIterator_incr(self, n)
138 decr(IMP_MODELLER_SwigPyIterator self, size_t n=1) -> IMP_MODELLER_SwigPyIterator
139 decr(IMP_MODELLER_SwigPyIterator self) -> IMP_MODELLER_SwigPyIterator
141 return _IMP_modeller.IMP_MODELLER_SwigPyIterator_decr(self, n)
144 def distance(self, x):
145 """distance(IMP_MODELLER_SwigPyIterator self, IMP_MODELLER_SwigPyIterator x) -> ptrdiff_t"""
146 return _IMP_modeller.IMP_MODELLER_SwigPyIterator_distance(self, x)
150 """equal(IMP_MODELLER_SwigPyIterator self, IMP_MODELLER_SwigPyIterator x) -> bool"""
151 return _IMP_modeller.IMP_MODELLER_SwigPyIterator_equal(self, x)
155 """copy(IMP_MODELLER_SwigPyIterator self) -> IMP_MODELLER_SwigPyIterator"""
156 return _IMP_modeller.IMP_MODELLER_SwigPyIterator_copy(self)
160 """next(IMP_MODELLER_SwigPyIterator self) -> PyObject *"""
161 return _IMP_modeller.IMP_MODELLER_SwigPyIterator_next(self)
165 """__next__(IMP_MODELLER_SwigPyIterator self) -> PyObject *"""
166 return _IMP_modeller.IMP_MODELLER_SwigPyIterator___next__(self)
170 """previous(IMP_MODELLER_SwigPyIterator self) -> PyObject *"""
171 return _IMP_modeller.IMP_MODELLER_SwigPyIterator_previous(self)
174 def advance(self, n):
175 """advance(IMP_MODELLER_SwigPyIterator self, ptrdiff_t n) -> IMP_MODELLER_SwigPyIterator"""
176 return _IMP_modeller.IMP_MODELLER_SwigPyIterator_advance(self, n)
180 """__eq__(IMP_MODELLER_SwigPyIterator self, IMP_MODELLER_SwigPyIterator x) -> bool"""
181 return _IMP_modeller.IMP_MODELLER_SwigPyIterator___eq__(self, x)
185 """__ne__(IMP_MODELLER_SwigPyIterator self, IMP_MODELLER_SwigPyIterator x) -> bool"""
186 return _IMP_modeller.IMP_MODELLER_SwigPyIterator___ne__(self, x)
189 def __iadd__(self, n):
190 """__iadd__(IMP_MODELLER_SwigPyIterator self, ptrdiff_t n) -> IMP_MODELLER_SwigPyIterator"""
191 return _IMP_modeller.IMP_MODELLER_SwigPyIterator___iadd__(self, n)
194 def __isub__(self, n):
195 """__isub__(IMP_MODELLER_SwigPyIterator self, ptrdiff_t n) -> IMP_MODELLER_SwigPyIterator"""
196 return _IMP_modeller.IMP_MODELLER_SwigPyIterator___isub__(self, n)
199 def __add__(self, n):
200 """__add__(IMP_MODELLER_SwigPyIterator self, ptrdiff_t n) -> IMP_MODELLER_SwigPyIterator"""
201 return _IMP_modeller.IMP_MODELLER_SwigPyIterator___add__(self, n)
204 def __sub__(self, *args):
206 __sub__(IMP_MODELLER_SwigPyIterator self, ptrdiff_t n) -> IMP_MODELLER_SwigPyIterator
207 __sub__(IMP_MODELLER_SwigPyIterator self, IMP_MODELLER_SwigPyIterator x) -> ptrdiff_t
209 return _IMP_modeller.IMP_MODELLER_SwigPyIterator___sub__(self, *args)
213 IMP_MODELLER_SwigPyIterator_swigregister = _IMP_modeller.IMP_MODELLER_SwigPyIterator_swigregister
214 IMP_MODELLER_SwigPyIterator_swigregister(IMP_MODELLER_SwigPyIterator)
222 _IMP_modeller.IMP_DEBUG_swigconstant(_IMP_modeller)
223 IMP_DEBUG = _IMP_modeller.IMP_DEBUG
225 _IMP_modeller.IMP_RELEASE_swigconstant(_IMP_modeller)
226 IMP_RELEASE = _IMP_modeller.IMP_RELEASE
228 _IMP_modeller.IMP_SILENT_swigconstant(_IMP_modeller)
229 IMP_SILENT = _IMP_modeller.IMP_SILENT
231 _IMP_modeller.IMP_PROGRESS_swigconstant(_IMP_modeller)
232 IMP_PROGRESS = _IMP_modeller.IMP_PROGRESS
234 _IMP_modeller.IMP_TERSE_swigconstant(_IMP_modeller)
235 IMP_TERSE = _IMP_modeller.IMP_TERSE
237 _IMP_modeller.IMP_VERBOSE_swigconstant(_IMP_modeller)
238 IMP_VERBOSE = _IMP_modeller.IMP_VERBOSE
240 _IMP_modeller.IMP_MEMORY_swigconstant(_IMP_modeller)
241 IMP_MEMORY = _IMP_modeller.IMP_MEMORY
243 _IMP_modeller.IMP_NONE_swigconstant(_IMP_modeller)
244 IMP_NONE = _IMP_modeller.IMP_NONE
246 _IMP_modeller.IMP_USAGE_swigconstant(_IMP_modeller)
247 IMP_USAGE = _IMP_modeller.IMP_USAGE
249 _IMP_modeller.IMP_INTERNAL_swigconstant(_IMP_modeller)
250 IMP_INTERNAL = _IMP_modeller.IMP_INTERNAL
252 _IMP_modeller.IMP_KERNEL_HAS_LOG4CXX_swigconstant(_IMP_modeller)
253 IMP_KERNEL_HAS_LOG4CXX = _IMP_modeller.IMP_KERNEL_HAS_LOG4CXX
255 _IMP_modeller.IMP_COMPILER_HAS_AUTO_swigconstant(_IMP_modeller)
256 IMP_COMPILER_HAS_AUTO = _IMP_modeller.IMP_COMPILER_HAS_AUTO
258 _IMP_modeller.IMP_COMPILER_HAS_DEBUG_VECTOR_swigconstant(_IMP_modeller)
259 IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_modeller.IMP_COMPILER_HAS_DEBUG_VECTOR
261 _IMP_modeller.IMP_KERNEL_HAS_BOOST_RANDOM_swigconstant(_IMP_modeller)
262 IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_modeller.IMP_KERNEL_HAS_BOOST_RANDOM
264 _IMP_modeller.IMP_KERNEL_HAS_GPERFTOOLS_swigconstant(_IMP_modeller)
265 IMP_KERNEL_HAS_GPERFTOOLS = _IMP_modeller.IMP_KERNEL_HAS_GPERFTOOLS
267 _IMP_modeller.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER_swigconstant(_IMP_modeller)
268 IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER = _IMP_modeller.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER
270 _IMP_modeller.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER_swigconstant(_IMP_modeller)
271 IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER = _IMP_modeller.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER
273 _IMP_modeller.IMPKERNEL_SHOW_WARNINGS_swigconstant(_IMP_modeller)
274 IMPKERNEL_SHOW_WARNINGS = _IMP_modeller.IMPKERNEL_SHOW_WARNINGS
276 class _DirectorObjects(object):
277 """@internal Simple class to keep references to director objects
278 to prevent premature deletion."""
281 def register(self, obj):
282 """Take a reference to a director object; will only work for
283 refcounted C++ classes"""
284 if hasattr(obj,
'get_ref_count'):
285 self._objects.append(obj)
287 """Only drop our reference and allow cleanup by Python if no other
288 Python references exist (we hold 3 references: one in self._objects,
289 one in x, and one in the argument list for getrefcount) *and* no
290 other C++ references exist (the Python object always holds one)"""
291 objs = [x
for x
in self._objects
if sys.getrefcount(x) > 3 \
292 or x.get_ref_count() > 1]
296 def get_object_count(self):
297 """Get number of director objects (useful for testing only)"""
298 return len(self._objects)
299 _director_objects = _DirectorObjects()
301 class _ostream(object):
302 """Proxy of C++ std::ostream class"""
303 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
305 def __init__(self, *args, **kwargs):
306 raise AttributeError(
"No constructor defined")
307 __repr__ = _swig_repr
309 def write(self, osa_buf):
310 """write(_ostream self, char const * osa_buf)"""
311 return _IMP_modeller._ostream_write(self, osa_buf)
313 _ostream_swigregister = _IMP_modeller._ostream_swigregister
314 _ostream_swigregister(_ostream)
317 _IMP_modeller.IMP_COMPILER_HAS_OVERRIDE_swigconstant(_IMP_modeller)
318 IMP_COMPILER_HAS_OVERRIDE = _IMP_modeller.IMP_COMPILER_HAS_OVERRIDE
320 _IMP_modeller.IMP_COMPILER_HAS_FINAL_swigconstant(_IMP_modeller)
321 IMP_COMPILER_HAS_FINAL = _IMP_modeller.IMP_COMPILER_HAS_FINAL
323 _IMP_modeller.IMP_HAS_NOEXCEPT_swigconstant(_IMP_modeller)
324 IMP_HAS_NOEXCEPT = _IMP_modeller.IMP_HAS_NOEXCEPT
327 _IMP_modeller.IMP_CGAL_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_modeller)
328 IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_modeller.IMP_CGAL_HAS_BOOST_FILESYSTEM
330 _IMP_modeller.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_modeller)
331 IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_modeller.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS
333 _IMP_modeller.IMP_CGAL_HAS_BOOST_RANDOM_swigconstant(_IMP_modeller)
334 IMP_CGAL_HAS_BOOST_RANDOM = _IMP_modeller.IMP_CGAL_HAS_BOOST_RANDOM
336 _IMP_modeller.IMP_CGAL_HAS_BOOST_SYSTEM_swigconstant(_IMP_modeller)
337 IMP_CGAL_HAS_BOOST_SYSTEM = _IMP_modeller.IMP_CGAL_HAS_BOOST_SYSTEM
339 _IMP_modeller.IMPCGAL_SHOW_WARNINGS_swigconstant(_IMP_modeller)
340 IMPCGAL_SHOW_WARNINGS = _IMP_modeller.IMPCGAL_SHOW_WARNINGS
343 _IMP_modeller.IMP_ALGEBRA_HAS_IMP_CGAL_swigconstant(_IMP_modeller)
344 IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_modeller.IMP_ALGEBRA_HAS_IMP_CGAL
346 _IMP_modeller.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_modeller)
347 IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_modeller.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM
349 _IMP_modeller.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_modeller)
350 IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_modeller.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS
352 _IMP_modeller.IMP_ALGEBRA_HAS_BOOST_RANDOM_swigconstant(_IMP_modeller)
353 IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_modeller.IMP_ALGEBRA_HAS_BOOST_RANDOM
355 _IMP_modeller.IMP_ALGEBRA_HAS_BOOST_SYSTEM_swigconstant(_IMP_modeller)
356 IMP_ALGEBRA_HAS_BOOST_SYSTEM = _IMP_modeller.IMP_ALGEBRA_HAS_BOOST_SYSTEM
358 _IMP_modeller.IMP_ALGEBRA_HAS_CGAL_swigconstant(_IMP_modeller)
359 IMP_ALGEBRA_HAS_CGAL = _IMP_modeller.IMP_ALGEBRA_HAS_CGAL
361 _IMP_modeller.IMP_ALGEBRA_HAS_ANN_swigconstant(_IMP_modeller)
362 IMP_ALGEBRA_HAS_ANN = _IMP_modeller.IMP_ALGEBRA_HAS_ANN
364 _IMP_modeller.IMPALGEBRA_SHOW_WARNINGS_swigconstant(_IMP_modeller)
365 IMPALGEBRA_SHOW_WARNINGS = _IMP_modeller.IMPALGEBRA_SHOW_WARNINGS
368 _IMP_modeller.IMP_DISPLAY_HAS_IMP_CGAL_swigconstant(_IMP_modeller)
369 IMP_DISPLAY_HAS_IMP_CGAL = _IMP_modeller.IMP_DISPLAY_HAS_IMP_CGAL
371 _IMP_modeller.IMP_DISPLAY_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_modeller)
372 IMP_DISPLAY_HAS_BOOST_FILESYSTEM = _IMP_modeller.IMP_DISPLAY_HAS_BOOST_FILESYSTEM
374 _IMP_modeller.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_modeller)
375 IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS = _IMP_modeller.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS
377 _IMP_modeller.IMP_DISPLAY_HAS_BOOST_RANDOM_swigconstant(_IMP_modeller)
378 IMP_DISPLAY_HAS_BOOST_RANDOM = _IMP_modeller.IMP_DISPLAY_HAS_BOOST_RANDOM
380 _IMP_modeller.IMP_DISPLAY_HAS_BOOST_SYSTEM_swigconstant(_IMP_modeller)
381 IMP_DISPLAY_HAS_BOOST_SYSTEM = _IMP_modeller.IMP_DISPLAY_HAS_BOOST_SYSTEM
383 _IMP_modeller.IMP_DISPLAY_HAS_CGAL_swigconstant(_IMP_modeller)
384 IMP_DISPLAY_HAS_CGAL = _IMP_modeller.IMP_DISPLAY_HAS_CGAL
386 _IMP_modeller.IMPDISPLAY_SHOW_WARNINGS_swigconstant(_IMP_modeller)
387 IMPDISPLAY_SHOW_WARNINGS = _IMP_modeller.IMPDISPLAY_SHOW_WARNINGS
390 _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_IMP_CGAL_swigconstant(_IMP_modeller)
391 IMP_SCORE_FUNCTOR_HAS_IMP_CGAL = _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_IMP_CGAL
393 _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_modeller)
394 IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM = _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM
396 _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_modeller)
397 IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS = _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS
399 _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM_swigconstant(_IMP_modeller)
400 IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM = _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM
402 _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM_swigconstant(_IMP_modeller)
403 IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM = _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM
405 _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_CGAL_swigconstant(_IMP_modeller)
406 IMP_SCORE_FUNCTOR_HAS_CGAL = _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_CGAL
408 _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_HDF5_swigconstant(_IMP_modeller)
409 IMP_SCORE_FUNCTOR_HAS_HDF5 = _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_HDF5
411 _IMP_modeller.IMPSCOREFUNCTOR_SHOW_WARNINGS_swigconstant(_IMP_modeller)
412 IMPSCOREFUNCTOR_SHOW_WARNINGS = _IMP_modeller.IMPSCOREFUNCTOR_SHOW_WARNINGS
415 _IMP_modeller.IMP_CORE_HAS_IMP_CGAL_swigconstant(_IMP_modeller)
416 IMP_CORE_HAS_IMP_CGAL = _IMP_modeller.IMP_CORE_HAS_IMP_CGAL
418 _IMP_modeller.IMP_CORE_HAS_IMP_KERNEL_swigconstant(_IMP_modeller)
419 IMP_CORE_HAS_IMP_KERNEL = _IMP_modeller.IMP_CORE_HAS_IMP_KERNEL
421 _IMP_modeller.IMP_CORE_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_modeller)
422 IMP_CORE_HAS_BOOST_FILESYSTEM = _IMP_modeller.IMP_CORE_HAS_BOOST_FILESYSTEM
424 _IMP_modeller.IMP_CORE_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_modeller)
425 IMP_CORE_HAS_BOOST_PROGRAMOPTIONS = _IMP_modeller.IMP_CORE_HAS_BOOST_PROGRAMOPTIONS
427 _IMP_modeller.IMP_CORE_HAS_BOOST_RANDOM_swigconstant(_IMP_modeller)
428 IMP_CORE_HAS_BOOST_RANDOM = _IMP_modeller.IMP_CORE_HAS_BOOST_RANDOM
430 _IMP_modeller.IMP_CORE_HAS_BOOST_SYSTEM_swigconstant(_IMP_modeller)
431 IMP_CORE_HAS_BOOST_SYSTEM = _IMP_modeller.IMP_CORE_HAS_BOOST_SYSTEM
433 _IMP_modeller.IMP_CORE_HAS_CGAL_swigconstant(_IMP_modeller)
434 IMP_CORE_HAS_CGAL = _IMP_modeller.IMP_CORE_HAS_CGAL
436 _IMP_modeller.IMP_CORE_HAS_HDF5_swigconstant(_IMP_modeller)
437 IMP_CORE_HAS_HDF5 = _IMP_modeller.IMP_CORE_HAS_HDF5
439 _IMP_modeller.IMPCORE_SHOW_WARNINGS_swigconstant(_IMP_modeller)
440 IMPCORE_SHOW_WARNINGS = _IMP_modeller.IMPCORE_SHOW_WARNINGS
443 _IMP_modeller.IMP_MODELLER_HAS_IMP_ALGEBRA_swigconstant(_IMP_modeller)
444 IMP_MODELLER_HAS_IMP_ALGEBRA = _IMP_modeller.IMP_MODELLER_HAS_IMP_ALGEBRA
446 _IMP_modeller.IMP_MODELLER_HAS_IMP_CGAL_swigconstant(_IMP_modeller)
447 IMP_MODELLER_HAS_IMP_CGAL = _IMP_modeller.IMP_MODELLER_HAS_IMP_CGAL
449 _IMP_modeller.IMP_MODELLER_HAS_IMP_DISPLAY_swigconstant(_IMP_modeller)
450 IMP_MODELLER_HAS_IMP_DISPLAY = _IMP_modeller.IMP_MODELLER_HAS_IMP_DISPLAY
452 _IMP_modeller.IMP_MODELLER_HAS_IMP_KERNEL_swigconstant(_IMP_modeller)
453 IMP_MODELLER_HAS_IMP_KERNEL = _IMP_modeller.IMP_MODELLER_HAS_IMP_KERNEL
455 _IMP_modeller.IMP_MODELLER_HAS_IMP_SCORE_FUNCTOR_swigconstant(_IMP_modeller)
456 IMP_MODELLER_HAS_IMP_SCORE_FUNCTOR = _IMP_modeller.IMP_MODELLER_HAS_IMP_SCORE_FUNCTOR
458 _IMP_modeller.IMP_MODELLER_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_modeller)
459 IMP_MODELLER_HAS_BOOST_FILESYSTEM = _IMP_modeller.IMP_MODELLER_HAS_BOOST_FILESYSTEM
461 _IMP_modeller.IMP_MODELLER_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_modeller)
462 IMP_MODELLER_HAS_BOOST_PROGRAMOPTIONS = _IMP_modeller.IMP_MODELLER_HAS_BOOST_PROGRAMOPTIONS
464 _IMP_modeller.IMP_MODELLER_HAS_BOOST_RANDOM_swigconstant(_IMP_modeller)
465 IMP_MODELLER_HAS_BOOST_RANDOM = _IMP_modeller.IMP_MODELLER_HAS_BOOST_RANDOM
467 _IMP_modeller.IMP_MODELLER_HAS_BOOST_SYSTEM_swigconstant(_IMP_modeller)
468 IMP_MODELLER_HAS_BOOST_SYSTEM = _IMP_modeller.IMP_MODELLER_HAS_BOOST_SYSTEM
470 _IMP_modeller.IMP_MODELLER_HAS_CGAL_swigconstant(_IMP_modeller)
471 IMP_MODELLER_HAS_CGAL = _IMP_modeller.IMP_MODELLER_HAS_CGAL
473 _IMP_modeller.IMP_MODELLER_HAS_HDF5_swigconstant(_IMP_modeller)
474 IMP_MODELLER_HAS_HDF5 = _IMP_modeller.IMP_MODELLER_HAS_HDF5
476 _IMP_modeller.IMPMODELLER_SHOW_WARNINGS_swigconstant(_IMP_modeller)
477 IMPMODELLER_SHOW_WARNINGS = _IMP_modeller.IMPMODELLER_SHOW_WARNINGS
478 BinormalTermList=list
479 _plural_types.append(
"BinormalTermList")
480 _value_types.append(
"BinormalTerm")
482 _object_types.append(
"MultipleBinormalRestraint")
485 def _object_cast_to_MultipleBinormalRestraint(o):
486 """_object_cast_to_MultipleBinormalRestraint(Object o) -> MultipleBinormalRestraint"""
487 return _IMP_modeller._object_cast_to_MultipleBinormalRestraint(o)
496 import modeller.scripts
497 import modeller.optimizers
499 class _TempDir(object):
500 """Make a temporary directory that is deleted when the object is."""
503 self.tmpdir = tempfile.mkdtemp()
506 shutil.rmtree(self.tmpdir, ignore_errors=
True)
510 """A Modeller restraint which evaluates an IMP scoring function.
511 This can be used to incorporate IMP Restraints into an existing
512 comparative modeling pipeline, or to use Modeller optimizers or
516 _physical_type = modeller.physical.absposition
518 def __init__(self, particles, scoring_function=None):
520 @param particles A list of the IMP atoms (as Particle objects),
521 same order as the Modeller atoms.
522 @param scoring_function An IMP::ScoringFunction object that will
523 be incorporated into the Modeller score (molpdf).
524 @note since Modeller, unlike IMP, is sensitive to the ordering
525 of atoms, it usually makes sense to create the model in
526 Modeller and then use ModelLoader to load it into IMP,
527 since that will preserve the Modeller atom ordering in IMP.
529 modeller.terms.energy_term.__init__(self)
530 self._particles = particles
532 self._sf = scoring_function
534 self._sf = particles[0].get_model()
536 def eval(self, mdl, deriv, indats):
537 atoms = self.indices_to_atoms(mdl, indats)
538 _copy_modeller_coords_to_imp(atoms, self._particles)
539 if len(self._particles) == 0:
542 score = self._sf.evaluate(deriv)
544 dvx = [0.] * len(indats)
545 dvy = [0.] * len(indats)
546 dvz = [0.] * len(indats)
547 _get_imp_derivs(self._particles, dvx, dvy, dvz)
548 return (score, dvx, dvy, dvz)
554 """An IMP restraint using all defined Modeller restraints.
555 This is useful if you want to use Modeller restraints with an IMP
556 optimizer, or in combination with IMP restraints.
558 @note Currently only the coordinates of the atoms are translated
559 between Modeller and IMP; thus, a Modeller restraint which
560 uses any other attribute (e.g. charge) will not react if
561 this attribute is changed by IMP.
564 def __init__(self, model, modeller_model, particles):
566 @param model The IMP Model object.
567 @param modeller_model The Modeller model object.
568 @param particles A list of the IMP atoms (as Particle objects),
569 in the same order as the Modeller atoms.
570 @note since Modeller, unlike IMP, is sensitive to the ordering
571 of atoms, it usually makes sense to create the model in
572 Modeller and then use ModelLoader to load it into IMP,
573 since that will preserve the Modeller atom ordering in IMP.
576 if hasattr(x,
'get_particle'):
577 return x.get_particle()
580 IMP.Restraint.__init__(self, model,
"ModellerRestraints %1%")
581 self._modeller_model = modeller_model
582 self._particles = [get_particle(x)
for x
in particles]
584 def unprotected_evaluate(self, accum):
585 atoms = self._modeller_model.atoms
586 sel = modeller.selection(self._modeller_model)
587 _copy_imp_coords_to_modeller(self._particles, atoms)
588 energies = sel.energy()
590 _add_modeller_derivs_to_imp(atoms, self._particles, accum)
596 def do_show(self, fh):
597 fh.write(
"ModellerRestraints")
599 return self._particles
602 def _copy_imp_coords_to_modeller(particles, atoms):
603 """Copy atom coordinates from IMP to Modeller"""
607 for (num, at)
in enumerate(atoms):
608 at.x = particles[num].get_value(xkey)
609 at.y = particles[num].get_value(ykey)
610 at.z = particles[num].get_value(zkey)
613 def _copy_modeller_coords_to_imp(atoms, particles):
614 """Copy atom coordinates from Modeller to IMP"""
618 for (num, at)
in enumerate(atoms):
619 particles[num].set_value(xkey, at.x)
620 particles[num].set_value(ykey, at.y)
621 particles[num].set_value(zkey, at.z)
624 def _add_modeller_derivs_to_imp(atoms, particles, accum):
625 """Add atom derivatives from Modeller to IMP"""
626 for (num, at)
in enumerate(atoms):
628 xyz.add_to_derivative(0, at.dvx, accum)
629 xyz.add_to_derivative(1, at.dvy, accum)
630 xyz.add_to_derivative(2, at.dvz, accum)
633 def _get_imp_derivs(particles, dvx, dvy, dvz):
634 """Move atom derivatives from IMP to Modeller"""
638 for idx
in range(0, len(dvx)):
639 dvx[idx] = particles[idx].get_derivative(xkey)
640 dvy[idx] = particles[idx].get_derivative(ykey)
641 dvz[idx] = particles[idx].get_derivative(zkey)
645 def _HarmonicLowerBoundGenerator(parameters, modalities):
646 (mean, stdev) = parameters
650 def _HarmonicUpperBoundGenerator(parameters, modalities):
651 (mean, stdev) = parameters
655 def _HarmonicGenerator(parameters, modalities):
656 (mean, stdev) = parameters
660 def _CosineGenerator(parameters, modalities):
661 (phase, force_constant) = parameters
662 (periodicity,) = modalities
665 def _LinearGenerator(parameters, modalities):
666 (scale,) = parameters
669 def _SplineGenerator(parameters, modalities):
670 (open, low, high, delta, lowderiv, highderiv) = parameters[:6]
672 for v
in parameters[6:]:
680 _unary_func_generators = {
681 1: _HarmonicLowerBoundGenerator,
682 2: _HarmonicUpperBoundGenerator,
683 3: _HarmonicGenerator,
686 10: _SplineGenerator,
690 def _DistanceRestraintGenerator(form, modalities, atoms, parameters):
691 unary_func_gen = _unary_func_generators[form]
693 unary_func_gen(parameters, modalities),
696 def _AngleRestraintGenerator(form, modalities, atoms, parameters):
697 unary_func_gen = _unary_func_generators[form]
699 unary_func_gen(parameters, modalities),
700 atoms[0], atoms[1], atoms[2])
702 def _MultiBinormalGenerator(form, modalities, atoms, parameters):
703 nterms = modalities[0]
704 if len(parameters) != nterms * 6:
705 raise ValueError(
"Incorrect number of parameters (%d) for multiple "
706 "binormal restraint - expecting %d (%d terms * 6)" \
707 % (len(parameters), nterms * 6, nterms))
709 atoms[:4], atoms[4:8])
710 for i
in range(nterms):
712 t.set_weight(parameters[i])
713 t.set_means((parameters[nterms + i * 2],
714 parameters[nterms + i * 2 + 1]))
715 t.set_standard_deviations((parameters[nterms * 3 + i * 2],
716 parameters[nterms * 3 + i * 2 + 1]))
717 t.set_correlation(parameters[nterms * 5 + i])
721 def _DihedralRestraintGenerator(form, modalities, atoms, parameters):
723 return _MultiBinormalGenerator(form, modalities, atoms, parameters)
724 unary_func_gen = _unary_func_generators[form]
726 unary_func_gen(parameters, modalities),
727 atoms[0], atoms[1], atoms[2], atoms[3])
729 def _get_protein_atom_particles(protein):
730 """Given a protein particle, get the flattened list of all child atoms"""
732 for ichain
in range(protein.get_number_of_children()):
733 chain = protein.get_child(ichain)
734 for ires
in range(chain.get_number_of_children()):
735 residue = chain.get_child(ires)
736 for iatom
in range(residue.get_number_of_children()):
737 atom = residue.get_child(iatom)
738 atom_particles.append(atom.get_particle())
739 return atom_particles
741 def _load_restraints_line(line, atom_particles):
742 """Parse a single Modeller restraints file line and return the
743 corresponding IMP restraint."""
746 if typ ==
'MODELLER5':
749 raise NotImplementedError(
"Only 'R' lines currently read from " + \
750 "Modeller restraints files")
751 form = int(spl.pop(0))
752 modalities = [int(spl.pop(0))]
753 features = [int(spl.pop(0))]
756 natoms = [int(spl.pop(0))]
757 nparam = int(spl.pop(0))
758 nfeat = int(spl.pop(0))
759 for i
in range(nfeat - 1):
760 modalities.append(int(spl.pop(0)))
761 features.append(int(spl.pop(0)))
762 natoms.append(int(spl.pop(0)))
763 atoms = [int(spl.pop(0))
for x
in range(natoms[0])]
764 for i
in range(len(atoms)):
765 atoms[i] = atom_particles[atoms[i] - 1]
766 parameters = [float(spl.pop(0))
for x
in range(nparam)]
767 restraint_generators = {
768 1 : _DistanceRestraintGenerator,
769 2 : _AngleRestraintGenerator,
770 3 : _DihedralRestraintGenerator,
772 restraint_gen = restraint_generators[features[0]]
773 return restraint_gen(form, modalities, atoms, parameters)
776 def _load_entire_restraints_file(filename, protein):
777 """Yield a set of IMP restraints from a Modeller restraints file."""
778 atoms = _get_protein_atom_particles(protein)
779 fh = open(filename,
'r')
782 rsr = _load_restraints_line(line, atoms)
785 except Exception
as err:
786 print(
"Cannot read restraints file line:\n" + line)
792 """Convert a Modeller restraints file into IMP::Restraint objects.
794 @param filename Name of the Modeller restraints file.
795 @param protein An IMP::atom::Hierarchy containing the protein atoms
796 (e.g. as returned by read_pdb). The Modeller restraints
797 file is assumed to act on the same PDB described by
799 @return A Python list of the newly-created IMP::Restraint objects.
801 return list(_load_entire_restraints_file(filename, protein))
804 def _copy_residue(r, model):
805 """Copy residue information from modeller to imp"""
810 p.set_name(str(
"residue "+r.num));
814 def _copy_atom(a, model):
815 """Copy atom information from modeller"""
821 if hasattr(a,
'charge'):
823 if hasattr(a,
'type'):
825 ap.set_input_index(a.index)
828 def _copy_chain(c, model):
829 """Copy chain information from modeller"""
836 def _get_forcefield(submodel):
848 """Add radii to the hierarchy using the Modeller radius library, radii.lib.
849 Each radius is scaled by the given scale (Modeller usually scales radii
850 by a factor of 0.82). submodel specifies the topology submodel, which is
851 the column in radii.lib to use."""
855 for line
in open(filename):
856 if line.startswith(
'#'):
continue
859 radii[spl[0]] = float(spl[submodel])
869 """Read a Modeller model into IMP. After creating this object, the atoms
870 in the Modeller model can be loaded into IMP using the load_atoms()
871 method, then optionally any Modeller static restraints can be read in
872 with load_static_restraints() or load_static_restraints_file().
874 This class can also be used to read Modeller alignment structures;
875 however, only load_atoms() will be useful in such a case (since
876 alignment structures don't have restraints or other information).
882 @param modeller_model The Modeller model or alignment structure
885 self._modeller_model = modeller_model
888 """Construct an IMP::atom::Hierarchy that contains the same atoms as
889 the Modeller model or alignment structure.
891 IMP atoms created from a Modeller model will be given charges and
892 CHARMM types, extracted from the model. Alignment structures don't
893 contain this information, so the IMP atoms won't either.
895 @param model The IMP::Model object in which the hierarchy will be
896 created. The highest level hierarchy node is a PROTEIN.
897 @return the newly-created root IMP::atom::Hierarchy.
902 for chain
in self._modeller_model.chains:
907 for residue
in chain.residues:
908 rp = _copy_residue(residue, model)
911 for atom
in residue.atoms:
912 ap = _copy_atom(atom, model)
915 self._atoms[atom.index] = ap
917 self._modeller_hierarchy = hpp
920 def _get_nonbonded_list(self, atoms, pair_filter, edat, distance):
925 if pair_filter
is None:
927 if edat.excl_local[0]:
928 pair_filter.set_bonds(list(self.
load_bonds()))
929 if edat.excl_local[1]:
931 if edat.excl_local[2]:
933 nbl.add_pair_filter(pair_filter)
937 """Load the Modeller bond topology into the IMP model. Each bond is
938 represented in IMP as an IMP::atom::Bond, with no defined length
939 or stiffness. These bonds are primarily useful as input to
940 IMP::atom::StereochemistryPairFilter, to exclude bond interactions
941 from the nonbonded list. Typically the contribution to the scoring
942 function from the bonds is included in the Modeller static restraints
943 (use load_static_restraints() or load_static_restraints_file() to
944 load these). If you want to regenerate the stereochemistry in IMP,
945 do not use these functions (as then stereochemistry scoring terms
946 and exclusions would be double-counted) and instead use the
947 IMP::atom::CHARMMTopology class.
949 You must call load_atoms() prior to using this function.
950 @see load_angles(), load_dihedrals(), load_impropers()
951 @return A generator listing all of the bonds.
953 if not hasattr(self,
'_modeller_hierarchy'):
954 raise ValueError(
"Call load_atoms() first.")
955 for (maa, mab)
in self._modeller_model.bonds:
956 pa = self._atoms[maa.index]
957 pb = self._atoms[mab.index]
967 IMP.atom.Bond.SINGLE).get_particle()
970 """Load the Modeller angle topology into the IMP model.
971 See load_bonds() for more details."""
972 return self._internal_load_angles(self._modeller_model.angles,
976 """Load the Modeller dihedral topology into the IMP model.
977 See load_bonds() for more details."""
978 return self._internal_load_angles(self._modeller_model.dihedrals,
982 """Load the Modeller improper topology into the IMP model.
983 See load_bonds() for more details."""
984 return self._internal_load_angles(self._modeller_model.impropers,
987 def _internal_load_angles(self, angles, angle_class):
988 if not hasattr(self,
'_modeller_hierarchy'):
989 raise ValueError(
"Call load_atoms() first.")
990 for modeller_atoms
in angles:
991 imp_particles = [self._atoms[x.index]
for x
in modeller_atoms]
993 a = angle_class.setup_particle(p,
995 yield a.get_particle()
998 """Convert a Modeller static restraints file into equivalent
999 IMP::Restraints. load_atoms() must have been called first to read
1000 in the atoms that the restraints will act upon.
1001 @param filename Name of the Modeller restraints file. The restraints
1002 in this file are assumed to act upon the model read in by
1003 load_atoms(); no checking is done to enforce this.
1004 @return A Python generator of the newly-created IMP::Restraint
1007 if not hasattr(self,
'_modeller_hierarchy'):
1008 raise ValueError(
"Call load_atoms() first.")
1009 return _load_entire_restraints_file(filename, self._modeller_hierarchy)
1013 """Convert the current set of Modeller static restraints into equivalent
1014 IMP::Restraints. load_atoms() must have been called first to read
1015 in the atoms that the restraints will act upon.
1016 @return A Python generator of the newly-created IMP::Restraint
1019 class _RestraintGenerator(object):
1020 """Simple generator wrapper"""
1023 def __iter__(self, *args, **keys):
1025 def close(self, *args, **keys):
1026 return self._gen.close(*args, **keys)
1028 return next(self._gen)
1030 def send(self, *args, **keys):
1031 return self._gen.send(*args, **keys)
1032 def throw(self, *args, **keys):
1033 return self._gen.throw(*args, **keys)
1036 rsrfile = os.path.join(t.tmpdir,
'restraints.rsr')
1037 self._modeller_model.restraints.write(file=rsrfile)
1040 wrap = _RestraintGenerator(gen)
1046 """Convert Modeller dynamic restraints into IMP::Restraint objects.
1048 For each currently active Modeller dynamic restraint
1049 (e.g. soft-sphere, electrostatics) an equivalent IMP::Restraint
1051 load_atoms() must have been called first to read
1052 in the atoms that the restraints will act upon.
1054 If pair_filter is given, it is an IMP::PairFilter object to exclude
1055 pairs from the nonbonded lists used by the dynamic restraints.
1056 Otherwise, an IMP::atom::StereochemistryPairFilter object is created
1057 to exclude Modeller bonds, angles and dihedrals, as specified by
1058 edat.excl_local. (Note that this calls load_bonds(), load_angles()
1059 and load_dihedrals(), so will create duplicate lists of bonds if
1060 those methods are called manually as well.)
1062 @note Currently only soft-sphere, electrostatic and Lennard-Jones
1063 restraints are loaded.
1064 @return A Python generator of the newly-created IMP::Restraint
1067 if not hasattr(self,
'_modeller_hierarchy'):
1068 raise ValueError(
"Call load_atoms() first.")
1069 edat = self._modeller_model.env.edat
1070 libs = self._modeller_model.env.libs
1072 m = atoms[0].get_model()
1075 if edat.dynamic_sphere:
1078 nbl = self._get_nonbonded_list(atoms, pair_filter, edat, 0.)
1081 libs.topology.submodel, edat.radii_factor)
1088 if edat.dynamic_lennard
or edat.dynamic_coulomb:
1090 d = max(edat.contact_shell - 3.0, 0.0)
1091 nbl = self._get_nonbonded_list(atoms, pair_filter, edat, d)
1092 ff = _get_forcefield(libs.topology.submodel)
1093 ff.add_radii(self._modeller_hierarchy)
1095 if edat.dynamic_lennard:
1096 ff.add_well_depths(self._modeller_hierarchy)
1098 edat.lennard_jones_switch[1])
1102 if edat.dynamic_coulomb:
1104 edat.coulomb_switch[1])
1106 ps.set_relative_dielectric(edat.relative_dielectric)
1111 "a PDB file, or ModelLoader to read a Modeller model.")
1112 def read_pdb(name, model, special_patches=None):
1113 """Construct an IMP::atom::Hierarchy from a PDB file.
1115 @param name The name of the PDB file to read.
1116 @param model The IMP::Model object in which the hierarchy will be
1117 created. The highest level hierarchy node is a PROTEIN.
1118 @param special_patches If given, a function that applies patches
1119 (e.g. nucleic acid termini) to the Modeller model.
1120 @return the newly-created root IMP::atom::Hierarchy.
1122 e = modeller.environ()
1123 e.libs.topology.read(
'${LIB}/top_heav.lib')
1124 e.libs.parameters.read(
'${LIB}/par.lib')
1126 modeller_model = modeller.scripts.complete_pdb(e, name,
1127 special_patches=special_patches)
1129 hpp = loader.load_atoms(model)
1130 hpp.get_particle().set_name(name)
1135 """Proxy of C++ IMP::modeller::MultipleBinormalRestraint class"""
1136 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
1138 def __init__(self, *args):
1140 __init__(IMP::modeller::MultipleBinormalRestraint self, Model m, IMP::ParticleIndexQuad const & q1, IMP::ParticleIndexQuad const & q2) -> MultipleBinormalRestraint
1141 __init__(IMP::modeller::MultipleBinormalRestraint self, IMP::ParticleQuad const & q1, IMP::ParticleQuad const & q2) -> MultipleBinormalRestraint
1143 this = _IMP_modeller.new_MultipleBinormalRestraint(*args)
1145 self.this.append(this)
1149 def add_term(self, term):
1150 """add_term(MultipleBinormalRestraint self, BinormalTerm term)"""
1151 return _IMP_modeller.MultipleBinormalRestraint_add_term(self, term)
1154 def do_get_inputs(self):
1155 """do_get_inputs(MultipleBinormalRestraint self) -> IMP::ModelObjectsTemp"""
1156 return _IMP_modeller.MultipleBinormalRestraint_do_get_inputs(self)
1159 def get_version_info(self):
1160 """get_version_info(MultipleBinormalRestraint self) -> VersionInfo"""
1161 return _IMP_modeller.MultipleBinormalRestraint_get_version_info(self)
1165 """__str__(MultipleBinormalRestraint self) -> std::string"""
1166 return _IMP_modeller.MultipleBinormalRestraint___str__(self)
1170 """__repr__(MultipleBinormalRestraint self) -> std::string"""
1171 return _IMP_modeller.MultipleBinormalRestraint___repr__(self)
1174 return _object_cast_to_MultipleBinormalRestraint(o)
1175 get_from = staticmethod(get_from)
1177 MultipleBinormalRestraint_swigregister = _IMP_modeller.MultipleBinormalRestraint_swigregister
1178 MultipleBinormalRestraint_swigregister(MultipleBinormalRestraint)
1181 """Proxy of C++ IMP::modeller::BinormalTerm class"""
1182 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
1185 """__init__(IMP::modeller::BinormalTerm self) -> BinormalTerm"""
1186 this = _IMP_modeller.new_BinormalTerm()
1188 self.this.append(this)
1192 def set_correlation(self, correlation):
1193 """set_correlation(BinormalTerm self, double correlation)"""
1194 return _IMP_modeller.BinormalTerm_set_correlation(self, correlation)
1197 def set_weight(self, weight):
1198 """set_weight(BinormalTerm self, double weight)"""
1199 return _IMP_modeller.BinormalTerm_set_weight(self, weight)
1202 def set_means(self, means):
1203 """set_means(BinormalTerm self, IMP::FloatPair means)"""
1204 return _IMP_modeller.BinormalTerm_set_means(self, means)
1207 def set_standard_deviations(self, stdevs):
1208 """set_standard_deviations(BinormalTerm self, IMP::FloatPair stdevs)"""
1209 return _IMP_modeller.BinormalTerm_set_standard_deviations(self, stdevs)
1212 def show(self, *args):
1214 show(BinormalTerm self, _ostream out)
1215 show(BinormalTerm self)
1217 return _IMP_modeller.BinormalTerm_show(self, *args)
1221 """__str__(BinormalTerm self) -> std::string"""
1222 return _IMP_modeller.BinormalTerm___str__(self)
1226 """__repr__(BinormalTerm self) -> std::string"""
1227 return _IMP_modeller.BinormalTerm___repr__(self)
1229 __swig_destroy__ = _IMP_modeller.delete_BinormalTerm
1230 __del__ =
lambda self:
None
1231 BinormalTerm_swigregister = _IMP_modeller.BinormalTerm_swigregister
1232 BinormalTerm_swigregister(BinormalTerm)
1235 def get_module_version():
1236 """get_module_version() -> std::string const"""
1237 return _IMP_modeller.get_module_version()
1240 """get_example_path(std::string fname) -> std::string"""
1241 return _IMP_modeller.get_example_path(fname)
1244 """get_data_path(std::string fname) -> std::string"""
1245 return _IMP_modeller.get_data_path(fname)
1246 from .
import _version_check
1247 _version_check.check_version(get_module_version())
1248 __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.
def read_pdb
Construct an IMP::atom::Hierarchy from a PDB file.
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.
def deprecated_function
Python decorator to mark a function as deprecated.
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.
Hierarchies get_by_type(Hierarchy mhd, GetByType t)
Gather all the molecular particles of a certain level in the hierarchy.
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 load_restraints_file
Convert a Modeller restraints file into IMP::Restraint objects.
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.
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)
void show(Hierarchy h, std::ostream &out=std::cout)
Print out a molecular hierarchy.
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)