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_kernel', [dirname(__file__)])
28 _mod = imp.load_module(
'_IMP_kernel', fp, pathname, description)
32 _IMP_kernel = 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_KERNEL_SwigPyIterator(object):
114 """Proxy of C++ swig::IMP_KERNEL_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_kernel.delete_IMP_KERNEL_SwigPyIterator
122 __del__ =
lambda self:
None
125 """value(IMP_KERNEL_SwigPyIterator self) -> PyObject *"""
126 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_value(self)
131 incr(IMP_KERNEL_SwigPyIterator self, size_t n=1) -> IMP_KERNEL_SwigPyIterator
132 incr(IMP_KERNEL_SwigPyIterator self) -> IMP_KERNEL_SwigPyIterator
134 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_incr(self, n)
139 decr(IMP_KERNEL_SwigPyIterator self, size_t n=1) -> IMP_KERNEL_SwigPyIterator
140 decr(IMP_KERNEL_SwigPyIterator self) -> IMP_KERNEL_SwigPyIterator
142 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_decr(self, n)
145 def distance(self, x):
146 """distance(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> ptrdiff_t"""
147 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_distance(self, x)
151 """equal(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> bool"""
152 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_equal(self, x)
156 """copy(IMP_KERNEL_SwigPyIterator self) -> IMP_KERNEL_SwigPyIterator"""
157 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_copy(self)
161 """next(IMP_KERNEL_SwigPyIterator self) -> PyObject *"""
162 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_next(self)
166 """__next__(IMP_KERNEL_SwigPyIterator self) -> PyObject *"""
167 return _IMP_kernel.IMP_KERNEL_SwigPyIterator___next__(self)
171 """previous(IMP_KERNEL_SwigPyIterator self) -> PyObject *"""
172 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_previous(self)
175 def advance(self, n):
176 """advance(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator"""
177 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_advance(self, n)
181 """__eq__(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> bool"""
182 return _IMP_kernel.IMP_KERNEL_SwigPyIterator___eq__(self, x)
186 """__ne__(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> bool"""
187 return _IMP_kernel.IMP_KERNEL_SwigPyIterator___ne__(self, x)
190 def __iadd__(self, n):
191 """__iadd__(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator"""
192 return _IMP_kernel.IMP_KERNEL_SwigPyIterator___iadd__(self, n)
195 def __isub__(self, n):
196 """__isub__(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator"""
197 return _IMP_kernel.IMP_KERNEL_SwigPyIterator___isub__(self, n)
200 def __add__(self, n):
201 """__add__(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator"""
202 return _IMP_kernel.IMP_KERNEL_SwigPyIterator___add__(self, n)
205 def __sub__(self, *args):
207 __sub__(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator
208 __sub__(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> ptrdiff_t
210 return _IMP_kernel.IMP_KERNEL_SwigPyIterator___sub__(self, *args)
214 IMP_KERNEL_SwigPyIterator_swigregister = _IMP_kernel.IMP_KERNEL_SwigPyIterator_swigregister
215 IMP_KERNEL_SwigPyIterator_swigregister(IMP_KERNEL_SwigPyIterator)
224 _IMP_kernel.IMP_DEBUG_swigconstant(_IMP_kernel)
225 IMP_DEBUG = _IMP_kernel.IMP_DEBUG
227 _IMP_kernel.IMP_RELEASE_swigconstant(_IMP_kernel)
228 IMP_RELEASE = _IMP_kernel.IMP_RELEASE
230 _IMP_kernel.IMP_SILENT_swigconstant(_IMP_kernel)
231 IMP_SILENT = _IMP_kernel.IMP_SILENT
233 _IMP_kernel.IMP_PROGRESS_swigconstant(_IMP_kernel)
234 IMP_PROGRESS = _IMP_kernel.IMP_PROGRESS
236 _IMP_kernel.IMP_TERSE_swigconstant(_IMP_kernel)
237 IMP_TERSE = _IMP_kernel.IMP_TERSE
239 _IMP_kernel.IMP_VERBOSE_swigconstant(_IMP_kernel)
240 IMP_VERBOSE = _IMP_kernel.IMP_VERBOSE
242 _IMP_kernel.IMP_MEMORY_swigconstant(_IMP_kernel)
243 IMP_MEMORY = _IMP_kernel.IMP_MEMORY
245 _IMP_kernel.IMP_NONE_swigconstant(_IMP_kernel)
246 IMP_NONE = _IMP_kernel.IMP_NONE
248 _IMP_kernel.IMP_USAGE_swigconstant(_IMP_kernel)
249 IMP_USAGE = _IMP_kernel.IMP_USAGE
251 _IMP_kernel.IMP_INTERNAL_swigconstant(_IMP_kernel)
252 IMP_INTERNAL = _IMP_kernel.IMP_INTERNAL
254 _IMP_kernel.IMP_KERNEL_HAS_LOG4CXX_swigconstant(_IMP_kernel)
255 IMP_KERNEL_HAS_LOG4CXX = _IMP_kernel.IMP_KERNEL_HAS_LOG4CXX
257 _IMP_kernel.IMP_COMPILER_HAS_AUTO_swigconstant(_IMP_kernel)
258 IMP_COMPILER_HAS_AUTO = _IMP_kernel.IMP_COMPILER_HAS_AUTO
260 _IMP_kernel.IMP_COMPILER_HAS_DEBUG_VECTOR_swigconstant(_IMP_kernel)
261 IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_kernel.IMP_COMPILER_HAS_DEBUG_VECTOR
263 _IMP_kernel.IMP_COMPILER_HAS_UNIQUE_PTR_swigconstant(_IMP_kernel)
264 IMP_COMPILER_HAS_UNIQUE_PTR = _IMP_kernel.IMP_COMPILER_HAS_UNIQUE_PTR
266 _IMP_kernel.IMP_KERNEL_HAS_BOOST_RANDOM_swigconstant(_IMP_kernel)
267 IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_kernel.IMP_KERNEL_HAS_BOOST_RANDOM
269 _IMP_kernel.IMP_KERNEL_HAS_GPERFTOOLS_swigconstant(_IMP_kernel)
270 IMP_KERNEL_HAS_GPERFTOOLS = _IMP_kernel.IMP_KERNEL_HAS_GPERFTOOLS
272 _IMP_kernel.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER_swigconstant(_IMP_kernel)
273 IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER = _IMP_kernel.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER
275 _IMP_kernel.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER_swigconstant(_IMP_kernel)
276 IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER = _IMP_kernel.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER
278 _IMP_kernel.IMPKERNEL_SHOW_WARNINGS_swigconstant(_IMP_kernel)
279 IMPKERNEL_SHOW_WARNINGS = _IMP_kernel.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()
308 _IMP_kernel.DEFAULT_CHECK_swigconstant(_IMP_kernel)
309 DEFAULT_CHECK = _IMP_kernel.DEFAULT_CHECK
311 _IMP_kernel.NONE_swigconstant(_IMP_kernel)
312 NONE = _IMP_kernel.NONE
314 _IMP_kernel.USAGE_swigconstant(_IMP_kernel)
315 USAGE = _IMP_kernel.USAGE
317 _IMP_kernel.USAGE_AND_INTERNAL_swigconstant(_IMP_kernel)
318 USAGE_AND_INTERNAL = _IMP_kernel.USAGE_AND_INTERNAL
321 """set_check_level(IMP::CheckLevel tf)"""
322 return _IMP_kernel.set_check_level(tf)
325 """get_check_level() -> IMP::CheckLevel"""
326 return _IMP_kernel.get_check_level()
328 from _IMP_kernel
import Exception, InternalException, ModelException, EventException
329 from _IMP_kernel
import UsageException, IndexException, IOException, ValueException
330 from _IMP_kernel
import TypeException
332 class _ostream(object):
333 """Proxy of C++ std::ostream class."""
335 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
337 def __init__(self, *args, **kwargs):
338 raise AttributeError(
"No constructor defined")
339 __repr__ = _swig_repr
341 def write(self, osa_buf):
342 """write(_ostream self, char const * osa_buf)"""
343 return _IMP_kernel._ostream_write(self, osa_buf)
345 _ostream_swigregister = _IMP_kernel._ostream_swigregister
346 _ostream_swigregister(_ostream)
349 _IMP_kernel.IMP_COMPILER_HAS_OVERRIDE_swigconstant(_IMP_kernel)
350 IMP_COMPILER_HAS_OVERRIDE = _IMP_kernel.IMP_COMPILER_HAS_OVERRIDE
352 _IMP_kernel.IMP_COMPILER_HAS_FINAL_swigconstant(_IMP_kernel)
353 IMP_COMPILER_HAS_FINAL = _IMP_kernel.IMP_COMPILER_HAS_FINAL
355 _IMP_kernel.IMP_HAS_NOEXCEPT_swigconstant(_IMP_kernel)
356 IMP_HAS_NOEXCEPT = _IMP_kernel.IMP_HAS_NOEXCEPT
358 _raii_types.append(
"SetLogState")
361 _raii_types.append(
"SetNumberOfThreads")
364 _raii_types.append(
"SetCheckState")
367 _object_types.append(
"Object")
370 def _object_cast_to_Object(o):
371 """_object_cast_to_Object(Object * o) -> Object"""
372 return _IMP_kernel._object_cast_to_Object(o)
374 _object_types.append(
"_TestObject")
377 def _object_cast_to__TestObject(o):
378 """_object_cast_to__TestObject(Object * o) -> _TestObject"""
379 return _IMP_kernel._object_cast_to__TestObject(o)
382 _plural_types.append(
"VersionInfos")
383 _value_types.append(
"VersionInfo")
386 _raii_types.append(
"CreateLogContext")
389 _raii_types.append(
"WarningContext")
392 _raii_types.append(
"SetLogTarget")
396 _plural_types.append(
"_TestValues")
397 _value_types.append(
"_TestValue")
401 _plural_types.append(
"Floats")
402 _value_types.append(
"Float")
406 _plural_types.append(
"Ints")
407 _value_types.append(
"Int")
411 _plural_types.append(
"Strings")
412 _value_types.append(
"String")
416 _plural_types.append(
"_Protections")
417 _value_types.append(
"_Protection")
419 class _InputAdaptor(object):
420 """Proxy of C++ IMP::InputAdaptor class."""
422 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
424 def __init__(self, *args, **kwargs):
425 raise AttributeError(
"No constructor defined")
426 __repr__ = _swig_repr
427 __swig_destroy__ = _IMP_kernel.delete__InputAdaptor
428 __del__ =
lambda self:
None
429 _InputAdaptor_swigregister = _IMP_kernel._InputAdaptor_swigregister
430 _InputAdaptor_swigregister(_InputAdaptor)
432 class _NonCopyable(object):
433 """Proxy of C++ IMP::NonCopyable class."""
435 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
437 def __init__(self, *args, **kwargs):
438 raise AttributeError(
"No constructor defined")
439 __repr__ = _swig_repr
440 __swig_destroy__ = _IMP_kernel.delete__NonCopyable
441 __del__ =
lambda self:
None
442 _NonCopyable_swigregister = _IMP_kernel._NonCopyable_swigregister
443 _NonCopyable_swigregister(_NonCopyable)
445 class _RAII(_NonCopyable):
446 """Proxy of C++ IMP::RAII class."""
448 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
450 def __init__(self, *args, **kwargs):
451 raise AttributeError(
"No constructor defined")
452 __repr__ = _swig_repr
453 __swig_destroy__ = _IMP_kernel.delete__RAII
454 __del__ =
lambda self:
None
455 _RAII_swigregister = _IMP_kernel._RAII_swigregister
456 _RAII_swigregister(_RAII)
458 class _Value(object):
459 """Proxy of C++ IMP::Value class."""
461 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
463 def __init__(self, *args, **kwargs):
464 raise AttributeError(
"No constructor defined")
465 __repr__ = _swig_repr
466 __swig_destroy__ = _IMP_kernel.delete__Value
467 __del__ =
lambda self:
None
468 _Value_swigregister = _IMP_kernel._Value_swigregister
469 _Value_swigregister(_Value)
473 """get_executable_name() -> std::string"""
474 return _IMP_kernel.get_executable_name()
478 setup_from_argv(IMP::Strings const & argv, std::string description)
479 setup_from_argv(IMP::Strings const & argv, std::string description, std::string positional_description, int num_positional) -> IMP::Strings
481 return _IMP_kernel.setup_from_argv(*args)
484 """add_string_flag(std::string name, std::string default_value, std::string description)"""
485 return _IMP_kernel.add_string_flag(name, default_value, description)
488 """get_string_flag(std::string name) -> std::string"""
489 return _IMP_kernel.get_string_flag(name)
492 """add_int_flag(std::string name, size_t default_value, std::string description)"""
493 return _IMP_kernel.add_int_flag(name, default_value, description)
496 """get_int_flag(std::string name) -> size_t"""
497 return _IMP_kernel.get_int_flag(name)
500 """add_bool_flag(std::string name, std::string description)"""
501 return _IMP_kernel.add_bool_flag(name, description)
504 """get_bool_flag(std::string name) -> bool"""
505 return _IMP_kernel.get_bool_flag(name)
508 """add_float_flag(std::string name, double default_value, std::string description)"""
509 return _IMP_kernel.add_float_flag(name, default_value, description)
512 """get_float_flag(std::string name) -> double"""
513 return _IMP_kernel.get_float_flag(name)
517 write_help(_ostream out)
520 return _IMP_kernel.write_help(*args)
523 """get_is_quick_test() -> bool"""
524 return _IMP_kernel.get_is_quick_test()
526 _IMP_kernel.DEFAULT_swigconstant(_IMP_kernel)
527 DEFAULT = _IMP_kernel.DEFAULT
529 _IMP_kernel.SILENT_swigconstant(_IMP_kernel)
530 SILENT = _IMP_kernel.SILENT
532 _IMP_kernel.WARNING_swigconstant(_IMP_kernel)
533 WARNING = _IMP_kernel.WARNING
535 _IMP_kernel.PROGRESS_swigconstant(_IMP_kernel)
536 PROGRESS = _IMP_kernel.PROGRESS
538 _IMP_kernel.TERSE_swigconstant(_IMP_kernel)
539 TERSE = _IMP_kernel.TERSE
541 _IMP_kernel.VERBOSE_swigconstant(_IMP_kernel)
542 VERBOSE = _IMP_kernel.VERBOSE
544 _IMP_kernel.MEMORY_swigconstant(_IMP_kernel)
545 MEMORY = _IMP_kernel.MEMORY
547 _IMP_kernel.ALL_LOG_swigconstant(_IMP_kernel)
548 ALL_LOG = _IMP_kernel.ALL_LOG
550 _IMP_kernel.NO_STATISTICS_swigconstant(_IMP_kernel)
551 NO_STATISTICS = _IMP_kernel.NO_STATISTICS
553 _IMP_kernel.ALL_STATISTICS_swigconstant(_IMP_kernel)
554 ALL_STATISTICS = _IMP_kernel.ALL_STATISTICS
555 class VersionInfo(_Value):
556 """Proxy of C++ IMP::VersionInfo class."""
558 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
560 def __init__(self, *args):
562 __init__(IMP::VersionInfo self, std::string module, std::string version) -> VersionInfo
563 __init__(IMP::VersionInfo self) -> VersionInfo
565 this = _IMP_kernel.new_VersionInfo(*args)
567 self.this.append(this)
571 def get_module(self):
572 """get_module(VersionInfo self) -> std::string"""
573 return _IMP_kernel.VersionInfo_get_module(self)
576 def get_version(self):
577 """get_version(VersionInfo self) -> std::string"""
578 return _IMP_kernel.VersionInfo_get_version(self)
581 def show(self, *args):
583 show(VersionInfo self, _ostream out)
584 show(VersionInfo self)
586 return _IMP_kernel.VersionInfo_show(self, *args)
589 def __cmp__(self, o):
590 """__cmp__(VersionInfo self, VersionInfo o) -> int"""
591 return _IMP_kernel.VersionInfo___cmp__(self, o)
595 """__eq__(VersionInfo self, VersionInfo o) -> bool"""
596 return _IMP_kernel.VersionInfo___eq__(self, o)
600 """__ne__(VersionInfo self, VersionInfo o) -> bool"""
601 return _IMP_kernel.VersionInfo___ne__(self, o)
605 """__lt__(VersionInfo self, VersionInfo o) -> bool"""
606 return _IMP_kernel.VersionInfo___lt__(self, o)
610 """__gt__(VersionInfo self, VersionInfo o) -> bool"""
611 return _IMP_kernel.VersionInfo___gt__(self, o)
615 """__ge__(VersionInfo self, VersionInfo o) -> bool"""
616 return _IMP_kernel.VersionInfo___ge__(self, o)
620 """__le__(VersionInfo self, VersionInfo o) -> bool"""
621 return _IMP_kernel.VersionInfo___le__(self, o)
625 """__str__(VersionInfo self) -> std::string"""
626 return _IMP_kernel.VersionInfo___str__(self)
630 """__repr__(VersionInfo self) -> std::string"""
631 return _IMP_kernel.VersionInfo___repr__(self)
633 __swig_destroy__ = _IMP_kernel.delete_VersionInfo
634 __del__ =
lambda self:
None
635 VersionInfo_swigregister = _IMP_kernel.VersionInfo_swigregister
636 VersionInfo_swigregister(VersionInfo)
638 class TextOutput(_InputAdaptor):
639 """Proxy of C++ IMP::TextOutput class."""
641 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
642 __repr__ = _swig_repr
644 def __init__(self, *args):
646 __init__(IMP::TextOutput self, int arg2) -> TextOutput
647 __init__(IMP::TextOutput self, double arg2) -> TextOutput
648 __init__(IMP::TextOutput self, char const * c, bool append=False) -> TextOutput
649 __init__(IMP::TextOutput self, char const * c) -> TextOutput
650 __init__(IMP::TextOutput self, IMP::TextProxy< std::ostream > p) -> TextOutput
651 __init__(IMP::TextOutput self) -> TextOutput
652 __init__(IMP::TextOutput self, std::string file_name, bool append=False) -> TextOutput
653 __init__(IMP::TextOutput self, std::string file_name) -> TextOutput
655 this = _IMP_kernel.new_TextOutput(*args)
657 self.this.append(this)
661 def show(self, *args):
663 show(TextOutput self, _ostream out)
664 show(TextOutput self)
666 return _IMP_kernel.TextOutput_show(self, *args)
670 """get_name(TextOutput self) -> std::string"""
671 return _IMP_kernel.TextOutput_get_name(self)
673 __swig_destroy__ = _IMP_kernel.delete_TextOutput
674 __del__ =
lambda self:
None
675 TextOutput_swigregister = _IMP_kernel.TextOutput_swigregister
676 TextOutput_swigregister(TextOutput)
678 class TextInput(_InputAdaptor):
679 """Proxy of C++ IMP::TextInput class."""
681 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
682 __repr__ = _swig_repr
684 def __init__(self, *args):
686 __init__(IMP::TextInput self, int arg2) -> TextInput
687 __init__(IMP::TextInput self, double arg2) -> TextInput
688 __init__(IMP::TextInput self, char const * c) -> TextInput
689 __init__(IMP::TextInput self, IMP::TextProxy< std::istream > p) -> TextInput
690 __init__(IMP::TextInput self) -> TextInput
691 __init__(IMP::TextInput self, std::string file_name) -> TextInput
693 this = _IMP_kernel.new_TextInput(*args)
695 self.this.append(this)
699 def show(self, *args):
701 show(TextInput self, _ostream out)
704 return _IMP_kernel.TextInput_show(self, *args)
708 """get_name(TextInput self) -> std::string"""
709 return _IMP_kernel.TextInput_get_name(self)
711 __swig_destroy__ = _IMP_kernel.delete_TextInput
712 __del__ =
lambda self:
None
713 TextInput_swigregister = _IMP_kernel.TextInput_swigregister
714 TextInput_swigregister(TextInput)
716 class SetLogTarget(_RAII):
717 """Proxy of C++ IMP::SetLogTarget class."""
719 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
721 def __init__(self, *args):
723 __init__(IMP::SetLogTarget self) -> SetLogTarget
724 __init__(IMP::SetLogTarget self, TextOutput to) -> SetLogTarget
726 this = _IMP_kernel.new_SetLogTarget(*args)
728 self.this.append(this)
733 """set(SetLogTarget self, TextOutput to)"""
734 return _IMP_kernel.SetLogTarget_set(self, to)
738 """reset(SetLogTarget self)"""
739 return _IMP_kernel.SetLogTarget_reset(self)
741 __swig_destroy__ = _IMP_kernel.delete_SetLogTarget
742 __del__ =
lambda self:
None
744 def show(self, *args):
746 show(SetLogTarget self, _ostream out)
747 show(SetLogTarget self)
749 return _IMP_kernel.SetLogTarget_show(self, *args)
754 def __exit__(self, exc_type, exc_val, exc_tb):
760 """__str__(SetLogTarget self) -> std::string"""
761 return _IMP_kernel.SetLogTarget___str__(self)
765 """__repr__(SetLogTarget self) -> std::string"""
766 return _IMP_kernel.SetLogTarget___repr__(self)
768 SetLogTarget_swigregister = _IMP_kernel.SetLogTarget_swigregister
769 SetLogTarget_swigregister(SetLogTarget)
774 create_temporary_file(std::string prefix, std::string suffix) -> TextOutput
775 create_temporary_file(std::string prefix) -> TextOutput
776 create_temporary_file() -> TextOutput
778 return _IMP_kernel.create_temporary_file(*args)
782 create_temporary_file_name(std::string prefix, std::string suffix) -> std::string
783 create_temporary_file_name(std::string prefix) -> std::string
784 create_temporary_file_name() -> std::string
786 return _IMP_kernel.create_temporary_file_name(*args)
789 """get_relative_path(std::string base, std::string relative) -> std::string"""
790 return _IMP_kernel.get_relative_path(base, relative)
792 def push_log_context(functionname, object):
793 """push_log_context(char const * functionname, void const * object)"""
794 return _IMP_kernel.push_log_context(functionname, object)
796 def pop_log_context():
797 """pop_log_context()"""
798 return _IMP_kernel.pop_log_context()
802 add_to_log(std::string to_write)
803 add_to_log(IMP::LogLevel level, std::string to_write)
805 return _IMP_kernel.add_to_log(*args)
808 """set_log_level(IMP::LogLevel l)"""
809 return _IMP_kernel.set_log_level(l)
812 """set_log_timer(bool tb)"""
813 return _IMP_kernel.set_log_timer(tb)
816 """reset_log_timer()"""
817 return _IMP_kernel.reset_log_timer()
820 """get_log_level() -> IMP::LogLevel"""
821 return _IMP_kernel.get_log_level()
824 """set_progress_display(std::string description, unsigned int steps)"""
825 return _IMP_kernel.set_progress_display(description, steps)
829 add_to_progress_display(unsigned int step=1)
830 add_to_progress_display()
832 return _IMP_kernel.add_to_progress_display(step)
833 class Object(_NonCopyable):
834 """Proxy of C++ IMP::Object class."""
836 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
838 def __init__(self, name):
839 """__init__(IMP::Object self, std::string name) -> Object"""
840 if self.__class__ == Object:
844 this = _IMP_kernel.new_Object(_self, name)
846 self.this.append(this)
850 if self.__class__ != Object:
851 _director_objects.register(self)
855 __swig_destroy__ = _IMP_kernel.delete_Object
856 __del__ =
lambda self:
None
859 """__hash__(Object self) -> std::size_t"""
860 return _IMP_kernel.Object___hash__(self)
864 """set_log_level(Object self, IMP::LogLevel l)"""
865 return _IMP_kernel.Object_set_log_level(self, l)
869 """set_check_level(Object self, IMP::CheckLevel l)"""
870 return _IMP_kernel.Object_set_check_level(self, l)
874 """get_log_level(Object self) -> IMP::LogLevel"""
875 return _IMP_kernel.Object_get_log_level(self)
879 """get_check_level(Object self) -> IMP::CheckLevel"""
880 return _IMP_kernel.Object_get_check_level(self)
883 def get_version_info(self):
884 """get_version_info(Object self) -> VersionInfo"""
885 return _IMP_kernel.Object_get_version_info(self)
889 """get_name(Object self) -> std::string const &"""
890 return _IMP_kernel.Object_get_name(self)
893 def set_name(self, name):
894 """set_name(Object self, std::string name)"""
895 return _IMP_kernel.Object_set_name(self, name)
898 def get_type_name(self):
899 """get_type_name(Object self) -> std::string"""
900 return _IMP_kernel.Object_get_type_name(self)
903 def set_was_used(self, tf):
904 """set_was_used(Object self, bool tf)"""
905 return _IMP_kernel.Object_set_was_used(self, tf)
908 def show(self, *args):
910 show(Object self, _ostream out)
913 return _IMP_kernel.Object_show(self, *args)
916 def get_string(self):
917 """get_string(Object self) -> std::string"""
918 return _IMP_kernel.Object_get_string(self)
921 def _on_destruction(self):
922 """_on_destruction(Object self)"""
923 return _IMP_kernel.Object__on_destruction(self)
926 def get_is_valid(self):
927 """get_is_valid(Object self) -> bool"""
928 return _IMP_kernel.Object_get_is_valid(self)
931 def get_ref_count(self):
932 """get_ref_count(Object self) -> unsigned int"""
933 return _IMP_kernel.Object_get_ref_count(self)
936 def get_number_of_live_objects():
937 """get_number_of_live_objects() -> unsigned int"""
938 return _IMP_kernel.Object_get_number_of_live_objects()
940 get_number_of_live_objects = staticmethod(get_number_of_live_objects)
942 def get_is_shared(self):
943 """get_is_shared(Object self) -> bool"""
944 return _IMP_kernel.Object_get_is_shared(self)
947 def clear_caches(self):
948 """clear_caches(Object self)"""
949 return _IMP_kernel.Object_clear_caches(self)
952 def do_destroy(self):
953 """do_destroy(Object self)"""
954 return _IMP_kernel.Object_do_destroy(self)
958 """__eq__(Object self, Object o) -> bool"""
959 return _IMP_kernel.Object___eq__(self, o)
963 """__ne__(Object self, Object o) -> bool"""
964 return _IMP_kernel.Object___ne__(self, o)
968 """__le__(Object self, Object o) -> bool"""
969 return _IMP_kernel.Object___le__(self, o)
973 """__lt__(Object self, Object o) -> bool"""
974 return _IMP_kernel.Object___lt__(self, o)
978 """__ge__(Object self, Object o) -> bool"""
979 return _IMP_kernel.Object___ge__(self, o)
983 """__gt__(Object self, Object o) -> bool"""
984 return _IMP_kernel.Object___gt__(self, o)
988 """__str__(Object self) -> std::string"""
989 return _IMP_kernel.Object___str__(self)
993 """__repr__(Object self) -> std::string"""
994 return _IMP_kernel.Object___repr__(self)
999 return _object_cast_to_Object(o)
1001 def __disown__(self):
1003 _IMP_kernel.disown_Object(self)
1004 return weakref_proxy(self)
1005 Object_swigregister = _IMP_kernel.Object_swigregister
1006 Object_swigregister(Object)
1008 def Object_get_number_of_live_objects():
1009 """Object_get_number_of_live_objects() -> unsigned int"""
1010 return _IMP_kernel.Object_get_number_of_live_objects()
1012 class SetLogState(_RAII):
1013 """Proxy of C++ IMP::SetLogState class."""
1015 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
1018 """reset(SetLogState self)"""
1019 return _IMP_kernel.SetLogState_reset(self)
1021 __swig_destroy__ = _IMP_kernel.delete_SetLogState
1022 __del__ =
lambda self:
None
1024 def show(self, *args):
1026 show(SetLogState self, _ostream out)
1027 show(SetLogState self)
1029 return _IMP_kernel.SetLogState_show(self, *args)
1032 def __init__(self, *args):
1034 __init__(IMP::SetLogState self) -> SetLogState
1035 __init__(IMP::SetLogState self, Object o, IMP::LogLevel l) -> SetLogState
1036 __init__(IMP::SetLogState self, IMP::LogLevel l) -> SetLogState
1038 this = _IMP_kernel.new_SetLogState(*args)
1040 self.this.append(this)
1044 def set(self, *args):
1046 set(SetLogState self, Object o, IMP::LogLevel l)
1047 set(SetLogState self, IMP::LogLevel l)
1049 return _IMP_kernel.SetLogState_set(self, *args)
1052 def __enter__(self):
1054 def __exit__(self, exc_type, exc_val, exc_tb):
1060 """__str__(SetLogState self) -> std::string"""
1061 return _IMP_kernel.SetLogState___str__(self)
1065 """__repr__(SetLogState self) -> std::string"""
1066 return _IMP_kernel.SetLogState___repr__(self)
1068 SetLogState_swigregister = _IMP_kernel.SetLogState_swigregister
1069 SetLogState_swigregister(SetLogState)
1071 class WarningContext(object):
1072 """Proxy of C++ IMP::WarningContext class."""
1074 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
1075 data_ = _swig_property(_IMP_kernel.WarningContext_data__get, _IMP_kernel.WarningContext_data__set)
1077 def add_warning(self, key, warning):
1078 """add_warning(WarningContext self, std::string key, std::string warning)"""
1079 return _IMP_kernel.WarningContext_add_warning(self, key, warning)
1082 def clear_warnings(self):
1083 """clear_warnings(WarningContext self)"""
1084 return _IMP_kernel.WarningContext_clear_warnings(self)
1087 def dump_warnings(self):
1088 """dump_warnings(WarningContext self)"""
1089 return _IMP_kernel.WarningContext_dump_warnings(self)
1091 __swig_destroy__ = _IMP_kernel.delete_WarningContext
1092 __del__ =
lambda self:
None
1094 def show(self, *args):
1096 show(WarningContext self, _ostream out)
1097 show(WarningContext self)
1099 return _IMP_kernel.WarningContext_show(self, *args)
1102 def __enter__(self):
1104 def __exit__(self, exc_type, exc_val, exc_tb):
1110 """__str__(WarningContext self) -> std::string"""
1111 return _IMP_kernel.WarningContext___str__(self)
1115 """__repr__(WarningContext self) -> std::string"""
1116 return _IMP_kernel.WarningContext___repr__(self)
1120 """__init__(IMP::WarningContext self) -> WarningContext"""
1121 this = _IMP_kernel.new_WarningContext()
1123 self.this.append(this)
1126 WarningContext_swigregister = _IMP_kernel.WarningContext_swigregister
1127 WarningContext_swigregister(WarningContext)
1129 class CreateLogContext(_RAII):
1130 """Proxy of C++ IMP::CreateLogContext class."""
1132 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
1134 def __init__(self, *args):
1136 __init__(IMP::CreateLogContext self, std::string fname, Object object=None) -> CreateLogContext
1137 __init__(IMP::CreateLogContext self, std::string fname) -> CreateLogContext
1138 __init__(IMP::CreateLogContext self) -> CreateLogContext
1139 __init__(IMP::CreateLogContext self, char const * fname, Object object=None) -> CreateLogContext
1140 __init__(IMP::CreateLogContext self, char const * fname) -> CreateLogContext
1142 this = _IMP_kernel.new_CreateLogContext(*args)
1144 self.this.append(this)
1148 def set(self, fname, object=None):
1150 set(CreateLogContext self, char const * fname, Object object=None)
1151 set(CreateLogContext self, char const * fname)
1153 return _IMP_kernel.CreateLogContext_set(self, fname, object)
1157 """reset(CreateLogContext self)"""
1158 return _IMP_kernel.CreateLogContext_reset(self)
1160 __swig_destroy__ = _IMP_kernel.delete_CreateLogContext
1161 __del__ =
lambda self:
None
1163 def show(self, *args):
1165 show(CreateLogContext self, _ostream out)
1166 show(CreateLogContext self)
1168 return _IMP_kernel.CreateLogContext_show(self, *args)
1171 def __enter__(self):
1173 def __exit__(self, exc_type, exc_val, exc_tb):
1179 """__str__(CreateLogContext self) -> std::string"""
1180 return _IMP_kernel.CreateLogContext___str__(self)
1184 """__repr__(CreateLogContext self) -> std::string"""
1185 return _IMP_kernel.CreateLogContext___repr__(self)
1187 CreateLogContext_swigregister = _IMP_kernel.CreateLogContext_swigregister
1188 CreateLogContext_swigregister(CreateLogContext)
1190 class SetCheckState(_RAII):
1191 """Proxy of C++ IMP::SetCheckState class."""
1193 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
1196 """reset(SetCheckState self)"""
1197 return _IMP_kernel.SetCheckState_reset(self)
1199 __swig_destroy__ = _IMP_kernel.delete_SetCheckState
1200 __del__ =
lambda self:
None
1202 def show(self, *args):
1204 show(SetCheckState self, _ostream out)
1205 show(SetCheckState self)
1207 return _IMP_kernel.SetCheckState_show(self, *args)
1210 def __init__(self, *args):
1212 __init__(IMP::SetCheckState self) -> SetCheckState
1213 __init__(IMP::SetCheckState self, Object o, IMP::CheckLevel l) -> SetCheckState
1214 __init__(IMP::SetCheckState self, IMP::CheckLevel l) -> SetCheckState
1216 this = _IMP_kernel.new_SetCheckState(*args)
1218 self.this.append(this)
1222 def set(self, *args):
1224 set(SetCheckState self, Object o, IMP::CheckLevel l)
1225 set(SetCheckState self, IMP::CheckLevel l)
1227 return _IMP_kernel.SetCheckState_set(self, *args)
1230 def __enter__(self):
1232 def __exit__(self, exc_type, exc_val, exc_tb):
1238 """__str__(SetCheckState self) -> std::string"""
1239 return _IMP_kernel.SetCheckState___str__(self)
1243 """__repr__(SetCheckState self) -> std::string"""
1244 return _IMP_kernel.SetCheckState___repr__(self)
1246 SetCheckState_swigregister = _IMP_kernel.SetCheckState_swigregister
1247 SetCheckState_swigregister(SetCheckState)
1251 """get_unique_name(std::string templ) -> std::string"""
1252 return _IMP_kernel.get_unique_name(templ)
1253 class _Protection(object):
1254 """Proxy of C++ IMP::internal::_Protection class."""
1256 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
1258 def __init__(self, *args, **kwargs):
1259 raise AttributeError(
"No constructor defined")
1261 def show(self, *args):
1263 show(_Protection self, _ostream out)
1264 show(_Protection self)
1266 return _IMP_kernel._Protection_show(self, *args)
1270 """__str__(_Protection self) -> std::string"""
1271 return _IMP_kernel._Protection___str__(self)
1275 """__repr__(_Protection self) -> std::string"""
1276 return _IMP_kernel._Protection___repr__(self)
1278 __swig_destroy__ = _IMP_kernel.delete__Protection
1279 __del__ =
lambda self:
None
1280 _Protection_swigregister = _IMP_kernel._Protection_swigregister
1281 _Protection_swigregister(_Protection)
1286 return _IMP_kernel._test_log()
1288 def _test_intranges(ips):
1289 """_test_intranges(IMP::IntRanges const & ips) -> int"""
1290 return _IMP_kernel._test_intranges(ips)
1292 def _test_intrange(*args):
1294 _test_intrange(IMP::IntRange const & ips) -> IMP::IntRange
1295 _test_intrange() -> IMP::IntRange
1297 return _IMP_kernel._test_intrange(*args)
1300 """_test_ifile(TextInput a) -> std::string"""
1301 return _IMP_kernel._test_ifile(a)
1304 """_test_ofile(TextOutput a) -> std::string"""
1305 return _IMP_kernel._test_ofile(a)
1307 def _test_ifile_overloaded(*args):
1309 _test_ifile_overloaded(TextInput a, int i) -> std::string
1310 _test_ifile_overloaded(TextInput a, std::string st) -> std::string
1312 return _IMP_kernel._test_ifile_overloaded(*args)
1314 def _test_ofile_overloaded(*args):
1316 _test_ofile_overloaded(TextOutput a, int i) -> std::string
1317 _test_ofile_overloaded(TextOutput a, std::string st) -> std::string
1319 return _IMP_kernel._test_ofile_overloaded(*args)
1320 class _TestValue(object):
1321 """Proxy of C++ IMP::internal::_TestValue class."""
1323 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
1325 def __init__(self, i):
1326 """__init__(IMP::internal::_TestValue self, int i) -> _TestValue"""
1327 this = _IMP_kernel.new__TestValue(i)
1329 self.this.append(this)
1333 def show(self, *args):
1335 show(_TestValue self, _ostream out)
1336 show(_TestValue self)
1338 return _IMP_kernel._TestValue_show(self, *args)
1341 def __cmp__(self, o):
1342 """__cmp__(_TestValue self, _TestValue o) -> int"""
1343 return _IMP_kernel._TestValue___cmp__(self, o)
1346 def __eq__(self, o):
1347 """__eq__(_TestValue self, _TestValue o) -> bool"""
1348 return _IMP_kernel._TestValue___eq__(self, o)
1351 def __ne__(self, o):
1352 """__ne__(_TestValue self, _TestValue o) -> bool"""
1353 return _IMP_kernel._TestValue___ne__(self, o)
1356 def __lt__(self, o):
1357 """__lt__(_TestValue self, _TestValue o) -> bool"""
1358 return _IMP_kernel._TestValue___lt__(self, o)
1361 def __gt__(self, o):
1362 """__gt__(_TestValue self, _TestValue o) -> bool"""
1363 return _IMP_kernel._TestValue___gt__(self, o)
1366 def __ge__(self, o):
1367 """__ge__(_TestValue self, _TestValue o) -> bool"""
1368 return _IMP_kernel._TestValue___ge__(self, o)
1371 def __le__(self, o):
1372 """__le__(_TestValue self, _TestValue o) -> bool"""
1373 return _IMP_kernel._TestValue___le__(self, o)
1377 """get(_TestValue self) -> int"""
1378 return _IMP_kernel._TestValue_get(self)
1381 def get_float(self):
1382 """get_float(_TestValue self) -> float const &"""
1383 return _IMP_kernel._TestValue_get_float(self)
1386 def get_double(self):
1387 """get_double(_TestValue self) -> double const &"""
1388 return _IMP_kernel._TestValue_get_double(self)
1391 def get_Float(self):
1392 """get_Float(_TestValue self) -> IMP::Float const &"""
1393 return _IMP_kernel._TestValue_get_Float(self)
1397 """get_int(_TestValue self) -> int const &"""
1398 return _IMP_kernel._TestValue_get_int(self)
1402 """get_Int(_TestValue self) -> IMP::Int const &"""
1403 return _IMP_kernel._TestValue_get_Int(self)
1406 def get_string(self):
1407 """get_string(_TestValue self) -> std::string const &"""
1408 return _IMP_kernel._TestValue_get_string(self)
1411 def get_String(self):
1412 """get_String(_TestValue self) -> IMP::String const &"""
1413 return _IMP_kernel._TestValue_get_String(self)
1417 """__str__(_TestValue self) -> std::string"""
1418 return _IMP_kernel._TestValue___str__(self)
1422 """__repr__(_TestValue self) -> std::string"""
1423 return _IMP_kernel._TestValue___repr__(self)
1425 __swig_destroy__ = _IMP_kernel.delete__TestValue
1426 __del__ =
lambda self:
None
1427 _TestValue_swigregister = _IMP_kernel._TestValue_swigregister
1428 _TestValue_swigregister(_TestValue)
1431 def _pass_plain_pair(p):
1432 """_pass_plain_pair(IMP::FloatPair p) -> IMP::FloatPair"""
1433 return _IMP_kernel._pass_plain_pair(p)
1435 def _pass_overloaded_strings(*args):
1437 _pass_overloaded_strings(IMP::Strings const & a, int arg2) -> IMP::Strings
1438 _pass_overloaded_strings(IMP::Strings const & a) -> IMP::Strings
1440 return _IMP_kernel._pass_overloaded_strings(*args)
1443 """_pass_pair(IMP::DerivativePair const & p) -> IMP::DerivativePair"""
1444 return _IMP_kernel._pass_pair(p)
1446 def _pass_floats(input):
1447 """_pass_floats(IMP::Floats const & input) -> IMP::Floats"""
1448 return _IMP_kernel._pass_floats(input)
1450 def _pass_ints(input):
1451 """_pass_ints(IMP::Ints input) -> IMP::Ints"""
1452 return _IMP_kernel._pass_ints(input)
1454 def _pass_ints_list(input):
1455 """_pass_ints_list(IMP::IntsList const & input) -> IMP::IntsList"""
1456 return _IMP_kernel._pass_ints_list(input)
1458 def _pass_ints_lists(input):
1459 """_pass_ints_lists(IMP::IntsLists const & input) -> IMP::IntsLists"""
1460 return _IMP_kernel._pass_ints_lists(input)
1462 def _pass_strings(input):
1463 """_pass_strings(IMP::Strings const & input) -> IMP::Strings const &"""
1464 return _IMP_kernel._pass_strings(input)
1465 class _TestObject(Object):
1466 """Proxy of C++ IMP::internal::_TestObject class."""
1468 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
1471 """__init__(IMP::internal::_TestObject self) -> _TestObject"""
1472 this = _IMP_kernel.new__TestObject()
1474 self.this.append(this)
1478 def get_version_info(self):
1479 """get_version_info(_TestObject self) -> VersionInfo"""
1480 return _IMP_kernel._TestObject_get_version_info(self)
1484 """__str__(_TestObject self) -> std::string"""
1485 return _IMP_kernel._TestObject___str__(self)
1489 """__repr__(_TestObject self) -> std::string"""
1490 return _IMP_kernel._TestObject___repr__(self)
1495 return _object_cast_to__TestObject(o)
1497 _TestObject_swigregister = _IMP_kernel._TestObject_swigregister
1498 _TestObject_swigregister(_TestObject)
1502 """get_live_object_names() -> IMP::Strings"""
1503 return _IMP_kernel.get_live_object_names()
1506 """get_live_objects() -> IMP::Objects"""
1507 return _IMP_kernel.get_live_objects()
1510 """set_show_leaked_objects(bool tf)"""
1511 return _IMP_kernel.set_show_leaked_objects(tf)
1514 """set_deprecation_warnings(bool tf)"""
1515 return _IMP_kernel.set_deprecation_warnings(tf)
1518 """set_deprecation_exceptions(bool tf)"""
1519 return _IMP_kernel.set_deprecation_exceptions(tf)
1522 """get_deprecation_exceptions() -> bool"""
1523 return _IMP_kernel.get_deprecation_exceptions()
1526 """handle_use_deprecated(std::string message)"""
1527 return _IMP_kernel.handle_use_deprecated(message)
1530 """get_number_of_threads() -> unsigned int"""
1531 return _IMP_kernel.get_number_of_threads()
1534 """set_number_of_threads(unsigned int n)"""
1535 return _IMP_kernel.set_number_of_threads(n)
1536 class SetNumberOfThreads(_RAII):
1537 """Proxy of C++ IMP::SetNumberOfThreads class."""
1539 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
1541 def __init__(self, *args):
1543 __init__(IMP::SetNumberOfThreads self) -> SetNumberOfThreads
1544 __init__(IMP::SetNumberOfThreads self, unsigned int n) -> SetNumberOfThreads
1546 this = _IMP_kernel.new_SetNumberOfThreads(*args)
1548 self.this.append(this)
1553 """set(SetNumberOfThreads self, unsigned int n)"""
1554 return _IMP_kernel.SetNumberOfThreads_set(self, n)
1558 """reset(SetNumberOfThreads self)"""
1559 return _IMP_kernel.SetNumberOfThreads_reset(self)
1561 __swig_destroy__ = _IMP_kernel.delete_SetNumberOfThreads
1562 __del__ =
lambda self:
None
1564 def show(self, *args):
1566 show(SetNumberOfThreads self, _ostream out)
1567 show(SetNumberOfThreads self)
1569 return _IMP_kernel.SetNumberOfThreads_show(self, *args)
1572 def __enter__(self):
1574 def __exit__(self, exc_type, exc_val, exc_tb):
1580 """__str__(SetNumberOfThreads self) -> std::string"""
1581 return _IMP_kernel.SetNumberOfThreads___str__(self)
1585 """__repr__(SetNumberOfThreads self) -> std::string"""
1586 return _IMP_kernel.SetNumberOfThreads___repr__(self)
1588 SetNumberOfThreads_swigregister = _IMP_kernel.SetNumberOfThreads_swigregister
1589 SetNumberOfThreads_swigregister(SetNumberOfThreads)
1593 """clear_statistics()"""
1594 return _IMP_kernel.clear_statistics()
1597 """show_timings(TextOutput out)"""
1598 return _IMP_kernel.show_timings(out)
1600 """Proxy of C++ IMP::Timer class."""
1602 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
1603 __repr__ = _swig_repr
1605 def __init__(self, *args):
1607 __init__(IMP::Timer self, Object object, std::string const & operation) -> Timer
1608 __init__(IMP::Timer self, Object object, char const * operation) -> Timer
1609 __init__(IMP::Timer self, std::string operation) -> Timer
1611 this = _IMP_kernel.new_Timer(*args)
1613 self.this.append(this)
1616 __swig_destroy__ = _IMP_kernel.delete_Timer
1617 __del__ =
lambda self:
None
1618 Timer_swigregister = _IMP_kernel.Timer_swigregister
1619 Timer_swigregister(Timer)
1623 """set_statistics_level(IMP::StatisticsLevel l)"""
1624 return _IMP_kernel.set_statistics_level(l)
1627 i_m_p=
"IMP_MODULE_PATH"
1628 if i_m_p
in os.environ.keys():
1629 __path__.insert(0, os.environ[i_m_p])
1631 def _forward_add_attribute(self, name, value, opt=None):
1633 self.get_particle().add_attribute(name, value, opt)
1635 self.get_particle().add_attribute(name, value)
1636 def _forward_get_value(self, name):
1637 self.get_particle().get_value(name)
1638 def _forward_set_value(self, name, value):
1639 self.get_particle().set_value(name, value)
1645 _object_types.append(
"Constraint")
1648 def _object_cast_to_Constraint(o):
1649 """_object_cast_to_Constraint(Object o) -> Constraint"""
1650 return _IMP_kernel._object_cast_to_Constraint(o)
1652 _object_types.append(
"Undecorator")
1655 def _object_cast_to_Undecorator(o):
1656 """_object_cast_to_Undecorator(Object o) -> Undecorator"""
1657 return _IMP_kernel._object_cast_to_Undecorator(o)
1659 _object_types.append(
"Container")
1662 def _object_cast_to_Container(o):
1663 """_object_cast_to_Container(Object o) -> Container"""
1664 return _IMP_kernel._object_cast_to_Container(o)
1666 _object_types.append(
"Optimizer")
1669 def _object_cast_to_Optimizer(o):
1670 """_object_cast_to_Optimizer(Object o) -> Optimizer"""
1671 return _IMP_kernel._object_cast_to_Optimizer(o)
1673 _object_types.append(
"AttributeOptimizer")
1676 def _object_cast_to_AttributeOptimizer(o):
1677 """_object_cast_to_AttributeOptimizer(Object o) -> AttributeOptimizer"""
1678 return _IMP_kernel._object_cast_to_AttributeOptimizer(o)
1680 _object_types.append(
"OptimizerState")
1683 def _object_cast_to_OptimizerState(o):
1684 """_object_cast_to_OptimizerState(Object o) -> OptimizerState"""
1685 return _IMP_kernel._object_cast_to_OptimizerState(o)
1687 _object_types.append(
"PairContainer")
1690 def _object_cast_to_PairContainer(o):
1691 """_object_cast_to_PairContainer(Object o) -> PairContainer"""
1692 return _IMP_kernel._object_cast_to_PairContainer(o)
1694 _object_types.append(
"PairModifier")
1697 def _object_cast_to_PairModifier(o):
1698 """_object_cast_to_PairModifier(Object o) -> PairModifier"""
1699 return _IMP_kernel._object_cast_to_PairModifier(o)
1701 _object_types.append(
"PairScore")
1704 def _object_cast_to_PairScore(o):
1705 """_object_cast_to_PairScore(Object o) -> PairScore"""
1706 return _IMP_kernel._object_cast_to_PairScore(o)
1708 _object_types.append(
"QuadContainer")
1711 def _object_cast_to_QuadContainer(o):
1712 """_object_cast_to_QuadContainer(Object o) -> QuadContainer"""
1713 return _IMP_kernel._object_cast_to_QuadContainer(o)
1715 _object_types.append(
"QuadModifier")
1718 def _object_cast_to_QuadModifier(o):
1719 """_object_cast_to_QuadModifier(Object o) -> QuadModifier"""
1720 return _IMP_kernel._object_cast_to_QuadModifier(o)
1722 _object_types.append(
"QuadScore")
1725 def _object_cast_to_QuadScore(o):
1726 """_object_cast_to_QuadScore(Object o) -> QuadScore"""
1727 return _IMP_kernel._object_cast_to_QuadScore(o)
1729 _object_types.append(
"Refiner")
1732 def _object_cast_to_Refiner(o):
1733 """_object_cast_to_Refiner(Object o) -> Refiner"""
1734 return _IMP_kernel._object_cast_to_Refiner(o)
1736 _object_types.append(
"Restraint")
1739 def _object_cast_to_Restraint(o):
1740 """_object_cast_to_Restraint(Object o) -> Restraint"""
1741 return _IMP_kernel._object_cast_to_Restraint(o)
1743 _object_types.append(
"Sampler")
1746 def _object_cast_to_Sampler(o):
1747 """_object_cast_to_Sampler(Object o) -> Sampler"""
1748 return _IMP_kernel._object_cast_to_Sampler(o)
1750 _object_types.append(
"ScoreState")
1753 def _object_cast_to_ScoreState(o):
1754 """_object_cast_to_ScoreState(Object o) -> ScoreState"""
1755 return _IMP_kernel._object_cast_to_ScoreState(o)
1757 _object_types.append(
"SingletonContainer")
1760 def _object_cast_to_SingletonContainer(o):
1761 """_object_cast_to_SingletonContainer(Object o) -> SingletonContainer"""
1762 return _IMP_kernel._object_cast_to_SingletonContainer(o)
1764 _object_types.append(
"SingletonModifier")
1767 def _object_cast_to_SingletonModifier(o):
1768 """_object_cast_to_SingletonModifier(Object o) -> SingletonModifier"""
1769 return _IMP_kernel._object_cast_to_SingletonModifier(o)
1771 _object_types.append(
"SingletonScore")
1774 def _object_cast_to_SingletonScore(o):
1775 """_object_cast_to_SingletonScore(Object o) -> SingletonScore"""
1776 return _IMP_kernel._object_cast_to_SingletonScore(o)
1778 _object_types.append(
"TripletContainer")
1781 def _object_cast_to_TripletContainer(o):
1782 """_object_cast_to_TripletContainer(Object o) -> TripletContainer"""
1783 return _IMP_kernel._object_cast_to_TripletContainer(o)
1785 _object_types.append(
"TripletModifier")
1788 def _object_cast_to_TripletModifier(o):
1789 """_object_cast_to_TripletModifier(Object o) -> TripletModifier"""
1790 return _IMP_kernel._object_cast_to_TripletModifier(o)
1792 _object_types.append(
"TripletScore")
1795 def _object_cast_to_TripletScore(o):
1796 """_object_cast_to_TripletScore(Object o) -> TripletScore"""
1797 return _IMP_kernel._object_cast_to_TripletScore(o)
1799 _object_types.append(
"UnaryFunction")
1802 def _object_cast_to_UnaryFunction(o):
1803 """_object_cast_to_UnaryFunction(Object o) -> UnaryFunction"""
1804 return _IMP_kernel._object_cast_to_UnaryFunction(o)
1806 _object_types.append(
"ConfigurationSet")
1809 def _object_cast_to_ConfigurationSet(o):
1810 """_object_cast_to_ConfigurationSet(Object o) -> ConfigurationSet"""
1811 return _IMP_kernel._object_cast_to_ConfigurationSet(o)
1813 _object_types.append(
"Configuration")
1816 def _object_cast_to_Configuration(o):
1817 """_object_cast_to_Configuration(Object o) -> Configuration"""
1818 return _IMP_kernel._object_cast_to_Configuration(o)
1820 _object_types.append(
"Model")
1823 def _object_cast_to_Model(o):
1824 """_object_cast_to_Model(Object o) -> Model"""
1825 return _IMP_kernel._object_cast_to_Model(o)
1827 _object_types.append(
"Particle")
1830 def _object_cast_to_Particle(o):
1831 """_object_cast_to_Particle(Object o) -> Particle"""
1832 return _IMP_kernel._object_cast_to_Particle(o)
1834 _object_types.append(
"RestraintSet")
1837 def _object_cast_to_RestraintSet(o):
1838 """_object_cast_to_RestraintSet(Object o) -> RestraintSet"""
1839 return _IMP_kernel._object_cast_to_RestraintSet(o)
1841 ParticlePairsTemp=list
1842 _plural_types.append(
"ParticlePairsTemp")
1843 _value_types.append(
"ParticlePair")
1846 ParticleTripletsTemp=list
1847 _plural_types.append(
"ParticleTripletsTemp")
1848 _value_types.append(
"ParticleTriplet")
1851 ParticleQuadsTemp=list
1852 _plural_types.append(
"ParticleQuadsTemp")
1853 _value_types.append(
"ParticleQuad")
1856 ParticleIndexPairs=list
1857 _plural_types.append(
"ParticleIndexPairs")
1858 _value_types.append(
"ParticleIndexPair")
1861 ParticleIndexTriplets=list
1862 _plural_types.append(
"ParticleIndexTriplets")
1863 _value_types.append(
"ParticleIndexTriplet")
1866 ParticleIndexQuads=list
1867 _plural_types.append(
"ParticleIndexQuads")
1868 _value_types.append(
"ParticleIndexQuad")
1871 _object_types.append(
"SingletonPredicate")
1874 def _object_cast_to_SingletonPredicate(o):
1875 """_object_cast_to_SingletonPredicate(Object o) -> SingletonPredicate"""
1876 return _IMP_kernel._object_cast_to_SingletonPredicate(o)
1878 _object_types.append(
"PairPredicate")
1881 def _object_cast_to_PairPredicate(o):
1882 """_object_cast_to_PairPredicate(Object o) -> PairPredicate"""
1883 return _IMP_kernel._object_cast_to_PairPredicate(o)
1885 _object_types.append(
"TripletPredicate")
1888 def _object_cast_to_TripletPredicate(o):
1889 """_object_cast_to_TripletPredicate(Object o) -> TripletPredicate"""
1890 return _IMP_kernel._object_cast_to_TripletPredicate(o)
1892 _object_types.append(
"QuadPredicate")
1895 def _object_cast_to_QuadPredicate(o):
1896 """_object_cast_to_QuadPredicate(Object o) -> QuadPredicate"""
1897 return _IMP_kernel._object_cast_to_QuadPredicate(o)
1899 _object_types.append(
"SaveToConfigurationSetOptimizerState")
1902 def _object_cast_to_SaveToConfigurationSetOptimizerState(o):
1903 """_object_cast_to_SaveToConfigurationSetOptimizerState(Object o) -> SaveToConfigurationSetOptimizerState"""
1904 return _IMP_kernel._object_cast_to_SaveToConfigurationSetOptimizerState(o)
1906 EvaluationStates=list
1907 _plural_types.append(
"EvaluationStates")
1908 _value_types.append(
"EvaluationState")
1911 ScoreAccumulators=list
1912 _plural_types.append(
"ScoreAccumulators")
1913 _value_types.append(
"ScoreAccumulator")
1916 ParticleIndexes=list
1917 _plural_types.append(
"ParticleIndexes")
1918 _value_types.append(
"ParticleIndex")
1922 _plural_types.append(
"FloatIndexes")
1923 _value_types.append(
"FloatIndex")
1927 _plural_types.append(
"FloatKeys")
1928 _value_types.append(
"FloatKey")
1932 _plural_types.append(
"IntKeys")
1933 _value_types.append(
"IntKey")
1937 _plural_types.append(
"StringKeys")
1938 _value_types.append(
"StringKey")
1941 ParticleIndexKeys=list
1942 _plural_types.append(
"ParticleIndexKeys")
1943 _value_types.append(
"ParticleIndexKey")
1946 ParticleIndexesKeys=list
1947 _plural_types.append(
"ParticleIndexesKeys")
1948 _value_types.append(
"ParticleIndexesKey")
1952 _plural_types.append(
"ObjectKeys")
1953 _value_types.append(
"ObjectKey")
1957 _plural_types.append(
"ModelKeys")
1958 _value_types.append(
"ModelKey")
1961 _raii_types.append(
"ScopedSetFloatAttribute")
1964 _object_types.append(
"ScoringFunction")
1967 def _object_cast_to_ScoringFunction(o):
1968 """_object_cast_to_ScoringFunction(Object o) -> ScoringFunction"""
1969 return _IMP_kernel._object_cast_to_ScoringFunction(o)
1971 _object_types.append(
"ModelObject")
1974 def _object_cast_to_ModelObject(o):
1975 """_object_cast_to_ModelObject(Object o) -> ModelObject"""
1976 return _IMP_kernel._object_cast_to_ModelObject(o)
1978 def _TrivialDecorators(l=[]):
1979 return [_TrivialDecorator(x)
for x
in l]
1980 _plural_types.append(
"_TrivialDecorators")
1983 _value_types.append(
"_TrivialDecorator")
1986 def _TrivialDerivedDecorators(l=[]):
1987 return [_TrivialDerivedDecorator(x)
for x
in l]
1988 _plural_types.append(
"_TrivialDerivedDecorators")
1991 _value_types.append(
"_TrivialDerivedDecorator")
1994 def _TrivialTraitsDecorators(l=[]):
1995 return [_TrivialTraitsDecorator(x)
for x
in l]
1996 _plural_types.append(
"_TrivialTraitsDecorators")
1999 _value_types.append(
"_TrivialTraitsDecorator")
2002 _object_types.append(
"_ConstRestraint")
2005 def _object_cast_to__ConstRestraint(o):
2006 """_object_cast_to__ConstRestraint(Object o) -> _ConstRestraint"""
2007 return _IMP_kernel._object_cast_to__ConstRestraint(o)
2009 _object_types.append(
"_ConstOptimizer")
2012 def _object_cast_to__ConstOptimizer(o):
2013 """_object_cast_to__ConstOptimizer(Object o) -> _ConstOptimizer"""
2014 return _IMP_kernel._object_cast_to__ConstOptimizer(o)
2016 """Proxy of C++ IMP::internal::BoostDigraph<(IMP::DependencyGraph,p.IMP::ModelObject,IMP::ShowDependencyGraphVertex)> class."""
2018 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
2019 __repr__ = _swig_repr
2022 """__init__(IMP::internal::BoostDigraph<(IMP::DependencyGraph,p.IMP::ModelObject,IMP::ShowDependencyGraphVertex)> self) -> DependencyGraph"""
2023 this = _IMP_kernel.new_DependencyGraph()
2025 self.this.append(this)
2029 def get_graph(self):
2030 """get_graph(DependencyGraph self) -> IMP::DependencyGraph const &"""
2031 return _IMP_kernel.DependencyGraph_get_graph(self)
2035 """get_vertices(DependencyGraph self) -> IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptors"""
2036 return _IMP_kernel.DependencyGraph_get_vertices(self)
2039 def get_vertex_name(self, i):
2040 """get_vertex_name(DependencyGraph self, IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptor i) -> ModelObject"""
2041 return _IMP_kernel.DependencyGraph_get_vertex_name(self, i)
2044 def get_in_neighbors(self, v):
2045 """get_in_neighbors(DependencyGraph self, IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptor v) -> IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptors"""
2046 return _IMP_kernel.DependencyGraph_get_in_neighbors(self, v)
2049 def get_out_neighbors(self, v):
2050 """get_out_neighbors(DependencyGraph self, IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptor v) -> IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptors"""
2051 return _IMP_kernel.DependencyGraph_get_out_neighbors(self, v)
2056 show_graphviz(DependencyGraph self, _ostream out)
2057 show_graphviz(DependencyGraph self)
2059 return _IMP_kernel.DependencyGraph_show_graphviz(self, *args)
2062 def get_graphviz_string(self):
2063 """get_graphviz_string(DependencyGraph self) -> std::string"""
2064 return _IMP_kernel.DependencyGraph_get_graphviz_string(self)
2067 def add_edge(self, v0, v1):
2068 """add_edge(DependencyGraph self, IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptor v0, IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptor v1)"""
2069 return _IMP_kernel.DependencyGraph_add_edge(self, v0, v1)
2072 def add_vertex(self, l):
2073 """add_vertex(DependencyGraph self, ModelObject l) -> IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptor"""
2074 return _IMP_kernel.DependencyGraph_add_vertex(self, l)
2077 def remove_vertex(self, l):
2078 """remove_vertex(DependencyGraph self, IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptor l)"""
2079 return _IMP_kernel.DependencyGraph_remove_vertex(self, l)
2081 __swig_destroy__ = _IMP_kernel.delete_DependencyGraph
2082 __del__ =
lambda self:
None
2083 DependencyGraph_swigregister = _IMP_kernel.DependencyGraph_swigregister
2084 DependencyGraph_swigregister(DependencyGraph)
2087 _value_types.append(
"DependencyGraph")
2090 """Proxy of C++ IMP::Key<(0,true)> class."""
2092 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
2094 def __init__(self, *args):
2096 __init__(IMP::Key<(0,true)> self) -> FloatKey
2097 __init__(IMP::Key<(0,true)> self, std::string c) -> FloatKey
2098 __init__(IMP::Key<(0,true)> self, unsigned int i) -> FloatKey
2100 this = _IMP_kernel.new_FloatKey(*args)
2102 self.this.append(this)
2107 """add_key(std::string sc) -> unsigned int"""
2108 return _IMP_kernel.FloatKey_add_key(sc)
2110 add_key = staticmethod(add_key)
2112 def get_key_exists(sc):
2113 """get_key_exists(std::string sc) -> bool"""
2114 return _IMP_kernel.FloatKey_get_key_exists(sc)
2116 get_key_exists = staticmethod(get_key_exists)
2118 def get_string(self):
2119 """get_string(FloatKey self) -> std::string const"""
2120 return _IMP_kernel.FloatKey_get_string(self)
2123 def __cmp__(self, o):
2124 """__cmp__(FloatKey self, FloatKey o) -> int"""
2125 return _IMP_kernel.FloatKey___cmp__(self, o)
2128 def __eq__(self, o):
2129 """__eq__(FloatKey self, FloatKey o) -> bool"""
2130 return _IMP_kernel.FloatKey___eq__(self, o)
2133 def __ne__(self, o):
2134 """__ne__(FloatKey self, FloatKey o) -> bool"""
2135 return _IMP_kernel.FloatKey___ne__(self, o)
2138 def __lt__(self, o):
2139 """__lt__(FloatKey self, FloatKey o) -> bool"""
2140 return _IMP_kernel.FloatKey___lt__(self, o)
2143 def __gt__(self, o):
2144 """__gt__(FloatKey self, FloatKey o) -> bool"""
2145 return _IMP_kernel.FloatKey___gt__(self, o)
2148 def __ge__(self, o):
2149 """__ge__(FloatKey self, FloatKey o) -> bool"""
2150 return _IMP_kernel.FloatKey___ge__(self, o)
2153 def __le__(self, o):
2154 """__le__(FloatKey self, FloatKey o) -> bool"""
2155 return _IMP_kernel.FloatKey___le__(self, o)
2159 """__hash__(FloatKey self) -> std::size_t"""
2160 return _IMP_kernel.FloatKey___hash__(self)
2163 def show(self, *args):
2165 show(FloatKey self, _ostream out)
2168 return _IMP_kernel.FloatKey_show(self, *args)
2171 def add_alias(old_key, new_name):
2172 """add_alias(FloatKey old_key, std::string new_name) -> FloatKey"""
2173 return _IMP_kernel.FloatKey_add_alias(old_key, new_name)
2175 add_alias = staticmethod(add_alias)
2178 """get_index(FloatKey self) -> unsigned int"""
2179 return _IMP_kernel.FloatKey_get_index(self)
2183 """show_all(_ostream out)"""
2184 return _IMP_kernel.FloatKey_show_all(out)
2186 show_all = staticmethod(show_all)
2188 def get_all_strings():
2189 """get_all_strings() -> IMP::Vector< std::string >"""
2190 return _IMP_kernel.FloatKey_get_all_strings()
2192 get_all_strings = staticmethod(get_all_strings)
2194 def get_number_unique():
2195 """get_number_unique() -> unsigned int"""
2196 return _IMP_kernel.FloatKey_get_number_unique()
2198 get_number_unique = staticmethod(get_number_unique)
2201 """__str__(FloatKey self) -> std::string"""
2202 return _IMP_kernel.FloatKey___str__(self)
2206 """__repr__(FloatKey self) -> std::string"""
2207 return _IMP_kernel.FloatKey___repr__(self)
2209 __swig_destroy__ = _IMP_kernel.delete_FloatKey
2210 __del__ =
lambda self:
None
2211 FloatKey_swigregister = _IMP_kernel.FloatKey_swigregister
2212 FloatKey_swigregister(FloatKey)
2214 def FloatKey_add_key(sc):
2215 """FloatKey_add_key(std::string sc) -> unsigned int"""
2216 return _IMP_kernel.FloatKey_add_key(sc)
2218 def FloatKey_get_key_exists(sc):
2219 """FloatKey_get_key_exists(std::string sc) -> bool"""
2220 return _IMP_kernel.FloatKey_get_key_exists(sc)
2222 def FloatKey_add_alias(old_key, new_name):
2223 """FloatKey_add_alias(FloatKey old_key, std::string new_name) -> FloatKey"""
2224 return _IMP_kernel.FloatKey_add_alias(old_key, new_name)
2226 def FloatKey_show_all(out):
2227 """FloatKey_show_all(_ostream out)"""
2228 return _IMP_kernel.FloatKey_show_all(out)
2230 def FloatKey_get_all_strings():
2231 """FloatKey_get_all_strings() -> IMP::Vector< std::string >"""
2232 return _IMP_kernel.FloatKey_get_all_strings()
2234 def FloatKey_get_number_unique():
2235 """FloatKey_get_number_unique() -> unsigned int"""
2236 return _IMP_kernel.FloatKey_get_number_unique()
2239 """Proxy of C++ IMP::Key<(1,true)> class."""
2241 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
2243 def __init__(self, *args):
2245 __init__(IMP::Key<(1,true)> self) -> IntKey
2246 __init__(IMP::Key<(1,true)> self, std::string c) -> IntKey
2247 __init__(IMP::Key<(1,true)> self, unsigned int i) -> IntKey
2249 this = _IMP_kernel.new_IntKey(*args)
2251 self.this.append(this)
2256 """add_key(std::string sc) -> unsigned int"""
2257 return _IMP_kernel.IntKey_add_key(sc)
2259 add_key = staticmethod(add_key)
2261 def get_key_exists(sc):
2262 """get_key_exists(std::string sc) -> bool"""
2263 return _IMP_kernel.IntKey_get_key_exists(sc)
2265 get_key_exists = staticmethod(get_key_exists)
2267 def get_string(self):
2268 """get_string(IntKey self) -> std::string const"""
2269 return _IMP_kernel.IntKey_get_string(self)
2272 def __cmp__(self, o):
2273 """__cmp__(IntKey self, IntKey o) -> int"""
2274 return _IMP_kernel.IntKey___cmp__(self, o)
2277 def __eq__(self, o):
2278 """__eq__(IntKey self, IntKey o) -> bool"""
2279 return _IMP_kernel.IntKey___eq__(self, o)
2282 def __ne__(self, o):
2283 """__ne__(IntKey self, IntKey o) -> bool"""
2284 return _IMP_kernel.IntKey___ne__(self, o)
2287 def __lt__(self, o):
2288 """__lt__(IntKey self, IntKey o) -> bool"""
2289 return _IMP_kernel.IntKey___lt__(self, o)
2292 def __gt__(self, o):
2293 """__gt__(IntKey self, IntKey o) -> bool"""
2294 return _IMP_kernel.IntKey___gt__(self, o)
2297 def __ge__(self, o):
2298 """__ge__(IntKey self, IntKey o) -> bool"""
2299 return _IMP_kernel.IntKey___ge__(self, o)
2302 def __le__(self, o):
2303 """__le__(IntKey self, IntKey o) -> bool"""
2304 return _IMP_kernel.IntKey___le__(self, o)
2308 """__hash__(IntKey self) -> std::size_t"""
2309 return _IMP_kernel.IntKey___hash__(self)
2312 def show(self, *args):
2314 show(IntKey self, _ostream out)
2317 return _IMP_kernel.IntKey_show(self, *args)
2320 def add_alias(old_key, new_name):
2321 """add_alias(IntKey old_key, std::string new_name) -> IntKey"""
2322 return _IMP_kernel.IntKey_add_alias(old_key, new_name)
2324 add_alias = staticmethod(add_alias)
2327 """get_index(IntKey self) -> unsigned int"""
2328 return _IMP_kernel.IntKey_get_index(self)
2332 """show_all(_ostream out)"""
2333 return _IMP_kernel.IntKey_show_all(out)
2335 show_all = staticmethod(show_all)
2337 def get_all_strings():
2338 """get_all_strings() -> IMP::Vector< std::string >"""
2339 return _IMP_kernel.IntKey_get_all_strings()
2341 get_all_strings = staticmethod(get_all_strings)
2343 def get_number_unique():
2344 """get_number_unique() -> unsigned int"""
2345 return _IMP_kernel.IntKey_get_number_unique()
2347 get_number_unique = staticmethod(get_number_unique)
2350 """__str__(IntKey self) -> std::string"""
2351 return _IMP_kernel.IntKey___str__(self)
2355 """__repr__(IntKey self) -> std::string"""
2356 return _IMP_kernel.IntKey___repr__(self)
2358 __swig_destroy__ = _IMP_kernel.delete_IntKey
2359 __del__ =
lambda self:
None
2360 IntKey_swigregister = _IMP_kernel.IntKey_swigregister
2361 IntKey_swigregister(IntKey)
2363 def IntKey_add_key(sc):
2364 """IntKey_add_key(std::string sc) -> unsigned int"""
2365 return _IMP_kernel.IntKey_add_key(sc)
2367 def IntKey_get_key_exists(sc):
2368 """IntKey_get_key_exists(std::string sc) -> bool"""
2369 return _IMP_kernel.IntKey_get_key_exists(sc)
2371 def IntKey_add_alias(old_key, new_name):
2372 """IntKey_add_alias(IntKey old_key, std::string new_name) -> IntKey"""
2373 return _IMP_kernel.IntKey_add_alias(old_key, new_name)
2375 def IntKey_show_all(out):
2376 """IntKey_show_all(_ostream out)"""
2377 return _IMP_kernel.IntKey_show_all(out)
2379 def IntKey_get_all_strings():
2380 """IntKey_get_all_strings() -> IMP::Vector< std::string >"""
2381 return _IMP_kernel.IntKey_get_all_strings()
2383 def IntKey_get_number_unique():
2384 """IntKey_get_number_unique() -> unsigned int"""
2385 return _IMP_kernel.IntKey_get_number_unique()
2388 """Proxy of C++ IMP::Key<(2,true)> class."""
2390 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
2392 def __init__(self, *args):
2394 __init__(IMP::Key<(2,true)> self) -> StringKey
2395 __init__(IMP::Key<(2,true)> self, std::string c) -> StringKey
2396 __init__(IMP::Key<(2,true)> self, unsigned int i) -> StringKey
2398 this = _IMP_kernel.new_StringKey(*args)
2400 self.this.append(this)
2405 """add_key(std::string sc) -> unsigned int"""
2406 return _IMP_kernel.StringKey_add_key(sc)
2408 add_key = staticmethod(add_key)
2410 def get_key_exists(sc):
2411 """get_key_exists(std::string sc) -> bool"""
2412 return _IMP_kernel.StringKey_get_key_exists(sc)
2414 get_key_exists = staticmethod(get_key_exists)
2416 def get_string(self):
2417 """get_string(StringKey self) -> std::string const"""
2418 return _IMP_kernel.StringKey_get_string(self)
2421 def __cmp__(self, o):
2422 """__cmp__(StringKey self, StringKey o) -> int"""
2423 return _IMP_kernel.StringKey___cmp__(self, o)
2426 def __eq__(self, o):
2427 """__eq__(StringKey self, StringKey o) -> bool"""
2428 return _IMP_kernel.StringKey___eq__(self, o)
2431 def __ne__(self, o):
2432 """__ne__(StringKey self, StringKey o) -> bool"""
2433 return _IMP_kernel.StringKey___ne__(self, o)
2436 def __lt__(self, o):
2437 """__lt__(StringKey self, StringKey o) -> bool"""
2438 return _IMP_kernel.StringKey___lt__(self, o)
2441 def __gt__(self, o):
2442 """__gt__(StringKey self, StringKey o) -> bool"""
2443 return _IMP_kernel.StringKey___gt__(self, o)
2446 def __ge__(self, o):
2447 """__ge__(StringKey self, StringKey o) -> bool"""
2448 return _IMP_kernel.StringKey___ge__(self, o)
2451 def __le__(self, o):
2452 """__le__(StringKey self, StringKey o) -> bool"""
2453 return _IMP_kernel.StringKey___le__(self, o)
2457 """__hash__(StringKey self) -> std::size_t"""
2458 return _IMP_kernel.StringKey___hash__(self)
2461 def show(self, *args):
2463 show(StringKey self, _ostream out)
2464 show(StringKey self)
2466 return _IMP_kernel.StringKey_show(self, *args)
2469 def add_alias(old_key, new_name):
2470 """add_alias(StringKey old_key, std::string new_name) -> StringKey"""
2471 return _IMP_kernel.StringKey_add_alias(old_key, new_name)
2473 add_alias = staticmethod(add_alias)
2476 """get_index(StringKey self) -> unsigned int"""
2477 return _IMP_kernel.StringKey_get_index(self)
2481 """show_all(_ostream out)"""
2482 return _IMP_kernel.StringKey_show_all(out)
2484 show_all = staticmethod(show_all)
2486 def get_all_strings():
2487 """get_all_strings() -> IMP::Vector< std::string >"""
2488 return _IMP_kernel.StringKey_get_all_strings()
2490 get_all_strings = staticmethod(get_all_strings)
2492 def get_number_unique():
2493 """get_number_unique() -> unsigned int"""
2494 return _IMP_kernel.StringKey_get_number_unique()
2496 get_number_unique = staticmethod(get_number_unique)
2499 """__str__(StringKey self) -> std::string"""
2500 return _IMP_kernel.StringKey___str__(self)
2504 """__repr__(StringKey self) -> std::string"""
2505 return _IMP_kernel.StringKey___repr__(self)
2507 __swig_destroy__ = _IMP_kernel.delete_StringKey
2508 __del__ =
lambda self:
None
2509 StringKey_swigregister = _IMP_kernel.StringKey_swigregister
2510 StringKey_swigregister(StringKey)
2512 def StringKey_add_key(sc):
2513 """StringKey_add_key(std::string sc) -> unsigned int"""
2514 return _IMP_kernel.StringKey_add_key(sc)
2516 def StringKey_get_key_exists(sc):
2517 """StringKey_get_key_exists(std::string sc) -> bool"""
2518 return _IMP_kernel.StringKey_get_key_exists(sc)
2520 def StringKey_add_alias(old_key, new_name):
2521 """StringKey_add_alias(StringKey old_key, std::string new_name) -> StringKey"""
2522 return _IMP_kernel.StringKey_add_alias(old_key, new_name)
2524 def StringKey_show_all(out):
2525 """StringKey_show_all(_ostream out)"""
2526 return _IMP_kernel.StringKey_show_all(out)
2528 def StringKey_get_all_strings():
2529 """StringKey_get_all_strings() -> IMP::Vector< std::string >"""
2530 return _IMP_kernel.StringKey_get_all_strings()
2532 def StringKey_get_number_unique():
2533 """StringKey_get_number_unique() -> unsigned int"""
2534 return _IMP_kernel.StringKey_get_number_unique()
2537 """Proxy of C++ IMP::Key<(3,true)> class."""
2539 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
2541 def __init__(self, *args):
2543 __init__(IMP::Key<(3,true)> self) -> ParticleIndexKey
2544 __init__(IMP::Key<(3,true)> self, std::string c) -> ParticleIndexKey
2545 __init__(IMP::Key<(3,true)> self, unsigned int i) -> ParticleIndexKey
2547 this = _IMP_kernel.new_ParticleIndexKey(*args)
2549 self.this.append(this)
2554 """add_key(std::string sc) -> unsigned int"""
2555 return _IMP_kernel.ParticleIndexKey_add_key(sc)
2557 add_key = staticmethod(add_key)
2559 def get_key_exists(sc):
2560 """get_key_exists(std::string sc) -> bool"""
2561 return _IMP_kernel.ParticleIndexKey_get_key_exists(sc)
2563 get_key_exists = staticmethod(get_key_exists)
2565 def get_string(self):
2566 """get_string(ParticleIndexKey self) -> std::string const"""
2567 return _IMP_kernel.ParticleIndexKey_get_string(self)
2570 def __cmp__(self, o):
2571 """__cmp__(ParticleIndexKey self, ParticleIndexKey o) -> int"""
2572 return _IMP_kernel.ParticleIndexKey___cmp__(self, o)
2575 def __eq__(self, o):
2576 """__eq__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2577 return _IMP_kernel.ParticleIndexKey___eq__(self, o)
2580 def __ne__(self, o):
2581 """__ne__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2582 return _IMP_kernel.ParticleIndexKey___ne__(self, o)
2585 def __lt__(self, o):
2586 """__lt__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2587 return _IMP_kernel.ParticleIndexKey___lt__(self, o)
2590 def __gt__(self, o):
2591 """__gt__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2592 return _IMP_kernel.ParticleIndexKey___gt__(self, o)
2595 def __ge__(self, o):
2596 """__ge__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2597 return _IMP_kernel.ParticleIndexKey___ge__(self, o)
2600 def __le__(self, o):
2601 """__le__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2602 return _IMP_kernel.ParticleIndexKey___le__(self, o)
2606 """__hash__(ParticleIndexKey self) -> std::size_t"""
2607 return _IMP_kernel.ParticleIndexKey___hash__(self)
2610 def show(self, *args):
2612 show(ParticleIndexKey self, _ostream out)
2613 show(ParticleIndexKey self)
2615 return _IMP_kernel.ParticleIndexKey_show(self, *args)
2618 def add_alias(old_key, new_name):
2619 """add_alias(ParticleIndexKey old_key, std::string new_name) -> ParticleIndexKey"""
2620 return _IMP_kernel.ParticleIndexKey_add_alias(old_key, new_name)
2622 add_alias = staticmethod(add_alias)
2625 """get_index(ParticleIndexKey self) -> unsigned int"""
2626 return _IMP_kernel.ParticleIndexKey_get_index(self)
2630 """show_all(_ostream out)"""
2631 return _IMP_kernel.ParticleIndexKey_show_all(out)
2633 show_all = staticmethod(show_all)
2635 def get_all_strings():
2636 """get_all_strings() -> IMP::Vector< std::string >"""
2637 return _IMP_kernel.ParticleIndexKey_get_all_strings()
2639 get_all_strings = staticmethod(get_all_strings)
2641 def get_number_unique():
2642 """get_number_unique() -> unsigned int"""
2643 return _IMP_kernel.ParticleIndexKey_get_number_unique()
2645 get_number_unique = staticmethod(get_number_unique)
2648 """__str__(ParticleIndexKey self) -> std::string"""
2649 return _IMP_kernel.ParticleIndexKey___str__(self)
2653 """__repr__(ParticleIndexKey self) -> std::string"""
2654 return _IMP_kernel.ParticleIndexKey___repr__(self)
2656 __swig_destroy__ = _IMP_kernel.delete_ParticleIndexKey
2657 __del__ =
lambda self:
None
2658 ParticleIndexKey_swigregister = _IMP_kernel.ParticleIndexKey_swigregister
2659 ParticleIndexKey_swigregister(ParticleIndexKey)
2661 def ParticleIndexKey_add_key(sc):
2662 """ParticleIndexKey_add_key(std::string sc) -> unsigned int"""
2663 return _IMP_kernel.ParticleIndexKey_add_key(sc)
2665 def ParticleIndexKey_get_key_exists(sc):
2666 """ParticleIndexKey_get_key_exists(std::string sc) -> bool"""
2667 return _IMP_kernel.ParticleIndexKey_get_key_exists(sc)
2669 def ParticleIndexKey_add_alias(old_key, new_name):
2670 """ParticleIndexKey_add_alias(ParticleIndexKey old_key, std::string new_name) -> ParticleIndexKey"""
2671 return _IMP_kernel.ParticleIndexKey_add_alias(old_key, new_name)
2673 def ParticleIndexKey_show_all(out):
2674 """ParticleIndexKey_show_all(_ostream out)"""
2675 return _IMP_kernel.ParticleIndexKey_show_all(out)
2677 def ParticleIndexKey_get_all_strings():
2678 """ParticleIndexKey_get_all_strings() -> IMP::Vector< std::string >"""
2679 return _IMP_kernel.ParticleIndexKey_get_all_strings()
2681 def ParticleIndexKey_get_number_unique():
2682 """ParticleIndexKey_get_number_unique() -> unsigned int"""
2683 return _IMP_kernel.ParticleIndexKey_get_number_unique()
2686 """Proxy of C++ IMP::Key<(4,true)> class."""
2688 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
2690 def __init__(self, *args):
2692 __init__(IMP::Key<(4,true)> self) -> ObjectKey
2693 __init__(IMP::Key<(4,true)> self, std::string c) -> ObjectKey
2694 __init__(IMP::Key<(4,true)> self, unsigned int i) -> ObjectKey
2696 this = _IMP_kernel.new_ObjectKey(*args)
2698 self.this.append(this)
2703 """add_key(std::string sc) -> unsigned int"""
2704 return _IMP_kernel.ObjectKey_add_key(sc)
2706 add_key = staticmethod(add_key)
2708 def get_key_exists(sc):
2709 """get_key_exists(std::string sc) -> bool"""
2710 return _IMP_kernel.ObjectKey_get_key_exists(sc)
2712 get_key_exists = staticmethod(get_key_exists)
2714 def get_string(self):
2715 """get_string(ObjectKey self) -> std::string const"""
2716 return _IMP_kernel.ObjectKey_get_string(self)
2719 def __cmp__(self, o):
2720 """__cmp__(ObjectKey self, ObjectKey o) -> int"""
2721 return _IMP_kernel.ObjectKey___cmp__(self, o)
2724 def __eq__(self, o):
2725 """__eq__(ObjectKey self, ObjectKey o) -> bool"""
2726 return _IMP_kernel.ObjectKey___eq__(self, o)
2729 def __ne__(self, o):
2730 """__ne__(ObjectKey self, ObjectKey o) -> bool"""
2731 return _IMP_kernel.ObjectKey___ne__(self, o)
2734 def __lt__(self, o):
2735 """__lt__(ObjectKey self, ObjectKey o) -> bool"""
2736 return _IMP_kernel.ObjectKey___lt__(self, o)
2739 def __gt__(self, o):
2740 """__gt__(ObjectKey self, ObjectKey o) -> bool"""
2741 return _IMP_kernel.ObjectKey___gt__(self, o)
2744 def __ge__(self, o):
2745 """__ge__(ObjectKey self, ObjectKey o) -> bool"""
2746 return _IMP_kernel.ObjectKey___ge__(self, o)
2749 def __le__(self, o):
2750 """__le__(ObjectKey self, ObjectKey o) -> bool"""
2751 return _IMP_kernel.ObjectKey___le__(self, o)
2755 """__hash__(ObjectKey self) -> std::size_t"""
2756 return _IMP_kernel.ObjectKey___hash__(self)
2759 def show(self, *args):
2761 show(ObjectKey self, _ostream out)
2762 show(ObjectKey self)
2764 return _IMP_kernel.ObjectKey_show(self, *args)
2767 def add_alias(old_key, new_name):
2768 """add_alias(ObjectKey old_key, std::string new_name) -> ObjectKey"""
2769 return _IMP_kernel.ObjectKey_add_alias(old_key, new_name)
2771 add_alias = staticmethod(add_alias)
2774 """get_index(ObjectKey self) -> unsigned int"""
2775 return _IMP_kernel.ObjectKey_get_index(self)
2779 """show_all(_ostream out)"""
2780 return _IMP_kernel.ObjectKey_show_all(out)
2782 show_all = staticmethod(show_all)
2784 def get_all_strings():
2785 """get_all_strings() -> IMP::Vector< std::string >"""
2786 return _IMP_kernel.ObjectKey_get_all_strings()
2788 get_all_strings = staticmethod(get_all_strings)
2790 def get_number_unique():
2791 """get_number_unique() -> unsigned int"""
2792 return _IMP_kernel.ObjectKey_get_number_unique()
2794 get_number_unique = staticmethod(get_number_unique)
2797 """__str__(ObjectKey self) -> std::string"""
2798 return _IMP_kernel.ObjectKey___str__(self)
2802 """__repr__(ObjectKey self) -> std::string"""
2803 return _IMP_kernel.ObjectKey___repr__(self)
2805 __swig_destroy__ = _IMP_kernel.delete_ObjectKey
2806 __del__ =
lambda self:
None
2807 ObjectKey_swigregister = _IMP_kernel.ObjectKey_swigregister
2808 ObjectKey_swigregister(ObjectKey)
2810 def ObjectKey_add_key(sc):
2811 """ObjectKey_add_key(std::string sc) -> unsigned int"""
2812 return _IMP_kernel.ObjectKey_add_key(sc)
2814 def ObjectKey_get_key_exists(sc):
2815 """ObjectKey_get_key_exists(std::string sc) -> bool"""
2816 return _IMP_kernel.ObjectKey_get_key_exists(sc)
2818 def ObjectKey_add_alias(old_key, new_name):
2819 """ObjectKey_add_alias(ObjectKey old_key, std::string new_name) -> ObjectKey"""
2820 return _IMP_kernel.ObjectKey_add_alias(old_key, new_name)
2822 def ObjectKey_show_all(out):
2823 """ObjectKey_show_all(_ostream out)"""
2824 return _IMP_kernel.ObjectKey_show_all(out)
2826 def ObjectKey_get_all_strings():
2827 """ObjectKey_get_all_strings() -> IMP::Vector< std::string >"""
2828 return _IMP_kernel.ObjectKey_get_all_strings()
2830 def ObjectKey_get_number_unique():
2831 """ObjectKey_get_number_unique() -> unsigned int"""
2832 return _IMP_kernel.ObjectKey_get_number_unique()
2835 """Proxy of C++ IMP::Key<(6,true)> class."""
2837 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
2839 def __init__(self, *args):
2841 __init__(IMP::Key<(6,true)> self) -> ParticleIndexesKey
2842 __init__(IMP::Key<(6,true)> self, std::string c) -> ParticleIndexesKey
2843 __init__(IMP::Key<(6,true)> self, unsigned int i) -> ParticleIndexesKey
2845 this = _IMP_kernel.new_ParticleIndexesKey(*args)
2847 self.this.append(this)
2852 """add_key(std::string sc) -> unsigned int"""
2853 return _IMP_kernel.ParticleIndexesKey_add_key(sc)
2855 add_key = staticmethod(add_key)
2857 def get_key_exists(sc):
2858 """get_key_exists(std::string sc) -> bool"""
2859 return _IMP_kernel.ParticleIndexesKey_get_key_exists(sc)
2861 get_key_exists = staticmethod(get_key_exists)
2863 def get_string(self):
2864 """get_string(ParticleIndexesKey self) -> std::string const"""
2865 return _IMP_kernel.ParticleIndexesKey_get_string(self)
2868 def __cmp__(self, o):
2869 """__cmp__(ParticleIndexesKey self, ParticleIndexesKey o) -> int"""
2870 return _IMP_kernel.ParticleIndexesKey___cmp__(self, o)
2873 def __eq__(self, o):
2874 """__eq__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
2875 return _IMP_kernel.ParticleIndexesKey___eq__(self, o)
2878 def __ne__(self, o):
2879 """__ne__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
2880 return _IMP_kernel.ParticleIndexesKey___ne__(self, o)
2883 def __lt__(self, o):
2884 """__lt__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
2885 return _IMP_kernel.ParticleIndexesKey___lt__(self, o)
2888 def __gt__(self, o):
2889 """__gt__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
2890 return _IMP_kernel.ParticleIndexesKey___gt__(self, o)
2893 def __ge__(self, o):
2894 """__ge__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
2895 return _IMP_kernel.ParticleIndexesKey___ge__(self, o)
2898 def __le__(self, o):
2899 """__le__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
2900 return _IMP_kernel.ParticleIndexesKey___le__(self, o)
2904 """__hash__(ParticleIndexesKey self) -> std::size_t"""
2905 return _IMP_kernel.ParticleIndexesKey___hash__(self)
2908 def show(self, *args):
2910 show(ParticleIndexesKey self, _ostream out)
2911 show(ParticleIndexesKey self)
2913 return _IMP_kernel.ParticleIndexesKey_show(self, *args)
2916 def add_alias(old_key, new_name):
2917 """add_alias(ParticleIndexesKey old_key, std::string new_name) -> ParticleIndexesKey"""
2918 return _IMP_kernel.ParticleIndexesKey_add_alias(old_key, new_name)
2920 add_alias = staticmethod(add_alias)
2923 """get_index(ParticleIndexesKey self) -> unsigned int"""
2924 return _IMP_kernel.ParticleIndexesKey_get_index(self)
2928 """show_all(_ostream out)"""
2929 return _IMP_kernel.ParticleIndexesKey_show_all(out)
2931 show_all = staticmethod(show_all)
2933 def get_all_strings():
2934 """get_all_strings() -> IMP::Vector< std::string >"""
2935 return _IMP_kernel.ParticleIndexesKey_get_all_strings()
2937 get_all_strings = staticmethod(get_all_strings)
2939 def get_number_unique():
2940 """get_number_unique() -> unsigned int"""
2941 return _IMP_kernel.ParticleIndexesKey_get_number_unique()
2943 get_number_unique = staticmethod(get_number_unique)
2946 """__str__(ParticleIndexesKey self) -> std::string"""
2947 return _IMP_kernel.ParticleIndexesKey___str__(self)
2951 """__repr__(ParticleIndexesKey self) -> std::string"""
2952 return _IMP_kernel.ParticleIndexesKey___repr__(self)
2954 __swig_destroy__ = _IMP_kernel.delete_ParticleIndexesKey
2955 __del__ =
lambda self:
None
2956 ParticleIndexesKey_swigregister = _IMP_kernel.ParticleIndexesKey_swigregister
2957 ParticleIndexesKey_swigregister(ParticleIndexesKey)
2959 def ParticleIndexesKey_add_key(sc):
2960 """ParticleIndexesKey_add_key(std::string sc) -> unsigned int"""
2961 return _IMP_kernel.ParticleIndexesKey_add_key(sc)
2963 def ParticleIndexesKey_get_key_exists(sc):
2964 """ParticleIndexesKey_get_key_exists(std::string sc) -> bool"""
2965 return _IMP_kernel.ParticleIndexesKey_get_key_exists(sc)
2967 def ParticleIndexesKey_add_alias(old_key, new_name):
2968 """ParticleIndexesKey_add_alias(ParticleIndexesKey old_key, std::string new_name) -> ParticleIndexesKey"""
2969 return _IMP_kernel.ParticleIndexesKey_add_alias(old_key, new_name)
2971 def ParticleIndexesKey_show_all(out):
2972 """ParticleIndexesKey_show_all(_ostream out)"""
2973 return _IMP_kernel.ParticleIndexesKey_show_all(out)
2975 def ParticleIndexesKey_get_all_strings():
2976 """ParticleIndexesKey_get_all_strings() -> IMP::Vector< std::string >"""
2977 return _IMP_kernel.ParticleIndexesKey_get_all_strings()
2979 def ParticleIndexesKey_get_number_unique():
2980 """ParticleIndexesKey_get_number_unique() -> unsigned int"""
2981 return _IMP_kernel.ParticleIndexesKey_get_number_unique()
2984 """Proxy of C++ IMP::Key<(8,true)> class."""
2986 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
2988 def __init__(self, *args):
2990 __init__(IMP::Key<(8,true)> self) -> ModelKey
2991 __init__(IMP::Key<(8,true)> self, std::string c) -> ModelKey
2992 __init__(IMP::Key<(8,true)> self, unsigned int i) -> ModelKey
2994 this = _IMP_kernel.new_ModelKey(*args)
2996 self.this.append(this)
3001 """add_key(std::string sc) -> unsigned int"""
3002 return _IMP_kernel.ModelKey_add_key(sc)
3004 add_key = staticmethod(add_key)
3006 def get_key_exists(sc):
3007 """get_key_exists(std::string sc) -> bool"""
3008 return _IMP_kernel.ModelKey_get_key_exists(sc)
3010 get_key_exists = staticmethod(get_key_exists)
3012 def get_string(self):
3013 """get_string(ModelKey self) -> std::string const"""
3014 return _IMP_kernel.ModelKey_get_string(self)
3017 def __cmp__(self, o):
3018 """__cmp__(ModelKey self, ModelKey o) -> int"""
3019 return _IMP_kernel.ModelKey___cmp__(self, o)
3022 def __eq__(self, o):
3023 """__eq__(ModelKey self, ModelKey o) -> bool"""
3024 return _IMP_kernel.ModelKey___eq__(self, o)
3027 def __ne__(self, o):
3028 """__ne__(ModelKey self, ModelKey o) -> bool"""
3029 return _IMP_kernel.ModelKey___ne__(self, o)
3032 def __lt__(self, o):
3033 """__lt__(ModelKey self, ModelKey o) -> bool"""
3034 return _IMP_kernel.ModelKey___lt__(self, o)
3037 def __gt__(self, o):
3038 """__gt__(ModelKey self, ModelKey o) -> bool"""
3039 return _IMP_kernel.ModelKey___gt__(self, o)
3042 def __ge__(self, o):
3043 """__ge__(ModelKey self, ModelKey o) -> bool"""
3044 return _IMP_kernel.ModelKey___ge__(self, o)
3047 def __le__(self, o):
3048 """__le__(ModelKey self, ModelKey o) -> bool"""
3049 return _IMP_kernel.ModelKey___le__(self, o)
3053 """__hash__(ModelKey self) -> std::size_t"""
3054 return _IMP_kernel.ModelKey___hash__(self)
3057 def show(self, *args):
3059 show(ModelKey self, _ostream out)
3062 return _IMP_kernel.ModelKey_show(self, *args)
3065 def add_alias(old_key, new_name):
3066 """add_alias(ModelKey old_key, std::string new_name) -> ModelKey"""
3067 return _IMP_kernel.ModelKey_add_alias(old_key, new_name)
3069 add_alias = staticmethod(add_alias)
3072 """get_index(ModelKey self) -> unsigned int"""
3073 return _IMP_kernel.ModelKey_get_index(self)
3077 """show_all(_ostream out)"""
3078 return _IMP_kernel.ModelKey_show_all(out)
3080 show_all = staticmethod(show_all)
3082 def get_all_strings():
3083 """get_all_strings() -> IMP::Vector< std::string >"""
3084 return _IMP_kernel.ModelKey_get_all_strings()
3086 get_all_strings = staticmethod(get_all_strings)
3088 def get_number_unique():
3089 """get_number_unique() -> unsigned int"""
3090 return _IMP_kernel.ModelKey_get_number_unique()
3092 get_number_unique = staticmethod(get_number_unique)
3095 """__str__(ModelKey self) -> std::string"""
3096 return _IMP_kernel.ModelKey___str__(self)
3100 """__repr__(ModelKey self) -> std::string"""
3101 return _IMP_kernel.ModelKey___repr__(self)
3103 __swig_destroy__ = _IMP_kernel.delete_ModelKey
3104 __del__ =
lambda self:
None
3105 ModelKey_swigregister = _IMP_kernel.ModelKey_swigregister
3106 ModelKey_swigregister(ModelKey)
3108 def ModelKey_add_key(sc):
3109 """ModelKey_add_key(std::string sc) -> unsigned int"""
3110 return _IMP_kernel.ModelKey_add_key(sc)
3112 def ModelKey_get_key_exists(sc):
3113 """ModelKey_get_key_exists(std::string sc) -> bool"""
3114 return _IMP_kernel.ModelKey_get_key_exists(sc)
3116 def ModelKey_add_alias(old_key, new_name):
3117 """ModelKey_add_alias(ModelKey old_key, std::string new_name) -> ModelKey"""
3118 return _IMP_kernel.ModelKey_add_alias(old_key, new_name)
3120 def ModelKey_show_all(out):
3121 """ModelKey_show_all(_ostream out)"""
3122 return _IMP_kernel.ModelKey_show_all(out)
3124 def ModelKey_get_all_strings():
3125 """ModelKey_get_all_strings() -> IMP::Vector< std::string >"""
3126 return _IMP_kernel.ModelKey_get_all_strings()
3128 def ModelKey_get_number_unique():
3129 """ModelKey_get_number_unique() -> unsigned int"""
3130 return _IMP_kernel.ModelKey_get_number_unique()
3133 """Proxy of C++ IMP::Index<(IMP::ParticleIndexTag)> class."""
3135 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3137 def __init__(self, *args):
3139 __init__(IMP::Index<(IMP::ParticleIndexTag)> self, int i) -> ParticleIndex
3140 __init__(IMP::Index<(IMP::ParticleIndexTag)> self) -> ParticleIndex
3142 this = _IMP_kernel.new_ParticleIndex(*args)
3144 self.this.append(this)
3149 """get_index(ParticleIndex self) -> int"""
3150 return _IMP_kernel.ParticleIndex_get_index(self)
3153 def __cmp__(self, o):
3154 """__cmp__(ParticleIndex self, ParticleIndex o) -> int"""
3155 return _IMP_kernel.ParticleIndex___cmp__(self, o)
3158 def __eq__(self, o):
3159 """__eq__(ParticleIndex self, ParticleIndex o) -> bool"""
3160 return _IMP_kernel.ParticleIndex___eq__(self, o)
3163 def __ne__(self, o):
3164 """__ne__(ParticleIndex self, ParticleIndex o) -> bool"""
3165 return _IMP_kernel.ParticleIndex___ne__(self, o)
3168 def __lt__(self, o):
3169 """__lt__(ParticleIndex self, ParticleIndex o) -> bool"""
3170 return _IMP_kernel.ParticleIndex___lt__(self, o)
3173 def __gt__(self, o):
3174 """__gt__(ParticleIndex self, ParticleIndex o) -> bool"""
3175 return _IMP_kernel.ParticleIndex___gt__(self, o)
3178 def __ge__(self, o):
3179 """__ge__(ParticleIndex self, ParticleIndex o) -> bool"""
3180 return _IMP_kernel.ParticleIndex___ge__(self, o)
3183 def __le__(self, o):
3184 """__le__(ParticleIndex self, ParticleIndex o) -> bool"""
3185 return _IMP_kernel.ParticleIndex___le__(self, o)
3188 def show(self, *args):
3190 show(ParticleIndex self, _ostream out)
3191 show(ParticleIndex self)
3193 return _IMP_kernel.ParticleIndex_show(self, *args)
3197 """__hash__(ParticleIndex self) -> std::size_t"""
3198 return _IMP_kernel.ParticleIndex___hash__(self)
3202 """__str__(ParticleIndex self) -> std::string"""
3203 return _IMP_kernel.ParticleIndex___str__(self)
3207 """__repr__(ParticleIndex self) -> std::string"""
3208 return _IMP_kernel.ParticleIndex___repr__(self)
3210 __swig_destroy__ = _IMP_kernel.delete_ParticleIndex
3211 __del__ =
lambda self:
None
3212 ParticleIndex_swigregister = _IMP_kernel.ParticleIndex_swigregister
3213 ParticleIndex_swigregister(ParticleIndex)
3223 class FloatIndex(_Value):
3224 """Proxy of C++ IMP::FloatIndex class."""
3226 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3228 def __init__(self, *args):
3230 __init__(IMP::FloatIndex self, ParticleIndex i0, FloatKey i1) -> FloatIndex
3231 __init__(IMP::FloatIndex self, ParticleIndex i0) -> FloatIndex
3232 __init__(IMP::FloatIndex self) -> FloatIndex
3234 this = _IMP_kernel.new_FloatIndex(*args)
3236 self.this.append(this)
3241 """__hash__(FloatIndex self) -> std::size_t"""
3242 return _IMP_kernel.FloatIndex___hash__(self)
3245 def show(self, *args):
3247 show(FloatIndex self, _ostream out)
3248 show(FloatIndex self)
3250 return _IMP_kernel.FloatIndex_show(self, *args)
3253 def __cmp__(self, o):
3254 """__cmp__(FloatIndex self, FloatIndex o) -> int"""
3255 return _IMP_kernel.FloatIndex___cmp__(self, o)
3258 def __eq__(self, o):
3259 """__eq__(FloatIndex self, FloatIndex o) -> bool"""
3260 return _IMP_kernel.FloatIndex___eq__(self, o)
3263 def __ne__(self, o):
3264 """__ne__(FloatIndex self, FloatIndex o) -> bool"""
3265 return _IMP_kernel.FloatIndex___ne__(self, o)
3268 def __lt__(self, o):
3269 """__lt__(FloatIndex self, FloatIndex o) -> bool"""
3270 return _IMP_kernel.FloatIndex___lt__(self, o)
3273 def __gt__(self, o):
3274 """__gt__(FloatIndex self, FloatIndex o) -> bool"""
3275 return _IMP_kernel.FloatIndex___gt__(self, o)
3278 def __ge__(self, o):
3279 """__ge__(FloatIndex self, FloatIndex o) -> bool"""
3280 return _IMP_kernel.FloatIndex___ge__(self, o)
3283 def __le__(self, o):
3284 """__le__(FloatIndex self, FloatIndex o) -> bool"""
3285 return _IMP_kernel.FloatIndex___le__(self, o)
3288 def get_particle(self):
3289 """get_particle(FloatIndex self) -> ParticleIndex const &"""
3290 return _IMP_kernel.FloatIndex_get_particle(self)
3293 def set_particle(self, v):
3294 """set_particle(FloatIndex self, ParticleIndex const & v)"""
3295 return _IMP_kernel.FloatIndex_set_particle(self, v)
3299 """get_key(FloatIndex self) -> FloatKey const &"""
3300 return _IMP_kernel.FloatIndex_get_key(self)
3303 def set_key(self, v):
3304 """set_key(FloatIndex self, FloatKey const & v)"""
3305 return _IMP_kernel.FloatIndex_set_key(self, v)
3309 """__str__(FloatIndex self) -> std::string"""
3310 return _IMP_kernel.FloatIndex___str__(self)
3314 """__repr__(FloatIndex self) -> std::string"""
3315 return _IMP_kernel.FloatIndex___repr__(self)
3317 __swig_destroy__ = _IMP_kernel.delete_FloatIndex
3318 __del__ =
lambda self:
None
3319 FloatIndex_swigregister = _IMP_kernel.FloatIndex_swigregister
3320 FloatIndex_swigregister(FloatIndex)
3322 class _ParticleIndexTag(object):
3323 """Proxy of C++ IMP::ParticleIndexTag class."""
3325 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3326 __repr__ = _swig_repr
3329 """__init__(IMP::ParticleIndexTag self) -> _ParticleIndexTag"""
3330 this = _IMP_kernel.new__ParticleIndexTag()
3332 self.this.append(this)
3335 __swig_destroy__ = _IMP_kernel.delete__ParticleIndexTag
3336 __del__ =
lambda self:
None
3337 _ParticleIndexTag_swigregister = _IMP_kernel._ParticleIndexTag_swigregister
3338 _ParticleIndexTag_swigregister(_ParticleIndexTag)
3340 class ModelObject(Object):
3341 """Proxy of C++ IMP::ModelObject class."""
3343 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3345 def __init__(self, m, name):
3346 """__init__(IMP::ModelObject self, Model m, std::string name) -> ModelObject"""
3347 if self.__class__ == ModelObject:
3351 this = _IMP_kernel.new_ModelObject(_self, m, name)
3353 self.this.append(this)
3357 if self.__class__ != ModelObject:
3358 _director_objects.register(self)
3362 __swig_destroy__ = _IMP_kernel.delete_ModelObject
3363 __del__ =
lambda self:
None
3365 def get_model(self):
3366 """get_model(ModelObject self) -> Model"""
3367 return _IMP_kernel.ModelObject_get_model(self)
3370 def get_inputs(self):
3371 """get_inputs(ModelObject self) -> IMP::ModelObjectsTemp"""
3372 return _IMP_kernel.ModelObject_get_inputs(self)
3375 def get_outputs(self):
3376 """get_outputs(ModelObject self) -> IMP::ModelObjectsTemp"""
3377 return _IMP_kernel.ModelObject_get_outputs(self)
3380 def get_interactions(self):
3381 """get_interactions(ModelObject self) -> IMP::ModelObjectsTemps"""
3382 return _IMP_kernel.ModelObject_get_interactions(self)
3385 def get_has_dependencies(self):
3386 """get_has_dependencies(ModelObject self) -> bool"""
3387 return _IMP_kernel.ModelObject_get_has_dependencies(self)
3390 def set_has_dependencies(self, tf):
3391 """set_has_dependencies(ModelObject self, bool tf)"""
3392 return _IMP_kernel.ModelObject_set_has_dependencies(self, tf)
3395 def set_has_required_score_states(self, tf):
3396 """set_has_required_score_states(ModelObject self, bool tf)"""
3397 return _IMP_kernel.ModelObject_set_has_required_score_states(self, tf)
3400 def get_has_required_score_states(self):
3401 """get_has_required_score_states(ModelObject self) -> bool"""
3402 return _IMP_kernel.ModelObject_get_has_required_score_states(self)
3406 """get_required_score_states(ModelObject self) -> IMP::ScoreStatesTemp const &"""
3407 return _IMP_kernel.ModelObject_get_required_score_states(self)
3410 def handle_set_has_required_score_states(self, arg0):
3411 """handle_set_has_required_score_states(ModelObject self, bool arg0)"""
3412 return _IMP_kernel.ModelObject_handle_set_has_required_score_states(self, arg0)
3415 def do_get_inputs(self):
3416 """do_get_inputs(ModelObject self) -> IMP::ModelObjectsTemp"""
3417 return _IMP_kernel.ModelObject_do_get_inputs(self)
3420 def do_get_outputs(self):
3421 """do_get_outputs(ModelObject self) -> IMP::ModelObjectsTemp"""
3422 return _IMP_kernel.ModelObject_do_get_outputs(self)
3425 def do_get_interactions(self):
3426 """do_get_interactions(ModelObject self) -> IMP::ModelObjectsTemps"""
3427 return _IMP_kernel.ModelObject_do_get_interactions(self)
3431 """__str__(ModelObject self) -> std::string"""
3432 return _IMP_kernel.ModelObject___str__(self)
3436 """__repr__(ModelObject self) -> std::string"""
3437 return _IMP_kernel.ModelObject___repr__(self)
3442 return _object_cast_to_ModelObject(o)
3445 def get_type_name(self):
3446 return self.__class__.__name__
3447 def do_show(self, out):
3449 def get_version_info(self):
3451 return VersionInfo(self.__module__,
3452 __import__(self.__module__).get_module_version())
3455 __import__(self.__module__).get_module_version())
3458 return _object_cast_to_ModelObject(o)
3460 def __disown__(self):
3462 _IMP_kernel.disown_ModelObject(self)
3463 return weakref_proxy(self)
3465 def do_destroy(self):
3466 """do_destroy(ModelObject self)"""
3467 return _IMP_kernel.ModelObject_do_destroy(self)
3469 ModelObject_swigregister = _IMP_kernel.ModelObject_swigregister
3470 ModelObject_swigregister(ModelObject)
3471 cvar = _IMP_kernel.cvar
3472 NO_MAX = cvar.NO_MAX
3473 BAD_SCORE = cvar.BAD_SCORE
3475 class _ParticleInputs(object):
3476 """Proxy of C++ IMP::ParticleInputs class."""
3478 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3480 def __init__(self, *args, **kwargs):
3481 raise AttributeError(
"No constructor defined - class is abstract")
3482 __repr__ = _swig_repr
3484 def get_inputs(self, m, pis):
3485 """get_inputs(_ParticleInputs self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
3486 return _IMP_kernel._ParticleInputs_get_inputs(self, m, pis)
3488 _ParticleInputs_swigregister = _IMP_kernel._ParticleInputs_swigregister
3489 _ParticleInputs_swigregister(_ParticleInputs)
3491 class _ParticleOutputs(object):
3492 """Proxy of C++ IMP::ParticleOutputs class."""
3494 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3496 def __init__(self, *args, **kwargs):
3497 raise AttributeError(
"No constructor defined - class is abstract")
3498 __repr__ = _swig_repr
3500 def get_outputs(self, m, pis):
3501 """get_outputs(_ParticleOutputs self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
3502 return _IMP_kernel._ParticleOutputs_get_outputs(self, m, pis)
3504 _ParticleOutputs_swigregister = _IMP_kernel._ParticleOutputs_swigregister
3505 _ParticleOutputs_swigregister(_ParticleOutputs)
3509 """get_input_particles(IMP::ModelObjectsTemp const & mos) -> IMP::ParticlesTemp"""
3510 return _IMP_kernel.get_input_particles(mos)
3513 """get_input_containers(IMP::ModelObjectsTemp const & mos) -> IMP::ContainersTemp"""
3514 return _IMP_kernel.get_input_containers(mos)
3517 """get_output_particles(IMP::ModelObjectsTemp const & mos) -> IMP::ParticlesTemp"""
3518 return _IMP_kernel.get_output_particles(mos)
3521 """get_output_containers(IMP::ModelObjectsTemp const & mos) -> IMP::ContainersTemp"""
3522 return _IMP_kernel.get_output_containers(mos)
3523 class DerivativeAccumulator(object):
3524 """Proxy of C++ IMP::DerivativeAccumulator class."""
3526 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3527 __repr__ = _swig_repr
3529 def __init__(self, *args):
3531 __init__(IMP::DerivativeAccumulator self, double weight=1.0) -> DerivativeAccumulator
3532 __init__(IMP::DerivativeAccumulator self) -> DerivativeAccumulator
3533 __init__(IMP::DerivativeAccumulator self, DerivativeAccumulator copy, double weight) -> DerivativeAccumulator
3535 this = _IMP_kernel.new_DerivativeAccumulator(*args)
3537 self.this.append(this)
3541 def __call__(self, value):
3542 """__call__(DerivativeAccumulator self, double const value) -> double"""
3543 return _IMP_kernel.DerivativeAccumulator___call__(self, value)
3546 def get_weight(self):
3547 """get_weight(DerivativeAccumulator self) -> double"""
3548 return _IMP_kernel.DerivativeAccumulator_get_weight(self)
3551 def show(self, *args):
3553 show(DerivativeAccumulator self, _ostream out)
3554 show(DerivativeAccumulator self)
3556 return _IMP_kernel.DerivativeAccumulator_show(self, *args)
3558 __swig_destroy__ = _IMP_kernel.delete_DerivativeAccumulator
3559 __del__ =
lambda self:
None
3560 DerivativeAccumulator_swigregister = _IMP_kernel.DerivativeAccumulator_swigregister
3561 DerivativeAccumulator_swigregister(DerivativeAccumulator)
3563 class EvaluationState(object):
3564 """Proxy of C++ IMP::EvaluationState class."""
3566 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3567 score = _swig_property(_IMP_kernel.EvaluationState_score_get, _IMP_kernel.EvaluationState_score_set)
3568 good = _swig_property(_IMP_kernel.EvaluationState_good_get, _IMP_kernel.EvaluationState_good_set)
3570 def __init__(self, *args):
3572 __init__(IMP::EvaluationState self, double oscore, bool ogood) -> EvaluationState
3573 __init__(IMP::EvaluationState self) -> EvaluationState
3575 this = _IMP_kernel.new_EvaluationState(*args)
3577 self.this.append(this)
3581 def show(self, *args):
3583 show(EvaluationState self, _ostream out)
3584 show(EvaluationState self)
3586 return _IMP_kernel.EvaluationState_show(self, *args)
3590 """__str__(EvaluationState self) -> std::string"""
3591 return _IMP_kernel.EvaluationState___str__(self)
3595 """__repr__(EvaluationState self) -> std::string"""
3596 return _IMP_kernel.EvaluationState___repr__(self)
3598 __swig_destroy__ = _IMP_kernel.delete_EvaluationState
3599 __del__ =
lambda self:
None
3600 EvaluationState_swigregister = _IMP_kernel.EvaluationState_swigregister
3601 EvaluationState_swigregister(EvaluationState)
3603 class ScoreAccumulator(_Value):
3604 """Proxy of C++ IMP::ScoreAccumulator class."""
3606 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3608 def __init__(self, *args):
3610 __init__(IMP::ScoreAccumulator self) -> ScoreAccumulator
3611 __init__(IMP::ScoreAccumulator self, ScoreAccumulator o, Restraint r) -> ScoreAccumulator
3612 __init__(IMP::ScoreAccumulator self, ScoreAccumulator o, double weight, double local_max) -> ScoreAccumulator
3614 this = _IMP_kernel.new_ScoreAccumulator(*args)
3616 self.this.append(this)
3620 def add_score(self, score):
3621 """add_score(ScoreAccumulator self, double score)"""
3622 return _IMP_kernel.ScoreAccumulator_add_score(self, score)
3625 def get_abort_evaluation(self):
3626 """get_abort_evaluation(ScoreAccumulator self) -> bool"""
3627 return _IMP_kernel.ScoreAccumulator_get_abort_evaluation(self)
3630 def get_is_evaluate_if_below(self):
3631 """get_is_evaluate_if_below(ScoreAccumulator self) -> bool"""
3632 return _IMP_kernel.ScoreAccumulator_get_is_evaluate_if_below(self)
3635 def get_is_evaluate_if_good(self):
3636 """get_is_evaluate_if_good(ScoreAccumulator self) -> bool"""
3637 return _IMP_kernel.ScoreAccumulator_get_is_evaluate_if_good(self)
3640 def get_maximum(self):
3641 """get_maximum(ScoreAccumulator self) -> double"""
3642 return _IMP_kernel.ScoreAccumulator_get_maximum(self)
3645 def get_derivative_accumulator(self):
3646 """get_derivative_accumulator(ScoreAccumulator self) -> DerivativeAccumulator"""
3647 return _IMP_kernel.ScoreAccumulator_get_derivative_accumulator(self)
3650 def show(self, *args):
3652 show(ScoreAccumulator self, _ostream out)
3653 show(ScoreAccumulator self)
3655 return _IMP_kernel.ScoreAccumulator_show(self, *args)
3659 """__str__(ScoreAccumulator self) -> std::string"""
3660 return _IMP_kernel.ScoreAccumulator___str__(self)
3664 """__repr__(ScoreAccumulator self) -> std::string"""
3665 return _IMP_kernel.ScoreAccumulator___repr__(self)
3667 __swig_destroy__ = _IMP_kernel.delete_ScoreAccumulator
3668 __del__ =
lambda self:
None
3669 ScoreAccumulator_swigregister = _IMP_kernel.ScoreAccumulator_swigregister
3670 ScoreAccumulator_swigregister(ScoreAccumulator)
3672 class ScoreState(ModelObject):
3673 """Proxy of C++ IMP::ScoreState class."""
3675 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3677 def __init__(self, m, name):
3678 """__init__(IMP::ScoreState self, Model m, std::string name) -> ScoreState"""
3679 if self.__class__ == ScoreState:
3683 this = _IMP_kernel.new_ScoreState(_self, m, name)
3685 self.this.append(this)
3689 if self.__class__ != ScoreState:
3690 _director_objects.register(self)
3695 def before_evaluate(self):
3696 """before_evaluate(ScoreState self)"""
3697 return _IMP_kernel.ScoreState_before_evaluate(self)
3700 def after_evaluate(self, accpt):
3701 """after_evaluate(ScoreState self, DerivativeAccumulator accpt)"""
3702 return _IMP_kernel.ScoreState_after_evaluate(self, accpt)
3705 def get_has_update_order(self):
3706 """get_has_update_order(ScoreState self) -> bool"""
3707 return _IMP_kernel.ScoreState_get_has_update_order(self)
3711 """get_update_order(ScoreState self) -> unsigned int"""
3712 return _IMP_kernel.ScoreState_get_update_order(self)
3715 def handle_set_has_required_score_states(self, tf):
3716 """handle_set_has_required_score_states(ScoreState self, bool tf)"""
3717 return _IMP_kernel.ScoreState_handle_set_has_required_score_states(self, tf)
3720 def do_before_evaluate(self):
3721 """do_before_evaluate(ScoreState self)"""
3722 return _IMP_kernel.ScoreState_do_before_evaluate(self)
3725 def do_after_evaluate(self, accpt):
3726 """do_after_evaluate(ScoreState self, DerivativeAccumulator accpt)"""
3727 return _IMP_kernel.ScoreState_do_after_evaluate(self, accpt)
3729 __swig_destroy__ = _IMP_kernel.delete_ScoreState
3730 __del__ =
lambda self:
None
3733 """__str__(ScoreState self) -> std::string"""
3734 return _IMP_kernel.ScoreState___str__(self)
3738 """__repr__(ScoreState self) -> std::string"""
3739 return _IMP_kernel.ScoreState___repr__(self)
3744 return _object_cast_to_ScoreState(o)
3747 def get_type_name(self):
3748 return self.__class__.__name__
3749 def do_show(self, out):
3751 def get_version_info(self):
3753 return VersionInfo(self.__module__,
3754 __import__(self.__module__).get_module_version())
3757 __import__(self.__module__).get_module_version())
3760 return _object_cast_to_ScoreState(o)
3762 def __disown__(self):
3764 _IMP_kernel.disown_ScoreState(self)
3765 return weakref_proxy(self)
3767 def do_destroy(self):
3768 """do_destroy(ScoreState self)"""
3769 return _IMP_kernel.ScoreState_do_destroy(self)
3772 def do_get_inputs(self):
3773 """do_get_inputs(ScoreState self) -> IMP::ModelObjectsTemp"""
3774 return _IMP_kernel.ScoreState_do_get_inputs(self)
3777 def do_get_outputs(self):
3778 """do_get_outputs(ScoreState self) -> IMP::ModelObjectsTemp"""
3779 return _IMP_kernel.ScoreState_do_get_outputs(self)
3782 def do_get_interactions(self):
3783 """do_get_interactions(ScoreState self) -> IMP::ModelObjectsTemps"""
3784 return _IMP_kernel.ScoreState_do_get_interactions(self)
3786 ScoreState_swigregister = _IMP_kernel.ScoreState_swigregister
3787 ScoreState_swigregister(ScoreState)
3791 """get_update_order(IMP::ScoreStatesTemp input) -> IMP::ScoreStatesTemp"""
3792 return _IMP_kernel.get_update_order(input)
3793 class Constraint(ScoreState):
3794 """Proxy of C++ IMP::Constraint class."""
3796 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3798 def __init__(self, *args):
3800 __init__(IMP::Constraint self, Model m, std::string name) -> Constraint
3801 __init__(IMP::Constraint self, Model m) -> Constraint
3803 if self.__class__ == Constraint:
3807 this = _IMP_kernel.new_Constraint(_self, *args)
3809 self.this.append(this)
3813 if self.__class__ != Constraint:
3814 _director_objects.register(self)
3819 def do_update_attributes(self):
3820 """do_update_attributes(Constraint self)"""
3821 return _IMP_kernel.Constraint_do_update_attributes(self)
3824 def do_update_derivatives(self, da):
3825 """do_update_derivatives(Constraint self, DerivativeAccumulator da)"""
3826 return _IMP_kernel.Constraint_do_update_derivatives(self, da)
3829 def do_before_evaluate(self):
3830 """do_before_evaluate(Constraint self)"""
3831 return _IMP_kernel.Constraint_do_before_evaluate(self)
3834 def do_after_evaluate(self, da):
3835 """do_after_evaluate(Constraint self, DerivativeAccumulator da)"""
3836 return _IMP_kernel.Constraint_do_after_evaluate(self, da)
3838 __swig_destroy__ = _IMP_kernel.delete_Constraint
3839 __del__ =
lambda self:
None
3842 """__str__(Constraint self) -> std::string"""
3843 return _IMP_kernel.Constraint___str__(self)
3847 """__repr__(Constraint self) -> std::string"""
3848 return _IMP_kernel.Constraint___repr__(self)
3853 return _object_cast_to_Constraint(o)
3856 def get_type_name(self):
3857 return self.__class__.__name__
3858 def do_show(self, out):
3860 def get_version_info(self):
3862 return VersionInfo(self.__module__,
3863 __import__(self.__module__).get_module_version())
3866 __import__(self.__module__).get_module_version())
3869 return _object_cast_to_Constraint(o)
3871 def __disown__(self):
3873 _IMP_kernel.disown_Constraint(self)
3874 return weakref_proxy(self)
3876 def do_destroy(self):
3877 """do_destroy(Constraint self)"""
3878 return _IMP_kernel.Constraint_do_destroy(self)
3881 def do_get_inputs(self):
3882 """do_get_inputs(Constraint self) -> IMP::ModelObjectsTemp"""
3883 return _IMP_kernel.Constraint_do_get_inputs(self)
3886 def do_get_outputs(self):
3887 """do_get_outputs(Constraint self) -> IMP::ModelObjectsTemp"""
3888 return _IMP_kernel.Constraint_do_get_outputs(self)
3891 def do_get_interactions(self):
3892 """do_get_interactions(Constraint self) -> IMP::ModelObjectsTemps"""
3893 return _IMP_kernel.Constraint_do_get_interactions(self)
3895 Constraint_swigregister = _IMP_kernel.Constraint_swigregister
3896 Constraint_swigregister(Constraint)
3898 class Container(ModelObject):
3899 """Proxy of C++ IMP::Container class."""
3901 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3903 def __init__(self, *args):
3905 __init__(IMP::Container self, Model m, std::string name) -> Container
3906 __init__(IMP::Container self, Model m) -> Container
3908 if self.__class__ == Container:
3912 this = _IMP_kernel.new_Container(_self, *args)
3914 self.this.append(this)
3918 if self.__class__ != Container:
3919 _director_objects.register(self)
3924 def do_get_contents_hash(self):
3925 """do_get_contents_hash(Container self) -> std::size_t"""
3926 return _IMP_kernel.Container_do_get_contents_hash(self)
3929 def get_all_possible_indexes(self):
3930 """get_all_possible_indexes(Container self) -> IMP::ParticleIndexes"""
3931 return _IMP_kernel.Container_get_all_possible_indexes(self)
3934 def get_contents_hash(self):
3935 """get_contents_hash(Container self) -> std::size_t"""
3936 return _IMP_kernel.Container_get_contents_hash(self)
3939 def do_get_outputs(self):
3940 """do_get_outputs(Container self) -> IMP::ModelObjectsTemp"""
3941 return _IMP_kernel.Container_do_get_outputs(self)
3944 def get_is_decomposable(self):
3945 """get_is_decomposable(Container self) -> bool"""
3946 return _IMP_kernel.Container_get_is_decomposable(self)
3949 def validate_readable(self):
3950 """validate_readable(Container self)"""
3951 return _IMP_kernel.Container_validate_readable(self)
3954 def validate_writable(self):
3955 """validate_writable(Container self)"""
3956 return _IMP_kernel.Container_validate_writable(self)
3959 def set_is_readable(self, tf):
3960 """set_is_readable(Container self, bool tf)"""
3961 return _IMP_kernel.Container_set_is_readable(self, tf)
3964 def set_is_writable(self, tf):
3965 """set_is_writable(Container self, bool tf)"""
3966 return _IMP_kernel.Container_set_is_writable(self, tf)
3968 __swig_destroy__ = _IMP_kernel.delete_Container
3969 __del__ =
lambda self:
None
3972 """__str__(Container self) -> std::string"""
3973 return _IMP_kernel.Container___str__(self)
3977 """__repr__(Container self) -> std::string"""
3978 return _IMP_kernel.Container___repr__(self)
3983 return _object_cast_to_Container(o)
3986 def get_type_name(self):
3987 return self.__class__.__name__
3988 def do_show(self, out):
3990 def get_version_info(self):
3992 return VersionInfo(self.__module__,
3993 __import__(self.__module__).get_module_version())
3996 __import__(self.__module__).get_module_version())
3999 return _object_cast_to_Container(o)
4001 def __disown__(self):
4003 _IMP_kernel.disown_Container(self)
4004 return weakref_proxy(self)
4006 def do_destroy(self):
4007 """do_destroy(Container self)"""
4008 return _IMP_kernel.Container_do_destroy(self)
4011 def handle_set_has_required_score_states(self, arg0):
4012 """handle_set_has_required_score_states(Container self, bool arg0)"""
4013 return _IMP_kernel.Container_handle_set_has_required_score_states(self, arg0)
4016 def do_get_inputs(self):
4017 """do_get_inputs(Container self) -> IMP::ModelObjectsTemp"""
4018 return _IMP_kernel.Container_do_get_inputs(self)
4021 def do_get_interactions(self):
4022 """do_get_interactions(Container self) -> IMP::ModelObjectsTemps"""
4023 return _IMP_kernel.Container_do_get_interactions(self)
4025 Container_swigregister = _IMP_kernel.Container_swigregister
4026 Container_swigregister(Container)
4028 class Restraint(ModelObject):
4029 """Proxy of C++ IMP::Restraint class."""
4031 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
4033 def __init__(self, m, name):
4034 """__init__(IMP::Restraint self, Model m, std::string name) -> Restraint"""
4035 if self.__class__ == Restraint:
4039 this = _IMP_kernel.new_Restraint(_self, m, name)
4041 self.this.append(this)
4045 if self.__class__ != Restraint:
4046 _director_objects.register(self)
4051 def get_score(self):
4052 """get_score(Restraint self) -> double"""
4053 return _IMP_kernel.Restraint_get_score(self)
4056 def evaluate(self, calc_derivs):
4057 """evaluate(Restraint self, bool calc_derivs) -> double"""
4058 return _IMP_kernel.Restraint_evaluate(self, calc_derivs)
4061 def evaluate_if_good(self, calc_derivatives):
4062 """evaluate_if_good(Restraint self, bool calc_derivatives) -> double"""
4063 return _IMP_kernel.Restraint_evaluate_if_good(self, calc_derivatives)
4066 def evaluate_if_below(self, calc_derivatives, max):
4067 """evaluate_if_below(Restraint self, bool calc_derivatives, double max) -> double"""
4068 return _IMP_kernel.Restraint_evaluate_if_below(self, calc_derivatives, max)
4071 def unprotected_evaluate(self, da):
4072 """unprotected_evaluate(Restraint self, DerivativeAccumulator da) -> double"""
4073 return _IMP_kernel.Restraint_unprotected_evaluate(self, da)
4076 def unprotected_evaluate_if_good(self, da, max):
4077 """unprotected_evaluate_if_good(Restraint self, DerivativeAccumulator da, double max) -> double"""
4078 return _IMP_kernel.Restraint_unprotected_evaluate_if_good(self, da, max)
4081 def unprotected_evaluate_if_below(self, da, max):
4082 """unprotected_evaluate_if_below(Restraint self, DerivativeAccumulator da, double max) -> double"""
4083 return _IMP_kernel.Restraint_unprotected_evaluate_if_below(self, da, max)
4086 def add_score_and_derivatives(self, sa):
4087 """add_score_and_derivatives(Restraint self, ScoreAccumulator sa)"""
4088 return _IMP_kernel.Restraint_add_score_and_derivatives(self, sa)
4092 """create_decomposition(Restraint self) -> Restraint"""
4093 return _IMP_kernel.Restraint_create_decomposition(self)
4096 def create_current_decomposition(self):
4097 """create_current_decomposition(Restraint self) -> Restraint"""
4098 return _IMP_kernel.Restraint_create_current_decomposition(self)
4101 def set_weight(self, weight):
4102 """set_weight(Restraint self, IMP::Float weight)"""
4103 return _IMP_kernel.Restraint_set_weight(self, weight)
4106 def get_weight(self):
4107 """get_weight(Restraint self) -> IMP::Float"""
4108 return _IMP_kernel.Restraint_get_weight(self)
4111 def get_maximum_score(self):
4112 """get_maximum_score(Restraint self) -> double"""
4113 return _IMP_kernel.Restraint_get_maximum_score(self)
4116 def set_maximum_score(self, s):
4117 """set_maximum_score(Restraint self, double s)"""
4118 return _IMP_kernel.Restraint_set_maximum_score(self, s)
4123 create_scoring_function(Restraint self, double weight=1.0, double max) -> ScoringFunction
4124 create_scoring_function(Restraint self, double weight=1.0) -> ScoringFunction
4125 create_scoring_function(Restraint self) -> ScoringFunction
4127 return _IMP_kernel.Restraint_create_scoring_function(self, *args)
4130 def set_last_score(self, s):
4131 """set_last_score(Restraint self, double s)"""
4132 return _IMP_kernel.Restraint_set_last_score(self, s)
4135 def get_last_score(self):
4136 """get_last_score(Restraint self) -> double"""
4137 return _IMP_kernel.Restraint_get_last_score(self)
4140 def get_was_good(self):
4141 """get_was_good(Restraint self) -> bool"""
4142 return _IMP_kernel.Restraint_get_was_good(self)
4144 __swig_destroy__ = _IMP_kernel.delete_Restraint
4145 __del__ =
lambda self:
None
4147 def do_create_decomposition(self):
4148 """do_create_decomposition(Restraint self) -> IMP::Restraints"""
4149 return _IMP_kernel.Restraint_do_create_decomposition(self)
4152 def do_create_current_decomposition(self):
4153 """do_create_current_decomposition(Restraint self) -> IMP::Restraints"""
4154 return _IMP_kernel.Restraint_do_create_current_decomposition(self)
4157 def do_add_score_and_derivatives(self, sa):
4158 """do_add_score_and_derivatives(Restraint self, ScoreAccumulator sa)"""
4159 return _IMP_kernel.Restraint_do_add_score_and_derivatives(self, sa)
4162 def do_get_outputs(self):
4163 """do_get_outputs(Restraint self) -> IMP::ModelObjectsTemp"""
4164 return _IMP_kernel.Restraint_do_get_outputs(self)
4168 """__str__(Restraint self) -> std::string"""
4169 return _IMP_kernel.Restraint___str__(self)
4173 """__repr__(Restraint self) -> std::string"""
4174 return _IMP_kernel.Restraint___repr__(self)
4179 return _object_cast_to_Restraint(o)
4182 def get_type_name(self):
4183 return self.__class__.__name__
4184 def do_show(self, out):
4186 def get_version_info(self):
4188 return VersionInfo(self.__module__,
4189 __import__(self.__module__).get_module_version())
4192 __import__(self.__module__).get_module_version())
4195 return _object_cast_to_Restraint(o)
4197 def __disown__(self):
4199 _IMP_kernel.disown_Restraint(self)
4200 return weakref_proxy(self)
4202 def do_destroy(self):
4203 """do_destroy(Restraint self)"""
4204 return _IMP_kernel.Restraint_do_destroy(self)
4207 def handle_set_has_required_score_states(self, arg0):
4208 """handle_set_has_required_score_states(Restraint self, bool arg0)"""
4209 return _IMP_kernel.Restraint_handle_set_has_required_score_states(self, arg0)
4212 def do_get_inputs(self):
4213 """do_get_inputs(Restraint self) -> IMP::ModelObjectsTemp"""
4214 return _IMP_kernel.Restraint_do_get_inputs(self)
4217 def do_get_interactions(self):
4218 """do_get_interactions(Restraint self) -> IMP::ModelObjectsTemps"""
4219 return _IMP_kernel.Restraint_do_get_interactions(self)
4221 Restraint_swigregister = _IMP_kernel.Restraint_swigregister
4222 Restraint_swigregister(Restraint)
4224 class _RestraintsAdaptor(_InputAdaptor):
4225 """Proxy of C++ IMP::RestraintsAdaptor class."""
4227 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
4228 __repr__ = _swig_repr
4230 def __init__(self, *args):
4232 __init__(IMP::RestraintsAdaptor self) -> _RestraintsAdaptor
4233 __init__(IMP::RestraintsAdaptor self, IMP::Restraints const & sf) -> _RestraintsAdaptor
4234 __init__(IMP::RestraintsAdaptor self, IMP::RestraintsTemp const & sf) -> _RestraintsAdaptor
4235 __init__(IMP::RestraintsAdaptor self, Restraint sf) -> _RestraintsAdaptor
4237 this = _IMP_kernel.new__RestraintsAdaptor(*args)
4239 self.this.append(this)
4242 __swig_destroy__ = _IMP_kernel.delete__RestraintsAdaptor
4243 __del__ =
lambda self:
None
4244 _RestraintsAdaptor_swigregister = _IMP_kernel._RestraintsAdaptor_swigregister
4245 _RestraintsAdaptor_swigregister(_RestraintsAdaptor)
4247 class RestraintSet(Restraint):
4248 """Proxy of C++ IMP::RestraintSet class."""
4250 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
4252 def __init__(self, *args):
4254 __init__(IMP::RestraintSet self, Model m, double weight, std::string const & name) -> RestraintSet
4255 __init__(IMP::RestraintSet self, Model m, double weight) -> RestraintSet
4256 __init__(IMP::RestraintSet self, Model m, std::string const & name) -> RestraintSet
4257 __init__(IMP::RestraintSet self, Model m) -> RestraintSet
4258 __init__(IMP::RestraintSet self, IMP::RestraintsTemp const & rs, double weight, std::string const & name) -> RestraintSet
4259 __init__(IMP::RestraintSet self, IMP::RestraintsTemp const & rs, double weight) -> RestraintSet
4261 this = _IMP_kernel.new_RestraintSet(*args)
4263 self.this.append(this)
4267 def get_version_info(self):
4268 """get_version_info(RestraintSet self) -> VersionInfo"""
4269 return _IMP_kernel.RestraintSet_get_version_info(self)
4272 def remove_restraint(self, d):
4273 """remove_restraint(RestraintSet self, Restraint d)"""
4274 return _IMP_kernel.RestraintSet_remove_restraint(self, d)
4277 def remove_restraints(self, d):
4278 """remove_restraints(RestraintSet self, IMP::Restraints const & d)"""
4279 return _IMP_kernel.RestraintSet_remove_restraints(self, d)
4282 def set_restraints(self, ps):
4283 """set_restraints(RestraintSet self, IMP::Restraints const & ps)"""
4284 return _IMP_kernel.RestraintSet_set_restraints(self, ps)
4287 def set_restraints_order(self, objs):
4288 """set_restraints_order(RestraintSet self, IMP::Restraints const & objs)"""
4289 return _IMP_kernel.RestraintSet_set_restraints_order(self, objs)
4293 """add_restraint(RestraintSet self, Restraint obj) -> unsigned int"""
4294 return _IMP_kernel.RestraintSet_add_restraint(self, obj)
4298 """add_restraints(RestraintSet self, IMP::Restraints const & objs)"""
4299 return _IMP_kernel.RestraintSet_add_restraints(self, objs)
4302 def clear_restraints(self):
4303 """clear_restraints(RestraintSet self)"""
4304 return _IMP_kernel.RestraintSet_clear_restraints(self)
4307 def get_number_of_restraints(self):
4308 """get_number_of_restraints(RestraintSet self) -> unsigned int"""
4309 return _IMP_kernel.RestraintSet_get_number_of_restraints(self)
4312 def get_has_restraints(self):
4313 """get_has_restraints(RestraintSet self) -> bool"""
4314 return _IMP_kernel.RestraintSet_get_has_restraints(self)
4317 def get_restraint(self, i):
4318 """get_restraint(RestraintSet self, unsigned int i) -> Restraint"""
4319 return _IMP_kernel.RestraintSet_get_restraint(self, i)
4322 def get_restraints(self):
4323 """get_restraints(RestraintSet self) -> IMP::Restraints"""
4324 return _IMP_kernel.RestraintSet_get_restraints(self)
4327 def reserve_restraints(self, sz):
4328 """reserve_restraints(RestraintSet self, unsigned int sz)"""
4329 return _IMP_kernel.RestraintSet_reserve_restraints(self, sz)
4332 def get_non_sets_and_sets(self):
4333 """get_non_sets_and_sets(RestraintSet self) -> std::pair< IMP::RestraintsTemp,IMP::RestraintSetsTemp >"""
4334 return _IMP_kernel.RestraintSet_get_non_sets_and_sets(self)
4337 def do_get_inputs(self):
4338 """do_get_inputs(RestraintSet self) -> IMP::ModelObjectsTemp"""
4339 return _IMP_kernel.RestraintSet_do_get_inputs(self)
4344 create_scoring_function(RestraintSet self, double weight=1.0, double max) -> ScoringFunction
4345 create_scoring_function(RestraintSet self, double weight=1.0) -> ScoringFunction
4346 create_scoring_function(RestraintSet self) -> ScoringFunction
4348 return _IMP_kernel.RestraintSet_create_scoring_function(self, *args)
4352 """__str__(RestraintSet self) -> std::string"""
4353 return _IMP_kernel.RestraintSet___str__(self)
4357 """__repr__(RestraintSet self) -> std::string"""
4358 return _IMP_kernel.RestraintSet___repr__(self)
4363 return _object_cast_to_RestraintSet(o)
4365 RestraintSet_swigregister = _IMP_kernel.RestraintSet_swigregister
4366 RestraintSet_swigregister(RestraintSet)
4369 def get_restraints(rs):
4370 """get_restraints(IMP::RestraintsTemp const & rs) -> IMP::RestraintsTemp"""
4371 return _IMP_kernel.get_restraints(rs)
4373 def _check_particle(p, a):
4374 if (
not p.get_is_active()):
4375 raise ValueError(
"Inactive Particle")
4376 if (type(a)() == a):
4377 raise IndexError(
"Cannot use default Index")
4378 if (
not p.has_attribute(a)):
4379 raise IndexError(
"Particle does not have attribute")
4381 class Particle(ModelObject):
4382 """Proxy of C++ IMP::Particle class."""
4384 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
4386 def get_version_info(self):
4387 """get_version_info(Particle self) -> VersionInfo"""
4388 return _IMP_kernel.Particle_get_version_info(self)
4391 def __init__(self, *args):
4393 __init__(IMP::Particle self, Model m, std::string name) -> Particle
4394 __init__(IMP::Particle self, Model m) -> Particle
4396 this = _IMP_kernel.new_Particle(*args)
4398 self.this.append(this)
4402 def get_float_keys(self):
4403 """get_float_keys(Particle self) -> IMP::FloatKeys"""
4404 return _IMP_kernel.Particle_get_float_keys(self)
4407 def get_int_keys(self):
4408 """get_int_keys(Particle self) -> IMP::IntKeys"""
4409 return _IMP_kernel.Particle_get_int_keys(self)
4412 def get_string_keys(self):
4413 """get_string_keys(Particle self) -> IMP::StringKeys"""
4414 return _IMP_kernel.Particle_get_string_keys(self)
4417 def get_object_keys(self):
4418 """get_object_keys(Particle self) -> IMP::ObjectKeys"""
4419 return _IMP_kernel.Particle_get_object_keys(self)
4422 def add_cache_attribute(self, *args):
4424 add_cache_attribute(Particle self, FloatKey name, IMP::Float value)
4425 add_cache_attribute(Particle self, IntKey name, IMP::Int value)
4426 add_cache_attribute(Particle self, StringKey name, IMP::String value)
4427 add_cache_attribute(Particle self, ObjectKey name, Object value)
4428 add_cache_attribute(Particle self, IMP::WeakObjectKey name, Object value)
4430 return _IMP_kernel.Particle_add_cache_attribute(self, *args)
4433 def get_weak_object_keys(self):
4434 """get_weak_object_keys(Particle self) -> IMP::WeakObjectKeys"""
4435 return _IMP_kernel.Particle_get_weak_object_keys(self)
4438 def add_to_derivative(self, key, value, da):
4439 """add_to_derivative(Particle self, FloatKey key, IMP::Float value, DerivativeAccumulator da)"""
4440 return _IMP_kernel.Particle_add_to_derivative(self, key, value, da)
4443 def set_is_optimized(self, k, tf):
4444 """set_is_optimized(Particle self, FloatKey k, bool tf)"""
4445 return _IMP_kernel.Particle_set_is_optimized(self, k, tf)
4448 def get_is_optimized(self, k):
4449 """get_is_optimized(Particle self, FloatKey k) -> bool"""
4450 return _IMP_kernel.Particle_get_is_optimized(self, k)
4453 def get_derivative(self, name):
4454 """get_derivative(Particle self, FloatKey name) -> IMP::Float"""
4455 return _IMP_kernel.Particle_get_derivative(self, name)
4458 def add_attribute(self, *args):
4460 add_attribute(Particle self, FloatKey name, IMP::Float initial_value)
4461 add_attribute(Particle self, IntKey name, IMP::Int initial_value)
4462 add_attribute(Particle self, StringKey name, IMP::String initial_value)
4463 add_attribute(Particle self, ObjectKey name, Object initial_value)
4464 add_attribute(Particle self, IMP::WeakObjectKey name, Object initial_value)
4465 add_attribute(Particle self, FloatKey name, IMP::Float const initial_value, bool optimized)
4466 add_attribute(Particle self, ParticleIndexKey k, Particle v)
4468 return _IMP_kernel.Particle_add_attribute(self, *args)
4471 def has_attribute(self, *args):
4473 has_attribute(Particle self, FloatKey name) -> bool
4474 has_attribute(Particle self, IntKey name) -> bool
4475 has_attribute(Particle self, StringKey name) -> bool
4476 has_attribute(Particle self, ObjectKey name) -> bool
4477 has_attribute(Particle self, IMP::WeakObjectKey name) -> bool
4478 has_attribute(Particle self, ParticleIndexKey k) -> bool
4480 return _IMP_kernel.Particle_has_attribute(self, *args)
4483 def set_value(self, *args):
4485 set_value(Particle self, FloatKey name, IMP::Float value)
4486 set_value(Particle self, IntKey name, IMP::Int value)
4487 set_value(Particle self, StringKey name, IMP::String value)
4488 set_value(Particle self, ObjectKey name, Object value)
4489 set_value(Particle self, IMP::WeakObjectKey name, Object value)
4490 set_value(Particle self, ParticleIndexKey k, Particle v)
4492 return _IMP_kernel.Particle_set_value(self, *args)
4495 def get_value(self, *args):
4497 get_value(Particle self, FloatKey name) -> IMP::Float
4498 get_value(Particle self, IntKey name) -> IMP::Int
4499 get_value(Particle self, StringKey name) -> IMP::String
4500 get_value(Particle self, ObjectKey name) -> Object
4501 get_value(Particle self, IMP::WeakObjectKey name) -> Object
4502 get_value(Particle self, ParticleIndexKey k) -> Particle
4504 return _IMP_kernel.Particle_get_value(self, *args)
4507 def remove_attribute(self, *args):
4509 remove_attribute(Particle self, FloatKey name)
4510 remove_attribute(Particle self, IntKey name)
4511 remove_attribute(Particle self, StringKey name)
4512 remove_attribute(Particle self, ObjectKey name)
4513 remove_attribute(Particle self, IMP::WeakObjectKey name)
4514 remove_attribute(Particle self, ParticleIndexKey k)
4516 return _IMP_kernel.Particle_remove_attribute(self, *args)
4519 def get_particle_keys(self):
4520 """get_particle_keys(Particle self) -> IMP::ParticleIndexKeys"""
4521 return _IMP_kernel.Particle_get_particle_keys(self)
4524 def show(self, *args):
4526 show(Particle self, _ostream out)
4529 return _IMP_kernel.Particle_show(self, *args)
4532 def get_is_active(self):
4533 """get_is_active(Particle self) -> bool"""
4534 return _IMP_kernel.Particle_get_is_active(self)
4538 """get_index(Particle self) -> ParticleIndex"""
4539 return _IMP_kernel.Particle_get_index(self)
4542 def __eq__(self, *args):
4544 __eq__(Particle self, Particle o) -> bool
4545 __eq__(Particle self, Decorator d) -> bool
4547 return _IMP_kernel.Particle___eq__(self, *args)
4550 def __ne__(self, *args):
4552 __ne__(Particle self, Particle o) -> bool
4553 __ne__(Particle self, Decorator d) -> bool
4555 return _IMP_kernel.Particle___ne__(self, *args)
4558 def __le__(self, *args):
4560 __le__(Particle self, Particle o) -> bool
4561 __le__(Particle self, Decorator d) -> bool
4563 return _IMP_kernel.Particle___le__(self, *args)
4566 def __lt__(self, *args):
4568 __lt__(Particle self, Particle o) -> bool
4569 __lt__(Particle self, Decorator d) -> bool
4571 return _IMP_kernel.Particle___lt__(self, *args)
4574 def __ge__(self, *args):
4576 __ge__(Particle self, Particle o) -> bool
4577 __ge__(Particle self, Decorator d) -> bool
4579 return _IMP_kernel.Particle___ge__(self, *args)
4582 def __gt__(self, *args):
4584 __gt__(Particle self, Particle o) -> bool
4585 __gt__(Particle self, Decorator d) -> bool
4587 return _IMP_kernel.Particle___gt__(self, *args)
4590 __hash__ = ModelObject.__hash__
4594 """__str__(Particle self) -> std::string"""
4595 return _IMP_kernel.Particle___str__(self)
4599 """__repr__(Particle self) -> std::string"""
4600 return _IMP_kernel.Particle___repr__(self)
4605 return _object_cast_to_Particle(o)
4607 Particle_swigregister = _IMP_kernel.Particle_swigregister
4608 Particle_swigregister(Particle)
4610 class _ParticleAdaptor(_InputAdaptor):
4611 """Proxy of C++ IMP::ParticleAdaptor class."""
4613 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
4614 __repr__ = _swig_repr
4616 def __init__(self, *args):
4618 __init__(IMP::ParticleAdaptor self) -> _ParticleAdaptor
4619 __init__(IMP::ParticleAdaptor self, Particle p) -> _ParticleAdaptor
4620 __init__(IMP::ParticleAdaptor self, Decorator d) -> _ParticleAdaptor
4622 this = _IMP_kernel.new__ParticleAdaptor(*args)
4624 self.this.append(this)
4628 def get_model(self):
4629 """get_model(_ParticleAdaptor self) -> Model"""
4630 return _IMP_kernel._ParticleAdaptor_get_model(self)
4633 def get_particle_index(self):
4634 """get_particle_index(_ParticleAdaptor self) -> ParticleIndex"""
4635 return _IMP_kernel._ParticleAdaptor_get_particle_index(self)
4637 __swig_destroy__ = _IMP_kernel.delete__ParticleAdaptor
4638 __del__ =
lambda self:
None
4639 _ParticleAdaptor_swigregister = _IMP_kernel._ParticleAdaptor_swigregister
4640 _ParticleAdaptor_swigregister(_ParticleAdaptor)
4642 class _DependencyGraphVertexIndex(object):
4643 """Proxy of C++ IMP::DependencyGraphVertexIndex class."""
4645 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
4646 __repr__ = _swig_repr
4649 """__init__(IMP::DependencyGraphVertexIndex self) -> _DependencyGraphVertexIndex"""
4650 this = _IMP_kernel.new__DependencyGraphVertexIndex()
4652 self.this.append(this)
4655 __swig_destroy__ = _IMP_kernel.delete__DependencyGraphVertexIndex
4656 __del__ =
lambda self:
None
4657 _DependencyGraphVertexIndex_swigregister = _IMP_kernel._DependencyGraphVertexIndex_swigregister
4658 _DependencyGraphVertexIndex_swigregister(_DependencyGraphVertexIndex)
4661 def show_as_graphviz(name, out):
4662 """show_as_graphviz(IMP::DependencyGraph const & name, TextOutput out)"""
4663 return _IMP_kernel.show_as_graphviz(name, out)
4665 def get_vertex_index(g):
4666 """get_vertex_index(IMP::DependencyGraph const & g) -> _DependencyGraphVertexIndex"""
4667 return _IMP_kernel.get_vertex_index(g)
4670 """get_dependency_graph(Model m) -> IMP::DependencyGraph"""
4671 return _IMP_kernel.get_dependency_graph(m)
4674 """get_pruned_dependency_graph(Model m) -> IMP::DependencyGraph"""
4675 return _IMP_kernel.get_pruned_dependency_graph(m)
4679 get_required_score_states(IMP::ModelObjectsTemp const & mos, IMP::ScoreStatesTemp exclude) -> IMP::ScoreStatesTemp
4680 get_required_score_states(IMP::ModelObjectsTemp const & mos) -> IMP::ScoreStatesTemp
4681 get_required_score_states(ModelObject p, IMP::ModelObjectsTemp const & all, IMP::DependencyGraph const & dg, _DependencyGraphVertexIndex index) -> IMP::ScoreStatesTemp
4683 return _IMP_kernel.get_required_score_states(*args)
4686 """get_dependent_particles(ModelObject p, IMP::ModelObjectsTemp const & all, IMP::DependencyGraph const & dg, _DependencyGraphVertexIndex index) -> IMP::ParticlesTemp"""
4687 return _IMP_kernel.get_dependent_particles(p, all, dg, index)
4689 def get_dependent_restraints(m, pi):
4690 """get_dependent_restraints(Model m, ParticleIndex pi) -> IMP::RestraintsTemp"""
4691 return _IMP_kernel.get_dependent_restraints(m, pi)
4692 class ScoringFunction(ModelObject):
4693 """Proxy of C++ IMP::ScoringFunction class."""
4695 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
4697 def do_add_score_and_derivatives(self, sa, ss):
4698 """do_add_score_and_derivatives(ScoringFunction self, ScoreAccumulator sa, IMP::ScoreStatesTemp const & ss)"""
4699 return _IMP_kernel.ScoringFunction_do_add_score_and_derivatives(self, sa, ss)
4702 def get_score_accumulator_if_below(self, deriv, max):
4703 """get_score_accumulator_if_below(ScoringFunction self, bool deriv, double max) -> ScoreAccumulator"""
4704 return _IMP_kernel.ScoringFunction_get_score_accumulator_if_below(self, deriv, max)
4707 def get_score_accumulator_if_good(self, deriv):
4708 """get_score_accumulator_if_good(ScoringFunction self, bool deriv) -> ScoreAccumulator"""
4709 return _IMP_kernel.ScoringFunction_get_score_accumulator_if_good(self, deriv)
4712 def get_score_accumulator(self, deriv):
4713 """get_score_accumulator(ScoringFunction self, bool deriv) -> ScoreAccumulator"""
4714 return _IMP_kernel.ScoringFunction_get_score_accumulator(self, deriv)
4717 def __init__(self, m, name):
4718 """__init__(IMP::ScoringFunction self, Model m, std::string name) -> ScoringFunction"""
4719 if self.__class__ == ScoringFunction:
4723 this = _IMP_kernel.new_ScoringFunction(_self, m, name)
4725 self.this.append(this)
4729 if self.__class__ != ScoringFunction:
4730 _director_objects.register(self)
4735 def do_get_outputs(self):
4736 """do_get_outputs(ScoringFunction self) -> IMP::ModelObjectsTemp"""
4737 return _IMP_kernel.ScoringFunction_do_get_outputs(self)
4740 def evaluate_if_good(self, derivatives):
4741 """evaluate_if_good(ScoringFunction self, bool derivatives) -> double"""
4742 return _IMP_kernel.ScoringFunction_evaluate_if_good(self, derivatives)
4745 def evaluate(self, derivatives):
4746 """evaluate(ScoringFunction self, bool derivatives) -> double"""
4747 return _IMP_kernel.ScoringFunction_evaluate(self, derivatives)
4750 def evaluate_if_below(self, derivatives, max):
4751 """evaluate_if_below(ScoringFunction self, bool derivatives, double max) -> double"""
4752 return _IMP_kernel.ScoringFunction_evaluate_if_below(self, derivatives, max)
4755 def get_had_good_score(self):
4756 """get_had_good_score(ScoringFunction self) -> bool"""
4757 return _IMP_kernel.ScoringFunction_get_had_good_score(self)
4760 def get_last_score(self):
4761 """get_last_score(ScoringFunction self) -> double"""
4762 return _IMP_kernel.ScoringFunction_get_last_score(self)
4766 """create_restraints(ScoringFunction self) -> IMP::Restraints"""
4767 return _IMP_kernel.ScoringFunction_create_restraints(self)
4771 """__str__(ScoringFunction self) -> std::string"""
4772 return _IMP_kernel.ScoringFunction___str__(self)
4776 """__repr__(ScoringFunction self) -> std::string"""
4777 return _IMP_kernel.ScoringFunction___repr__(self)
4782 return _object_cast_to_ScoringFunction(o)
4785 def get_type_name(self):
4786 return self.__class__.__name__
4787 def do_show(self, out):
4789 def get_version_info(self):
4791 return VersionInfo(self.__module__,
4792 __import__(self.__module__).get_module_version())
4795 __import__(self.__module__).get_module_version())
4798 return _object_cast_to_ScoringFunction(o)
4800 __swig_destroy__ = _IMP_kernel.delete_ScoringFunction
4801 __del__ =
lambda self:
None
4802 def __disown__(self):
4804 _IMP_kernel.disown_ScoringFunction(self)
4805 return weakref_proxy(self)
4807 def do_destroy(self):
4808 """do_destroy(ScoringFunction self)"""
4809 return _IMP_kernel.ScoringFunction_do_destroy(self)
4812 def handle_set_has_required_score_states(self, arg0):
4813 """handle_set_has_required_score_states(ScoringFunction self, bool arg0)"""
4814 return _IMP_kernel.ScoringFunction_handle_set_has_required_score_states(self, arg0)
4817 def do_get_inputs(self):
4818 """do_get_inputs(ScoringFunction self) -> IMP::ModelObjectsTemp"""
4819 return _IMP_kernel.ScoringFunction_do_get_inputs(self)
4822 def do_get_interactions(self):
4823 """do_get_interactions(ScoringFunction self) -> IMP::ModelObjectsTemps"""
4824 return _IMP_kernel.ScoringFunction_do_get_interactions(self)
4826 ScoringFunction_swigregister = _IMP_kernel.ScoringFunction_swigregister
4827 ScoringFunction_swigregister(ScoringFunction)
4832 create_decomposition(IMP::RestraintsTemp const & rs) -> IMP::Restraints
4833 create_decomposition(ScoringFunction sf) -> IMP::ScoringFunctions
4835 return _IMP_kernel.create_decomposition(*args)
4836 class _ScoringFunctionAdaptor(_InputAdaptor):
4837 """Proxy of C++ IMP::ScoringFunctionAdaptor class."""
4839 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
4840 __repr__ = _swig_repr
4842 def __init__(self, *args):
4844 __init__(IMP::ScoringFunctionAdaptor self) -> _ScoringFunctionAdaptor
4845 __init__(IMP::ScoringFunctionAdaptor self, ScoringFunction sf) -> _ScoringFunctionAdaptor
4846 __init__(IMP::ScoringFunctionAdaptor self, IMP::RestraintsTemp const & sf) -> _ScoringFunctionAdaptor
4847 __init__(IMP::ScoringFunctionAdaptor self, IMP::Restraints const & sf) -> _ScoringFunctionAdaptor
4848 __init__(IMP::ScoringFunctionAdaptor self, Restraint sf) -> _ScoringFunctionAdaptor
4850 this = _IMP_kernel.new__ScoringFunctionAdaptor(*args)
4852 self.this.append(this)
4855 __swig_destroy__ = _IMP_kernel.delete__ScoringFunctionAdaptor
4856 __del__ =
lambda self:
None
4857 _ScoringFunctionAdaptor_swigregister = _IMP_kernel._ScoringFunctionAdaptor_swigregister
4858 _ScoringFunctionAdaptor_swigregister(_ScoringFunctionAdaptor)
4863 show_restraint_hierarchy(_ScoringFunctionAdaptor rs, _ostream out)
4864 show_restraint_hierarchy(_ScoringFunctionAdaptor rs)
4866 return _IMP_kernel.show_restraint_hierarchy(*args)
4867 class Undecorator(Object):
4868 """Proxy of C++ IMP::Undecorator class."""
4870 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
4872 def __init__(self, m, name):
4873 """__init__(IMP::Undecorator self, Model m, std::string name) -> Undecorator"""
4874 if self.__class__ == Undecorator:
4878 this = _IMP_kernel.new_Undecorator(_self, m, name)
4880 self.this.append(this)
4884 if self.__class__ != Undecorator:
4885 _director_objects.register(self)
4890 def teardown(self, pi):
4891 """teardown(Undecorator self, ParticleIndex pi)"""
4892 return _IMP_kernel.Undecorator_teardown(self, pi)
4896 """__str__(Undecorator self) -> std::string"""
4897 return _IMP_kernel.Undecorator___str__(self)
4901 """__repr__(Undecorator self) -> std::string"""
4902 return _IMP_kernel.Undecorator___repr__(self)
4907 return _object_cast_to_Undecorator(o)
4910 def get_type_name(self):
4911 return self.__class__.__name__
4912 def do_show(self, out):
4914 def get_version_info(self):
4916 return VersionInfo(self.__module__,
4917 __import__(self.__module__).get_module_version())
4920 __import__(self.__module__).get_module_version())
4923 return _object_cast_to_Undecorator(o)
4925 __swig_destroy__ = _IMP_kernel.delete_Undecorator
4926 __del__ =
lambda self:
None
4927 def __disown__(self):
4929 _IMP_kernel.disown_Undecorator(self)
4930 return weakref_proxy(self)
4932 def do_destroy(self):
4933 """do_destroy(Undecorator self)"""
4934 return _IMP_kernel.Undecorator_do_destroy(self)
4936 Undecorator_swigregister = _IMP_kernel.Undecorator_swigregister
4937 Undecorator_swigregister(Undecorator)
4939 class Model(Object):
4940 """Proxy of C++ IMP::Model class."""
4942 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
4944 def __init__(self, *args):
4946 __init__(IMP::Model self, std::string name) -> Model
4947 __init__(IMP::Model self) -> Model
4949 this = _IMP_kernel.new_Model(*args)
4951 self.this.append(this)
4955 def clear_particle_caches(self, pi):
4956 """clear_particle_caches(Model self, ParticleIndex pi)"""
4957 return _IMP_kernel.Model_clear_particle_caches(self, pi)
4961 """add_particle(Model self, std::string name) -> ParticleIndex"""
4962 return _IMP_kernel.Model_add_particle(self, name)
4965 def get_particle_name(self, pi):
4966 """get_particle_name(Model self, ParticleIndex pi) -> std::string"""
4967 return _IMP_kernel.Model_get_particle_name(self, pi)
4970 def add_undecorator(self, pi, d):
4971 """add_undecorator(Model self, ParticleIndex pi, Undecorator d)"""
4972 return _IMP_kernel.Model_add_undecorator(self, pi, d)
4975 def remove_score_state(self, d):
4976 """remove_score_state(Model self, ScoreState d)"""
4977 return _IMP_kernel.Model_remove_score_state(self, d)
4980 def remove_score_states(self, d):
4981 """remove_score_states(Model self, IMP::ScoreStates const & d)"""
4982 return _IMP_kernel.Model_remove_score_states(self, d)
4985 def set_score_states(self, ps):
4986 """set_score_states(Model self, IMP::ScoreStates const & ps)"""
4987 return _IMP_kernel.Model_set_score_states(self, ps)
4990 def set_score_states_order(self, objs):
4991 """set_score_states_order(Model self, IMP::ScoreStates const & objs)"""
4992 return _IMP_kernel.Model_set_score_states_order(self, objs)
4995 def add_score_state(self, obj):
4996 """add_score_state(Model self, ScoreState obj) -> unsigned int"""
4997 return _IMP_kernel.Model_add_score_state(self, obj)
5000 def add_score_states(self, objs):
5001 """add_score_states(Model self, IMP::ScoreStates const & objs)"""
5002 return _IMP_kernel.Model_add_score_states(self, objs)
5005 def clear_score_states(self):
5006 """clear_score_states(Model self)"""
5007 return _IMP_kernel.Model_clear_score_states(self)
5010 def get_number_of_score_states(self):
5011 """get_number_of_score_states(Model self) -> unsigned int"""
5012 return _IMP_kernel.Model_get_number_of_score_states(self)
5015 def get_has_score_states(self):
5016 """get_has_score_states(Model self) -> bool"""
5017 return _IMP_kernel.Model_get_has_score_states(self)
5020 def get_score_state(self, i):
5021 """get_score_state(Model self, unsigned int i) -> ScoreState"""
5022 return _IMP_kernel.Model_get_score_state(self, i)
5025 def get_score_states(self):
5026 """get_score_states(Model self) -> IMP::ScoreStates"""
5027 return _IMP_kernel.Model_get_score_states(self)
5030 def reserve_score_states(self, sz):
5031 """reserve_score_states(Model self, unsigned int sz)"""
5032 return _IMP_kernel.Model_reserve_score_states(self, sz)
5036 """update(Model self)"""
5037 return _IMP_kernel.Model_update(self)
5040 def add_attribute(self, *args):
5042 add_attribute(Model self, FloatKey attribute_key, ParticleIndex particle, IMP::Float value)
5043 add_attribute(Model self, IntKey attribute_key, ParticleIndex particle, IMP::Int value)
5044 add_attribute(Model self, IMP::IntsKey attribute_key, ParticleIndex particle, IMP::Ints value)
5045 add_attribute(Model self, StringKey attribute_key, ParticleIndex particle, IMP::String value)
5046 add_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle, IMP::ParticleIndexes value)
5047 add_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle, ParticleIndex value)
5048 add_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle, Object value)
5049 add_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle, Object value)
5051 return _IMP_kernel.Model_add_attribute(self, *args)
5054 def remove_attribute(self, *args):
5056 remove_attribute(Model self, FloatKey attribute_key, ParticleIndex particle)
5057 remove_attribute(Model self, IntKey attribute_key, ParticleIndex particle)
5058 remove_attribute(Model self, IMP::IntsKey attribute_key, ParticleIndex particle)
5059 remove_attribute(Model self, StringKey attribute_key, ParticleIndex particle)
5060 remove_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle)
5061 remove_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle)
5062 remove_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle)
5063 remove_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle)
5065 return _IMP_kernel.Model_remove_attribute(self, *args)
5068 def get_has_attribute(self, *args):
5070 get_has_attribute(Model self, FloatKey attribute_key, ParticleIndex particle) -> bool
5071 get_has_attribute(Model self, IntKey attribute_key, ParticleIndex particle) -> bool
5072 get_has_attribute(Model self, IMP::IntsKey attribute_key, ParticleIndex particle) -> bool
5073 get_has_attribute(Model self, StringKey attribute_key, ParticleIndex particle) -> bool
5074 get_has_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle) -> bool
5075 get_has_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle) -> bool
5076 get_has_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle) -> bool
5077 get_has_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle) -> bool
5079 return _IMP_kernel.Model_get_has_attribute(self, *args)
5082 def set_attribute(self, *args):
5084 set_attribute(Model self, FloatKey attribute_key, ParticleIndex particle, IMP::Float value)
5085 set_attribute(Model self, IntKey attribute_key, ParticleIndex particle, IMP::Int value)
5086 set_attribute(Model self, IMP::IntsKey attribute_key, ParticleIndex particle, IMP::Ints value)
5087 set_attribute(Model self, StringKey attribute_key, ParticleIndex particle, IMP::String value)
5088 set_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle, IMP::ParticleIndexes value)
5089 set_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle, ParticleIndex value)
5090 set_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle, Object value)
5091 set_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle, Object value)
5093 return _IMP_kernel.Model_set_attribute(self, *args)
5096 def get_attribute(self, *args):
5098 get_attribute(Model self, FloatKey attribute_key, ParticleIndex particle) -> IMP::Float
5099 get_attribute(Model self, IntKey attribute_key, ParticleIndex particle) -> IMP::Int
5100 get_attribute(Model self, IMP::IntsKey attribute_key, ParticleIndex particle) -> IMP::Ints
5101 get_attribute(Model self, StringKey attribute_key, ParticleIndex particle) -> IMP::String
5102 get_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle) -> IMP::ParticleIndexes
5103 get_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle) -> ParticleIndex
5104 get_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle) -> Object
5105 get_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle) -> Object
5107 return _IMP_kernel.Model_get_attribute(self, *args)
5110 def add_cache_attribute(self, *args):
5112 add_cache_attribute(Model self, FloatKey attribute_key, ParticleIndex particle, IMP::Float value)
5113 add_cache_attribute(Model self, IntKey attribute_key, ParticleIndex particle, IMP::Int value)
5114 add_cache_attribute(Model self, IMP::IntsKey attribute_key, ParticleIndex particle, IMP::Ints value)
5115 add_cache_attribute(Model self, StringKey attribute_key, ParticleIndex particle, IMP::String value)
5116 add_cache_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle, IMP::ParticleIndexes value)
5117 add_cache_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle, ParticleIndex value)
5118 add_cache_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle, Object value)
5119 add_cache_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle, Object value)
5121 return _IMP_kernel.Model_add_cache_attribute(self, *args)
5124 def set_is_optimized(self, arg2, arg3, arg4):
5125 """set_is_optimized(Model self, FloatKey arg2, ParticleIndex arg3, bool arg4)"""
5126 return _IMP_kernel.Model_set_is_optimized(self, arg2, arg3, arg4)
5129 def add_to_derivative(self, k, particle, v, da):
5130 """add_to_derivative(Model self, FloatKey k, ParticleIndex particle, double v, DerivativeAccumulator da)"""
5131 return _IMP_kernel.Model_add_to_derivative(self, k, particle, v, da)
5134 def get_particle(self, p):
5135 """get_particle(Model self, ParticleIndex p) -> Particle"""
5136 return _IMP_kernel.Model_get_particle(self, p)
5139 def get_has_particle(self, p):
5140 """get_has_particle(Model self, ParticleIndex p) -> bool"""
5141 return _IMP_kernel.Model_get_has_particle(self, p)
5144 def get_particle_indexes(self):
5145 """get_particle_indexes(Model self) -> IMP::ParticleIndexes"""
5146 return _IMP_kernel.Model_get_particle_indexes(self)
5149 def get_model_objects(self):
5150 """get_model_objects(Model self) -> IMP::ModelObjectsTemp"""
5151 return _IMP_kernel.Model_get_model_objects(self)
5154 def remove_particle(self, pi):
5155 """remove_particle(Model self, ParticleIndex pi)"""
5156 return _IMP_kernel.Model_remove_particle(self, pi)
5159 def add_data(self, mk, o):
5160 """add_data(Model self, ModelKey mk, Object o)"""
5161 return _IMP_kernel.Model_add_data(self, mk, o)
5164 def get_data(self, mk):
5165 """get_data(Model self, ModelKey mk) -> Object"""
5166 return _IMP_kernel.Model_get_data(self, mk)
5169 def remove_data(self, mk):
5170 """remove_data(Model self, ModelKey mk)"""
5171 return _IMP_kernel.Model_remove_data(self, mk)
5174 def get_has_data(self, mk):
5175 """get_has_data(Model self, ModelKey mk) -> bool"""
5176 return _IMP_kernel.Model_get_has_data(self, mk)
5179 def get_version_info(self):
5180 """get_version_info(Model self) -> VersionInfo"""
5181 return _IMP_kernel.Model_get_version_info(self)
5184 def do_destroy(self):
5185 """do_destroy(Model self)"""
5186 return _IMP_kernel.Model_do_destroy(self)
5190 """__str__(Model self) -> std::string"""
5191 return _IMP_kernel.Model___str__(self)
5195 """__repr__(Model self) -> std::string"""
5196 return _IMP_kernel.Model___repr__(self)
5201 return _object_cast_to_Model(o)
5203 Model_swigregister = _IMP_kernel.Model_swigregister
5204 Model_swigregister(Model)
5206 class Decorator(_Value):
5207 """Proxy of C++ IMP::Decorator class."""
5209 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
5210 __repr__ = _swig_repr
5212 def __init__(self, p):
5213 """__init__(IMP::Decorator self, _ParticleAdaptor p) -> Decorator"""
5214 this = _IMP_kernel.new_Decorator(p)
5216 self.this.append(this)
5220 def __ne__(self, o):
5221 """__ne__(Decorator self, Object o) -> bool"""
5222 return _IMP_kernel.Decorator___ne__(self, o)
5225 def __lt__(self, o):
5226 """__lt__(Decorator self, Object o) -> bool"""
5227 return _IMP_kernel.Decorator___lt__(self, o)
5230 def __gt__(self, o):
5231 """__gt__(Decorator self, Object o) -> bool"""
5232 return _IMP_kernel.Decorator___gt__(self, o)
5235 def __ge__(self, o):
5236 """__ge__(Decorator self, Object o) -> bool"""
5237 return _IMP_kernel.Decorator___ge__(self, o)
5240 def __le__(self, o):
5241 """__le__(Decorator self, Object o) -> bool"""
5242 return _IMP_kernel.Decorator___le__(self, o)
5245 def get_particle(self):
5246 """get_particle(Decorator self) -> Particle"""
5247 return _IMP_kernel.Decorator_get_particle(self)
5250 def get_particle_index(self):
5251 """get_particle_index(Decorator self) -> ParticleIndex"""
5252 return _IMP_kernel.Decorator_get_particle_index(self)
5255 def get_model(self):
5256 """get_model(Decorator self) -> Model"""
5257 return _IMP_kernel.Decorator_get_model(self)
5260 def get_is_valid(self):
5261 """get_is_valid(Decorator self) -> bool"""
5262 return _IMP_kernel.Decorator_get_is_valid(self)
5266 """__hash__(Decorator self) -> std::size_t"""
5267 return _IMP_kernel.Decorator___hash__(self)
5270 def __eq__(self, *args):
5272 __eq__(Decorator self, Object o) -> bool
5273 __eq__(Decorator self, Decorator o) -> bool
5274 __eq__(Decorator self, Particle o) -> bool
5276 return _IMP_kernel.Decorator___eq__(self, *args)
5280 """__bool__(Decorator self) -> bool"""
5281 return _IMP_kernel.Decorator___bool__(self)
5284 __nonzero__ = __bool__
5286 __swig_destroy__ = _IMP_kernel.delete_Decorator
5287 __del__ =
lambda self:
None
5288 Decorator_swigregister = _IMP_kernel.Decorator_swigregister
5289 Decorator_swigregister(Decorator)
5292 def check_particle(m, pi):
5293 """check_particle(Model m, ParticleIndex pi)"""
5294 return _IMP_kernel.check_particle(m, pi)
5295 class UnaryFunction(Object):
5296 """Proxy of C++ IMP::UnaryFunction class."""
5298 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
5300 def __init__(self, *args):
5302 __init__(IMP::UnaryFunction self, std::string name) -> UnaryFunction
5303 __init__(IMP::UnaryFunction self) -> UnaryFunction
5305 if self.__class__ == UnaryFunction:
5309 this = _IMP_kernel.new_UnaryFunction(_self, *args)
5311 self.this.append(this)
5315 if self.__class__ != UnaryFunction:
5316 _director_objects.register(self)
5321 def evaluate(self, feature):
5322 """evaluate(UnaryFunction self, double feature) -> double"""
5323 return _IMP_kernel.UnaryFunction_evaluate(self, feature)
5326 def evaluate_with_derivative(self, feature):
5327 """evaluate_with_derivative(UnaryFunction self, double feature) -> IMP::DerivativePair"""
5328 return _IMP_kernel.UnaryFunction_evaluate_with_derivative(self, feature)
5330 __swig_destroy__ = _IMP_kernel.delete_UnaryFunction
5331 __del__ =
lambda self:
None
5334 """__str__(UnaryFunction self) -> std::string"""
5335 return _IMP_kernel.UnaryFunction___str__(self)
5339 """__repr__(UnaryFunction self) -> std::string"""
5340 return _IMP_kernel.UnaryFunction___repr__(self)
5345 return _object_cast_to_UnaryFunction(o)
5348 def get_type_name(self):
5349 return self.__class__.__name__
5350 def do_show(self, out):
5352 def get_version_info(self):
5354 return VersionInfo(self.__module__,
5355 __import__(self.__module__).get_module_version())
5358 __import__(self.__module__).get_module_version())
5361 return _object_cast_to_UnaryFunction(o)
5363 def __disown__(self):
5365 _IMP_kernel.disown_UnaryFunction(self)
5366 return weakref_proxy(self)
5368 def do_destroy(self):
5369 """do_destroy(UnaryFunction self)"""
5370 return _IMP_kernel.UnaryFunction_do_destroy(self)
5372 UnaryFunction_swigregister = _IMP_kernel.UnaryFunction_swigregister
5373 UnaryFunction_swigregister(UnaryFunction)
5375 class OptimizerState(ModelObject):
5376 """Proxy of C++ IMP::OptimizerState class."""
5378 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
5380 def __init__(self, m, name):
5381 """__init__(IMP::OptimizerState self, Model m, std::string name) -> OptimizerState"""
5382 if self.__class__ == OptimizerState:
5386 this = _IMP_kernel.new_OptimizerState(_self, m, name)
5388 self.this.append(this)
5392 if self.__class__ != OptimizerState:
5393 _director_objects.register(self)
5399 """update(OptimizerState self)"""
5400 return _IMP_kernel.OptimizerState_update(self)
5403 def set_is_optimizing(self, arg0):
5404 """set_is_optimizing(OptimizerState self, bool arg0)"""
5405 return _IMP_kernel.OptimizerState_set_is_optimizing(self, arg0)
5408 def get_optimizer(self):
5409 """get_optimizer(OptimizerState self) -> Optimizer"""
5410 return _IMP_kernel.OptimizerState_get_optimizer(self)
5413 def set_period(self, p):
5414 """set_period(OptimizerState self, unsigned int p)"""
5415 return _IMP_kernel.OptimizerState_set_period(self, p)
5418 def get_period(self):
5419 """get_period(OptimizerState self) -> unsigned int"""
5420 return _IMP_kernel.OptimizerState_get_period(self)
5424 """reset(OptimizerState self)"""
5425 return _IMP_kernel.OptimizerState_reset(self)
5428 def update_always(self):
5429 """update_always(OptimizerState self)"""
5430 return _IMP_kernel.OptimizerState_update_always(self)
5433 def get_number_of_updates(self):
5434 """get_number_of_updates(OptimizerState self) -> unsigned int"""
5435 return _IMP_kernel.OptimizerState_get_number_of_updates(self)
5438 def set_number_of_updates(self, n):
5439 """set_number_of_updates(OptimizerState self, unsigned int n)"""
5440 return _IMP_kernel.OptimizerState_set_number_of_updates(self, n)
5442 __swig_destroy__ = _IMP_kernel.delete_OptimizerState
5443 __del__ =
lambda self:
None
5445 def do_update(self, arg0):
5446 """do_update(OptimizerState self, unsigned int arg0)"""
5447 return _IMP_kernel.OptimizerState_do_update(self, arg0)
5450 def do_set_is_optimizing(self, arg0):
5451 """do_set_is_optimizing(OptimizerState self, bool arg0)"""
5452 return _IMP_kernel.OptimizerState_do_set_is_optimizing(self, arg0)
5455 def do_get_inputs(self):
5456 """do_get_inputs(OptimizerState self) -> IMP::ModelObjectsTemp"""
5457 return _IMP_kernel.OptimizerState_do_get_inputs(self)
5460 def do_get_outputs(self):
5461 """do_get_outputs(OptimizerState self) -> IMP::ModelObjectsTemp"""
5462 return _IMP_kernel.OptimizerState_do_get_outputs(self)
5466 """__str__(OptimizerState self) -> std::string"""
5467 return _IMP_kernel.OptimizerState___str__(self)
5471 """__repr__(OptimizerState self) -> std::string"""
5472 return _IMP_kernel.OptimizerState___repr__(self)
5477 return _object_cast_to_OptimizerState(o)
5480 def get_type_name(self):
5481 return self.__class__.__name__
5482 def do_show(self, out):
5484 def get_version_info(self):
5486 return VersionInfo(self.__module__,
5487 __import__(self.__module__).get_module_version())
5490 __import__(self.__module__).get_module_version())
5493 return _object_cast_to_OptimizerState(o)
5495 def __disown__(self):
5497 _IMP_kernel.disown_OptimizerState(self)
5498 return weakref_proxy(self)
5500 def do_destroy(self):
5501 """do_destroy(OptimizerState self)"""
5502 return _IMP_kernel.OptimizerState_do_destroy(self)
5505 def handle_set_has_required_score_states(self, arg0):
5506 """handle_set_has_required_score_states(OptimizerState self, bool arg0)"""
5507 return _IMP_kernel.OptimizerState_handle_set_has_required_score_states(self, arg0)
5510 def do_get_interactions(self):
5511 """do_get_interactions(OptimizerState self) -> IMP::ModelObjectsTemps"""
5512 return _IMP_kernel.OptimizerState_do_get_interactions(self)
5514 OptimizerState_swigregister = _IMP_kernel.OptimizerState_swigregister
5515 OptimizerState_swigregister(OptimizerState)
5517 class Refiner(_ParticleInputs, Object):
5518 """Proxy of C++ IMP::Refiner class."""
5520 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
5522 def __init__(self, *args):
5524 __init__(IMP::Refiner self, std::string name, bool is_by_ref=False) -> Refiner
5525 __init__(IMP::Refiner self, std::string name) -> Refiner
5526 __init__(IMP::Refiner self) -> Refiner
5528 if self.__class__ == Refiner:
5532 this = _IMP_kernel.new_Refiner(_self, *args)
5534 self.this.append(this)
5538 if self.__class__ != Refiner:
5539 _director_objects.register(self)
5544 def get_can_refine(self, arg0):
5545 """get_can_refine(Refiner self, Particle arg0) -> bool"""
5546 return _IMP_kernel.Refiner_get_can_refine(self, arg0)
5549 def get_refined_indexes(self, m, pi):
5550 """get_refined_indexes(Refiner self, Model m, ParticleIndex pi) -> IMP::ParticleIndexes"""
5551 return _IMP_kernel.Refiner_get_refined_indexes(self, m, pi)
5554 def get_refined_indexes_by_ref(self, m, pi):
5555 """get_refined_indexes_by_ref(Refiner self, Model m, ParticleIndex pi) -> IMP::ParticleIndexes const &"""
5556 return _IMP_kernel.Refiner_get_refined_indexes_by_ref(self, m, pi)
5559 def get_is_by_ref_supported(self):
5560 """get_is_by_ref_supported(Refiner self) -> bool"""
5561 return _IMP_kernel.Refiner_get_is_by_ref_supported(self)
5564 def get_refined(self, *args):
5566 get_refined(Refiner self, Particle a) -> IMP::ParticlesTemp const
5567 get_refined(Refiner self, Particle a, unsigned int i) -> Particle
5569 return _IMP_kernel.Refiner_get_refined(self, *args)
5572 def get_number_of_refined(self, a):
5573 """get_number_of_refined(Refiner self, Particle a) -> unsigned int"""
5574 return _IMP_kernel.Refiner_get_number_of_refined(self, a)
5578 """__str__(Refiner self) -> std::string"""
5579 return _IMP_kernel.Refiner___str__(self)
5583 """__repr__(Refiner self) -> std::string"""
5584 return _IMP_kernel.Refiner___repr__(self)
5589 return _object_cast_to_Refiner(o)
5592 def get_type_name(self):
5593 return self.__class__.__name__
5594 def do_show(self, out):
5596 def get_version_info(self):
5598 return VersionInfo(self.__module__,
5599 __import__(self.__module__).get_module_version())
5602 __import__(self.__module__).get_module_version())
5605 return _object_cast_to_Refiner(o)
5607 __swig_destroy__ = _IMP_kernel.delete_Refiner
5608 __del__ =
lambda self:
None
5609 def __disown__(self):
5611 _IMP_kernel.disown_Refiner(self)
5612 return weakref_proxy(self)
5614 def do_get_inputs(self, m, pis):
5615 """do_get_inputs(Refiner self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
5616 return _IMP_kernel.Refiner_do_get_inputs(self, m, pis)
5619 def do_destroy(self):
5620 """do_destroy(Refiner self)"""
5621 return _IMP_kernel.Refiner_do_destroy(self)
5623 Refiner_swigregister = _IMP_kernel.Refiner_swigregister
5624 Refiner_swigregister(Refiner)
5626 class Optimizer(ModelObject):
5627 """Proxy of C++ IMP::Optimizer class."""
5629 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
5631 def set_is_optimizing_states(self, tf):
5632 """set_is_optimizing_states(Optimizer self, bool tf)"""
5633 return _IMP_kernel.Optimizer_set_is_optimizing_states(self, tf)
5636 def get_optimizer_state_inputs(self):
5637 """get_optimizer_state_inputs(Optimizer self) -> IMP::ModelObjectsTemp"""
5638 return _IMP_kernel.Optimizer_get_optimizer_state_inputs(self)
5641 def do_get_inputs(self):
5642 """do_get_inputs(Optimizer self) -> IMP::ModelObjectsTemp"""
5643 return _IMP_kernel.Optimizer_do_get_inputs(self)
5646 def do_get_outputs(self):
5647 """do_get_outputs(Optimizer self) -> IMP::ModelObjectsTemp"""
5648 return _IMP_kernel.Optimizer_do_get_outputs(self)
5651 def __init__(self, *args):
5653 __init__(IMP::Optimizer self, Model m, std::string name) -> Optimizer
5654 __init__(IMP::Optimizer self, Model m) -> Optimizer
5656 if self.__class__ == Optimizer:
5660 this = _IMP_kernel.new_Optimizer(_self, *args)
5662 self.this.append(this)
5666 if self.__class__ != Optimizer:
5667 _director_objects.register(self)
5672 def optimize(self, max_steps):
5673 """optimize(Optimizer self, unsigned int max_steps) -> double"""
5674 return _IMP_kernel.Optimizer_optimize(self, max_steps)
5677 def set_stop_on_good_score(self, tf):
5678 """set_stop_on_good_score(Optimizer self, bool tf)"""
5679 return _IMP_kernel.Optimizer_set_stop_on_good_score(self, tf)
5682 def get_stop_on_good_score(self):
5683 """get_stop_on_good_score(Optimizer self) -> bool"""
5684 return _IMP_kernel.Optimizer_get_stop_on_good_score(self)
5687 def get_last_score(self):
5688 """get_last_score(Optimizer self) -> double"""
5689 return _IMP_kernel.Optimizer_get_last_score(self)
5692 def get_scoring_function(self):
5693 """get_scoring_function(Optimizer self) -> ScoringFunction"""
5694 return _IMP_kernel.Optimizer_get_scoring_function(self)
5697 def remove_optimizer_state(self, d):
5698 """remove_optimizer_state(Optimizer self, OptimizerState d)"""
5699 return _IMP_kernel.Optimizer_remove_optimizer_state(self, d)
5702 def remove_optimizer_states(self, d):
5703 """remove_optimizer_states(Optimizer self, IMP::OptimizerStates const & d)"""
5704 return _IMP_kernel.Optimizer_remove_optimizer_states(self, d)
5707 def set_optimizer_states(self, ps):
5708 """set_optimizer_states(Optimizer self, IMP::OptimizerStates const & ps)"""
5709 return _IMP_kernel.Optimizer_set_optimizer_states(self, ps)
5712 def set_optimizer_states_order(self, objs):
5713 """set_optimizer_states_order(Optimizer self, IMP::OptimizerStates const & objs)"""
5714 return _IMP_kernel.Optimizer_set_optimizer_states_order(self, objs)
5717 def add_optimizer_state(self, obj):
5718 """add_optimizer_state(Optimizer self, OptimizerState obj) -> unsigned int"""
5719 return _IMP_kernel.Optimizer_add_optimizer_state(self, obj)
5722 def add_optimizer_states(self, objs):
5723 """add_optimizer_states(Optimizer self, IMP::OptimizerStates const & objs)"""
5724 return _IMP_kernel.Optimizer_add_optimizer_states(self, objs)
5727 def clear_optimizer_states(self):
5728 """clear_optimizer_states(Optimizer self)"""
5729 return _IMP_kernel.Optimizer_clear_optimizer_states(self)
5732 def get_number_of_optimizer_states(self):
5733 """get_number_of_optimizer_states(Optimizer self) -> unsigned int"""
5734 return _IMP_kernel.Optimizer_get_number_of_optimizer_states(self)
5737 def get_has_optimizer_states(self):
5738 """get_has_optimizer_states(Optimizer self) -> bool"""
5739 return _IMP_kernel.Optimizer_get_has_optimizer_states(self)
5742 def get_optimizer_state(self, i):
5743 """get_optimizer_state(Optimizer self, unsigned int i) -> OptimizerState"""
5744 return _IMP_kernel.Optimizer_get_optimizer_state(self, i)
5747 def get_optimizer_states(self):
5748 """get_optimizer_states(Optimizer self) -> IMP::OptimizerStates"""
5749 return _IMP_kernel.Optimizer_get_optimizer_states(self)
5752 def reserve_optimizer_states(self, sz):
5753 """reserve_optimizer_states(Optimizer self, unsigned int sz)"""
5754 return _IMP_kernel.Optimizer_reserve_optimizer_states(self, sz)
5757 def set_scoring_function(self, sf):
5758 """set_scoring_function(Optimizer self, _ScoringFunctionAdaptor sf)"""
5759 return _IMP_kernel.Optimizer_set_scoring_function(self, sf)
5761 __swig_destroy__ = _IMP_kernel.delete_Optimizer
5763 """__del__(IMP::Optimizer self)"""
5765 _director_objects.cleanup()
5771 def do_optimize(self, ns):
5772 """do_optimize(Optimizer self, unsigned int ns) -> double"""
5773 return _IMP_kernel.Optimizer_do_optimize(self, ns)
5776 def update_states(self):
5777 """update_states(Optimizer self)"""
5778 return _IMP_kernel.Optimizer_update_states(self)
5782 """__str__(Optimizer self) -> std::string"""
5783 return _IMP_kernel.Optimizer___str__(self)
5787 """__repr__(Optimizer self) -> std::string"""
5788 return _IMP_kernel.Optimizer___repr__(self)
5793 return _object_cast_to_Optimizer(o)
5796 def get_type_name(self):
5797 return self.__class__.__name__
5798 def do_show(self, out):
5800 def get_version_info(self):
5802 return VersionInfo(self.__module__,
5803 __import__(self.__module__).get_module_version())
5806 __import__(self.__module__).get_module_version())
5809 return _object_cast_to_Optimizer(o)
5811 def __disown__(self):
5813 _IMP_kernel.disown_Optimizer(self)
5814 return weakref_proxy(self)
5816 def do_destroy(self):
5817 """do_destroy(Optimizer self)"""
5818 return _IMP_kernel.Optimizer_do_destroy(self)
5821 def handle_set_has_required_score_states(self, arg0):
5822 """handle_set_has_required_score_states(Optimizer self, bool arg0)"""
5823 return _IMP_kernel.Optimizer_handle_set_has_required_score_states(self, arg0)
5826 def do_get_interactions(self):
5827 """do_get_interactions(Optimizer self) -> IMP::ModelObjectsTemps"""
5828 return _IMP_kernel.Optimizer_do_get_interactions(self)
5830 Optimizer_swigregister = _IMP_kernel.Optimizer_swigregister
5831 Optimizer_swigregister(Optimizer)
5833 class AttributeOptimizer(Optimizer):
5834 """Proxy of C++ IMP::AttributeOptimizer class."""
5836 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
5838 def __init__(self, *args):
5840 __init__(IMP::AttributeOptimizer self, Model m, std::string name) -> AttributeOptimizer
5841 __init__(IMP::AttributeOptimizer self, Model m) -> AttributeOptimizer
5843 if self.__class__ == AttributeOptimizer:
5847 this = _IMP_kernel.new_AttributeOptimizer(_self, *args)
5849 self.this.append(this)
5853 if self.__class__ != AttributeOptimizer:
5854 _director_objects.register(self)
5859 def get_optimized_attributes(self):
5860 """get_optimized_attributes(AttributeOptimizer self) -> IMP::FloatIndexes"""
5861 return _IMP_kernel.AttributeOptimizer_get_optimized_attributes(self)
5864 def set_value(self, fi, v):
5865 """set_value(AttributeOptimizer self, FloatIndex fi, double v)"""
5866 return _IMP_kernel.AttributeOptimizer_set_value(self, fi, v)
5869 def get_value(self, fi):
5870 """get_value(AttributeOptimizer self, FloatIndex fi) -> IMP::Float"""
5871 return _IMP_kernel.AttributeOptimizer_get_value(self, fi)
5874 def get_derivative(self, fi):
5875 """get_derivative(AttributeOptimizer self, FloatIndex fi) -> IMP::Float"""
5876 return _IMP_kernel.AttributeOptimizer_get_derivative(self, fi)
5879 def get_width(self, k):
5880 """get_width(AttributeOptimizer self, FloatKey k) -> double"""
5881 return _IMP_kernel.AttributeOptimizer_get_width(self, k)
5884 def set_scaled_value(self, fi, v):
5885 """set_scaled_value(AttributeOptimizer self, FloatIndex fi, IMP::Float v)"""
5886 return _IMP_kernel.AttributeOptimizer_set_scaled_value(self, fi, v)
5889 def get_scaled_value(self, fi):
5890 """get_scaled_value(AttributeOptimizer self, FloatIndex fi) -> double"""
5891 return _IMP_kernel.AttributeOptimizer_get_scaled_value(self, fi)
5894 def get_scaled_derivative(self, fi):
5895 """get_scaled_derivative(AttributeOptimizer self, FloatIndex fi) -> double"""
5896 return _IMP_kernel.AttributeOptimizer_get_scaled_derivative(self, fi)
5899 def clear_range_cache(self):
5900 """clear_range_cache(AttributeOptimizer self)"""
5901 return _IMP_kernel.AttributeOptimizer_clear_range_cache(self)
5905 """__str__(AttributeOptimizer self) -> std::string"""
5906 return _IMP_kernel.AttributeOptimizer___str__(self)
5910 """__repr__(AttributeOptimizer self) -> std::string"""
5911 return _IMP_kernel.AttributeOptimizer___repr__(self)
5916 return _object_cast_to_AttributeOptimizer(o)
5919 def get_type_name(self):
5920 return self.__class__.__name__
5921 def do_show(self, out):
5923 def get_version_info(self):
5925 return VersionInfo(self.__module__,
5926 __import__(self.__module__).get_module_version())
5929 __import__(self.__module__).get_module_version())
5932 return _object_cast_to_AttributeOptimizer(o)
5934 __swig_destroy__ = _IMP_kernel.delete_AttributeOptimizer
5935 __del__ =
lambda self:
None
5936 def __disown__(self):
5938 _IMP_kernel.disown_AttributeOptimizer(self)
5939 return weakref_proxy(self)
5941 def do_destroy(self):
5942 """do_destroy(AttributeOptimizer self)"""
5943 return _IMP_kernel.AttributeOptimizer_do_destroy(self)
5946 def handle_set_has_required_score_states(self, arg0):
5947 """handle_set_has_required_score_states(AttributeOptimizer self, bool arg0)"""
5948 return _IMP_kernel.AttributeOptimizer_handle_set_has_required_score_states(self, arg0)
5951 def do_get_inputs(self):
5952 """do_get_inputs(AttributeOptimizer self) -> IMP::ModelObjectsTemp"""
5953 return _IMP_kernel.AttributeOptimizer_do_get_inputs(self)
5956 def do_get_outputs(self):
5957 """do_get_outputs(AttributeOptimizer self) -> IMP::ModelObjectsTemp"""
5958 return _IMP_kernel.AttributeOptimizer_do_get_outputs(self)
5961 def do_get_interactions(self):
5962 """do_get_interactions(AttributeOptimizer self) -> IMP::ModelObjectsTemps"""
5963 return _IMP_kernel.AttributeOptimizer_do_get_interactions(self)
5966 def do_optimize(self, ns):
5967 """do_optimize(AttributeOptimizer self, unsigned int ns) -> double"""
5968 return _IMP_kernel.AttributeOptimizer_do_optimize(self, ns)
5970 AttributeOptimizer_swigregister = _IMP_kernel.AttributeOptimizer_swigregister
5971 AttributeOptimizer_swigregister(AttributeOptimizer)
5973 class ConfigurationSet(Object):
5974 """Proxy of C++ IMP::ConfigurationSet class."""
5976 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
5978 def __init__(self, *args):
5980 __init__(IMP::ConfigurationSet self, Model m, std::string name) -> ConfigurationSet
5981 __init__(IMP::ConfigurationSet self, Model m) -> ConfigurationSet
5983 this = _IMP_kernel.new_ConfigurationSet(*args)
5985 self.this.append(this)
5989 def save_configuration(self):
5990 """save_configuration(ConfigurationSet self)"""
5991 return _IMP_kernel.ConfigurationSet_save_configuration(self)
5994 def get_number_of_configurations(self):
5995 """get_number_of_configurations(ConfigurationSet self) -> unsigned int"""
5996 return _IMP_kernel.ConfigurationSet_get_number_of_configurations(self)
5999 def load_configuration(self, i):
6000 """load_configuration(ConfigurationSet self, int i)"""
6001 return _IMP_kernel.ConfigurationSet_load_configuration(self, i)
6004 def remove_configuration(self, i):
6005 """remove_configuration(ConfigurationSet self, unsigned int i)"""
6006 return _IMP_kernel.ConfigurationSet_remove_configuration(self, i)
6009 def get_model(self):
6010 """get_model(ConfigurationSet self) -> Model"""
6011 return _IMP_kernel.ConfigurationSet_get_model(self)
6014 def get_version_info(self):
6015 """get_version_info(ConfigurationSet self) -> VersionInfo"""
6016 return _IMP_kernel.ConfigurationSet_get_version_info(self)
6020 """__str__(ConfigurationSet self) -> std::string"""
6021 return _IMP_kernel.ConfigurationSet___str__(self)
6025 """__repr__(ConfigurationSet self) -> std::string"""
6026 return _IMP_kernel.ConfigurationSet___repr__(self)
6031 return _object_cast_to_ConfigurationSet(o)
6033 ConfigurationSet_swigregister = _IMP_kernel.ConfigurationSet_swigregister
6034 ConfigurationSet_swigregister(ConfigurationSet)
6036 class SaveToConfigurationSetOptimizerState(OptimizerState):
6037 """Proxy of C++ IMP::SaveToConfigurationSetOptimizerState class."""
6039 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6041 def __init__(self, cs):
6042 """__init__(IMP::SaveToConfigurationSetOptimizerState self, ConfigurationSet cs) -> SaveToConfigurationSetOptimizerState"""
6043 this = _IMP_kernel.new_SaveToConfigurationSetOptimizerState(cs)
6045 self.this.append(this)
6049 def get_version_info(self):
6050 """get_version_info(SaveToConfigurationSetOptimizerState self) -> VersionInfo"""
6051 return _IMP_kernel.SaveToConfigurationSetOptimizerState_get_version_info(self)
6055 """__str__(SaveToConfigurationSetOptimizerState self) -> std::string"""
6056 return _IMP_kernel.SaveToConfigurationSetOptimizerState___str__(self)
6060 """__repr__(SaveToConfigurationSetOptimizerState self) -> std::string"""
6061 return _IMP_kernel.SaveToConfigurationSetOptimizerState___repr__(self)
6066 return _object_cast_to_SaveToConfigurationSetOptimizerState(o)
6068 SaveToConfigurationSetOptimizerState_swigregister = _IMP_kernel.SaveToConfigurationSetOptimizerState_swigregister
6069 SaveToConfigurationSetOptimizerState_swigregister(SaveToConfigurationSetOptimizerState)
6071 class Configuration(Object):
6072 """Proxy of C++ IMP::Configuration class."""
6074 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6076 def __init__(self, *args):
6078 __init__(IMP::Configuration self, Model m, std::string name) -> Configuration
6079 __init__(IMP::Configuration self, Model m) -> Configuration
6080 __init__(IMP::Configuration self, Model m, Configuration base, std::string name) -> Configuration
6081 __init__(IMP::Configuration self, Model m, Configuration base) -> Configuration
6083 this = _IMP_kernel.new_Configuration(*args)
6085 self.this.append(this)
6089 def load_configuration(self):
6090 """load_configuration(Configuration self)"""
6091 return _IMP_kernel.Configuration_load_configuration(self)
6094 def swap_configuration(self):
6095 """swap_configuration(Configuration self)"""
6096 return _IMP_kernel.Configuration_swap_configuration(self)
6099 def get_version_info(self):
6100 """get_version_info(Configuration self) -> VersionInfo"""
6101 return _IMP_kernel.Configuration_get_version_info(self)
6105 """__str__(Configuration self) -> std::string"""
6106 return _IMP_kernel.Configuration___str__(self)
6110 """__repr__(Configuration self) -> std::string"""
6111 return _IMP_kernel.Configuration___repr__(self)
6116 return _object_cast_to_Configuration(o)
6118 Configuration_swigregister = _IMP_kernel.Configuration_swigregister
6119 Configuration_swigregister(Configuration)
6121 class Sampler(Object):
6122 """Proxy of C++ IMP::Sampler class."""
6124 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6126 def __init__(self, *args):
6128 __init__(IMP::Sampler self, Model m, std::string name) -> Sampler
6129 __init__(IMP::Sampler self, Model m) -> Sampler
6131 if self.__class__ == Sampler:
6135 this = _IMP_kernel.new_Sampler(_self, *args)
6137 self.this.append(this)
6141 if self.__class__ != Sampler:
6142 _director_objects.register(self)
6147 def create_sample(self):
6148 """create_sample(Sampler self) -> ConfigurationSet"""
6149 return _IMP_kernel.Sampler_create_sample(self)
6152 def get_scoring_function(self):
6153 """get_scoring_function(Sampler self) -> ScoringFunction"""
6154 return _IMP_kernel.Sampler_get_scoring_function(self)
6157 def set_scoring_function(self, sf):
6158 """set_scoring_function(Sampler self, _ScoringFunctionAdaptor sf)"""
6159 return _IMP_kernel.Sampler_set_scoring_function(self, sf)
6162 def get_model(self):
6163 """get_model(Sampler self) -> Model"""
6164 return _IMP_kernel.Sampler_get_model(self)
6167 def do_sample(self):
6168 """do_sample(Sampler self) -> ConfigurationSet"""
6169 return _IMP_kernel.Sampler_do_sample(self)
6171 __swig_destroy__ = _IMP_kernel.delete_Sampler
6172 __del__ =
lambda self:
None
6175 """__str__(Sampler self) -> std::string"""
6176 return _IMP_kernel.Sampler___str__(self)
6180 """__repr__(Sampler self) -> std::string"""
6181 return _IMP_kernel.Sampler___repr__(self)
6186 return _object_cast_to_Sampler(o)
6189 def get_type_name(self):
6190 return self.__class__.__name__
6191 def do_show(self, out):
6193 def get_version_info(self):
6195 return VersionInfo(self.__module__,
6196 __import__(self.__module__).get_module_version())
6199 __import__(self.__module__).get_module_version())
6202 return _object_cast_to_Sampler(o)
6204 def __disown__(self):
6206 _IMP_kernel.disown_Sampler(self)
6207 return weakref_proxy(self)
6209 def do_destroy(self):
6210 """do_destroy(Sampler self)"""
6211 return _IMP_kernel.Sampler_do_destroy(self)
6213 Sampler_swigregister = _IMP_kernel.Sampler_swigregister
6214 Sampler_swigregister(Sampler)
6216 class PairModifier(_ParticleInputs, _ParticleOutputs, Object):
6217 """Proxy of C++ IMP::PairModifier class."""
6219 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6221 def __init__(self, *args):
6223 __init__(IMP::PairModifier self, std::string name) -> PairModifier
6224 __init__(IMP::PairModifier self) -> PairModifier
6226 if self.__class__ == PairModifier:
6230 this = _IMP_kernel.new_PairModifier(_self, *args)
6232 self.this.append(this)
6236 if self.__class__ != PairModifier:
6237 _director_objects.register(self)
6242 def apply_index(self, m, v):
6243 """apply_index(PairModifier self, Model m, IMP::ParticleIndexPair const & v)"""
6244 return _IMP_kernel.PairModifier_apply_index(self, m, v)
6247 def apply_indexes(self, m, o, lower_bound, upper_bound):
6248 """apply_indexes(PairModifier self, Model m, IMP::ParticleIndexPairs const & o, unsigned int lower_bound, unsigned int upper_bound)"""
6249 return _IMP_kernel.PairModifier_apply_indexes(self, m, o, lower_bound, upper_bound)
6253 """__str__(PairModifier self) -> std::string"""
6254 return _IMP_kernel.PairModifier___str__(self)
6258 """__repr__(PairModifier self) -> std::string"""
6259 return _IMP_kernel.PairModifier___repr__(self)
6264 return _object_cast_to_PairModifier(o)
6267 def get_type_name(self):
6268 return self.__class__.__name__
6269 def do_show(self, out):
6271 def get_version_info(self):
6273 return VersionInfo(self.__module__,
6274 __import__(self.__module__).get_module_version())
6277 __import__(self.__module__).get_module_version())
6280 return _object_cast_to_PairModifier(o)
6282 __swig_destroy__ = _IMP_kernel.delete_PairModifier
6283 __del__ =
lambda self:
None
6284 def __disown__(self):
6286 _IMP_kernel.disown_PairModifier(self)
6287 return weakref_proxy(self)
6289 def do_get_inputs(self, m, pis):
6290 """do_get_inputs(PairModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6291 return _IMP_kernel.PairModifier_do_get_inputs(self, m, pis)
6294 def do_get_outputs(self, m, pis):
6295 """do_get_outputs(PairModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6296 return _IMP_kernel.PairModifier_do_get_outputs(self, m, pis)
6299 def do_destroy(self):
6300 """do_destroy(PairModifier self)"""
6301 return _IMP_kernel.PairModifier_do_destroy(self)
6303 PairModifier_swigregister = _IMP_kernel.PairModifier_swigregister
6304 PairModifier_swigregister(PairModifier)
6306 class PairScore(_ParticleInputs, Object):
6307 """Proxy of C++ IMP::PairScore class."""
6309 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6311 def __init__(self, *args):
6313 __init__(IMP::PairScore self, std::string name) -> PairScore
6314 __init__(IMP::PairScore self) -> PairScore
6316 if self.__class__ == PairScore:
6320 this = _IMP_kernel.new_PairScore(_self, *args)
6322 self.this.append(this)
6326 if self.__class__ != PairScore:
6327 _director_objects.register(self)
6332 def evaluate_index(self, m, vt, da):
6333 """evaluate_index(PairScore self, Model m, IMP::ParticleIndexPair const & vt, DerivativeAccumulator da) -> double"""
6334 return _IMP_kernel.PairScore_evaluate_index(self, m, vt, da)
6337 def evaluate_indexes(self, m, o, da, lower_bound, upper_bound):
6338 """evaluate_indexes(PairScore self, Model m, IMP::ParticleIndexPairs const & o, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound) -> double"""
6339 return _IMP_kernel.PairScore_evaluate_indexes(self, m, o, da, lower_bound, upper_bound)
6342 def evaluate_if_good_index(self, m, vt, da, max):
6343 """evaluate_if_good_index(PairScore self, Model m, IMP::ParticleIndexPair const & vt, DerivativeAccumulator da, double max) -> double"""
6344 return _IMP_kernel.PairScore_evaluate_if_good_index(self, m, vt, da, max)
6347 def evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound):
6348 """evaluate_if_good_indexes(PairScore self, Model m, IMP::ParticleIndexPairs const & o, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound) -> double"""
6349 return _IMP_kernel.PairScore_evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound)
6352 def create_current_decomposition(self, m, vt):
6353 """create_current_decomposition(PairScore self, Model m, IMP::ParticleIndexPair const & vt) -> IMP::Restraints"""
6354 return _IMP_kernel.PairScore_create_current_decomposition(self, m, vt)
6357 def do_create_current_decomposition(self, m, vt):
6358 """do_create_current_decomposition(PairScore self, Model m, IMP::ParticleIndexPair const & vt) -> IMP::Restraints"""
6359 return _IMP_kernel.PairScore_do_create_current_decomposition(self, m, vt)
6361 __swig_destroy__ = _IMP_kernel.delete_PairScore
6362 __del__ =
lambda self:
None
6365 """__str__(PairScore self) -> std::string"""
6366 return _IMP_kernel.PairScore___str__(self)
6370 """__repr__(PairScore self) -> std::string"""
6371 return _IMP_kernel.PairScore___repr__(self)
6376 return _object_cast_to_PairScore(o)
6379 def get_type_name(self):
6380 return self.__class__.__name__
6381 def do_show(self, out):
6383 def get_version_info(self):
6385 return VersionInfo(self.__module__,
6386 __import__(self.__module__).get_module_version())
6389 __import__(self.__module__).get_module_version())
6392 return _object_cast_to_PairScore(o)
6394 def __disown__(self):
6396 _IMP_kernel.disown_PairScore(self)
6397 return weakref_proxy(self)
6399 def do_get_inputs(self, m, pis):
6400 """do_get_inputs(PairScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6401 return _IMP_kernel.PairScore_do_get_inputs(self, m, pis)
6404 def do_destroy(self):
6405 """do_destroy(PairScore self)"""
6406 return _IMP_kernel.PairScore_do_destroy(self)
6408 PairScore_swigregister = _IMP_kernel.PairScore_swigregister
6409 PairScore_swigregister(PairScore)
6411 class PairPredicate(_ParticleInputs, Object):
6412 """Proxy of C++ IMP::PairPredicate class."""
6414 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6416 def __init__(self, *args):
6418 __init__(IMP::PairPredicate self, std::string name) -> PairPredicate
6419 __init__(IMP::PairPredicate self) -> PairPredicate
6421 if self.__class__ == PairPredicate:
6425 this = _IMP_kernel.new_PairPredicate(_self, *args)
6427 self.this.append(this)
6431 if self.__class__ != PairPredicate:
6432 _director_objects.register(self)
6437 def get_value(self, *args):
6439 get_value(PairPredicate self, IMP::ParticlePair const & vt) -> int
6440 get_value(PairPredicate self, IMP::ParticlePairsTemp const & o) -> IMP::Ints
6442 return _IMP_kernel.PairPredicate_get_value(self, *args)
6445 def __call__(self, m, vt):
6446 """__call__(PairPredicate self, Model m, IMP::ParticleIndexPair const & vt) -> int"""
6447 return _IMP_kernel.PairPredicate___call__(self, m, vt)
6450 def get_value_index(self, *args):
6452 get_value_index(PairPredicate self, Model m, IMP::ParticleIndexPair const & vt) -> int
6453 get_value_index(PairPredicate self, Model m, IMP::ParticleIndexPairs const & o) -> IMP::Ints
6455 return _IMP_kernel.PairPredicate_get_value_index(self, *args)
6457 __swig_destroy__ = _IMP_kernel.delete_PairPredicate
6458 __del__ =
lambda self:
None
6461 """__str__(PairPredicate self) -> std::string"""
6462 return _IMP_kernel.PairPredicate___str__(self)
6466 """__repr__(PairPredicate self) -> std::string"""
6467 return _IMP_kernel.PairPredicate___repr__(self)
6472 return _object_cast_to_PairPredicate(o)
6475 def get_type_name(self):
6476 return self.__class__.__name__
6477 def do_show(self, out):
6479 def get_version_info(self):
6481 return VersionInfo(self.__module__,
6482 __import__(self.__module__).get_module_version())
6485 __import__(self.__module__).get_module_version())
6488 return _object_cast_to_PairPredicate(o)
6490 def __disown__(self):
6492 _IMP_kernel.disown_PairPredicate(self)
6493 return weakref_proxy(self)
6495 def do_get_inputs(self, m, pis):
6496 """do_get_inputs(PairPredicate self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6497 return _IMP_kernel.PairPredicate_do_get_inputs(self, m, pis)
6500 def do_destroy(self):
6501 """do_destroy(PairPredicate self)"""
6502 return _IMP_kernel.PairPredicate_do_destroy(self)
6504 PairPredicate_swigregister = _IMP_kernel.PairPredicate_swigregister
6505 PairPredicate_swigregister(PairPredicate)
6507 class PairContainer(Container):
6508 """Proxy of C++ IMP::PairContainer class."""
6510 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6512 def apply_generic(self, m):
6513 """apply_generic(PairContainer self, PairModifier m)"""
6514 return _IMP_kernel.PairContainer_apply_generic(self, m)
6517 def apply(self, sm):
6518 """apply(PairContainer self, PairModifier sm)"""
6519 return _IMP_kernel.PairContainer_apply(self, sm)
6522 def get_range_indexes(self):
6523 """get_range_indexes(PairContainer self) -> IMP::ParticleIndexPairs"""
6524 return _IMP_kernel.PairContainer_get_range_indexes(self)
6527 def get_contents(self):
6528 """get_contents(PairContainer self) -> IMP::ParticleIndexPairs const &"""
6529 return _IMP_kernel.PairContainer_get_contents(self)
6533 """get_indexes(PairContainer self) -> IMP::ParticleIndexPairs"""
6534 return _IMP_kernel.PairContainer_get_indexes(self)
6537 def get(self, *args):
6539 get(PairContainer self) -> IMP::ParticlePairsTemp
6540 get(PairContainer self, unsigned int i) -> IMP::ParticlePair
6542 return _IMP_kernel.PairContainer_get(self, *args)
6545 def get_number(self):
6546 """get_number(PairContainer self) -> unsigned int"""
6547 return _IMP_kernel.PairContainer_get_number(self)
6550 def get_particle_pairs(self):
6551 """get_particle_pairs(PairContainer self) -> IMP::ParticlePairsTemp"""
6552 return _IMP_kernel.PairContainer_get_particle_pairs(self)
6555 def get_particle_pair(self, i):
6556 """get_particle_pair(PairContainer self, unsigned int i) -> IMP::ParticlePair"""
6557 return _IMP_kernel.PairContainer_get_particle_pair(self, i)
6560 def __init__(self, *args):
6562 __init__(IMP::PairContainer self, Model m, std::string name) -> PairContainer
6563 __init__(IMP::PairContainer self, Model m) -> PairContainer
6565 if self.__class__ == PairContainer:
6569 this = _IMP_kernel.new_PairContainer(_self, *args)
6571 self.this.append(this)
6575 if self.__class__ != PairContainer:
6576 _director_objects.register(self)
6581 def do_apply(self, sm):
6582 """do_apply(PairContainer self, PairModifier sm)"""
6583 return _IMP_kernel.PairContainer_do_apply(self, sm)
6586 def do_get_provides_access(self):
6587 """do_get_provides_access(PairContainer self) -> bool"""
6588 return _IMP_kernel.PairContainer_do_get_provides_access(self)
6590 __swig_destroy__ = _IMP_kernel.delete_PairContainer
6591 __del__ =
lambda self:
None
6594 """__str__(PairContainer self) -> std::string"""
6595 return _IMP_kernel.PairContainer___str__(self)
6599 """__repr__(PairContainer self) -> std::string"""
6600 return _IMP_kernel.PairContainer___repr__(self)
6605 return _object_cast_to_PairContainer(o)
6608 def get_type_name(self):
6609 return self.__class__.__name__
6610 def do_show(self, out):
6612 def get_version_info(self):
6614 return VersionInfo(self.__module__,
6615 __import__(self.__module__).get_module_version())
6618 __import__(self.__module__).get_module_version())
6621 return _object_cast_to_PairContainer(o)
6623 def __disown__(self):
6625 _IMP_kernel.disown_PairContainer(self)
6626 return weakref_proxy(self)
6628 def do_destroy(self):
6629 """do_destroy(PairContainer self)"""
6630 return _IMP_kernel.PairContainer_do_destroy(self)
6633 def handle_set_has_required_score_states(self, arg0):
6634 """handle_set_has_required_score_states(PairContainer self, bool arg0)"""
6635 return _IMP_kernel.PairContainer_handle_set_has_required_score_states(self, arg0)
6638 def do_get_inputs(self):
6639 """do_get_inputs(PairContainer self) -> IMP::ModelObjectsTemp"""
6640 return _IMP_kernel.PairContainer_do_get_inputs(self)
6643 def do_get_interactions(self):
6644 """do_get_interactions(PairContainer self) -> IMP::ModelObjectsTemps"""
6645 return _IMP_kernel.PairContainer_do_get_interactions(self)
6648 def do_get_contents_hash(self):
6649 """do_get_contents_hash(PairContainer self) -> std::size_t"""
6650 return _IMP_kernel.PairContainer_do_get_contents_hash(self)
6652 PairContainer_swigregister = _IMP_kernel.PairContainer_swigregister
6653 PairContainer_swigregister(PairContainer)
6655 class _PairContainerAdaptor(_InputAdaptor):
6656 """Proxy of C++ IMP::PairContainerAdaptor class."""
6658 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6659 __repr__ = _swig_repr
6661 def __init__(self, *args):
6663 __init__(IMP::PairContainerAdaptor self) -> _PairContainerAdaptor
6664 __init__(IMP::PairContainerAdaptor self, PairContainer c) -> _PairContainerAdaptor
6665 __init__(IMP::PairContainerAdaptor self, IMP::ParticlePairsTemp const & t) -> _PairContainerAdaptor
6667 this = _IMP_kernel.new__PairContainerAdaptor(*args)
6669 self.this.append(this)
6673 def set_name_if_default(self, name):
6674 """set_name_if_default(_PairContainerAdaptor self, std::string name)"""
6675 return _IMP_kernel._PairContainerAdaptor_set_name_if_default(self, name)
6677 __swig_destroy__ = _IMP_kernel.delete__PairContainerAdaptor
6678 __del__ =
lambda self:
None
6679 _PairContainerAdaptor_swigregister = _IMP_kernel._PairContainerAdaptor_swigregister
6680 _PairContainerAdaptor_swigregister(_PairContainerAdaptor)
6682 class QuadModifier(_ParticleInputs, _ParticleOutputs, Object):
6683 """Proxy of C++ IMP::QuadModifier class."""
6685 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6687 def __init__(self, *args):
6689 __init__(IMP::QuadModifier self, std::string name) -> QuadModifier
6690 __init__(IMP::QuadModifier self) -> QuadModifier
6692 if self.__class__ == QuadModifier:
6696 this = _IMP_kernel.new_QuadModifier(_self, *args)
6698 self.this.append(this)
6702 if self.__class__ != QuadModifier:
6703 _director_objects.register(self)
6708 def apply_index(self, m, v):
6709 """apply_index(QuadModifier self, Model m, IMP::ParticleIndexQuad const & v)"""
6710 return _IMP_kernel.QuadModifier_apply_index(self, m, v)
6713 def apply_indexes(self, m, o, lower_bound, upper_bound):
6714 """apply_indexes(QuadModifier self, Model m, IMP::ParticleIndexQuads const & o, unsigned int lower_bound, unsigned int upper_bound)"""
6715 return _IMP_kernel.QuadModifier_apply_indexes(self, m, o, lower_bound, upper_bound)
6719 """__str__(QuadModifier self) -> std::string"""
6720 return _IMP_kernel.QuadModifier___str__(self)
6724 """__repr__(QuadModifier self) -> std::string"""
6725 return _IMP_kernel.QuadModifier___repr__(self)
6730 return _object_cast_to_QuadModifier(o)
6733 def get_type_name(self):
6734 return self.__class__.__name__
6735 def do_show(self, out):
6737 def get_version_info(self):
6739 return VersionInfo(self.__module__,
6740 __import__(self.__module__).get_module_version())
6743 __import__(self.__module__).get_module_version())
6746 return _object_cast_to_QuadModifier(o)
6748 __swig_destroy__ = _IMP_kernel.delete_QuadModifier
6749 __del__ =
lambda self:
None
6750 def __disown__(self):
6752 _IMP_kernel.disown_QuadModifier(self)
6753 return weakref_proxy(self)
6755 def do_get_inputs(self, m, pis):
6756 """do_get_inputs(QuadModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6757 return _IMP_kernel.QuadModifier_do_get_inputs(self, m, pis)
6760 def do_get_outputs(self, m, pis):
6761 """do_get_outputs(QuadModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6762 return _IMP_kernel.QuadModifier_do_get_outputs(self, m, pis)
6765 def do_destroy(self):
6766 """do_destroy(QuadModifier self)"""
6767 return _IMP_kernel.QuadModifier_do_destroy(self)
6769 QuadModifier_swigregister = _IMP_kernel.QuadModifier_swigregister
6770 QuadModifier_swigregister(QuadModifier)
6772 class QuadScore(_ParticleInputs, Object):
6773 """Proxy of C++ IMP::QuadScore class."""
6775 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6777 def __init__(self, *args):
6779 __init__(IMP::QuadScore self, std::string name) -> QuadScore
6780 __init__(IMP::QuadScore self) -> QuadScore
6782 if self.__class__ == QuadScore:
6786 this = _IMP_kernel.new_QuadScore(_self, *args)
6788 self.this.append(this)
6792 if self.__class__ != QuadScore:
6793 _director_objects.register(self)
6798 def evaluate_index(self, m, vt, da):
6799 """evaluate_index(QuadScore self, Model m, IMP::ParticleIndexQuad const & vt, DerivativeAccumulator da) -> double"""
6800 return _IMP_kernel.QuadScore_evaluate_index(self, m, vt, da)
6803 def evaluate_indexes(self, m, o, da, lower_bound, upper_bound):
6804 """evaluate_indexes(QuadScore self, Model m, IMP::ParticleIndexQuads const & o, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound) -> double"""
6805 return _IMP_kernel.QuadScore_evaluate_indexes(self, m, o, da, lower_bound, upper_bound)
6808 def evaluate_if_good_index(self, m, vt, da, max):
6809 """evaluate_if_good_index(QuadScore self, Model m, IMP::ParticleIndexQuad const & vt, DerivativeAccumulator da, double max) -> double"""
6810 return _IMP_kernel.QuadScore_evaluate_if_good_index(self, m, vt, da, max)
6813 def evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound):
6814 """evaluate_if_good_indexes(QuadScore self, Model m, IMP::ParticleIndexQuads const & o, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound) -> double"""
6815 return _IMP_kernel.QuadScore_evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound)
6818 def create_current_decomposition(self, m, vt):
6819 """create_current_decomposition(QuadScore self, Model m, IMP::ParticleIndexQuad const & vt) -> IMP::Restraints"""
6820 return _IMP_kernel.QuadScore_create_current_decomposition(self, m, vt)
6823 def do_create_current_decomposition(self, m, vt):
6824 """do_create_current_decomposition(QuadScore self, Model m, IMP::ParticleIndexQuad const & vt) -> IMP::Restraints"""
6825 return _IMP_kernel.QuadScore_do_create_current_decomposition(self, m, vt)
6827 __swig_destroy__ = _IMP_kernel.delete_QuadScore
6828 __del__ =
lambda self:
None
6831 """__str__(QuadScore self) -> std::string"""
6832 return _IMP_kernel.QuadScore___str__(self)
6836 """__repr__(QuadScore self) -> std::string"""
6837 return _IMP_kernel.QuadScore___repr__(self)
6842 return _object_cast_to_QuadScore(o)
6845 def get_type_name(self):
6846 return self.__class__.__name__
6847 def do_show(self, out):
6849 def get_version_info(self):
6851 return VersionInfo(self.__module__,
6852 __import__(self.__module__).get_module_version())
6855 __import__(self.__module__).get_module_version())
6858 return _object_cast_to_QuadScore(o)
6860 def __disown__(self):
6862 _IMP_kernel.disown_QuadScore(self)
6863 return weakref_proxy(self)
6865 def do_get_inputs(self, m, pis):
6866 """do_get_inputs(QuadScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6867 return _IMP_kernel.QuadScore_do_get_inputs(self, m, pis)
6870 def do_destroy(self):
6871 """do_destroy(QuadScore self)"""
6872 return _IMP_kernel.QuadScore_do_destroy(self)
6874 QuadScore_swigregister = _IMP_kernel.QuadScore_swigregister
6875 QuadScore_swigregister(QuadScore)
6877 class QuadPredicate(_ParticleInputs, Object):
6878 """Proxy of C++ IMP::QuadPredicate class."""
6880 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6882 def __init__(self, *args):
6884 __init__(IMP::QuadPredicate self, std::string name) -> QuadPredicate
6885 __init__(IMP::QuadPredicate self) -> QuadPredicate
6887 if self.__class__ == QuadPredicate:
6891 this = _IMP_kernel.new_QuadPredicate(_self, *args)
6893 self.this.append(this)
6897 if self.__class__ != QuadPredicate:
6898 _director_objects.register(self)
6903 def get_value(self, *args):
6905 get_value(QuadPredicate self, IMP::ParticleQuad const & vt) -> int
6906 get_value(QuadPredicate self, IMP::ParticleQuadsTemp const & o) -> IMP::Ints
6908 return _IMP_kernel.QuadPredicate_get_value(self, *args)
6911 def __call__(self, m, vt):
6912 """__call__(QuadPredicate self, Model m, IMP::ParticleIndexQuad const & vt) -> int"""
6913 return _IMP_kernel.QuadPredicate___call__(self, m, vt)
6916 def get_value_index(self, *args):
6918 get_value_index(QuadPredicate self, Model m, IMP::ParticleIndexQuad const & vt) -> int
6919 get_value_index(QuadPredicate self, Model m, IMP::ParticleIndexQuads const & o) -> IMP::Ints
6921 return _IMP_kernel.QuadPredicate_get_value_index(self, *args)
6923 __swig_destroy__ = _IMP_kernel.delete_QuadPredicate
6924 __del__ =
lambda self:
None
6927 """__str__(QuadPredicate self) -> std::string"""
6928 return _IMP_kernel.QuadPredicate___str__(self)
6932 """__repr__(QuadPredicate self) -> std::string"""
6933 return _IMP_kernel.QuadPredicate___repr__(self)
6938 return _object_cast_to_QuadPredicate(o)
6941 def get_type_name(self):
6942 return self.__class__.__name__
6943 def do_show(self, out):
6945 def get_version_info(self):
6947 return VersionInfo(self.__module__,
6948 __import__(self.__module__).get_module_version())
6951 __import__(self.__module__).get_module_version())
6954 return _object_cast_to_QuadPredicate(o)
6956 def __disown__(self):
6958 _IMP_kernel.disown_QuadPredicate(self)
6959 return weakref_proxy(self)
6961 def do_get_inputs(self, m, pis):
6962 """do_get_inputs(QuadPredicate self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6963 return _IMP_kernel.QuadPredicate_do_get_inputs(self, m, pis)
6966 def do_destroy(self):
6967 """do_destroy(QuadPredicate self)"""
6968 return _IMP_kernel.QuadPredicate_do_destroy(self)
6970 QuadPredicate_swigregister = _IMP_kernel.QuadPredicate_swigregister
6971 QuadPredicate_swigregister(QuadPredicate)
6973 class QuadContainer(Container):
6974 """Proxy of C++ IMP::QuadContainer class."""
6976 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6978 def apply_generic(self, m):
6979 """apply_generic(QuadContainer self, QuadModifier m)"""
6980 return _IMP_kernel.QuadContainer_apply_generic(self, m)
6983 def apply(self, sm):
6984 """apply(QuadContainer self, QuadModifier sm)"""
6985 return _IMP_kernel.QuadContainer_apply(self, sm)
6988 def get_range_indexes(self):
6989 """get_range_indexes(QuadContainer self) -> IMP::ParticleIndexQuads"""
6990 return _IMP_kernel.QuadContainer_get_range_indexes(self)
6993 def get_contents(self):
6994 """get_contents(QuadContainer self) -> IMP::ParticleIndexQuads const &"""
6995 return _IMP_kernel.QuadContainer_get_contents(self)
6999 """get_indexes(QuadContainer self) -> IMP::ParticleIndexQuads"""
7000 return _IMP_kernel.QuadContainer_get_indexes(self)
7003 def get(self, *args):
7005 get(QuadContainer self) -> IMP::ParticleQuadsTemp
7006 get(QuadContainer self, unsigned int i) -> IMP::ParticleQuad
7008 return _IMP_kernel.QuadContainer_get(self, *args)
7011 def get_number(self):
7012 """get_number(QuadContainer self) -> unsigned int"""
7013 return _IMP_kernel.QuadContainer_get_number(self)
7016 def get_particle_quads(self):
7017 """get_particle_quads(QuadContainer self) -> IMP::ParticleQuadsTemp"""
7018 return _IMP_kernel.QuadContainer_get_particle_quads(self)
7021 def get_particle_quad(self, i):
7022 """get_particle_quad(QuadContainer self, unsigned int i) -> IMP::ParticleQuad"""
7023 return _IMP_kernel.QuadContainer_get_particle_quad(self, i)
7026 def __init__(self, *args):
7028 __init__(IMP::QuadContainer self, Model m, std::string name) -> QuadContainer
7029 __init__(IMP::QuadContainer self, Model m) -> QuadContainer
7031 if self.__class__ == QuadContainer:
7035 this = _IMP_kernel.new_QuadContainer(_self, *args)
7037 self.this.append(this)
7041 if self.__class__ != QuadContainer:
7042 _director_objects.register(self)
7047 def do_apply(self, sm):
7048 """do_apply(QuadContainer self, QuadModifier sm)"""
7049 return _IMP_kernel.QuadContainer_do_apply(self, sm)
7052 def do_get_provides_access(self):
7053 """do_get_provides_access(QuadContainer self) -> bool"""
7054 return _IMP_kernel.QuadContainer_do_get_provides_access(self)
7056 __swig_destroy__ = _IMP_kernel.delete_QuadContainer
7057 __del__ =
lambda self:
None
7060 """__str__(QuadContainer self) -> std::string"""
7061 return _IMP_kernel.QuadContainer___str__(self)
7065 """__repr__(QuadContainer self) -> std::string"""
7066 return _IMP_kernel.QuadContainer___repr__(self)
7071 return _object_cast_to_QuadContainer(o)
7074 def get_type_name(self):
7075 return self.__class__.__name__
7076 def do_show(self, out):
7078 def get_version_info(self):
7080 return VersionInfo(self.__module__,
7081 __import__(self.__module__).get_module_version())
7084 __import__(self.__module__).get_module_version())
7087 return _object_cast_to_QuadContainer(o)
7089 def __disown__(self):
7091 _IMP_kernel.disown_QuadContainer(self)
7092 return weakref_proxy(self)
7094 def do_destroy(self):
7095 """do_destroy(QuadContainer self)"""
7096 return _IMP_kernel.QuadContainer_do_destroy(self)
7099 def handle_set_has_required_score_states(self, arg0):
7100 """handle_set_has_required_score_states(QuadContainer self, bool arg0)"""
7101 return _IMP_kernel.QuadContainer_handle_set_has_required_score_states(self, arg0)
7104 def do_get_inputs(self):
7105 """do_get_inputs(QuadContainer self) -> IMP::ModelObjectsTemp"""
7106 return _IMP_kernel.QuadContainer_do_get_inputs(self)
7109 def do_get_interactions(self):
7110 """do_get_interactions(QuadContainer self) -> IMP::ModelObjectsTemps"""
7111 return _IMP_kernel.QuadContainer_do_get_interactions(self)
7114 def do_get_contents_hash(self):
7115 """do_get_contents_hash(QuadContainer self) -> std::size_t"""
7116 return _IMP_kernel.QuadContainer_do_get_contents_hash(self)
7118 QuadContainer_swigregister = _IMP_kernel.QuadContainer_swigregister
7119 QuadContainer_swigregister(QuadContainer)
7121 class _QuadContainerAdaptor(_InputAdaptor):
7122 """Proxy of C++ IMP::QuadContainerAdaptor class."""
7124 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
7125 __repr__ = _swig_repr
7127 def __init__(self, *args):
7129 __init__(IMP::QuadContainerAdaptor self) -> _QuadContainerAdaptor
7130 __init__(IMP::QuadContainerAdaptor self, QuadContainer c) -> _QuadContainerAdaptor
7131 __init__(IMP::QuadContainerAdaptor self, IMP::ParticleQuadsTemp const & t) -> _QuadContainerAdaptor
7133 this = _IMP_kernel.new__QuadContainerAdaptor(*args)
7135 self.this.append(this)
7139 def set_name_if_default(self, name):
7140 """set_name_if_default(_QuadContainerAdaptor self, std::string name)"""
7141 return _IMP_kernel._QuadContainerAdaptor_set_name_if_default(self, name)
7143 __swig_destroy__ = _IMP_kernel.delete__QuadContainerAdaptor
7144 __del__ =
lambda self:
None
7145 _QuadContainerAdaptor_swigregister = _IMP_kernel._QuadContainerAdaptor_swigregister
7146 _QuadContainerAdaptor_swigregister(_QuadContainerAdaptor)
7148 class SingletonModifier(_ParticleInputs, _ParticleOutputs, Object):
7149 """Proxy of C++ IMP::SingletonModifier class."""
7151 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
7153 def __init__(self, *args):
7155 __init__(IMP::SingletonModifier self, std::string name) -> SingletonModifier
7156 __init__(IMP::SingletonModifier self) -> SingletonModifier
7158 if self.__class__ == SingletonModifier:
7162 this = _IMP_kernel.new_SingletonModifier(_self, *args)
7164 self.this.append(this)
7168 if self.__class__ != SingletonModifier:
7169 _director_objects.register(self)
7174 def apply_index(self, m, v):
7175 """apply_index(SingletonModifier self, Model m, ParticleIndex v)"""
7176 return _IMP_kernel.SingletonModifier_apply_index(self, m, v)
7179 def apply_indexes(self, m, o, lower_bound, upper_bound):
7180 """apply_indexes(SingletonModifier self, Model m, IMP::ParticleIndexes const & o, unsigned int lower_bound, unsigned int upper_bound)"""
7181 return _IMP_kernel.SingletonModifier_apply_indexes(self, m, o, lower_bound, upper_bound)
7185 """__str__(SingletonModifier self) -> std::string"""
7186 return _IMP_kernel.SingletonModifier___str__(self)
7190 """__repr__(SingletonModifier self) -> std::string"""
7191 return _IMP_kernel.SingletonModifier___repr__(self)
7196 return _object_cast_to_SingletonModifier(o)
7199 def get_type_name(self):
7200 return self.__class__.__name__
7201 def do_show(self, out):
7203 def get_version_info(self):
7205 return VersionInfo(self.__module__,
7206 __import__(self.__module__).get_module_version())
7209 __import__(self.__module__).get_module_version())
7212 return _object_cast_to_SingletonModifier(o)
7214 __swig_destroy__ = _IMP_kernel.delete_SingletonModifier
7215 __del__ =
lambda self:
None
7216 def __disown__(self):
7218 _IMP_kernel.disown_SingletonModifier(self)
7219 return weakref_proxy(self)
7221 def do_get_inputs(self, m, pis):
7222 """do_get_inputs(SingletonModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7223 return _IMP_kernel.SingletonModifier_do_get_inputs(self, m, pis)
7226 def do_get_outputs(self, m, pis):
7227 """do_get_outputs(SingletonModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7228 return _IMP_kernel.SingletonModifier_do_get_outputs(self, m, pis)
7231 def do_destroy(self):
7232 """do_destroy(SingletonModifier self)"""
7233 return _IMP_kernel.SingletonModifier_do_destroy(self)
7235 SingletonModifier_swigregister = _IMP_kernel.SingletonModifier_swigregister
7236 SingletonModifier_swigregister(SingletonModifier)
7238 class SingletonScore(_ParticleInputs, Object):
7239 """Proxy of C++ IMP::SingletonScore class."""
7241 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
7243 def __init__(self, *args):
7245 __init__(IMP::SingletonScore self, std::string name) -> SingletonScore
7246 __init__(IMP::SingletonScore self) -> SingletonScore
7248 if self.__class__ == SingletonScore:
7252 this = _IMP_kernel.new_SingletonScore(_self, *args)
7254 self.this.append(this)
7258 if self.__class__ != SingletonScore:
7259 _director_objects.register(self)
7264 def evaluate_index(self, m, vt, da):
7265 """evaluate_index(SingletonScore self, Model m, ParticleIndex vt, DerivativeAccumulator da) -> double"""
7266 return _IMP_kernel.SingletonScore_evaluate_index(self, m, vt, da)
7269 def evaluate_indexes(self, m, o, da, lower_bound, upper_bound):
7270 """evaluate_indexes(SingletonScore self, Model m, IMP::ParticleIndexes const & o, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound) -> double"""
7271 return _IMP_kernel.SingletonScore_evaluate_indexes(self, m, o, da, lower_bound, upper_bound)
7274 def evaluate_if_good_index(self, m, vt, da, max):
7275 """evaluate_if_good_index(SingletonScore self, Model m, ParticleIndex vt, DerivativeAccumulator da, double max) -> double"""
7276 return _IMP_kernel.SingletonScore_evaluate_if_good_index(self, m, vt, da, max)
7279 def evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound):
7280 """evaluate_if_good_indexes(SingletonScore self, Model m, IMP::ParticleIndexes const & o, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound) -> double"""
7281 return _IMP_kernel.SingletonScore_evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound)
7284 def create_current_decomposition(self, m, vt):
7285 """create_current_decomposition(SingletonScore self, Model m, ParticleIndex vt) -> IMP::Restraints"""
7286 return _IMP_kernel.SingletonScore_create_current_decomposition(self, m, vt)
7289 def do_create_current_decomposition(self, m, vt):
7290 """do_create_current_decomposition(SingletonScore self, Model m, ParticleIndex vt) -> IMP::Restraints"""
7291 return _IMP_kernel.SingletonScore_do_create_current_decomposition(self, m, vt)
7293 __swig_destroy__ = _IMP_kernel.delete_SingletonScore
7294 __del__ =
lambda self:
None
7297 """__str__(SingletonScore self) -> std::string"""
7298 return _IMP_kernel.SingletonScore___str__(self)
7302 """__repr__(SingletonScore self) -> std::string"""
7303 return _IMP_kernel.SingletonScore___repr__(self)
7308 return _object_cast_to_SingletonScore(o)
7311 def get_type_name(self):
7312 return self.__class__.__name__
7313 def do_show(self, out):
7315 def get_version_info(self):
7317 return VersionInfo(self.__module__,
7318 __import__(self.__module__).get_module_version())
7321 __import__(self.__module__).get_module_version())
7324 return _object_cast_to_SingletonScore(o)
7326 def __disown__(self):
7328 _IMP_kernel.disown_SingletonScore(self)
7329 return weakref_proxy(self)
7331 def do_get_inputs(self, m, pis):
7332 """do_get_inputs(SingletonScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7333 return _IMP_kernel.SingletonScore_do_get_inputs(self, m, pis)
7336 def do_destroy(self):
7337 """do_destroy(SingletonScore self)"""
7338 return _IMP_kernel.SingletonScore_do_destroy(self)
7340 SingletonScore_swigregister = _IMP_kernel.SingletonScore_swigregister
7341 SingletonScore_swigregister(SingletonScore)
7343 class SingletonPredicate(_ParticleInputs, Object):
7344 """Proxy of C++ IMP::SingletonPredicate class."""
7346 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
7348 def __init__(self, *args):
7350 __init__(IMP::SingletonPredicate self, std::string name) -> SingletonPredicate
7351 __init__(IMP::SingletonPredicate self) -> SingletonPredicate
7353 if self.__class__ == SingletonPredicate:
7357 this = _IMP_kernel.new_SingletonPredicate(_self, *args)
7359 self.this.append(this)
7363 if self.__class__ != SingletonPredicate:
7364 _director_objects.register(self)
7369 def get_value(self, *args):
7371 get_value(SingletonPredicate self, Particle vt) -> int
7372 get_value(SingletonPredicate self, IMP::ParticlesTemp const & o) -> IMP::Ints
7374 return _IMP_kernel.SingletonPredicate_get_value(self, *args)
7377 def __call__(self, m, vt):
7378 """__call__(SingletonPredicate self, Model m, ParticleIndex vt) -> int"""
7379 return _IMP_kernel.SingletonPredicate___call__(self, m, vt)
7382 def get_value_index(self, *args):
7384 get_value_index(SingletonPredicate self, Model m, ParticleIndex vt) -> int
7385 get_value_index(SingletonPredicate self, Model m, IMP::ParticleIndexes const & o) -> IMP::Ints
7387 return _IMP_kernel.SingletonPredicate_get_value_index(self, *args)
7389 __swig_destroy__ = _IMP_kernel.delete_SingletonPredicate
7390 __del__ =
lambda self:
None
7393 """__str__(SingletonPredicate self) -> std::string"""
7394 return _IMP_kernel.SingletonPredicate___str__(self)
7398 """__repr__(SingletonPredicate self) -> std::string"""
7399 return _IMP_kernel.SingletonPredicate___repr__(self)
7404 return _object_cast_to_SingletonPredicate(o)
7407 def get_type_name(self):
7408 return self.__class__.__name__
7409 def do_show(self, out):
7411 def get_version_info(self):
7413 return VersionInfo(self.__module__,
7414 __import__(self.__module__).get_module_version())
7417 __import__(self.__module__).get_module_version())
7420 return _object_cast_to_SingletonPredicate(o)
7422 def __disown__(self):
7424 _IMP_kernel.disown_SingletonPredicate(self)
7425 return weakref_proxy(self)
7427 def do_get_inputs(self, m, pis):
7428 """do_get_inputs(SingletonPredicate self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7429 return _IMP_kernel.SingletonPredicate_do_get_inputs(self, m, pis)
7432 def do_destroy(self):
7433 """do_destroy(SingletonPredicate self)"""
7434 return _IMP_kernel.SingletonPredicate_do_destroy(self)
7436 SingletonPredicate_swigregister = _IMP_kernel.SingletonPredicate_swigregister
7437 SingletonPredicate_swigregister(SingletonPredicate)
7439 class SingletonContainer(Container):
7440 """Proxy of C++ IMP::SingletonContainer class."""
7442 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
7444 def apply_generic(self, m):
7445 """apply_generic(SingletonContainer self, SingletonModifier m)"""
7446 return _IMP_kernel.SingletonContainer_apply_generic(self, m)
7449 def apply(self, sm):
7450 """apply(SingletonContainer self, SingletonModifier sm)"""
7451 return _IMP_kernel.SingletonContainer_apply(self, sm)
7454 def get_range_indexes(self):
7455 """get_range_indexes(SingletonContainer self) -> IMP::ParticleIndexes"""
7456 return _IMP_kernel.SingletonContainer_get_range_indexes(self)
7459 def get_contents(self):
7460 """get_contents(SingletonContainer self) -> IMP::ParticleIndexes const &"""
7461 return _IMP_kernel.SingletonContainer_get_contents(self)
7465 """get_indexes(SingletonContainer self) -> IMP::ParticleIndexes"""
7466 return _IMP_kernel.SingletonContainer_get_indexes(self)
7469 def get(self, *args):
7471 get(SingletonContainer self) -> IMP::ParticlesTemp
7472 get(SingletonContainer self, unsigned int i) -> Particle
7474 return _IMP_kernel.SingletonContainer_get(self, *args)
7477 def get_number(self):
7478 """get_number(SingletonContainer self) -> unsigned int"""
7479 return _IMP_kernel.SingletonContainer_get_number(self)
7483 """get_particles(SingletonContainer self) -> IMP::ParticlesTemp"""
7484 return _IMP_kernel.SingletonContainer_get_particles(self)
7487 def get_particle(self, i):
7488 """get_particle(SingletonContainer self, unsigned int i) -> Particle"""
7489 return _IMP_kernel.SingletonContainer_get_particle(self, i)
7492 def __init__(self, *args):
7494 __init__(IMP::SingletonContainer self, Model m, std::string name) -> SingletonContainer
7495 __init__(IMP::SingletonContainer self, Model m) -> SingletonContainer
7497 if self.__class__ == SingletonContainer:
7501 this = _IMP_kernel.new_SingletonContainer(_self, *args)
7503 self.this.append(this)
7507 if self.__class__ != SingletonContainer:
7508 _director_objects.register(self)
7513 def do_apply(self, sm):
7514 """do_apply(SingletonContainer self, SingletonModifier sm)"""
7515 return _IMP_kernel.SingletonContainer_do_apply(self, sm)
7518 def do_get_provides_access(self):
7519 """do_get_provides_access(SingletonContainer self) -> bool"""
7520 return _IMP_kernel.SingletonContainer_do_get_provides_access(self)
7522 __swig_destroy__ = _IMP_kernel.delete_SingletonContainer
7523 __del__ =
lambda self:
None
7526 """__str__(SingletonContainer self) -> std::string"""
7527 return _IMP_kernel.SingletonContainer___str__(self)
7531 """__repr__(SingletonContainer self) -> std::string"""
7532 return _IMP_kernel.SingletonContainer___repr__(self)
7537 return _object_cast_to_SingletonContainer(o)
7540 def get_type_name(self):
7541 return self.__class__.__name__
7542 def do_show(self, out):
7544 def get_version_info(self):
7546 return VersionInfo(self.__module__,
7547 __import__(self.__module__).get_module_version())
7550 __import__(self.__module__).get_module_version())
7553 return _object_cast_to_SingletonContainer(o)
7555 def __disown__(self):
7557 _IMP_kernel.disown_SingletonContainer(self)
7558 return weakref_proxy(self)
7560 def do_destroy(self):
7561 """do_destroy(SingletonContainer self)"""
7562 return _IMP_kernel.SingletonContainer_do_destroy(self)
7565 def handle_set_has_required_score_states(self, arg0):
7566 """handle_set_has_required_score_states(SingletonContainer self, bool arg0)"""
7567 return _IMP_kernel.SingletonContainer_handle_set_has_required_score_states(self, arg0)
7570 def do_get_inputs(self):
7571 """do_get_inputs(SingletonContainer self) -> IMP::ModelObjectsTemp"""
7572 return _IMP_kernel.SingletonContainer_do_get_inputs(self)
7575 def do_get_interactions(self):
7576 """do_get_interactions(SingletonContainer self) -> IMP::ModelObjectsTemps"""
7577 return _IMP_kernel.SingletonContainer_do_get_interactions(self)
7580 def do_get_contents_hash(self):
7581 """do_get_contents_hash(SingletonContainer self) -> std::size_t"""
7582 return _IMP_kernel.SingletonContainer_do_get_contents_hash(self)
7584 SingletonContainer_swigregister = _IMP_kernel.SingletonContainer_swigregister
7585 SingletonContainer_swigregister(SingletonContainer)
7587 class _SingletonContainerAdaptor(_InputAdaptor):
7588 """Proxy of C++ IMP::SingletonContainerAdaptor class."""
7590 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
7591 __repr__ = _swig_repr
7593 def __init__(self, *args):
7595 __init__(IMP::SingletonContainerAdaptor self) -> _SingletonContainerAdaptor
7596 __init__(IMP::SingletonContainerAdaptor self, SingletonContainer c) -> _SingletonContainerAdaptor
7597 __init__(IMP::SingletonContainerAdaptor self, IMP::ParticlesTemp const & t) -> _SingletonContainerAdaptor
7599 this = _IMP_kernel.new__SingletonContainerAdaptor(*args)
7601 self.this.append(this)
7605 def set_name_if_default(self, name):
7606 """set_name_if_default(_SingletonContainerAdaptor self, std::string name)"""
7607 return _IMP_kernel._SingletonContainerAdaptor_set_name_if_default(self, name)
7609 __swig_destroy__ = _IMP_kernel.delete__SingletonContainerAdaptor
7610 __del__ =
lambda self:
None
7611 _SingletonContainerAdaptor_swigregister = _IMP_kernel._SingletonContainerAdaptor_swigregister
7612 _SingletonContainerAdaptor_swigregister(_SingletonContainerAdaptor)
7614 class TripletModifier(_ParticleInputs, _ParticleOutputs, Object):
7615 """Proxy of C++ IMP::TripletModifier class."""
7617 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
7619 def __init__(self, *args):
7621 __init__(IMP::TripletModifier self, std::string name) -> TripletModifier
7622 __init__(IMP::TripletModifier self) -> TripletModifier
7624 if self.__class__ == TripletModifier:
7628 this = _IMP_kernel.new_TripletModifier(_self, *args)
7630 self.this.append(this)
7634 if self.__class__ != TripletModifier:
7635 _director_objects.register(self)
7640 def apply_index(self, m, v):
7641 """apply_index(TripletModifier self, Model m, IMP::ParticleIndexTriplet const & v)"""
7642 return _IMP_kernel.TripletModifier_apply_index(self, m, v)
7645 def apply_indexes(self, m, o, lower_bound, upper_bound):
7646 """apply_indexes(TripletModifier self, Model m, IMP::ParticleIndexTriplets const & o, unsigned int lower_bound, unsigned int upper_bound)"""
7647 return _IMP_kernel.TripletModifier_apply_indexes(self, m, o, lower_bound, upper_bound)
7651 """__str__(TripletModifier self) -> std::string"""
7652 return _IMP_kernel.TripletModifier___str__(self)
7656 """__repr__(TripletModifier self) -> std::string"""
7657 return _IMP_kernel.TripletModifier___repr__(self)
7662 return _object_cast_to_TripletModifier(o)
7665 def get_type_name(self):
7666 return self.__class__.__name__
7667 def do_show(self, out):
7669 def get_version_info(self):
7671 return VersionInfo(self.__module__,
7672 __import__(self.__module__).get_module_version())
7675 __import__(self.__module__).get_module_version())
7678 return _object_cast_to_TripletModifier(o)
7680 __swig_destroy__ = _IMP_kernel.delete_TripletModifier
7681 __del__ =
lambda self:
None
7682 def __disown__(self):
7684 _IMP_kernel.disown_TripletModifier(self)
7685 return weakref_proxy(self)
7687 def do_get_inputs(self, m, pis):
7688 """do_get_inputs(TripletModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7689 return _IMP_kernel.TripletModifier_do_get_inputs(self, m, pis)
7692 def do_get_outputs(self, m, pis):
7693 """do_get_outputs(TripletModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7694 return _IMP_kernel.TripletModifier_do_get_outputs(self, m, pis)
7697 def do_destroy(self):
7698 """do_destroy(TripletModifier self)"""
7699 return _IMP_kernel.TripletModifier_do_destroy(self)
7701 TripletModifier_swigregister = _IMP_kernel.TripletModifier_swigregister
7702 TripletModifier_swigregister(TripletModifier)
7704 class TripletScore(_ParticleInputs, Object):
7705 """Proxy of C++ IMP::TripletScore class."""
7707 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
7709 def __init__(self, *args):
7711 __init__(IMP::TripletScore self, std::string name) -> TripletScore
7712 __init__(IMP::TripletScore self) -> TripletScore
7714 if self.__class__ == TripletScore:
7718 this = _IMP_kernel.new_TripletScore(_self, *args)
7720 self.this.append(this)
7724 if self.__class__ != TripletScore:
7725 _director_objects.register(self)
7730 def evaluate_index(self, m, vt, da):
7731 """evaluate_index(TripletScore self, Model m, IMP::ParticleIndexTriplet const & vt, DerivativeAccumulator da) -> double"""
7732 return _IMP_kernel.TripletScore_evaluate_index(self, m, vt, da)
7735 def evaluate_indexes(self, m, o, da, lower_bound, upper_bound):
7736 """evaluate_indexes(TripletScore self, Model m, IMP::ParticleIndexTriplets const & o, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound) -> double"""
7737 return _IMP_kernel.TripletScore_evaluate_indexes(self, m, o, da, lower_bound, upper_bound)
7740 def evaluate_if_good_index(self, m, vt, da, max):
7741 """evaluate_if_good_index(TripletScore self, Model m, IMP::ParticleIndexTriplet const & vt, DerivativeAccumulator da, double max) -> double"""
7742 return _IMP_kernel.TripletScore_evaluate_if_good_index(self, m, vt, da, max)
7745 def evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound):
7746 """evaluate_if_good_indexes(TripletScore self, Model m, IMP::ParticleIndexTriplets const & o, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound) -> double"""
7747 return _IMP_kernel.TripletScore_evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound)
7750 def create_current_decomposition(self, m, vt):
7751 """create_current_decomposition(TripletScore self, Model m, IMP::ParticleIndexTriplet const & vt) -> IMP::Restraints"""
7752 return _IMP_kernel.TripletScore_create_current_decomposition(self, m, vt)
7755 def do_create_current_decomposition(self, m, vt):
7756 """do_create_current_decomposition(TripletScore self, Model m, IMP::ParticleIndexTriplet const & vt) -> IMP::Restraints"""
7757 return _IMP_kernel.TripletScore_do_create_current_decomposition(self, m, vt)
7759 __swig_destroy__ = _IMP_kernel.delete_TripletScore
7760 __del__ =
lambda self:
None
7763 """__str__(TripletScore self) -> std::string"""
7764 return _IMP_kernel.TripletScore___str__(self)
7768 """__repr__(TripletScore self) -> std::string"""
7769 return _IMP_kernel.TripletScore___repr__(self)
7774 return _object_cast_to_TripletScore(o)
7777 def get_type_name(self):
7778 return self.__class__.__name__
7779 def do_show(self, out):
7781 def get_version_info(self):
7783 return VersionInfo(self.__module__,
7784 __import__(self.__module__).get_module_version())
7787 __import__(self.__module__).get_module_version())
7790 return _object_cast_to_TripletScore(o)
7792 def __disown__(self):
7794 _IMP_kernel.disown_TripletScore(self)
7795 return weakref_proxy(self)
7797 def do_get_inputs(self, m, pis):
7798 """do_get_inputs(TripletScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7799 return _IMP_kernel.TripletScore_do_get_inputs(self, m, pis)
7802 def do_destroy(self):
7803 """do_destroy(TripletScore self)"""
7804 return _IMP_kernel.TripletScore_do_destroy(self)
7806 TripletScore_swigregister = _IMP_kernel.TripletScore_swigregister
7807 TripletScore_swigregister(TripletScore)
7809 class TripletPredicate(_ParticleInputs, Object):
7810 """Proxy of C++ IMP::TripletPredicate class."""
7812 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
7814 def __init__(self, *args):
7816 __init__(IMP::TripletPredicate self, std::string name) -> TripletPredicate
7817 __init__(IMP::TripletPredicate self) -> TripletPredicate
7819 if self.__class__ == TripletPredicate:
7823 this = _IMP_kernel.new_TripletPredicate(_self, *args)
7825 self.this.append(this)
7829 if self.__class__ != TripletPredicate:
7830 _director_objects.register(self)
7835 def get_value(self, *args):
7837 get_value(TripletPredicate self, IMP::ParticleTriplet const & vt) -> int
7838 get_value(TripletPredicate self, IMP::ParticleTripletsTemp const & o) -> IMP::Ints
7840 return _IMP_kernel.TripletPredicate_get_value(self, *args)
7843 def __call__(self, m, vt):
7844 """__call__(TripletPredicate self, Model m, IMP::ParticleIndexTriplet const & vt) -> int"""
7845 return _IMP_kernel.TripletPredicate___call__(self, m, vt)
7848 def get_value_index(self, *args):
7850 get_value_index(TripletPredicate self, Model m, IMP::ParticleIndexTriplet const & vt) -> int
7851 get_value_index(TripletPredicate self, Model m, IMP::ParticleIndexTriplets const & o) -> IMP::Ints
7853 return _IMP_kernel.TripletPredicate_get_value_index(self, *args)
7855 __swig_destroy__ = _IMP_kernel.delete_TripletPredicate
7856 __del__ =
lambda self:
None
7859 """__str__(TripletPredicate self) -> std::string"""
7860 return _IMP_kernel.TripletPredicate___str__(self)
7864 """__repr__(TripletPredicate self) -> std::string"""
7865 return _IMP_kernel.TripletPredicate___repr__(self)
7870 return _object_cast_to_TripletPredicate(o)
7873 def get_type_name(self):
7874 return self.__class__.__name__
7875 def do_show(self, out):
7877 def get_version_info(self):
7879 return VersionInfo(self.__module__,
7880 __import__(self.__module__).get_module_version())
7883 __import__(self.__module__).get_module_version())
7886 return _object_cast_to_TripletPredicate(o)
7888 def __disown__(self):
7890 _IMP_kernel.disown_TripletPredicate(self)
7891 return weakref_proxy(self)
7893 def do_get_inputs(self, m, pis):
7894 """do_get_inputs(TripletPredicate self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7895 return _IMP_kernel.TripletPredicate_do_get_inputs(self, m, pis)
7898 def do_destroy(self):
7899 """do_destroy(TripletPredicate self)"""
7900 return _IMP_kernel.TripletPredicate_do_destroy(self)
7902 TripletPredicate_swigregister = _IMP_kernel.TripletPredicate_swigregister
7903 TripletPredicate_swigregister(TripletPredicate)
7905 class TripletContainer(Container):
7906 """Proxy of C++ IMP::TripletContainer class."""
7908 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
7910 def apply_generic(self, m):
7911 """apply_generic(TripletContainer self, TripletModifier m)"""
7912 return _IMP_kernel.TripletContainer_apply_generic(self, m)
7915 def apply(self, sm):
7916 """apply(TripletContainer self, TripletModifier sm)"""
7917 return _IMP_kernel.TripletContainer_apply(self, sm)
7920 def get_range_indexes(self):
7921 """get_range_indexes(TripletContainer self) -> IMP::ParticleIndexTriplets"""
7922 return _IMP_kernel.TripletContainer_get_range_indexes(self)
7925 def get_contents(self):
7926 """get_contents(TripletContainer self) -> IMP::ParticleIndexTriplets const &"""
7927 return _IMP_kernel.TripletContainer_get_contents(self)
7931 """get_indexes(TripletContainer self) -> IMP::ParticleIndexTriplets"""
7932 return _IMP_kernel.TripletContainer_get_indexes(self)
7935 def get(self, *args):
7937 get(TripletContainer self) -> IMP::ParticleTripletsTemp
7938 get(TripletContainer self, unsigned int i) -> IMP::ParticleTriplet
7940 return _IMP_kernel.TripletContainer_get(self, *args)
7943 def get_number(self):
7944 """get_number(TripletContainer self) -> unsigned int"""
7945 return _IMP_kernel.TripletContainer_get_number(self)
7948 def get_particle_triplets(self):
7949 """get_particle_triplets(TripletContainer self) -> IMP::ParticleTripletsTemp"""
7950 return _IMP_kernel.TripletContainer_get_particle_triplets(self)
7953 def get_particle_triplet(self, i):
7954 """get_particle_triplet(TripletContainer self, unsigned int i) -> IMP::ParticleTriplet"""
7955 return _IMP_kernel.TripletContainer_get_particle_triplet(self, i)
7958 def __init__(self, *args):
7960 __init__(IMP::TripletContainer self, Model m, std::string name) -> TripletContainer
7961 __init__(IMP::TripletContainer self, Model m) -> TripletContainer
7963 if self.__class__ == TripletContainer:
7967 this = _IMP_kernel.new_TripletContainer(_self, *args)
7969 self.this.append(this)
7973 if self.__class__ != TripletContainer:
7974 _director_objects.register(self)
7979 def do_apply(self, sm):
7980 """do_apply(TripletContainer self, TripletModifier sm)"""
7981 return _IMP_kernel.TripletContainer_do_apply(self, sm)
7984 def do_get_provides_access(self):
7985 """do_get_provides_access(TripletContainer self) -> bool"""
7986 return _IMP_kernel.TripletContainer_do_get_provides_access(self)
7988 __swig_destroy__ = _IMP_kernel.delete_TripletContainer
7989 __del__ =
lambda self:
None
7992 """__str__(TripletContainer self) -> std::string"""
7993 return _IMP_kernel.TripletContainer___str__(self)
7997 """__repr__(TripletContainer self) -> std::string"""
7998 return _IMP_kernel.TripletContainer___repr__(self)
8003 return _object_cast_to_TripletContainer(o)
8006 def get_type_name(self):
8007 return self.__class__.__name__
8008 def do_show(self, out):
8010 def get_version_info(self):
8012 return VersionInfo(self.__module__,
8013 __import__(self.__module__).get_module_version())
8016 __import__(self.__module__).get_module_version())
8019 return _object_cast_to_TripletContainer(o)
8021 def __disown__(self):
8023 _IMP_kernel.disown_TripletContainer(self)
8024 return weakref_proxy(self)
8026 def do_destroy(self):
8027 """do_destroy(TripletContainer self)"""
8028 return _IMP_kernel.TripletContainer_do_destroy(self)
8031 def handle_set_has_required_score_states(self, arg0):
8032 """handle_set_has_required_score_states(TripletContainer self, bool arg0)"""
8033 return _IMP_kernel.TripletContainer_handle_set_has_required_score_states(self, arg0)
8036 def do_get_inputs(self):
8037 """do_get_inputs(TripletContainer self) -> IMP::ModelObjectsTemp"""
8038 return _IMP_kernel.TripletContainer_do_get_inputs(self)
8041 def do_get_interactions(self):
8042 """do_get_interactions(TripletContainer self) -> IMP::ModelObjectsTemps"""
8043 return _IMP_kernel.TripletContainer_do_get_interactions(self)
8046 def do_get_contents_hash(self):
8047 """do_get_contents_hash(TripletContainer self) -> std::size_t"""
8048 return _IMP_kernel.TripletContainer_do_get_contents_hash(self)
8050 TripletContainer_swigregister = _IMP_kernel.TripletContainer_swigregister
8051 TripletContainer_swigregister(TripletContainer)
8053 class _TripletContainerAdaptor(_InputAdaptor):
8054 """Proxy of C++ IMP::TripletContainerAdaptor class."""
8056 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
8057 __repr__ = _swig_repr
8059 def __init__(self, *args):
8061 __init__(IMP::TripletContainerAdaptor self) -> _TripletContainerAdaptor
8062 __init__(IMP::TripletContainerAdaptor self, TripletContainer c) -> _TripletContainerAdaptor
8063 __init__(IMP::TripletContainerAdaptor self, IMP::ParticleTripletsTemp const & t) -> _TripletContainerAdaptor
8065 this = _IMP_kernel.new__TripletContainerAdaptor(*args)
8067 self.this.append(this)
8071 def set_name_if_default(self, name):
8072 """set_name_if_default(_TripletContainerAdaptor self, std::string name)"""
8073 return _IMP_kernel._TripletContainerAdaptor_set_name_if_default(self, name)
8075 __swig_destroy__ = _IMP_kernel.delete__TripletContainerAdaptor
8076 __del__ =
lambda self:
None
8077 _TripletContainerAdaptor_swigregister = _IMP_kernel._TripletContainerAdaptor_swigregister
8078 _TripletContainerAdaptor_swigregister(_TripletContainerAdaptor)
8082 """write_particles_to_buffer(IMP::ParticlesTemp const & particles, IMP::FloatKeys const & keys) -> IMP::Vector< char >"""
8083 return _IMP_kernel.write_particles_to_buffer(particles, keys)
8086 """read_particles_from_buffer(IMP::Vector< char > const & buffer, IMP::ParticlesTemp const & particles, IMP::FloatKeys const & keys)"""
8087 return _IMP_kernel.read_particles_from_buffer(buffer, particles, keys)
8090 """get_particles(Model m, IMP::ParticleIndexes const & ps) -> IMP::ParticlesTemp"""
8091 return _IMP_kernel.get_particles(m, ps)
8095 get_indexes(IMP::ParticlesTemp const & ps) -> IMP::ParticleIndexes
8096 get_indexes(IMP::ParticlePairsTemp const & ps) -> IMP::ParticleIndexPairs
8098 return _IMP_kernel.get_indexes(*args)
8099 class _ParticleIndexAdaptor(object):
8100 """Proxy of C++ IMP::ParticleIndexAdaptor class."""
8102 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
8103 __repr__ = _swig_repr
8105 def __init__(self, *args):
8107 __init__(IMP::ParticleIndexAdaptor self, Particle p) -> _ParticleIndexAdaptor
8108 __init__(IMP::ParticleIndexAdaptor self, ParticleIndex pi) -> _ParticleIndexAdaptor
8109 __init__(IMP::ParticleIndexAdaptor self, Decorator d) -> _ParticleIndexAdaptor
8111 this = _IMP_kernel.new__ParticleIndexAdaptor(*args)
8113 self.this.append(this)
8116 __swig_destroy__ = _IMP_kernel.delete__ParticleIndexAdaptor
8117 __del__ =
lambda self:
None
8118 _ParticleIndexAdaptor_swigregister = _IMP_kernel._ParticleIndexAdaptor_swigregister
8119 _ParticleIndexAdaptor_swigregister(_ParticleIndexAdaptor)
8121 class _ParticleIndexesAdaptor(_InputAdaptor):
8122 """Proxy of C++ IMP::ParticleIndexesAdaptor class."""
8124 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
8125 __repr__ = _swig_repr
8127 def __init__(self, *args):
8129 __init__(IMP::ParticleIndexesAdaptor self, IMP::ParticlesTemp const & ps) -> _ParticleIndexesAdaptor
8130 __init__(IMP::ParticleIndexesAdaptor self, IMP::ParticleIndexes const & pi) -> _ParticleIndexesAdaptor
8131 __init__(IMP::ParticleIndexesAdaptor self) -> _ParticleIndexesAdaptor
8133 this = _IMP_kernel.new__ParticleIndexesAdaptor(*args)
8135 self.this.append(this)
8138 __swig_destroy__ = _IMP_kernel.delete__ParticleIndexesAdaptor
8139 __del__ =
lambda self:
None
8140 _ParticleIndexesAdaptor_swigregister = _IMP_kernel._ParticleIndexesAdaptor_swigregister
8141 _ParticleIndexesAdaptor_swigregister(_ParticleIndexesAdaptor)
8143 class _ParticleIndexPairsAdaptor(object):
8144 """Proxy of C++ IMP::ParticleIndexPairsAdaptor class."""
8146 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
8147 __repr__ = _swig_repr
8149 def __init__(self, *args):
8151 __init__(IMP::ParticleIndexPairsAdaptor self, IMP::ParticlePairsTemp const & ps) -> _ParticleIndexPairsAdaptor
8152 __init__(IMP::ParticleIndexPairsAdaptor self, IMP::ParticleIndexPairs const & pi) -> _ParticleIndexPairsAdaptor
8153 __init__(IMP::ParticleIndexPairsAdaptor self) -> _ParticleIndexPairsAdaptor
8155 this = _IMP_kernel.new__ParticleIndexPairsAdaptor(*args)
8157 self.this.append(this)
8160 __swig_destroy__ = _IMP_kernel.delete__ParticleIndexPairsAdaptor
8161 __del__ =
lambda self:
None
8162 _ParticleIndexPairsAdaptor_swigregister = _IMP_kernel._ParticleIndexPairsAdaptor_swigregister
8163 _ParticleIndexPairsAdaptor_swigregister(_ParticleIndexPairsAdaptor)
8165 class _ConstRestraint(Restraint):
8166 """Proxy of C++ IMP::internal::_ConstRestraint class."""
8168 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
8170 def __init__(self, *args):
8172 __init__(IMP::internal::_ConstRestraint self, double v, IMP::ParticlesTemp const ps) -> _ConstRestraint
8173 __init__(IMP::internal::_ConstRestraint self, Model m, IMP::ParticleIndexes const & pis, double v) -> _ConstRestraint
8175 this = _IMP_kernel.new__ConstRestraint(*args)
8177 self.this.append(this)
8181 def get_value(self):
8182 """get_value(_ConstRestraint self) -> double"""
8183 return _IMP_kernel._ConstRestraint_get_value(self)
8186 def do_create_decomposition(self):
8187 """do_create_decomposition(_ConstRestraint self) -> IMP::Restraints"""
8188 return _IMP_kernel._ConstRestraint_do_create_decomposition(self)
8191 def do_get_inputs(self):
8192 """do_get_inputs(_ConstRestraint self) -> IMP::ModelObjectsTemp"""
8193 return _IMP_kernel._ConstRestraint_do_get_inputs(self)
8196 def get_version_info(self):
8197 """get_version_info(_ConstRestraint self) -> VersionInfo"""
8198 return _IMP_kernel._ConstRestraint_get_version_info(self)
8202 """__str__(_ConstRestraint self) -> std::string"""
8203 return _IMP_kernel._ConstRestraint___str__(self)
8207 """__repr__(_ConstRestraint self) -> std::string"""
8208 return _IMP_kernel._ConstRestraint___repr__(self)
8213 return _object_cast_to__ConstRestraint(o)
8215 _ConstRestraint_swigregister = _IMP_kernel._ConstRestraint_swigregister
8216 _ConstRestraint_swigregister(_ConstRestraint)
8218 class _ConstSingletonScore(SingletonScore):
8219 """Proxy of C++ IMP::internal::_ConstSingletonScore class."""
8221 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
8222 __repr__ = _swig_repr
8224 def __init__(self, v):
8225 """__init__(IMP::internal::_ConstSingletonScore self, double v) -> _ConstSingletonScore"""
8226 this = _IMP_kernel.new__ConstSingletonScore(v)
8228 self.this.append(this)
8232 def do_get_inputs(self, arg2, arg3):
8233 """do_get_inputs(_ConstSingletonScore self, Model arg2, IMP::ParticleIndexes const & arg3) -> IMP::ModelObjectsTemp"""
8234 return _IMP_kernel._ConstSingletonScore_do_get_inputs(self, arg2, arg3)
8237 def get_version_info(self):
8238 """get_version_info(_ConstSingletonScore self) -> VersionInfo"""
8239 return _IMP_kernel._ConstSingletonScore_get_version_info(self)
8241 _ConstSingletonScore_swigregister = _IMP_kernel._ConstSingletonScore_swigregister
8242 _ConstSingletonScore_swigregister(_ConstSingletonScore)
8244 class _ConstPairScore(PairScore):
8245 """Proxy of C++ IMP::internal::_ConstPairScore class."""
8247 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
8248 __repr__ = _swig_repr
8250 def __init__(self, v):
8251 """__init__(IMP::internal::_ConstPairScore self, double v) -> _ConstPairScore"""
8252 this = _IMP_kernel.new__ConstPairScore(v)
8254 self.this.append(this)
8258 def do_get_inputs(self, arg2, arg3):
8259 """do_get_inputs(_ConstPairScore self, Model arg2, IMP::ParticleIndexes const & arg3) -> IMP::ModelObjectsTemp"""
8260 return _IMP_kernel._ConstPairScore_do_get_inputs(self, arg2, arg3)
8263 def get_version_info(self):
8264 """get_version_info(_ConstPairScore self) -> VersionInfo"""
8265 return _IMP_kernel._ConstPairScore_get_version_info(self)
8267 _ConstPairScore_swigregister = _IMP_kernel._ConstPairScore_swigregister
8268 _ConstPairScore_swigregister(_ConstPairScore)
8270 class _TrivialDecorator(Decorator):
8271 """Proxy of C++ IMP::internal::_TrivialDecorator class."""
8273 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
8275 def __init__(self, *args):
8277 __init__(IMP::internal::_TrivialDecorator self) -> _TrivialDecorator
8278 __init__(IMP::internal::_TrivialDecorator self, Model m, ParticleIndex id) -> _TrivialDecorator
8279 __init__(IMP::internal::_TrivialDecorator self, _ParticleAdaptor d) -> _TrivialDecorator
8281 this = _IMP_kernel.new__TrivialDecorator(*args)
8283 self.this.append(this)
8287 def show(self, *args):
8289 show(_TrivialDecorator self, _ostream out)
8290 show(_TrivialDecorator self)
8292 return _IMP_kernel._TrivialDecorator_show(self, *args)
8295 def setup_particle(*args):
8297 setup_particle(Model m, ParticleIndex pi) -> _TrivialDecorator
8298 setup_particle(_ParticleAdaptor decorator) -> _TrivialDecorator
8300 return _IMP_kernel._TrivialDecorator_setup_particle(*args)
8302 setup_particle = staticmethod(setup_particle)
8304 def get_is_setup(*args):
8306 get_is_setup(_ParticleAdaptor p) -> bool
8307 get_is_setup(Model m, ParticleIndex pi) -> bool
8309 return _IMP_kernel._TrivialDecorator_get_is_setup(*args)
8311 get_is_setup = staticmethod(get_is_setup)
8313 def add_attribute(self, *args):
8315 add_attribute(_TrivialDecorator self, FloatKey k, IMP::Float v, bool opt)
8316 add_attribute(_TrivialDecorator self, FloatKey a0, IMP::Float a1)
8317 add_attribute(_TrivialDecorator self, IntKey a0, IMP::Int a1)
8318 add_attribute(_TrivialDecorator self, StringKey a0, IMP::String a1)
8319 add_attribute(_TrivialDecorator self, ParticleIndexKey a0, Particle a1)
8320 add_attribute(_TrivialDecorator self, ObjectKey a0, Object a1)
8322 return _IMP_kernel._TrivialDecorator_add_attribute(self, *args)
8325 def get_value(self, *args):
8327 get_value(_TrivialDecorator self, FloatKey a0) -> IMP::Float
8328 get_value(_TrivialDecorator self, IntKey a0) -> IMP::Int
8329 get_value(_TrivialDecorator self, StringKey a0) -> IMP::String
8330 get_value(_TrivialDecorator self, ParticleIndexKey a0) -> Particle
8331 get_value(_TrivialDecorator self, ObjectKey a0) -> Object
8333 return _IMP_kernel._TrivialDecorator_get_value(self, *args)
8336 def set_value(self, *args):
8338 set_value(_TrivialDecorator self, FloatKey a0, IMP::Float a1)
8339 set_value(_TrivialDecorator self, IntKey a0, IMP::Int a1)
8340 set_value(_TrivialDecorator self, StringKey a0, IMP::String a1)
8341 set_value(_TrivialDecorator self, ParticleIndexKey a0, Particle a1)
8342 set_value(_TrivialDecorator self, ObjectKey a0, Object a1)
8344 return _IMP_kernel._TrivialDecorator_set_value(self, *args)
8347 def remove_attribute(self, *args):
8349 remove_attribute(_TrivialDecorator self, FloatKey a0)
8350 remove_attribute(_TrivialDecorator self, IntKey a0)
8351 remove_attribute(_TrivialDecorator self, StringKey a0)
8352 remove_attribute(_TrivialDecorator self, ParticleIndexKey a0)
8353 remove_attribute(_TrivialDecorator self, ObjectKey a0)
8355 return _IMP_kernel._TrivialDecorator_remove_attribute(self, *args)
8358 def has_attribute(self, *args):
8360 has_attribute(_TrivialDecorator self, FloatKey a0) -> bool
8361 has_attribute(_TrivialDecorator self, IntKey a0) -> bool
8362 has_attribute(_TrivialDecorator self, StringKey a0) -> bool
8363 has_attribute(_TrivialDecorator self, ParticleIndexKey a0) -> bool
8364 has_attribute(_TrivialDecorator self, ObjectKey a0) -> bool
8366 return _IMP_kernel._TrivialDecorator_has_attribute(self, *args)
8369 def get_derivative(self, a0):
8370 """get_derivative(_TrivialDecorator self, FloatKey a0) -> double"""
8371 return _IMP_kernel._TrivialDecorator_get_derivative(self, a0)
8375 """get_name(_TrivialDecorator self) -> std::string"""
8376 return _IMP_kernel._TrivialDecorator_get_name(self)
8379 def clear_caches(self):
8380 """clear_caches(_TrivialDecorator self)"""
8381 return _IMP_kernel._TrivialDecorator_clear_caches(self)
8384 def set_name(self, a0):
8385 """set_name(_TrivialDecorator self, std::string a0)"""
8386 return _IMP_kernel._TrivialDecorator_set_name(self, a0)
8390 """set_check_level(_TrivialDecorator self, IMP::CheckLevel a0)"""
8391 return _IMP_kernel._TrivialDecorator_set_check_level(self, a0)
8394 def add_to_derivative(self, a0, a1, a2):
8395 """add_to_derivative(_TrivialDecorator self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
8396 return _IMP_kernel._TrivialDecorator_add_to_derivative(self, a0, a1, a2)
8399 def set_is_optimized(self, a0, a1):
8400 """set_is_optimized(_TrivialDecorator self, FloatKey a0, bool a1)"""
8401 return _IMP_kernel._TrivialDecorator_set_is_optimized(self, a0, a1)
8404 def get_is_optimized(self, a0):
8405 """get_is_optimized(_TrivialDecorator self, FloatKey a0) -> bool"""
8406 return _IMP_kernel._TrivialDecorator_get_is_optimized(self, a0)
8410 """get_check_level(_TrivialDecorator self) -> IMP::CheckLevel"""
8411 return _IMP_kernel._TrivialDecorator_get_check_level(self)
8414 def __eq__(self, *args):
8416 __eq__(_TrivialDecorator self, _TrivialDecorator o) -> bool
8417 __eq__(_TrivialDecorator self, Particle d) -> bool
8419 return _IMP_kernel._TrivialDecorator___eq__(self, *args)
8422 def __ne__(self, *args):
8424 __ne__(_TrivialDecorator self, _TrivialDecorator o) -> bool
8425 __ne__(_TrivialDecorator self, Particle d) -> bool
8427 return _IMP_kernel._TrivialDecorator___ne__(self, *args)
8430 def __le__(self, *args):
8432 __le__(_TrivialDecorator self, _TrivialDecorator o) -> bool
8433 __le__(_TrivialDecorator self, Particle d) -> bool
8435 return _IMP_kernel._TrivialDecorator___le__(self, *args)
8438 def __lt__(self, *args):
8440 __lt__(_TrivialDecorator self, _TrivialDecorator o) -> bool
8441 __lt__(_TrivialDecorator self, Particle d) -> bool
8443 return _IMP_kernel._TrivialDecorator___lt__(self, *args)
8446 def __ge__(self, *args):
8448 __ge__(_TrivialDecorator self, _TrivialDecorator o) -> bool
8449 __ge__(_TrivialDecorator self, Particle d) -> bool
8451 return _IMP_kernel._TrivialDecorator___ge__(self, *args)
8454 def __gt__(self, *args):
8456 __gt__(_TrivialDecorator self, _TrivialDecorator o) -> bool
8457 __gt__(_TrivialDecorator self, Particle d) -> bool
8459 return _IMP_kernel._TrivialDecorator___gt__(self, *args)
8463 """__hash__(_TrivialDecorator self) -> std::size_t"""
8464 return _IMP_kernel._TrivialDecorator___hash__(self)
8468 """__str__(_TrivialDecorator self) -> std::string"""
8469 return _IMP_kernel._TrivialDecorator___str__(self)
8473 """__repr__(_TrivialDecorator self) -> std::string"""
8474 return _IMP_kernel._TrivialDecorator___repr__(self)
8476 __swig_destroy__ = _IMP_kernel.delete__TrivialDecorator
8477 __del__ =
lambda self:
None
8478 _TrivialDecorator_swigregister = _IMP_kernel._TrivialDecorator_swigregister
8479 _TrivialDecorator_swigregister(_TrivialDecorator)
8481 def _TrivialDecorator_setup_particle(*args):
8483 setup_particle(Model m, ParticleIndex pi) -> _TrivialDecorator
8484 _TrivialDecorator_setup_particle(_ParticleAdaptor decorator) -> _TrivialDecorator
8486 return _IMP_kernel._TrivialDecorator_setup_particle(*args)
8488 def _TrivialDecorator_get_is_setup(*args):
8490 get_is_setup(_ParticleAdaptor p) -> bool
8491 _TrivialDecorator_get_is_setup(Model m, ParticleIndex pi) -> bool
8493 return _IMP_kernel._TrivialDecorator_get_is_setup(*args)
8495 class _TrivialDerivedDecorator(_TrivialDecorator):
8496 """Proxy of C++ IMP::internal::_TrivialDerivedDecorator class."""
8498 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
8500 def __init__(self, *args):
8502 __init__(IMP::internal::_TrivialDerivedDecorator self) -> _TrivialDerivedDecorator
8503 __init__(IMP::internal::_TrivialDerivedDecorator self, Model m, ParticleIndex id) -> _TrivialDerivedDecorator
8504 __init__(IMP::internal::_TrivialDerivedDecorator self, _ParticleAdaptor d) -> _TrivialDerivedDecorator
8506 this = _IMP_kernel.new__TrivialDerivedDecorator(*args)
8508 self.this.append(this)
8512 def show(self, *args):
8514 show(_TrivialDerivedDecorator self, _ostream out)
8515 show(_TrivialDerivedDecorator self)
8517 return _IMP_kernel._TrivialDerivedDecorator_show(self, *args)
8520 def setup_particle(*args):
8522 setup_particle(Model m, ParticleIndex pi) -> _TrivialDerivedDecorator
8523 setup_particle(_ParticleAdaptor decorator) -> _TrivialDerivedDecorator
8525 return _IMP_kernel._TrivialDerivedDecorator_setup_particle(*args)
8527 setup_particle = staticmethod(setup_particle)
8529 def get_is_setup(*args):
8531 get_is_setup(_ParticleAdaptor p) -> bool
8532 get_is_setup(Model m, ParticleIndex pi) -> bool
8534 return _IMP_kernel._TrivialDerivedDecorator_get_is_setup(*args)
8536 get_is_setup = staticmethod(get_is_setup)
8538 def add_attribute(self, *args):
8540 add_attribute(_TrivialDerivedDecorator self, FloatKey k, IMP::Float v, bool opt)
8541 add_attribute(_TrivialDerivedDecorator self, FloatKey a0, IMP::Float a1)
8542 add_attribute(_TrivialDerivedDecorator self, IntKey a0, IMP::Int a1)
8543 add_attribute(_TrivialDerivedDecorator self, StringKey a0, IMP::String a1)
8544 add_attribute(_TrivialDerivedDecorator self, ParticleIndexKey a0, Particle a1)
8545 add_attribute(_TrivialDerivedDecorator self, ObjectKey a0, Object a1)
8547 return _IMP_kernel._TrivialDerivedDecorator_add_attribute(self, *args)
8550 def get_value(self, *args):
8552 get_value(_TrivialDerivedDecorator self, FloatKey a0) -> IMP::Float
8553 get_value(_TrivialDerivedDecorator self, IntKey a0) -> IMP::Int
8554 get_value(_TrivialDerivedDecorator self, StringKey a0) -> IMP::String
8555 get_value(_TrivialDerivedDecorator self, ParticleIndexKey a0) -> Particle
8556 get_value(_TrivialDerivedDecorator self, ObjectKey a0) -> Object
8558 return _IMP_kernel._TrivialDerivedDecorator_get_value(self, *args)
8561 def set_value(self, *args):
8563 set_value(_TrivialDerivedDecorator self, FloatKey a0, IMP::Float a1)
8564 set_value(_TrivialDerivedDecorator self, IntKey a0, IMP::Int a1)
8565 set_value(_TrivialDerivedDecorator self, StringKey a0, IMP::String a1)
8566 set_value(_TrivialDerivedDecorator self, ParticleIndexKey a0, Particle a1)
8567 set_value(_TrivialDerivedDecorator self, ObjectKey a0, Object a1)
8569 return _IMP_kernel._TrivialDerivedDecorator_set_value(self, *args)
8572 def remove_attribute(self, *args):
8574 remove_attribute(_TrivialDerivedDecorator self, FloatKey a0)
8575 remove_attribute(_TrivialDerivedDecorator self, IntKey a0)
8576 remove_attribute(_TrivialDerivedDecorator self, StringKey a0)
8577 remove_attribute(_TrivialDerivedDecorator self, ParticleIndexKey a0)
8578 remove_attribute(_TrivialDerivedDecorator self, ObjectKey a0)
8580 return _IMP_kernel._TrivialDerivedDecorator_remove_attribute(self, *args)
8583 def has_attribute(self, *args):
8585 has_attribute(_TrivialDerivedDecorator self, FloatKey a0) -> bool
8586 has_attribute(_TrivialDerivedDecorator self, IntKey a0) -> bool
8587 has_attribute(_TrivialDerivedDecorator self, StringKey a0) -> bool
8588 has_attribute(_TrivialDerivedDecorator self, ParticleIndexKey a0) -> bool
8589 has_attribute(_TrivialDerivedDecorator self, ObjectKey a0) -> bool
8591 return _IMP_kernel._TrivialDerivedDecorator_has_attribute(self, *args)
8594 def get_derivative(self, a0):
8595 """get_derivative(_TrivialDerivedDecorator self, FloatKey a0) -> double"""
8596 return _IMP_kernel._TrivialDerivedDecorator_get_derivative(self, a0)
8600 """get_name(_TrivialDerivedDecorator self) -> std::string"""
8601 return _IMP_kernel._TrivialDerivedDecorator_get_name(self)
8604 def clear_caches(self):
8605 """clear_caches(_TrivialDerivedDecorator self)"""
8606 return _IMP_kernel._TrivialDerivedDecorator_clear_caches(self)
8609 def set_name(self, a0):
8610 """set_name(_TrivialDerivedDecorator self, std::string a0)"""
8611 return _IMP_kernel._TrivialDerivedDecorator_set_name(self, a0)
8615 """set_check_level(_TrivialDerivedDecorator self, IMP::CheckLevel a0)"""
8616 return _IMP_kernel._TrivialDerivedDecorator_set_check_level(self, a0)
8619 def add_to_derivative(self, a0, a1, a2):
8620 """add_to_derivative(_TrivialDerivedDecorator self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
8621 return _IMP_kernel._TrivialDerivedDecorator_add_to_derivative(self, a0, a1, a2)
8624 def set_is_optimized(self, a0, a1):
8625 """set_is_optimized(_TrivialDerivedDecorator self, FloatKey a0, bool a1)"""
8626 return _IMP_kernel._TrivialDerivedDecorator_set_is_optimized(self, a0, a1)
8629 def get_is_optimized(self, a0):
8630 """get_is_optimized(_TrivialDerivedDecorator self, FloatKey a0) -> bool"""
8631 return _IMP_kernel._TrivialDerivedDecorator_get_is_optimized(self, a0)
8635 """get_check_level(_TrivialDerivedDecorator self) -> IMP::CheckLevel"""
8636 return _IMP_kernel._TrivialDerivedDecorator_get_check_level(self)
8639 def __eq__(self, *args):
8641 __eq__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
8642 __eq__(_TrivialDerivedDecorator self, Particle d) -> bool
8644 return _IMP_kernel._TrivialDerivedDecorator___eq__(self, *args)
8647 def __ne__(self, *args):
8649 __ne__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
8650 __ne__(_TrivialDerivedDecorator self, Particle d) -> bool
8652 return _IMP_kernel._TrivialDerivedDecorator___ne__(self, *args)
8655 def __le__(self, *args):
8657 __le__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
8658 __le__(_TrivialDerivedDecorator self, Particle d) -> bool
8660 return _IMP_kernel._TrivialDerivedDecorator___le__(self, *args)
8663 def __lt__(self, *args):
8665 __lt__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
8666 __lt__(_TrivialDerivedDecorator self, Particle d) -> bool
8668 return _IMP_kernel._TrivialDerivedDecorator___lt__(self, *args)
8671 def __ge__(self, *args):
8673 __ge__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
8674 __ge__(_TrivialDerivedDecorator self, Particle d) -> bool
8676 return _IMP_kernel._TrivialDerivedDecorator___ge__(self, *args)
8679 def __gt__(self, *args):
8681 __gt__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
8682 __gt__(_TrivialDerivedDecorator self, Particle d) -> bool
8684 return _IMP_kernel._TrivialDerivedDecorator___gt__(self, *args)
8688 """__hash__(_TrivialDerivedDecorator self) -> std::size_t"""
8689 return _IMP_kernel._TrivialDerivedDecorator___hash__(self)
8693 """__str__(_TrivialDerivedDecorator self) -> std::string"""
8694 return _IMP_kernel._TrivialDerivedDecorator___str__(self)
8698 """__repr__(_TrivialDerivedDecorator self) -> std::string"""
8699 return _IMP_kernel._TrivialDerivedDecorator___repr__(self)
8701 __swig_destroy__ = _IMP_kernel.delete__TrivialDerivedDecorator
8702 __del__ =
lambda self:
None
8703 _TrivialDerivedDecorator_swigregister = _IMP_kernel._TrivialDerivedDecorator_swigregister
8704 _TrivialDerivedDecorator_swigregister(_TrivialDerivedDecorator)
8706 def _TrivialDerivedDecorator_setup_particle(*args):
8708 setup_particle(Model m, ParticleIndex pi) -> _TrivialDerivedDecorator
8709 _TrivialDerivedDecorator_setup_particle(_ParticleAdaptor decorator) -> _TrivialDerivedDecorator
8711 return _IMP_kernel._TrivialDerivedDecorator_setup_particle(*args)
8713 def _TrivialDerivedDecorator_get_is_setup(*args):
8715 get_is_setup(_ParticleAdaptor p) -> bool
8716 _TrivialDerivedDecorator_get_is_setup(Model m, ParticleIndex pi) -> bool
8718 return _IMP_kernel._TrivialDerivedDecorator_get_is_setup(*args)
8720 class _TrivialTraitsDecorator(Decorator):
8721 """Proxy of C++ IMP::internal::_TrivialTraitsDecorator class."""
8723 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
8725 def get_decorator_traits(self):
8726 """get_decorator_traits(_TrivialTraitsDecorator self) -> StringKey"""
8727 return _IMP_kernel._TrivialTraitsDecorator_get_decorator_traits(self)
8730 def get_default_decorator_traits():
8731 """get_default_decorator_traits() -> StringKey"""
8732 return _IMP_kernel._TrivialTraitsDecorator_get_default_decorator_traits()
8734 get_default_decorator_traits = staticmethod(get_default_decorator_traits)
8736 def __init__(self, *args):
8738 __init__(IMP::internal::_TrivialTraitsDecorator self) -> _TrivialTraitsDecorator
8739 __init__(IMP::internal::_TrivialTraitsDecorator self, Model m, ParticleIndex id, StringKey tr) -> _TrivialTraitsDecorator
8740 __init__(IMP::internal::_TrivialTraitsDecorator self, Model m, ParticleIndex id) -> _TrivialTraitsDecorator
8741 __init__(IMP::internal::_TrivialTraitsDecorator self, _ParticleAdaptor d, StringKey tr) -> _TrivialTraitsDecorator
8742 __init__(IMP::internal::_TrivialTraitsDecorator self, _ParticleAdaptor d) -> _TrivialTraitsDecorator
8744 this = _IMP_kernel.new__TrivialTraitsDecorator(*args)
8746 self.this.append(this)
8750 def show(self, *args):
8752 show(_TrivialTraitsDecorator self, _ostream out)
8753 show(_TrivialTraitsDecorator self)
8755 return _IMP_kernel._TrivialTraitsDecorator_show(self, *args)
8758 def setup_particle(*args):
8760 setup_particle(Model m, ParticleIndex pi, StringKey tr) -> _TrivialTraitsDecorator
8761 setup_particle(Model m, ParticleIndex pi) -> _TrivialTraitsDecorator
8762 setup_particle(_ParticleAdaptor d, StringKey tr) -> _TrivialTraitsDecorator
8763 setup_particle(_ParticleAdaptor d) -> _TrivialTraitsDecorator
8765 return _IMP_kernel._TrivialTraitsDecorator_setup_particle(*args)
8767 setup_particle = staticmethod(setup_particle)
8769 def get_is_setup(*args):
8771 get_is_setup(_ParticleAdaptor p, StringKey tr) -> bool
8772 get_is_setup(_ParticleAdaptor p) -> bool
8773 get_is_setup(Model m, ParticleIndex pi, StringKey k) -> bool
8774 get_is_setup(Model m, ParticleIndex pi) -> bool
8776 return _IMP_kernel._TrivialTraitsDecorator_get_is_setup(*args)
8778 get_is_setup = staticmethod(get_is_setup)
8780 def get_default_key():
8781 """get_default_key() -> StringKey"""
8782 return _IMP_kernel._TrivialTraitsDecorator_get_default_key()
8784 get_default_key = staticmethod(get_default_key)
8786 def add_attribute(self, *args):
8788 add_attribute(_TrivialTraitsDecorator self, FloatKey k, IMP::Float v, bool opt)
8789 add_attribute(_TrivialTraitsDecorator self, FloatKey a0, IMP::Float a1)
8790 add_attribute(_TrivialTraitsDecorator self, IntKey a0, IMP::Int a1)
8791 add_attribute(_TrivialTraitsDecorator self, StringKey a0, IMP::String a1)
8792 add_attribute(_TrivialTraitsDecorator self, ParticleIndexKey a0, Particle a1)
8793 add_attribute(_TrivialTraitsDecorator self, ObjectKey a0, Object a1)
8795 return _IMP_kernel._TrivialTraitsDecorator_add_attribute(self, *args)
8798 def get_value(self, *args):
8800 get_value(_TrivialTraitsDecorator self, FloatKey a0) -> IMP::Float
8801 get_value(_TrivialTraitsDecorator self, IntKey a0) -> IMP::Int
8802 get_value(_TrivialTraitsDecorator self, StringKey a0) -> IMP::String
8803 get_value(_TrivialTraitsDecorator self, ParticleIndexKey a0) -> Particle
8804 get_value(_TrivialTraitsDecorator self, ObjectKey a0) -> Object
8806 return _IMP_kernel._TrivialTraitsDecorator_get_value(self, *args)
8809 def set_value(self, *args):
8811 set_value(_TrivialTraitsDecorator self, FloatKey a0, IMP::Float a1)
8812 set_value(_TrivialTraitsDecorator self, IntKey a0, IMP::Int a1)
8813 set_value(_TrivialTraitsDecorator self, StringKey a0, IMP::String a1)
8814 set_value(_TrivialTraitsDecorator self, ParticleIndexKey a0, Particle a1)
8815 set_value(_TrivialTraitsDecorator self, ObjectKey a0, Object a1)
8817 return _IMP_kernel._TrivialTraitsDecorator_set_value(self, *args)
8820 def remove_attribute(self, *args):
8822 remove_attribute(_TrivialTraitsDecorator self, FloatKey a0)
8823 remove_attribute(_TrivialTraitsDecorator self, IntKey a0)
8824 remove_attribute(_TrivialTraitsDecorator self, StringKey a0)
8825 remove_attribute(_TrivialTraitsDecorator self, ParticleIndexKey a0)
8826 remove_attribute(_TrivialTraitsDecorator self, ObjectKey a0)
8828 return _IMP_kernel._TrivialTraitsDecorator_remove_attribute(self, *args)
8831 def has_attribute(self, *args):
8833 has_attribute(_TrivialTraitsDecorator self, FloatKey a0) -> bool
8834 has_attribute(_TrivialTraitsDecorator self, IntKey a0) -> bool
8835 has_attribute(_TrivialTraitsDecorator self, StringKey a0) -> bool
8836 has_attribute(_TrivialTraitsDecorator self, ParticleIndexKey a0) -> bool
8837 has_attribute(_TrivialTraitsDecorator self, ObjectKey a0) -> bool
8839 return _IMP_kernel._TrivialTraitsDecorator_has_attribute(self, *args)
8842 def get_derivative(self, a0):
8843 """get_derivative(_TrivialTraitsDecorator self, FloatKey a0) -> double"""
8844 return _IMP_kernel._TrivialTraitsDecorator_get_derivative(self, a0)
8848 """get_name(_TrivialTraitsDecorator self) -> std::string"""
8849 return _IMP_kernel._TrivialTraitsDecorator_get_name(self)
8852 def clear_caches(self):
8853 """clear_caches(_TrivialTraitsDecorator self)"""
8854 return _IMP_kernel._TrivialTraitsDecorator_clear_caches(self)
8857 def set_name(self, a0):
8858 """set_name(_TrivialTraitsDecorator self, std::string a0)"""
8859 return _IMP_kernel._TrivialTraitsDecorator_set_name(self, a0)
8863 """set_check_level(_TrivialTraitsDecorator self, IMP::CheckLevel a0)"""
8864 return _IMP_kernel._TrivialTraitsDecorator_set_check_level(self, a0)
8867 def add_to_derivative(self, a0, a1, a2):
8868 """add_to_derivative(_TrivialTraitsDecorator self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
8869 return _IMP_kernel._TrivialTraitsDecorator_add_to_derivative(self, a0, a1, a2)
8872 def set_is_optimized(self, a0, a1):
8873 """set_is_optimized(_TrivialTraitsDecorator self, FloatKey a0, bool a1)"""
8874 return _IMP_kernel._TrivialTraitsDecorator_set_is_optimized(self, a0, a1)
8877 def get_is_optimized(self, a0):
8878 """get_is_optimized(_TrivialTraitsDecorator self, FloatKey a0) -> bool"""
8879 return _IMP_kernel._TrivialTraitsDecorator_get_is_optimized(self, a0)
8883 """get_check_level(_TrivialTraitsDecorator self) -> IMP::CheckLevel"""
8884 return _IMP_kernel._TrivialTraitsDecorator_get_check_level(self)
8887 def __eq__(self, *args):
8889 __eq__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
8890 __eq__(_TrivialTraitsDecorator self, Particle d) -> bool
8892 return _IMP_kernel._TrivialTraitsDecorator___eq__(self, *args)
8895 def __ne__(self, *args):
8897 __ne__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
8898 __ne__(_TrivialTraitsDecorator self, Particle d) -> bool
8900 return _IMP_kernel._TrivialTraitsDecorator___ne__(self, *args)
8903 def __le__(self, *args):
8905 __le__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
8906 __le__(_TrivialTraitsDecorator self, Particle d) -> bool
8908 return _IMP_kernel._TrivialTraitsDecorator___le__(self, *args)
8911 def __lt__(self, *args):
8913 __lt__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
8914 __lt__(_TrivialTraitsDecorator self, Particle d) -> bool
8916 return _IMP_kernel._TrivialTraitsDecorator___lt__(self, *args)
8919 def __ge__(self, *args):
8921 __ge__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
8922 __ge__(_TrivialTraitsDecorator self, Particle d) -> bool
8924 return _IMP_kernel._TrivialTraitsDecorator___ge__(self, *args)
8927 def __gt__(self, *args):
8929 __gt__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
8930 __gt__(_TrivialTraitsDecorator self, Particle d) -> bool
8932 return _IMP_kernel._TrivialTraitsDecorator___gt__(self, *args)
8936 """__hash__(_TrivialTraitsDecorator self) -> std::size_t"""
8937 return _IMP_kernel._TrivialTraitsDecorator___hash__(self)
8941 """__str__(_TrivialTraitsDecorator self) -> std::string"""
8942 return _IMP_kernel._TrivialTraitsDecorator___str__(self)
8946 """__repr__(_TrivialTraitsDecorator self) -> std::string"""
8947 return _IMP_kernel._TrivialTraitsDecorator___repr__(self)
8949 __swig_destroy__ = _IMP_kernel.delete__TrivialTraitsDecorator
8950 __del__ =
lambda self:
None
8951 _TrivialTraitsDecorator_swigregister = _IMP_kernel._TrivialTraitsDecorator_swigregister
8952 _TrivialTraitsDecorator_swigregister(_TrivialTraitsDecorator)
8954 def _TrivialTraitsDecorator_get_default_decorator_traits():
8955 """_TrivialTraitsDecorator_get_default_decorator_traits() -> StringKey"""
8956 return _IMP_kernel._TrivialTraitsDecorator_get_default_decorator_traits()
8958 def _TrivialTraitsDecorator_setup_particle(*args):
8960 setup_particle(Model m, ParticleIndex pi, StringKey tr) -> _TrivialTraitsDecorator
8961 setup_particle(Model m, ParticleIndex pi) -> _TrivialTraitsDecorator
8962 setup_particle(_ParticleAdaptor d, StringKey tr) -> _TrivialTraitsDecorator
8963 _TrivialTraitsDecorator_setup_particle(_ParticleAdaptor d) -> _TrivialTraitsDecorator
8965 return _IMP_kernel._TrivialTraitsDecorator_setup_particle(*args)
8967 def _TrivialTraitsDecorator_get_is_setup(*args):
8969 get_is_setup(_ParticleAdaptor p, StringKey tr) -> bool
8970 get_is_setup(_ParticleAdaptor p) -> bool
8971 get_is_setup(Model m, ParticleIndex pi, StringKey k) -> bool
8972 _TrivialTraitsDecorator_get_is_setup(Model m, ParticleIndex pi) -> bool
8974 return _IMP_kernel._TrivialTraitsDecorator_get_is_setup(*args)
8976 def _TrivialTraitsDecorator_get_default_key():
8977 """_TrivialTraitsDecorator_get_default_key() -> StringKey"""
8978 return _IMP_kernel._TrivialTraitsDecorator_get_default_key()
8981 def __lshift__(*args):
8983 __lshift__(_ostream out, _TrivialDecorator n) -> _ostream
8984 __lshift__(_ostream out, _TrivialDerivedDecorator n) -> _ostream
8985 __lshift__(_ostream out, _TrivialTraitsDecorator n) -> _ostream
8987 return _IMP_kernel.__lshift__(*args)
8988 class _ConstOptimizer(Optimizer):
8989 """Proxy of C++ IMP::internal::_ConstOptimizer class."""
8991 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
8993 def __init__(self, m):
8994 """__init__(IMP::internal::_ConstOptimizer self, Model m) -> _ConstOptimizer"""
8995 this = _IMP_kernel.new__ConstOptimizer(m)
8997 self.this.append(this)
9001 def do_optimize(self, max_steps):
9002 """do_optimize(_ConstOptimizer self, unsigned int max_steps) -> IMP::Float"""
9003 return _IMP_kernel._ConstOptimizer_do_optimize(self, max_steps)
9006 def get_version_info(self):
9007 """get_version_info(_ConstOptimizer self) -> VersionInfo"""
9008 return _IMP_kernel._ConstOptimizer_get_version_info(self)
9012 """__str__(_ConstOptimizer self) -> std::string"""
9013 return _IMP_kernel._ConstOptimizer___str__(self)
9017 """__repr__(_ConstOptimizer self) -> std::string"""
9018 return _IMP_kernel._ConstOptimizer___repr__(self)
9023 return _object_cast_to__ConstOptimizer(o)
9025 _ConstOptimizer_swigregister = _IMP_kernel._ConstOptimizer_swigregister
9026 _ConstOptimizer_swigregister(_ConstOptimizer)
9029 def get_particle(p):
9030 """get_particle(Particle p) -> Particle"""
9031 return _IMP_kernel.get_particle(p)
9033 def _decorator_test(p):
9034 """_decorator_test(Particle p)"""
9035 return _IMP_kernel._decorator_test(p)
9037 def _overloaded_decorator(*args):
9039 _overloaded_decorator(_TrivialDecorator a) -> int
9040 _overloaded_decorator(_TrivialDerivedDecorator a) -> int
9042 return _IMP_kernel._overloaded_decorator(*args)
9044 def _take_particles(*args):
9046 _take_particles(IMP::Particles const & ps) -> unsigned int
9047 _take_particles(Model m, IMP::Particles const & ps) -> unsigned int
9048 _take_particles(Model m, IMP::Particles const & ps, TextOutput out) -> unsigned int
9050 return _IMP_kernel._take_particles(*args)
9052 def _give_particles(m):
9053 """_give_particles(Model m) -> IMP::Particles const &"""
9054 return _IMP_kernel._give_particles(m)
9056 def _pass_particles(ps):
9057 """_pass_particles(IMP::Particles const & ps) -> IMP::Particles const &"""
9058 return _IMP_kernel._pass_particles(ps)
9060 def _pass_particle(ps):
9061 """_pass_particle(Particle ps) -> Particle"""
9062 return _IMP_kernel._pass_particle(ps)
9064 def _pass_particle_pair(pp):
9065 """_pass_particle_pair(IMP::ParticlePair const & pp) -> IMP::ParticlePair const &"""
9066 return _IMP_kernel._pass_particle_pair(pp)
9068 def _give_particles_copy(m):
9069 """_give_particles_copy(Model m) -> IMP::Particles"""
9070 return _IMP_kernel._give_particles_copy(m)
9072 def _pass_float_keys(input):
9073 """_pass_float_keys(IMP::FloatKeys const & input) -> IMP::FloatKeys"""
9074 return _IMP_kernel._pass_float_keys(input)
9078 _pass(IMP::Particles const & p) -> IMP::Particles const
9079 _pass(IMP::Restraints const & p) -> IMP::Restraints const &
9081 return _IMP_kernel._pass(*args)
9083 def _pass_decorators(p):
9084 """_pass_decorators(IMP::internal::_TrivialDecorators const & p) -> IMP::internal::_TrivialDecorators const &"""
9085 return _IMP_kernel._pass_decorators(p)
9087 def _pass_decorator_traits(p):
9088 """_pass_decorator_traits(IMP::internal::_TrivialTraitsDecorators const & p) -> IMP::internal::_TrivialTraitsDecorators const &"""
9089 return _IMP_kernel._pass_decorator_traits(p)
9091 def _pass_particle_pairs(p):
9092 """_pass_particle_pairs(IMP::ParticlePairsTemp const & p) -> IMP::ParticlePairsTemp"""
9093 return _IMP_kernel._pass_particle_pairs(p)
9095 def _pass_particle_index_pairs(p):
9096 """_pass_particle_index_pairs(IMP::ParticleIndexPairs const & p) -> IMP::ParticleIndexPairs"""
9097 return _IMP_kernel._pass_particle_index_pairs(p)
9099 def _pass_model_objects(p):
9100 """_pass_model_objects(IMP::ModelObjectsTemp const & p) -> IMP::ModelObjectsTemp"""
9101 return _IMP_kernel._pass_model_objects(p)
9103 def _pass_particles_temps(ps):
9104 """_pass_particles_temps(IMP::ParticlesTemps const & ps) -> IMP::ParticlesTemps"""
9105 return _IMP_kernel._pass_particles_temps(ps)
9107 def _test_overload(*args):
9109 _test_overload(IMP::Particles const & ps) -> int
9110 _test_overload(IMP::Restraints const & ps) -> int
9112 return _IMP_kernel._test_overload(*args)
9114 def _get_range(m, k):
9115 """_get_range(Model m, FloatKey k) -> IMP::FloatRange"""
9116 return _IMP_kernel._get_range(m, k)
9118 def _create_particles_from_pdb(name, m):
9119 """_create_particles_from_pdb(std::string name, Model m) -> IMP::ParticleIndexes"""
9120 return _IMP_kernel._create_particles_from_pdb(name, m)
9121 class _LogPairScore(PairScore):
9122 """Proxy of C++ IMP::internal::_LogPairScore class."""
9124 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
9125 __repr__ = _swig_repr
9128 """__init__(IMP::internal::_LogPairScore self) -> _LogPairScore"""
9129 this = _IMP_kernel.new__LogPairScore()
9131 self.this.append(this)
9135 def do_get_inputs(self, arg2, arg3):
9136 """do_get_inputs(_LogPairScore self, Model arg2, IMP::ParticleIndexes const & arg3) -> IMP::ModelObjectsTemp"""
9137 return _IMP_kernel._LogPairScore_do_get_inputs(self, arg2, arg3)
9140 def get_version_info(self):
9141 """get_version_info(_LogPairScore self) -> VersionInfo"""
9142 return _IMP_kernel._LogPairScore_get_version_info(self)
9145 def get_particle_pairs(self):
9146 """get_particle_pairs(_LogPairScore self) -> IMP::ParticlePairsTemp"""
9147 return _IMP_kernel._LogPairScore_get_particle_pairs(self)
9151 """clear(_LogPairScore self)"""
9152 return _IMP_kernel._LogPairScore_clear(self)
9155 def get_contains(self, pp):
9156 """get_contains(_LogPairScore self, IMP::ParticlePair const & pp) -> bool"""
9157 return _IMP_kernel._LogPairScore_get_contains(self, pp)
9159 _LogPairScore_swigregister = _IMP_kernel._LogPairScore_swigregister
9160 _LogPairScore_swigregister(_LogPairScore)
9163 def _overloaded_particles(*args):
9165 _overloaded_particles(Particle arg1)
9166 _overloaded_particles(IMP::Particles const & arg1)
9167 _overloaded_particles(IMP::ParticlesTemp const & arg1)
9168 _overloaded_particles(Model arg1, IMP::ParticleIndexes const & arg2)
9169 _overloaded_particles(IMP::internal::_TrivialDecorators const & arg1)
9170 _overloaded_particles(_TrivialDecorator arg1)
9172 return _IMP_kernel._overloaded_particles(*args)
9173 class _ImplicitParticles(object):
9174 """Proxy of C++ IMP::internal::_ImplicitParticles class."""
9176 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
9177 __repr__ = _swig_repr
9179 def __init__(self, *args):
9181 __init__(IMP::internal::_ImplicitParticles self, Particle arg2) -> _ImplicitParticles
9182 __init__(IMP::internal::_ImplicitParticles self, IMP::Particles const & arg2) -> _ImplicitParticles
9183 __init__(IMP::internal::_ImplicitParticles self, IMP::ParticlesTemp const & arg2) -> _ImplicitParticles
9184 __init__(IMP::internal::_ImplicitParticles self, Model arg2, IMP::ParticleIndexes const & arg3) -> _ImplicitParticles
9185 __init__(IMP::internal::_ImplicitParticles self, IMP::internal::_TrivialDecorators const & arg2) -> _ImplicitParticles
9186 __init__(IMP::internal::_ImplicitParticles self, _TrivialDecorator arg2) -> _ImplicitParticles
9188 this = _IMP_kernel.new__ImplicitParticles(*args)
9190 self.this.append(this)
9193 __swig_destroy__ = _IMP_kernel.delete__ImplicitParticles
9194 __del__ =
lambda self:
None
9195 _ImplicitParticles_swigregister = _IMP_kernel._ImplicitParticles_swigregister
9196 _ImplicitParticles_swigregister(_ImplicitParticles)
9199 def _implicit_particles(arg1):
9200 """_implicit_particles(_ImplicitParticles arg1)"""
9201 return _IMP_kernel._implicit_particles(arg1)
9203 def _take_particle_adaptor(pa):
9204 """_take_particle_adaptor(_ParticleAdaptor pa) -> ParticleIndex"""
9205 return _IMP_kernel._take_particle_adaptor(pa)
9207 def _take_particle_indexes_adaptor(pa):
9208 """_take_particle_indexes_adaptor(_ParticleIndexesAdaptor pa) -> IMP::ParticleIndexes"""
9209 return _IMP_kernel._take_particle_indexes_adaptor(pa)
9210 class ScopedSetFloatAttribute(_RAII):
9211 """Proxy of C++ IMP::ScopedSetAttribute<(FloatKey,IMP::Float)> class."""
9213 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
9215 def __init__(self, *args):
9217 __init__(IMP::ScopedSetAttribute<(FloatKey,IMP::Float)> self) -> ScopedSetFloatAttribute
9218 __init__(IMP::ScopedSetAttribute<(FloatKey,IMP::Float)> self, Particle p, FloatKey key, double const & value) -> ScopedSetFloatAttribute
9220 this = _IMP_kernel.new_ScopedSetFloatAttribute(*args)
9222 self.this.append(this)
9226 def set(self, p, key, value):
9227 """set(ScopedSetFloatAttribute self, Particle p, FloatKey key, double const & value)"""
9228 return _IMP_kernel.ScopedSetFloatAttribute_set(self, p, key, value)
9232 """reset(ScopedSetFloatAttribute self)"""
9233 return _IMP_kernel.ScopedSetFloatAttribute_reset(self)
9235 __swig_destroy__ = _IMP_kernel.delete_ScopedSetFloatAttribute
9236 __del__ =
lambda self:
None
9238 def show(self, *args):
9240 show(ScopedSetFloatAttribute self, _ostream out)
9241 show(ScopedSetFloatAttribute self)
9243 return _IMP_kernel.ScopedSetFloatAttribute_show(self, *args)
9247 """__str__(ScopedSetFloatAttribute self) -> std::string"""
9248 return _IMP_kernel.ScopedSetFloatAttribute___str__(self)
9252 """__repr__(ScopedSetFloatAttribute self) -> std::string"""
9253 return _IMP_kernel.ScopedSetFloatAttribute___repr__(self)
9255 ScopedSetFloatAttribute_swigregister = _IMP_kernel.ScopedSetFloatAttribute_swigregister
9256 ScopedSetFloatAttribute_swigregister(ScopedSetFloatAttribute)
9266 if sys.platform ==
'win32' and 'IMP_LD_PATH' in os.environ:
9267 dirs = os.environ[
'IMP_LD_PATH'].split(
":")
9268 pathcomps = os.environ[
'PATH'].split(
";")
9270 if d
not in pathcomps:
9271 os.environ[
'PATH'] = d +
';' + os.environ[
'PATH']
9279 """Allow command line tools to easily implement multiple commands.
9280 Typically, an IMP command line tool will use an instance of this class
9281 to provide a consistent interface to multiple distinct commands
9282 from a single binary, rather than providing a potentially large
9283 number of binaries. This is similar to the way a number of common
9284 command line tools outside of %IMP function (e.g. Git provides a single
9285 `git` tool which implements multiple commands - `git add`, `git commit`,
9286 `git push` and so on).
9288 Each command is implemented with a Python module of the same name
9289 that can be imported from the module (for example, if `module_name`
9290 is `IMP.foo`, the `bar` command is provided by the `IMP.foo.bar` Python
9291 module, which would usually be found as `modules/foo/pyext/src/bar.py`).
9292 Each such module should have a docstring and a `%main()` method
9293 that takes no arguments (the module should also call its `%main()` method
9294 if it is run directly, i.e. with something like
9295 `if __name__=="__main__": %main()`). The encompassing module
9296 (`IMP.foo` in the example) should define `_all_commands` as a Python
9297 list of all valid commands.
9299 See the `multifit` and `cnmultifit` command line tools for example
9303 def __init__(self, short_help, long_help, module_name):
9305 @param short_help A few words that describe the command line tool.
9306 @param long_help Longer text, used in the `help` command.
9307 @param module_name Name of the module (e.g. `IMP.foo`) that
9308 implements the commands.
9310 self.short_help = short_help
9311 self.long_help = long_help
9312 self.module_name = module_name
9313 self._all_commands = self.import_module()._all_commands
9314 self._progname = os.path.basename(sys.argv[0])
9317 """Call this method to act upon the user-provided command line"""
9318 if len(sys.argv) <= 1:
9319 print(self.short_help +
" Use '%s help' for help." % self._progname)
9321 command = sys.argv[1]
9322 if command
in (
'help',
'--help',
'-h'):
9323 if len(sys.argv) == 3:
9324 self.show_command_help(sys.argv[2])
9327 elif command ==
'--version':
9329 elif command
in self._all_commands:
9330 self.do_command(command)
9332 self.unknown_command(command)
9334 def import_module(self, mod=None):
9335 modname = self.module_name
9337 modname +=
"." + mod
9338 return __import__(modname, {}, {}, [
''])
9340 def unknown_command(self, command):
9341 print(
"Unknown command: '%s'" % command)
9342 print(
"Use '%s help' for help." % self._progname)
9345 def _get_version(self):
9346 return self.import_module().get_module_version()
9348 def show_version(self):
9349 print(self._progname +
' ' + self._get_version())
9351 def show_help(self):
9352 ver = self._get_version()
9353 print(
"%s, version %s." % (self._progname, ver))
9354 print(self.long_help +
"""
9356 This program is part of IMP, the Integrative Modeling Platform,
9357 which is Copyright 2007-2016 IMP Inventors.
9358 For additional information about IMP, see <https://integrativemodeling.org>.
9360 Usage: %s <command> [options] [args]
9362 Commands:""" % self._progname)
9363 commands = self._all_commands[:] + [
'help']
9365 cmdlen = max([len(c)
for c
in commands])
9368 doc =
'Get help on using %s.' % self._progname
9370 doc = self.import_module(c).__doc__
or "<no help>"
9371 c +=
' ' * (cmdlen - len(c))
9372 print(
' ' + c +
' ' + doc)
9374 Use "%s help <command>" for detailed help on any command
9375 or "%s --version" to see the version number.""" % (self._progname,
9378 def do_command(self, command):
9379 mod = self.import_module(command)
9380 sys.argv[0] = self._progname +
' ' + command
9384 def show_command_help(self, command):
9385 if command ==
'help':
9387 elif command
in self._all_commands
or command ==
'help':
9388 mod = self.import_module(command)
9389 sys.argv = [self._progname +
' ' + command,
'--help']
9392 self.unknown_command(command)
9401 """IMP-specific subclass of optparse.OptionParser.
9402 This adds options common to all IMP applications
9403 (see IMP::setup_from_argv()).
9406 _use_boost_parser =
True
9408 def __init__(self, *args, **kwargs):
9411 kwargs[
'add_help_option'] =
False
9412 kwargs[
'version'] =
None
9414 if 'imp_module' in kwargs:
9415 del kwargs[
'imp_module']
9417 optparse.OptionParser.__init__(self, *args, **kwargs)
9419 if 'epilog' in kwargs:
9421 del kwargs[
'epilog']
9422 optparse.OptionParser.__init__(self, *args, **kwargs)
9428 def _process_long_opt(self, rargs, values):
9429 if self._use_boost_parser:
9431 optparse.OptionParser._process_long_opt(self, rargs, values)
9432 except optparse.BadOptionError
as err:
9433 if not hasattr(err,
'opt_str') \
9434 and err.msg.startswith(
'no such option:'):
9435 self.largs.append(err.msg[16:])
9437 self.largs.append(err.opt_str)
9439 optparse.OptionParser._process_long_opt(self, rargs, values)
9440 def _process_short_opts(self, rargs, values):
9441 if self._use_boost_parser:
9443 optparse.OptionParser._process_short_opts(self, rargs, values)
9444 except optparse.BadOptionError
as err:
9445 self.largs.append(err.opt_str)
9447 optparse.OptionParser._process_short_opts(self, rargs, values)
9449 def _process_args(self, largs, rargs, values):
9450 if self._use_boost_parser:
9455 dashdash = rargs.index(
'--')
9457 dashdash = len(rargs)
9458 saved_args = rargs[dashdash:]
9459 del rargs[dashdash:]
9460 optparse.OptionParser._process_args(self, largs, rargs, values)
9461 rargs.extend(saved_args)
9463 optparse.OptionParser._process_args(self, largs, rargs, values)
9466 """Parse the command line and return options and positional arguments.
9467 This functions in the same way as the method in the base class
9468 optparse.OptionParser, except that it also processes options common
9469 to all IMP applications (these are not returned in opts, but can be
9470 obtained in the usual way, e.g. by calling
9471 IMP::get_string_flag()).
9472 @param[in] num_positional If a positive integer, exactly that
9473 many positional arguments must be specified on the
9474 command line; if a negative integer, that many or
9475 more must be given; if None, any number of positional
9476 arguments can be given.
9480 opts, args = optparse.OptionParser.parse_args(self)
9481 if not self._use_boost_parser:
9483 orig_desc = self.description
9484 orig_usage = self.usage
9486 usage = self.usage.replace(
'%prog ',
'')
9489 if num_positional
is None:
9493 args.append(
'dummy')
9495 numpos = num_positional
9497 self.usage = self.description =
None
9501 self.format_help() \
9502 +
"\nOptions common to all IMP applications:",
9505 self.description = orig_desc
9506 self.usage = orig_usage
9507 if num_positional
is None:
9515 g = networkx.DiGraph()
9516 if len(ig.get_vertices()) == 0:
9521 def __init__(self, p):
9525 return self.p.get_name()
9527 def __call__(self, name):
9528 return self.p.__call__(name)
9530 for vi
in ig.get_vertices():
9531 n = ig.get_vertex_name(vi)
9532 g.add_node(NodeWrapper(n))
9533 for vi
in ig.get_vertices():
9534 n = ig.get_vertex_name(vi)
9535 for ni
in ig.get_out_neighbors(vi):
9536 nn = ig.get_vertex_name(ni)
9537 g.add_edge(NodeWrapper(n), NodeWrapper(nn))
9544 n0 = name.get_name()
9547 n1 = str(n0).replace(
'"',
'')
9548 n2 = n1.replace(
"\n",
'')
9551 from altgraph
import Graph, Dot
9552 graph = Graph.Graph()
9553 for i, v
in enumerate(g.get_vertices()):
9555 for i, v
in enumerate(g.get_vertices()):
9556 for n
in g.get_out_neighbors(v):
9557 graph.add_edge(v, n)
9558 dot = Dot.Dot(graph)
9559 for i, v
in enumerate(g.get_vertices()):
9560 dot.node_style(i, label=clean(g.get_vertex_name(v)))
9567 st = g.get_graphviz_string()
9568 open(tfn,
"w").write(st)
9573 sys.stderr.write(
"Cannot run dot on Python 2.3 systems.\n")
9576 print(
"running dot")
9577 sp = subprocess.Popen([
"dot",
"-Tpdf", tfn,
"-o" + tfon])
9581 sys.stderr.write(
"The dot command from the graphviz package was not found. Please make sure it is in the PATH passed to IMP.\n")
9584 if platform.system() ==
"Darwin":
9587 cmd = [
"gv",
"acroread",
"xpdf"]
9590 print(
"launching viewer " + c)
9592 subprocess.check_call([c, tfon])
9598 print(
"Could not display file. It is saved at " + tfon)
9608 """Mark a Python module as deprecated.
9609 @note The `module` argument would normally be `__name__`.
9610 @see [deprecation support](@ref deprecation)."""
9612 "Module %s is deprecated. %s\n" % (module, help_message))
9615 """Python decorator to mark a class as deprecated.
9616 @see [deprecation support](@ref deprecation)."""
9618 orig_init = obj.__init__
9621 @functools.wraps(orig_init, (
'__name__',
'__doc__'))
9622 def __init__(obj, *args, **keys):
9624 % (type(obj), help_message))
9625 orig_init(obj, *args, **keys)
9626 obj.__init__ = __init__
9631 """Python decorator to mark a method as deprecated.
9632 @see [deprecation support](@ref deprecation)."""
9633 def out_wrapper(obj):
9634 @functools.wraps(obj)
9635 def wrapper(cls, *args, **keys):
9637 % (obj.__name__, type(cls), help_message))
9638 return obj(cls, *args, **keys)
9643 """Python decorator to mark a function as deprecated.
9644 @see [deprecation support](@ref deprecation)."""
9645 def out_wrapper(obj):
9646 @functools.wraps(obj)
9647 def wrapper(*args, **keys):
9649 % (obj.__name__, help_message))
9650 return obj(*args, **keys)
9654 @contextlib.contextmanager
9656 """Context manager to temporarily allow (or disallow) deprecated code.
9657 @see [deprecation support](@ref deprecation)."""
9663 class RandomNumberGenerator(object):
9664 """Proxy of C++ IMP::RandomNumberGenerator class."""
9666 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
9667 __repr__ = _swig_repr
9670 """seed(RandomNumberGenerator self, ::boost::int32_t x)"""
9671 return _IMP_kernel.RandomNumberGenerator_seed(self, x)
9675 """__call__(RandomNumberGenerator self) -> int"""
9676 return _IMP_kernel.RandomNumberGenerator___call__(self)
9680 """__init__(IMP::RandomNumberGenerator self) -> RandomNumberGenerator"""
9681 this = _IMP_kernel.new_RandomNumberGenerator()
9683 self.this.append(this)
9686 __swig_destroy__ = _IMP_kernel.delete_RandomNumberGenerator
9687 __del__ =
lambda self:
None
9688 RandomNumberGenerator_swigregister = _IMP_kernel.RandomNumberGenerator_swigregister
9689 RandomNumberGenerator_swigregister(RandomNumberGenerator)
9694 get_random_float_uniform() -> float
9695 get_random_float_uniform(float min, float max) -> float
9697 return _IMP_kernel.get_random_float_uniform(*args)
9701 get_random_double_uniform() -> double
9702 get_random_double_uniform(double min, double max) -> double
9704 return _IMP_kernel.get_random_double_uniform(*args)
9706 def get_random_floats_normal(n, mean=0.0, stddev=1.0):
9708 get_random_floats_normal(unsigned int n, float mean=0.0, float stddev=1.0) -> IMP::Vector< float >
9709 get_random_floats_normal(unsigned int n, float mean=0.0) -> IMP::Vector< float >
9710 get_random_floats_normal(unsigned int n) -> IMP::Vector< float >
9712 return _IMP_kernel.get_random_floats_normal(n, mean, stddev)
9714 def get_random_doubles_normal(n, mean=0.0, stddev=1.0):
9716 get_random_doubles_normal(unsigned int n, double mean=0.0, double stddev=1.0) -> IMP::Vector< double >
9717 get_random_doubles_normal(unsigned int n, double mean=0.0) -> IMP::Vector< double >
9718 get_random_doubles_normal(unsigned int n) -> IMP::Vector< double >
9720 return _IMP_kernel.get_random_doubles_normal(n, mean, stddev)
9722 def get_random_floats_uniform(n):
9723 """get_random_floats_uniform(unsigned int n) -> IMP::Vector< float >"""
9724 return _IMP_kernel.get_random_floats_uniform(n)
9726 def get_random_doubles_uniform(n):
9727 """get_random_doubles_uniform(unsigned int n) -> IMP::Vector< double >"""
9728 return _IMP_kernel.get_random_doubles_uniform(n)
9731 """get_random_seed() -> boost::uint64_t"""
9732 return _IMP_kernel.get_random_seed()
9734 def get_module_version():
9735 """get_module_version() -> std::string const"""
9736 return _IMP_kernel.get_module_version()
9739 """get_example_path(std::string fname) -> std::string"""
9740 return _IMP_kernel.get_example_path(fname)
9743 """get_data_path(std::string fname) -> std::string"""
9744 return _IMP_kernel.get_data_path(fname)
9746 from .
import _version_check
9747 _version_check.check_version(get_module_version())
9748 __version__ = get_module_version()
9751 random_number_generator = cvar.random_number_generator
Key< 4, true > ObjectKey
The type used to identify an Object attribute.
void add_int_flag(std::string name, size_t default_value, std::string description)
Allow command line tools to easily implement multiple commands.
CheckLevel get_check_level()
Get the current audit mode.
def allow_deprecated
Context manager to temporarily allow (or disallow) deprecated code.
std::string get_unique_name(std::string templ)
Return a unique name produced from the string.
DependencyGraph get_dependency_graph(Model *m)
Objects get_live_objects()
Return pointers to all live objects.
Vector< char > write_particles_to_buffer(const ParticlesTemp &particles, const FloatKeys &keys)
return a binary buffer with the data
void show_timings(TextOutput out)
Show all captured timings.
def main
Call this method to act upon the user-provided command line.
boost::graph DependencyGraph
A directed graph on the interactions between the various objects in the model.
ContainersTemp get_input_containers(const ModelObjectsTemp &mos)
Return all the input particles for a given ModelObject.
ParticlesTemp get_dependent_particles(ModelObject *p, const ModelObjectsTemp &all, const DependencyGraph &dg, const DependencyGraphVertexIndex &index)
def deprecated_module
Mark a Python module as deprecated.
Vector< VectorD< D > > get_vertices(const BoundingBoxD< D > &bb)
Return a list of the 2^D bounding points for the bounding box.
Key< 8, true > ModelKey
The type used to identify data stored directly in the model.
Array< 4, WeakPointer< Particle >, Particle * > ParticleQuad
bool get_bool_flag(std::string name)
void handle_use_deprecated(std::string message)
void set_progress_display(std::string description, unsigned int steps)
Set up the progress bar with the passed description.
def deprecated_function
Python decorator to mark a function as deprecated.
def parse_args
Parse the command line and return options and positional arguments.
Index< ParticleIndexTag > ParticleIndex
ParticlesTemp get_particles(Model *m, const ParticleIndexes &ps)
Array< 3, WeakPointer< Particle >, Particle * > ParticleTriplet
ContainersTemp get_output_containers(const ModelObjectsTemp &mos)
Return all the output particles for a given ModelObject.
void add_particle(RMF::FileHandle fh, Particle *hs)
std::string get_data_path(std::string file_name)
Return the full path to one of this module's data files.
void add_string_flag(std::string name, std::string default_value, std::string description)
LogLevel get_log_level()
Get the currently active global log level.
void set_deprecation_warnings(bool tf)
Toggle printing of warnings on using deprecated classes.
TextOutput create_temporary_file(std::string prefix="imp_temp", std::string suffix="")
ParticlesTemp get_output_particles(const ModelObjectsTemp &mos)
Return all the output particles for a given ModelObject.
IMP-specific subclass of optparse.OptionParser.
ScoringFunction * create_scoring_function(RestraintType *rs, double weight=1.0, double max=NO_MAX, std::string name=std::string())
void clear_statistics()
Reset all the statistics for IMP.
Key< 1, true > IntKey
The type used to identify int attributes in the Particles.
void write_help(std::ostream &out=std::cerr)
size_t get_int_flag(std::string name)
void add_restraint(RMF::FileHandle fh, Restraint *hs)
ScoreStatesTemp get_required_score_states(ModelObject *p, const ModelObjectsTemp &all, const DependencyGraph &dg, const DependencyGraphVertexIndex &index)
boost::uint64_t get_random_seed()
Return the initial random seed.
Strings get_live_object_names()
Return the names of all live objects.
void add_to_progress_display(unsigned int step=1)
Set the current progress.
void add_float_flag(std::string name, double default_value, std::string description)
Ints get_index(const ParticlesTemp &particles, const Subset &subset, const Subsets &excluded)
def deprecated_method
Python decorator to mark a method as deprecated.
void reset_log_timer()
Reset the log timer.
void add_restraints(RMF::FileHandle fh, const Restraints &hs)
void add_to_log(LogLevel level, std::string to_write)
Write a string to the log, for Python.
Key< 3, true > ParticleIndexKey
The type used to identify a particle attribute in the Particles.
Version and module information for Objects.
Key< 0, true > FloatKey
The type used to identify float attributes in the Particles.
Restraints create_decomposition(const RestraintsTemp &rs)
Return the decomposition of a list of restraints.
std::string get_relative_path(std::string base, std::string relative)
Return a path to a file relative to another file.
void set_deprecation_exceptions(bool tf)
Toggle whether an exception is thrown when a deprecated method is used.
std::ostream & show(Hierarchy h, std::ostream &out=std::cout)
Print the hierarchy using a given decorator to display each node.
std::string get_executable_name()
Return the name of the current executable.
void set_log_level(LogLevel l)
Set the current global log level.
unsigned int get_number_of_threads()
float get_random_float_uniform()
Return a uniformly distributed float number in range [0..1)
def deprecated_object
Python decorator to mark a class as deprecated.
ParticlesTemp get_input_particles(const ModelObjectsTemp &mos)
Return all the input particles for a given ModelObject.
Key< 6, true > ParticleIndexesKey
The type used to identify a particle attribute in the Particles.
void set_show_leaked_objects(bool tf)
Set whether to complain about objects not being properly cleaned up.
bool get_deprecation_exceptions()
Get whether an exception is thrown when a deprecated method is used.
void set_log_timer(bool tb)
Set whether log messages are tagged with the current log time.
void show_restraint_hierarchy(ScoringFunctionAdaptor rs, std::ostream &out=std::cout)
Print the hierarchy of restraints.
DependencyGraph get_pruned_dependency_graph(Model *m)
std::string get_example_path(std::string file_name)
Return the full path to one of this module's example files.
void set_statistics_level(StatisticsLevel l)
Set the level of statistics to be gathered.
Array< 2, WeakPointer< Particle >, Particle * > ParticlePair
Restraints create_restraints(RMF::FileConstHandle fh, Model *m)
std::string show_graphviz(Graph g)
std::string get_string_flag(std::string name)
networkx::DiGraph get_networkx_graph(Graph g)
double get_random_double_uniform()
Return a uniformly distributed double number in range [0..1)
Key< 2, true > StringKey
The type used to identify string attributes in the Particles.
void show_altgraph(Graph g)
void setup_from_argv(int argc, char **argv, std::string description)
Parse the command line flags and return the positional arguments.
void add_bool_flag(std::string name, std::string description)
ParticleIndexes get_indexes(const ParticlesTemp &ps)
void read_particles_from_buffer(const Vector< char > &buffer, const ParticlesTemp &particles, const FloatKeys &keys)
load found attributes into the particles
void set_number_of_threads(unsigned int n)
double get_float_flag(std::string name)
void set_check_level(CheckLevel tf)
Control runtime checks in the code.
ScoreStatesTemp get_update_order(ScoreStatesTemp input)
std::string create_temporary_file_name(std::string prefix="imp_temp", std::string suffix="")
Create a temporary file.