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)
223 _IMP_modeller.IMP_DEBUG_swigconstant(_IMP_modeller)
224 IMP_DEBUG = _IMP_modeller.IMP_DEBUG
226 _IMP_modeller.IMP_RELEASE_swigconstant(_IMP_modeller)
227 IMP_RELEASE = _IMP_modeller.IMP_RELEASE
229 _IMP_modeller.IMP_SILENT_swigconstant(_IMP_modeller)
230 IMP_SILENT = _IMP_modeller.IMP_SILENT
232 _IMP_modeller.IMP_PROGRESS_swigconstant(_IMP_modeller)
233 IMP_PROGRESS = _IMP_modeller.IMP_PROGRESS
235 _IMP_modeller.IMP_TERSE_swigconstant(_IMP_modeller)
236 IMP_TERSE = _IMP_modeller.IMP_TERSE
238 _IMP_modeller.IMP_VERBOSE_swigconstant(_IMP_modeller)
239 IMP_VERBOSE = _IMP_modeller.IMP_VERBOSE
241 _IMP_modeller.IMP_MEMORY_swigconstant(_IMP_modeller)
242 IMP_MEMORY = _IMP_modeller.IMP_MEMORY
244 _IMP_modeller.IMP_NONE_swigconstant(_IMP_modeller)
245 IMP_NONE = _IMP_modeller.IMP_NONE
247 _IMP_modeller.IMP_USAGE_swigconstant(_IMP_modeller)
248 IMP_USAGE = _IMP_modeller.IMP_USAGE
250 _IMP_modeller.IMP_INTERNAL_swigconstant(_IMP_modeller)
251 IMP_INTERNAL = _IMP_modeller.IMP_INTERNAL
253 _IMP_modeller.IMP_KERNEL_HAS_LOG4CXX_swigconstant(_IMP_modeller)
254 IMP_KERNEL_HAS_LOG4CXX = _IMP_modeller.IMP_KERNEL_HAS_LOG4CXX
256 _IMP_modeller.IMP_COMPILER_HAS_AUTO_swigconstant(_IMP_modeller)
257 IMP_COMPILER_HAS_AUTO = _IMP_modeller.IMP_COMPILER_HAS_AUTO
259 _IMP_modeller.IMP_COMPILER_HAS_DEBUG_VECTOR_swigconstant(_IMP_modeller)
260 IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_modeller.IMP_COMPILER_HAS_DEBUG_VECTOR
262 _IMP_modeller.IMP_COMPILER_HAS_UNIQUE_PTR_swigconstant(_IMP_modeller)
263 IMP_COMPILER_HAS_UNIQUE_PTR = _IMP_modeller.IMP_COMPILER_HAS_UNIQUE_PTR
265 _IMP_modeller.IMP_KERNEL_HAS_BOOST_RANDOM_swigconstant(_IMP_modeller)
266 IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_modeller.IMP_KERNEL_HAS_BOOST_RANDOM
268 _IMP_modeller.IMP_KERNEL_HAS_GPERFTOOLS_swigconstant(_IMP_modeller)
269 IMP_KERNEL_HAS_GPERFTOOLS = _IMP_modeller.IMP_KERNEL_HAS_GPERFTOOLS
271 _IMP_modeller.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER_swigconstant(_IMP_modeller)
272 IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER = _IMP_modeller.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER
274 _IMP_modeller.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER_swigconstant(_IMP_modeller)
275 IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER = _IMP_modeller.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER
277 _IMP_modeller.IMPKERNEL_SHOW_WARNINGS_swigconstant(_IMP_modeller)
278 IMPKERNEL_SHOW_WARNINGS = _IMP_modeller.IMPKERNEL_SHOW_WARNINGS
281 class _DirectorObjects(object):
282 """@internal Simple class to keep references to director objects
283 to prevent premature deletion."""
286 def register(self, obj):
287 """Take a reference to a director object; will only work for
288 refcounted C++ classes"""
289 if hasattr(obj,
'get_ref_count'):
290 self._objects.append(obj)
292 """Only drop our reference and allow cleanup by Python if no other
293 Python references exist (we hold 3 references: one in self._objects,
294 one in x, and one in the argument list for getrefcount) *and* no
295 other C++ references exist (the Python object always holds one)"""
296 objs = [x
for x
in self._objects
if sys.getrefcount(x) > 3 \
297 or x.get_ref_count() > 1]
301 def get_object_count(self):
302 """Get number of director objects (useful for testing only)"""
303 return len(self._objects)
304 _director_objects = _DirectorObjects()
306 class _ostream(object):
307 """Proxy of C++ std::ostream class"""
308 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
310 def __init__(self, *args, **kwargs):
311 raise AttributeError(
"No constructor defined")
312 __repr__ = _swig_repr
314 def write(self, osa_buf):
315 """write(_ostream self, char const * osa_buf)"""
316 return _IMP_modeller._ostream_write(self, osa_buf)
318 _ostream_swigregister = _IMP_modeller._ostream_swigregister
319 _ostream_swigregister(_ostream)
322 _IMP_modeller.IMP_COMPILER_HAS_OVERRIDE_swigconstant(_IMP_modeller)
323 IMP_COMPILER_HAS_OVERRIDE = _IMP_modeller.IMP_COMPILER_HAS_OVERRIDE
325 _IMP_modeller.IMP_COMPILER_HAS_FINAL_swigconstant(_IMP_modeller)
326 IMP_COMPILER_HAS_FINAL = _IMP_modeller.IMP_COMPILER_HAS_FINAL
328 _IMP_modeller.IMP_HAS_NOEXCEPT_swigconstant(_IMP_modeller)
329 IMP_HAS_NOEXCEPT = _IMP_modeller.IMP_HAS_NOEXCEPT
332 _IMP_modeller.IMP_CGAL_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_modeller)
333 IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_modeller.IMP_CGAL_HAS_BOOST_FILESYSTEM
335 _IMP_modeller.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_modeller)
336 IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_modeller.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS
338 _IMP_modeller.IMP_CGAL_HAS_BOOST_RANDOM_swigconstant(_IMP_modeller)
339 IMP_CGAL_HAS_BOOST_RANDOM = _IMP_modeller.IMP_CGAL_HAS_BOOST_RANDOM
341 _IMP_modeller.IMP_CGAL_HAS_BOOST_SYSTEM_swigconstant(_IMP_modeller)
342 IMP_CGAL_HAS_BOOST_SYSTEM = _IMP_modeller.IMP_CGAL_HAS_BOOST_SYSTEM
344 _IMP_modeller.IMPCGAL_SHOW_WARNINGS_swigconstant(_IMP_modeller)
345 IMPCGAL_SHOW_WARNINGS = _IMP_modeller.IMPCGAL_SHOW_WARNINGS
348 _IMP_modeller.IMP_ALGEBRA_HAS_IMP_CGAL_swigconstant(_IMP_modeller)
349 IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_modeller.IMP_ALGEBRA_HAS_IMP_CGAL
351 _IMP_modeller.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_modeller)
352 IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_modeller.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM
354 _IMP_modeller.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_modeller)
355 IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_modeller.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS
357 _IMP_modeller.IMP_ALGEBRA_HAS_BOOST_RANDOM_swigconstant(_IMP_modeller)
358 IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_modeller.IMP_ALGEBRA_HAS_BOOST_RANDOM
360 _IMP_modeller.IMP_ALGEBRA_HAS_BOOST_SYSTEM_swigconstant(_IMP_modeller)
361 IMP_ALGEBRA_HAS_BOOST_SYSTEM = _IMP_modeller.IMP_ALGEBRA_HAS_BOOST_SYSTEM
363 _IMP_modeller.IMP_ALGEBRA_HAS_CGAL_swigconstant(_IMP_modeller)
364 IMP_ALGEBRA_HAS_CGAL = _IMP_modeller.IMP_ALGEBRA_HAS_CGAL
366 _IMP_modeller.IMP_ALGEBRA_HAS_ANN_swigconstant(_IMP_modeller)
367 IMP_ALGEBRA_HAS_ANN = _IMP_modeller.IMP_ALGEBRA_HAS_ANN
369 _IMP_modeller.IMPALGEBRA_SHOW_WARNINGS_swigconstant(_IMP_modeller)
370 IMPALGEBRA_SHOW_WARNINGS = _IMP_modeller.IMPALGEBRA_SHOW_WARNINGS
373 _IMP_modeller.IMP_DISPLAY_HAS_IMP_CGAL_swigconstant(_IMP_modeller)
374 IMP_DISPLAY_HAS_IMP_CGAL = _IMP_modeller.IMP_DISPLAY_HAS_IMP_CGAL
376 _IMP_modeller.IMP_DISPLAY_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_modeller)
377 IMP_DISPLAY_HAS_BOOST_FILESYSTEM = _IMP_modeller.IMP_DISPLAY_HAS_BOOST_FILESYSTEM
379 _IMP_modeller.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_modeller)
380 IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS = _IMP_modeller.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS
382 _IMP_modeller.IMP_DISPLAY_HAS_BOOST_RANDOM_swigconstant(_IMP_modeller)
383 IMP_DISPLAY_HAS_BOOST_RANDOM = _IMP_modeller.IMP_DISPLAY_HAS_BOOST_RANDOM
385 _IMP_modeller.IMP_DISPLAY_HAS_BOOST_SYSTEM_swigconstant(_IMP_modeller)
386 IMP_DISPLAY_HAS_BOOST_SYSTEM = _IMP_modeller.IMP_DISPLAY_HAS_BOOST_SYSTEM
388 _IMP_modeller.IMP_DISPLAY_HAS_CGAL_swigconstant(_IMP_modeller)
389 IMP_DISPLAY_HAS_CGAL = _IMP_modeller.IMP_DISPLAY_HAS_CGAL
391 _IMP_modeller.IMPDISPLAY_SHOW_WARNINGS_swigconstant(_IMP_modeller)
392 IMPDISPLAY_SHOW_WARNINGS = _IMP_modeller.IMPDISPLAY_SHOW_WARNINGS
395 _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_IMP_CGAL_swigconstant(_IMP_modeller)
396 IMP_SCORE_FUNCTOR_HAS_IMP_CGAL = _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_IMP_CGAL
398 _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_modeller)
399 IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM = _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM
401 _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_modeller)
402 IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS = _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS
404 _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM_swigconstant(_IMP_modeller)
405 IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM = _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM
407 _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM_swigconstant(_IMP_modeller)
408 IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM = _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM
410 _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_CGAL_swigconstant(_IMP_modeller)
411 IMP_SCORE_FUNCTOR_HAS_CGAL = _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_CGAL
413 _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_HDF5_swigconstant(_IMP_modeller)
414 IMP_SCORE_FUNCTOR_HAS_HDF5 = _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_HDF5
416 _IMP_modeller.IMPSCOREFUNCTOR_SHOW_WARNINGS_swigconstant(_IMP_modeller)
417 IMPSCOREFUNCTOR_SHOW_WARNINGS = _IMP_modeller.IMPSCOREFUNCTOR_SHOW_WARNINGS
420 _IMP_modeller.IMP_CORE_HAS_IMP_CGAL_swigconstant(_IMP_modeller)
421 IMP_CORE_HAS_IMP_CGAL = _IMP_modeller.IMP_CORE_HAS_IMP_CGAL
423 _IMP_modeller.IMP_CORE_HAS_IMP_KERNEL_swigconstant(_IMP_modeller)
424 IMP_CORE_HAS_IMP_KERNEL = _IMP_modeller.IMP_CORE_HAS_IMP_KERNEL
426 _IMP_modeller.IMP_CORE_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_modeller)
427 IMP_CORE_HAS_BOOST_FILESYSTEM = _IMP_modeller.IMP_CORE_HAS_BOOST_FILESYSTEM
429 _IMP_modeller.IMP_CORE_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_modeller)
430 IMP_CORE_HAS_BOOST_PROGRAMOPTIONS = _IMP_modeller.IMP_CORE_HAS_BOOST_PROGRAMOPTIONS
432 _IMP_modeller.IMP_CORE_HAS_BOOST_RANDOM_swigconstant(_IMP_modeller)
433 IMP_CORE_HAS_BOOST_RANDOM = _IMP_modeller.IMP_CORE_HAS_BOOST_RANDOM
435 _IMP_modeller.IMP_CORE_HAS_BOOST_SYSTEM_swigconstant(_IMP_modeller)
436 IMP_CORE_HAS_BOOST_SYSTEM = _IMP_modeller.IMP_CORE_HAS_BOOST_SYSTEM
438 _IMP_modeller.IMP_CORE_HAS_CGAL_swigconstant(_IMP_modeller)
439 IMP_CORE_HAS_CGAL = _IMP_modeller.IMP_CORE_HAS_CGAL
441 _IMP_modeller.IMP_CORE_HAS_HDF5_swigconstant(_IMP_modeller)
442 IMP_CORE_HAS_HDF5 = _IMP_modeller.IMP_CORE_HAS_HDF5
444 _IMP_modeller.IMPCORE_SHOW_WARNINGS_swigconstant(_IMP_modeller)
445 IMPCORE_SHOW_WARNINGS = _IMP_modeller.IMPCORE_SHOW_WARNINGS
448 _IMP_modeller.IMP_MODELLER_HAS_IMP_ALGEBRA_swigconstant(_IMP_modeller)
449 IMP_MODELLER_HAS_IMP_ALGEBRA = _IMP_modeller.IMP_MODELLER_HAS_IMP_ALGEBRA
451 _IMP_modeller.IMP_MODELLER_HAS_IMP_CGAL_swigconstant(_IMP_modeller)
452 IMP_MODELLER_HAS_IMP_CGAL = _IMP_modeller.IMP_MODELLER_HAS_IMP_CGAL
454 _IMP_modeller.IMP_MODELLER_HAS_IMP_DISPLAY_swigconstant(_IMP_modeller)
455 IMP_MODELLER_HAS_IMP_DISPLAY = _IMP_modeller.IMP_MODELLER_HAS_IMP_DISPLAY
457 _IMP_modeller.IMP_MODELLER_HAS_IMP_KERNEL_swigconstant(_IMP_modeller)
458 IMP_MODELLER_HAS_IMP_KERNEL = _IMP_modeller.IMP_MODELLER_HAS_IMP_KERNEL
460 _IMP_modeller.IMP_MODELLER_HAS_IMP_SCORE_FUNCTOR_swigconstant(_IMP_modeller)
461 IMP_MODELLER_HAS_IMP_SCORE_FUNCTOR = _IMP_modeller.IMP_MODELLER_HAS_IMP_SCORE_FUNCTOR
463 _IMP_modeller.IMP_MODELLER_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_modeller)
464 IMP_MODELLER_HAS_BOOST_FILESYSTEM = _IMP_modeller.IMP_MODELLER_HAS_BOOST_FILESYSTEM
466 _IMP_modeller.IMP_MODELLER_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_modeller)
467 IMP_MODELLER_HAS_BOOST_PROGRAMOPTIONS = _IMP_modeller.IMP_MODELLER_HAS_BOOST_PROGRAMOPTIONS
469 _IMP_modeller.IMP_MODELLER_HAS_BOOST_RANDOM_swigconstant(_IMP_modeller)
470 IMP_MODELLER_HAS_BOOST_RANDOM = _IMP_modeller.IMP_MODELLER_HAS_BOOST_RANDOM
472 _IMP_modeller.IMP_MODELLER_HAS_BOOST_SYSTEM_swigconstant(_IMP_modeller)
473 IMP_MODELLER_HAS_BOOST_SYSTEM = _IMP_modeller.IMP_MODELLER_HAS_BOOST_SYSTEM
475 _IMP_modeller.IMP_MODELLER_HAS_CGAL_swigconstant(_IMP_modeller)
476 IMP_MODELLER_HAS_CGAL = _IMP_modeller.IMP_MODELLER_HAS_CGAL
478 _IMP_modeller.IMP_MODELLER_HAS_HDF5_swigconstant(_IMP_modeller)
479 IMP_MODELLER_HAS_HDF5 = _IMP_modeller.IMP_MODELLER_HAS_HDF5
481 _IMP_modeller.IMPMODELLER_SHOW_WARNINGS_swigconstant(_IMP_modeller)
482 IMPMODELLER_SHOW_WARNINGS = _IMP_modeller.IMPMODELLER_SHOW_WARNINGS
484 BinormalTermList=list
485 _plural_types.append(
"BinormalTermList")
486 _value_types.append(
"BinormalTerm")
489 _object_types.append(
"MultipleBinormalRestraint")
492 def _object_cast_to_MultipleBinormalRestraint(o):
493 """_object_cast_to_MultipleBinormalRestraint(Object o) -> MultipleBinormalRestraint"""
494 return _IMP_modeller._object_cast_to_MultipleBinormalRestraint(o)
505 import modeller.scripts
506 import modeller.optimizers
508 class _TempDir(object):
509 """Make a temporary directory that is deleted when the object is."""
512 self.tmpdir = tempfile.mkdtemp()
515 shutil.rmtree(self.tmpdir, ignore_errors=
True)
519 """A Modeller restraint which evaluates an IMP scoring function.
520 This can be used to incorporate IMP Restraints into an existing
521 comparative modeling pipeline, or to use Modeller optimizers or
525 _physical_type = modeller.physical.absposition
527 def __init__(self, particles, scoring_function=None):
529 @param particles A list of the IMP atoms (as Particle objects),
530 same order as the Modeller atoms.
531 @param scoring_function An IMP::ScoringFunction object that will
532 be incorporated into the Modeller score (molpdf).
533 @note since Modeller, unlike IMP, is sensitive to the ordering
534 of atoms, it usually makes sense to create the model in
535 Modeller and then use ModelLoader to load it into IMP,
536 since that will preserve the Modeller atom ordering in IMP.
538 modeller.terms.energy_term.__init__(self)
539 self._particles = particles
541 self._sf = scoring_function
543 self._sf = particles[0].get_model()
545 def eval(self, mdl, deriv, indats):
546 atoms = self.indices_to_atoms(mdl, indats)
547 _copy_modeller_coords_to_imp(atoms, self._particles)
548 if len(self._particles) == 0:
551 score = self._sf.evaluate(deriv)
553 dvx = [0.] * len(indats)
554 dvy = [0.] * len(indats)
555 dvz = [0.] * len(indats)
556 _get_imp_derivs(self._particles, dvx, dvy, dvz)
557 return (score, dvx, dvy, dvz)
563 """An IMP restraint using all defined Modeller restraints.
564 This is useful if you want to use Modeller restraints with an IMP
565 optimizer, or in combination with IMP restraints.
567 @note Currently only the coordinates of the atoms are translated
568 between Modeller and IMP; thus, a Modeller restraint which
569 uses any other attribute (e.g. charge) will not react if
570 this attribute is changed by IMP.
573 def __init__(self, model, modeller_model, particles):
575 @param model The IMP Model object.
576 @param modeller_model The Modeller model object.
577 @param particles A list of the IMP atoms (as Particle objects),
578 in the same order as the Modeller atoms.
579 @note since Modeller, unlike IMP, is sensitive to the ordering
580 of atoms, it usually makes sense to create the model in
581 Modeller and then use ModelLoader to load it into IMP,
582 since that will preserve the Modeller atom ordering in IMP.
585 if hasattr(x,
'get_particle'):
586 return x.get_particle()
589 IMP.Restraint.__init__(self, model,
"ModellerRestraints %1%")
590 self._modeller_model = modeller_model
591 self._particles = [get_particle(x)
for x
in particles]
593 def unprotected_evaluate(self, accum):
594 atoms = self._modeller_model.atoms
595 sel = modeller.selection(self._modeller_model)
596 _copy_imp_coords_to_modeller(self._particles, atoms)
597 energies = sel.energy()
599 _add_modeller_derivs_to_imp(atoms, self._particles, accum)
605 def do_show(self, fh):
606 fh.write(
"ModellerRestraints")
608 return self._particles
611 def _copy_imp_coords_to_modeller(particles, atoms):
612 """Copy atom coordinates from IMP to Modeller"""
616 for (num, at)
in enumerate(atoms):
617 at.x = particles[num].get_value(xkey)
618 at.y = particles[num].get_value(ykey)
619 at.z = particles[num].get_value(zkey)
622 def _copy_modeller_coords_to_imp(atoms, particles):
623 """Copy atom coordinates from Modeller to IMP"""
627 for (num, at)
in enumerate(atoms):
628 particles[num].set_value(xkey, at.x)
629 particles[num].set_value(ykey, at.y)
630 particles[num].set_value(zkey, at.z)
633 def _add_modeller_derivs_to_imp(atoms, particles, accum):
634 """Add atom derivatives from Modeller to IMP"""
635 for (num, at)
in enumerate(atoms):
637 xyz.add_to_derivative(0, at.dvx, accum)
638 xyz.add_to_derivative(1, at.dvy, accum)
639 xyz.add_to_derivative(2, at.dvz, accum)
642 def _get_imp_derivs(particles, dvx, dvy, dvz):
643 """Move atom derivatives from IMP to Modeller"""
647 for idx
in range(0, len(dvx)):
648 dvx[idx] = particles[idx].get_derivative(xkey)
649 dvy[idx] = particles[idx].get_derivative(ykey)
650 dvz[idx] = particles[idx].get_derivative(zkey)
654 def _HarmonicLowerBoundGenerator(parameters, modalities):
655 (mean, stdev) = parameters
659 def _HarmonicUpperBoundGenerator(parameters, modalities):
660 (mean, stdev) = parameters
664 def _HarmonicGenerator(parameters, modalities):
665 (mean, stdev) = parameters
669 def _CosineGenerator(parameters, modalities):
670 (phase, force_constant) = parameters
671 (periodicity,) = modalities
674 def _LinearGenerator(parameters, modalities):
675 (scale,) = parameters
678 def _SplineGenerator(parameters, modalities):
679 (open, low, high, delta, lowderiv, highderiv) = parameters[:6]
681 for v
in parameters[6:]:
689 _unary_func_generators = {
690 1: _HarmonicLowerBoundGenerator,
691 2: _HarmonicUpperBoundGenerator,
692 3: _HarmonicGenerator,
695 10: _SplineGenerator,
699 def _DistanceRestraintGenerator(form, modalities, atoms, parameters):
700 unary_func_gen = _unary_func_generators[form]
702 unary_func_gen(parameters, modalities),
705 def _AngleRestraintGenerator(form, modalities, atoms, parameters):
706 unary_func_gen = _unary_func_generators[form]
708 unary_func_gen(parameters, modalities),
709 atoms[0], atoms[1], atoms[2])
711 def _MultiBinormalGenerator(form, modalities, atoms, parameters):
712 nterms = modalities[0]
713 if len(parameters) != nterms * 6:
714 raise ValueError(
"Incorrect number of parameters (%d) for multiple "
715 "binormal restraint - expecting %d (%d terms * 6)" \
716 % (len(parameters), nterms * 6, nterms))
718 atoms[:4], atoms[4:8])
719 for i
in range(nterms):
721 t.set_weight(parameters[i])
722 t.set_means((parameters[nterms + i * 2],
723 parameters[nterms + i * 2 + 1]))
724 t.set_standard_deviations((parameters[nterms * 3 + i * 2],
725 parameters[nterms * 3 + i * 2 + 1]))
726 t.set_correlation(parameters[nterms * 5 + i])
730 def _DihedralRestraintGenerator(form, modalities, atoms, parameters):
732 return _MultiBinormalGenerator(form, modalities, atoms, parameters)
733 unary_func_gen = _unary_func_generators[form]
735 unary_func_gen(parameters, modalities),
736 atoms[0], atoms[1], atoms[2], atoms[3])
738 def _get_protein_atom_particles(protein):
739 """Given a protein particle, get the flattened list of all child atoms"""
741 for ichain
in range(protein.get_number_of_children()):
742 chain = protein.get_child(ichain)
743 for ires
in range(chain.get_number_of_children()):
744 residue = chain.get_child(ires)
745 for iatom
in range(residue.get_number_of_children()):
746 atom = residue.get_child(iatom)
747 atom_particles.append(atom.get_particle())
748 return atom_particles
750 def _load_restraints_line(line, atom_particles):
751 """Parse a single Modeller restraints file line and return the
752 corresponding IMP restraint."""
755 if typ ==
'MODELLER5':
758 raise NotImplementedError(
"Only 'R' lines currently read from " + \
759 "Modeller restraints files")
760 form = int(spl.pop(0))
761 modalities = [int(spl.pop(0))]
762 features = [int(spl.pop(0))]
765 natoms = [int(spl.pop(0))]
766 nparam = int(spl.pop(0))
767 nfeat = int(spl.pop(0))
768 for i
in range(nfeat - 1):
769 modalities.append(int(spl.pop(0)))
770 features.append(int(spl.pop(0)))
771 natoms.append(int(spl.pop(0)))
772 atoms = [int(spl.pop(0))
for x
in range(natoms[0])]
773 for i
in range(len(atoms)):
774 atoms[i] = atom_particles[atoms[i] - 1]
775 parameters = [float(spl.pop(0))
for x
in range(nparam)]
776 restraint_generators = {
777 1 : _DistanceRestraintGenerator,
778 2 : _AngleRestraintGenerator,
779 3 : _DihedralRestraintGenerator,
781 restraint_gen = restraint_generators[features[0]]
782 return restraint_gen(form, modalities, atoms, parameters)
785 def _load_entire_restraints_file(filename, protein):
786 """Yield a set of IMP restraints from a Modeller restraints file."""
787 atoms = _get_protein_atom_particles(protein)
788 fh = open(filename,
'r')
791 rsr = _load_restraints_line(line, atoms)
794 except Exception
as err:
795 print(
"Cannot read restraints file line:\n" + line)
799 def _copy_residue(r, model):
800 """Copy residue information from modeller to imp"""
805 p.set_name(str(
"residue "+r.num));
809 def _copy_atom(a, model):
810 """Copy atom information from modeller"""
816 if hasattr(a,
'charge'):
818 if hasattr(a,
'type'):
820 ap.set_input_index(a.index)
823 def _copy_chain(c, model):
824 """Copy chain information from modeller"""
831 def _get_forcefield(submodel):
843 """Add radii to the hierarchy using the Modeller radius library, radii.lib.
844 Each radius is scaled by the given scale (Modeller usually scales radii
845 by a factor of 0.82). submodel specifies the topology submodel, which is
846 the column in radii.lib to use."""
850 for line
in open(filename):
851 if line.startswith(
'#'):
continue
854 radii[spl[0]] = float(spl[submodel])
855 atoms = IMP.atom.get_by_type(hierarchy, IMP.atom.ATOM_TYPE)
864 """Read a Modeller model into IMP. After creating this object, the atoms
865 in the Modeller model can be loaded into IMP using the load_atoms()
866 method, then optionally any Modeller static restraints can be read in
867 with load_static_restraints() or load_static_restraints_file().
869 This class can also be used to read Modeller alignment structures;
870 however, only load_atoms() will be useful in such a case (since
871 alignment structures don't have restraints or other information).
877 @param modeller_model The Modeller model or alignment structure
880 self._modeller_model = modeller_model
883 """Construct an IMP::atom::Hierarchy that contains the same atoms as
884 the Modeller model or alignment structure.
886 IMP atoms created from a Modeller model will be given charges and
887 CHARMM types, extracted from the model. Alignment structures don't
888 contain this information, so the IMP atoms won't either.
890 @param model The IMP::Model object in which the hierarchy will be
891 created. The highest level hierarchy node is a PROTEIN.
892 @return the newly-created root IMP::atom::Hierarchy.
897 for chain
in self._modeller_model.chains:
902 for residue
in chain.residues:
903 rp = _copy_residue(residue, model)
906 for atom
in residue.atoms:
907 ap = _copy_atom(atom, model)
910 self._atoms[atom.index] = ap
912 self._modeller_hierarchy = hpp
915 def _get_nonbonded_list(self, atoms, pair_filter, edat, distance):
920 if pair_filter
is None:
922 if edat.excl_local[0]:
923 pair_filter.set_bonds(list(self.
load_bonds()))
924 if edat.excl_local[1]:
926 if edat.excl_local[2]:
928 nbl.add_pair_filter(pair_filter)
932 """Load the Modeller bond topology into the IMP model. Each bond is
933 represented in IMP as an IMP::atom::Bond, with no defined length
934 or stiffness. These bonds are primarily useful as input to
935 IMP::atom::StereochemistryPairFilter, to exclude bond interactions
936 from the nonbonded list. Typically the contribution to the scoring
937 function from the bonds is included in the Modeller static restraints
938 (use load_static_restraints() or load_static_restraints_file() to
939 load these). If you want to regenerate the stereochemistry in IMP,
940 do not use these functions (as then stereochemistry scoring terms
941 and exclusions would be double-counted) and instead use the
942 IMP::atom::CHARMMTopology class.
944 You must call load_atoms() prior to using this function.
945 @see load_angles(), load_dihedrals(), load_impropers()
946 @return A generator listing all of the bonds.
948 if not hasattr(self,
'_modeller_hierarchy'):
949 raise ValueError(
"Call load_atoms() first.")
950 for (maa, mab)
in self._modeller_model.bonds:
951 pa = self._atoms[maa.index]
952 pb = self._atoms[mab.index]
962 IMP.atom.Bond.SINGLE).get_particle()
965 """Load the Modeller angle topology into the IMP model.
966 See load_bonds() for more details."""
967 return self._internal_load_angles(self._modeller_model.angles,
971 """Load the Modeller dihedral topology into the IMP model.
972 See load_bonds() for more details."""
973 return self._internal_load_angles(self._modeller_model.dihedrals,
977 """Load the Modeller improper topology into the IMP model.
978 See load_bonds() for more details."""
979 return self._internal_load_angles(self._modeller_model.impropers,
982 def _internal_load_angles(self, angles, angle_class):
983 if not hasattr(self,
'_modeller_hierarchy'):
984 raise ValueError(
"Call load_atoms() first.")
985 for modeller_atoms
in angles:
986 imp_particles = [self._atoms[x.index]
for x
in modeller_atoms]
988 a = angle_class.setup_particle(p,
990 yield a.get_particle()
993 """Convert a Modeller static restraints file into equivalent
994 IMP::Restraints. load_atoms() must have been called first to read
995 in the atoms that the restraints will act upon.
996 @param filename Name of the Modeller restraints file. The restraints
997 in this file are assumed to act upon the model read in by
998 load_atoms(); no checking is done to enforce this.
999 @return A Python generator of the newly-created IMP::Restraint
1002 if not hasattr(self,
'_modeller_hierarchy'):
1003 raise ValueError(
"Call load_atoms() first.")
1004 return _load_entire_restraints_file(filename, self._modeller_hierarchy)
1008 """Convert the current set of Modeller static restraints into equivalent
1009 IMP::Restraints. load_atoms() must have been called first to read
1010 in the atoms that the restraints will act upon.
1011 @return A Python generator of the newly-created IMP::Restraint
1014 class _RestraintGenerator(object):
1015 """Simple generator wrapper"""
1018 def __iter__(self, *args, **keys):
1020 def close(self, *args, **keys):
1021 return self._gen.close(*args, **keys)
1023 return next(self._gen)
1025 def send(self, *args, **keys):
1026 return self._gen.send(*args, **keys)
1027 def throw(self, *args, **keys):
1028 return self._gen.throw(*args, **keys)
1031 rsrfile = os.path.join(t.tmpdir,
'restraints.rsr')
1032 self._modeller_model.restraints.write(file=rsrfile)
1035 wrap = _RestraintGenerator(gen)
1041 """Convert Modeller dynamic restraints into IMP::Restraint objects.
1043 For each currently active Modeller dynamic restraint
1044 (e.g. soft-sphere, electrostatics) an equivalent IMP::Restraint
1046 load_atoms() must have been called first to read
1047 in the atoms that the restraints will act upon.
1049 If pair_filter is given, it is an IMP::PairFilter object to exclude
1050 pairs from the nonbonded lists used by the dynamic restraints.
1051 Otherwise, an IMP::atom::StereochemistryPairFilter object is created
1052 to exclude Modeller bonds, angles and dihedrals, as specified by
1053 edat.excl_local. (Note that this calls load_bonds(), load_angles()
1054 and load_dihedrals(), so will create duplicate lists of bonds if
1055 those methods are called manually as well.)
1057 @note Currently only soft-sphere, electrostatic and Lennard-Jones
1058 restraints are loaded.
1059 @return A Python generator of the newly-created IMP::Restraint
1062 if not hasattr(self,
'_modeller_hierarchy'):
1063 raise ValueError(
"Call load_atoms() first.")
1064 edat = self._modeller_model.env.edat
1065 libs = self._modeller_model.env.libs
1067 m = atoms[0].get_model()
1070 if edat.dynamic_sphere:
1073 nbl = self._get_nonbonded_list(atoms, pair_filter, edat, 0.)
1076 libs.topology.submodel, edat.radii_factor)
1083 if edat.dynamic_lennard
or edat.dynamic_coulomb:
1085 d = max(edat.contact_shell - 3.0, 0.0)
1086 nbl = self._get_nonbonded_list(atoms, pair_filter, edat, d)
1087 ff = _get_forcefield(libs.topology.submodel)
1088 ff.add_radii(self._modeller_hierarchy)
1090 if edat.dynamic_lennard:
1091 ff.add_well_depths(self._modeller_hierarchy)
1093 edat.lennard_jones_switch[1])
1097 if edat.dynamic_coulomb:
1099 edat.coulomb_switch[1])
1101 ps.set_relative_dielectric(edat.relative_dielectric)
1106 """Proxy of C++ IMP::modeller::MultipleBinormalRestraint class"""
1107 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
1110 """__init__(IMP::modeller::MultipleBinormalRestraint self, Model m, IMP::ParticleIndexQuad const & q1, IMP::ParticleIndexQuad const & q2) -> MultipleBinormalRestraint"""
1111 this = _IMP_modeller.new_MultipleBinormalRestraint(m, q1, q2)
1113 self.this.append(this)
1117 def add_term(self, term):
1118 """add_term(MultipleBinormalRestraint self, BinormalTerm term)"""
1119 return _IMP_modeller.MultipleBinormalRestraint_add_term(self, term)
1122 def do_get_inputs(self):
1123 """do_get_inputs(MultipleBinormalRestraint self) -> IMP::ModelObjectsTemp"""
1124 return _IMP_modeller.MultipleBinormalRestraint_do_get_inputs(self)
1127 def get_version_info(self):
1128 """get_version_info(MultipleBinormalRestraint self) -> VersionInfo"""
1129 return _IMP_modeller.MultipleBinormalRestraint_get_version_info(self)
1133 """__str__(MultipleBinormalRestraint self) -> std::string"""
1134 return _IMP_modeller.MultipleBinormalRestraint___str__(self)
1138 """__repr__(MultipleBinormalRestraint self) -> std::string"""
1139 return _IMP_modeller.MultipleBinormalRestraint___repr__(self)
1144 return _object_cast_to_MultipleBinormalRestraint(o)
1146 MultipleBinormalRestraint_swigregister = _IMP_modeller.MultipleBinormalRestraint_swigregister
1147 MultipleBinormalRestraint_swigregister(MultipleBinormalRestraint)
1150 """Proxy of C++ IMP::modeller::BinormalTerm class"""
1151 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
1154 """__init__(IMP::modeller::BinormalTerm self) -> BinormalTerm"""
1155 this = _IMP_modeller.new_BinormalTerm()
1157 self.this.append(this)
1161 def set_correlation(self, correlation):
1162 """set_correlation(BinormalTerm self, double correlation)"""
1163 return _IMP_modeller.BinormalTerm_set_correlation(self, correlation)
1166 def set_weight(self, weight):
1167 """set_weight(BinormalTerm self, double weight)"""
1168 return _IMP_modeller.BinormalTerm_set_weight(self, weight)
1171 def set_means(self, means):
1172 """set_means(BinormalTerm self, IMP::FloatPair means)"""
1173 return _IMP_modeller.BinormalTerm_set_means(self, means)
1176 def set_standard_deviations(self, stdevs):
1177 """set_standard_deviations(BinormalTerm self, IMP::FloatPair stdevs)"""
1178 return _IMP_modeller.BinormalTerm_set_standard_deviations(self, stdevs)
1181 def show(self, *args):
1183 show(BinormalTerm self, _ostream out)
1184 show(BinormalTerm self)
1186 return _IMP_modeller.BinormalTerm_show(self, *args)
1190 """__str__(BinormalTerm self) -> std::string"""
1191 return _IMP_modeller.BinormalTerm___str__(self)
1195 """__repr__(BinormalTerm self) -> std::string"""
1196 return _IMP_modeller.BinormalTerm___repr__(self)
1198 __swig_destroy__ = _IMP_modeller.delete_BinormalTerm
1199 __del__ =
lambda self:
None
1200 BinormalTerm_swigregister = _IMP_modeller.BinormalTerm_swigregister
1201 BinormalTerm_swigregister(BinormalTerm)
1204 def get_module_version():
1205 """get_module_version() -> std::string const"""
1206 return _IMP_modeller.get_module_version()
1209 """get_example_path(std::string fname) -> std::string"""
1210 return _IMP_modeller.get_example_path(fname)
1213 """get_data_path(std::string fname) -> std::string"""
1214 return _IMP_modeller.get_data_path(fname)
1216 from .
import _version_check
1217 _version_check.check_version(get_module_version())
1218 __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)