14 from sys
import version_info
as _swig_python_version_info
18 import builtins
as __builtin__
24 strthis =
"proxy of " + self.this.__repr__()
25 except __builtin__.Exception:
27 return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
30 def _swig_setattr_nondynamic_instance_variable(set):
31 def set_instance_attr(self, name, value):
33 set(self, name, value)
34 elif name ==
"thisown":
36 elif hasattr(self, name)
and isinstance(getattr(type(self), name), property):
37 set(self, name, value)
39 raise AttributeError(
"You cannot add instance attributes to %s" % self)
40 return set_instance_attr
43 def _swig_setattr_nondynamic_class_variable(set):
44 def set_class_attr(cls, name, value):
45 if hasattr(cls, name)
and not isinstance(getattr(cls, name), property):
48 raise AttributeError(
"You cannot add class attributes to %s" % cls)
52 def _swig_add_metaclass(metaclass):
53 """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
55 return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
59 class _SwigNonDynamicMeta(type):
60 """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
61 __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)
66 class IMP_KERNEL_SwigPyIterator(object):
67 r"""Proxy of C++ swig::IMP_KERNEL_SwigPyIterator class."""
69 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
71 def __init__(self, *args, **kwargs):
72 raise AttributeError(
"No constructor defined - class is abstract")
74 __swig_destroy__ = _IMP_kernel.delete_IMP_KERNEL_SwigPyIterator
77 r"""value(IMP_KERNEL_SwigPyIterator self) -> PyObject *"""
78 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_value(self)
81 r"""incr(IMP_KERNEL_SwigPyIterator self, size_t n=1) -> IMP_KERNEL_SwigPyIterator"""
82 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_incr(self, n)
85 r"""decr(IMP_KERNEL_SwigPyIterator self, size_t n=1) -> IMP_KERNEL_SwigPyIterator"""
86 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_decr(self, n)
88 def distance(self, x):
89 r"""distance(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> ptrdiff_t"""
90 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_distance(self, x)
93 r"""equal(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> bool"""
94 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_equal(self, x)
97 r"""copy(IMP_KERNEL_SwigPyIterator self) -> IMP_KERNEL_SwigPyIterator"""
98 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_copy(self)
101 r"""next(IMP_KERNEL_SwigPyIterator self) -> PyObject *"""
102 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_next(self)
105 r"""__next__(IMP_KERNEL_SwigPyIterator self) -> PyObject *"""
106 return _IMP_kernel.IMP_KERNEL_SwigPyIterator___next__(self)
109 r"""previous(IMP_KERNEL_SwigPyIterator self) -> PyObject *"""
110 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_previous(self)
112 def advance(self, n):
113 r"""advance(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator"""
114 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_advance(self, n)
117 r"""__eq__(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> bool"""
118 return _IMP_kernel.IMP_KERNEL_SwigPyIterator___eq__(self, x)
121 r"""__ne__(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> bool"""
122 return _IMP_kernel.IMP_KERNEL_SwigPyIterator___ne__(self, x)
124 def __iadd__(self, n):
125 r"""__iadd__(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator"""
126 return _IMP_kernel.IMP_KERNEL_SwigPyIterator___iadd__(self, n)
128 def __isub__(self, n):
129 r"""__isub__(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator"""
130 return _IMP_kernel.IMP_KERNEL_SwigPyIterator___isub__(self, n)
132 def __add__(self, n):
133 r"""__add__(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator"""
134 return _IMP_kernel.IMP_KERNEL_SwigPyIterator___add__(self, n)
136 def __sub__(self, *args):
138 __sub__(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator
139 __sub__(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> ptrdiff_t
141 return _IMP_kernel.IMP_KERNEL_SwigPyIterator___sub__(self, *args)
146 _IMP_kernel.IMP_KERNEL_SwigPyIterator_swigregister(IMP_KERNEL_SwigPyIterator)
153 IMP_DEBUG = _IMP_kernel.IMP_DEBUG
155 IMP_RELEASE = _IMP_kernel.IMP_RELEASE
157 IMP_SILENT = _IMP_kernel.IMP_SILENT
159 IMP_PROGRESS = _IMP_kernel.IMP_PROGRESS
161 IMP_TERSE = _IMP_kernel.IMP_TERSE
163 IMP_VERBOSE = _IMP_kernel.IMP_VERBOSE
165 IMP_MEMORY = _IMP_kernel.IMP_MEMORY
167 IMP_NONE = _IMP_kernel.IMP_NONE
169 IMP_USAGE = _IMP_kernel.IMP_USAGE
171 IMP_INTERNAL = _IMP_kernel.IMP_INTERNAL
173 IMP_KERNEL_HAS_LOG4CXX = _IMP_kernel.IMP_KERNEL_HAS_LOG4CXX
175 IMP_COMPILER_HAS_CEREAL_RAW_POINTER = _IMP_kernel.IMP_COMPILER_HAS_CEREAL_RAW_POINTER
177 IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_kernel.IMP_COMPILER_HAS_DEBUG_VECTOR
179 IMP_COMPILER_HAS_RANDOM_SHUFFLE = _IMP_kernel.IMP_COMPILER_HAS_RANDOM_SHUFFLE
181 IMP_COMPILER_HAS_THREE_WAY = _IMP_kernel.IMP_COMPILER_HAS_THREE_WAY
183 IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_kernel.IMP_KERNEL_HAS_BOOST_RANDOM
185 IMP_KERNEL_HAS_NUMPY = _IMP_kernel.IMP_KERNEL_HAS_NUMPY
187 IMP_KERNEL_HAS_BOOST_SYSTEM = _IMP_kernel.IMP_KERNEL_HAS_BOOST_SYSTEM
189 IMP_KERNEL_HAS_GPERFTOOLS = _IMP_kernel.IMP_KERNEL_HAS_GPERFTOOLS
191 IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER = _IMP_kernel.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER
193 IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER = _IMP_kernel.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER
195 IMPKERNEL_SHOW_WARNINGS = _IMP_kernel.IMPKERNEL_SHOW_WARNINGS
199 class _DirectorObjects:
200 """@internal Simple class to keep references to director objects
201 to prevent premature deletion."""
204 def register(self, obj):
205 """Take a reference to a director object; will only work for
206 refcounted C++ classes"""
207 if hasattr(obj,
'get_ref_count'):
208 self._objects.append(obj)
210 """Only drop our reference and allow cleanup by Python if no other
211 Python references exist (we hold 3 references: one in self._objects,
212 one in x, and one in the argument list for getrefcount) *and* no
213 other C++ references exist (the Python object always holds one)"""
214 objs = [x
for x
in self._objects
if sys.getrefcount(x) > 3 \
215 or x.get_ref_count() > 1]
219 def get_object_count(self):
220 """Get number of director objects (useful for testing only)"""
221 return len(self._objects)
222 _director_objects = _DirectorObjects()
224 DEFAULT_CHECK = _IMP_kernel.DEFAULT_CHECK
226 NONE = _IMP_kernel.NONE
228 USAGE = _IMP_kernel.USAGE
230 USAGE_AND_INTERNAL = _IMP_kernel.USAGE_AND_INTERNAL
234 r"""set_check_level(IMP::CheckLevel tf)"""
235 return _IMP_kernel.set_check_level(tf)
238 r"""get_check_level() -> IMP::CheckLevel"""
239 return _IMP_kernel.get_check_level()
241 from _IMP_kernel
import Exception, InternalException, ModelException, EventException
242 from _IMP_kernel
import UsageException, IndexException, IOException, ValueException
243 from _IMP_kernel
import TypeException
245 class _ostream(object):
246 r"""Proxy of C++ std::ostream class."""
248 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
250 def __init__(self, *args, **kwargs):
251 raise AttributeError(
"No constructor defined")
252 __repr__ = _swig_repr
254 def write(self, osa_buf):
255 r"""write(_ostream self, char const * osa_buf)"""
256 return _IMP_kernel._ostream_write(self, osa_buf)
259 _IMP_kernel._ostream_swigregister(_ostream)
260 IMP_C_OPEN_BINARY = _IMP_kernel.IMP_C_OPEN_BINARY
263 from .
import _list_util
266 _models_set = weakref.WeakSet()
268 def _models_set_get(m):
269 for x
in _models_set:
274 _raii_types.append(
"SetLogState")
277 _raii_types.append(
"SetNumberOfThreads")
280 _raii_types.append(
"SetCheckState")
283 _object_types.append(
"Object")
286 def _object_cast_to_Object(o):
287 r"""_object_cast_to_Object(Object * o) -> Object"""
288 return _IMP_kernel._object_cast_to_Object(o)
290 _object_types.append(
"_TestObject")
293 def _object_cast_to__TestObject(o):
294 r"""_object_cast_to__TestObject(Object * o) -> _TestObject"""
295 return _IMP_kernel._object_cast_to__TestObject(o)
298 _plural_types.append(
"VersionInfos")
299 _value_types.append(
"VersionInfo")
302 _raii_types.append(
"CreateLogContext")
305 _raii_types.append(
"WarningContext")
308 _raii_types.append(
"SetLogTarget")
312 _plural_types.append(
"_TestValues")
313 _value_types.append(
"_TestValue")
317 _plural_types.append(
"Floats")
318 _value_types.append(
"Float")
322 _plural_types.append(
"Ints")
323 _value_types.append(
"Int")
327 _plural_types.append(
"Strings")
328 _value_types.append(
"String")
332 _plural_types.append(
"_Protections")
333 _value_types.append(
"_Protection")
335 class _InputAdaptor(object):
336 r"""Proxy of C++ IMP::InputAdaptor class."""
338 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
340 def __init__(self, *args, **kwargs):
341 raise AttributeError(
"No constructor defined")
342 __repr__ = _swig_repr
344 def __getstate__(self):
345 raise NotImplementedError(str(self.__class__)
346 +
" does not support serialization")
348 __swig_destroy__ = _IMP_kernel.delete__InputAdaptor
351 _IMP_kernel._InputAdaptor_swigregister(_InputAdaptor)
352 class _NonCopyable(object):
353 r"""Proxy of C++ IMP::NonCopyable class."""
355 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
357 def __init__(self, *args, **kwargs):
358 raise AttributeError(
"No constructor defined")
359 __repr__ = _swig_repr
360 __swig_destroy__ = _IMP_kernel.delete__NonCopyable
363 _IMP_kernel._NonCopyable_swigregister(_NonCopyable)
364 class _RAII(_NonCopyable):
365 r"""Proxy of C++ IMP::RAII class."""
367 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
369 def __init__(self, *args, **kwargs):
370 raise AttributeError(
"No constructor defined")
371 __repr__ = _swig_repr
372 __swig_destroy__ = _IMP_kernel.delete__RAII
375 _IMP_kernel._RAII_swigregister(_RAII)
376 class _Value(object):
377 r"""Proxy of C++ IMP::Value class."""
379 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
381 def __init__(self, *args, **kwargs):
382 raise AttributeError(
"No constructor defined")
383 __repr__ = _swig_repr
385 def __getstate__(self):
386 raise NotImplementedError(str(self.__class__)
387 +
" does not support serialization")
389 __swig_destroy__ = _IMP_kernel.delete__Value
392 _IMP_kernel._Value_swigregister(_Value)
395 r"""get_executable_name() -> std::string"""
396 return _IMP_kernel.get_executable_name()
400 setup_from_argv(IMP::Strings const & argv, std::string description)
401 setup_from_argv(IMP::Strings const & argv, std::string description, std::string positional_description, int num_positional) -> IMP::Strings
403 return _IMP_kernel.setup_from_argv(*args)
406 r"""add_string_flag(std::string name, std::string default_value, std::string description)"""
407 return _IMP_kernel.add_string_flag(name, default_value, description)
410 r"""get_string_flag(std::string name) -> std::string"""
411 return _IMP_kernel.get_string_flag(name)
414 r"""add_int_flag(std::string name, size_t default_value, std::string description)"""
415 return _IMP_kernel.add_int_flag(name, default_value, description)
418 r"""get_int_flag(std::string name) -> size_t"""
419 return _IMP_kernel.get_int_flag(name)
422 r"""add_bool_flag(std::string name, std::string description)"""
423 return _IMP_kernel.add_bool_flag(name, description)
426 r"""get_bool_flag(std::string name) -> bool"""
427 return _IMP_kernel.get_bool_flag(name)
430 r"""add_float_flag(std::string name, double default_value, std::string description)"""
431 return _IMP_kernel.add_float_flag(name, default_value, description)
434 r"""get_float_flag(std::string name) -> double"""
435 return _IMP_kernel.get_float_flag(name)
438 r"""write_help(_ostream out=std::cerr)"""
439 return _IMP_kernel.write_help(*args)
442 r"""get_is_quick_test() -> bool"""
443 return _IMP_kernel.get_is_quick_test()
444 DEFAULT = _IMP_kernel.DEFAULT
446 SILENT = _IMP_kernel.SILENT
448 WARNING = _IMP_kernel.WARNING
450 PROGRESS = _IMP_kernel.PROGRESS
452 TERSE = _IMP_kernel.TERSE
454 VERBOSE = _IMP_kernel.VERBOSE
456 MEMORY = _IMP_kernel.MEMORY
458 ALL_LOG = _IMP_kernel.ALL_LOG
460 class VersionInfo(_Value):
461 r"""Proxy of C++ IMP::VersionInfo class."""
463 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
465 def __init__(self, *args):
467 __init__(VersionInfo self, std::string module, std::string version) -> VersionInfo
468 __init__(VersionInfo self) -> VersionInfo
470 _IMP_kernel.VersionInfo_swiginit(self, _IMP_kernel.new_VersionInfo(*args))
472 def get_module(self):
473 r"""get_module(VersionInfo self) -> std::string"""
474 return _IMP_kernel.VersionInfo_get_module(self)
476 def get_version(self):
477 r"""get_version(VersionInfo self) -> std::string"""
478 return _IMP_kernel.VersionInfo_get_version(self)
480 def show(self, *args):
481 r"""show(VersionInfo self, _ostream out=std::cout)"""
482 return _IMP_kernel.VersionInfo_show(self, *args)
484 def __cmp__(self, o):
485 r"""__cmp__(VersionInfo self, VersionInfo o) -> int"""
486 return _IMP_kernel.VersionInfo___cmp__(self, o)
489 r"""__eq__(VersionInfo self, VersionInfo o) -> bool"""
490 return _IMP_kernel.VersionInfo___eq__(self, o)
493 r"""__ne__(VersionInfo self, VersionInfo o) -> bool"""
494 return _IMP_kernel.VersionInfo___ne__(self, o)
497 r"""__lt__(VersionInfo self, VersionInfo o) -> bool"""
498 return _IMP_kernel.VersionInfo___lt__(self, o)
501 r"""__gt__(VersionInfo self, VersionInfo o) -> bool"""
502 return _IMP_kernel.VersionInfo___gt__(self, o)
505 r"""__ge__(VersionInfo self, VersionInfo o) -> bool"""
506 return _IMP_kernel.VersionInfo___ge__(self, o)
509 r"""__le__(VersionInfo self, VersionInfo o) -> bool"""
510 return _IMP_kernel.VersionInfo___le__(self, o)
513 r"""__str__(VersionInfo self) -> std::string"""
514 return _IMP_kernel.VersionInfo___str__(self)
517 r"""__repr__(VersionInfo self) -> std::string"""
518 return _IMP_kernel.VersionInfo___repr__(self)
520 def _get_as_binary(self):
521 r"""_get_as_binary(VersionInfo self) -> PyObject *"""
522 return _IMP_kernel.VersionInfo__get_as_binary(self)
524 def _set_from_binary(self, p):
525 r"""_set_from_binary(VersionInfo self, PyObject * p)"""
526 return _IMP_kernel.VersionInfo__set_from_binary(self, p)
528 def __getstate__(self):
529 p = self._get_as_binary()
530 if len(self.__dict__) > 1:
531 d = self.__dict__.copy()
536 def __setstate__(self, p):
537 if not hasattr(self,
'this'):
539 if isinstance(p, tuple):
541 self.__dict__.update(d)
542 return self._set_from_binary(p)
544 __swig_destroy__ = _IMP_kernel.delete_VersionInfo
547 _IMP_kernel.VersionInfo_swigregister(VersionInfo)
548 class TextOutput(_InputAdaptor):
549 r"""Proxy of C++ IMP::TextOutput class."""
551 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
552 __repr__ = _swig_repr
554 def __init__(self, *args):
556 __init__(TextOutput self, int arg2) -> TextOutput
557 __init__(TextOutput self, double arg2) -> TextOutput
558 __init__(TextOutput self, char const * c, bool append=False) -> TextOutput
559 __init__(TextOutput self, IMP::TextProxy< std::ostream > p) -> TextOutput
560 __init__(TextOutput self) -> TextOutput
561 __init__(TextOutput self, std::string file_name, bool append=False) -> TextOutput
563 _IMP_kernel.TextOutput_swiginit(self, _IMP_kernel.new_TextOutput(*args))
565 def show(self, *args):
566 r"""show(TextOutput self, _ostream out=std::cout)"""
567 return _IMP_kernel.TextOutput_show(self, *args)
570 r"""get_name(TextOutput self) -> std::string"""
571 return _IMP_kernel.TextOutput_get_name(self)
572 __swig_destroy__ = _IMP_kernel.delete_TextOutput
575 _IMP_kernel.TextOutput_swigregister(TextOutput)
576 class TextInput(_InputAdaptor):
577 r"""Proxy of C++ IMP::TextInput class."""
579 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
580 __repr__ = _swig_repr
582 def __init__(self, *args):
584 __init__(TextInput self, int arg2) -> TextInput
585 __init__(TextInput self, double arg2) -> TextInput
586 __init__(TextInput self, char const * c) -> TextInput
587 __init__(TextInput self, IMP::TextProxy< std::istream > p) -> TextInput
588 __init__(TextInput self) -> TextInput
589 __init__(TextInput self, std::string file_name) -> TextInput
591 _IMP_kernel.TextInput_swiginit(self, _IMP_kernel.new_TextInput(*args))
593 def show(self, *args):
594 r"""show(TextInput self, _ostream out=std::cout)"""
595 return _IMP_kernel.TextInput_show(self, *args)
598 r"""get_name(TextInput self) -> std::string"""
599 return _IMP_kernel.TextInput_get_name(self)
601 def set_binary_open_mode(self, binary):
602 r"""set_binary_open_mode(TextInput self, bool binary)"""
603 return _IMP_kernel.TextInput_set_binary_open_mode(self, binary)
604 __swig_destroy__ = _IMP_kernel.delete_TextInput
607 _IMP_kernel.TextInput_swigregister(TextInput)
608 class SetLogTarget(_RAII):
609 r"""Proxy of C++ IMP::SetLogTarget class."""
611 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
613 def __init__(self, *args):
615 __init__(SetLogTarget self) -> SetLogTarget
616 __init__(SetLogTarget self, TextOutput to) -> SetLogTarget
618 _IMP_kernel.SetLogTarget_swiginit(self, _IMP_kernel.new_SetLogTarget(*args))
621 r"""set(SetLogTarget self, TextOutput to)"""
622 return _IMP_kernel.SetLogTarget_set(self, to)
625 r"""reset(SetLogTarget self)"""
626 return _IMP_kernel.SetLogTarget_reset(self)
627 __swig_destroy__ = _IMP_kernel.delete_SetLogTarget
629 def show(self, *args):
630 r"""show(SetLogTarget self, _ostream out=std::cout)"""
631 return _IMP_kernel.SetLogTarget_show(self, *args)
635 def __exit__(self, exc_type, exc_val, exc_tb):
641 r"""__str__(SetLogTarget self) -> std::string"""
642 return _IMP_kernel.SetLogTarget___str__(self)
645 r"""__repr__(SetLogTarget self) -> std::string"""
646 return _IMP_kernel.SetLogTarget___repr__(self)
649 _IMP_kernel.SetLogTarget_swigregister(SetLogTarget)
652 r"""create_temporary_file(std::string prefix="imp_temp", std::string suffix="") -> TextOutput"""
653 return _IMP_kernel.create_temporary_file(*args)
656 r"""create_temporary_file_name(std::string prefix="imp_temp", std::string suffix="") -> std::string"""
657 return _IMP_kernel.create_temporary_file_name(*args)
660 r"""get_relative_path(std::string base, std::string relative) -> std::string"""
661 return _IMP_kernel.get_relative_path(base, relative)
664 r"""get_absolute_path(std::string file) -> std::string"""
665 return _IMP_kernel.get_absolute_path(file)
667 def push_log_context(functionname, object):
668 r"""push_log_context(char const * functionname, void const * object)"""
669 return _IMP_kernel.push_log_context(functionname, object)
671 def pop_log_context():
672 r"""pop_log_context()"""
673 return _IMP_kernel.pop_log_context()
677 add_to_log(std::string to_write)
678 add_to_log(IMP::LogLevel level, std::string to_write)
680 return _IMP_kernel.add_to_log(*args)
683 r"""set_log_level(IMP::LogLevel l)"""
684 return _IMP_kernel.set_log_level(l)
687 r"""set_log_timer(bool tb)"""
688 return _IMP_kernel.set_log_timer(tb)
691 r"""reset_log_timer()"""
692 return _IMP_kernel.reset_log_timer()
695 r"""get_log_level() -> IMP::LogLevel"""
696 return _IMP_kernel.get_log_level()
699 r"""set_progress_display(std::string description, unsigned int steps)"""
700 return _IMP_kernel.set_progress_display(description, steps)
703 r"""add_to_progress_display(unsigned int step=1)"""
704 return _IMP_kernel.add_to_progress_display(step)
705 class Object(_NonCopyable):
706 r"""Proxy of C++ IMP::Object class."""
708 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
710 def __init__(self, name):
711 r"""__init__(Object self, std::string name) -> Object"""
712 if self.__class__ == Object:
716 _IMP_kernel.Object_swiginit(self, _IMP_kernel.new_Object(_self, name))
718 if self.__class__ != Object:
719 _director_objects.register(self)
723 __swig_destroy__ = _IMP_kernel.delete_Object
726 r"""__hash__(Object self) -> std::size_t"""
727 return _IMP_kernel.Object___hash__(self)
730 r"""set_log_level(Object self, IMP::LogLevel l)"""
731 return _IMP_kernel.Object_set_log_level(self, l)
734 r"""set_check_level(Object self, IMP::CheckLevel l)"""
735 return _IMP_kernel.Object_set_check_level(self, l)
738 r"""get_log_level(Object self) -> IMP::LogLevel"""
739 return _IMP_kernel.Object_get_log_level(self)
742 r"""get_check_level(Object self) -> IMP::CheckLevel"""
743 return _IMP_kernel.Object_get_check_level(self)
745 def get_version_info(self):
746 r"""get_version_info(Object self) -> VersionInfo"""
747 val = _IMP_kernel.Object_get_version_info(self)
748 if val.get_module() ==
'none':
755 r"""get_name(Object self) -> std::string const &"""
756 return _IMP_kernel.Object_get_name(self)
758 def set_name(self, name):
759 r"""set_name(Object self, std::string name)"""
760 return _IMP_kernel.Object_set_name(self, name)
762 def get_type_name(self):
763 r"""get_type_name(Object self) -> std::string"""
764 val = _IMP_kernel.Object_get_type_name(self)
765 if val ==
'unknown object type':
766 val = self.__class__.__name__
769 def set_was_used(self, tf):
770 r"""set_was_used(Object self, bool tf)"""
771 return _IMP_kernel.Object_set_was_used(self, tf)
773 def show(self, *args):
774 r"""show(Object self, _ostream out=std::cout)"""
775 return _IMP_kernel.Object_show(self, *args)
777 def get_string(self):
778 r"""get_string(Object self) -> std::string"""
779 return _IMP_kernel.Object_get_string(self)
781 def _on_destruction(self):
782 r"""_on_destruction(Object self)"""
783 return _IMP_kernel.Object__on_destruction(self)
785 def get_is_valid(self):
786 r"""get_is_valid(Object self) -> bool"""
787 return _IMP_kernel.Object_get_is_valid(self)
789 def get_ref_count(self):
790 r"""get_ref_count(Object self) -> unsigned int"""
791 return _IMP_kernel.Object_get_ref_count(self)
794 def get_number_of_live_objects():
795 r"""get_number_of_live_objects() -> unsigned int"""
796 return _IMP_kernel.Object_get_number_of_live_objects()
798 def get_is_shared(self):
799 r"""get_is_shared(Object self) -> bool"""
800 return _IMP_kernel.Object_get_is_shared(self)
802 def clear_caches(self):
803 r"""clear_caches(Object self)"""
804 return _IMP_kernel.Object_clear_caches(self)
806 def do_destroy(self):
807 r"""do_destroy(Object self)"""
808 return _IMP_kernel.Object_do_destroy(self)
810 def __getstate__(self):
811 raise NotImplementedError(str(self.__class__)
812 +
" does not support serialization")
816 r"""__eq__(Object self, Object o) -> bool"""
817 return _IMP_kernel.Object___eq__(self, o)
820 r"""__ne__(Object self, Object o) -> bool"""
821 return _IMP_kernel.Object___ne__(self, o)
824 r"""__le__(Object self, Object o) -> bool"""
825 return _IMP_kernel.Object___le__(self, o)
828 r"""__lt__(Object self, Object o) -> bool"""
829 return _IMP_kernel.Object___lt__(self, o)
832 r"""__ge__(Object self, Object o) -> bool"""
833 return _IMP_kernel.Object___ge__(self, o)
836 r"""__gt__(Object self, Object o) -> bool"""
837 return _IMP_kernel.Object___gt__(self, o)
840 """Return this object cast to the most derived subclass."""
842 modobj = sys.modules[modname]
844 return clsobj.get_from(self)
848 r"""__str__(Object self) -> std::string"""
849 return _IMP_kernel.Object___str__(self)
852 r"""__repr__(Object self) -> std::string"""
853 return _IMP_kernel.Object___repr__(self)
857 return _object_cast_to_Object(o)
859 def __disown__(self):
861 _IMP_kernel.disown_Object(self)
862 return weakref.proxy(self)
865 _IMP_kernel.Object_swigregister(Object)
867 r"""Proxy of C++ IMP::SetLogState class."""
869 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
872 r"""reset(SetLogState self)"""
873 return _IMP_kernel.SetLogState_reset(self)
874 __swig_destroy__ = _IMP_kernel.delete_SetLogState
876 def show(self, *args):
877 r"""show(SetLogState self, _ostream out=std::cout)"""
878 return _IMP_kernel.SetLogState_show(self, *args)
880 def __init__(self, *args):
882 __init__(SetLogState self) -> SetLogState
883 __init__(SetLogState self, Object o, IMP::LogLevel l) -> SetLogState
884 __init__(SetLogState self, IMP::LogLevel l) -> SetLogState
886 _IMP_kernel.SetLogState_swiginit(self, _IMP_kernel.new_SetLogState(*args))
888 def set(self, *args):
890 set(SetLogState self, Object o, IMP::LogLevel l)
891 set(SetLogState self, IMP::LogLevel l)
893 return _IMP_kernel.SetLogState_set(self, *args)
897 def __exit__(self, exc_type, exc_val, exc_tb):
903 r"""__str__(SetLogState self) -> std::string"""
904 return _IMP_kernel.SetLogState___str__(self)
907 r"""__repr__(SetLogState self) -> std::string"""
908 return _IMP_kernel.SetLogState___repr__(self)
911 _IMP_kernel.SetLogState_swigregister(SetLogState)
913 r"""Proxy of C++ IMP::WarningContext class."""
915 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
916 data_ = property(_IMP_kernel.WarningContext_data__get, _IMP_kernel.WarningContext_data__set, doc=
r"""data_ : boost::unordered_set<(std::string)>""")
918 def add_warning(self, key, warning):
919 r"""add_warning(WarningContext self, std::string key, std::string warning)"""
920 return _IMP_kernel.WarningContext_add_warning(self, key, warning)
922 def clear_warnings(self):
923 r"""clear_warnings(WarningContext self)"""
924 return _IMP_kernel.WarningContext_clear_warnings(self)
926 def dump_warnings(self):
927 r"""dump_warnings(WarningContext self)"""
928 return _IMP_kernel.WarningContext_dump_warnings(self)
929 __swig_destroy__ = _IMP_kernel.delete_WarningContext
931 def show(self, *args):
932 r"""show(WarningContext self, _ostream out=std::cout)"""
933 return _IMP_kernel.WarningContext_show(self, *args)
937 def __exit__(self, exc_type, exc_val, exc_tb):
943 r"""__str__(WarningContext self) -> std::string"""
944 return _IMP_kernel.WarningContext___str__(self)
947 r"""__repr__(WarningContext self) -> std::string"""
948 return _IMP_kernel.WarningContext___repr__(self)
951 r"""__init__(WarningContext self) -> WarningContext"""
952 _IMP_kernel.WarningContext_swiginit(self, _IMP_kernel.new_WarningContext())
955 _IMP_kernel.WarningContext_swigregister(WarningContext)
957 r"""Proxy of C++ IMP::CreateLogContext class."""
959 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
961 def __init__(self, *args):
963 __init__(CreateLogContext self, std::string fname, Object object=None) -> CreateLogContext
964 __init__(CreateLogContext self) -> CreateLogContext
965 __init__(CreateLogContext self, char const * fname, Object object=None) -> CreateLogContext
967 _IMP_kernel.CreateLogContext_swiginit(self, _IMP_kernel.new_CreateLogContext(*args))
969 def set(self, fname, object=None):
970 r"""set(CreateLogContext self, char const * fname, Object object=None)"""
971 return _IMP_kernel.CreateLogContext_set(self, fname, object)
974 r"""reset(CreateLogContext self)"""
975 return _IMP_kernel.CreateLogContext_reset(self)
976 __swig_destroy__ = _IMP_kernel.delete_CreateLogContext
978 def show(self, *args):
979 r"""show(CreateLogContext self, _ostream out=std::cout)"""
980 return _IMP_kernel.CreateLogContext_show(self, *args)
984 def __exit__(self, exc_type, exc_val, exc_tb):
990 r"""__str__(CreateLogContext self) -> std::string"""
991 return _IMP_kernel.CreateLogContext___str__(self)
994 r"""__repr__(CreateLogContext self) -> std::string"""
995 return _IMP_kernel.CreateLogContext___repr__(self)
998 _IMP_kernel.CreateLogContext_swigregister(CreateLogContext)
1000 r"""Proxy of C++ IMP::SetCheckState class."""
1002 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1005 r"""reset(SetCheckState self)"""
1006 return _IMP_kernel.SetCheckState_reset(self)
1007 __swig_destroy__ = _IMP_kernel.delete_SetCheckState
1009 def show(self, *args):
1010 r"""show(SetCheckState self, _ostream out=std::cout)"""
1011 return _IMP_kernel.SetCheckState_show(self, *args)
1013 def __init__(self, *args):
1015 __init__(SetCheckState self) -> SetCheckState
1016 __init__(SetCheckState self, Object o, IMP::CheckLevel l) -> SetCheckState
1017 __init__(SetCheckState self, IMP::CheckLevel l) -> SetCheckState
1019 _IMP_kernel.SetCheckState_swiginit(self, _IMP_kernel.new_SetCheckState(*args))
1021 def set(self, *args):
1023 set(SetCheckState self, Object o, IMP::CheckLevel l)
1024 set(SetCheckState self, IMP::CheckLevel l)
1026 return _IMP_kernel.SetCheckState_set(self, *args)
1028 def __enter__(self):
1030 def __exit__(self, exc_type, exc_val, exc_tb):
1036 r"""__str__(SetCheckState self) -> std::string"""
1037 return _IMP_kernel.SetCheckState___str__(self)
1040 r"""__repr__(SetCheckState self) -> std::string"""
1041 return _IMP_kernel.SetCheckState___repr__(self)
1044 _IMP_kernel.SetCheckState_swigregister(SetCheckState)
1047 r"""get_unique_name(std::string templ) -> std::string"""
1048 return _IMP_kernel.get_unique_name(templ)
1051 r"""get_copyright() -> std::string"""
1052 return _IMP_kernel.get_copyright()
1053 class _Protection(object):
1054 r"""Proxy of C++ IMP::internal::_Protection class."""
1056 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1058 def __init__(self, *args, **kwargs):
1059 raise AttributeError(
"No constructor defined")
1061 def show(self, *args):
1062 r"""show(_Protection self, _ostream out=std::cout)"""
1063 return _IMP_kernel._Protection_show(self, *args)
1066 r"""__str__(_Protection self) -> std::string"""
1067 return _IMP_kernel._Protection___str__(self)
1070 r"""__repr__(_Protection self) -> std::string"""
1071 return _IMP_kernel._Protection___repr__(self)
1072 __swig_destroy__ = _IMP_kernel.delete__Protection
1075 _IMP_kernel._Protection_swigregister(_Protection)
1079 return _IMP_kernel._test_log()
1081 def _test_intranges(ips):
1082 r"""_test_intranges(IMP::IntRanges const & ips) -> int"""
1083 return _IMP_kernel._test_intranges(ips)
1085 def _test_intrange(*args):
1087 _test_intrange(IMP::IntRange const & ips) -> IMP::IntRange
1088 _test_intrange() -> IMP::IntRange
1090 return _IMP_kernel._test_intrange(*args)
1093 r"""_test_ifile(TextInput a) -> std::string"""
1094 return _IMP_kernel._test_ifile(a)
1097 r"""_test_ofile(TextOutput a) -> std::string"""
1098 return _IMP_kernel._test_ofile(a)
1100 def _test_ifile_overloaded(*args):
1102 _test_ifile_overloaded(TextInput a, int i) -> std::string
1103 _test_ifile_overloaded(TextInput a, std::string st) -> std::string
1105 return _IMP_kernel._test_ifile_overloaded(*args)
1107 def _test_ofile_overloaded(*args):
1109 _test_ofile_overloaded(TextOutput a, int i) -> std::string
1110 _test_ofile_overloaded(TextOutput a, std::string st) -> std::string
1112 return _IMP_kernel._test_ofile_overloaded(*args)
1113 class _TestValue(object):
1114 r"""Proxy of C++ IMP::internal::_TestValue class."""
1116 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1118 def __init__(self, i):
1119 r"""__init__(_TestValue self, int i) -> _TestValue"""
1120 _IMP_kernel._TestValue_swiginit(self, _IMP_kernel.new__TestValue(i))
1122 def show(self, *args):
1123 r"""show(_TestValue self, _ostream out=std::cout)"""
1124 return _IMP_kernel._TestValue_show(self, *args)
1126 def __cmp__(self, o):
1127 r"""__cmp__(_TestValue self, _TestValue o) -> int"""
1128 return _IMP_kernel._TestValue___cmp__(self, o)
1130 def __eq__(self, o):
1131 r"""__eq__(_TestValue self, _TestValue o) -> bool"""
1132 return _IMP_kernel._TestValue___eq__(self, o)
1134 def __ne__(self, o):
1135 r"""__ne__(_TestValue self, _TestValue o) -> bool"""
1136 return _IMP_kernel._TestValue___ne__(self, o)
1138 def __lt__(self, o):
1139 r"""__lt__(_TestValue self, _TestValue o) -> bool"""
1140 return _IMP_kernel._TestValue___lt__(self, o)
1142 def __gt__(self, o):
1143 r"""__gt__(_TestValue self, _TestValue o) -> bool"""
1144 return _IMP_kernel._TestValue___gt__(self, o)
1146 def __ge__(self, o):
1147 r"""__ge__(_TestValue self, _TestValue o) -> bool"""
1148 return _IMP_kernel._TestValue___ge__(self, o)
1150 def __le__(self, o):
1151 r"""__le__(_TestValue self, _TestValue o) -> bool"""
1152 return _IMP_kernel._TestValue___le__(self, o)
1155 r"""get(_TestValue self) -> int"""
1156 return _IMP_kernel._TestValue_get(self)
1158 def get_float(self):
1159 r"""get_float(_TestValue self) -> float const &"""
1160 return _IMP_kernel._TestValue_get_float(self)
1162 def get_double(self):
1163 r"""get_double(_TestValue self) -> double const &"""
1164 return _IMP_kernel._TestValue_get_double(self)
1166 def get_Float(self):
1167 r"""get_Float(_TestValue self) -> IMP::Float const &"""
1168 return _IMP_kernel._TestValue_get_Float(self)
1171 r"""get_int(_TestValue self) -> int const &"""
1172 return _IMP_kernel._TestValue_get_int(self)
1175 r"""get_Int(_TestValue self) -> IMP::Int const &"""
1176 return _IMP_kernel._TestValue_get_Int(self)
1178 def get_string(self):
1179 r"""get_string(_TestValue self) -> std::string const &"""
1180 return _IMP_kernel._TestValue_get_string(self)
1182 def get_String(self):
1183 r"""get_String(_TestValue self) -> IMP::String const &"""
1184 return _IMP_kernel._TestValue_get_String(self)
1187 r"""__str__(_TestValue self) -> std::string"""
1188 return _IMP_kernel._TestValue___str__(self)
1191 r"""__repr__(_TestValue self) -> std::string"""
1192 return _IMP_kernel._TestValue___repr__(self)
1193 __swig_destroy__ = _IMP_kernel.delete__TestValue
1196 _IMP_kernel._TestValue_swigregister(_TestValue)
1198 def _pass_plain_pair(p):
1199 r"""_pass_plain_pair(IMP::FloatPair p) -> IMP::FloatPair"""
1200 return _IMP_kernel._pass_plain_pair(p)
1202 def _pass_overloaded_strings(*args):
1204 _pass_overloaded_strings(IMP::Strings const & a, int arg2) -> IMP::Strings
1205 _pass_overloaded_strings(IMP::Strings const & a) -> IMP::Strings
1207 return _IMP_kernel._pass_overloaded_strings(*args)
1210 r"""_pass_pair(IMP::DerivativePair const & p) -> IMP::DerivativePair"""
1211 return _IMP_kernel._pass_pair(p)
1213 def _pass_floats(input):
1214 r"""_pass_floats(IMP::Floats const & input) -> IMP::Floats"""
1215 return _IMP_kernel._pass_floats(input)
1217 def _pass_ints(input):
1218 r"""_pass_ints(IMP::Ints input) -> IMP::Ints"""
1219 return _IMP_kernel._pass_ints(input)
1221 def _pass_ints_list(input):
1222 r"""_pass_ints_list(IMP::IntsList const & input) -> IMP::IntsList"""
1223 return _IMP_kernel._pass_ints_list(input)
1225 def _pass_ints_lists(input):
1226 r"""_pass_ints_lists(IMP::IntsLists const & input) -> IMP::IntsLists"""
1227 return _IMP_kernel._pass_ints_lists(input)
1229 def _pass_strings(input):
1230 r"""_pass_strings(IMP::Strings const & input) -> IMP::Strings const &"""
1231 return _IMP_kernel._pass_strings(input)
1232 class _TestObject(
Object):
1233 r"""Proxy of C++ IMP::internal::_TestObject class."""
1235 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1238 r"""__init__(_TestObject self) -> _TestObject"""
1239 _IMP_kernel._TestObject_swiginit(self, _IMP_kernel.new__TestObject())
1242 r"""get_version_info(_TestObject self) -> VersionInfo"""
1243 return _IMP_kernel._TestObject_get_version_info(self)
1244 __swig_destroy__ = _IMP_kernel.delete__TestObject
1247 r"""__str__(_TestObject self) -> std::string"""
1248 return _IMP_kernel._TestObject___str__(self)
1251 r"""__repr__(_TestObject self) -> std::string"""
1252 return _IMP_kernel._TestObject___repr__(self)
1256 return _object_cast_to__TestObject(o)
1260 _IMP_kernel._TestObject_swigregister(_TestObject)
1263 r"""get_live_object_names() -> IMP::Strings"""
1264 return _IMP_kernel.get_live_object_names()
1267 r"""get_live_objects() -> IMP::Objects"""
1268 return _IMP_kernel.get_live_objects()
1271 r"""set_show_leaked_objects(bool tf)"""
1272 return _IMP_kernel.set_show_leaked_objects(tf)
1275 r"""set_deprecation_warnings(bool tf)"""
1276 return _IMP_kernel.set_deprecation_warnings(tf)
1279 r"""set_deprecation_exceptions(bool tf)"""
1280 return _IMP_kernel.set_deprecation_exceptions(tf)
1283 r"""get_deprecation_exceptions() -> bool"""
1284 return _IMP_kernel.get_deprecation_exceptions()
1287 r"""handle_use_deprecated(std::string message)"""
1288 return _IMP_kernel.handle_use_deprecated(message)
1291 r"""get_number_of_threads() -> unsigned int"""
1292 return _IMP_kernel.get_number_of_threads()
1295 r"""set_number_of_threads(unsigned int n)"""
1296 return _IMP_kernel.set_number_of_threads(n)
1298 r"""Proxy of C++ IMP::SetNumberOfThreads class."""
1300 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1302 def __init__(self, *args):
1304 __init__(SetNumberOfThreads self) -> SetNumberOfThreads
1305 __init__(SetNumberOfThreads self, unsigned int n) -> SetNumberOfThreads
1307 _IMP_kernel.SetNumberOfThreads_swiginit(self, _IMP_kernel.new_SetNumberOfThreads(*args))
1310 r"""set(SetNumberOfThreads self, unsigned int n)"""
1311 return _IMP_kernel.SetNumberOfThreads_set(self, n)
1314 r"""reset(SetNumberOfThreads self)"""
1315 return _IMP_kernel.SetNumberOfThreads_reset(self)
1316 __swig_destroy__ = _IMP_kernel.delete_SetNumberOfThreads
1318 def show(self, *args):
1319 r"""show(SetNumberOfThreads self, _ostream out=std::cout)"""
1320 return _IMP_kernel.SetNumberOfThreads_show(self, *args)
1322 def __enter__(self):
1324 def __exit__(self, exc_type, exc_val, exc_tb):
1330 r"""__str__(SetNumberOfThreads self) -> std::string"""
1331 return _IMP_kernel.SetNumberOfThreads___str__(self)
1334 r"""__repr__(SetNumberOfThreads self) -> std::string"""
1335 return _IMP_kernel.SetNumberOfThreads___repr__(self)
1338 _IMP_kernel.SetNumberOfThreads_swigregister(SetNumberOfThreads)
1341 i_m_p=
"IMP_MODULE_PATH"
1342 if i_m_p
in os.environ.keys():
1343 __path__.insert(0, os.environ[i_m_p])
1345 def _forward_add_attribute(self, name, value, opt=None):
1347 self.get_particle().add_attribute(name, value, opt)
1349 self.get_particle().add_attribute(name, value)
1350 def _forward_get_value(self, name):
1351 self.get_particle().get_value(name)
1352 def _forward_set_value(self, name, value):
1353 self.get_particle().set_value(name, value)
1359 _object_types.append(
"Constraint")
1362 def _object_cast_to_Constraint(o):
1363 r"""_object_cast_to_Constraint(Object o) -> Constraint"""
1364 return _IMP_kernel._object_cast_to_Constraint(o)
1366 _object_types.append(
"Undecorator")
1369 def _object_cast_to_Undecorator(o):
1370 r"""_object_cast_to_Undecorator(Object o) -> Undecorator"""
1371 return _IMP_kernel._object_cast_to_Undecorator(o)
1373 _object_types.append(
"Container")
1376 def _object_cast_to_Container(o):
1377 r"""_object_cast_to_Container(Object o) -> Container"""
1378 return _IMP_kernel._object_cast_to_Container(o)
1380 _object_types.append(
"Optimizer")
1383 def _object_cast_to_Optimizer(o):
1384 r"""_object_cast_to_Optimizer(Object o) -> Optimizer"""
1385 return _IMP_kernel._object_cast_to_Optimizer(o)
1387 _object_types.append(
"AttributeOptimizer")
1390 def _object_cast_to_AttributeOptimizer(o):
1391 r"""_object_cast_to_AttributeOptimizer(Object o) -> AttributeOptimizer"""
1392 return _IMP_kernel._object_cast_to_AttributeOptimizer(o)
1394 _object_types.append(
"OptimizerState")
1397 def _object_cast_to_OptimizerState(o):
1398 r"""_object_cast_to_OptimizerState(Object o) -> OptimizerState"""
1399 return _IMP_kernel._object_cast_to_OptimizerState(o)
1401 _object_types.append(
"PairContainer")
1404 def _object_cast_to_PairContainer(o):
1405 r"""_object_cast_to_PairContainer(Object o) -> PairContainer"""
1406 return _IMP_kernel._object_cast_to_PairContainer(o)
1408 _object_types.append(
"PairModifier")
1411 def _object_cast_to_PairModifier(o):
1412 r"""_object_cast_to_PairModifier(Object o) -> PairModifier"""
1413 return _IMP_kernel._object_cast_to_PairModifier(o)
1415 _object_types.append(
"PairScore")
1418 def _object_cast_to_PairScore(o):
1419 r"""_object_cast_to_PairScore(Object o) -> PairScore"""
1420 return _IMP_kernel._object_cast_to_PairScore(o)
1422 _object_types.append(
"QuadContainer")
1425 def _object_cast_to_QuadContainer(o):
1426 r"""_object_cast_to_QuadContainer(Object o) -> QuadContainer"""
1427 return _IMP_kernel._object_cast_to_QuadContainer(o)
1429 _object_types.append(
"QuadModifier")
1432 def _object_cast_to_QuadModifier(o):
1433 r"""_object_cast_to_QuadModifier(Object o) -> QuadModifier"""
1434 return _IMP_kernel._object_cast_to_QuadModifier(o)
1436 _object_types.append(
"QuadScore")
1439 def _object_cast_to_QuadScore(o):
1440 r"""_object_cast_to_QuadScore(Object o) -> QuadScore"""
1441 return _IMP_kernel._object_cast_to_QuadScore(o)
1443 _object_types.append(
"Refiner")
1446 def _object_cast_to_Refiner(o):
1447 r"""_object_cast_to_Refiner(Object o) -> Refiner"""
1448 return _IMP_kernel._object_cast_to_Refiner(o)
1450 _object_types.append(
"Restraint")
1453 def _object_cast_to_Restraint(o):
1454 r"""_object_cast_to_Restraint(Object o) -> Restraint"""
1455 return _IMP_kernel._object_cast_to_Restraint(o)
1457 _object_types.append(
"Sampler")
1460 def _object_cast_to_Sampler(o):
1461 r"""_object_cast_to_Sampler(Object o) -> Sampler"""
1462 return _IMP_kernel._object_cast_to_Sampler(o)
1464 _object_types.append(
"ScoreState")
1467 def _object_cast_to_ScoreState(o):
1468 r"""_object_cast_to_ScoreState(Object o) -> ScoreState"""
1469 return _IMP_kernel._object_cast_to_ScoreState(o)
1471 _object_types.append(
"SingletonContainer")
1474 def _object_cast_to_SingletonContainer(o):
1475 r"""_object_cast_to_SingletonContainer(Object o) -> SingletonContainer"""
1476 return _IMP_kernel._object_cast_to_SingletonContainer(o)
1478 _object_types.append(
"SingletonModifier")
1481 def _object_cast_to_SingletonModifier(o):
1482 r"""_object_cast_to_SingletonModifier(Object o) -> SingletonModifier"""
1483 return _IMP_kernel._object_cast_to_SingletonModifier(o)
1485 _object_types.append(
"SingletonScore")
1488 def _object_cast_to_SingletonScore(o):
1489 r"""_object_cast_to_SingletonScore(Object o) -> SingletonScore"""
1490 return _IMP_kernel._object_cast_to_SingletonScore(o)
1492 _object_types.append(
"TripletContainer")
1495 def _object_cast_to_TripletContainer(o):
1496 r"""_object_cast_to_TripletContainer(Object o) -> TripletContainer"""
1497 return _IMP_kernel._object_cast_to_TripletContainer(o)
1499 _object_types.append(
"TripletModifier")
1502 def _object_cast_to_TripletModifier(o):
1503 r"""_object_cast_to_TripletModifier(Object o) -> TripletModifier"""
1504 return _IMP_kernel._object_cast_to_TripletModifier(o)
1506 _object_types.append(
"TripletScore")
1509 def _object_cast_to_TripletScore(o):
1510 r"""_object_cast_to_TripletScore(Object o) -> TripletScore"""
1511 return _IMP_kernel._object_cast_to_TripletScore(o)
1513 _object_types.append(
"UnaryFunction")
1516 def _object_cast_to_UnaryFunction(o):
1517 r"""_object_cast_to_UnaryFunction(Object o) -> UnaryFunction"""
1518 return _IMP_kernel._object_cast_to_UnaryFunction(o)
1520 _object_types.append(
"RestraintInfo")
1523 def _object_cast_to_RestraintInfo(o):
1524 r"""_object_cast_to_RestraintInfo(Object o) -> RestraintInfo"""
1525 return _IMP_kernel._object_cast_to_RestraintInfo(o)
1527 _object_types.append(
"ConfigurationSet")
1530 def _object_cast_to_ConfigurationSet(o):
1531 r"""_object_cast_to_ConfigurationSet(Object o) -> ConfigurationSet"""
1532 return _IMP_kernel._object_cast_to_ConfigurationSet(o)
1534 _object_types.append(
"Configuration")
1537 def _object_cast_to_Configuration(o):
1538 r"""_object_cast_to_Configuration(Object o) -> Configuration"""
1539 return _IMP_kernel._object_cast_to_Configuration(o)
1541 _object_types.append(
"Model")
1544 def _object_cast_to_Model(o):
1545 r"""_object_cast_to_Model(Object o) -> Model"""
1546 return _IMP_kernel._object_cast_to_Model(o)
1548 _object_types.append(
"Particle")
1551 def _object_cast_to_Particle(o):
1552 r"""_object_cast_to_Particle(Object o) -> Particle"""
1553 return _IMP_kernel._object_cast_to_Particle(o)
1555 _object_types.append(
"RestraintSet")
1558 def _object_cast_to_RestraintSet(o):
1559 r"""_object_cast_to_RestraintSet(Object o) -> RestraintSet"""
1560 return _IMP_kernel._object_cast_to_RestraintSet(o)
1562 ParticlePairsTemp=list
1563 _plural_types.append(
"ParticlePairsTemp")
1564 _value_types.append(
"ParticlePair")
1567 ParticleTripletsTemp=list
1568 _plural_types.append(
"ParticleTripletsTemp")
1569 _value_types.append(
"ParticleTriplet")
1572 ParticleQuadsTemp=list
1573 _plural_types.append(
"ParticleQuadsTemp")
1574 _value_types.append(
"ParticleQuad")
1577 ParticleIndexPairs=list
1578 _plural_types.append(
"ParticleIndexPairs")
1579 _value_types.append(
"ParticleIndexPair")
1582 ParticleIndexTriplets=list
1583 _plural_types.append(
"ParticleIndexTriplets")
1584 _value_types.append(
"ParticleIndexTriplet")
1587 ParticleIndexQuads=list
1588 _plural_types.append(
"ParticleIndexQuads")
1589 _value_types.append(
"ParticleIndexQuad")
1592 _object_types.append(
"SingletonPredicate")
1595 def _object_cast_to_SingletonPredicate(o):
1596 r"""_object_cast_to_SingletonPredicate(Object o) -> SingletonPredicate"""
1597 return _IMP_kernel._object_cast_to_SingletonPredicate(o)
1599 _object_types.append(
"PairPredicate")
1602 def _object_cast_to_PairPredicate(o):
1603 r"""_object_cast_to_PairPredicate(Object o) -> PairPredicate"""
1604 return _IMP_kernel._object_cast_to_PairPredicate(o)
1606 _object_types.append(
"TripletPredicate")
1609 def _object_cast_to_TripletPredicate(o):
1610 r"""_object_cast_to_TripletPredicate(Object o) -> TripletPredicate"""
1611 return _IMP_kernel._object_cast_to_TripletPredicate(o)
1613 _object_types.append(
"QuadPredicate")
1616 def _object_cast_to_QuadPredicate(o):
1617 r"""_object_cast_to_QuadPredicate(Object o) -> QuadPredicate"""
1618 return _IMP_kernel._object_cast_to_QuadPredicate(o)
1620 _object_types.append(
"SaveToConfigurationSetOptimizerState")
1623 def _object_cast_to_SaveToConfigurationSetOptimizerState(o):
1624 r"""_object_cast_to_SaveToConfigurationSetOptimizerState(Object o) -> SaveToConfigurationSetOptimizerState"""
1625 return _IMP_kernel._object_cast_to_SaveToConfigurationSetOptimizerState(o)
1627 EvaluationStates=list
1628 _plural_types.append(
"EvaluationStates")
1629 _value_types.append(
"EvaluationState")
1632 ScoreAccumulators=list
1633 _plural_types.append(
"ScoreAccumulators")
1634 _value_types.append(
"ScoreAccumulator")
1637 ParticleIndexes=list
1638 _plural_types.append(
"ParticleIndexes")
1639 _value_types.append(
"ParticleIndex")
1643 _plural_types.append(
"FloatIndexes")
1644 _value_types.append(
"FloatIndex")
1648 _plural_types.append(
"FloatKeys")
1649 _value_types.append(
"FloatKey")
1653 _plural_types.append(
"FloatsKeys")
1654 _value_types.append(
"FloatsKey")
1658 _plural_types.append(
"IntKeys")
1659 _value_types.append(
"IntKey")
1663 _plural_types.append(
"IntsKeys")
1664 _value_types.append(
"IntsKey")
1668 _plural_types.append(
"StringKeys")
1669 _value_types.append(
"StringKey")
1672 ParticleIndexKeys=list
1673 _plural_types.append(
"ParticleIndexKeys")
1674 _value_types.append(
"ParticleIndexKey")
1677 ParticleIndexesKeys=list
1678 _plural_types.append(
"ParticleIndexesKeys")
1679 _value_types.append(
"ParticleIndexesKey")
1683 _plural_types.append(
"ObjectKeys")
1684 _value_types.append(
"ObjectKey")
1688 _plural_types.append(
"ModelKeys")
1689 _value_types.append(
"ModelKey")
1693 _plural_types.append(
"TriggerKeys")
1694 _value_types.append(
"TriggerKey")
1697 SparseFloatKeys=list
1698 _plural_types.append(
"SparseFloatKeys")
1699 _value_types.append(
"SparseFloatKey")
1703 _plural_types.append(
"SparseIntKeys")
1704 _value_types.append(
"SparseIntKey")
1707 SparseStringKeys=list
1708 _plural_types.append(
"SparseStringKeys")
1709 _value_types.append(
"SparseStringKey")
1712 SparseParticleIndexKeys=list
1713 _plural_types.append(
"SparseParticleIndexKeys")
1714 _value_types.append(
"SparseParticleIndexKey")
1717 _raii_types.append(
"ScopedSetFloatAttribute")
1720 _object_types.append(
"ScoringFunction")
1723 def _object_cast_to_ScoringFunction(o):
1724 r"""_object_cast_to_ScoringFunction(Object o) -> ScoringFunction"""
1725 return _IMP_kernel._object_cast_to_ScoringFunction(o)
1727 _object_types.append(
"ModelObject")
1730 def _object_cast_to_ModelObject(o):
1731 r"""_object_cast_to_ModelObject(Object o) -> ModelObject"""
1732 return _IMP_kernel._object_cast_to_ModelObject(o)
1734 def _TrivialDecorators(l=[]):
1735 return [_TrivialDecorator(x)
for x
in l]
1736 _plural_types.append(
"_TrivialDecorators")
1739 _value_types.append(
"_TrivialDecorator")
1742 def _TrivialDerivedDecorators(l=[]):
1743 return [_TrivialDerivedDecorator(x)
for x
in l]
1744 _plural_types.append(
"_TrivialDerivedDecorators")
1747 _value_types.append(
"_TrivialDerivedDecorator")
1750 def _TrivialTraitsDecorators(l=[]):
1751 return [_TrivialTraitsDecorator(x)
for x
in l]
1752 _plural_types.append(
"_TrivialTraitsDecorators")
1755 _value_types.append(
"_TrivialTraitsDecorator")
1758 _object_types.append(
"_ConstRestraint")
1761 def _object_cast_to__ConstRestraint(o):
1762 r"""_object_cast_to__ConstRestraint(Object o) -> _ConstRestraint"""
1763 return _IMP_kernel._object_cast_to__ConstRestraint(o)
1765 _object_types.append(
"_ConstOptimizer")
1768 def _object_cast_to__ConstOptimizer(o):
1769 r"""_object_cast_to__ConstOptimizer(Object o) -> _ConstOptimizer"""
1770 return _IMP_kernel._object_cast_to__ConstOptimizer(o)
1772 _object_types.append(
"_ConstSingletonScore")
1775 def _object_cast_to__ConstSingletonScore(o):
1776 r"""_object_cast_to__ConstSingletonScore(Object o) -> _ConstSingletonScore"""
1777 return _IMP_kernel._object_cast_to__ConstSingletonScore(o)
1779 _object_types.append(
"_ConstPairScore")
1782 def _object_cast_to__ConstPairScore(o):
1783 r"""_object_cast_to__ConstPairScore(Object o) -> _ConstPairScore"""
1784 return _IMP_kernel._object_cast_to__ConstPairScore(o)
1785 class DependencyGraph(
Object):
1786 r"""Proxy of C++ IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex > class."""
1788 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1789 __repr__ = _swig_repr
1792 r"""__init__(DependencyGraph self) -> DependencyGraph"""
1793 _IMP_kernel.DependencyGraph_swiginit(self, _IMP_kernel.new_DependencyGraph())
1795 def get_graph(self):
1796 r"""get_graph(DependencyGraph self) -> IMP::DependencyGraph const &"""
1797 return _IMP_kernel.DependencyGraph_get_graph(self)
1800 r"""get_vertices(DependencyGraph self) -> IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptors"""
1801 return _IMP_kernel.DependencyGraph_get_vertices(self)
1803 def get_vertex_name(self, i):
1804 r"""get_vertex_name(DependencyGraph self, IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptor i) -> ModelObject"""
1805 return _IMP_kernel.DependencyGraph_get_vertex_name(self, i)
1807 def get_in_neighbors(self, v):
1808 r"""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"""
1809 return _IMP_kernel.DependencyGraph_get_in_neighbors(self, v)
1811 def get_out_neighbors(self, v):
1812 r"""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"""
1813 return _IMP_kernel.DependencyGraph_get_out_neighbors(self, v)
1816 r"""show_graphviz(DependencyGraph self, _ostream out=std::cout)"""
1817 return _IMP_kernel.DependencyGraph_show_graphviz(self, *args)
1819 def get_graphviz_string(self):
1820 r"""get_graphviz_string(DependencyGraph self) -> std::string"""
1821 return _IMP_kernel.DependencyGraph_get_graphviz_string(self)
1823 def add_edge(self, v0, v1):
1824 r"""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)"""
1825 return _IMP_kernel.DependencyGraph_add_edge(self, v0, v1)
1827 def add_vertex(self, l):
1828 r"""add_vertex(DependencyGraph self, ModelObject l) -> IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptor"""
1829 return _IMP_kernel.DependencyGraph_add_vertex(self, l)
1831 def remove_vertex(self, l):
1832 r"""remove_vertex(DependencyGraph self, IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptor l)"""
1833 return _IMP_kernel.DependencyGraph_remove_vertex(self, l)
1834 __swig_destroy__ = _IMP_kernel.delete_DependencyGraph
1837 _IMP_kernel.DependencyGraph_swigregister(DependencyGraph)
1839 _value_types.append(
"DependencyGraph")
1842 r"""Proxy of C++ IMP::Key< 0 > class."""
1844 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1846 def __init__(self, *args):
1848 __init__(FloatKey self) -> FloatKey
1849 __init__(FloatKey self, std::string const & c, bool is_implicit_add_permitted=True) -> FloatKey
1850 __init__(FloatKey self, unsigned int i) -> FloatKey
1852 _IMP_kernel.FloatKey_swiginit(self, _IMP_kernel.new_FloatKey(*args))
1856 r"""add_key(std::string sc) -> unsigned int"""
1857 return _IMP_kernel.FloatKey_add_key(sc)
1860 def get_key_exists(sc):
1861 r"""get_key_exists(std::string sc) -> bool"""
1862 return _IMP_kernel.FloatKey_get_key_exists(sc)
1864 def get_string(self):
1865 r"""get_string(FloatKey self) -> std::string const"""
1866 return _IMP_kernel.FloatKey_get_string(self)
1868 def __cmp__(self, o):
1869 r"""__cmp__(FloatKey self, FloatKey o) -> int"""
1870 return _IMP_kernel.FloatKey___cmp__(self, o)
1872 def __eq__(self, o):
1873 r"""__eq__(FloatKey self, FloatKey o) -> bool"""
1874 return _IMP_kernel.FloatKey___eq__(self, o)
1876 def __ne__(self, o):
1877 r"""__ne__(FloatKey self, FloatKey o) -> bool"""
1878 return _IMP_kernel.FloatKey___ne__(self, o)
1880 def __lt__(self, o):
1881 r"""__lt__(FloatKey self, FloatKey o) -> bool"""
1882 return _IMP_kernel.FloatKey___lt__(self, o)
1884 def __gt__(self, o):
1885 r"""__gt__(FloatKey self, FloatKey o) -> bool"""
1886 return _IMP_kernel.FloatKey___gt__(self, o)
1888 def __ge__(self, o):
1889 r"""__ge__(FloatKey self, FloatKey o) -> bool"""
1890 return _IMP_kernel.FloatKey___ge__(self, o)
1892 def __le__(self, o):
1893 r"""__le__(FloatKey self, FloatKey o) -> bool"""
1894 return _IMP_kernel.FloatKey___le__(self, o)
1897 r"""__hash__(FloatKey self) -> std::size_t"""
1898 return _IMP_kernel.FloatKey___hash__(self)
1900 def show(self, *args):
1901 r"""show(FloatKey self, _ostream out=std::cout)"""
1902 return _IMP_kernel.FloatKey_show(self, *args)
1905 def add_alias(old_key, new_name):
1906 r"""add_alias(FloatKey old_key, std::string new_name) -> FloatKey"""
1907 return _IMP_kernel.FloatKey_add_alias(old_key, new_name)
1910 def get_number_of_keys():
1911 r"""get_number_of_keys() -> unsigned int"""
1912 return _IMP_kernel.FloatKey_get_number_of_keys()
1915 r"""get_index(FloatKey self) -> unsigned int"""
1916 return _IMP_kernel.FloatKey_get_index(self)
1920 r"""show_all(_ostream out)"""
1921 return _IMP_kernel.FloatKey_show_all(out)
1924 def get_all_strings():
1925 r"""get_all_strings() -> IMP::Vector< std::string >"""
1926 return _IMP_kernel.FloatKey_get_all_strings()
1929 def get_number_unique():
1930 r"""get_number_unique() -> unsigned int"""
1931 return _IMP_kernel.FloatKey_get_number_unique()
1934 r"""__str__(FloatKey self) -> std::string"""
1935 return _IMP_kernel.FloatKey___str__(self)
1938 r"""__repr__(FloatKey self) -> std::string"""
1939 return _IMP_kernel.FloatKey___repr__(self)
1940 __swig_destroy__ = _IMP_kernel.delete_FloatKey
1943 _IMP_kernel.FloatKey_swigregister(FloatKey)
1945 r"""Proxy of C++ IMP::Key< 1 > class."""
1947 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1949 def __init__(self, *args):
1951 __init__(IntKey self) -> IntKey
1952 __init__(IntKey self, std::string const & c, bool is_implicit_add_permitted=True) -> IntKey
1953 __init__(IntKey self, unsigned int i) -> IntKey
1955 _IMP_kernel.IntKey_swiginit(self, _IMP_kernel.new_IntKey(*args))
1959 r"""add_key(std::string sc) -> unsigned int"""
1960 return _IMP_kernel.IntKey_add_key(sc)
1963 def get_key_exists(sc):
1964 r"""get_key_exists(std::string sc) -> bool"""
1965 return _IMP_kernel.IntKey_get_key_exists(sc)
1967 def get_string(self):
1968 r"""get_string(IntKey self) -> std::string const"""
1969 return _IMP_kernel.IntKey_get_string(self)
1971 def __cmp__(self, o):
1972 r"""__cmp__(IntKey self, IntKey o) -> int"""
1973 return _IMP_kernel.IntKey___cmp__(self, o)
1975 def __eq__(self, o):
1976 r"""__eq__(IntKey self, IntKey o) -> bool"""
1977 return _IMP_kernel.IntKey___eq__(self, o)
1979 def __ne__(self, o):
1980 r"""__ne__(IntKey self, IntKey o) -> bool"""
1981 return _IMP_kernel.IntKey___ne__(self, o)
1983 def __lt__(self, o):
1984 r"""__lt__(IntKey self, IntKey o) -> bool"""
1985 return _IMP_kernel.IntKey___lt__(self, o)
1987 def __gt__(self, o):
1988 r"""__gt__(IntKey self, IntKey o) -> bool"""
1989 return _IMP_kernel.IntKey___gt__(self, o)
1991 def __ge__(self, o):
1992 r"""__ge__(IntKey self, IntKey o) -> bool"""
1993 return _IMP_kernel.IntKey___ge__(self, o)
1995 def __le__(self, o):
1996 r"""__le__(IntKey self, IntKey o) -> bool"""
1997 return _IMP_kernel.IntKey___le__(self, o)
2000 r"""__hash__(IntKey self) -> std::size_t"""
2001 return _IMP_kernel.IntKey___hash__(self)
2003 def show(self, *args):
2004 r"""show(IntKey self, _ostream out=std::cout)"""
2005 return _IMP_kernel.IntKey_show(self, *args)
2008 def add_alias(old_key, new_name):
2009 r"""add_alias(IntKey old_key, std::string new_name) -> IntKey"""
2010 return _IMP_kernel.IntKey_add_alias(old_key, new_name)
2013 def get_number_of_keys():
2014 r"""get_number_of_keys() -> unsigned int"""
2015 return _IMP_kernel.IntKey_get_number_of_keys()
2018 r"""get_index(IntKey self) -> unsigned int"""
2019 return _IMP_kernel.IntKey_get_index(self)
2023 r"""show_all(_ostream out)"""
2024 return _IMP_kernel.IntKey_show_all(out)
2027 def get_all_strings():
2028 r"""get_all_strings() -> IMP::Vector< std::string >"""
2029 return _IMP_kernel.IntKey_get_all_strings()
2032 def get_number_unique():
2033 r"""get_number_unique() -> unsigned int"""
2034 return _IMP_kernel.IntKey_get_number_unique()
2037 r"""__str__(IntKey self) -> std::string"""
2038 return _IMP_kernel.IntKey___str__(self)
2041 r"""__repr__(IntKey self) -> std::string"""
2042 return _IMP_kernel.IntKey___repr__(self)
2043 __swig_destroy__ = _IMP_kernel.delete_IntKey
2046 _IMP_kernel.IntKey_swigregister(IntKey)
2048 r"""Proxy of C++ IMP::Key< 2 > class."""
2050 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2052 def __init__(self, *args):
2054 __init__(StringKey self) -> StringKey
2055 __init__(StringKey self, std::string const & c, bool is_implicit_add_permitted=True) -> StringKey
2056 __init__(StringKey self, unsigned int i) -> StringKey
2058 _IMP_kernel.StringKey_swiginit(self, _IMP_kernel.new_StringKey(*args))
2062 r"""add_key(std::string sc) -> unsigned int"""
2063 return _IMP_kernel.StringKey_add_key(sc)
2066 def get_key_exists(sc):
2067 r"""get_key_exists(std::string sc) -> bool"""
2068 return _IMP_kernel.StringKey_get_key_exists(sc)
2070 def get_string(self):
2071 r"""get_string(StringKey self) -> std::string const"""
2072 return _IMP_kernel.StringKey_get_string(self)
2074 def __cmp__(self, o):
2075 r"""__cmp__(StringKey self, StringKey o) -> int"""
2076 return _IMP_kernel.StringKey___cmp__(self, o)
2078 def __eq__(self, o):
2079 r"""__eq__(StringKey self, StringKey o) -> bool"""
2080 return _IMP_kernel.StringKey___eq__(self, o)
2082 def __ne__(self, o):
2083 r"""__ne__(StringKey self, StringKey o) -> bool"""
2084 return _IMP_kernel.StringKey___ne__(self, o)
2086 def __lt__(self, o):
2087 r"""__lt__(StringKey self, StringKey o) -> bool"""
2088 return _IMP_kernel.StringKey___lt__(self, o)
2090 def __gt__(self, o):
2091 r"""__gt__(StringKey self, StringKey o) -> bool"""
2092 return _IMP_kernel.StringKey___gt__(self, o)
2094 def __ge__(self, o):
2095 r"""__ge__(StringKey self, StringKey o) -> bool"""
2096 return _IMP_kernel.StringKey___ge__(self, o)
2098 def __le__(self, o):
2099 r"""__le__(StringKey self, StringKey o) -> bool"""
2100 return _IMP_kernel.StringKey___le__(self, o)
2103 r"""__hash__(StringKey self) -> std::size_t"""
2104 return _IMP_kernel.StringKey___hash__(self)
2106 def show(self, *args):
2107 r"""show(StringKey self, _ostream out=std::cout)"""
2108 return _IMP_kernel.StringKey_show(self, *args)
2111 def add_alias(old_key, new_name):
2112 r"""add_alias(StringKey old_key, std::string new_name) -> StringKey"""
2113 return _IMP_kernel.StringKey_add_alias(old_key, new_name)
2116 def get_number_of_keys():
2117 r"""get_number_of_keys() -> unsigned int"""
2118 return _IMP_kernel.StringKey_get_number_of_keys()
2121 r"""get_index(StringKey self) -> unsigned int"""
2122 return _IMP_kernel.StringKey_get_index(self)
2126 r"""show_all(_ostream out)"""
2127 return _IMP_kernel.StringKey_show_all(out)
2130 def get_all_strings():
2131 r"""get_all_strings() -> IMP::Vector< std::string >"""
2132 return _IMP_kernel.StringKey_get_all_strings()
2135 def get_number_unique():
2136 r"""get_number_unique() -> unsigned int"""
2137 return _IMP_kernel.StringKey_get_number_unique()
2140 r"""__str__(StringKey self) -> std::string"""
2141 return _IMP_kernel.StringKey___str__(self)
2144 r"""__repr__(StringKey self) -> std::string"""
2145 return _IMP_kernel.StringKey___repr__(self)
2146 __swig_destroy__ = _IMP_kernel.delete_StringKey
2149 _IMP_kernel.StringKey_swigregister(StringKey)
2151 r"""Proxy of C++ IMP::Key< 3 > class."""
2153 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2155 def __init__(self, *args):
2157 __init__(ParticleIndexKey self) -> ParticleIndexKey
2158 __init__(ParticleIndexKey self, std::string const & c, bool is_implicit_add_permitted=True) -> ParticleIndexKey
2159 __init__(ParticleIndexKey self, unsigned int i) -> ParticleIndexKey
2161 _IMP_kernel.ParticleIndexKey_swiginit(self, _IMP_kernel.new_ParticleIndexKey(*args))
2165 r"""add_key(std::string sc) -> unsigned int"""
2166 return _IMP_kernel.ParticleIndexKey_add_key(sc)
2169 def get_key_exists(sc):
2170 r"""get_key_exists(std::string sc) -> bool"""
2171 return _IMP_kernel.ParticleIndexKey_get_key_exists(sc)
2173 def get_string(self):
2174 r"""get_string(ParticleIndexKey self) -> std::string const"""
2175 return _IMP_kernel.ParticleIndexKey_get_string(self)
2177 def __cmp__(self, o):
2178 r"""__cmp__(ParticleIndexKey self, ParticleIndexKey o) -> int"""
2179 return _IMP_kernel.ParticleIndexKey___cmp__(self, o)
2181 def __eq__(self, o):
2182 r"""__eq__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2183 return _IMP_kernel.ParticleIndexKey___eq__(self, o)
2185 def __ne__(self, o):
2186 r"""__ne__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2187 return _IMP_kernel.ParticleIndexKey___ne__(self, o)
2189 def __lt__(self, o):
2190 r"""__lt__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2191 return _IMP_kernel.ParticleIndexKey___lt__(self, o)
2193 def __gt__(self, o):
2194 r"""__gt__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2195 return _IMP_kernel.ParticleIndexKey___gt__(self, o)
2197 def __ge__(self, o):
2198 r"""__ge__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2199 return _IMP_kernel.ParticleIndexKey___ge__(self, o)
2201 def __le__(self, o):
2202 r"""__le__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2203 return _IMP_kernel.ParticleIndexKey___le__(self, o)
2206 r"""__hash__(ParticleIndexKey self) -> std::size_t"""
2207 return _IMP_kernel.ParticleIndexKey___hash__(self)
2209 def show(self, *args):
2210 r"""show(ParticleIndexKey self, _ostream out=std::cout)"""
2211 return _IMP_kernel.ParticleIndexKey_show(self, *args)
2214 def add_alias(old_key, new_name):
2215 r"""add_alias(ParticleIndexKey old_key, std::string new_name) -> ParticleIndexKey"""
2216 return _IMP_kernel.ParticleIndexKey_add_alias(old_key, new_name)
2219 def get_number_of_keys():
2220 r"""get_number_of_keys() -> unsigned int"""
2221 return _IMP_kernel.ParticleIndexKey_get_number_of_keys()
2224 r"""get_index(ParticleIndexKey self) -> unsigned int"""
2225 return _IMP_kernel.ParticleIndexKey_get_index(self)
2229 r"""show_all(_ostream out)"""
2230 return _IMP_kernel.ParticleIndexKey_show_all(out)
2233 def get_all_strings():
2234 r"""get_all_strings() -> IMP::Vector< std::string >"""
2235 return _IMP_kernel.ParticleIndexKey_get_all_strings()
2238 def get_number_unique():
2239 r"""get_number_unique() -> unsigned int"""
2240 return _IMP_kernel.ParticleIndexKey_get_number_unique()
2243 r"""__str__(ParticleIndexKey self) -> std::string"""
2244 return _IMP_kernel.ParticleIndexKey___str__(self)
2247 r"""__repr__(ParticleIndexKey self) -> std::string"""
2248 return _IMP_kernel.ParticleIndexKey___repr__(self)
2249 __swig_destroy__ = _IMP_kernel.delete_ParticleIndexKey
2252 _IMP_kernel.ParticleIndexKey_swigregister(ParticleIndexKey)
2254 r"""Proxy of C++ IMP::Key< 4 > class."""
2256 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2258 def __init__(self, *args):
2260 __init__(ObjectKey self) -> ObjectKey
2261 __init__(ObjectKey self, std::string const & c, bool is_implicit_add_permitted=True) -> ObjectKey
2262 __init__(ObjectKey self, unsigned int i) -> ObjectKey
2264 _IMP_kernel.ObjectKey_swiginit(self, _IMP_kernel.new_ObjectKey(*args))
2268 r"""add_key(std::string sc) -> unsigned int"""
2269 return _IMP_kernel.ObjectKey_add_key(sc)
2272 def get_key_exists(sc):
2273 r"""get_key_exists(std::string sc) -> bool"""
2274 return _IMP_kernel.ObjectKey_get_key_exists(sc)
2276 def get_string(self):
2277 r"""get_string(ObjectKey self) -> std::string const"""
2278 return _IMP_kernel.ObjectKey_get_string(self)
2280 def __cmp__(self, o):
2281 r"""__cmp__(ObjectKey self, ObjectKey o) -> int"""
2282 return _IMP_kernel.ObjectKey___cmp__(self, o)
2284 def __eq__(self, o):
2285 r"""__eq__(ObjectKey self, ObjectKey o) -> bool"""
2286 return _IMP_kernel.ObjectKey___eq__(self, o)
2288 def __ne__(self, o):
2289 r"""__ne__(ObjectKey self, ObjectKey o) -> bool"""
2290 return _IMP_kernel.ObjectKey___ne__(self, o)
2292 def __lt__(self, o):
2293 r"""__lt__(ObjectKey self, ObjectKey o) -> bool"""
2294 return _IMP_kernel.ObjectKey___lt__(self, o)
2296 def __gt__(self, o):
2297 r"""__gt__(ObjectKey self, ObjectKey o) -> bool"""
2298 return _IMP_kernel.ObjectKey___gt__(self, o)
2300 def __ge__(self, o):
2301 r"""__ge__(ObjectKey self, ObjectKey o) -> bool"""
2302 return _IMP_kernel.ObjectKey___ge__(self, o)
2304 def __le__(self, o):
2305 r"""__le__(ObjectKey self, ObjectKey o) -> bool"""
2306 return _IMP_kernel.ObjectKey___le__(self, o)
2309 r"""__hash__(ObjectKey self) -> std::size_t"""
2310 return _IMP_kernel.ObjectKey___hash__(self)
2312 def show(self, *args):
2313 r"""show(ObjectKey self, _ostream out=std::cout)"""
2314 return _IMP_kernel.ObjectKey_show(self, *args)
2317 def add_alias(old_key, new_name):
2318 r"""add_alias(ObjectKey old_key, std::string new_name) -> ObjectKey"""
2319 return _IMP_kernel.ObjectKey_add_alias(old_key, new_name)
2322 def get_number_of_keys():
2323 r"""get_number_of_keys() -> unsigned int"""
2324 return _IMP_kernel.ObjectKey_get_number_of_keys()
2327 r"""get_index(ObjectKey self) -> unsigned int"""
2328 return _IMP_kernel.ObjectKey_get_index(self)
2332 r"""show_all(_ostream out)"""
2333 return _IMP_kernel.ObjectKey_show_all(out)
2336 def get_all_strings():
2337 r"""get_all_strings() -> IMP::Vector< std::string >"""
2338 return _IMP_kernel.ObjectKey_get_all_strings()
2341 def get_number_unique():
2342 r"""get_number_unique() -> unsigned int"""
2343 return _IMP_kernel.ObjectKey_get_number_unique()
2346 r"""__str__(ObjectKey self) -> std::string"""
2347 return _IMP_kernel.ObjectKey___str__(self)
2350 r"""__repr__(ObjectKey self) -> std::string"""
2351 return _IMP_kernel.ObjectKey___repr__(self)
2352 __swig_destroy__ = _IMP_kernel.delete_ObjectKey
2355 _IMP_kernel.ObjectKey_swigregister(ObjectKey)
2357 r"""Proxy of C++ IMP::Key< 5 > class."""
2359 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2361 def __init__(self, *args):
2363 __init__(IntsKey self) -> IntsKey
2364 __init__(IntsKey self, std::string const & c, bool is_implicit_add_permitted=True) -> IntsKey
2365 __init__(IntsKey self, unsigned int i) -> IntsKey
2367 _IMP_kernel.IntsKey_swiginit(self, _IMP_kernel.new_IntsKey(*args))
2371 r"""add_key(std::string sc) -> unsigned int"""
2372 return _IMP_kernel.IntsKey_add_key(sc)
2375 def get_key_exists(sc):
2376 r"""get_key_exists(std::string sc) -> bool"""
2377 return _IMP_kernel.IntsKey_get_key_exists(sc)
2379 def get_string(self):
2380 r"""get_string(IntsKey self) -> std::string const"""
2381 return _IMP_kernel.IntsKey_get_string(self)
2383 def __cmp__(self, o):
2384 r"""__cmp__(IntsKey self, IntsKey o) -> int"""
2385 return _IMP_kernel.IntsKey___cmp__(self, o)
2387 def __eq__(self, o):
2388 r"""__eq__(IntsKey self, IntsKey o) -> bool"""
2389 return _IMP_kernel.IntsKey___eq__(self, o)
2391 def __ne__(self, o):
2392 r"""__ne__(IntsKey self, IntsKey o) -> bool"""
2393 return _IMP_kernel.IntsKey___ne__(self, o)
2395 def __lt__(self, o):
2396 r"""__lt__(IntsKey self, IntsKey o) -> bool"""
2397 return _IMP_kernel.IntsKey___lt__(self, o)
2399 def __gt__(self, o):
2400 r"""__gt__(IntsKey self, IntsKey o) -> bool"""
2401 return _IMP_kernel.IntsKey___gt__(self, o)
2403 def __ge__(self, o):
2404 r"""__ge__(IntsKey self, IntsKey o) -> bool"""
2405 return _IMP_kernel.IntsKey___ge__(self, o)
2407 def __le__(self, o):
2408 r"""__le__(IntsKey self, IntsKey o) -> bool"""
2409 return _IMP_kernel.IntsKey___le__(self, o)
2412 r"""__hash__(IntsKey self) -> std::size_t"""
2413 return _IMP_kernel.IntsKey___hash__(self)
2415 def show(self, *args):
2416 r"""show(IntsKey self, _ostream out=std::cout)"""
2417 return _IMP_kernel.IntsKey_show(self, *args)
2420 def add_alias(old_key, new_name):
2421 r"""add_alias(IntsKey old_key, std::string new_name) -> IntsKey"""
2422 return _IMP_kernel.IntsKey_add_alias(old_key, new_name)
2425 def get_number_of_keys():
2426 r"""get_number_of_keys() -> unsigned int"""
2427 return _IMP_kernel.IntsKey_get_number_of_keys()
2430 r"""get_index(IntsKey self) -> unsigned int"""
2431 return _IMP_kernel.IntsKey_get_index(self)
2435 r"""show_all(_ostream out)"""
2436 return _IMP_kernel.IntsKey_show_all(out)
2439 def get_all_strings():
2440 r"""get_all_strings() -> IMP::Vector< std::string >"""
2441 return _IMP_kernel.IntsKey_get_all_strings()
2444 def get_number_unique():
2445 r"""get_number_unique() -> unsigned int"""
2446 return _IMP_kernel.IntsKey_get_number_unique()
2449 r"""__str__(IntsKey self) -> std::string"""
2450 return _IMP_kernel.IntsKey___str__(self)
2453 r"""__repr__(IntsKey self) -> std::string"""
2454 return _IMP_kernel.IntsKey___repr__(self)
2455 __swig_destroy__ = _IMP_kernel.delete_IntsKey
2458 _IMP_kernel.IntsKey_swigregister(IntsKey)
2460 r"""Proxy of C++ IMP::Key< 6 > class."""
2462 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2464 def __init__(self, *args):
2466 __init__(ParticleIndexesKey self) -> ParticleIndexesKey
2467 __init__(ParticleIndexesKey self, std::string const & c, bool is_implicit_add_permitted=True) -> ParticleIndexesKey
2468 __init__(ParticleIndexesKey self, unsigned int i) -> ParticleIndexesKey
2470 _IMP_kernel.ParticleIndexesKey_swiginit(self, _IMP_kernel.new_ParticleIndexesKey(*args))
2474 r"""add_key(std::string sc) -> unsigned int"""
2475 return _IMP_kernel.ParticleIndexesKey_add_key(sc)
2478 def get_key_exists(sc):
2479 r"""get_key_exists(std::string sc) -> bool"""
2480 return _IMP_kernel.ParticleIndexesKey_get_key_exists(sc)
2482 def get_string(self):
2483 r"""get_string(ParticleIndexesKey self) -> std::string const"""
2484 return _IMP_kernel.ParticleIndexesKey_get_string(self)
2486 def __cmp__(self, o):
2487 r"""__cmp__(ParticleIndexesKey self, ParticleIndexesKey o) -> int"""
2488 return _IMP_kernel.ParticleIndexesKey___cmp__(self, o)
2490 def __eq__(self, o):
2491 r"""__eq__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
2492 return _IMP_kernel.ParticleIndexesKey___eq__(self, o)
2494 def __ne__(self, o):
2495 r"""__ne__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
2496 return _IMP_kernel.ParticleIndexesKey___ne__(self, o)
2498 def __lt__(self, o):
2499 r"""__lt__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
2500 return _IMP_kernel.ParticleIndexesKey___lt__(self, o)
2502 def __gt__(self, o):
2503 r"""__gt__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
2504 return _IMP_kernel.ParticleIndexesKey___gt__(self, o)
2506 def __ge__(self, o):
2507 r"""__ge__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
2508 return _IMP_kernel.ParticleIndexesKey___ge__(self, o)
2510 def __le__(self, o):
2511 r"""__le__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
2512 return _IMP_kernel.ParticleIndexesKey___le__(self, o)
2515 r"""__hash__(ParticleIndexesKey self) -> std::size_t"""
2516 return _IMP_kernel.ParticleIndexesKey___hash__(self)
2518 def show(self, *args):
2519 r"""show(ParticleIndexesKey self, _ostream out=std::cout)"""
2520 return _IMP_kernel.ParticleIndexesKey_show(self, *args)
2523 def add_alias(old_key, new_name):
2524 r"""add_alias(ParticleIndexesKey old_key, std::string new_name) -> ParticleIndexesKey"""
2525 return _IMP_kernel.ParticleIndexesKey_add_alias(old_key, new_name)
2528 def get_number_of_keys():
2529 r"""get_number_of_keys() -> unsigned int"""
2530 return _IMP_kernel.ParticleIndexesKey_get_number_of_keys()
2533 r"""get_index(ParticleIndexesKey self) -> unsigned int"""
2534 return _IMP_kernel.ParticleIndexesKey_get_index(self)
2538 r"""show_all(_ostream out)"""
2539 return _IMP_kernel.ParticleIndexesKey_show_all(out)
2542 def get_all_strings():
2543 r"""get_all_strings() -> IMP::Vector< std::string >"""
2544 return _IMP_kernel.ParticleIndexesKey_get_all_strings()
2547 def get_number_unique():
2548 r"""get_number_unique() -> unsigned int"""
2549 return _IMP_kernel.ParticleIndexesKey_get_number_unique()
2552 r"""__str__(ParticleIndexesKey self) -> std::string"""
2553 return _IMP_kernel.ParticleIndexesKey___str__(self)
2556 r"""__repr__(ParticleIndexesKey self) -> std::string"""
2557 return _IMP_kernel.ParticleIndexesKey___repr__(self)
2558 __swig_destroy__ = _IMP_kernel.delete_ParticleIndexesKey
2561 _IMP_kernel.ParticleIndexesKey_swigregister(ParticleIndexesKey)
2563 r"""Proxy of C++ IMP::Key< 8 > class."""
2565 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2567 def __init__(self, *args):
2569 __init__(ModelKey self) -> ModelKey
2570 __init__(ModelKey self, std::string const & c, bool is_implicit_add_permitted=True) -> ModelKey
2571 __init__(ModelKey self, unsigned int i) -> ModelKey
2573 _IMP_kernel.ModelKey_swiginit(self, _IMP_kernel.new_ModelKey(*args))
2577 r"""add_key(std::string sc) -> unsigned int"""
2578 return _IMP_kernel.ModelKey_add_key(sc)
2581 def get_key_exists(sc):
2582 r"""get_key_exists(std::string sc) -> bool"""
2583 return _IMP_kernel.ModelKey_get_key_exists(sc)
2585 def get_string(self):
2586 r"""get_string(ModelKey self) -> std::string const"""
2587 return _IMP_kernel.ModelKey_get_string(self)
2589 def __cmp__(self, o):
2590 r"""__cmp__(ModelKey self, ModelKey o) -> int"""
2591 return _IMP_kernel.ModelKey___cmp__(self, o)
2593 def __eq__(self, o):
2594 r"""__eq__(ModelKey self, ModelKey o) -> bool"""
2595 return _IMP_kernel.ModelKey___eq__(self, o)
2597 def __ne__(self, o):
2598 r"""__ne__(ModelKey self, ModelKey o) -> bool"""
2599 return _IMP_kernel.ModelKey___ne__(self, o)
2601 def __lt__(self, o):
2602 r"""__lt__(ModelKey self, ModelKey o) -> bool"""
2603 return _IMP_kernel.ModelKey___lt__(self, o)
2605 def __gt__(self, o):
2606 r"""__gt__(ModelKey self, ModelKey o) -> bool"""
2607 return _IMP_kernel.ModelKey___gt__(self, o)
2609 def __ge__(self, o):
2610 r"""__ge__(ModelKey self, ModelKey o) -> bool"""
2611 return _IMP_kernel.ModelKey___ge__(self, o)
2613 def __le__(self, o):
2614 r"""__le__(ModelKey self, ModelKey o) -> bool"""
2615 return _IMP_kernel.ModelKey___le__(self, o)
2618 r"""__hash__(ModelKey self) -> std::size_t"""
2619 return _IMP_kernel.ModelKey___hash__(self)
2621 def show(self, *args):
2622 r"""show(ModelKey self, _ostream out=std::cout)"""
2623 return _IMP_kernel.ModelKey_show(self, *args)
2626 def add_alias(old_key, new_name):
2627 r"""add_alias(ModelKey old_key, std::string new_name) -> ModelKey"""
2628 return _IMP_kernel.ModelKey_add_alias(old_key, new_name)
2631 def get_number_of_keys():
2632 r"""get_number_of_keys() -> unsigned int"""
2633 return _IMP_kernel.ModelKey_get_number_of_keys()
2636 r"""get_index(ModelKey self) -> unsigned int"""
2637 return _IMP_kernel.ModelKey_get_index(self)
2641 r"""show_all(_ostream out)"""
2642 return _IMP_kernel.ModelKey_show_all(out)
2645 def get_all_strings():
2646 r"""get_all_strings() -> IMP::Vector< std::string >"""
2647 return _IMP_kernel.ModelKey_get_all_strings()
2650 def get_number_unique():
2651 r"""get_number_unique() -> unsigned int"""
2652 return _IMP_kernel.ModelKey_get_number_unique()
2655 r"""__str__(ModelKey self) -> std::string"""
2656 return _IMP_kernel.ModelKey___str__(self)
2659 r"""__repr__(ModelKey self) -> std::string"""
2660 return _IMP_kernel.ModelKey___repr__(self)
2661 __swig_destroy__ = _IMP_kernel.delete_ModelKey
2664 _IMP_kernel.ModelKey_swigregister(ModelKey)
2666 r"""Proxy of C++ IMP::Key< 11 > class."""
2668 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2670 def __init__(self, *args):
2672 __init__(TriggerKey self) -> TriggerKey
2673 __init__(TriggerKey self, std::string const & c, bool is_implicit_add_permitted=True) -> TriggerKey
2674 __init__(TriggerKey self, unsigned int i) -> TriggerKey
2676 _IMP_kernel.TriggerKey_swiginit(self, _IMP_kernel.new_TriggerKey(*args))
2680 r"""add_key(std::string sc) -> unsigned int"""
2681 return _IMP_kernel.TriggerKey_add_key(sc)
2684 def get_key_exists(sc):
2685 r"""get_key_exists(std::string sc) -> bool"""
2686 return _IMP_kernel.TriggerKey_get_key_exists(sc)
2688 def get_string(self):
2689 r"""get_string(TriggerKey self) -> std::string const"""
2690 return _IMP_kernel.TriggerKey_get_string(self)
2692 def __cmp__(self, o):
2693 r"""__cmp__(TriggerKey self, TriggerKey o) -> int"""
2694 return _IMP_kernel.TriggerKey___cmp__(self, o)
2696 def __eq__(self, o):
2697 r"""__eq__(TriggerKey self, TriggerKey o) -> bool"""
2698 return _IMP_kernel.TriggerKey___eq__(self, o)
2700 def __ne__(self, o):
2701 r"""__ne__(TriggerKey self, TriggerKey o) -> bool"""
2702 return _IMP_kernel.TriggerKey___ne__(self, o)
2704 def __lt__(self, o):
2705 r"""__lt__(TriggerKey self, TriggerKey o) -> bool"""
2706 return _IMP_kernel.TriggerKey___lt__(self, o)
2708 def __gt__(self, o):
2709 r"""__gt__(TriggerKey self, TriggerKey o) -> bool"""
2710 return _IMP_kernel.TriggerKey___gt__(self, o)
2712 def __ge__(self, o):
2713 r"""__ge__(TriggerKey self, TriggerKey o) -> bool"""
2714 return _IMP_kernel.TriggerKey___ge__(self, o)
2716 def __le__(self, o):
2717 r"""__le__(TriggerKey self, TriggerKey o) -> bool"""
2718 return _IMP_kernel.TriggerKey___le__(self, o)
2721 r"""__hash__(TriggerKey self) -> std::size_t"""
2722 return _IMP_kernel.TriggerKey___hash__(self)
2724 def show(self, *args):
2725 r"""show(TriggerKey self, _ostream out=std::cout)"""
2726 return _IMP_kernel.TriggerKey_show(self, *args)
2729 def add_alias(old_key, new_name):
2730 r"""add_alias(TriggerKey old_key, std::string new_name) -> TriggerKey"""
2731 return _IMP_kernel.TriggerKey_add_alias(old_key, new_name)
2734 def get_number_of_keys():
2735 r"""get_number_of_keys() -> unsigned int"""
2736 return _IMP_kernel.TriggerKey_get_number_of_keys()
2739 r"""get_index(TriggerKey self) -> unsigned int"""
2740 return _IMP_kernel.TriggerKey_get_index(self)
2744 r"""show_all(_ostream out)"""
2745 return _IMP_kernel.TriggerKey_show_all(out)
2748 def get_all_strings():
2749 r"""get_all_strings() -> IMP::Vector< std::string >"""
2750 return _IMP_kernel.TriggerKey_get_all_strings()
2753 def get_number_unique():
2754 r"""get_number_unique() -> unsigned int"""
2755 return _IMP_kernel.TriggerKey_get_number_unique()
2758 r"""__str__(TriggerKey self) -> std::string"""
2759 return _IMP_kernel.TriggerKey___str__(self)
2762 r"""__repr__(TriggerKey self) -> std::string"""
2763 return _IMP_kernel.TriggerKey___repr__(self)
2764 __swig_destroy__ = _IMP_kernel.delete_TriggerKey
2767 _IMP_kernel.TriggerKey_swigregister(TriggerKey)
2769 r"""Proxy of C++ IMP::Index< IMP::ParticleIndexTag > class."""
2771 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2773 def __init__(self, *args):
2775 __init__(ParticleIndex self, int i) -> ParticleIndex
2776 __init__(ParticleIndex self) -> ParticleIndex
2778 _IMP_kernel.ParticleIndex_swiginit(self, _IMP_kernel.new_ParticleIndex(*args))
2781 r"""get_index(ParticleIndex self) -> int"""
2782 return _IMP_kernel.ParticleIndex_get_index(self)
2784 def __cmp__(self, o):
2785 r"""__cmp__(ParticleIndex self, ParticleIndex o) -> int"""
2786 return _IMP_kernel.ParticleIndex___cmp__(self, o)
2788 def __eq__(self, o):
2789 r"""__eq__(ParticleIndex self, ParticleIndex o) -> bool"""
2790 return _IMP_kernel.ParticleIndex___eq__(self, o)
2792 def __ne__(self, o):
2793 r"""__ne__(ParticleIndex self, ParticleIndex o) -> bool"""
2794 return _IMP_kernel.ParticleIndex___ne__(self, o)
2796 def __lt__(self, o):
2797 r"""__lt__(ParticleIndex self, ParticleIndex o) -> bool"""
2798 return _IMP_kernel.ParticleIndex___lt__(self, o)
2800 def __gt__(self, o):
2801 r"""__gt__(ParticleIndex self, ParticleIndex o) -> bool"""
2802 return _IMP_kernel.ParticleIndex___gt__(self, o)
2804 def __ge__(self, o):
2805 r"""__ge__(ParticleIndex self, ParticleIndex o) -> bool"""
2806 return _IMP_kernel.ParticleIndex___ge__(self, o)
2808 def __le__(self, o):
2809 r"""__le__(ParticleIndex self, ParticleIndex o) -> bool"""
2810 return _IMP_kernel.ParticleIndex___le__(self, o)
2812 def show(self, *args):
2813 r"""show(ParticleIndex self, _ostream out=std::cout)"""
2814 return _IMP_kernel.ParticleIndex_show(self, *args)
2817 r"""__hash__(ParticleIndex self) -> std::size_t"""
2818 return _IMP_kernel.ParticleIndex___hash__(self)
2821 r"""__str__(ParticleIndex self) -> std::string"""
2822 return _IMP_kernel.ParticleIndex___str__(self)
2825 r"""__repr__(ParticleIndex self) -> std::string"""
2826 return _IMP_kernel.ParticleIndex___repr__(self)
2827 __swig_destroy__ = _IMP_kernel.delete_ParticleIndex
2830 _IMP_kernel.ParticleIndex_swigregister(ParticleIndex)
2832 r"""Proxy of C++ IMP::Key< 10 > class."""
2834 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2836 def __init__(self, *args):
2838 __init__(FloatsKey self) -> FloatsKey
2839 __init__(FloatsKey self, std::string const & c, bool is_implicit_add_permitted=True) -> FloatsKey
2840 __init__(FloatsKey self, unsigned int i) -> FloatsKey
2842 _IMP_kernel.FloatsKey_swiginit(self, _IMP_kernel.new_FloatsKey(*args))
2846 r"""add_key(std::string sc) -> unsigned int"""
2847 return _IMP_kernel.FloatsKey_add_key(sc)
2850 def get_key_exists(sc):
2851 r"""get_key_exists(std::string sc) -> bool"""
2852 return _IMP_kernel.FloatsKey_get_key_exists(sc)
2854 def get_string(self):
2855 r"""get_string(FloatsKey self) -> std::string const"""
2856 return _IMP_kernel.FloatsKey_get_string(self)
2858 def __cmp__(self, o):
2859 r"""__cmp__(FloatsKey self, FloatsKey o) -> int"""
2860 return _IMP_kernel.FloatsKey___cmp__(self, o)
2862 def __eq__(self, o):
2863 r"""__eq__(FloatsKey self, FloatsKey o) -> bool"""
2864 return _IMP_kernel.FloatsKey___eq__(self, o)
2866 def __ne__(self, o):
2867 r"""__ne__(FloatsKey self, FloatsKey o) -> bool"""
2868 return _IMP_kernel.FloatsKey___ne__(self, o)
2870 def __lt__(self, o):
2871 r"""__lt__(FloatsKey self, FloatsKey o) -> bool"""
2872 return _IMP_kernel.FloatsKey___lt__(self, o)
2874 def __gt__(self, o):
2875 r"""__gt__(FloatsKey self, FloatsKey o) -> bool"""
2876 return _IMP_kernel.FloatsKey___gt__(self, o)
2878 def __ge__(self, o):
2879 r"""__ge__(FloatsKey self, FloatsKey o) -> bool"""
2880 return _IMP_kernel.FloatsKey___ge__(self, o)
2882 def __le__(self, o):
2883 r"""__le__(FloatsKey self, FloatsKey o) -> bool"""
2884 return _IMP_kernel.FloatsKey___le__(self, o)
2887 r"""__hash__(FloatsKey self) -> std::size_t"""
2888 return _IMP_kernel.FloatsKey___hash__(self)
2890 def show(self, *args):
2891 r"""show(FloatsKey self, _ostream out=std::cout)"""
2892 return _IMP_kernel.FloatsKey_show(self, *args)
2895 def add_alias(old_key, new_name):
2896 r"""add_alias(FloatsKey old_key, std::string new_name) -> FloatsKey"""
2897 return _IMP_kernel.FloatsKey_add_alias(old_key, new_name)
2900 def get_number_of_keys():
2901 r"""get_number_of_keys() -> unsigned int"""
2902 return _IMP_kernel.FloatsKey_get_number_of_keys()
2905 r"""get_index(FloatsKey self) -> unsigned int"""
2906 return _IMP_kernel.FloatsKey_get_index(self)
2910 r"""show_all(_ostream out)"""
2911 return _IMP_kernel.FloatsKey_show_all(out)
2914 def get_all_strings():
2915 r"""get_all_strings() -> IMP::Vector< std::string >"""
2916 return _IMP_kernel.FloatsKey_get_all_strings()
2919 def get_number_unique():
2920 r"""get_number_unique() -> unsigned int"""
2921 return _IMP_kernel.FloatsKey_get_number_unique()
2924 r"""__str__(FloatsKey self) -> std::string"""
2925 return _IMP_kernel.FloatsKey___str__(self)
2928 r"""__repr__(FloatsKey self) -> std::string"""
2929 return _IMP_kernel.FloatsKey___repr__(self)
2930 __swig_destroy__ = _IMP_kernel.delete_FloatsKey
2933 _IMP_kernel.FloatsKey_swigregister(FloatsKey)
2935 r"""Proxy of C++ IMP::Key< 12 > class."""
2937 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2939 def __init__(self, *args):
2941 __init__(SparseStringKey self) -> SparseStringKey
2942 __init__(SparseStringKey self, std::string const & c, bool is_implicit_add_permitted=True) -> SparseStringKey
2943 __init__(SparseStringKey self, unsigned int i) -> SparseStringKey
2945 _IMP_kernel.SparseStringKey_swiginit(self, _IMP_kernel.new_SparseStringKey(*args))
2949 r"""add_key(std::string sc) -> unsigned int"""
2950 return _IMP_kernel.SparseStringKey_add_key(sc)
2953 def get_key_exists(sc):
2954 r"""get_key_exists(std::string sc) -> bool"""
2955 return _IMP_kernel.SparseStringKey_get_key_exists(sc)
2957 def get_string(self):
2958 r"""get_string(SparseStringKey self) -> std::string const"""
2959 return _IMP_kernel.SparseStringKey_get_string(self)
2961 def __cmp__(self, o):
2962 r"""__cmp__(SparseStringKey self, SparseStringKey o) -> int"""
2963 return _IMP_kernel.SparseStringKey___cmp__(self, o)
2965 def __eq__(self, o):
2966 r"""__eq__(SparseStringKey self, SparseStringKey o) -> bool"""
2967 return _IMP_kernel.SparseStringKey___eq__(self, o)
2969 def __ne__(self, o):
2970 r"""__ne__(SparseStringKey self, SparseStringKey o) -> bool"""
2971 return _IMP_kernel.SparseStringKey___ne__(self, o)
2973 def __lt__(self, o):
2974 r"""__lt__(SparseStringKey self, SparseStringKey o) -> bool"""
2975 return _IMP_kernel.SparseStringKey___lt__(self, o)
2977 def __gt__(self, o):
2978 r"""__gt__(SparseStringKey self, SparseStringKey o) -> bool"""
2979 return _IMP_kernel.SparseStringKey___gt__(self, o)
2981 def __ge__(self, o):
2982 r"""__ge__(SparseStringKey self, SparseStringKey o) -> bool"""
2983 return _IMP_kernel.SparseStringKey___ge__(self, o)
2985 def __le__(self, o):
2986 r"""__le__(SparseStringKey self, SparseStringKey o) -> bool"""
2987 return _IMP_kernel.SparseStringKey___le__(self, o)
2990 r"""__hash__(SparseStringKey self) -> std::size_t"""
2991 return _IMP_kernel.SparseStringKey___hash__(self)
2993 def show(self, *args):
2994 r"""show(SparseStringKey self, _ostream out=std::cout)"""
2995 return _IMP_kernel.SparseStringKey_show(self, *args)
2998 def add_alias(old_key, new_name):
2999 r"""add_alias(SparseStringKey old_key, std::string new_name) -> SparseStringKey"""
3000 return _IMP_kernel.SparseStringKey_add_alias(old_key, new_name)
3003 def get_number_of_keys():
3004 r"""get_number_of_keys() -> unsigned int"""
3005 return _IMP_kernel.SparseStringKey_get_number_of_keys()
3008 r"""get_index(SparseStringKey self) -> unsigned int"""
3009 return _IMP_kernel.SparseStringKey_get_index(self)
3013 r"""show_all(_ostream out)"""
3014 return _IMP_kernel.SparseStringKey_show_all(out)
3017 def get_all_strings():
3018 r"""get_all_strings() -> IMP::Vector< std::string >"""
3019 return _IMP_kernel.SparseStringKey_get_all_strings()
3022 def get_number_unique():
3023 r"""get_number_unique() -> unsigned int"""
3024 return _IMP_kernel.SparseStringKey_get_number_unique()
3027 r"""__str__(SparseStringKey self) -> std::string"""
3028 return _IMP_kernel.SparseStringKey___str__(self)
3031 r"""__repr__(SparseStringKey self) -> std::string"""
3032 return _IMP_kernel.SparseStringKey___repr__(self)
3033 __swig_destroy__ = _IMP_kernel.delete_SparseStringKey
3036 _IMP_kernel.SparseStringKey_swigregister(SparseStringKey)
3038 r"""Proxy of C++ IMP::Key< 13 > class."""
3040 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3042 def __init__(self, *args):
3044 __init__(SparseIntKey self) -> SparseIntKey
3045 __init__(SparseIntKey self, std::string const & c, bool is_implicit_add_permitted=True) -> SparseIntKey
3046 __init__(SparseIntKey self, unsigned int i) -> SparseIntKey
3048 _IMP_kernel.SparseIntKey_swiginit(self, _IMP_kernel.new_SparseIntKey(*args))
3052 r"""add_key(std::string sc) -> unsigned int"""
3053 return _IMP_kernel.SparseIntKey_add_key(sc)
3056 def get_key_exists(sc):
3057 r"""get_key_exists(std::string sc) -> bool"""
3058 return _IMP_kernel.SparseIntKey_get_key_exists(sc)
3060 def get_string(self):
3061 r"""get_string(SparseIntKey self) -> std::string const"""
3062 return _IMP_kernel.SparseIntKey_get_string(self)
3064 def __cmp__(self, o):
3065 r"""__cmp__(SparseIntKey self, SparseIntKey o) -> int"""
3066 return _IMP_kernel.SparseIntKey___cmp__(self, o)
3068 def __eq__(self, o):
3069 r"""__eq__(SparseIntKey self, SparseIntKey o) -> bool"""
3070 return _IMP_kernel.SparseIntKey___eq__(self, o)
3072 def __ne__(self, o):
3073 r"""__ne__(SparseIntKey self, SparseIntKey o) -> bool"""
3074 return _IMP_kernel.SparseIntKey___ne__(self, o)
3076 def __lt__(self, o):
3077 r"""__lt__(SparseIntKey self, SparseIntKey o) -> bool"""
3078 return _IMP_kernel.SparseIntKey___lt__(self, o)
3080 def __gt__(self, o):
3081 r"""__gt__(SparseIntKey self, SparseIntKey o) -> bool"""
3082 return _IMP_kernel.SparseIntKey___gt__(self, o)
3084 def __ge__(self, o):
3085 r"""__ge__(SparseIntKey self, SparseIntKey o) -> bool"""
3086 return _IMP_kernel.SparseIntKey___ge__(self, o)
3088 def __le__(self, o):
3089 r"""__le__(SparseIntKey self, SparseIntKey o) -> bool"""
3090 return _IMP_kernel.SparseIntKey___le__(self, o)
3093 r"""__hash__(SparseIntKey self) -> std::size_t"""
3094 return _IMP_kernel.SparseIntKey___hash__(self)
3096 def show(self, *args):
3097 r"""show(SparseIntKey self, _ostream out=std::cout)"""
3098 return _IMP_kernel.SparseIntKey_show(self, *args)
3101 def add_alias(old_key, new_name):
3102 r"""add_alias(SparseIntKey old_key, std::string new_name) -> SparseIntKey"""
3103 return _IMP_kernel.SparseIntKey_add_alias(old_key, new_name)
3106 def get_number_of_keys():
3107 r"""get_number_of_keys() -> unsigned int"""
3108 return _IMP_kernel.SparseIntKey_get_number_of_keys()
3111 r"""get_index(SparseIntKey self) -> unsigned int"""
3112 return _IMP_kernel.SparseIntKey_get_index(self)
3116 r"""show_all(_ostream out)"""
3117 return _IMP_kernel.SparseIntKey_show_all(out)
3120 def get_all_strings():
3121 r"""get_all_strings() -> IMP::Vector< std::string >"""
3122 return _IMP_kernel.SparseIntKey_get_all_strings()
3125 def get_number_unique():
3126 r"""get_number_unique() -> unsigned int"""
3127 return _IMP_kernel.SparseIntKey_get_number_unique()
3130 r"""__str__(SparseIntKey self) -> std::string"""
3131 return _IMP_kernel.SparseIntKey___str__(self)
3134 r"""__repr__(SparseIntKey self) -> std::string"""
3135 return _IMP_kernel.SparseIntKey___repr__(self)
3136 __swig_destroy__ = _IMP_kernel.delete_SparseIntKey
3139 _IMP_kernel.SparseIntKey_swigregister(SparseIntKey)
3141 r"""Proxy of C++ IMP::Key< 14 > class."""
3143 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3145 def __init__(self, *args):
3147 __init__(SparseFloatKey self) -> SparseFloatKey
3148 __init__(SparseFloatKey self, std::string const & c, bool is_implicit_add_permitted=True) -> SparseFloatKey
3149 __init__(SparseFloatKey self, unsigned int i) -> SparseFloatKey
3151 _IMP_kernel.SparseFloatKey_swiginit(self, _IMP_kernel.new_SparseFloatKey(*args))
3155 r"""add_key(std::string sc) -> unsigned int"""
3156 return _IMP_kernel.SparseFloatKey_add_key(sc)
3159 def get_key_exists(sc):
3160 r"""get_key_exists(std::string sc) -> bool"""
3161 return _IMP_kernel.SparseFloatKey_get_key_exists(sc)
3163 def get_string(self):
3164 r"""get_string(SparseFloatKey self) -> std::string const"""
3165 return _IMP_kernel.SparseFloatKey_get_string(self)
3167 def __cmp__(self, o):
3168 r"""__cmp__(SparseFloatKey self, SparseFloatKey o) -> int"""
3169 return _IMP_kernel.SparseFloatKey___cmp__(self, o)
3171 def __eq__(self, o):
3172 r"""__eq__(SparseFloatKey self, SparseFloatKey o) -> bool"""
3173 return _IMP_kernel.SparseFloatKey___eq__(self, o)
3175 def __ne__(self, o):
3176 r"""__ne__(SparseFloatKey self, SparseFloatKey o) -> bool"""
3177 return _IMP_kernel.SparseFloatKey___ne__(self, o)
3179 def __lt__(self, o):
3180 r"""__lt__(SparseFloatKey self, SparseFloatKey o) -> bool"""
3181 return _IMP_kernel.SparseFloatKey___lt__(self, o)
3183 def __gt__(self, o):
3184 r"""__gt__(SparseFloatKey self, SparseFloatKey o) -> bool"""
3185 return _IMP_kernel.SparseFloatKey___gt__(self, o)
3187 def __ge__(self, o):
3188 r"""__ge__(SparseFloatKey self, SparseFloatKey o) -> bool"""
3189 return _IMP_kernel.SparseFloatKey___ge__(self, o)
3191 def __le__(self, o):
3192 r"""__le__(SparseFloatKey self, SparseFloatKey o) -> bool"""
3193 return _IMP_kernel.SparseFloatKey___le__(self, o)
3196 r"""__hash__(SparseFloatKey self) -> std::size_t"""
3197 return _IMP_kernel.SparseFloatKey___hash__(self)
3199 def show(self, *args):
3200 r"""show(SparseFloatKey self, _ostream out=std::cout)"""
3201 return _IMP_kernel.SparseFloatKey_show(self, *args)
3204 def add_alias(old_key, new_name):
3205 r"""add_alias(SparseFloatKey old_key, std::string new_name) -> SparseFloatKey"""
3206 return _IMP_kernel.SparseFloatKey_add_alias(old_key, new_name)
3209 def get_number_of_keys():
3210 r"""get_number_of_keys() -> unsigned int"""
3211 return _IMP_kernel.SparseFloatKey_get_number_of_keys()
3214 r"""get_index(SparseFloatKey self) -> unsigned int"""
3215 return _IMP_kernel.SparseFloatKey_get_index(self)
3219 r"""show_all(_ostream out)"""
3220 return _IMP_kernel.SparseFloatKey_show_all(out)
3223 def get_all_strings():
3224 r"""get_all_strings() -> IMP::Vector< std::string >"""
3225 return _IMP_kernel.SparseFloatKey_get_all_strings()
3228 def get_number_unique():
3229 r"""get_number_unique() -> unsigned int"""
3230 return _IMP_kernel.SparseFloatKey_get_number_unique()
3233 r"""__str__(SparseFloatKey self) -> std::string"""
3234 return _IMP_kernel.SparseFloatKey___str__(self)
3237 r"""__repr__(SparseFloatKey self) -> std::string"""
3238 return _IMP_kernel.SparseFloatKey___repr__(self)
3239 __swig_destroy__ = _IMP_kernel.delete_SparseFloatKey
3242 _IMP_kernel.SparseFloatKey_swigregister(SparseFloatKey)
3244 r"""Proxy of C++ IMP::Key< 15 > class."""
3246 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3248 def __init__(self, *args):
3250 __init__(SparseParticleIndexKey self) -> SparseParticleIndexKey
3251 __init__(SparseParticleIndexKey self, std::string const & c, bool is_implicit_add_permitted=True) -> SparseParticleIndexKey
3252 __init__(SparseParticleIndexKey self, unsigned int i) -> SparseParticleIndexKey
3254 _IMP_kernel.SparseParticleIndexKey_swiginit(self, _IMP_kernel.new_SparseParticleIndexKey(*args))
3258 r"""add_key(std::string sc) -> unsigned int"""
3259 return _IMP_kernel.SparseParticleIndexKey_add_key(sc)
3262 def get_key_exists(sc):
3263 r"""get_key_exists(std::string sc) -> bool"""
3264 return _IMP_kernel.SparseParticleIndexKey_get_key_exists(sc)
3266 def get_string(self):
3267 r"""get_string(SparseParticleIndexKey self) -> std::string const"""
3268 return _IMP_kernel.SparseParticleIndexKey_get_string(self)
3270 def __cmp__(self, o):
3271 r"""__cmp__(SparseParticleIndexKey self, SparseParticleIndexKey o) -> int"""
3272 return _IMP_kernel.SparseParticleIndexKey___cmp__(self, o)
3274 def __eq__(self, o):
3275 r"""__eq__(SparseParticleIndexKey self, SparseParticleIndexKey o) -> bool"""
3276 return _IMP_kernel.SparseParticleIndexKey___eq__(self, o)
3278 def __ne__(self, o):
3279 r"""__ne__(SparseParticleIndexKey self, SparseParticleIndexKey o) -> bool"""
3280 return _IMP_kernel.SparseParticleIndexKey___ne__(self, o)
3282 def __lt__(self, o):
3283 r"""__lt__(SparseParticleIndexKey self, SparseParticleIndexKey o) -> bool"""
3284 return _IMP_kernel.SparseParticleIndexKey___lt__(self, o)
3286 def __gt__(self, o):
3287 r"""__gt__(SparseParticleIndexKey self, SparseParticleIndexKey o) -> bool"""
3288 return _IMP_kernel.SparseParticleIndexKey___gt__(self, o)
3290 def __ge__(self, o):
3291 r"""__ge__(SparseParticleIndexKey self, SparseParticleIndexKey o) -> bool"""
3292 return _IMP_kernel.SparseParticleIndexKey___ge__(self, o)
3294 def __le__(self, o):
3295 r"""__le__(SparseParticleIndexKey self, SparseParticleIndexKey o) -> bool"""
3296 return _IMP_kernel.SparseParticleIndexKey___le__(self, o)
3299 r"""__hash__(SparseParticleIndexKey self) -> std::size_t"""
3300 return _IMP_kernel.SparseParticleIndexKey___hash__(self)
3302 def show(self, *args):
3303 r"""show(SparseParticleIndexKey self, _ostream out=std::cout)"""
3304 return _IMP_kernel.SparseParticleIndexKey_show(self, *args)
3307 def add_alias(old_key, new_name):
3308 r"""add_alias(SparseParticleIndexKey old_key, std::string new_name) -> SparseParticleIndexKey"""
3309 return _IMP_kernel.SparseParticleIndexKey_add_alias(old_key, new_name)
3312 def get_number_of_keys():
3313 r"""get_number_of_keys() -> unsigned int"""
3314 return _IMP_kernel.SparseParticleIndexKey_get_number_of_keys()
3317 r"""get_index(SparseParticleIndexKey self) -> unsigned int"""
3318 return _IMP_kernel.SparseParticleIndexKey_get_index(self)
3322 r"""show_all(_ostream out)"""
3323 return _IMP_kernel.SparseParticleIndexKey_show_all(out)
3326 def get_all_strings():
3327 r"""get_all_strings() -> IMP::Vector< std::string >"""
3328 return _IMP_kernel.SparseParticleIndexKey_get_all_strings()
3331 def get_number_unique():
3332 r"""get_number_unique() -> unsigned int"""
3333 return _IMP_kernel.SparseParticleIndexKey_get_number_unique()
3336 r"""__str__(SparseParticleIndexKey self) -> std::string"""
3337 return _IMP_kernel.SparseParticleIndexKey___str__(self)
3340 r"""__repr__(SparseParticleIndexKey self) -> std::string"""
3341 return _IMP_kernel.SparseParticleIndexKey___repr__(self)
3342 __swig_destroy__ = _IMP_kernel.delete_SparseParticleIndexKey
3345 _IMP_kernel.SparseParticleIndexKey_swigregister(SparseParticleIndexKey)
3355 r"""Proxy of C++ IMP::FloatIndex class."""
3357 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3359 def __init__(self, *args):
3360 r"""__init__(FloatIndex self, ParticleIndex i0=ParticleIndex(), FloatKey i1=FloatKey()) -> FloatIndex"""
3361 _IMP_kernel.FloatIndex_swiginit(self, _IMP_kernel.new_FloatIndex(*args))
3364 r"""__hash__(FloatIndex self) -> std::size_t"""
3365 return _IMP_kernel.FloatIndex___hash__(self)
3367 def show(self, *args):
3368 r"""show(FloatIndex self, _ostream out=std::cout)"""
3369 return _IMP_kernel.FloatIndex_show(self, *args)
3371 def __cmp__(self, o):
3372 r"""__cmp__(FloatIndex self, FloatIndex o) -> int"""
3373 return _IMP_kernel.FloatIndex___cmp__(self, o)
3375 def __eq__(self, o):
3376 r"""__eq__(FloatIndex self, FloatIndex o) -> bool"""
3377 return _IMP_kernel.FloatIndex___eq__(self, o)
3379 def __ne__(self, o):
3380 r"""__ne__(FloatIndex self, FloatIndex o) -> bool"""
3381 return _IMP_kernel.FloatIndex___ne__(self, o)
3383 def __lt__(self, o):
3384 r"""__lt__(FloatIndex self, FloatIndex o) -> bool"""
3385 return _IMP_kernel.FloatIndex___lt__(self, o)
3387 def __gt__(self, o):
3388 r"""__gt__(FloatIndex self, FloatIndex o) -> bool"""
3389 return _IMP_kernel.FloatIndex___gt__(self, o)
3391 def __ge__(self, o):
3392 r"""__ge__(FloatIndex self, FloatIndex o) -> bool"""
3393 return _IMP_kernel.FloatIndex___ge__(self, o)
3395 def __le__(self, o):
3396 r"""__le__(FloatIndex self, FloatIndex o) -> bool"""
3397 return _IMP_kernel.FloatIndex___le__(self, o)
3399 def get_particle(self):
3400 r"""get_particle(FloatIndex self) -> ParticleIndex const &"""
3401 return _IMP_kernel.FloatIndex_get_particle(self)
3403 def set_particle(self, v):
3404 r"""set_particle(FloatIndex self, ParticleIndex const & v)"""
3405 return _IMP_kernel.FloatIndex_set_particle(self, v)
3408 r"""get_key(FloatIndex self) -> FloatKey const &"""
3409 return _IMP_kernel.FloatIndex_get_key(self)
3411 def set_key(self, v):
3412 r"""set_key(FloatIndex self, FloatKey const & v)"""
3413 return _IMP_kernel.FloatIndex_set_key(self, v)
3416 r"""__str__(FloatIndex self) -> std::string"""
3417 return _IMP_kernel.FloatIndex___str__(self)
3420 r"""__repr__(FloatIndex self) -> std::string"""
3421 return _IMP_kernel.FloatIndex___repr__(self)
3422 __swig_destroy__ = _IMP_kernel.delete_FloatIndex
3425 _IMP_kernel.FloatIndex_swigregister(FloatIndex)
3426 class _ParticleIndexTag(object):
3427 r"""Proxy of C++ IMP::ParticleIndexTag class."""
3429 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3430 __repr__ = _swig_repr
3433 r"""__init__(_ParticleIndexTag self) -> _ParticleIndexTag"""
3434 _IMP_kernel._ParticleIndexTag_swiginit(self, _IMP_kernel.new__ParticleIndexTag())
3435 __swig_destroy__ = _IMP_kernel.delete__ParticleIndexTag
3438 _IMP_kernel._ParticleIndexTag_swigregister(_ParticleIndexTag)
3440 r"""Proxy of C++ IMP::ModelObject class."""
3442 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3444 def __init__(self, *args):
3446 __init__(ModelObject self, Model m, std::string name) -> ModelObject
3447 __init__(ModelObject self) -> ModelObject
3449 if self.__class__ == ModelObject:
3453 _IMP_kernel.ModelObject_swiginit(self, _IMP_kernel.new_ModelObject(_self, *args))
3455 if self.__class__ != ModelObject:
3456 _director_objects.register(self)
3460 __swig_destroy__ = _IMP_kernel.delete_ModelObject
3462 def get_model(self):
3463 m = _IMP_kernel.ModelObject_get_model(self)
3464 if m
in _models_set:
3465 m = _models_set_get(m)
3470 def get_inputs(self):
3471 r"""get_inputs(ModelObject self) -> IMP::ModelObjectsTemp"""
3472 return _IMP_kernel.ModelObject_get_inputs(self)
3474 def get_outputs(self):
3475 r"""get_outputs(ModelObject self) -> IMP::ModelObjectsTemp"""
3476 return _IMP_kernel.ModelObject_get_outputs(self)
3478 def get_interactions(self):
3479 r"""get_interactions(ModelObject self) -> IMP::ModelObjectsTemps"""
3480 return _IMP_kernel.ModelObject_get_interactions(self)
3482 def get_has_dependencies(self):
3483 r"""get_has_dependencies(ModelObject self) -> bool"""
3484 return _IMP_kernel.ModelObject_get_has_dependencies(self)
3486 def set_has_dependencies(self, tf):
3487 r"""set_has_dependencies(ModelObject self, bool tf)"""
3488 return _IMP_kernel.ModelObject_set_has_dependencies(self, tf)
3490 def set_has_required_score_states(self, tf):
3491 r"""set_has_required_score_states(ModelObject self, bool tf)"""
3492 return _IMP_kernel.ModelObject_set_has_required_score_states(self, tf)
3494 def get_has_required_score_states(self):
3495 r"""get_has_required_score_states(ModelObject self) -> bool"""
3496 return _IMP_kernel.ModelObject_get_has_required_score_states(self)
3498 def get_required_score_states(self):
3499 r"""get_required_score_states(ModelObject self) -> IMP::ScoreStatesTemp const &"""
3500 return _IMP_kernel.ModelObject_get_required_score_states(self)
3502 def handle_set_has_required_score_states(self, arg0):
3503 r"""handle_set_has_required_score_states(ModelObject self, bool arg0)"""
3504 return _IMP_kernel.ModelObject_handle_set_has_required_score_states(self, arg0)
3506 def do_get_inputs(self):
3507 r"""do_get_inputs(ModelObject self) -> IMP::ModelObjectsTemp"""
3508 return _IMP_kernel.ModelObject_do_get_inputs(self)
3510 def do_get_outputs(self):
3511 r"""do_get_outputs(ModelObject self) -> IMP::ModelObjectsTemp"""
3512 return _IMP_kernel.ModelObject_do_get_outputs(self)
3514 def do_get_interactions(self):
3515 r"""do_get_interactions(ModelObject self) -> IMP::ModelObjectsTemps"""
3516 return _IMP_kernel.ModelObject_do_get_interactions(self)
3519 r"""__str__(ModelObject self) -> std::string"""
3520 return _IMP_kernel.ModelObject___str__(self)
3523 r"""__repr__(ModelObject self) -> std::string"""
3524 return _IMP_kernel.ModelObject___repr__(self)
3528 return _object_cast_to_ModelObject(o)
3531 def do_show(self, out):
3536 return _object_cast_to_ModelObject(o)
3538 def __disown__(self):
3540 _IMP_kernel.disown_ModelObject(self)
3541 return weakref.proxy(self)
3544 r"""do_destroy(ModelObject self)"""
3545 return _IMP_kernel.ModelObject_do_destroy(self)
3548 _IMP_kernel.ModelObject_swigregister(ModelObject)
3549 cvar = _IMP_kernel.cvar
3550 NO_MAX = cvar.NO_MAX
3551 BAD_SCORE = cvar.BAD_SCORE
3553 class _ParticleInputs(object):
3554 r"""Proxy of C++ IMP::ParticleInputs class."""
3556 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3558 def __init__(self, *args, **kwargs):
3559 raise AttributeError(
"No constructor defined - class is abstract")
3560 __repr__ = _swig_repr
3562 def get_inputs(self, m, pis):
3563 r"""get_inputs(_ParticleInputs self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
3564 return _IMP_kernel._ParticleInputs_get_inputs(self, m, pis)
3567 _IMP_kernel._ParticleInputs_swigregister(_ParticleInputs)
3568 class _ParticleOutputs(object):
3569 r"""Proxy of C++ IMP::ParticleOutputs class."""
3571 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3573 def __init__(self, *args, **kwargs):
3574 raise AttributeError(
"No constructor defined - class is abstract")
3575 __repr__ = _swig_repr
3577 def get_outputs(self, m, pis):
3578 r"""get_outputs(_ParticleOutputs self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
3579 return _IMP_kernel._ParticleOutputs_get_outputs(self, m, pis)
3582 _IMP_kernel._ParticleOutputs_swigregister(_ParticleOutputs)
3585 r"""get_input_particles(IMP::ModelObjectsTemp const & mos) -> IMP::ParticlesTemp"""
3586 return _IMP_kernel.get_input_particles(mos)
3589 r"""get_input_containers(IMP::ModelObjectsTemp const & mos) -> IMP::ContainersTemp"""
3590 return _IMP_kernel.get_input_containers(mos)
3593 r"""get_output_particles(IMP::ModelObjectsTemp const & mos) -> IMP::ParticlesTemp"""
3594 return _IMP_kernel.get_output_particles(mos)
3597 r"""get_output_containers(IMP::ModelObjectsTemp const & mos) -> IMP::ContainersTemp"""
3598 return _IMP_kernel.get_output_containers(mos)
3600 r"""Proxy of C++ IMP::DerivativeAccumulator class."""
3602 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3603 __repr__ = _swig_repr
3605 def __init__(self, *args):
3607 __init__(DerivativeAccumulator self, DerivativeAccumulator arg2) -> DerivativeAccumulator
3608 __init__(DerivativeAccumulator self, double weight=1.0) -> DerivativeAccumulator
3609 __init__(DerivativeAccumulator self, DerivativeAccumulator copy, double weight) -> DerivativeAccumulator
3611 _IMP_kernel.DerivativeAccumulator_swiginit(self, _IMP_kernel.new_DerivativeAccumulator(*args))
3613 def __call__(self, value):
3614 r"""__call__(DerivativeAccumulator self, double const value) -> double"""
3615 return _IMP_kernel.DerivativeAccumulator___call__(self, value)
3617 def get_weight(self):
3618 r"""get_weight(DerivativeAccumulator self) -> double"""
3619 return _IMP_kernel.DerivativeAccumulator_get_weight(self)
3621 def show(self, *args):
3622 r"""show(DerivativeAccumulator self, _ostream out=std::cout)"""
3623 return _IMP_kernel.DerivativeAccumulator_show(self, *args)
3624 __swig_destroy__ = _IMP_kernel.delete_DerivativeAccumulator
3627 _IMP_kernel.DerivativeAccumulator_swigregister(DerivativeAccumulator)
3629 r"""Proxy of C++ IMP::EvaluationState class."""
3631 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3632 score = property(_IMP_kernel.EvaluationState_score_get, _IMP_kernel.EvaluationState_score_set, doc=
r"""score : double""")
3633 good = property(_IMP_kernel.EvaluationState_good_get, _IMP_kernel.EvaluationState_good_set, doc=
r"""good : bool""")
3635 def __init__(self, *args):
3637 __init__(EvaluationState self, double oscore, bool ogood) -> EvaluationState
3638 __init__(EvaluationState self) -> EvaluationState
3640 _IMP_kernel.EvaluationState_swiginit(self, _IMP_kernel.new_EvaluationState(*args))
3642 def show(self, *args):
3643 r"""show(EvaluationState self, _ostream out=std::cout)"""
3644 return _IMP_kernel.EvaluationState_show(self, *args)
3647 r"""__str__(EvaluationState self) -> std::string"""
3648 return _IMP_kernel.EvaluationState___str__(self)
3651 r"""__repr__(EvaluationState self) -> std::string"""
3652 return _IMP_kernel.EvaluationState___repr__(self)
3653 __swig_destroy__ = _IMP_kernel.delete_EvaluationState
3656 _IMP_kernel.EvaluationState_swigregister(EvaluationState)
3658 r"""Proxy of C++ IMP::ScoreAccumulator class."""
3660 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3662 def __init__(self, *args):
3664 __init__(ScoreAccumulator self, ScoreAccumulator arg2) -> ScoreAccumulator
3665 __init__(ScoreAccumulator self) -> ScoreAccumulator
3666 __init__(ScoreAccumulator self, ScoreAccumulator o, Restraint r) -> ScoreAccumulator
3667 __init__(ScoreAccumulator self, ScoreAccumulator o, double weight, double local_max) -> ScoreAccumulator
3669 _IMP_kernel.ScoreAccumulator_swiginit(self, _IMP_kernel.new_ScoreAccumulator(*args))
3671 def add_score(self, score):
3672 r"""add_score(ScoreAccumulator self, double score)"""
3673 return _IMP_kernel.ScoreAccumulator_add_score(self, score)
3675 def get_abort_evaluation(self):
3676 r"""get_abort_evaluation(ScoreAccumulator self) -> bool"""
3677 return _IMP_kernel.ScoreAccumulator_get_abort_evaluation(self)
3679 def get_is_evaluate_if_below(self):
3680 r"""get_is_evaluate_if_below(ScoreAccumulator self) -> bool"""
3681 return _IMP_kernel.ScoreAccumulator_get_is_evaluate_if_below(self)
3683 def get_is_evaluate_if_good(self):
3684 r"""get_is_evaluate_if_good(ScoreAccumulator self) -> bool"""
3685 return _IMP_kernel.ScoreAccumulator_get_is_evaluate_if_good(self)
3687 def get_maximum(self):
3688 r"""get_maximum(ScoreAccumulator self) -> double"""
3689 return _IMP_kernel.ScoreAccumulator_get_maximum(self)
3691 def get_derivative_accumulator(self):
3692 r"""get_derivative_accumulator(ScoreAccumulator self) -> DerivativeAccumulator"""
3693 return _IMP_kernel.ScoreAccumulator_get_derivative_accumulator(self)
3695 def show(self, *args):
3696 r"""show(ScoreAccumulator self, _ostream out=std::cout)"""
3697 return _IMP_kernel.ScoreAccumulator_show(self, *args)
3700 r"""__str__(ScoreAccumulator self) -> std::string"""
3701 return _IMP_kernel.ScoreAccumulator___str__(self)
3704 r"""__repr__(ScoreAccumulator self) -> std::string"""
3705 return _IMP_kernel.ScoreAccumulator___repr__(self)
3706 __swig_destroy__ = _IMP_kernel.delete_ScoreAccumulator
3709 _IMP_kernel.ScoreAccumulator_swigregister(ScoreAccumulator)
3711 r"""Proxy of C++ IMP::ScoreState class."""
3713 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3715 def set_can_skip(self, can_skip):
3716 r"""set_can_skip(ScoreState self, bool can_skip)"""
3717 return _IMP_kernel.ScoreState_set_can_skip(self, can_skip)
3719 def __init__(self, *args):
3721 __init__(ScoreState self, Model m, std::string name) -> ScoreState
3722 __init__(ScoreState self) -> ScoreState
3724 if self.__class__ == ScoreState:
3728 _IMP_kernel.ScoreState_swiginit(self, _IMP_kernel.new_ScoreState(_self, *args))
3730 if self.__class__ != ScoreState:
3731 _director_objects.register(self)
3736 def before_evaluate(self):
3737 r"""before_evaluate(ScoreState self)"""
3738 return _IMP_kernel.ScoreState_before_evaluate(self)
3740 def after_evaluate(self, accpt):
3741 r"""after_evaluate(ScoreState self, DerivativeAccumulator accpt)"""
3742 return _IMP_kernel.ScoreState_after_evaluate(self, accpt)
3744 def get_can_skip(self):
3745 r"""get_can_skip(ScoreState self) -> bool"""
3746 return _IMP_kernel.ScoreState_get_can_skip(self)
3748 def get_has_update_order(self):
3749 r"""get_has_update_order(ScoreState self) -> bool"""
3750 return _IMP_kernel.ScoreState_get_has_update_order(self)
3753 r"""get_update_order(ScoreState self) -> unsigned int"""
3754 return _IMP_kernel.ScoreState_get_update_order(self)
3756 def handle_set_has_required_score_states(self, tf):
3757 r"""handle_set_has_required_score_states(ScoreState self, bool tf)"""
3758 return _IMP_kernel.ScoreState_handle_set_has_required_score_states(self, tf)
3760 def do_before_evaluate(self):
3761 r"""do_before_evaluate(ScoreState self)"""
3762 return _IMP_kernel.ScoreState_do_before_evaluate(self)
3764 def do_after_evaluate(self, accpt):
3765 r"""do_after_evaluate(ScoreState self, DerivativeAccumulator accpt)"""
3766 return _IMP_kernel.ScoreState_do_after_evaluate(self, accpt)
3767 __swig_destroy__ = _IMP_kernel.delete_ScoreState
3770 r"""__str__(ScoreState self) -> std::string"""
3771 return _IMP_kernel.ScoreState___str__(self)
3774 r"""__repr__(ScoreState self) -> std::string"""
3775 return _IMP_kernel.ScoreState___repr__(self)
3779 return _object_cast_to_ScoreState(o)
3782 def do_show(self, out):
3787 return _object_cast_to_ScoreState(o)
3789 def __disown__(self):
3791 _IMP_kernel.disown_ScoreState(self)
3792 return weakref.proxy(self)
3795 r"""do_destroy(ScoreState self)"""
3796 return _IMP_kernel.ScoreState_do_destroy(self)
3798 def do_get_inputs(self):
3799 r"""do_get_inputs(ScoreState self) -> IMP::ModelObjectsTemp"""
3800 return _IMP_kernel.ScoreState_do_get_inputs(self)
3802 def do_get_outputs(self):
3803 r"""do_get_outputs(ScoreState self) -> IMP::ModelObjectsTemp"""
3804 return _IMP_kernel.ScoreState_do_get_outputs(self)
3806 def do_get_interactions(self):
3807 r"""do_get_interactions(ScoreState self) -> IMP::ModelObjectsTemps"""
3808 return _IMP_kernel.ScoreState_do_get_interactions(self)
3811 _IMP_kernel.ScoreState_swigregister(ScoreState)
3814 r"""get_update_order(IMP::ScoreStatesTemp input) -> IMP::ScoreStatesTemp"""
3815 return _IMP_kernel.get_update_order(input)
3817 r"""Proxy of C++ IMP::Constraint class."""
3819 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3821 def __init__(self, *args):
3823 __init__(Constraint self, Model m, std::string name="Constraint %1%") -> Constraint
3824 __init__(Constraint self) -> Constraint
3826 if self.__class__ == Constraint:
3830 _IMP_kernel.Constraint_swiginit(self, _IMP_kernel.new_Constraint(_self, *args))
3832 if self.__class__ != Constraint:
3833 _director_objects.register(self)
3838 def do_update_attributes(self):
3839 r"""do_update_attributes(Constraint self)"""
3840 return _IMP_kernel.Constraint_do_update_attributes(self)
3842 def do_update_derivatives(self, da):
3843 r"""do_update_derivatives(Constraint self, DerivativeAccumulator da)"""
3844 return _IMP_kernel.Constraint_do_update_derivatives(self, da)
3846 def do_before_evaluate(self):
3847 r"""do_before_evaluate(Constraint self)"""
3848 return _IMP_kernel.Constraint_do_before_evaluate(self)
3850 def do_after_evaluate(self, da):
3851 r"""do_after_evaluate(Constraint self, DerivativeAccumulator da)"""
3852 return _IMP_kernel.Constraint_do_after_evaluate(self, da)
3853 __swig_destroy__ = _IMP_kernel.delete_Constraint
3856 r"""__str__(Constraint self) -> std::string"""
3857 return _IMP_kernel.Constraint___str__(self)
3860 r"""__repr__(Constraint self) -> std::string"""
3861 return _IMP_kernel.Constraint___repr__(self)
3865 return _object_cast_to_Constraint(o)
3868 def do_show(self, out):
3873 return _object_cast_to_Constraint(o)
3875 def __disown__(self):
3877 _IMP_kernel.disown_Constraint(self)
3878 return weakref.proxy(self)
3881 r"""do_destroy(Constraint self)"""
3882 return _IMP_kernel.Constraint_do_destroy(self)
3884 def do_get_inputs(self):
3885 r"""do_get_inputs(Constraint self) -> IMP::ModelObjectsTemp"""
3886 return _IMP_kernel.Constraint_do_get_inputs(self)
3888 def do_get_outputs(self):
3889 r"""do_get_outputs(Constraint self) -> IMP::ModelObjectsTemp"""
3890 return _IMP_kernel.Constraint_do_get_outputs(self)
3892 def do_get_interactions(self):
3893 r"""do_get_interactions(Constraint self) -> IMP::ModelObjectsTemps"""
3894 return _IMP_kernel.Constraint_do_get_interactions(self)
3897 _IMP_kernel.Constraint_swigregister(Constraint)
3899 r"""Proxy of C++ IMP::Container class."""
3901 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3903 def __init__(self, *args):
3905 __init__(Container self, Model m, std::string name="Container %1%") -> Container
3906 __init__(Container self) -> Container
3908 if self.__class__ == Container:
3912 _IMP_kernel.Container_swiginit(self, _IMP_kernel.new_Container(_self, *args))
3914 if self.__class__ != Container:
3915 _director_objects.register(self)
3920 def do_get_contents_hash(self):
3921 r"""do_get_contents_hash(Container self) -> std::size_t"""
3922 return _IMP_kernel.Container_do_get_contents_hash(self)
3924 def get_all_possible_indexes(self):
3925 r"""get_all_possible_indexes(Container self) -> IMP::ParticleIndexes"""
3926 return _IMP_kernel.Container_get_all_possible_indexes(self)
3928 def get_contents_hash(self):
3929 r"""get_contents_hash(Container self) -> std::size_t"""
3930 return _IMP_kernel.Container_get_contents_hash(self)
3932 def do_get_outputs(self):
3933 r"""do_get_outputs(Container self) -> IMP::ModelObjectsTemp"""
3934 return _IMP_kernel.Container_do_get_outputs(self)
3936 def get_is_decomposable(self):
3937 r"""get_is_decomposable(Container self) -> bool"""
3938 return _IMP_kernel.Container_get_is_decomposable(self)
3940 def validate_readable(self):
3941 r"""validate_readable(Container self)"""
3942 return _IMP_kernel.Container_validate_readable(self)
3944 def validate_writable(self):
3945 r"""validate_writable(Container self)"""
3946 return _IMP_kernel.Container_validate_writable(self)
3948 def set_is_readable(self, tf):
3949 r"""set_is_readable(Container self, bool tf)"""
3950 return _IMP_kernel.Container_set_is_readable(self, tf)
3952 def set_is_writable(self, tf):
3953 r"""set_is_writable(Container self, bool tf)"""
3954 return _IMP_kernel.Container_set_is_writable(self, tf)
3955 __swig_destroy__ = _IMP_kernel.delete_Container
3958 r"""__str__(Container self) -> std::string"""
3959 return _IMP_kernel.Container___str__(self)
3962 r"""__repr__(Container self) -> std::string"""
3963 return _IMP_kernel.Container___repr__(self)
3967 return _object_cast_to_Container(o)
3970 def do_show(self, out):
3975 return _object_cast_to_Container(o)
3977 def __disown__(self):
3979 _IMP_kernel.disown_Container(self)
3980 return weakref.proxy(self)
3983 r"""do_destroy(Container self)"""
3984 return _IMP_kernel.Container_do_destroy(self)
3986 def handle_set_has_required_score_states(self, arg0):
3987 r"""handle_set_has_required_score_states(Container self, bool arg0)"""
3988 return _IMP_kernel.Container_handle_set_has_required_score_states(self, arg0)
3990 def do_get_inputs(self):
3991 r"""do_get_inputs(Container self) -> IMP::ModelObjectsTemp"""
3992 return _IMP_kernel.Container_do_get_inputs(self)
3994 def do_get_interactions(self):
3995 r"""do_get_interactions(Container self) -> IMP::ModelObjectsTemps"""
3996 return _IMP_kernel.Container_do_get_interactions(self)
3999 _IMP_kernel.Container_swigregister(Container)
4001 r"""Proxy of C++ IMP::RestraintInfo class."""
4003 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
4005 def __init__(self, *args):
4006 r"""__init__(RestraintInfo self, std::string name="RestraintInfo %1%") -> RestraintInfo"""
4007 _IMP_kernel.RestraintInfo_swiginit(self, _IMP_kernel.new_RestraintInfo(*args))
4010 r"""clear(RestraintInfo self)"""
4011 return _IMP_kernel.RestraintInfo_clear(self)
4013 def add_int(self, key, value):
4014 r"""add_int(RestraintInfo self, std::string key, int value)"""
4015 return _IMP_kernel.RestraintInfo_add_int(self, key, value)
4017 def get_number_of_int(self):
4018 r"""get_number_of_int(RestraintInfo self) -> unsigned int"""
4019 return _IMP_kernel.RestraintInfo_get_number_of_int(self)
4021 def get_int_key(self, i):
4022 r"""get_int_key(RestraintInfo self, unsigned int i) -> std::string"""
4023 return _IMP_kernel.RestraintInfo_get_int_key(self, i)
4025 def get_int_value(self, i):
4026 r"""get_int_value(RestraintInfo self, unsigned int i) -> int"""
4027 return _IMP_kernel.RestraintInfo_get_int_value(self, i)
4029 def add_float(self, key, value):
4030 r"""add_float(RestraintInfo self, std::string key, double value)"""
4031 return _IMP_kernel.RestraintInfo_add_float(self, key, value)
4033 def get_number_of_float(self):
4034 r"""get_number_of_float(RestraintInfo self) -> unsigned int"""
4035 return _IMP_kernel.RestraintInfo_get_number_of_float(self)
4037 def get_float_key(self, i):
4038 r"""get_float_key(RestraintInfo self, unsigned int i) -> std::string"""
4039 return _IMP_kernel.RestraintInfo_get_float_key(self, i)
4041 def get_float_value(self, i):
4042 r"""get_float_value(RestraintInfo self, unsigned int i) -> double"""
4043 return _IMP_kernel.RestraintInfo_get_float_value(self, i)
4045 def add_string(self, key, value):
4046 r"""add_string(RestraintInfo self, std::string key, std::string value)"""
4047 return _IMP_kernel.RestraintInfo_add_string(self, key, value)
4049 def get_number_of_string(self):
4050 r"""get_number_of_string(RestraintInfo self) -> unsigned int"""
4051 return _IMP_kernel.RestraintInfo_get_number_of_string(self)
4053 def get_string_key(self, i):
4054 r"""get_string_key(RestraintInfo self, unsigned int i) -> std::string"""
4055 return _IMP_kernel.RestraintInfo_get_string_key(self, i)
4057 def get_string_value(self, i):
4058 r"""get_string_value(RestraintInfo self, unsigned int i) -> std::string"""
4059 return _IMP_kernel.RestraintInfo_get_string_value(self, i)
4061 def add_filename(self, key, value):
4062 r"""add_filename(RestraintInfo self, std::string key, std::string value)"""
4063 return _IMP_kernel.RestraintInfo_add_filename(self, key, value)
4065 def get_number_of_filename(self):
4066 r"""get_number_of_filename(RestraintInfo self) -> unsigned int"""
4067 return _IMP_kernel.RestraintInfo_get_number_of_filename(self)
4069 def get_filename_key(self, i):
4070 r"""get_filename_key(RestraintInfo self, unsigned int i) -> std::string"""
4071 return _IMP_kernel.RestraintInfo_get_filename_key(self, i)
4073 def get_filename_value(self, i):
4074 r"""get_filename_value(RestraintInfo self, unsigned int i) -> std::string"""
4075 return _IMP_kernel.RestraintInfo_get_filename_value(self, i)
4077 def add_floats(self, key, value):
4078 r"""add_floats(RestraintInfo self, std::string key, IMP::Floats value)"""
4079 return _IMP_kernel.RestraintInfo_add_floats(self, key, value)
4081 def get_number_of_floats(self):
4082 r"""get_number_of_floats(RestraintInfo self) -> unsigned int"""
4083 return _IMP_kernel.RestraintInfo_get_number_of_floats(self)
4085 def get_floats_key(self, i):
4086 r"""get_floats_key(RestraintInfo self, unsigned int i) -> std::string"""
4087 return _IMP_kernel.RestraintInfo_get_floats_key(self, i)
4089 def get_floats_value(self, i):
4090 r"""get_floats_value(RestraintInfo self, unsigned int i) -> IMP::Floats"""
4091 return _IMP_kernel.RestraintInfo_get_floats_value(self, i)
4093 def add_ints(self, key, value):
4094 r"""add_ints(RestraintInfo self, std::string key, IMP::Ints value)"""
4095 return _IMP_kernel.RestraintInfo_add_ints(self, key, value)
4097 def get_number_of_ints(self):
4098 r"""get_number_of_ints(RestraintInfo self) -> unsigned int"""
4099 return _IMP_kernel.RestraintInfo_get_number_of_ints(self)
4101 def get_ints_key(self, i):
4102 r"""get_ints_key(RestraintInfo self, unsigned int i) -> std::string"""
4103 return _IMP_kernel.RestraintInfo_get_ints_key(self, i)
4105 def get_ints_value(self, i):
4106 r"""get_ints_value(RestraintInfo self, unsigned int i) -> IMP::Ints"""
4107 return _IMP_kernel.RestraintInfo_get_ints_value(self, i)
4109 def add_strings(self, key, value):
4110 r"""add_strings(RestraintInfo self, std::string key, IMP::Strings value)"""
4111 return _IMP_kernel.RestraintInfo_add_strings(self, key, value)
4113 def get_number_of_strings(self):
4114 r"""get_number_of_strings(RestraintInfo self) -> unsigned int"""
4115 return _IMP_kernel.RestraintInfo_get_number_of_strings(self)
4117 def get_strings_key(self, i):
4118 r"""get_strings_key(RestraintInfo self, unsigned int i) -> std::string"""
4119 return _IMP_kernel.RestraintInfo_get_strings_key(self, i)
4121 def get_strings_value(self, i):
4122 r"""get_strings_value(RestraintInfo self, unsigned int i) -> IMP::Strings"""
4123 return _IMP_kernel.RestraintInfo_get_strings_value(self, i)
4125 def add_filenames(self, key, value):
4126 r"""add_filenames(RestraintInfo self, std::string key, IMP::Strings value)"""
4127 return _IMP_kernel.RestraintInfo_add_filenames(self, key, value)
4129 def get_number_of_filenames(self):
4130 r"""get_number_of_filenames(RestraintInfo self) -> unsigned int"""
4131 return _IMP_kernel.RestraintInfo_get_number_of_filenames(self)
4133 def get_filenames_key(self, i):
4134 r"""get_filenames_key(RestraintInfo self, unsigned int i) -> std::string"""
4135 return _IMP_kernel.RestraintInfo_get_filenames_key(self, i)
4137 def get_filenames_value(self, i):
4138 r"""get_filenames_value(RestraintInfo self, unsigned int i) -> IMP::Strings"""
4139 return _IMP_kernel.RestraintInfo_get_filenames_value(self, i)
4141 def add_particle_indexes(self, key, value):
4142 r"""add_particle_indexes(RestraintInfo self, std::string key, IMP::ParticleIndexes value)"""
4143 return _IMP_kernel.RestraintInfo_add_particle_indexes(self, key, value)
4145 def get_number_of_particle_indexes(self):
4146 r"""get_number_of_particle_indexes(RestraintInfo self) -> unsigned int"""
4147 return _IMP_kernel.RestraintInfo_get_number_of_particle_indexes(self)
4149 def get_particle_indexes_key(self, i):
4150 r"""get_particle_indexes_key(RestraintInfo self, unsigned int i) -> std::string"""
4151 return _IMP_kernel.RestraintInfo_get_particle_indexes_key(self, i)
4153 def get_particle_indexes_value(self, i):
4154 r"""get_particle_indexes_value(RestraintInfo self, unsigned int i) -> IMP::ParticleIndexes"""
4155 return _IMP_kernel.RestraintInfo_get_particle_indexes_value(self, i)
4158 r"""get_version_info(RestraintInfo self) -> VersionInfo"""
4159 return _IMP_kernel.RestraintInfo_get_version_info(self)
4160 __swig_destroy__ = _IMP_kernel.delete_RestraintInfo
4163 r"""__str__(RestraintInfo self) -> std::string"""
4164 return _IMP_kernel.RestraintInfo___str__(self)
4167 r"""__repr__(RestraintInfo self) -> std::string"""
4168 return _IMP_kernel.RestraintInfo___repr__(self)
4172 return _object_cast_to_RestraintInfo(o)
4176 _IMP_kernel.RestraintInfo_swigregister(RestraintInfo)
4178 r"""Proxy of C++ IMP::Restraint class."""
4180 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
4182 def __init__(self, *args):
4184 __init__(Restraint self, Model m, std::string name) -> Restraint
4185 __init__(Restraint self) -> Restraint
4187 if self.__class__ == Restraint:
4191 _IMP_kernel.Restraint_swiginit(self, _IMP_kernel.new_Restraint(_self, *args))
4193 if self.__class__ != Restraint:
4194 _director_objects.register(self)
4199 def get_score(self):
4200 r"""get_score(Restraint self) -> double"""
4201 return _IMP_kernel.Restraint_get_score(self)
4203 def evaluate(self, calc_derivs):
4204 r"""evaluate(Restraint self, bool calc_derivs) -> double"""
4205 return _IMP_kernel.Restraint_evaluate(self, calc_derivs)
4207 def evaluate_moved(self, calc_derivs, moved_pis, reset_pis):
4208 r"""evaluate_moved(Restraint self, bool calc_derivs, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis) -> double"""
4209 return _IMP_kernel.Restraint_evaluate_moved(self, calc_derivs, moved_pis, reset_pis)
4211 def evaluate_moved_if_below(self, calc_derivatives, moved_pis, reset_pis, max):
4212 r"""evaluate_moved_if_below(Restraint self, bool calc_derivatives, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis, double max) -> double"""
4213 return _IMP_kernel.Restraint_evaluate_moved_if_below(self, calc_derivatives, moved_pis, reset_pis, max)
4215 def evaluate_moved_if_good(self, calc_derivatives, moved_pis, reset_pis):
4216 r"""evaluate_moved_if_good(Restraint self, bool calc_derivatives, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis) -> double"""
4217 return _IMP_kernel.Restraint_evaluate_moved_if_good(self, calc_derivatives, moved_pis, reset_pis)
4219 def evaluate_if_good(self, calc_derivatives):
4220 r"""evaluate_if_good(Restraint self, bool calc_derivatives) -> double"""
4221 return _IMP_kernel.Restraint_evaluate_if_good(self, calc_derivatives)
4223 def evaluate_if_below(self, calc_derivatives, max):
4224 r"""evaluate_if_below(Restraint self, bool calc_derivatives, double max) -> double"""
4225 return _IMP_kernel.Restraint_evaluate_if_below(self, calc_derivatives, max)
4227 def unprotected_evaluate(self, da):
4228 r"""unprotected_evaluate(Restraint self, DerivativeAccumulator da) -> double"""
4229 return _IMP_kernel.Restraint_unprotected_evaluate(self, da)
4231 def unprotected_evaluate_moved(self, da, moved_pis, reset_pis):
4232 r"""unprotected_evaluate_moved(Restraint self, DerivativeAccumulator da, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis) -> double"""
4233 return _IMP_kernel.Restraint_unprotected_evaluate_moved(self, da, moved_pis, reset_pis)
4235 def unprotected_evaluate_if_good(self, da, max):
4236 r"""unprotected_evaluate_if_good(Restraint self, DerivativeAccumulator da, double max) -> double"""
4237 return _IMP_kernel.Restraint_unprotected_evaluate_if_good(self, da, max)
4239 def unprotected_evaluate_if_below(self, da, max):
4240 r"""unprotected_evaluate_if_below(Restraint self, DerivativeAccumulator da, double max) -> double"""
4241 return _IMP_kernel.Restraint_unprotected_evaluate_if_below(self, da, max)
4243 def unprotected_evaluate_moved_if_below(self, da, moved_pis, reset_pis, max):
4244 r"""unprotected_evaluate_moved_if_below(Restraint self, DerivativeAccumulator da, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis, double max) -> double"""
4245 return _IMP_kernel.Restraint_unprotected_evaluate_moved_if_below(self, da, moved_pis, reset_pis, max)
4247 def unprotected_evaluate_moved_if_good(self, da, moved_pis, reset_pis, max):
4248 r"""unprotected_evaluate_moved_if_good(Restraint self, DerivativeAccumulator da, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis, double max) -> double"""
4249 return _IMP_kernel.Restraint_unprotected_evaluate_moved_if_good(self, da, moved_pis, reset_pis, max)
4251 def get_static_info(self):
4252 r"""get_static_info(Restraint self) -> RestraintInfo"""
4253 return _IMP_kernel.Restraint_get_static_info(self)
4255 def get_dynamic_info(self):
4256 r"""get_dynamic_info(Restraint self) -> RestraintInfo"""
4257 return _IMP_kernel.Restraint_get_dynamic_info(self)
4259 def add_score_and_derivatives(self, sa):
4260 r"""add_score_and_derivatives(Restraint self, ScoreAccumulator sa)"""
4261 return _IMP_kernel.Restraint_add_score_and_derivatives(self, sa)
4263 def add_score_and_derivatives_moved(self, sa, moved_pis, reset_pis):
4264 r"""add_score_and_derivatives_moved(Restraint self, ScoreAccumulator sa, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis)"""
4265 return _IMP_kernel.Restraint_add_score_and_derivatives_moved(self, sa, moved_pis, reset_pis)
4268 r"""create_decomposition(Restraint self) -> Restraint"""
4269 return _IMP_kernel.Restraint_create_decomposition(self)
4271 def create_current_decomposition(self):
4272 r"""create_current_decomposition(Restraint self) -> Restraint"""
4273 return _IMP_kernel.Restraint_create_current_decomposition(self)
4275 def set_weight(self, weight):
4276 r"""set_weight(Restraint self, IMP::Float weight)"""
4277 return _IMP_kernel.Restraint_set_weight(self, weight)
4279 def get_weight(self):
4280 r"""get_weight(Restraint self) -> IMP::Float"""
4281 return _IMP_kernel.Restraint_get_weight(self)
4283 def get_maximum_score(self):
4284 r"""get_maximum_score(Restraint self) -> double"""
4285 return _IMP_kernel.Restraint_get_maximum_score(self)
4287 def set_maximum_score(self, s):
4288 r"""set_maximum_score(Restraint self, double s)"""
4289 return _IMP_kernel.Restraint_set_maximum_score(self, s)
4292 r"""create_scoring_function(Restraint self, double weight=1.0, double max=NO_MAX) -> ScoringFunction"""
4293 return _IMP_kernel.Restraint_create_scoring_function(self, *args)
4295 def set_last_score(self, s):
4296 r"""set_last_score(Restraint self, double s)"""
4297 return _IMP_kernel.Restraint_set_last_score(self, s)
4299 def set_last_last_score(self, s):
4300 r"""set_last_last_score(Restraint self, double s)"""
4301 return _IMP_kernel.Restraint_set_last_last_score(self, s)
4303 def get_last_score(self):
4304 r"""get_last_score(Restraint self) -> double"""
4305 return _IMP_kernel.Restraint_get_last_score(self)
4307 def get_last_last_score(self):
4308 r"""get_last_last_score(Restraint self) -> double"""
4309 return _IMP_kernel.Restraint_get_last_last_score(self)
4311 def get_is_aggregate(self):
4312 r"""get_is_aggregate(Restraint self) -> bool"""
4313 return _IMP_kernel.Restraint_get_is_aggregate(self)
4315 def get_was_good(self):
4316 r"""get_was_good(Restraint self) -> bool"""
4317 return _IMP_kernel.Restraint_get_was_good(self)
4318 __swig_destroy__ = _IMP_kernel.delete_Restraint
4320 def do_create_decomposition(self):
4321 r"""do_create_decomposition(Restraint self) -> IMP::Restraints"""
4322 return _IMP_kernel.Restraint_do_create_decomposition(self)
4324 def do_create_current_decomposition(self):
4325 r"""do_create_current_decomposition(Restraint self) -> IMP::Restraints"""
4326 return _IMP_kernel.Restraint_do_create_current_decomposition(self)
4328 def do_add_score_and_derivatives(self, sa):
4329 r"""do_add_score_and_derivatives(Restraint self, ScoreAccumulator sa)"""
4330 return _IMP_kernel.Restraint_do_add_score_and_derivatives(self, sa)
4332 def do_add_score_and_derivatives_moved(self, sa, moved_pis, reset_pis):
4333 r"""do_add_score_and_derivatives_moved(Restraint self, ScoreAccumulator sa, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis)"""
4334 return _IMP_kernel.Restraint_do_add_score_and_derivatives_moved(self, sa, moved_pis, reset_pis)
4336 def do_get_outputs(self):
4337 r"""do_get_outputs(Restraint self) -> IMP::ModelObjectsTemp"""
4338 return _IMP_kernel.Restraint_do_get_outputs(self)
4339 is_aggregate_ = property(_IMP_kernel.Restraint_is_aggregate__get, _IMP_kernel.Restraint_is_aggregate__set, doc=
r"""is_aggregate_ : bool""")
4342 r"""__str__(Restraint self) -> std::string"""
4343 return _IMP_kernel.Restraint___str__(self)
4346 r"""__repr__(Restraint self) -> std::string"""
4347 return _IMP_kernel.Restraint___repr__(self)
4351 return _object_cast_to_Restraint(o)
4354 def do_show(self, out):
4359 return _object_cast_to_Restraint(o)
4361 def __disown__(self):
4363 _IMP_kernel.disown_Restraint(self)
4364 return weakref.proxy(self)
4367 r"""do_destroy(Restraint self)"""
4368 return _IMP_kernel.Restraint_do_destroy(self)
4370 def handle_set_has_required_score_states(self, arg0):
4371 r"""handle_set_has_required_score_states(Restraint self, bool arg0)"""
4372 return _IMP_kernel.Restraint_handle_set_has_required_score_states(self, arg0)
4374 def do_get_inputs(self):
4375 r"""do_get_inputs(Restraint self) -> IMP::ModelObjectsTemp"""
4376 return _IMP_kernel.Restraint_do_get_inputs(self)
4378 def do_get_interactions(self):
4379 r"""do_get_interactions(Restraint self) -> IMP::ModelObjectsTemps"""
4380 return _IMP_kernel.Restraint_do_get_interactions(self)
4383 _IMP_kernel.Restraint_swigregister(Restraint)
4384 class _RestraintsAdaptor(_InputAdaptor):
4385 r"""Proxy of C++ IMP::RestraintsAdaptor class."""
4387 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
4388 __repr__ = _swig_repr
4390 def __init__(self, *args):
4392 __init__(_RestraintsAdaptor self) -> _RestraintsAdaptor
4393 __init__(_RestraintsAdaptor self, IMP::Restraints const & sf) -> _RestraintsAdaptor
4394 __init__(_RestraintsAdaptor self, IMP::RestraintsTemp const & sf) -> _RestraintsAdaptor
4395 __init__(_RestraintsAdaptor self, Restraint sf) -> _RestraintsAdaptor
4397 _IMP_kernel._RestraintsAdaptor_swiginit(self, _IMP_kernel.new__RestraintsAdaptor(*args))
4398 __swig_destroy__ = _IMP_kernel.delete__RestraintsAdaptor
4401 _IMP_kernel._RestraintsAdaptor_swigregister(_RestraintsAdaptor)
4403 r"""Proxy of C++ IMP::RestraintSet class."""
4405 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
4407 def __init__(self, *args):
4409 __init__(RestraintSet self, Model m, double weight, std::string const & name="RestraintSet %1%") -> RestraintSet
4410 __init__(RestraintSet self, Model m, std::string const & name="RestraintSet %1%") -> RestraintSet
4411 __init__(RestraintSet self, IMP::RestraintsTemp const & rs, double weight, std::string const & name="RestraintSet %1%") -> RestraintSet
4412 __init__(RestraintSet self) -> RestraintSet
4414 if self.__class__ == RestraintSet:
4418 _IMP_kernel.RestraintSet_swiginit(self, _IMP_kernel.new_RestraintSet(_self, *args))
4420 if self.__class__ != RestraintSet:
4421 _director_objects.register(self)
4426 def unprotected_evaluate(self, da):
4427 r"""unprotected_evaluate(RestraintSet self, DerivativeAccumulator da) -> double"""
4428 return _IMP_kernel.RestraintSet_unprotected_evaluate(self, da)
4430 def get_type_name(self):
4431 r"""get_type_name(RestraintSet self) -> std::string"""
4432 return _IMP_kernel.RestraintSet_get_type_name(self)
4435 r"""get_version_info(RestraintSet self) -> VersionInfo"""
4436 return _IMP_kernel.RestraintSet_get_version_info(self)
4437 __swig_destroy__ = _IMP_kernel.delete_RestraintSet
4438 def __get_restraints(self):
return _list_util.VarList(getdimfunc=self.get_number_of_restraints, getfunc=self.get_restraint, erasefunc=self.erase_restraint, appendfunc=self.add_restraint, extendfunc=self.add_restraints, clearfunc=self.clear_restraints, indexfunc=self._python_index_restraint)
4439 def __set_restraints(self, obj): _list_util.set_varlist(self.restraints, obj)
4440 def __del_restraints(self): _list_util.del_varlist(self.restraints)
4441 restraints = property(__get_restraints, __set_restraints, __del_restraints, doc=
"List of ##ucnames")
4443 def remove_restraint(self, d):
4444 r"""remove_restraint(RestraintSet self, Restraint d)"""
4445 return _IMP_kernel.RestraintSet_remove_restraint(self, d)
4447 def _python_index_restraint(self, d, start, stop):
4448 r"""_python_index_restraint(RestraintSet self, Restraint d, unsigned int start, unsigned int stop) -> unsigned int"""
4449 return _IMP_kernel.RestraintSet__python_index_restraint(self, d, start, stop)
4451 def remove_restraints(self, d):
4452 r"""remove_restraints(RestraintSet self, IMP::Restraints const & d)"""
4453 return _IMP_kernel.RestraintSet_remove_restraints(self, d)
4455 def set_restraints(self, ps):
4456 r"""set_restraints(RestraintSet self, IMP::Restraints const & ps)"""
4457 return _IMP_kernel.RestraintSet_set_restraints(self, ps)
4459 def set_restraints_order(self, objs):
4460 r"""set_restraints_order(RestraintSet self, IMP::Restraints const & objs)"""
4461 return _IMP_kernel.RestraintSet_set_restraints_order(self, objs)
4464 r"""add_restraint(RestraintSet self, Restraint obj) -> unsigned int"""
4465 return _IMP_kernel.RestraintSet_add_restraint(self, obj)
4468 r"""add_restraints(RestraintSet self, IMP::Restraints const & objs)"""
4469 return _IMP_kernel.RestraintSet_add_restraints(self, objs)
4471 def clear_restraints(self):
4472 r"""clear_restraints(RestraintSet self)"""
4473 return _IMP_kernel.RestraintSet_clear_restraints(self)
4475 def get_number_of_restraints(self):
4476 r"""get_number_of_restraints(RestraintSet self) -> unsigned int"""
4477 return _IMP_kernel.RestraintSet_get_number_of_restraints(self)
4479 def get_has_restraints(self):
4480 r"""get_has_restraints(RestraintSet self) -> bool"""
4481 return _IMP_kernel.RestraintSet_get_has_restraints(self)
4483 def get_restraint(self, i):
4484 r"""get_restraint(RestraintSet self, unsigned int i) -> Restraint"""
4485 return _IMP_kernel.RestraintSet_get_restraint(self, i)
4487 def get_restraints(self):
4488 r"""get_restraints(RestraintSet self) -> IMP::Restraints"""
4489 return _IMP_kernel.RestraintSet_get_restraints(self)
4491 def erase_restraint(self, i):
4492 r"""erase_restraint(RestraintSet self, unsigned int i)"""
4493 return _IMP_kernel.RestraintSet_erase_restraint(self, i)
4495 def reserve_restraints(self, sz):
4496 r"""reserve_restraints(RestraintSet self, unsigned int sz)"""
4497 return _IMP_kernel.RestraintSet_reserve_restraints(self, sz)
4499 def get_non_sets_and_sets(self):
4500 r"""get_non_sets_and_sets(RestraintSet self) -> std::pair< IMP::RestraintsTemp,IMP::RestraintSetsTemp >"""
4501 return _IMP_kernel.RestraintSet_get_non_sets_and_sets(self)
4503 def do_get_inputs(self):
4504 r"""do_get_inputs(RestraintSet self) -> IMP::ModelObjectsTemp"""
4505 return _IMP_kernel.RestraintSet_do_get_inputs(self)
4508 r"""create_scoring_function(RestraintSet self, double weight=1.0, double max=std::numeric_limits< double >::max()) -> ScoringFunction"""
4509 return _IMP_kernel.RestraintSet_create_scoring_function(self, *args)
4511 def get_last_score(self):
4512 r"""get_last_score(RestraintSet self) -> double"""
4513 return _IMP_kernel.RestraintSet_get_last_score(self)
4516 r"""__str__(RestraintSet self) -> std::string"""
4517 return _IMP_kernel.RestraintSet___str__(self)
4520 r"""__repr__(RestraintSet self) -> std::string"""
4521 return _IMP_kernel.RestraintSet___repr__(self)
4525 return _object_cast_to_RestraintSet(o)
4528 def do_show(self, out):
4533 return _object_cast_to_RestraintSet(o)
4536 def _get_as_binary(self):
4537 r"""_get_as_binary(RestraintSet self) -> PyObject *"""
4538 return _IMP_kernel.RestraintSet__get_as_binary(self)
4540 def _set_from_binary(self, p):
4541 r"""_set_from_binary(RestraintSet self, PyObject * p)"""
4542 return _IMP_kernel.RestraintSet__set_from_binary(self, p)
4544 def __getstate__(self):
4545 p = self._get_as_binary()
4546 if len(self.__dict__) > 1:
4547 d = self.__dict__.copy()
4552 def __setstate__(self, p):
4553 if not hasattr(self,
'this'):
4555 if isinstance(p, tuple):
4557 self.__dict__.update(d)
4558 return self._set_from_binary(p)
4560 def __disown__(self):
4562 _IMP_kernel.disown_RestraintSet(self)
4563 return weakref.proxy(self)
4566 r"""do_destroy(RestraintSet self)"""
4567 return _IMP_kernel.RestraintSet_do_destroy(self)
4569 def handle_set_has_required_score_states(self, arg0):
4570 r"""handle_set_has_required_score_states(RestraintSet self, bool arg0)"""
4571 return _IMP_kernel.RestraintSet_handle_set_has_required_score_states(self, arg0)
4573 def do_get_outputs(self):
4574 r"""do_get_outputs(RestraintSet self) -> IMP::ModelObjectsTemp"""
4575 return _IMP_kernel.RestraintSet_do_get_outputs(self)
4577 def do_get_interactions(self):
4578 r"""do_get_interactions(RestraintSet self) -> IMP::ModelObjectsTemps"""
4579 return _IMP_kernel.RestraintSet_do_get_interactions(self)
4581 def do_create_decomposition(self):
4582 r"""do_create_decomposition(RestraintSet self) -> IMP::Restraints"""
4583 return _IMP_kernel.RestraintSet_do_create_decomposition(self)
4585 def do_create_current_decomposition(self):
4586 r"""do_create_current_decomposition(RestraintSet self) -> IMP::Restraints"""
4587 return _IMP_kernel.RestraintSet_do_create_current_decomposition(self)
4589 def do_add_score_and_derivatives(self, sa):
4590 r"""do_add_score_and_derivatives(RestraintSet self, ScoreAccumulator sa)"""
4591 return _IMP_kernel.RestraintSet_do_add_score_and_derivatives(self, sa)
4593 def do_add_score_and_derivatives_moved(self, sa, moved_pis, reset_pis):
4594 r"""do_add_score_and_derivatives_moved(RestraintSet self, ScoreAccumulator sa, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis)"""
4595 return _IMP_kernel.RestraintSet_do_add_score_and_derivatives_moved(self, sa, moved_pis, reset_pis)
4598 _IMP_kernel.RestraintSet_swigregister(RestraintSet)
4600 def get_restraints(rs):
4601 r"""get_restraints(IMP::RestraintsTemp const & rs) -> IMP::RestraintsTemp"""
4602 return _IMP_kernel.get_restraints(rs)
4604 def _check_particle(p, a):
4605 if (
not p.get_is_active()):
4606 raise ValueError(
"Inactive Particle")
4607 if (type(a)() == a):
4608 raise IndexError(
"Cannot use default Index")
4609 if (
not p.has_attribute(a)):
4610 raise IndexError(
"Particle does not have attribute")
4613 r"""Proxy of C++ IMP::Particle class."""
4615 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
4618 r"""get_version_info(Particle self) -> VersionInfo"""
4619 return _IMP_kernel.Particle_get_version_info(self)
4620 __swig_destroy__ = _IMP_kernel.delete_Particle
4622 def __init__(self, *args):
4624 __init__(Particle self, Model m, std::string name) -> Particle
4625 __init__(Particle self, Model m) -> Particle
4626 __init__(Particle self) -> Particle
4628 _IMP_kernel.Particle_swiginit(self, _IMP_kernel.new_Particle(*args))
4630 def get_float_keys(self):
4631 r"""get_float_keys(Particle self) -> IMP::FloatKeys"""
4632 return _IMP_kernel.Particle_get_float_keys(self)
4634 def get_floats_keys(self):
4635 r"""get_floats_keys(Particle self) -> IMP::FloatsKeys"""
4636 return _IMP_kernel.Particle_get_floats_keys(self)
4638 def get_int_keys(self):
4639 r"""get_int_keys(Particle self) -> IMP::IntKeys"""
4640 return _IMP_kernel.Particle_get_int_keys(self)
4642 def get_ints_keys(self):
4643 r"""get_ints_keys(Particle self) -> IMP::IntsKeys"""
4644 return _IMP_kernel.Particle_get_ints_keys(self)
4646 def get_string_keys(self):
4647 r"""get_string_keys(Particle self) -> IMP::StringKeys"""
4648 return _IMP_kernel.Particle_get_string_keys(self)
4650 def get_object_keys(self):
4651 r"""get_object_keys(Particle self) -> IMP::ObjectKeys"""
4652 return _IMP_kernel.Particle_get_object_keys(self)
4654 def add_cache_attribute(self, *args):
4656 add_cache_attribute(Particle self, FloatKey name, IMP::Float value)
4657 add_cache_attribute(Particle self, FloatsKey name, IMP::Floats value)
4658 add_cache_attribute(Particle self, IntKey name, IMP::Int value)
4659 add_cache_attribute(Particle self, IntsKey name, IMP::Ints value)
4660 add_cache_attribute(Particle self, StringKey name, IMP::String value)
4661 add_cache_attribute(Particle self, ObjectKey name, Object value)
4662 add_cache_attribute(Particle self, IMP::WeakObjectKey name, Object value)
4664 return _IMP_kernel.Particle_add_cache_attribute(self, *args)
4666 def get_weak_object_keys(self):
4667 r"""get_weak_object_keys(Particle self) -> IMP::WeakObjectKeys"""
4668 return _IMP_kernel.Particle_get_weak_object_keys(self)
4670 def add_to_derivative(self, key, value, da):
4671 r"""add_to_derivative(Particle self, FloatKey key, IMP::Float value, DerivativeAccumulator da)"""
4672 return _IMP_kernel.Particle_add_to_derivative(self, key, value, da)
4674 def set_is_optimized(self, k, tf):
4675 r"""set_is_optimized(Particle self, FloatKey k, bool tf)"""
4676 return _IMP_kernel.Particle_set_is_optimized(self, k, tf)
4678 def get_is_optimized(self, k):
4679 r"""get_is_optimized(Particle self, FloatKey k) -> bool"""
4680 return _IMP_kernel.Particle_get_is_optimized(self, k)
4682 def get_derivative(self, k):
4683 r"""get_derivative(Particle self, FloatKey k) -> IMP::Float"""
4684 return _IMP_kernel.Particle_get_derivative(self, k)
4686 def add_attribute(self, *args):
4688 add_attribute(Particle self, FloatKey name, IMP::Float initial_value)
4689 add_attribute(Particle self, FloatsKey name, IMP::Floats initial_value)
4690 add_attribute(Particle self, IntKey name, IMP::Int initial_value)
4691 add_attribute(Particle self, IntsKey name, IMP::Ints initial_value)
4692 add_attribute(Particle self, StringKey name, IMP::String initial_value)
4693 add_attribute(Particle self, ObjectKey name, Object initial_value)
4694 add_attribute(Particle self, IMP::WeakObjectKey name, Object initial_value)
4695 add_attribute(Particle self, SparseStringKey name, IMP::String initial_value)
4696 add_attribute(Particle self, SparseIntKey name, IMP::Int initial_value)
4697 add_attribute(Particle self, SparseFloatKey name, IMP::Float initial_value)
4698 add_attribute(Particle self, SparseParticleIndexKey name, ParticleIndex initial_value)
4699 add_attribute(Particle self, FloatKey name, IMP::Float const initial_value, bool optimized)
4700 add_attribute(Particle self, ParticleIndexKey k, Particle v)
4702 return _IMP_kernel.Particle_add_attribute(self, *args)
4704 def has_attribute(self, *args):
4706 has_attribute(Particle self, FloatKey name) -> bool
4707 has_attribute(Particle self, FloatsKey name) -> bool
4708 has_attribute(Particle self, IntKey name) -> bool
4709 has_attribute(Particle self, IntsKey name) -> bool
4710 has_attribute(Particle self, StringKey name) -> bool
4711 has_attribute(Particle self, ObjectKey name) -> bool
4712 has_attribute(Particle self, IMP::WeakObjectKey name) -> bool
4713 has_attribute(Particle self, SparseStringKey name) -> bool
4714 has_attribute(Particle self, SparseIntKey name) -> bool
4715 has_attribute(Particle self, SparseFloatKey name) -> bool
4716 has_attribute(Particle self, SparseParticleIndexKey name) -> bool
4717 has_attribute(Particle self, ParticleIndexKey k) -> bool
4719 return _IMP_kernel.Particle_has_attribute(self, *args)
4721 def set_value(self, *args):
4723 set_value(Particle self, FloatKey name, IMP::Float value)
4724 set_value(Particle self, FloatsKey name, IMP::Floats value)
4725 set_value(Particle self, IntKey name, IMP::Int value)
4726 set_value(Particle self, IntsKey name, IMP::Ints value)
4727 set_value(Particle self, StringKey name, IMP::String value)
4728 set_value(Particle self, ObjectKey name, Object value)
4729 set_value(Particle self, IMP::WeakObjectKey name, Object value)
4730 set_value(Particle self, SparseStringKey name, IMP::String value)
4731 set_value(Particle self, SparseIntKey name, IMP::Int value)
4732 set_value(Particle self, SparseFloatKey name, IMP::Float value)
4733 set_value(Particle self, SparseParticleIndexKey name, ParticleIndex value)
4734 set_value(Particle self, ParticleIndexKey k, Particle v)
4736 return _IMP_kernel.Particle_set_value(self, *args)
4738 def get_value(self, *args):
4740 get_value(Particle self, FloatKey name) -> IMP::Float
4741 get_value(Particle self, FloatsKey name) -> IMP::Floats
4742 get_value(Particle self, IntKey name) -> IMP::Int
4743 get_value(Particle self, IntsKey name) -> IMP::Ints
4744 get_value(Particle self, StringKey name) -> IMP::String
4745 get_value(Particle self, ObjectKey name) -> Object
4746 get_value(Particle self, IMP::WeakObjectKey name) -> Object
4747 get_value(Particle self, SparseStringKey name) -> IMP::String
4748 get_value(Particle self, SparseIntKey name) -> IMP::Int
4749 get_value(Particle self, SparseFloatKey name) -> IMP::Float
4750 get_value(Particle self, SparseParticleIndexKey name) -> ParticleIndex
4751 get_value(Particle self, ParticleIndexKey k) -> Particle
4753 return _IMP_kernel.Particle_get_value(self, *args)
4755 def remove_attribute(self, *args):
4757 remove_attribute(Particle self, FloatKey name)
4758 remove_attribute(Particle self, FloatsKey name)
4759 remove_attribute(Particle self, IntKey name)
4760 remove_attribute(Particle self, IntsKey name)
4761 remove_attribute(Particle self, StringKey name)
4762 remove_attribute(Particle self, ObjectKey name)
4763 remove_attribute(Particle self, IMP::WeakObjectKey name)
4764 remove_attribute(Particle self, SparseStringKey name)
4765 remove_attribute(Particle self, SparseIntKey name)
4766 remove_attribute(Particle self, SparseFloatKey name)
4767 remove_attribute(Particle self, SparseParticleIndexKey name)
4768 remove_attribute(Particle self, ParticleIndexKey k)
4770 return _IMP_kernel.Particle_remove_attribute(self, *args)
4772 def get_particle_keys(self):
4773 r"""get_particle_keys(Particle self) -> IMP::ParticleIndexKeys"""
4774 return _IMP_kernel.Particle_get_particle_keys(self)
4776 def show(self, *args):
4777 r"""show(Particle self, _ostream out=std::cout)"""
4778 return _IMP_kernel.Particle_show(self, *args)
4780 def get_is_active(self):
4781 r"""get_is_active(Particle self) -> bool"""
4782 return _IMP_kernel.Particle_get_is_active(self)
4785 r"""get_index(Particle self) -> ParticleIndex"""
4786 return _IMP_kernel.Particle_get_index(self)
4788 def __eq__(self, *args):
4790 __eq__(Particle self, Particle o) -> bool
4791 __eq__(Particle self, Decorator d) -> bool
4793 return _IMP_kernel.Particle___eq__(self, *args)
4795 def __ne__(self, *args):
4797 __ne__(Particle self, Particle o) -> bool
4798 __ne__(Particle self, Decorator d) -> bool
4800 return _IMP_kernel.Particle___ne__(self, *args)
4802 def __le__(self, *args):
4804 __le__(Particle self, Particle o) -> bool
4805 __le__(Particle self, Decorator d) -> bool
4807 return _IMP_kernel.Particle___le__(self, *args)
4809 def __lt__(self, *args):
4811 __lt__(Particle self, Particle o) -> bool
4812 __lt__(Particle self, Decorator d) -> bool
4814 return _IMP_kernel.Particle___lt__(self, *args)
4816 def __ge__(self, *args):
4818 __ge__(Particle self, Particle o) -> bool
4819 __ge__(Particle self, Decorator d) -> bool
4821 return _IMP_kernel.Particle___ge__(self, *args)
4823 def __gt__(self, *args):
4825 __gt__(Particle self, Particle o) -> bool
4826 __gt__(Particle self, Decorator d) -> bool
4828 return _IMP_kernel.Particle___gt__(self, *args)
4830 __hash__ = ModelObject.__hash__
4834 r"""__str__(Particle self) -> std::string"""
4835 return _IMP_kernel.Particle___str__(self)
4838 r"""__repr__(Particle self) -> std::string"""
4839 return _IMP_kernel.Particle___repr__(self)
4843 return _object_cast_to_Particle(o)
4846 def _get_as_binary(self):
4847 r"""_get_as_binary(Particle self) -> PyObject *"""
4848 return _IMP_kernel.Particle__get_as_binary(self)
4850 def _set_from_binary(self, p):
4851 r"""_set_from_binary(Particle self, PyObject * p)"""
4852 return _IMP_kernel.Particle__set_from_binary(self, p)
4854 def __getstate__(self):
4855 p = self._get_as_binary()
4856 if len(self.__dict__) > 1:
4857 d = self.__dict__.copy()
4862 def __setstate__(self, p):
4863 if not hasattr(self,
'this'):
4865 if isinstance(p, tuple):
4867 self.__dict__.update(d)
4868 return self._set_from_binary(p)
4872 _IMP_kernel.Particle_swigregister(Particle)
4873 class _ParticleAdaptor(_InputAdaptor):
4874 r"""Proxy of C++ IMP::ParticleAdaptor class."""
4876 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
4877 __repr__ = _swig_repr
4879 def __init__(self, *args):
4881 __init__(_ParticleAdaptor self) -> _ParticleAdaptor
4882 __init__(_ParticleAdaptor self, Particle p) -> _ParticleAdaptor
4883 __init__(_ParticleAdaptor self, Decorator d) -> _ParticleAdaptor
4885 _IMP_kernel._ParticleAdaptor_swiginit(self, _IMP_kernel.new__ParticleAdaptor(*args))
4887 def get_model(self):
4888 r"""get_model(_ParticleAdaptor self) -> Model"""
4889 return _IMP_kernel._ParticleAdaptor_get_model(self)
4891 def get_particle_index(self):
4892 r"""get_particle_index(_ParticleAdaptor self) -> ParticleIndex"""
4893 return _IMP_kernel._ParticleAdaptor_get_particle_index(self)
4894 __swig_destroy__ = _IMP_kernel.delete__ParticleAdaptor
4897 _IMP_kernel._ParticleAdaptor_swigregister(_ParticleAdaptor)
4898 class _DependencyGraphVertexIndex(object):
4899 r"""Proxy of C++ IMP::DependencyGraphVertexIndex class."""
4901 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
4902 __repr__ = _swig_repr
4905 r"""__init__(_DependencyGraphVertexIndex self) -> _DependencyGraphVertexIndex"""
4906 _IMP_kernel._DependencyGraphVertexIndex_swiginit(self, _IMP_kernel.new__DependencyGraphVertexIndex())
4907 __swig_destroy__ = _IMP_kernel.delete__DependencyGraphVertexIndex
4910 _IMP_kernel._DependencyGraphVertexIndex_swigregister(_DependencyGraphVertexIndex)
4912 def show_as_graphviz(name, out):
4913 r"""show_as_graphviz(IMP::DependencyGraph const & name, TextOutput out)"""
4914 return _IMP_kernel.show_as_graphviz(name, out)
4916 def get_vertex_index(g):
4917 r"""get_vertex_index(IMP::DependencyGraph const & g) -> _DependencyGraphVertexIndex"""
4918 return _IMP_kernel.get_vertex_index(g)
4921 r"""get_dependency_graph(Model m) -> IMP::DependencyGraph"""
4922 return _IMP_kernel.get_dependency_graph(m)
4925 r"""get_pruned_dependency_graph(Model m) -> IMP::DependencyGraph"""
4926 return _IMP_kernel.get_pruned_dependency_graph(m)
4928 def get_dependent_particles(p, all, dg, index):
4929 r"""get_dependent_particles(ModelObject p, IMP::ModelObjectsTemp const & all, IMP::DependencyGraph const & dg, _DependencyGraphVertexIndex index) -> IMP::ParticlesTemp"""
4930 return _IMP_kernel.get_dependent_particles(p, all, dg, index)
4932 def get_required_score_states(*args):
4934 get_required_score_states(IMP::ModelObjectsTemp const & mos, IMP::ScoreStatesTemp exclude=IMP::ScoreStatesTemp()) -> IMP::ScoreStatesTemp
4935 get_required_score_states(ModelObject p, IMP::ModelObjectsTemp const & all, IMP::DependencyGraph const & dg, _DependencyGraphVertexIndex index) -> IMP::ScoreStatesTemp
4936 get_required_score_states(Model m, ParticleIndex pi) -> IMP::ScoreStatesTemp
4938 return _IMP_kernel.get_required_score_states(*args)
4940 r"""Proxy of C++ IMP::ScoringFunction class."""
4942 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
4944 def do_add_score_and_derivatives(self, sa, ss):
4945 r"""do_add_score_and_derivatives(ScoringFunction self, ScoreAccumulator sa, IMP::ScoreStatesTemp const & ss)"""
4946 return _IMP_kernel.ScoringFunction_do_add_score_and_derivatives(self, sa, ss)
4948 def do_add_score_and_derivatives_moved(self, sa, moved_pis, reset_pis, ss):
4949 r"""do_add_score_and_derivatives_moved(ScoringFunction self, ScoreAccumulator sa, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis, IMP::ScoreStatesTemp const & ss)"""
4950 return _IMP_kernel.ScoringFunction_do_add_score_and_derivatives_moved(self, sa, moved_pis, reset_pis, ss)
4952 def get_score_accumulator_if_below(self, deriv, max):
4953 r"""get_score_accumulator_if_below(ScoringFunction self, bool deriv, double max) -> ScoreAccumulator"""
4954 return _IMP_kernel.ScoringFunction_get_score_accumulator_if_below(self, deriv, max)
4956 def get_score_accumulator_if_good(self, deriv):
4957 r"""get_score_accumulator_if_good(ScoringFunction self, bool deriv) -> ScoreAccumulator"""
4958 return _IMP_kernel.ScoringFunction_get_score_accumulator_if_good(self, deriv)
4960 def get_score_accumulator(self, deriv):
4961 r"""get_score_accumulator(ScoringFunction self, bool deriv) -> ScoreAccumulator"""
4962 return _IMP_kernel.ScoringFunction_get_score_accumulator(self, deriv)
4964 def __init__(self, *args):
4966 __init__(ScoringFunction self, Model m, std::string name) -> ScoringFunction
4967 __init__(ScoringFunction self) -> ScoringFunction
4969 if self.__class__ == ScoringFunction:
4973 _IMP_kernel.ScoringFunction_swiginit(self, _IMP_kernel.new_ScoringFunction(_self, *args))
4975 if self.__class__ != ScoringFunction:
4976 _director_objects.register(self)
4981 def do_get_outputs(self):
4982 r"""do_get_outputs(ScoringFunction self) -> IMP::ModelObjectsTemp"""
4983 return _IMP_kernel.ScoringFunction_do_get_outputs(self)
4985 def evaluate(self, derivatives):
4986 r"""evaluate(ScoringFunction self, bool derivatives) -> double"""
4987 return _IMP_kernel.ScoringFunction_evaluate(self, derivatives)
4989 def evaluate_if_good(self, derivatives):
4990 r"""evaluate_if_good(ScoringFunction self, bool derivatives) -> double"""
4991 return _IMP_kernel.ScoringFunction_evaluate_if_good(self, derivatives)
4993 def evaluate_if_below(self, derivatives, max):
4994 r"""evaluate_if_below(ScoringFunction self, bool derivatives, double max) -> double"""
4995 return _IMP_kernel.ScoringFunction_evaluate_if_below(self, derivatives, max)
4997 def evaluate_moved(self, derivatives, moved_pis, reset_pis):
4998 r"""evaluate_moved(ScoringFunction self, bool derivatives, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis) -> double"""
4999 return _IMP_kernel.ScoringFunction_evaluate_moved(self, derivatives, moved_pis, reset_pis)
5001 def evaluate_moved_if_below(self, derivatives, moved_pis, reset_pis, max):
5002 r"""evaluate_moved_if_below(ScoringFunction self, bool derivatives, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis, double max) -> double"""
5003 return _IMP_kernel.ScoringFunction_evaluate_moved_if_below(self, derivatives, moved_pis, reset_pis, max)
5005 def evaluate_moved_if_good(self, derivatives, moved_pis, reset_pis):
5006 r"""evaluate_moved_if_good(ScoringFunction self, bool derivatives, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis) -> double"""
5007 return _IMP_kernel.ScoringFunction_evaluate_moved_if_good(self, derivatives, moved_pis, reset_pis)
5009 def get_had_good_score(self):
5010 r"""get_had_good_score(ScoringFunction self) -> bool"""
5011 return _IMP_kernel.ScoringFunction_get_had_good_score(self)
5013 def get_last_score(self):
5014 r"""get_last_score(ScoringFunction self) -> double"""
5015 return _IMP_kernel.ScoringFunction_get_last_score(self)
5018 r"""create_restraints(ScoringFunction self) -> IMP::Restraints"""
5019 return _IMP_kernel.ScoringFunction_create_restraints(self)
5022 r"""__str__(ScoringFunction self) -> std::string"""
5023 return _IMP_kernel.ScoringFunction___str__(self)
5026 r"""__repr__(ScoringFunction self) -> std::string"""
5027 return _IMP_kernel.ScoringFunction___repr__(self)
5031 return _object_cast_to_ScoringFunction(o)
5034 def do_show(self, out):
5039 return _object_cast_to_ScoringFunction(o)
5041 __swig_destroy__ = _IMP_kernel.delete_ScoringFunction
5042 def __disown__(self):
5044 _IMP_kernel.disown_ScoringFunction(self)
5045 return weakref.proxy(self)
5048 r"""do_destroy(ScoringFunction self)"""
5049 return _IMP_kernel.ScoringFunction_do_destroy(self)
5051 def handle_set_has_required_score_states(self, arg0):
5052 r"""handle_set_has_required_score_states(ScoringFunction self, bool arg0)"""
5053 return _IMP_kernel.ScoringFunction_handle_set_has_required_score_states(self, arg0)
5055 def do_get_inputs(self):
5056 r"""do_get_inputs(ScoringFunction self) -> IMP::ModelObjectsTemp"""
5057 return _IMP_kernel.ScoringFunction_do_get_inputs(self)
5059 def do_get_interactions(self):
5060 r"""do_get_interactions(ScoringFunction self) -> IMP::ModelObjectsTemps"""
5061 return _IMP_kernel.ScoringFunction_do_get_interactions(self)
5064 _IMP_kernel.ScoringFunction_swigregister(ScoringFunction)
5068 create_decomposition(IMP::RestraintsTemp const & rs) -> IMP::Restraints
5069 create_decomposition(ScoringFunction sf) -> IMP::ScoringFunctions
5071 return _IMP_kernel.create_decomposition(*args)
5072 class _ScoringFunctionAdaptor(_InputAdaptor):
5073 r"""Proxy of C++ IMP::ScoringFunctionAdaptor class."""
5075 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5076 __repr__ = _swig_repr
5078 def __init__(self, *args):
5080 __init__(_ScoringFunctionAdaptor self) -> _ScoringFunctionAdaptor
5081 __init__(_ScoringFunctionAdaptor self, ScoringFunction sf) -> _ScoringFunctionAdaptor
5082 __init__(_ScoringFunctionAdaptor self, IMP::RestraintsTemp const & sf) -> _ScoringFunctionAdaptor
5083 __init__(_ScoringFunctionAdaptor self, IMP::Restraints const & sf) -> _ScoringFunctionAdaptor
5084 __init__(_ScoringFunctionAdaptor self, Restraint sf) -> _ScoringFunctionAdaptor
5086 _IMP_kernel._ScoringFunctionAdaptor_swiginit(self, _IMP_kernel.new__ScoringFunctionAdaptor(*args))
5087 __swig_destroy__ = _IMP_kernel.delete__ScoringFunctionAdaptor
5090 _IMP_kernel._ScoringFunctionAdaptor_swigregister(_ScoringFunctionAdaptor)
5093 r"""show_restraint_hierarchy(_ScoringFunctionAdaptor rs, _ostream out=std::cout)"""
5094 return _IMP_kernel.show_restraint_hierarchy(*args)
5096 r"""Proxy of C++ IMP::Undecorator class."""
5098 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5100 def __init__(self, m, name):
5101 r"""__init__(Undecorator self, Model m, std::string name) -> Undecorator"""
5102 if self.__class__ == Undecorator:
5106 _IMP_kernel.Undecorator_swiginit(self, _IMP_kernel.new_Undecorator(_self, m, name))
5108 if self.__class__ != Undecorator:
5109 _director_objects.register(self)
5114 def teardown(self, pi):
5115 r"""teardown(Undecorator self, ParticleIndex pi)"""
5116 return _IMP_kernel.Undecorator_teardown(self, pi)
5119 r"""__str__(Undecorator self) -> std::string"""
5120 return _IMP_kernel.Undecorator___str__(self)
5123 r"""__repr__(Undecorator self) -> std::string"""
5124 return _IMP_kernel.Undecorator___repr__(self)
5128 return _object_cast_to_Undecorator(o)
5131 def do_show(self, out):
5136 return _object_cast_to_Undecorator(o)
5138 __swig_destroy__ = _IMP_kernel.delete_Undecorator
5139 def __disown__(self):
5141 _IMP_kernel.disown_Undecorator(self)
5142 return weakref.proxy(self)
5145 r"""do_destroy(Undecorator self)"""
5146 return _IMP_kernel.Undecorator_do_destroy(self)
5149 _IMP_kernel.Undecorator_swigregister(Undecorator)
5151 r"""Proxy of C++ IMP::Model class."""
5153 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5155 def __init__(self, *args):
5156 r"""__init__(Model self, std::string name="Model %1%") -> Model"""
5157 _IMP_kernel.Model_swiginit(self, _IMP_kernel.new_Model(*args))
5159 if self
not in _models_set:
5160 _models_set.add(self)
5165 def clear_particle_caches(self, pi):
5166 r"""clear_particle_caches(Model self, ParticleIndex pi)"""
5167 return _IMP_kernel.Model_clear_particle_caches(self, pi)
5170 r"""add_particle(Model self, std::string name) -> ParticleIndex"""
5171 return _IMP_kernel.Model_add_particle(self, name)
5173 def get_particle_name(self, pi):
5174 r"""get_particle_name(Model self, ParticleIndex pi) -> std::string"""
5175 return _IMP_kernel.Model_get_particle_name(self, pi)
5177 def add_undecorator(self, pi, d):
5178 r"""add_undecorator(Model self, ParticleIndex pi, Undecorator d)"""
5179 return _IMP_kernel.Model_add_undecorator(self, pi, d)
5181 def get_dependent_restraints_uncached(self, pi):
5182 r"""get_dependent_restraints_uncached(Model self, ParticleIndex pi) -> IMP::RestraintsTemp"""
5183 return _IMP_kernel.Model_get_dependent_restraints_uncached(self, pi)
5185 def get_dependent_particles_uncached(self, pi):
5186 r"""get_dependent_particles_uncached(Model self, ParticleIndex pi) -> IMP::ParticlesTemp"""
5187 return _IMP_kernel.Model_get_dependent_particles_uncached(self, pi)
5189 def get_dependent_score_states_uncached(self, pi):
5190 r"""get_dependent_score_states_uncached(Model self, ParticleIndex pi) -> IMP::ScoreStatesTemp"""
5191 return _IMP_kernel.Model_get_dependent_score_states_uncached(self, pi)
5192 def __get_score_states(self):
return _list_util.VarList(getdimfunc=self.get_number_of_score_states, getfunc=self.get_score_state, erasefunc=self.erase_score_state, appendfunc=self.add_score_state, extendfunc=self.add_score_states, clearfunc=self.clear_score_states, indexfunc=self._python_index_score_state)
5193 def __set_score_states(self, obj): _list_util.set_varlist(self.score_states, obj)
5194 def __del_score_states(self): _list_util.del_varlist(self.score_states)
5195 score_states = property(__get_score_states, __set_score_states, __del_score_states, doc=
"List of ##ucnames")
5197 def remove_score_state(self, d):
5198 r"""remove_score_state(Model self, ScoreState d)"""
5199 return _IMP_kernel.Model_remove_score_state(self, d)
5201 def _python_index_score_state(self, d, start, stop):
5202 r"""_python_index_score_state(Model self, ScoreState d, unsigned int start, unsigned int stop) -> unsigned int"""
5203 return _IMP_kernel.Model__python_index_score_state(self, d, start, stop)
5205 def remove_score_states(self, d):
5206 r"""remove_score_states(Model self, IMP::ScoreStates const & d)"""
5207 return _IMP_kernel.Model_remove_score_states(self, d)
5209 def set_score_states(self, ps):
5210 r"""set_score_states(Model self, IMP::ScoreStates const & ps)"""
5211 return _IMP_kernel.Model_set_score_states(self, ps)
5213 def set_score_states_order(self, objs):
5214 r"""set_score_states_order(Model self, IMP::ScoreStates const & objs)"""
5215 return _IMP_kernel.Model_set_score_states_order(self, objs)
5217 def add_score_state(self, obj):
5218 r"""add_score_state(Model self, ScoreState obj) -> unsigned int"""
5219 return _IMP_kernel.Model_add_score_state(self, obj)
5221 def add_score_states(self, objs):
5222 r"""add_score_states(Model self, IMP::ScoreStates const & objs)"""
5223 return _IMP_kernel.Model_add_score_states(self, objs)
5225 def clear_score_states(self):
5226 r"""clear_score_states(Model self)"""
5227 return _IMP_kernel.Model_clear_score_states(self)
5229 def get_number_of_score_states(self):
5230 r"""get_number_of_score_states(Model self) -> unsigned int"""
5231 return _IMP_kernel.Model_get_number_of_score_states(self)
5233 def get_has_score_states(self):
5234 r"""get_has_score_states(Model self) -> bool"""
5235 return _IMP_kernel.Model_get_has_score_states(self)
5237 def get_score_state(self, i):
5238 r"""get_score_state(Model self, unsigned int i) -> ScoreState"""
5239 return _IMP_kernel.Model_get_score_state(self, i)
5241 def get_score_states(self):
5242 r"""get_score_states(Model self) -> IMP::ScoreStates"""
5243 return _IMP_kernel.Model_get_score_states(self)
5245 def erase_score_state(self, i):
5246 r"""erase_score_state(Model self, unsigned int i)"""
5247 return _IMP_kernel.Model_erase_score_state(self, i)
5249 def reserve_score_states(self, sz):
5250 r"""reserve_score_states(Model self, unsigned int sz)"""
5251 return _IMP_kernel.Model_reserve_score_states(self, sz)
5254 r"""update(Model self)"""
5255 return _IMP_kernel.Model_update(self)
5257 def add_cache_attribute(self, *args):
5259 add_cache_attribute(Model self, FloatKey attribute_key, ParticleIndex particle, IMP::Float value)
5260 add_cache_attribute(Model self, IntKey attribute_key, ParticleIndex particle, IMP::Int value)
5261 add_cache_attribute(Model self, FloatsKey attribute_key, ParticleIndex particle, IMP::Floats value)
5262 add_cache_attribute(Model self, IntsKey attribute_key, ParticleIndex particle, IMP::Ints value)
5263 add_cache_attribute(Model self, StringKey attribute_key, ParticleIndex particle, IMP::String value)
5264 add_cache_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle, IMP::ParticleIndexes value)
5265 add_cache_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle, ParticleIndex value)
5266 add_cache_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle, Object value)
5267 add_cache_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle, Object value)
5269 return _IMP_kernel.Model_add_cache_attribute(self, *args)
5271 def add_attribute(self, *args):
5273 add_attribute(Model self, FloatKey attribute_key, ParticleIndex particle, IMP::Float value)
5274 add_attribute(Model self, IntKey attribute_key, ParticleIndex particle, IMP::Int value)
5275 add_attribute(Model self, FloatsKey attribute_key, ParticleIndex particle, IMP::Floats value)
5276 add_attribute(Model self, IntsKey attribute_key, ParticleIndex particle, IMP::Ints value)
5277 add_attribute(Model self, StringKey attribute_key, ParticleIndex particle, IMP::String value)
5278 add_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle, IMP::ParticleIndexes value)
5279 add_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle, ParticleIndex value)
5280 add_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle, Object value)
5281 add_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle, Object value)
5282 add_attribute(Model self, SparseStringKey attribute_key, ParticleIndex particle, IMP::String value)
5283 add_attribute(Model self, SparseIntKey attribute_key, ParticleIndex particle, IMP::Int value)
5284 add_attribute(Model self, SparseFloatKey attribute_key, ParticleIndex particle, IMP::Float value)
5285 add_attribute(Model self, SparseParticleIndexKey attribute_key, ParticleIndex particle, ParticleIndex value)
5287 return _IMP_kernel.Model_add_attribute(self, *args)
5289 def remove_attribute(self, *args):
5291 remove_attribute(Model self, FloatKey attribute_key, ParticleIndex particle)
5292 remove_attribute(Model self, IntKey attribute_key, ParticleIndex particle)
5293 remove_attribute(Model self, FloatsKey attribute_key, ParticleIndex particle)
5294 remove_attribute(Model self, IntsKey attribute_key, ParticleIndex particle)
5295 remove_attribute(Model self, StringKey attribute_key, ParticleIndex particle)
5296 remove_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle)
5297 remove_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle)
5298 remove_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle)
5299 remove_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle)
5300 remove_attribute(Model self, SparseStringKey attribute_key, ParticleIndex particle)
5301 remove_attribute(Model self, SparseIntKey attribute_key, ParticleIndex particle)
5302 remove_attribute(Model self, SparseFloatKey attribute_key, ParticleIndex particle)
5303 remove_attribute(Model self, SparseParticleIndexKey attribute_key, ParticleIndex particle)
5305 return _IMP_kernel.Model_remove_attribute(self, *args)
5307 def get_has_attribute(self, *args):
5309 get_has_attribute(Model self, FloatKey attribute_key, ParticleIndex particle) -> bool
5310 get_has_attribute(Model self, IntKey attribute_key, ParticleIndex particle) -> bool
5311 get_has_attribute(Model self, FloatsKey attribute_key, ParticleIndex particle) -> bool
5312 get_has_attribute(Model self, IntsKey attribute_key, ParticleIndex particle) -> bool
5313 get_has_attribute(Model self, StringKey attribute_key, ParticleIndex particle) -> bool
5314 get_has_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle) -> bool
5315 get_has_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle) -> bool
5316 get_has_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle) -> bool
5317 get_has_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle) -> bool
5318 get_has_attribute(Model self, SparseStringKey attribute_key, ParticleIndex particle) -> bool
5319 get_has_attribute(Model self, SparseIntKey attribute_key, ParticleIndex particle) -> bool
5320 get_has_attribute(Model self, SparseFloatKey attribute_key, ParticleIndex particle) -> bool
5321 get_has_attribute(Model self, SparseParticleIndexKey attribute_key, ParticleIndex particle) -> bool
5323 return _IMP_kernel.Model_get_has_attribute(self, *args)
5325 def set_attribute(self, *args):
5327 set_attribute(Model self, FloatKey attribute_key, ParticleIndex particle, IMP::Float value)
5328 set_attribute(Model self, IntKey attribute_key, ParticleIndex particle, IMP::Int value)
5329 set_attribute(Model self, FloatsKey attribute_key, ParticleIndex particle, IMP::Floats value)
5330 set_attribute(Model self, IntsKey attribute_key, ParticleIndex particle, IMP::Ints value)
5331 set_attribute(Model self, StringKey attribute_key, ParticleIndex particle, IMP::String value)
5332 set_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle, IMP::ParticleIndexes value)
5333 set_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle, ParticleIndex value)
5334 set_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle, Object value)
5335 set_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle, Object value)
5336 set_attribute(Model self, SparseStringKey attribute_key, ParticleIndex particle, IMP::String value)
5337 set_attribute(Model self, SparseIntKey attribute_key, ParticleIndex particle, IMP::Int value)
5338 set_attribute(Model self, SparseFloatKey attribute_key, ParticleIndex particle, IMP::Float value)
5339 set_attribute(Model self, SparseParticleIndexKey attribute_key, ParticleIndex particle, ParticleIndex value)
5341 return _IMP_kernel.Model_set_attribute(self, *args)
5343 def get_attribute(self, *args):
5345 get_attribute(Model self, FloatKey attribute_key, ParticleIndex particle) -> IMP::Float
5346 get_attribute(Model self, IntKey attribute_key, ParticleIndex particle) -> IMP::Int
5347 get_attribute(Model self, FloatsKey attribute_key, ParticleIndex particle) -> IMP::Floats
5348 get_attribute(Model self, IntsKey attribute_key, ParticleIndex particle) -> IMP::Ints
5349 get_attribute(Model self, StringKey attribute_key, ParticleIndex particle) -> IMP::String
5350 get_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle) -> IMP::ParticleIndexes
5351 get_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle) -> ParticleIndex
5352 get_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle) -> Object
5353 get_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle) -> Object
5354 get_attribute(Model self, SparseStringKey attribute_key, ParticleIndex particle) -> IMP::String
5355 get_attribute(Model self, SparseIntKey attribute_key, ParticleIndex particle) -> IMP::Int
5356 get_attribute(Model self, SparseFloatKey attribute_key, ParticleIndex particle) -> IMP::Float
5357 get_attribute(Model self, SparseParticleIndexKey attribute_key, ParticleIndex particle) -> ParticleIndex
5359 return _IMP_kernel.Model_get_attribute(self, *args)
5361 def set_is_optimized(self, arg2, arg3, arg4):
5362 r"""set_is_optimized(Model self, FloatKey arg2, ParticleIndex arg3, bool arg4)"""
5363 return _IMP_kernel.Model_set_is_optimized(self, arg2, arg3, arg4)
5365 def add_to_derivative(self, k, particle, v, da):
5366 r"""add_to_derivative(Model self, FloatKey k, ParticleIndex particle, double v, DerivativeAccumulator da)"""
5367 return _IMP_kernel.Model_add_to_derivative(self, k, particle, v, da)
5369 def get_particle(self, p):
5370 r"""get_particle(Model self, ParticleIndex p) -> Particle"""
5371 return _IMP_kernel.Model_get_particle(self, p)
5373 def get_has_particle(self, p):
5374 r"""get_has_particle(Model self, ParticleIndex p) -> bool"""
5375 return _IMP_kernel.Model_get_has_particle(self, p)
5378 r"""get_particle_indexes(Model self) -> IMP::ParticleIndexes"""
5379 return _IMP_kernel.Model_get_particle_indexes(self)
5381 def get_model_objects(self):
5382 r"""get_model_objects(Model self) -> IMP::ModelObjectsTemp"""
5383 return _IMP_kernel.Model_get_model_objects(self)
5385 def remove_particle(self, pi):
5386 r"""remove_particle(Model self, ParticleIndex pi)"""
5387 return _IMP_kernel.Model_remove_particle(self, pi)
5389 def add_data(self, mk, o):
5390 r"""add_data(Model self, ModelKey mk, Object o)"""
5391 return _IMP_kernel.Model_add_data(self, mk, o)
5393 def get_data(self, mk):
5394 r"""get_data(Model self, ModelKey mk) -> Object"""
5395 return _IMP_kernel.Model_get_data(self, mk)
5397 def remove_data(self, mk):
5398 r"""remove_data(Model self, ModelKey mk)"""
5399 return _IMP_kernel.Model_remove_data(self, mk)
5401 def get_has_data(self, mk):
5402 r"""get_has_data(Model self, ModelKey mk) -> bool"""
5403 return _IMP_kernel.Model_get_has_data(self, mk)
5406 r"""get_age(Model self) -> unsigned int"""
5407 return _IMP_kernel.Model_get_age(self)
5409 def get_trigger_last_updated(self, tk):
5410 r"""get_trigger_last_updated(Model self, TriggerKey tk) -> unsigned int"""
5411 return _IMP_kernel.Model_get_trigger_last_updated(self, tk)
5413 def set_trigger_updated(self, tk):
5414 r"""set_trigger_updated(Model self, TriggerKey tk)"""
5415 return _IMP_kernel.Model_set_trigger_updated(self, tk)
5417 def get_dependencies_updated(self):
5418 r"""get_dependencies_updated(Model self) -> unsigned int"""
5419 return _IMP_kernel.Model_get_dependencies_updated(self)
5421 def get_removed_particles_attributes_age(self):
5422 r"""get_removed_particles_attributes_age(Model self) -> unsigned int"""
5423 return _IMP_kernel.Model_get_removed_particles_attributes_age(self)
5425 def save_dependencies(self):
5426 r"""save_dependencies(Model self)"""
5427 return _IMP_kernel.Model_save_dependencies(self)
5429 def restore_dependencies(self):
5430 r"""restore_dependencies(Model self)"""
5431 return _IMP_kernel.Model_restore_dependencies(self)
5433 def get_particles_size(self):
5434 r"""get_particles_size(Model self) -> unsigned int"""
5435 return _IMP_kernel.Model_get_particles_size(self)
5437 def get_unique_id(self):
5438 r"""get_unique_id(Model self) -> uint32_t"""
5439 return _IMP_kernel.Model_get_unique_id(self)
5442 def get_by_unique_id(id):
5443 r"""get_by_unique_id(uint32_t id) -> Model"""
5444 return _IMP_kernel.Model_get_by_unique_id(id)
5447 r"""get_version_info(Model self) -> VersionInfo"""
5448 return _IMP_kernel.Model_get_version_info(self)
5449 __swig_destroy__ = _IMP_kernel.delete_Model
5451 r"""__del__(Model self)"""
5453 _director_objects.cleanup()
5460 r"""do_destroy(Model self)"""
5461 return _IMP_kernel.Model_do_destroy(self)
5464 r"""__str__(Model self) -> std::string"""
5465 return _IMP_kernel.Model___str__(self)
5468 r"""__repr__(Model self) -> std::string"""
5469 return _IMP_kernel.Model___repr__(self)
5473 return _object_cast_to_Model(o)
5476 def _get_as_binary(self):
5477 r"""_get_as_binary(Model self) -> PyObject *"""
5478 return _IMP_kernel.Model__get_as_binary(self)
5480 def _set_from_binary(self, p):
5481 r"""_set_from_binary(Model self, PyObject * p)"""
5482 return _IMP_kernel.Model__set_from_binary(self, p)
5484 def __getstate__(self):
5485 p = self._get_as_binary()
5486 if len(self.__dict__) > 1:
5487 d = self.__dict__.copy()
5492 def __setstate__(self, p):
5493 if not hasattr(self,
'this'):
5495 if isinstance(p, tuple):
5497 self.__dict__.update(d)
5498 return self._set_from_binary(p)
5502 """Get the model's attribute array for IntKey k as a NumPy array.
5503 The array is indexed by ParticleIndex; particles that don't have
5504 this attribute will either be off the end of the array or will have
5506 This is a NumPy view that shares memory with the Model. Thus,
5507 any changes to values in this list will be reflected in the Model.
5508 Also, if the Model attribute array moves in memory (e.g. if particles
5509 or attributes are added) this array will be invalidated, so it is
5510 unsafe to keep it around long term.
5512 return _get_ints_numpy(self, k, self)
5515 """Get the model's attribute array for FloatKey k as a NumPy array.
5516 See Model::get_ints_numpy() for more details."""
5517 return _get_floats_numpy(self, k, self)
5520 """Get the model's attribute derivatives array for FloatKey k
5521 as a NumPy array. See Model::get_ints_numpy() for more details."""
5522 return _get_derivatives_numpy(self, k, self)
5525 """Get the model's XYZR attribute arrays as NumPy arrays.
5526 The attribute arrays for Cartesian coordinates and radii are
5527 stored separately from those for other FloatKeys. This function
5528 returns a tuple of two NumPy arrays, the first of coordinates and
5529 the second of radii. See Model::get_ints_numpy() for more details."""
5530 return _get_spheres_numpy(self, self)
5533 """Get the model's XYZR attribute derivatives arrays as NumPy arrays.
5534 See Model::get_ints_numpy() for more details."""
5535 return _get_sphere_derivatives_numpy(self, self)
5539 _IMP_kernel.Model_swigregister(Model)
5541 r"""Proxy of C++ IMP::Decorator class."""
5543 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5544 __repr__ = _swig_repr
5546 def __init__(self, p):
5547 r"""__init__(Decorator self, _ParticleAdaptor p) -> Decorator"""
5548 _IMP_kernel.Decorator_swiginit(self, _IMP_kernel.new_Decorator(p))
5550 def __ne__(self, o):
5551 r"""__ne__(Decorator self, Object o) -> bool"""
5552 return _IMP_kernel.Decorator___ne__(self, o)
5554 def __lt__(self, o):
5555 r"""__lt__(Decorator self, Object o) -> bool"""
5556 return _IMP_kernel.Decorator___lt__(self, o)
5558 def __gt__(self, o):
5559 r"""__gt__(Decorator self, Object o) -> bool"""
5560 return _IMP_kernel.Decorator___gt__(self, o)
5562 def __ge__(self, o):
5563 r"""__ge__(Decorator self, Object o) -> bool"""
5564 return _IMP_kernel.Decorator___ge__(self, o)
5566 def __le__(self, o):
5567 r"""__le__(Decorator self, Object o) -> bool"""
5568 return _IMP_kernel.Decorator___le__(self, o)
5571 r"""get_particle(Decorator self) -> Particle"""
5572 return _IMP_kernel.Decorator_get_particle(self)
5574 def get_particle_index(self):
5575 r"""get_particle_index(Decorator self) -> ParticleIndex"""
5576 return _IMP_kernel.Decorator_get_particle_index(self)
5578 def get_model(self):
5579 m = _IMP_kernel.Decorator_get_model(self)
5580 if m
in _models_set:
5581 m = _models_set_get(m)
5586 def get_is_valid(self):
5587 r"""get_is_valid(Decorator self) -> bool"""
5588 return _IMP_kernel.Decorator_get_is_valid(self)
5591 r"""__hash__(Decorator self) -> std::size_t"""
5592 return _IMP_kernel.Decorator___hash__(self)
5594 def __eq__(self, *args):
5596 __eq__(Decorator self, Object o) -> bool
5597 __eq__(Decorator self, Decorator o) -> bool
5598 __eq__(Decorator self, Particle o) -> bool
5600 return _IMP_kernel.Decorator___eq__(self, *args)
5603 r"""__bool__(Decorator self) -> bool"""
5604 return _IMP_kernel.Decorator___bool__(self)
5605 __swig_destroy__ = _IMP_kernel.delete_Decorator
5608 _IMP_kernel.Decorator_swigregister(Decorator)
5610 def check_particle(m, pi):
5611 r"""check_particle(Model m, ParticleIndex pi)"""
5612 return _IMP_kernel.check_particle(m, pi)
5614 r"""Proxy of C++ IMP::UnaryFunction class."""
5616 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5618 def __init__(self, *args):
5619 r"""__init__(UnaryFunction self, std::string name="UnaryFunction%1%") -> UnaryFunction"""
5620 if self.__class__ == UnaryFunction:
5624 _IMP_kernel.UnaryFunction_swiginit(self, _IMP_kernel.new_UnaryFunction(_self, *args))
5626 if self.__class__ != UnaryFunction:
5627 _director_objects.register(self)
5632 def evaluate(self, feature):
5633 r"""evaluate(UnaryFunction self, double feature) -> double"""
5634 return _IMP_kernel.UnaryFunction_evaluate(self, feature)
5636 def evaluate_with_derivative(self, feature):
5637 r"""evaluate_with_derivative(UnaryFunction self, double feature) -> IMP::DerivativePair"""
5638 return _IMP_kernel.UnaryFunction_evaluate_with_derivative(self, feature)
5639 __swig_destroy__ = _IMP_kernel.delete_UnaryFunction
5642 r"""__str__(UnaryFunction self) -> std::string"""
5643 return _IMP_kernel.UnaryFunction___str__(self)
5646 r"""__repr__(UnaryFunction self) -> std::string"""
5647 return _IMP_kernel.UnaryFunction___repr__(self)
5651 return _object_cast_to_UnaryFunction(o)
5654 def do_show(self, out):
5659 return _object_cast_to_UnaryFunction(o)
5661 def __disown__(self):
5663 _IMP_kernel.disown_UnaryFunction(self)
5664 return weakref.proxy(self)
5667 r"""do_destroy(UnaryFunction self)"""
5668 return _IMP_kernel.UnaryFunction_do_destroy(self)
5671 _IMP_kernel.UnaryFunction_swigregister(UnaryFunction)
5673 r"""Proxy of C++ IMP::OptimizerState class."""
5675 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5677 def __init__(self, *args):
5679 __init__(OptimizerState self, Model m, std::string name) -> OptimizerState
5680 __init__(OptimizerState self) -> OptimizerState
5682 if self.__class__ == OptimizerState:
5686 _IMP_kernel.OptimizerState_swiginit(self, _IMP_kernel.new_OptimizerState(_self, *args))
5688 if self.__class__ != OptimizerState:
5689 _director_objects.register(self)
5695 r"""update(OptimizerState self)"""
5696 return _IMP_kernel.OptimizerState_update(self)
5698 def set_is_optimizing(self, arg0):
5699 r"""set_is_optimizing(OptimizerState self, bool arg0)"""
5700 return _IMP_kernel.OptimizerState_set_is_optimizing(self, arg0)
5702 def get_optimizer(self):
5703 r"""get_optimizer(OptimizerState self) -> Optimizer"""
5704 return _IMP_kernel.OptimizerState_get_optimizer(self)
5706 def set_period(self, p):
5707 r"""set_period(OptimizerState self, unsigned int p)"""
5708 return _IMP_kernel.OptimizerState_set_period(self, p)
5710 def get_period(self):
5711 r"""get_period(OptimizerState self) -> unsigned int"""
5712 return _IMP_kernel.OptimizerState_get_period(self)
5715 r"""reset(OptimizerState self)"""
5716 return _IMP_kernel.OptimizerState_reset(self)
5718 def update_always(self):
5719 r"""update_always(OptimizerState self)"""
5720 return _IMP_kernel.OptimizerState_update_always(self)
5722 def get_number_of_updates(self):
5723 r"""get_number_of_updates(OptimizerState self) -> unsigned int"""
5724 return _IMP_kernel.OptimizerState_get_number_of_updates(self)
5726 def set_number_of_updates(self, n):
5727 r"""set_number_of_updates(OptimizerState self, unsigned int n)"""
5728 return _IMP_kernel.OptimizerState_set_number_of_updates(self, n)
5729 __swig_destroy__ = _IMP_kernel.delete_OptimizerState
5731 def do_update(self, arg0):
5732 r"""do_update(OptimizerState self, unsigned int arg0)"""
5733 return _IMP_kernel.OptimizerState_do_update(self, arg0)
5735 def do_set_is_optimizing(self, arg0):
5736 r"""do_set_is_optimizing(OptimizerState self, bool arg0)"""
5737 return _IMP_kernel.OptimizerState_do_set_is_optimizing(self, arg0)
5739 def do_get_inputs(self):
5740 r"""do_get_inputs(OptimizerState self) -> IMP::ModelObjectsTemp"""
5741 return _IMP_kernel.OptimizerState_do_get_inputs(self)
5743 def do_get_outputs(self):
5744 r"""do_get_outputs(OptimizerState self) -> IMP::ModelObjectsTemp"""
5745 return _IMP_kernel.OptimizerState_do_get_outputs(self)
5748 r"""__str__(OptimizerState self) -> std::string"""
5749 return _IMP_kernel.OptimizerState___str__(self)
5752 r"""__repr__(OptimizerState self) -> std::string"""
5753 return _IMP_kernel.OptimizerState___repr__(self)
5757 return _object_cast_to_OptimizerState(o)
5760 def do_show(self, out):
5765 return _object_cast_to_OptimizerState(o)
5767 def __disown__(self):
5769 _IMP_kernel.disown_OptimizerState(self)
5770 return weakref.proxy(self)
5773 r"""do_destroy(OptimizerState self)"""
5774 return _IMP_kernel.OptimizerState_do_destroy(self)
5776 def handle_set_has_required_score_states(self, arg0):
5777 r"""handle_set_has_required_score_states(OptimizerState self, bool arg0)"""
5778 return _IMP_kernel.OptimizerState_handle_set_has_required_score_states(self, arg0)
5780 def do_get_interactions(self):
5781 r"""do_get_interactions(OptimizerState self) -> IMP::ModelObjectsTemps"""
5782 return _IMP_kernel.OptimizerState_do_get_interactions(self)
5785 _IMP_kernel.OptimizerState_swigregister(OptimizerState)
5787 r"""Proxy of C++ IMP::Refiner class."""
5789 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5791 def __init__(self, *args):
5792 r"""__init__(Refiner self, std::string name="Refiner %1%", bool is_by_ref=False) -> Refiner"""
5793 if self.__class__ == Refiner:
5797 _IMP_kernel.Refiner_swiginit(self, _IMP_kernel.new_Refiner(_self, *args))
5799 if self.__class__ != Refiner:
5800 _director_objects.register(self)
5805 def get_can_refine(self, arg0):
5806 r"""get_can_refine(Refiner self, Particle arg0) -> bool"""
5807 return _IMP_kernel.Refiner_get_can_refine(self, arg0)
5809 def get_refined_indexes(self, m, pi):
5810 r"""get_refined_indexes(Refiner self, Model m, ParticleIndex pi) -> IMP::ParticleIndexes"""
5811 return _IMP_kernel.Refiner_get_refined_indexes(self, m, pi)
5813 def get_refined_indexes_by_ref(self, m, pi):
5814 r"""get_refined_indexes_by_ref(Refiner self, Model m, ParticleIndex pi) -> IMP::ParticleIndexes const &"""
5815 return _IMP_kernel.Refiner_get_refined_indexes_by_ref(self, m, pi)
5817 def get_is_by_ref_supported(self):
5818 r"""get_is_by_ref_supported(Refiner self) -> bool"""
5819 return _IMP_kernel.Refiner_get_is_by_ref_supported(self)
5821 def get_refined(self, *args):
5823 get_refined(Refiner self, Particle a) -> IMP::ParticlesTemp const
5824 get_refined(Refiner self, Particle a, unsigned int i) -> Particle
5826 return _IMP_kernel.Refiner_get_refined(self, *args)
5828 def get_number_of_refined(self, a):
5829 r"""get_number_of_refined(Refiner self, Particle a) -> unsigned int"""
5830 return _IMP_kernel.Refiner_get_number_of_refined(self, a)
5833 r"""__str__(Refiner self) -> std::string"""
5834 return _IMP_kernel.Refiner___str__(self)
5837 r"""__repr__(Refiner self) -> std::string"""
5838 return _IMP_kernel.Refiner___repr__(self)
5842 return _object_cast_to_Refiner(o)
5845 def do_show(self, out):
5850 return _object_cast_to_Refiner(o)
5852 __swig_destroy__ = _IMP_kernel.delete_Refiner
5853 def __disown__(self):
5855 _IMP_kernel.disown_Refiner(self)
5856 return weakref.proxy(self)
5858 def do_get_inputs(self, m, pis):
5859 r"""do_get_inputs(Refiner self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
5860 return _IMP_kernel.Refiner_do_get_inputs(self, m, pis)
5863 r"""do_destroy(Refiner self)"""
5864 return _IMP_kernel.Refiner_do_destroy(self)
5867 _IMP_kernel.Refiner_swigregister(Refiner)
5869 r"""Proxy of C++ IMP::Optimizer class."""
5871 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5873 def set_is_optimizing_states(self, tf):
5874 r"""set_is_optimizing_states(Optimizer self, bool tf)"""
5875 return _IMP_kernel.Optimizer_set_is_optimizing_states(self, tf)
5877 def get_optimizer_state_inputs(self):
5878 r"""get_optimizer_state_inputs(Optimizer self) -> IMP::ModelObjectsTemp"""
5879 return _IMP_kernel.Optimizer_get_optimizer_state_inputs(self)
5881 def do_get_inputs(self):
5882 r"""do_get_inputs(Optimizer self) -> IMP::ModelObjectsTemp"""
5883 return _IMP_kernel.Optimizer_do_get_inputs(self)
5885 def do_get_outputs(self):
5886 r"""do_get_outputs(Optimizer self) -> IMP::ModelObjectsTemp"""
5887 return _IMP_kernel.Optimizer_do_get_outputs(self)
5889 def __init__(self, *args):
5891 __init__(Optimizer self, Model m, std::string name="Optimizer %1%") -> Optimizer
5892 __init__(Optimizer self) -> Optimizer
5894 if self.__class__ == Optimizer:
5898 _IMP_kernel.Optimizer_swiginit(self, _IMP_kernel.new_Optimizer(_self, *args))
5900 if self.__class__ != Optimizer:
5901 _director_objects.register(self)
5906 def optimize(self, max_steps):
5907 r"""optimize(Optimizer self, unsigned int max_steps) -> double"""
5908 return _IMP_kernel.Optimizer_optimize(self, max_steps)
5910 def set_stop_on_good_score(self, tf):
5911 r"""set_stop_on_good_score(Optimizer self, bool tf)"""
5912 return _IMP_kernel.Optimizer_set_stop_on_good_score(self, tf)
5914 def get_stop_on_good_score(self):
5915 r"""get_stop_on_good_score(Optimizer self) -> bool"""
5916 return _IMP_kernel.Optimizer_get_stop_on_good_score(self)
5918 def get_last_score(self):
5919 r"""get_last_score(Optimizer self) -> double"""
5920 return _IMP_kernel.Optimizer_get_last_score(self)
5922 def get_scoring_function(self):
5923 r"""get_scoring_function(Optimizer self) -> ScoringFunction"""
5924 return _IMP_kernel.Optimizer_get_scoring_function(self)
5925 def __get_optimizer_states(self):
return _list_util.VarList(getdimfunc=self.get_number_of_optimizer_states, getfunc=self.get_optimizer_state, erasefunc=self.erase_optimizer_state, appendfunc=self.add_optimizer_state, extendfunc=self.add_optimizer_states, clearfunc=self.clear_optimizer_states, indexfunc=self._python_index_optimizer_state)
5926 def __set_optimizer_states(self, obj): _list_util.set_varlist(self.optimizer_states, obj)
5927 def __del_optimizer_states(self): _list_util.del_varlist(self.optimizer_states)
5928 optimizer_states = property(__get_optimizer_states, __set_optimizer_states, __del_optimizer_states, doc=
"List of ##ucnames")
5930 def remove_optimizer_state(self, d):
5931 r"""remove_optimizer_state(Optimizer self, OptimizerState d)"""
5932 return _IMP_kernel.Optimizer_remove_optimizer_state(self, d)
5934 def _python_index_optimizer_state(self, d, start, stop):
5935 r"""_python_index_optimizer_state(Optimizer self, OptimizerState d, unsigned int start, unsigned int stop) -> unsigned int"""
5936 return _IMP_kernel.Optimizer__python_index_optimizer_state(self, d, start, stop)
5938 def remove_optimizer_states(self, d):
5939 r"""remove_optimizer_states(Optimizer self, IMP::OptimizerStates const & d)"""
5940 return _IMP_kernel.Optimizer_remove_optimizer_states(self, d)
5942 def set_optimizer_states(self, ps):
5943 r"""set_optimizer_states(Optimizer self, IMP::OptimizerStates const & ps)"""
5944 return _IMP_kernel.Optimizer_set_optimizer_states(self, ps)
5946 def set_optimizer_states_order(self, objs):
5947 r"""set_optimizer_states_order(Optimizer self, IMP::OptimizerStates const & objs)"""
5948 return _IMP_kernel.Optimizer_set_optimizer_states_order(self, objs)
5950 def add_optimizer_state(self, obj):
5951 r"""add_optimizer_state(Optimizer self, OptimizerState obj) -> unsigned int"""
5952 return _IMP_kernel.Optimizer_add_optimizer_state(self, obj)
5954 def add_optimizer_states(self, objs):
5955 r"""add_optimizer_states(Optimizer self, IMP::OptimizerStates const & objs)"""
5956 return _IMP_kernel.Optimizer_add_optimizer_states(self, objs)
5958 def clear_optimizer_states(self):
5959 r"""clear_optimizer_states(Optimizer self)"""
5960 return _IMP_kernel.Optimizer_clear_optimizer_states(self)
5962 def get_number_of_optimizer_states(self):
5963 r"""get_number_of_optimizer_states(Optimizer self) -> unsigned int"""
5964 return _IMP_kernel.Optimizer_get_number_of_optimizer_states(self)
5966 def get_has_optimizer_states(self):
5967 r"""get_has_optimizer_states(Optimizer self) -> bool"""
5968 return _IMP_kernel.Optimizer_get_has_optimizer_states(self)
5970 def get_optimizer_state(self, i):
5971 r"""get_optimizer_state(Optimizer self, unsigned int i) -> OptimizerState"""
5972 return _IMP_kernel.Optimizer_get_optimizer_state(self, i)
5974 def get_optimizer_states(self):
5975 r"""get_optimizer_states(Optimizer self) -> IMP::OptimizerStates"""
5976 return _IMP_kernel.Optimizer_get_optimizer_states(self)
5978 def erase_optimizer_state(self, i):
5979 r"""erase_optimizer_state(Optimizer self, unsigned int i)"""
5980 return _IMP_kernel.Optimizer_erase_optimizer_state(self, i)
5982 def reserve_optimizer_states(self, sz):
5983 r"""reserve_optimizer_states(Optimizer self, unsigned int sz)"""
5984 return _IMP_kernel.Optimizer_reserve_optimizer_states(self, sz)
5986 def set_scoring_function(self, sf):
5987 r"""set_scoring_function(Optimizer self, _ScoringFunctionAdaptor sf)"""
5988 return _IMP_kernel.Optimizer_set_scoring_function(self, sf)
5989 __swig_destroy__ = _IMP_kernel.delete_Optimizer
5991 r"""__del__(Optimizer self)"""
5993 _director_objects.cleanup()
5999 def do_optimize(self, ns):
6000 r"""do_optimize(Optimizer self, unsigned int ns) -> double"""
6001 return _IMP_kernel.Optimizer_do_optimize(self, ns)
6003 def update_states(self):
6004 r"""update_states(Optimizer self)"""
6005 return _IMP_kernel.Optimizer_update_states(self)
6008 r"""__str__(Optimizer self) -> std::string"""
6009 return _IMP_kernel.Optimizer___str__(self)
6012 r"""__repr__(Optimizer self) -> std::string"""
6013 return _IMP_kernel.Optimizer___repr__(self)
6017 return _object_cast_to_Optimizer(o)
6020 def do_show(self, out):
6025 return _object_cast_to_Optimizer(o)
6027 def __disown__(self):
6029 _IMP_kernel.disown_Optimizer(self)
6030 return weakref.proxy(self)
6033 r"""do_destroy(Optimizer self)"""
6034 return _IMP_kernel.Optimizer_do_destroy(self)
6036 def handle_set_has_required_score_states(self, arg0):
6037 r"""handle_set_has_required_score_states(Optimizer self, bool arg0)"""
6038 return _IMP_kernel.Optimizer_handle_set_has_required_score_states(self, arg0)
6040 def do_get_interactions(self):
6041 r"""do_get_interactions(Optimizer self) -> IMP::ModelObjectsTemps"""
6042 return _IMP_kernel.Optimizer_do_get_interactions(self)
6045 _IMP_kernel.Optimizer_swigregister(Optimizer)
6047 r"""Proxy of C++ IMP::AttributeOptimizer class."""
6049 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
6051 def __init__(self, *args):
6053 __init__(AttributeOptimizer self, Model m, std::string name="Optimizer %1%") -> AttributeOptimizer
6054 __init__(AttributeOptimizer self) -> AttributeOptimizer
6056 if self.__class__ == AttributeOptimizer:
6060 _IMP_kernel.AttributeOptimizer_swiginit(self, _IMP_kernel.new_AttributeOptimizer(_self, *args))
6062 if self.__class__ != AttributeOptimizer:
6063 _director_objects.register(self)
6068 def get_optimized_attributes(self):
6069 r"""get_optimized_attributes(AttributeOptimizer self) -> IMP::FloatIndexes"""
6070 return _IMP_kernel.AttributeOptimizer_get_optimized_attributes(self)
6072 def set_value(self, fi, v):
6073 r"""set_value(AttributeOptimizer self, FloatIndex fi, double v)"""
6074 return _IMP_kernel.AttributeOptimizer_set_value(self, fi, v)
6076 def get_value(self, fi):
6077 r"""get_value(AttributeOptimizer self, FloatIndex fi) -> IMP::Float"""
6078 return _IMP_kernel.AttributeOptimizer_get_value(self, fi)
6080 def get_derivative(self, fi):
6081 r"""get_derivative(AttributeOptimizer self, FloatIndex fi) -> IMP::Float"""
6082 return _IMP_kernel.AttributeOptimizer_get_derivative(self, fi)
6084 def get_width(self, k):
6085 r"""get_width(AttributeOptimizer self, FloatKey k) -> double"""
6086 return _IMP_kernel.AttributeOptimizer_get_width(self, k)
6088 def set_scaled_value(self, fi, v):
6089 r"""set_scaled_value(AttributeOptimizer self, FloatIndex fi, IMP::Float v)"""
6090 return _IMP_kernel.AttributeOptimizer_set_scaled_value(self, fi, v)
6092 def get_scaled_value(self, fi):
6093 r"""get_scaled_value(AttributeOptimizer self, FloatIndex fi) -> double"""
6094 return _IMP_kernel.AttributeOptimizer_get_scaled_value(self, fi)
6096 def get_scaled_derivative(self, fi):
6097 r"""get_scaled_derivative(AttributeOptimizer self, FloatIndex fi) -> double"""
6098 return _IMP_kernel.AttributeOptimizer_get_scaled_derivative(self, fi)
6100 def clear_range_cache(self):
6101 r"""clear_range_cache(AttributeOptimizer self)"""
6102 return _IMP_kernel.AttributeOptimizer_clear_range_cache(self)
6105 r"""__str__(AttributeOptimizer self) -> std::string"""
6106 return _IMP_kernel.AttributeOptimizer___str__(self)
6109 r"""__repr__(AttributeOptimizer self) -> std::string"""
6110 return _IMP_kernel.AttributeOptimizer___repr__(self)
6114 return _object_cast_to_AttributeOptimizer(o)
6117 def do_show(self, out):
6122 return _object_cast_to_AttributeOptimizer(o)
6124 __swig_destroy__ = _IMP_kernel.delete_AttributeOptimizer
6125 def __disown__(self):
6127 _IMP_kernel.disown_AttributeOptimizer(self)
6128 return weakref.proxy(self)
6131 r"""do_destroy(AttributeOptimizer self)"""
6132 return _IMP_kernel.AttributeOptimizer_do_destroy(self)
6134 def handle_set_has_required_score_states(self, arg0):
6135 r"""handle_set_has_required_score_states(AttributeOptimizer self, bool arg0)"""
6136 return _IMP_kernel.AttributeOptimizer_handle_set_has_required_score_states(self, arg0)
6138 def do_get_inputs(self):
6139 r"""do_get_inputs(AttributeOptimizer self) -> IMP::ModelObjectsTemp"""
6140 return _IMP_kernel.AttributeOptimizer_do_get_inputs(self)
6142 def do_get_outputs(self):
6143 r"""do_get_outputs(AttributeOptimizer self) -> IMP::ModelObjectsTemp"""
6144 return _IMP_kernel.AttributeOptimizer_do_get_outputs(self)
6146 def do_get_interactions(self):
6147 r"""do_get_interactions(AttributeOptimizer self) -> IMP::ModelObjectsTemps"""
6148 return _IMP_kernel.AttributeOptimizer_do_get_interactions(self)
6150 def do_optimize(self, ns):
6151 r"""do_optimize(AttributeOptimizer self, unsigned int ns) -> double"""
6152 return _IMP_kernel.AttributeOptimizer_do_optimize(self, ns)
6155 _IMP_kernel.AttributeOptimizer_swigregister(AttributeOptimizer)
6157 r"""Proxy of C++ IMP::ConfigurationSet class."""
6159 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
6161 def __init__(self, *args):
6162 r"""__init__(ConfigurationSet self, Model m, std::string name="ConfigurationSet %1%") -> ConfigurationSet"""
6163 _IMP_kernel.ConfigurationSet_swiginit(self, _IMP_kernel.new_ConfigurationSet(*args))
6165 def save_configuration(self):
6166 r"""save_configuration(ConfigurationSet self)"""
6167 return _IMP_kernel.ConfigurationSet_save_configuration(self)
6169 def get_number_of_configurations(self):
6170 r"""get_number_of_configurations(ConfigurationSet self) -> unsigned int"""
6171 return _IMP_kernel.ConfigurationSet_get_number_of_configurations(self)
6173 def load_configuration(self, i):
6174 r"""load_configuration(ConfigurationSet self, int i)"""
6175 return _IMP_kernel.ConfigurationSet_load_configuration(self, i)
6177 def remove_configuration(self, i):
6178 r"""remove_configuration(ConfigurationSet self, unsigned int i)"""
6179 return _IMP_kernel.ConfigurationSet_remove_configuration(self, i)
6181 def get_model(self):
6182 r"""get_model(ConfigurationSet self) -> Model"""
6183 return _IMP_kernel.ConfigurationSet_get_model(self)
6186 r"""get_version_info(ConfigurationSet self) -> VersionInfo"""
6187 return _IMP_kernel.ConfigurationSet_get_version_info(self)
6188 __swig_destroy__ = _IMP_kernel.delete_ConfigurationSet
6191 r"""__str__(ConfigurationSet self) -> std::string"""
6192 return _IMP_kernel.ConfigurationSet___str__(self)
6195 r"""__repr__(ConfigurationSet self) -> std::string"""
6196 return _IMP_kernel.ConfigurationSet___repr__(self)
6200 return _object_cast_to_ConfigurationSet(o)
6204 _IMP_kernel.ConfigurationSet_swigregister(ConfigurationSet)
6206 r"""Proxy of C++ IMP::SaveToConfigurationSetOptimizerState class."""
6208 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
6210 def __init__(self, cs):
6211 r"""__init__(SaveToConfigurationSetOptimizerState self, ConfigurationSet cs) -> SaveToConfigurationSetOptimizerState"""
6212 _IMP_kernel.SaveToConfigurationSetOptimizerState_swiginit(self, _IMP_kernel.new_SaveToConfigurationSetOptimizerState(cs))
6215 r"""get_version_info(SaveToConfigurationSetOptimizerState self) -> VersionInfo"""
6216 return _IMP_kernel.SaveToConfigurationSetOptimizerState_get_version_info(self)
6217 __swig_destroy__ = _IMP_kernel.delete_SaveToConfigurationSetOptimizerState
6220 r"""__str__(SaveToConfigurationSetOptimizerState self) -> std::string"""
6221 return _IMP_kernel.SaveToConfigurationSetOptimizerState___str__(self)
6224 r"""__repr__(SaveToConfigurationSetOptimizerState self) -> std::string"""
6225 return _IMP_kernel.SaveToConfigurationSetOptimizerState___repr__(self)
6229 return _object_cast_to_SaveToConfigurationSetOptimizerState(o)
6233 _IMP_kernel.SaveToConfigurationSetOptimizerState_swigregister(SaveToConfigurationSetOptimizerState)
6235 r"""Proxy of C++ IMP::Configuration class."""
6237 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
6239 def __init__(self, *args):
6241 __init__(Configuration self, Model m, std::string name="Configuration %1%") -> Configuration
6242 __init__(Configuration self, Model m, Configuration base, std::string name="Configuration %1%") -> Configuration
6244 _IMP_kernel.Configuration_swiginit(self, _IMP_kernel.new_Configuration(*args))
6246 def load_configuration(self):
6247 r"""load_configuration(Configuration self)"""
6248 return _IMP_kernel.Configuration_load_configuration(self)
6250 def swap_configuration(self):
6251 r"""swap_configuration(Configuration self)"""
6252 return _IMP_kernel.Configuration_swap_configuration(self)
6255 r"""get_version_info(Configuration self) -> VersionInfo"""
6256 return _IMP_kernel.Configuration_get_version_info(self)
6257 __swig_destroy__ = _IMP_kernel.delete_Configuration
6260 r"""__str__(Configuration self) -> std::string"""
6261 return _IMP_kernel.Configuration___str__(self)
6264 r"""__repr__(Configuration self) -> std::string"""
6265 return _IMP_kernel.Configuration___repr__(self)
6269 return _object_cast_to_Configuration(o)
6273 _IMP_kernel.Configuration_swigregister(Configuration)
6275 r"""Proxy of C++ IMP::Sampler class."""
6277 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
6279 def __init__(self, *args):
6280 r"""__init__(Sampler self, Model m, std::string name="Sampler %1%") -> Sampler"""
6281 if self.__class__ == Sampler:
6285 _IMP_kernel.Sampler_swiginit(self, _IMP_kernel.new_Sampler(_self, *args))
6287 if self.__class__ != Sampler:
6288 _director_objects.register(self)
6293 def create_sample(self):
6294 r"""create_sample(Sampler self) -> ConfigurationSet"""
6295 return _IMP_kernel.Sampler_create_sample(self)
6297 def get_scoring_function(self):
6298 r"""get_scoring_function(Sampler self) -> ScoringFunction"""
6299 return _IMP_kernel.Sampler_get_scoring_function(self)
6301 def set_scoring_function(self, sf):
6302 r"""set_scoring_function(Sampler self, _ScoringFunctionAdaptor sf)"""
6303 return _IMP_kernel.Sampler_set_scoring_function(self, sf)
6305 def get_model(self):
6306 r"""get_model(Sampler self) -> Model"""
6307 return _IMP_kernel.Sampler_get_model(self)
6309 def do_sample(self):
6310 r"""do_sample(Sampler self) -> ConfigurationSet"""
6311 return _IMP_kernel.Sampler_do_sample(self)
6312 __swig_destroy__ = _IMP_kernel.delete_Sampler
6315 r"""__str__(Sampler self) -> std::string"""
6316 return _IMP_kernel.Sampler___str__(self)
6319 r"""__repr__(Sampler self) -> std::string"""
6320 return _IMP_kernel.Sampler___repr__(self)
6324 return _object_cast_to_Sampler(o)
6327 def do_show(self, out):
6332 return _object_cast_to_Sampler(o)
6334 def __disown__(self):
6336 _IMP_kernel.disown_Sampler(self)
6337 return weakref.proxy(self)
6340 r"""do_destroy(Sampler self)"""
6341 return _IMP_kernel.Sampler_do_destroy(self)
6344 _IMP_kernel.Sampler_swigregister(Sampler)
6346 r"""Proxy of C++ IMP::PairModifier class."""
6348 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
6350 def __init__(self, *args):
6351 r"""__init__(PairModifier self, std::string name="PairModifier %1%") -> PairModifier"""
6352 if self.__class__ == PairModifier:
6356 _IMP_kernel.PairModifier_swiginit(self, _IMP_kernel.new_PairModifier(_self, *args))
6358 if self.__class__ != PairModifier:
6359 _director_objects.register(self)
6364 def apply_index(self, m, v):
6365 r"""apply_index(PairModifier self, Model m, IMP::ParticleIndexPair const & v)"""
6366 return _IMP_kernel.PairModifier_apply_index(self, m, v)
6368 def apply_indexes(self, m, o, lower_bound, upper_bound):
6369 r"""apply_indexes(PairModifier self, Model m, IMP::ParticleIndexPairs const & o, unsigned int lower_bound, unsigned int upper_bound)"""
6370 return _IMP_kernel.PairModifier_apply_indexes(self, m, o, lower_bound, upper_bound)
6372 def apply_indexes_moved(self, m, o, lower_bound, upper_bound, moved_pis, reset_pis):
6373 r"""apply_indexes_moved(PairModifier self, Model m, IMP::ParticleIndexPairs const & o, unsigned int lower_bound, unsigned int upper_bound, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis)"""
6374 return _IMP_kernel.PairModifier_apply_indexes_moved(self, m, o, lower_bound, upper_bound, moved_pis, reset_pis)
6377 r"""__str__(PairModifier self) -> std::string"""
6378 return _IMP_kernel.PairModifier___str__(self)
6381 r"""__repr__(PairModifier self) -> std::string"""
6382 return _IMP_kernel.PairModifier___repr__(self)
6386 return _object_cast_to_PairModifier(o)
6389 def do_show(self, out):
6394 return _object_cast_to_PairModifier(o)
6396 __swig_destroy__ = _IMP_kernel.delete_PairModifier
6397 def __disown__(self):
6399 _IMP_kernel.disown_PairModifier(self)
6400 return weakref.proxy(self)
6402 def do_get_inputs(self, m, pis):
6403 r"""do_get_inputs(PairModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6404 return _IMP_kernel.PairModifier_do_get_inputs(self, m, pis)
6406 def do_get_outputs(self, m, pis):
6407 r"""do_get_outputs(PairModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6408 return _IMP_kernel.PairModifier_do_get_outputs(self, m, pis)
6411 r"""do_destroy(PairModifier self)"""
6412 return _IMP_kernel.PairModifier_do_destroy(self)
6415 _IMP_kernel.PairModifier_swigregister(PairModifier)
6417 r"""Proxy of C++ IMP::PairScore class."""
6419 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
6421 def __init__(self, *args):
6422 r"""__init__(PairScore self, std::string name="PairScore %1%") -> PairScore"""
6423 if self.__class__ == PairScore:
6427 _IMP_kernel.PairScore_swiginit(self, _IMP_kernel.new_PairScore(_self, *args))
6429 if self.__class__ != PairScore:
6430 _director_objects.register(self)
6435 def evaluate_index(self, m, vt, da):
6436 r"""evaluate_index(PairScore self, Model m, IMP::ParticleIndexPair const & vt, DerivativeAccumulator da) -> double"""
6437 return _IMP_kernel.PairScore_evaluate_index(self, m, vt, da)
6439 def check_indexes(self, m, pis):
6440 r"""check_indexes(PairScore self, Model m, IMP::ParticleIndexes const & pis) -> bool"""
6441 return _IMP_kernel.PairScore_check_indexes(self, m, pis)
6443 def evaluate_indexes(self, m, o, da, lower_bound, upper_bound, all_indexes_checked=False):
6444 r"""evaluate_indexes(PairScore self, Model m, IMP::ParticleIndexPairs const & o, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
6445 return _IMP_kernel.PairScore_evaluate_indexes(self, m, o, da, lower_bound, upper_bound, all_indexes_checked)
6447 def evaluate_indexes_scores(self, m, o, da, lower_bound, upper_bound, score, all_indexes_checked=False):
6448 r"""evaluate_indexes_scores(PairScore self, Model m, IMP::ParticleIndexPairs const & o, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
6449 return _IMP_kernel.PairScore_evaluate_indexes_scores(self, m, o, da, lower_bound, upper_bound, score, all_indexes_checked)
6451 def evaluate_indexes_delta(self, m, o, da, indexes, score, all_indexes_checked=False):
6452 r"""evaluate_indexes_delta(PairScore self, Model m, IMP::ParticleIndexPairs const & o, DerivativeAccumulator da, std::vector< unsigned int,std::allocator< unsigned int > > const & indexes, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
6453 return _IMP_kernel.PairScore_evaluate_indexes_delta(self, m, o, da, indexes, score, all_indexes_checked)
6455 def evaluate_if_good_index(self, m, vt, da, max):
6456 r"""evaluate_if_good_index(PairScore self, Model m, IMP::ParticleIndexPair const & vt, DerivativeAccumulator da, double max) -> double"""
6457 return _IMP_kernel.PairScore_evaluate_if_good_index(self, m, vt, da, max)
6459 def evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound, all_indexes_checked=False):
6460 r"""evaluate_if_good_indexes(PairScore self, Model m, IMP::ParticleIndexPairs const & o, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
6461 return _IMP_kernel.PairScore_evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound, all_indexes_checked)
6463 def create_current_decomposition(self, m, vt):
6464 r"""create_current_decomposition(PairScore self, Model m, IMP::ParticleIndexPair const & vt) -> IMP::Restraints"""
6465 return _IMP_kernel.PairScore_create_current_decomposition(self, m, vt)
6467 def do_create_current_decomposition(self, m, vt):
6468 r"""do_create_current_decomposition(PairScore self, Model m, IMP::ParticleIndexPair const & vt) -> IMP::Restraints"""
6469 return _IMP_kernel.PairScore_do_create_current_decomposition(self, m, vt)
6470 __swig_destroy__ = _IMP_kernel.delete_PairScore
6473 r"""__str__(PairScore self) -> std::string"""
6474 return _IMP_kernel.PairScore___str__(self)
6477 r"""__repr__(PairScore self) -> std::string"""
6478 return _IMP_kernel.PairScore___repr__(self)
6482 return _object_cast_to_PairScore(o)
6485 def do_show(self, out):
6490 return _object_cast_to_PairScore(o)
6492 def __disown__(self):
6494 _IMP_kernel.disown_PairScore(self)
6495 return weakref.proxy(self)
6497 def do_get_inputs(self, m, pis):
6498 r"""do_get_inputs(PairScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6499 return _IMP_kernel.PairScore_do_get_inputs(self, m, pis)
6502 r"""do_destroy(PairScore self)"""
6503 return _IMP_kernel.PairScore_do_destroy(self)
6506 _IMP_kernel.PairScore_swigregister(PairScore)
6508 r"""Proxy of C++ IMP::PairPredicate class."""
6510 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
6512 def __init__(self, *args):
6513 r"""__init__(PairPredicate self, std::string name="PairPredicate %1%") -> PairPredicate"""
6514 if self.__class__ == PairPredicate:
6518 _IMP_kernel.PairPredicate_swiginit(self, _IMP_kernel.new_PairPredicate(_self, *args))
6520 if self.__class__ != PairPredicate:
6521 _director_objects.register(self)
6526 def setup_for_get_value_index_in_batch(self, arg0):
6527 r"""setup_for_get_value_index_in_batch(PairPredicate self, Model arg0)"""
6528 return _IMP_kernel.PairPredicate_setup_for_get_value_index_in_batch(self, arg0)
6530 def get_value_index_in_batch(self, m, vt):
6531 r"""get_value_index_in_batch(PairPredicate self, Model m, IMP::ParticleIndexPair const & vt) -> int"""
6532 return _IMP_kernel.PairPredicate_get_value_index_in_batch(self, m, vt)
6534 def __call__(self, m, vt):
6535 r"""__call__(PairPredicate self, Model m, IMP::ParticleIndexPair const & vt) -> int"""
6536 return _IMP_kernel.PairPredicate___call__(self, m, vt)
6538 def get_value_index(self, *args):
6540 get_value_index(PairPredicate self, Model m, IMP::ParticleIndexPair const & vt) -> int
6541 get_value_index(PairPredicate self, Model m, IMP::ParticleIndexPairs const & o) -> IMP::Ints
6543 return _IMP_kernel.PairPredicate_get_value_index(self, *args)
6544 __swig_destroy__ = _IMP_kernel.delete_PairPredicate
6547 r"""__str__(PairPredicate self) -> std::string"""
6548 return _IMP_kernel.PairPredicate___str__(self)
6551 r"""__repr__(PairPredicate self) -> std::string"""
6552 return _IMP_kernel.PairPredicate___repr__(self)
6556 return _object_cast_to_PairPredicate(o)
6559 def do_show(self, out):
6564 return _object_cast_to_PairPredicate(o)
6566 def __disown__(self):
6568 _IMP_kernel.disown_PairPredicate(self)
6569 return weakref.proxy(self)
6571 def do_get_inputs(self, m, pis):
6572 r"""do_get_inputs(PairPredicate self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6573 return _IMP_kernel.PairPredicate_do_get_inputs(self, m, pis)
6576 r"""do_destroy(PairPredicate self)"""
6577 return _IMP_kernel.PairPredicate_do_destroy(self)
6580 _IMP_kernel.PairPredicate_swigregister(PairPredicate)
6582 r"""Proxy of C++ IMP::PairContainer class."""
6584 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
6586 def apply_generic(self, m):
6587 r"""apply_generic(PairContainer self, PairModifier m)"""
6588 return _IMP_kernel.PairContainer_apply_generic(self, m)
6590 def apply_generic_moved(self, m, moved_pis, reset_pis):
6591 r"""apply_generic_moved(PairContainer self, PairModifier m, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis)"""
6592 return _IMP_kernel.PairContainer_apply_generic_moved(self, m, moved_pis, reset_pis)
6594 def apply(self, sm):
6595 r"""apply(PairContainer self, PairModifier sm)"""
6596 return _IMP_kernel.PairContainer_apply(self, sm)
6598 def apply_moved(self, sm, moved_pis, reset_pis):
6599 r"""apply_moved(PairContainer self, PairModifier sm, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis)"""
6600 return _IMP_kernel.PairContainer_apply_moved(self, sm, moved_pis, reset_pis)
6602 def get_range_indexes(self):
6603 r"""get_range_indexes(PairContainer self) -> IMP::ParticleIndexPairs"""
6604 return _IMP_kernel.PairContainer_get_range_indexes(self)
6606 def get_contents(self):
6607 r"""get_contents(PairContainer self) -> IMP::ParticleIndexPairs const &"""
6608 return _IMP_kernel.PairContainer_get_contents(self)
6611 r"""get_indexes(PairContainer self) -> IMP::ParticleIndexPairs"""
6612 return _IMP_kernel.PairContainer_get_indexes(self)
6614 def get(self, *args):
6616 get(PairContainer self) -> IMP::ParticlePairsTemp
6617 get(PairContainer self, unsigned int i) -> IMP::ParticlePair
6619 return _IMP_kernel.PairContainer_get(self, *args)
6621 def get_number(self):
6622 r"""get_number(PairContainer self) -> unsigned int"""
6623 return _IMP_kernel.PairContainer_get_number(self)
6625 def __init__(self, *args):
6627 __init__(PairContainer self, Model m, std::string name="PairContainer %1%") -> PairContainer
6628 __init__(PairContainer self) -> PairContainer
6630 if self.__class__ == PairContainer:
6634 _IMP_kernel.PairContainer_swiginit(self, _IMP_kernel.new_PairContainer(_self, *args))
6636 if self.__class__ != PairContainer:
6637 _director_objects.register(self)
6642 def do_apply(self, sm):
6643 r"""do_apply(PairContainer self, PairModifier sm)"""
6644 return _IMP_kernel.PairContainer_do_apply(self, sm)
6646 def do_apply_moved(self, sm, moved_pis, reset_pis):
6647 r"""do_apply_moved(PairContainer self, PairModifier sm, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis)"""
6648 return _IMP_kernel.PairContainer_do_apply_moved(self, sm, moved_pis, reset_pis)
6650 def do_get_provides_access(self):
6651 r"""do_get_provides_access(PairContainer self) -> bool"""
6652 return _IMP_kernel.PairContainer_do_get_provides_access(self)
6653 __swig_destroy__ = _IMP_kernel.delete_PairContainer
6656 r"""__str__(PairContainer self) -> std::string"""
6657 return _IMP_kernel.PairContainer___str__(self)
6660 r"""__repr__(PairContainer self) -> std::string"""
6661 return _IMP_kernel.PairContainer___repr__(self)
6665 return _object_cast_to_PairContainer(o)
6668 def do_show(self, out):
6673 return _object_cast_to_PairContainer(o)
6675 def __disown__(self):
6677 _IMP_kernel.disown_PairContainer(self)
6678 return weakref.proxy(self)
6681 r"""do_destroy(PairContainer self)"""
6682 return _IMP_kernel.PairContainer_do_destroy(self)
6684 def handle_set_has_required_score_states(self, arg0):
6685 r"""handle_set_has_required_score_states(PairContainer self, bool arg0)"""
6686 return _IMP_kernel.PairContainer_handle_set_has_required_score_states(self, arg0)
6688 def do_get_inputs(self):
6689 r"""do_get_inputs(PairContainer self) -> IMP::ModelObjectsTemp"""
6690 return _IMP_kernel.PairContainer_do_get_inputs(self)
6692 def do_get_interactions(self):
6693 r"""do_get_interactions(PairContainer self) -> IMP::ModelObjectsTemps"""
6694 return _IMP_kernel.PairContainer_do_get_interactions(self)
6696 def do_get_contents_hash(self):
6697 r"""do_get_contents_hash(PairContainer self) -> std::size_t"""
6698 return _IMP_kernel.PairContainer_do_get_contents_hash(self)
6701 _IMP_kernel.PairContainer_swigregister(PairContainer)
6702 class _PairContainerAdaptor(_InputAdaptor):
6703 r"""Proxy of C++ IMP::PairContainerAdaptor class."""
6705 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
6706 __repr__ = _swig_repr
6708 def __init__(self, *args):
6710 __init__(_PairContainerAdaptor self) -> _PairContainerAdaptor
6711 __init__(_PairContainerAdaptor self, PairContainer c) -> _PairContainerAdaptor
6712 __init__(_PairContainerAdaptor self, IMP::ParticlePairsTemp const & t) -> _PairContainerAdaptor
6714 _IMP_kernel._PairContainerAdaptor_swiginit(self, _IMP_kernel.new__PairContainerAdaptor(*args))
6716 def set_name_if_default(self, name):
6717 r"""set_name_if_default(_PairContainerAdaptor self, std::string name)"""
6718 return _IMP_kernel._PairContainerAdaptor_set_name_if_default(self, name)
6719 __swig_destroy__ = _IMP_kernel.delete__PairContainerAdaptor
6722 _IMP_kernel._PairContainerAdaptor_swigregister(_PairContainerAdaptor)
6724 r"""Proxy of C++ IMP::QuadModifier class."""
6726 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
6728 def __init__(self, *args):
6729 r"""__init__(QuadModifier self, std::string name="QuadModifier %1%") -> QuadModifier"""
6730 if self.__class__ == QuadModifier:
6734 _IMP_kernel.QuadModifier_swiginit(self, _IMP_kernel.new_QuadModifier(_self, *args))
6736 if self.__class__ != QuadModifier:
6737 _director_objects.register(self)
6742 def apply_index(self, m, v):
6743 r"""apply_index(QuadModifier self, Model m, IMP::ParticleIndexQuad const & v)"""
6744 return _IMP_kernel.QuadModifier_apply_index(self, m, v)
6746 def apply_indexes(self, m, o, lower_bound, upper_bound):
6747 r"""apply_indexes(QuadModifier self, Model m, IMP::ParticleIndexQuads const & o, unsigned int lower_bound, unsigned int upper_bound)"""
6748 return _IMP_kernel.QuadModifier_apply_indexes(self, m, o, lower_bound, upper_bound)
6750 def apply_indexes_moved(self, m, o, lower_bound, upper_bound, moved_pis, reset_pis):
6751 r"""apply_indexes_moved(QuadModifier self, Model m, IMP::ParticleIndexQuads const & o, unsigned int lower_bound, unsigned int upper_bound, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis)"""
6752 return _IMP_kernel.QuadModifier_apply_indexes_moved(self, m, o, lower_bound, upper_bound, moved_pis, reset_pis)
6755 r"""__str__(QuadModifier self) -> std::string"""
6756 return _IMP_kernel.QuadModifier___str__(self)
6759 r"""__repr__(QuadModifier self) -> std::string"""
6760 return _IMP_kernel.QuadModifier___repr__(self)
6764 return _object_cast_to_QuadModifier(o)
6767 def do_show(self, out):
6772 return _object_cast_to_QuadModifier(o)
6774 __swig_destroy__ = _IMP_kernel.delete_QuadModifier
6775 def __disown__(self):
6777 _IMP_kernel.disown_QuadModifier(self)
6778 return weakref.proxy(self)
6780 def do_get_inputs(self, m, pis):
6781 r"""do_get_inputs(QuadModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6782 return _IMP_kernel.QuadModifier_do_get_inputs(self, m, pis)
6784 def do_get_outputs(self, m, pis):
6785 r"""do_get_outputs(QuadModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6786 return _IMP_kernel.QuadModifier_do_get_outputs(self, m, pis)
6789 r"""do_destroy(QuadModifier self)"""
6790 return _IMP_kernel.QuadModifier_do_destroy(self)
6793 _IMP_kernel.QuadModifier_swigregister(QuadModifier)
6795 r"""Proxy of C++ IMP::QuadScore class."""
6797 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
6799 def __init__(self, *args):
6800 r"""__init__(QuadScore self, std::string name="QuadScore %1%") -> QuadScore"""
6801 if self.__class__ == QuadScore:
6805 _IMP_kernel.QuadScore_swiginit(self, _IMP_kernel.new_QuadScore(_self, *args))
6807 if self.__class__ != QuadScore:
6808 _director_objects.register(self)
6813 def evaluate_index(self, m, vt, da):
6814 r"""evaluate_index(QuadScore self, Model m, IMP::ParticleIndexQuad const & vt, DerivativeAccumulator da) -> double"""
6815 return _IMP_kernel.QuadScore_evaluate_index(self, m, vt, da)
6817 def check_indexes(self, m, pis):
6818 r"""check_indexes(QuadScore self, Model m, IMP::ParticleIndexes const & pis) -> bool"""
6819 return _IMP_kernel.QuadScore_check_indexes(self, m, pis)
6821 def evaluate_indexes(self, m, o, da, lower_bound, upper_bound, all_indexes_checked=False):
6822 r"""evaluate_indexes(QuadScore self, Model m, IMP::ParticleIndexQuads const & o, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
6823 return _IMP_kernel.QuadScore_evaluate_indexes(self, m, o, da, lower_bound, upper_bound, all_indexes_checked)
6825 def evaluate_indexes_scores(self, m, o, da, lower_bound, upper_bound, score, all_indexes_checked=False):
6826 r"""evaluate_indexes_scores(QuadScore self, Model m, IMP::ParticleIndexQuads const & o, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
6827 return _IMP_kernel.QuadScore_evaluate_indexes_scores(self, m, o, da, lower_bound, upper_bound, score, all_indexes_checked)
6829 def evaluate_indexes_delta(self, m, o, da, indexes, score, all_indexes_checked=False):
6830 r"""evaluate_indexes_delta(QuadScore self, Model m, IMP::ParticleIndexQuads const & o, DerivativeAccumulator da, std::vector< unsigned int,std::allocator< unsigned int > > const & indexes, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
6831 return _IMP_kernel.QuadScore_evaluate_indexes_delta(self, m, o, da, indexes, score, all_indexes_checked)
6833 def evaluate_if_good_index(self, m, vt, da, max):
6834 r"""evaluate_if_good_index(QuadScore self, Model m, IMP::ParticleIndexQuad const & vt, DerivativeAccumulator da, double max) -> double"""
6835 return _IMP_kernel.QuadScore_evaluate_if_good_index(self, m, vt, da, max)
6837 def evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound, all_indexes_checked=False):
6838 r"""evaluate_if_good_indexes(QuadScore self, Model m, IMP::ParticleIndexQuads const & o, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
6839 return _IMP_kernel.QuadScore_evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound, all_indexes_checked)
6841 def create_current_decomposition(self, m, vt):
6842 r"""create_current_decomposition(QuadScore self, Model m, IMP::ParticleIndexQuad const & vt) -> IMP::Restraints"""
6843 return _IMP_kernel.QuadScore_create_current_decomposition(self, m, vt)
6845 def do_create_current_decomposition(self, m, vt):
6846 r"""do_create_current_decomposition(QuadScore self, Model m, IMP::ParticleIndexQuad const & vt) -> IMP::Restraints"""
6847 return _IMP_kernel.QuadScore_do_create_current_decomposition(self, m, vt)
6848 __swig_destroy__ = _IMP_kernel.delete_QuadScore
6851 r"""__str__(QuadScore self) -> std::string"""
6852 return _IMP_kernel.QuadScore___str__(self)
6855 r"""__repr__(QuadScore self) -> std::string"""
6856 return _IMP_kernel.QuadScore___repr__(self)
6860 return _object_cast_to_QuadScore(o)
6863 def do_show(self, out):
6868 return _object_cast_to_QuadScore(o)
6870 def __disown__(self):
6872 _IMP_kernel.disown_QuadScore(self)
6873 return weakref.proxy(self)
6875 def do_get_inputs(self, m, pis):
6876 r"""do_get_inputs(QuadScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6877 return _IMP_kernel.QuadScore_do_get_inputs(self, m, pis)
6880 r"""do_destroy(QuadScore self)"""
6881 return _IMP_kernel.QuadScore_do_destroy(self)
6884 _IMP_kernel.QuadScore_swigregister(QuadScore)
6886 r"""Proxy of C++ IMP::QuadPredicate class."""
6888 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
6890 def __init__(self, *args):
6891 r"""__init__(QuadPredicate self, std::string name="QuadPredicate %1%") -> QuadPredicate"""
6892 if self.__class__ == QuadPredicate:
6896 _IMP_kernel.QuadPredicate_swiginit(self, _IMP_kernel.new_QuadPredicate(_self, *args))
6898 if self.__class__ != QuadPredicate:
6899 _director_objects.register(self)
6904 def setup_for_get_value_index_in_batch(self, arg0):
6905 r"""setup_for_get_value_index_in_batch(QuadPredicate self, Model arg0)"""
6906 return _IMP_kernel.QuadPredicate_setup_for_get_value_index_in_batch(self, arg0)
6908 def get_value_index_in_batch(self, m, vt):
6909 r"""get_value_index_in_batch(QuadPredicate self, Model m, IMP::ParticleIndexQuad const & vt) -> int"""
6910 return _IMP_kernel.QuadPredicate_get_value_index_in_batch(self, m, vt)
6912 def __call__(self, m, vt):
6913 r"""__call__(QuadPredicate self, Model m, IMP::ParticleIndexQuad const & vt) -> int"""
6914 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)
6922 __swig_destroy__ = _IMP_kernel.delete_QuadPredicate
6925 r"""__str__(QuadPredicate self) -> std::string"""
6926 return _IMP_kernel.QuadPredicate___str__(self)
6929 r"""__repr__(QuadPredicate self) -> std::string"""
6930 return _IMP_kernel.QuadPredicate___repr__(self)
6934 return _object_cast_to_QuadPredicate(o)
6937 def do_show(self, out):
6942 return _object_cast_to_QuadPredicate(o)
6944 def __disown__(self):
6946 _IMP_kernel.disown_QuadPredicate(self)
6947 return weakref.proxy(self)
6949 def do_get_inputs(self, m, pis):
6950 r"""do_get_inputs(QuadPredicate self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6951 return _IMP_kernel.QuadPredicate_do_get_inputs(self, m, pis)
6954 r"""do_destroy(QuadPredicate self)"""
6955 return _IMP_kernel.QuadPredicate_do_destroy(self)
6958 _IMP_kernel.QuadPredicate_swigregister(QuadPredicate)
6960 r"""Proxy of C++ IMP::QuadContainer class."""
6962 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
6964 def apply_generic(self, m):
6965 r"""apply_generic(QuadContainer self, QuadModifier m)"""
6966 return _IMP_kernel.QuadContainer_apply_generic(self, m)
6968 def apply_generic_moved(self, m, moved_pis, reset_pis):
6969 r"""apply_generic_moved(QuadContainer self, QuadModifier m, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis)"""
6970 return _IMP_kernel.QuadContainer_apply_generic_moved(self, m, moved_pis, reset_pis)
6972 def apply(self, sm):
6973 r"""apply(QuadContainer self, QuadModifier sm)"""
6974 return _IMP_kernel.QuadContainer_apply(self, sm)
6976 def apply_moved(self, sm, moved_pis, reset_pis):
6977 r"""apply_moved(QuadContainer self, QuadModifier sm, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis)"""
6978 return _IMP_kernel.QuadContainer_apply_moved(self, sm, moved_pis, reset_pis)
6980 def get_range_indexes(self):
6981 r"""get_range_indexes(QuadContainer self) -> IMP::ParticleIndexQuads"""
6982 return _IMP_kernel.QuadContainer_get_range_indexes(self)
6984 def get_contents(self):
6985 r"""get_contents(QuadContainer self) -> IMP::ParticleIndexQuads const &"""
6986 return _IMP_kernel.QuadContainer_get_contents(self)
6989 r"""get_indexes(QuadContainer self) -> IMP::ParticleIndexQuads"""
6990 return _IMP_kernel.QuadContainer_get_indexes(self)
6992 def get(self, *args):
6994 get(QuadContainer self) -> IMP::ParticleQuadsTemp
6995 get(QuadContainer self, unsigned int i) -> IMP::ParticleQuad
6997 return _IMP_kernel.QuadContainer_get(self, *args)
6999 def get_number(self):
7000 r"""get_number(QuadContainer self) -> unsigned int"""
7001 return _IMP_kernel.QuadContainer_get_number(self)
7003 def __init__(self, *args):
7005 __init__(QuadContainer self, Model m, std::string name="QuadContainer %1%") -> QuadContainer
7006 __init__(QuadContainer self) -> QuadContainer
7008 if self.__class__ == QuadContainer:
7012 _IMP_kernel.QuadContainer_swiginit(self, _IMP_kernel.new_QuadContainer(_self, *args))
7014 if self.__class__ != QuadContainer:
7015 _director_objects.register(self)
7020 def do_apply(self, sm):
7021 r"""do_apply(QuadContainer self, QuadModifier sm)"""
7022 return _IMP_kernel.QuadContainer_do_apply(self, sm)
7024 def do_apply_moved(self, sm, moved_pis, reset_pis):
7025 r"""do_apply_moved(QuadContainer self, QuadModifier sm, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis)"""
7026 return _IMP_kernel.QuadContainer_do_apply_moved(self, sm, moved_pis, reset_pis)
7028 def do_get_provides_access(self):
7029 r"""do_get_provides_access(QuadContainer self) -> bool"""
7030 return _IMP_kernel.QuadContainer_do_get_provides_access(self)
7031 __swig_destroy__ = _IMP_kernel.delete_QuadContainer
7034 r"""__str__(QuadContainer self) -> std::string"""
7035 return _IMP_kernel.QuadContainer___str__(self)
7038 r"""__repr__(QuadContainer self) -> std::string"""
7039 return _IMP_kernel.QuadContainer___repr__(self)
7043 return _object_cast_to_QuadContainer(o)
7046 def do_show(self, out):
7051 return _object_cast_to_QuadContainer(o)
7053 def __disown__(self):
7055 _IMP_kernel.disown_QuadContainer(self)
7056 return weakref.proxy(self)
7059 r"""do_destroy(QuadContainer self)"""
7060 return _IMP_kernel.QuadContainer_do_destroy(self)
7062 def handle_set_has_required_score_states(self, arg0):
7063 r"""handle_set_has_required_score_states(QuadContainer self, bool arg0)"""
7064 return _IMP_kernel.QuadContainer_handle_set_has_required_score_states(self, arg0)
7066 def do_get_inputs(self):
7067 r"""do_get_inputs(QuadContainer self) -> IMP::ModelObjectsTemp"""
7068 return _IMP_kernel.QuadContainer_do_get_inputs(self)
7070 def do_get_interactions(self):
7071 r"""do_get_interactions(QuadContainer self) -> IMP::ModelObjectsTemps"""
7072 return _IMP_kernel.QuadContainer_do_get_interactions(self)
7074 def do_get_contents_hash(self):
7075 r"""do_get_contents_hash(QuadContainer self) -> std::size_t"""
7076 return _IMP_kernel.QuadContainer_do_get_contents_hash(self)
7079 _IMP_kernel.QuadContainer_swigregister(QuadContainer)
7080 class _QuadContainerAdaptor(_InputAdaptor):
7081 r"""Proxy of C++ IMP::QuadContainerAdaptor class."""
7083 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
7084 __repr__ = _swig_repr
7086 def __init__(self, *args):
7088 __init__(_QuadContainerAdaptor self) -> _QuadContainerAdaptor
7089 __init__(_QuadContainerAdaptor self, QuadContainer c) -> _QuadContainerAdaptor
7090 __init__(_QuadContainerAdaptor self, IMP::ParticleQuadsTemp const & t) -> _QuadContainerAdaptor
7092 _IMP_kernel._QuadContainerAdaptor_swiginit(self, _IMP_kernel.new__QuadContainerAdaptor(*args))
7094 def set_name_if_default(self, name):
7095 r"""set_name_if_default(_QuadContainerAdaptor self, std::string name)"""
7096 return _IMP_kernel._QuadContainerAdaptor_set_name_if_default(self, name)
7097 __swig_destroy__ = _IMP_kernel.delete__QuadContainerAdaptor
7100 _IMP_kernel._QuadContainerAdaptor_swigregister(_QuadContainerAdaptor)
7102 r"""Proxy of C++ IMP::SingletonModifier class."""
7104 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
7106 def __init__(self, *args):
7107 r"""__init__(SingletonModifier self, std::string name="SingletonModifier %1%") -> SingletonModifier"""
7108 if self.__class__ == SingletonModifier:
7112 _IMP_kernel.SingletonModifier_swiginit(self, _IMP_kernel.new_SingletonModifier(_self, *args))
7114 if self.__class__ != SingletonModifier:
7115 _director_objects.register(self)
7120 def apply_index(self, m, v):
7121 r"""apply_index(SingletonModifier self, Model m, ParticleIndex v)"""
7122 return _IMP_kernel.SingletonModifier_apply_index(self, m, v)
7124 def apply_indexes(self, m, o, lower_bound, upper_bound):
7125 r"""apply_indexes(SingletonModifier self, Model m, IMP::ParticleIndexes const & o, unsigned int lower_bound, unsigned int upper_bound)"""
7126 return _IMP_kernel.SingletonModifier_apply_indexes(self, m, o, lower_bound, upper_bound)
7128 def apply_indexes_moved(self, m, o, lower_bound, upper_bound, moved_pis, reset_pis):
7129 r"""apply_indexes_moved(SingletonModifier self, Model m, IMP::ParticleIndexes const & o, unsigned int lower_bound, unsigned int upper_bound, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis)"""
7130 return _IMP_kernel.SingletonModifier_apply_indexes_moved(self, m, o, lower_bound, upper_bound, moved_pis, reset_pis)
7133 r"""__str__(SingletonModifier self) -> std::string"""
7134 return _IMP_kernel.SingletonModifier___str__(self)
7137 r"""__repr__(SingletonModifier self) -> std::string"""
7138 return _IMP_kernel.SingletonModifier___repr__(self)
7142 return _object_cast_to_SingletonModifier(o)
7145 def do_show(self, out):
7150 return _object_cast_to_SingletonModifier(o)
7152 __swig_destroy__ = _IMP_kernel.delete_SingletonModifier
7153 def __disown__(self):
7155 _IMP_kernel.disown_SingletonModifier(self)
7156 return weakref.proxy(self)
7158 def do_get_inputs(self, m, pis):
7159 r"""do_get_inputs(SingletonModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7160 return _IMP_kernel.SingletonModifier_do_get_inputs(self, m, pis)
7162 def do_get_outputs(self, m, pis):
7163 r"""do_get_outputs(SingletonModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7164 return _IMP_kernel.SingletonModifier_do_get_outputs(self, m, pis)
7167 r"""do_destroy(SingletonModifier self)"""
7168 return _IMP_kernel.SingletonModifier_do_destroy(self)
7171 _IMP_kernel.SingletonModifier_swigregister(SingletonModifier)
7173 r"""Proxy of C++ IMP::SingletonScore class."""
7175 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
7177 def __init__(self, *args):
7178 r"""__init__(SingletonScore self, std::string name="SingletonScore %1%") -> SingletonScore"""
7179 if self.__class__ == SingletonScore:
7183 _IMP_kernel.SingletonScore_swiginit(self, _IMP_kernel.new_SingletonScore(_self, *args))
7185 if self.__class__ != SingletonScore:
7186 _director_objects.register(self)
7191 def evaluate_index(self, m, vt, da):
7192 r"""evaluate_index(SingletonScore self, Model m, ParticleIndex vt, DerivativeAccumulator da) -> double"""
7193 return _IMP_kernel.SingletonScore_evaluate_index(self, m, vt, da)
7195 def check_indexes(self, m, pis):
7196 r"""check_indexes(SingletonScore self, Model m, IMP::ParticleIndexes const & pis) -> bool"""
7197 return _IMP_kernel.SingletonScore_check_indexes(self, m, pis)
7199 def evaluate_indexes(self, m, o, da, lower_bound, upper_bound, all_indexes_checked=False):
7200 r"""evaluate_indexes(SingletonScore self, Model m, IMP::ParticleIndexes const & o, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
7201 return _IMP_kernel.SingletonScore_evaluate_indexes(self, m, o, da, lower_bound, upper_bound, all_indexes_checked)
7203 def evaluate_indexes_scores(self, m, o, da, lower_bound, upper_bound, score, all_indexes_checked=False):
7204 r"""evaluate_indexes_scores(SingletonScore self, Model m, IMP::ParticleIndexes const & o, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
7205 return _IMP_kernel.SingletonScore_evaluate_indexes_scores(self, m, o, da, lower_bound, upper_bound, score, all_indexes_checked)
7207 def evaluate_indexes_delta(self, m, o, da, indexes, score, all_indexes_checked=False):
7208 r"""evaluate_indexes_delta(SingletonScore self, Model m, IMP::ParticleIndexes const & o, DerivativeAccumulator da, std::vector< unsigned int,std::allocator< unsigned int > > const & indexes, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
7209 return _IMP_kernel.SingletonScore_evaluate_indexes_delta(self, m, o, da, indexes, score, all_indexes_checked)
7211 def evaluate_if_good_index(self, m, vt, da, max):
7212 r"""evaluate_if_good_index(SingletonScore self, Model m, ParticleIndex vt, DerivativeAccumulator da, double max) -> double"""
7213 return _IMP_kernel.SingletonScore_evaluate_if_good_index(self, m, vt, da, max)
7215 def evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound, all_indexes_checked=False):
7216 r"""evaluate_if_good_indexes(SingletonScore self, Model m, IMP::ParticleIndexes const & o, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
7217 return _IMP_kernel.SingletonScore_evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound, all_indexes_checked)
7219 def create_current_decomposition(self, m, vt):
7220 r"""create_current_decomposition(SingletonScore self, Model m, ParticleIndex vt) -> IMP::Restraints"""
7221 return _IMP_kernel.SingletonScore_create_current_decomposition(self, m, vt)
7223 def do_create_current_decomposition(self, m, vt):
7224 r"""do_create_current_decomposition(SingletonScore self, Model m, ParticleIndex vt) -> IMP::Restraints"""
7225 return _IMP_kernel.SingletonScore_do_create_current_decomposition(self, m, vt)
7226 __swig_destroy__ = _IMP_kernel.delete_SingletonScore
7229 r"""__str__(SingletonScore self) -> std::string"""
7230 return _IMP_kernel.SingletonScore___str__(self)
7233 r"""__repr__(SingletonScore self) -> std::string"""
7234 return _IMP_kernel.SingletonScore___repr__(self)
7238 return _object_cast_to_SingletonScore(o)
7241 def do_show(self, out):
7246 return _object_cast_to_SingletonScore(o)
7248 def __disown__(self):
7250 _IMP_kernel.disown_SingletonScore(self)
7251 return weakref.proxy(self)
7253 def do_get_inputs(self, m, pis):
7254 r"""do_get_inputs(SingletonScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7255 return _IMP_kernel.SingletonScore_do_get_inputs(self, m, pis)
7258 r"""do_destroy(SingletonScore self)"""
7259 return _IMP_kernel.SingletonScore_do_destroy(self)
7262 _IMP_kernel.SingletonScore_swigregister(SingletonScore)
7264 r"""Proxy of C++ IMP::SingletonPredicate class."""
7266 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
7268 def __init__(self, *args):
7269 r"""__init__(SingletonPredicate self, std::string name="SingletonPredicate %1%") -> SingletonPredicate"""
7270 if self.__class__ == SingletonPredicate:
7274 _IMP_kernel.SingletonPredicate_swiginit(self, _IMP_kernel.new_SingletonPredicate(_self, *args))
7276 if self.__class__ != SingletonPredicate:
7277 _director_objects.register(self)
7282 def setup_for_get_value_index_in_batch(self, arg0):
7283 r"""setup_for_get_value_index_in_batch(SingletonPredicate self, Model arg0)"""
7284 return _IMP_kernel.SingletonPredicate_setup_for_get_value_index_in_batch(self, arg0)
7286 def get_value_index_in_batch(self, m, vt):
7287 r"""get_value_index_in_batch(SingletonPredicate self, Model m, ParticleIndex vt) -> int"""
7288 return _IMP_kernel.SingletonPredicate_get_value_index_in_batch(self, m, vt)
7290 def __call__(self, m, vt):
7291 r"""__call__(SingletonPredicate self, Model m, ParticleIndex vt) -> int"""
7292 return _IMP_kernel.SingletonPredicate___call__(self, m, vt)
7294 def get_value_index(self, *args):
7296 get_value_index(SingletonPredicate self, Model m, ParticleIndex vt) -> int
7297 get_value_index(SingletonPredicate self, Model m, IMP::ParticleIndexes const & o) -> IMP::Ints
7299 return _IMP_kernel.SingletonPredicate_get_value_index(self, *args)
7300 __swig_destroy__ = _IMP_kernel.delete_SingletonPredicate
7303 r"""__str__(SingletonPredicate self) -> std::string"""
7304 return _IMP_kernel.SingletonPredicate___str__(self)
7307 r"""__repr__(SingletonPredicate self) -> std::string"""
7308 return _IMP_kernel.SingletonPredicate___repr__(self)
7312 return _object_cast_to_SingletonPredicate(o)
7315 def do_show(self, out):
7320 return _object_cast_to_SingletonPredicate(o)
7322 def __disown__(self):
7324 _IMP_kernel.disown_SingletonPredicate(self)
7325 return weakref.proxy(self)
7327 def do_get_inputs(self, m, pis):
7328 r"""do_get_inputs(SingletonPredicate self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7329 return _IMP_kernel.SingletonPredicate_do_get_inputs(self, m, pis)
7332 r"""do_destroy(SingletonPredicate self)"""
7333 return _IMP_kernel.SingletonPredicate_do_destroy(self)
7336 _IMP_kernel.SingletonPredicate_swigregister(SingletonPredicate)
7338 r"""Proxy of C++ IMP::SingletonContainer class."""
7340 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
7342 def apply_generic(self, m):
7343 r"""apply_generic(SingletonContainer self, SingletonModifier m)"""
7344 return _IMP_kernel.SingletonContainer_apply_generic(self, m)
7346 def apply_generic_moved(self, m, moved_pis, reset_pis):
7347 r"""apply_generic_moved(SingletonContainer self, SingletonModifier m, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis)"""
7348 return _IMP_kernel.SingletonContainer_apply_generic_moved(self, m, moved_pis, reset_pis)
7350 def apply(self, sm):
7351 r"""apply(SingletonContainer self, SingletonModifier sm)"""
7352 return _IMP_kernel.SingletonContainer_apply(self, sm)
7354 def apply_moved(self, sm, moved_pis, reset_pis):
7355 r"""apply_moved(SingletonContainer self, SingletonModifier sm, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis)"""
7356 return _IMP_kernel.SingletonContainer_apply_moved(self, sm, moved_pis, reset_pis)
7358 def get_range_indexes(self):
7359 r"""get_range_indexes(SingletonContainer self) -> IMP::ParticleIndexes"""
7360 return _IMP_kernel.SingletonContainer_get_range_indexes(self)
7362 def get_contents(self):
7363 r"""get_contents(SingletonContainer self) -> IMP::ParticleIndexes const &"""
7364 return _IMP_kernel.SingletonContainer_get_contents(self)
7367 r"""get_indexes(SingletonContainer self) -> IMP::ParticleIndexes"""
7368 return _IMP_kernel.SingletonContainer_get_indexes(self)
7370 def get(self, *args):
7372 get(SingletonContainer self) -> IMP::ParticlesTemp
7373 get(SingletonContainer self, unsigned int i) -> Particle
7375 return _IMP_kernel.SingletonContainer_get(self, *args)
7377 def get_number(self):
7378 r"""get_number(SingletonContainer self) -> unsigned int"""
7379 return _IMP_kernel.SingletonContainer_get_number(self)
7381 def __init__(self, *args):
7383 __init__(SingletonContainer self, Model m, std::string name="SingletonContainer %1%") -> SingletonContainer
7384 __init__(SingletonContainer self) -> SingletonContainer
7386 if self.__class__ == SingletonContainer:
7390 _IMP_kernel.SingletonContainer_swiginit(self, _IMP_kernel.new_SingletonContainer(_self, *args))
7392 if self.__class__ != SingletonContainer:
7393 _director_objects.register(self)
7398 def do_apply(self, sm):
7399 r"""do_apply(SingletonContainer self, SingletonModifier sm)"""
7400 return _IMP_kernel.SingletonContainer_do_apply(self, sm)
7402 def do_apply_moved(self, sm, moved_pis, reset_pis):
7403 r"""do_apply_moved(SingletonContainer self, SingletonModifier sm, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis)"""
7404 return _IMP_kernel.SingletonContainer_do_apply_moved(self, sm, moved_pis, reset_pis)
7406 def do_get_provides_access(self):
7407 r"""do_get_provides_access(SingletonContainer self) -> bool"""
7408 return _IMP_kernel.SingletonContainer_do_get_provides_access(self)
7409 __swig_destroy__ = _IMP_kernel.delete_SingletonContainer
7412 r"""__str__(SingletonContainer self) -> std::string"""
7413 return _IMP_kernel.SingletonContainer___str__(self)
7416 r"""__repr__(SingletonContainer self) -> std::string"""
7417 return _IMP_kernel.SingletonContainer___repr__(self)
7421 return _object_cast_to_SingletonContainer(o)
7424 def do_show(self, out):
7429 return _object_cast_to_SingletonContainer(o)
7431 def __disown__(self):
7433 _IMP_kernel.disown_SingletonContainer(self)
7434 return weakref.proxy(self)
7437 r"""do_destroy(SingletonContainer self)"""
7438 return _IMP_kernel.SingletonContainer_do_destroy(self)
7440 def handle_set_has_required_score_states(self, arg0):
7441 r"""handle_set_has_required_score_states(SingletonContainer self, bool arg0)"""
7442 return _IMP_kernel.SingletonContainer_handle_set_has_required_score_states(self, arg0)
7444 def do_get_inputs(self):
7445 r"""do_get_inputs(SingletonContainer self) -> IMP::ModelObjectsTemp"""
7446 return _IMP_kernel.SingletonContainer_do_get_inputs(self)
7448 def do_get_interactions(self):
7449 r"""do_get_interactions(SingletonContainer self) -> IMP::ModelObjectsTemps"""
7450 return _IMP_kernel.SingletonContainer_do_get_interactions(self)
7452 def do_get_contents_hash(self):
7453 r"""do_get_contents_hash(SingletonContainer self) -> std::size_t"""
7454 return _IMP_kernel.SingletonContainer_do_get_contents_hash(self)
7457 _IMP_kernel.SingletonContainer_swigregister(SingletonContainer)
7458 class _SingletonContainerAdaptor(_InputAdaptor):
7459 r"""Proxy of C++ IMP::SingletonContainerAdaptor class."""
7461 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
7462 __repr__ = _swig_repr
7464 def __init__(self, *args):
7466 __init__(_SingletonContainerAdaptor self) -> _SingletonContainerAdaptor
7467 __init__(_SingletonContainerAdaptor self, SingletonContainer c) -> _SingletonContainerAdaptor
7468 __init__(_SingletonContainerAdaptor self, IMP::ParticlesTemp const & t) -> _SingletonContainerAdaptor
7470 _IMP_kernel._SingletonContainerAdaptor_swiginit(self, _IMP_kernel.new__SingletonContainerAdaptor(*args))
7472 def set_name_if_default(self, name):
7473 r"""set_name_if_default(_SingletonContainerAdaptor self, std::string name)"""
7474 return _IMP_kernel._SingletonContainerAdaptor_set_name_if_default(self, name)
7475 __swig_destroy__ = _IMP_kernel.delete__SingletonContainerAdaptor
7478 _IMP_kernel._SingletonContainerAdaptor_swigregister(_SingletonContainerAdaptor)
7480 r"""Proxy of C++ IMP::TripletModifier class."""
7482 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
7484 def __init__(self, *args):
7485 r"""__init__(TripletModifier self, std::string name="TripletModifier %1%") -> TripletModifier"""
7486 if self.__class__ == TripletModifier:
7490 _IMP_kernel.TripletModifier_swiginit(self, _IMP_kernel.new_TripletModifier(_self, *args))
7492 if self.__class__ != TripletModifier:
7493 _director_objects.register(self)
7498 def apply_index(self, m, v):
7499 r"""apply_index(TripletModifier self, Model m, IMP::ParticleIndexTriplet const & v)"""
7500 return _IMP_kernel.TripletModifier_apply_index(self, m, v)
7502 def apply_indexes(self, m, o, lower_bound, upper_bound):
7503 r"""apply_indexes(TripletModifier self, Model m, IMP::ParticleIndexTriplets const & o, unsigned int lower_bound, unsigned int upper_bound)"""
7504 return _IMP_kernel.TripletModifier_apply_indexes(self, m, o, lower_bound, upper_bound)
7506 def apply_indexes_moved(self, m, o, lower_bound, upper_bound, moved_pis, reset_pis):
7507 r"""apply_indexes_moved(TripletModifier self, Model m, IMP::ParticleIndexTriplets const & o, unsigned int lower_bound, unsigned int upper_bound, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis)"""
7508 return _IMP_kernel.TripletModifier_apply_indexes_moved(self, m, o, lower_bound, upper_bound, moved_pis, reset_pis)
7511 r"""__str__(TripletModifier self) -> std::string"""
7512 return _IMP_kernel.TripletModifier___str__(self)
7515 r"""__repr__(TripletModifier self) -> std::string"""
7516 return _IMP_kernel.TripletModifier___repr__(self)
7520 return _object_cast_to_TripletModifier(o)
7523 def do_show(self, out):
7528 return _object_cast_to_TripletModifier(o)
7530 __swig_destroy__ = _IMP_kernel.delete_TripletModifier
7531 def __disown__(self):
7533 _IMP_kernel.disown_TripletModifier(self)
7534 return weakref.proxy(self)
7536 def do_get_inputs(self, m, pis):
7537 r"""do_get_inputs(TripletModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7538 return _IMP_kernel.TripletModifier_do_get_inputs(self, m, pis)
7540 def do_get_outputs(self, m, pis):
7541 r"""do_get_outputs(TripletModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7542 return _IMP_kernel.TripletModifier_do_get_outputs(self, m, pis)
7545 r"""do_destroy(TripletModifier self)"""
7546 return _IMP_kernel.TripletModifier_do_destroy(self)
7549 _IMP_kernel.TripletModifier_swigregister(TripletModifier)
7551 r"""Proxy of C++ IMP::TripletScore class."""
7553 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
7555 def __init__(self, *args):
7556 r"""__init__(TripletScore self, std::string name="TripletScore %1%") -> TripletScore"""
7557 if self.__class__ == TripletScore:
7561 _IMP_kernel.TripletScore_swiginit(self, _IMP_kernel.new_TripletScore(_self, *args))
7563 if self.__class__ != TripletScore:
7564 _director_objects.register(self)
7569 def evaluate_index(self, m, vt, da):
7570 r"""evaluate_index(TripletScore self, Model m, IMP::ParticleIndexTriplet const & vt, DerivativeAccumulator da) -> double"""
7571 return _IMP_kernel.TripletScore_evaluate_index(self, m, vt, da)
7573 def check_indexes(self, m, pis):
7574 r"""check_indexes(TripletScore self, Model m, IMP::ParticleIndexes const & pis) -> bool"""
7575 return _IMP_kernel.TripletScore_check_indexes(self, m, pis)
7577 def evaluate_indexes(self, m, o, da, lower_bound, upper_bound, all_indexes_checked=False):
7578 r"""evaluate_indexes(TripletScore self, Model m, IMP::ParticleIndexTriplets const & o, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
7579 return _IMP_kernel.TripletScore_evaluate_indexes(self, m, o, da, lower_bound, upper_bound, all_indexes_checked)
7581 def evaluate_indexes_scores(self, m, o, da, lower_bound, upper_bound, score, all_indexes_checked=False):
7582 r"""evaluate_indexes_scores(TripletScore self, Model m, IMP::ParticleIndexTriplets const & o, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
7583 return _IMP_kernel.TripletScore_evaluate_indexes_scores(self, m, o, da, lower_bound, upper_bound, score, all_indexes_checked)
7585 def evaluate_indexes_delta(self, m, o, da, indexes, score, all_indexes_checked=False):
7586 r"""evaluate_indexes_delta(TripletScore self, Model m, IMP::ParticleIndexTriplets const & o, DerivativeAccumulator da, std::vector< unsigned int,std::allocator< unsigned int > > const & indexes, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
7587 return _IMP_kernel.TripletScore_evaluate_indexes_delta(self, m, o, da, indexes, score, all_indexes_checked)
7589 def evaluate_if_good_index(self, m, vt, da, max):
7590 r"""evaluate_if_good_index(TripletScore self, Model m, IMP::ParticleIndexTriplet const & vt, DerivativeAccumulator da, double max) -> double"""
7591 return _IMP_kernel.TripletScore_evaluate_if_good_index(self, m, vt, da, max)
7593 def evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound, all_indexes_checked=False):
7594 r"""evaluate_if_good_indexes(TripletScore self, Model m, IMP::ParticleIndexTriplets const & o, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
7595 return _IMP_kernel.TripletScore_evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound, all_indexes_checked)
7597 def create_current_decomposition(self, m, vt):
7598 r"""create_current_decomposition(TripletScore self, Model m, IMP::ParticleIndexTriplet const & vt) -> IMP::Restraints"""
7599 return _IMP_kernel.TripletScore_create_current_decomposition(self, m, vt)
7601 def do_create_current_decomposition(self, m, vt):
7602 r"""do_create_current_decomposition(TripletScore self, Model m, IMP::ParticleIndexTriplet const & vt) -> IMP::Restraints"""
7603 return _IMP_kernel.TripletScore_do_create_current_decomposition(self, m, vt)
7604 __swig_destroy__ = _IMP_kernel.delete_TripletScore
7607 r"""__str__(TripletScore self) -> std::string"""
7608 return _IMP_kernel.TripletScore___str__(self)
7611 r"""__repr__(TripletScore self) -> std::string"""
7612 return _IMP_kernel.TripletScore___repr__(self)
7616 return _object_cast_to_TripletScore(o)
7619 def do_show(self, out):
7624 return _object_cast_to_TripletScore(o)
7626 def __disown__(self):
7628 _IMP_kernel.disown_TripletScore(self)
7629 return weakref.proxy(self)
7631 def do_get_inputs(self, m, pis):
7632 r"""do_get_inputs(TripletScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7633 return _IMP_kernel.TripletScore_do_get_inputs(self, m, pis)
7636 r"""do_destroy(TripletScore self)"""
7637 return _IMP_kernel.TripletScore_do_destroy(self)
7640 _IMP_kernel.TripletScore_swigregister(TripletScore)
7642 r"""Proxy of C++ IMP::TripletPredicate class."""
7644 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
7646 def __init__(self, *args):
7647 r"""__init__(TripletPredicate self, std::string name="TripletPredicate %1%") -> TripletPredicate"""
7648 if self.__class__ == TripletPredicate:
7652 _IMP_kernel.TripletPredicate_swiginit(self, _IMP_kernel.new_TripletPredicate(_self, *args))
7654 if self.__class__ != TripletPredicate:
7655 _director_objects.register(self)
7660 def setup_for_get_value_index_in_batch(self, arg0):
7661 r"""setup_for_get_value_index_in_batch(TripletPredicate self, Model arg0)"""
7662 return _IMP_kernel.TripletPredicate_setup_for_get_value_index_in_batch(self, arg0)
7664 def get_value_index_in_batch(self, m, vt):
7665 r"""get_value_index_in_batch(TripletPredicate self, Model m, IMP::ParticleIndexTriplet const & vt) -> int"""
7666 return _IMP_kernel.TripletPredicate_get_value_index_in_batch(self, m, vt)
7668 def __call__(self, m, vt):
7669 r"""__call__(TripletPredicate self, Model m, IMP::ParticleIndexTriplet const & vt) -> int"""
7670 return _IMP_kernel.TripletPredicate___call__(self, m, vt)
7672 def get_value_index(self, *args):
7674 get_value_index(TripletPredicate self, Model m, IMP::ParticleIndexTriplet const & vt) -> int
7675 get_value_index(TripletPredicate self, Model m, IMP::ParticleIndexTriplets const & o) -> IMP::Ints
7677 return _IMP_kernel.TripletPredicate_get_value_index(self, *args)
7678 __swig_destroy__ = _IMP_kernel.delete_TripletPredicate
7681 r"""__str__(TripletPredicate self) -> std::string"""
7682 return _IMP_kernel.TripletPredicate___str__(self)
7685 r"""__repr__(TripletPredicate self) -> std::string"""
7686 return _IMP_kernel.TripletPredicate___repr__(self)
7690 return _object_cast_to_TripletPredicate(o)
7693 def do_show(self, out):
7698 return _object_cast_to_TripletPredicate(o)
7700 def __disown__(self):
7702 _IMP_kernel.disown_TripletPredicate(self)
7703 return weakref.proxy(self)
7705 def do_get_inputs(self, m, pis):
7706 r"""do_get_inputs(TripletPredicate self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7707 return _IMP_kernel.TripletPredicate_do_get_inputs(self, m, pis)
7710 r"""do_destroy(TripletPredicate self)"""
7711 return _IMP_kernel.TripletPredicate_do_destroy(self)
7714 _IMP_kernel.TripletPredicate_swigregister(TripletPredicate)
7716 r"""Proxy of C++ IMP::TripletContainer class."""
7718 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
7720 def apply_generic(self, m):
7721 r"""apply_generic(TripletContainer self, TripletModifier m)"""
7722 return _IMP_kernel.TripletContainer_apply_generic(self, m)
7724 def apply_generic_moved(self, m, moved_pis, reset_pis):
7725 r"""apply_generic_moved(TripletContainer self, TripletModifier m, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis)"""
7726 return _IMP_kernel.TripletContainer_apply_generic_moved(self, m, moved_pis, reset_pis)
7728 def apply(self, sm):
7729 r"""apply(TripletContainer self, TripletModifier sm)"""
7730 return _IMP_kernel.TripletContainer_apply(self, sm)
7732 def apply_moved(self, sm, moved_pis, reset_pis):
7733 r"""apply_moved(TripletContainer self, TripletModifier sm, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis)"""
7734 return _IMP_kernel.TripletContainer_apply_moved(self, sm, moved_pis, reset_pis)
7736 def get_range_indexes(self):
7737 r"""get_range_indexes(TripletContainer self) -> IMP::ParticleIndexTriplets"""
7738 return _IMP_kernel.TripletContainer_get_range_indexes(self)
7740 def get_contents(self):
7741 r"""get_contents(TripletContainer self) -> IMP::ParticleIndexTriplets const &"""
7742 return _IMP_kernel.TripletContainer_get_contents(self)
7745 r"""get_indexes(TripletContainer self) -> IMP::ParticleIndexTriplets"""
7746 return _IMP_kernel.TripletContainer_get_indexes(self)
7748 def get(self, *args):
7750 get(TripletContainer self) -> IMP::ParticleTripletsTemp
7751 get(TripletContainer self, unsigned int i) -> IMP::ParticleTriplet
7753 return _IMP_kernel.TripletContainer_get(self, *args)
7755 def get_number(self):
7756 r"""get_number(TripletContainer self) -> unsigned int"""
7757 return _IMP_kernel.TripletContainer_get_number(self)
7759 def __init__(self, *args):
7761 __init__(TripletContainer self, Model m, std::string name="TripletContainer %1%") -> TripletContainer
7762 __init__(TripletContainer self) -> TripletContainer
7764 if self.__class__ == TripletContainer:
7768 _IMP_kernel.TripletContainer_swiginit(self, _IMP_kernel.new_TripletContainer(_self, *args))
7770 if self.__class__ != TripletContainer:
7771 _director_objects.register(self)
7776 def do_apply(self, sm):
7777 r"""do_apply(TripletContainer self, TripletModifier sm)"""
7778 return _IMP_kernel.TripletContainer_do_apply(self, sm)
7780 def do_apply_moved(self, sm, moved_pis, reset_pis):
7781 r"""do_apply_moved(TripletContainer self, TripletModifier sm, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis)"""
7782 return _IMP_kernel.TripletContainer_do_apply_moved(self, sm, moved_pis, reset_pis)
7784 def do_get_provides_access(self):
7785 r"""do_get_provides_access(TripletContainer self) -> bool"""
7786 return _IMP_kernel.TripletContainer_do_get_provides_access(self)
7787 __swig_destroy__ = _IMP_kernel.delete_TripletContainer
7790 r"""__str__(TripletContainer self) -> std::string"""
7791 return _IMP_kernel.TripletContainer___str__(self)
7794 r"""__repr__(TripletContainer self) -> std::string"""
7795 return _IMP_kernel.TripletContainer___repr__(self)
7799 return _object_cast_to_TripletContainer(o)
7802 def do_show(self, out):
7807 return _object_cast_to_TripletContainer(o)
7809 def __disown__(self):
7811 _IMP_kernel.disown_TripletContainer(self)
7812 return weakref.proxy(self)
7815 r"""do_destroy(TripletContainer self)"""
7816 return _IMP_kernel.TripletContainer_do_destroy(self)
7818 def handle_set_has_required_score_states(self, arg0):
7819 r"""handle_set_has_required_score_states(TripletContainer self, bool arg0)"""
7820 return _IMP_kernel.TripletContainer_handle_set_has_required_score_states(self, arg0)
7822 def do_get_inputs(self):
7823 r"""do_get_inputs(TripletContainer self) -> IMP::ModelObjectsTemp"""
7824 return _IMP_kernel.TripletContainer_do_get_inputs(self)
7826 def do_get_interactions(self):
7827 r"""do_get_interactions(TripletContainer self) -> IMP::ModelObjectsTemps"""
7828 return _IMP_kernel.TripletContainer_do_get_interactions(self)
7830 def do_get_contents_hash(self):
7831 r"""do_get_contents_hash(TripletContainer self) -> std::size_t"""
7832 return _IMP_kernel.TripletContainer_do_get_contents_hash(self)
7835 _IMP_kernel.TripletContainer_swigregister(TripletContainer)
7836 class _TripletContainerAdaptor(_InputAdaptor):
7837 r"""Proxy of C++ IMP::TripletContainerAdaptor class."""
7839 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
7840 __repr__ = _swig_repr
7842 def __init__(self, *args):
7844 __init__(_TripletContainerAdaptor self) -> _TripletContainerAdaptor
7845 __init__(_TripletContainerAdaptor self, TripletContainer c) -> _TripletContainerAdaptor
7846 __init__(_TripletContainerAdaptor self, IMP::ParticleTripletsTemp const & t) -> _TripletContainerAdaptor
7848 _IMP_kernel._TripletContainerAdaptor_swiginit(self, _IMP_kernel.new__TripletContainerAdaptor(*args))
7850 def set_name_if_default(self, name):
7851 r"""set_name_if_default(_TripletContainerAdaptor self, std::string name)"""
7852 return _IMP_kernel._TripletContainerAdaptor_set_name_if_default(self, name)
7853 __swig_destroy__ = _IMP_kernel.delete__TripletContainerAdaptor
7856 _IMP_kernel._TripletContainerAdaptor_swigregister(_TripletContainerAdaptor)
7859 r"""write_particles_to_buffer(IMP::ParticlesTemp const & particles, IMP::FloatKeys const & keys) -> IMP::Vector< char,std::allocator< char > >"""
7860 return _IMP_kernel.write_particles_to_buffer(particles, keys)
7863 r"""read_particles_from_buffer(IMP::Vector< char,std::allocator< char > > const & buffer, IMP::ParticlesTemp const & particles, IMP::FloatKeys const & keys)"""
7864 return _IMP_kernel.read_particles_from_buffer(buffer, particles, keys)
7867 r"""get_particles(Model m, IMP::ParticleIndexes const & ps) -> IMP::ParticlesTemp"""
7868 return _IMP_kernel.get_particles(m, ps)
7872 get_indexes(IMP::ParticlesTemp const & ps) -> IMP::ParticleIndexes
7873 get_indexes(IMP::ParticlePairsTemp const & ps) -> IMP::ParticleIndexPairs
7875 return _IMP_kernel.get_indexes(*args)
7876 class _ParticleIndexAdaptor(object):
7877 r"""Proxy of C++ IMP::ParticleIndexAdaptor class."""
7879 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
7880 __repr__ = _swig_repr
7882 def __init__(self, *args):
7884 __init__(_ParticleIndexAdaptor self, Particle p) -> _ParticleIndexAdaptor
7885 __init__(_ParticleIndexAdaptor self, ParticleIndex pi) -> _ParticleIndexAdaptor
7886 __init__(_ParticleIndexAdaptor self, Decorator d) -> _ParticleIndexAdaptor
7888 _IMP_kernel._ParticleIndexAdaptor_swiginit(self, _IMP_kernel.new__ParticleIndexAdaptor(*args))
7889 __swig_destroy__ = _IMP_kernel.delete__ParticleIndexAdaptor
7892 _IMP_kernel._ParticleIndexAdaptor_swigregister(_ParticleIndexAdaptor)
7893 class _ParticleIndexesAdaptor(_InputAdaptor):
7894 r"""Proxy of C++ IMP::ParticleIndexesAdaptor class."""
7896 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
7897 __repr__ = _swig_repr
7899 def __init__(self, *args):
7901 __init__(_ParticleIndexesAdaptor self, IMP::ParticlesTemp const & ps) -> _ParticleIndexesAdaptor
7902 __init__(_ParticleIndexesAdaptor self, IMP::ParticleIndexes const & pi) -> _ParticleIndexesAdaptor
7903 __init__(_ParticleIndexesAdaptor self) -> _ParticleIndexesAdaptor
7905 _IMP_kernel._ParticleIndexesAdaptor_swiginit(self, _IMP_kernel.new__ParticleIndexesAdaptor(*args))
7906 __swig_destroy__ = _IMP_kernel.delete__ParticleIndexesAdaptor
7909 _IMP_kernel._ParticleIndexesAdaptor_swigregister(_ParticleIndexesAdaptor)
7910 class _ParticleIndexPairsAdaptor(object):
7911 r"""Proxy of C++ IMP::ParticleIndexPairsAdaptor class."""
7913 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
7914 __repr__ = _swig_repr
7916 def __init__(self, *args):
7918 __init__(_ParticleIndexPairsAdaptor self, IMP::ParticlePairsTemp const & ps) -> _ParticleIndexPairsAdaptor
7919 __init__(_ParticleIndexPairsAdaptor self, IMP::ParticleIndexPairs const & pi) -> _ParticleIndexPairsAdaptor
7920 __init__(_ParticleIndexPairsAdaptor self) -> _ParticleIndexPairsAdaptor
7922 _IMP_kernel._ParticleIndexPairsAdaptor_swiginit(self, _IMP_kernel.new__ParticleIndexPairsAdaptor(*args))
7923 __swig_destroy__ = _IMP_kernel.delete__ParticleIndexPairsAdaptor
7926 _IMP_kernel._ParticleIndexPairsAdaptor_swigregister(_ParticleIndexPairsAdaptor)
7928 r"""Proxy of C++ IMP::internal::_ConstRestraint class."""
7930 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
7932 def __init__(self, *args):
7934 __init__(_ConstRestraint self, Model m, IMP::ParticleIndexes const & pis, double v) -> _ConstRestraint
7935 __init__(_ConstRestraint self) -> _ConstRestraint
7937 _IMP_kernel._ConstRestraint_swiginit(self, _IMP_kernel.new__ConstRestraint(*args))
7939 def get_value(self):
7940 r"""get_value(_ConstRestraint self) -> double"""
7941 return _IMP_kernel._ConstRestraint_get_value(self)
7943 def do_create_decomposition(self):
7944 r"""do_create_decomposition(_ConstRestraint self) -> IMP::Restraints"""
7945 return _IMP_kernel._ConstRestraint_do_create_decomposition(self)
7947 def do_get_inputs(self):
7948 r"""do_get_inputs(_ConstRestraint self) -> IMP::ModelObjectsTemp"""
7949 return _IMP_kernel._ConstRestraint_do_get_inputs(self)
7952 r"""get_version_info(_ConstRestraint self) -> VersionInfo"""
7953 return _IMP_kernel._ConstRestraint_get_version_info(self)
7954 __swig_destroy__ = _IMP_kernel.delete__ConstRestraint
7957 r"""__str__(_ConstRestraint self) -> std::string"""
7958 return _IMP_kernel._ConstRestraint___str__(self)
7961 r"""__repr__(_ConstRestraint self) -> std::string"""
7962 return _IMP_kernel._ConstRestraint___repr__(self)
7966 return _object_cast_to__ConstRestraint(o)
7969 def _get_as_binary(self):
7970 r"""_get_as_binary(_ConstRestraint self) -> PyObject *"""
7971 return _IMP_kernel._ConstRestraint__get_as_binary(self)
7973 def _set_from_binary(self, p):
7974 r"""_set_from_binary(_ConstRestraint self, PyObject * p)"""
7975 return _IMP_kernel._ConstRestraint__set_from_binary(self, p)
7977 def __getstate__(self):
7978 p = self._get_as_binary()
7979 if len(self.__dict__) > 1:
7980 d = self.__dict__.copy()
7985 def __setstate__(self, p):
7986 if not hasattr(self,
'this'):
7988 if isinstance(p, tuple):
7990 self.__dict__.update(d)
7991 return self._set_from_binary(p)
7995 _IMP_kernel._ConstRestraint_swigregister(_ConstRestraint)
7997 r"""Proxy of C++ IMP::internal::_ConstSingletonScore class."""
7999 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
8001 def __init__(self, *args):
8003 __init__(_ConstSingletonScore self, double v) -> _ConstSingletonScore
8004 __init__(_ConstSingletonScore self) -> _ConstSingletonScore
8006 _IMP_kernel._ConstSingletonScore_swiginit(self, _IMP_kernel.new__ConstSingletonScore(*args))
8008 def do_get_inputs(self, arg2, arg3):
8009 r"""do_get_inputs(_ConstSingletonScore self, Model arg2, IMP::ParticleIndexes const & arg3) -> IMP::ModelObjectsTemp"""
8010 return _IMP_kernel._ConstSingletonScore_do_get_inputs(self, arg2, arg3)
8012 def evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked=False):
8013 r"""evaluate_indexes(_ConstSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
8014 return _IMP_kernel._ConstSingletonScore_evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked)
8016 def evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked=False):
8017 r"""evaluate_indexes_scores(_ConstSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
8018 return _IMP_kernel._ConstSingletonScore_evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked)
8020 def evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked=False):
8021 r"""evaluate_indexes_delta(_ConstSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, std::vector< unsigned int,std::allocator< unsigned int > > const & indexes, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
8022 return _IMP_kernel._ConstSingletonScore_evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked)
8024 def evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked=False):
8025 r"""evaluate_if_good_indexes(_ConstSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
8026 return _IMP_kernel._ConstSingletonScore_evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked)
8029 r"""get_version_info(_ConstSingletonScore self) -> VersionInfo"""
8030 return _IMP_kernel._ConstSingletonScore_get_version_info(self)
8031 __swig_destroy__ = _IMP_kernel.delete__ConstSingletonScore
8034 r"""__str__(_ConstSingletonScore self) -> std::string"""
8035 return _IMP_kernel._ConstSingletonScore___str__(self)
8038 r"""__repr__(_ConstSingletonScore self) -> std::string"""
8039 return _IMP_kernel._ConstSingletonScore___repr__(self)
8043 return _object_cast_to__ConstSingletonScore(o)
8046 def _get_as_binary(self):
8047 r"""_get_as_binary(_ConstSingletonScore self) -> PyObject *"""
8048 return _IMP_kernel._ConstSingletonScore__get_as_binary(self)
8050 def _set_from_binary(self, p):
8051 r"""_set_from_binary(_ConstSingletonScore self, PyObject * p)"""
8052 return _IMP_kernel._ConstSingletonScore__set_from_binary(self, p)
8054 def __getstate__(self):
8055 p = self._get_as_binary()
8056 if len(self.__dict__) > 1:
8057 d = self.__dict__.copy()
8062 def __setstate__(self, p):
8063 if not hasattr(self,
'this'):
8065 if isinstance(p, tuple):
8067 self.__dict__.update(d)
8068 return self._set_from_binary(p)
8072 _IMP_kernel._ConstSingletonScore_swigregister(_ConstSingletonScore)
8074 r"""Proxy of C++ IMP::internal::_ConstPairScore class."""
8076 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
8078 def __init__(self, *args):
8080 __init__(_ConstPairScore self, double v) -> _ConstPairScore
8081 __init__(_ConstPairScore self) -> _ConstPairScore
8083 _IMP_kernel._ConstPairScore_swiginit(self, _IMP_kernel.new__ConstPairScore(*args))
8085 def do_get_inputs(self, arg2, arg3):
8086 r"""do_get_inputs(_ConstPairScore self, Model arg2, IMP::ParticleIndexes const & arg3) -> IMP::ModelObjectsTemp"""
8087 return _IMP_kernel._ConstPairScore_do_get_inputs(self, arg2, arg3)
8089 def evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked=False):
8090 r"""evaluate_indexes(_ConstPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
8091 return _IMP_kernel._ConstPairScore_evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked)
8093 def evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked=False):
8094 r"""evaluate_indexes_scores(_ConstPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
8095 return _IMP_kernel._ConstPairScore_evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked)
8097 def evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked=False):
8098 r"""evaluate_indexes_delta(_ConstPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, std::vector< unsigned int,std::allocator< unsigned int > > const & indexes, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
8099 return _IMP_kernel._ConstPairScore_evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked)
8101 def evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked=False):
8102 r"""evaluate_if_good_indexes(_ConstPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
8103 return _IMP_kernel._ConstPairScore_evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked)
8106 r"""get_version_info(_ConstPairScore self) -> VersionInfo"""
8107 return _IMP_kernel._ConstPairScore_get_version_info(self)
8108 __swig_destroy__ = _IMP_kernel.delete__ConstPairScore
8111 r"""__str__(_ConstPairScore self) -> std::string"""
8112 return _IMP_kernel._ConstPairScore___str__(self)
8115 r"""__repr__(_ConstPairScore self) -> std::string"""
8116 return _IMP_kernel._ConstPairScore___repr__(self)
8120 return _object_cast_to__ConstPairScore(o)
8123 def _get_as_binary(self):
8124 r"""_get_as_binary(_ConstPairScore self) -> PyObject *"""
8125 return _IMP_kernel._ConstPairScore__get_as_binary(self)
8127 def _set_from_binary(self, p):
8128 r"""_set_from_binary(_ConstPairScore self, PyObject * p)"""
8129 return _IMP_kernel._ConstPairScore__set_from_binary(self, p)
8131 def __getstate__(self):
8132 p = self._get_as_binary()
8133 if len(self.__dict__) > 1:
8134 d = self.__dict__.copy()
8139 def __setstate__(self, p):
8140 if not hasattr(self,
'this'):
8142 if isinstance(p, tuple):
8144 self.__dict__.update(d)
8145 return self._set_from_binary(p)
8149 _IMP_kernel._ConstPairScore_swigregister(_ConstPairScore)
8151 r"""Proxy of C++ IMP::internal::_TrivialDecorator class."""
8153 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
8155 def __init__(self, *args):
8157 __init__(_TrivialDecorator self) -> _TrivialDecorator
8158 __init__(_TrivialDecorator self, Model m, ParticleIndex id) -> _TrivialDecorator
8159 __init__(_TrivialDecorator self, _ParticleAdaptor d) -> _TrivialDecorator
8161 _IMP_kernel._TrivialDecorator_swiginit(self, _IMP_kernel.new__TrivialDecorator(*args))
8163 def show(self, *args):
8164 r"""show(_TrivialDecorator self, _ostream out=std::cout)"""
8165 return _IMP_kernel._TrivialDecorator_show(self, *args)
8168 def setup_particle(*args):
8170 setup_particle(Model m, ParticleIndex pi) -> _TrivialDecorator
8171 setup_particle(_ParticleAdaptor pa) -> _TrivialDecorator
8173 return _IMP_kernel._TrivialDecorator_setup_particle(*args)
8176 def get_is_setup(*args):
8178 get_is_setup(_ParticleAdaptor p) -> bool
8179 get_is_setup(Model m, ParticleIndex pi) -> bool
8181 return _IMP_kernel._TrivialDecorator_get_is_setup(*args)
8185 add_attribute(_TrivialDecorator self, FloatKey k, IMP::Float v, bool opt)
8186 add_attribute(_TrivialDecorator self, FloatKey a0, IMP::Float a1)
8187 add_attribute(_TrivialDecorator self, IntKey a0, IMP::Int a1)
8188 add_attribute(_TrivialDecorator self, FloatsKey a0, IMP::Floats a1)
8189 add_attribute(_TrivialDecorator self, IntsKey a0, IMP::Ints a1)
8190 add_attribute(_TrivialDecorator self, StringKey a0, IMP::String a1)
8191 add_attribute(_TrivialDecorator self, ParticleIndexKey a0, Particle a1)
8192 add_attribute(_TrivialDecorator self, ObjectKey a0, Object a1)
8193 add_attribute(_TrivialDecorator self, SparseFloatKey a0, IMP::Float a1)
8194 add_attribute(_TrivialDecorator self, SparseIntKey a0, IMP::Int a1)
8195 add_attribute(_TrivialDecorator self, SparseStringKey a0, IMP::String a1)
8196 add_attribute(_TrivialDecorator self, SparseParticleIndexKey a0, ParticleIndex a1)
8198 return _IMP_kernel._TrivialDecorator_add_attribute(self, *args)
8200 def get_value(self, *args):
8202 get_value(_TrivialDecorator self, FloatKey a0) -> IMP::Float
8203 get_value(_TrivialDecorator self, IntKey a0) -> IMP::Int
8204 get_value(_TrivialDecorator self, FloatsKey a0) -> IMP::Floats
8205 get_value(_TrivialDecorator self, IntsKey a0) -> IMP::Ints
8206 get_value(_TrivialDecorator self, StringKey a0) -> IMP::String
8207 get_value(_TrivialDecorator self, ParticleIndexKey a0) -> Particle
8208 get_value(_TrivialDecorator self, ObjectKey a0) -> Object
8209 get_value(_TrivialDecorator self, SparseFloatKey a0) -> IMP::Float
8210 get_value(_TrivialDecorator self, SparseIntKey a0) -> IMP::Int
8211 get_value(_TrivialDecorator self, SparseStringKey a0) -> IMP::String
8212 get_value(_TrivialDecorator self, SparseParticleIndexKey a0) -> ParticleIndex
8214 return _IMP_kernel._TrivialDecorator_get_value(self, *args)
8216 def set_value(self, *args):
8218 set_value(_TrivialDecorator self, FloatKey a0, IMP::Float a1)
8219 set_value(_TrivialDecorator self, IntKey a0, IMP::Int a1)
8220 set_value(_TrivialDecorator self, FloatsKey a0, IMP::Floats a1)
8221 set_value(_TrivialDecorator self, IntsKey a0, IMP::Ints a1)
8222 set_value(_TrivialDecorator self, StringKey a0, IMP::String a1)
8223 set_value(_TrivialDecorator self, ParticleIndexKey a0, Particle a1)
8224 set_value(_TrivialDecorator self, ObjectKey a0, Object a1)
8225 set_value(_TrivialDecorator self, SparseFloatKey a0, IMP::Float a1)
8226 set_value(_TrivialDecorator self, SparseIntKey a0, IMP::Int a1)
8227 set_value(_TrivialDecorator self, SparseStringKey a0, IMP::String a1)
8228 set_value(_TrivialDecorator self, SparseParticleIndexKey a0, ParticleIndex a1)
8230 return _IMP_kernel._TrivialDecorator_set_value(self, *args)
8234 remove_attribute(_TrivialDecorator self, FloatKey a0)
8235 remove_attribute(_TrivialDecorator self, IntKey a0)
8236 remove_attribute(_TrivialDecorator self, FloatsKey a0)
8237 remove_attribute(_TrivialDecorator self, IntsKey a0)
8238 remove_attribute(_TrivialDecorator self, StringKey a0)
8239 remove_attribute(_TrivialDecorator self, ParticleIndexKey a0)
8240 remove_attribute(_TrivialDecorator self, ObjectKey a0)
8241 remove_attribute(_TrivialDecorator self, SparseFloatKey a0)
8242 remove_attribute(_TrivialDecorator self, SparseIntKey a0)
8243 remove_attribute(_TrivialDecorator self, SparseStringKey a0)
8244 remove_attribute(_TrivialDecorator self, SparseParticleIndexKey a0)
8246 return _IMP_kernel._TrivialDecorator_remove_attribute(self, *args)
8248 def has_attribute(self, *args):
8250 has_attribute(_TrivialDecorator self, FloatKey a0) -> bool
8251 has_attribute(_TrivialDecorator self, IntKey a0) -> bool
8252 has_attribute(_TrivialDecorator self, FloatsKey a0) -> bool
8253 has_attribute(_TrivialDecorator self, IntsKey a0) -> bool
8254 has_attribute(_TrivialDecorator self, StringKey a0) -> bool
8255 has_attribute(_TrivialDecorator self, ParticleIndexKey a0) -> bool
8256 has_attribute(_TrivialDecorator self, ObjectKey a0) -> bool
8257 has_attribute(_TrivialDecorator self, SparseFloatKey a0) -> bool
8258 has_attribute(_TrivialDecorator self, SparseIntKey a0) -> bool
8259 has_attribute(_TrivialDecorator self, SparseStringKey a0) -> bool
8260 has_attribute(_TrivialDecorator self, SparseParticleIndexKey a0) -> bool
8262 return _IMP_kernel._TrivialDecorator_has_attribute(self, *args)
8264 def get_derivative(self, a0):
8265 r"""get_derivative(_TrivialDecorator self, FloatKey a0) -> double"""
8266 return _IMP_kernel._TrivialDecorator_get_derivative(self, a0)
8269 r"""get_name(_TrivialDecorator self) -> std::string"""
8270 return _IMP_kernel._TrivialDecorator_get_name(self)
8273 r"""clear_caches(_TrivialDecorator self)"""
8274 return _IMP_kernel._TrivialDecorator_clear_caches(self)
8276 def set_name(self, a0):
8277 r"""set_name(_TrivialDecorator self, std::string a0)"""
8278 return _IMP_kernel._TrivialDecorator_set_name(self, a0)
8281 r"""set_check_level(_TrivialDecorator self, IMP::CheckLevel a0)"""
8282 return _IMP_kernel._TrivialDecorator_set_check_level(self, a0)
8284 def add_to_derivative(self, a0, a1, a2):
8285 r"""add_to_derivative(_TrivialDecorator self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
8286 return _IMP_kernel._TrivialDecorator_add_to_derivative(self, a0, a1, a2)
8289 r"""set_is_optimized(_TrivialDecorator self, FloatKey a0, bool a1)"""
8290 return _IMP_kernel._TrivialDecorator_set_is_optimized(self, a0, a1)
8292 def get_is_optimized(self, a0):
8293 r"""get_is_optimized(_TrivialDecorator self, FloatKey a0) -> bool"""
8294 return _IMP_kernel._TrivialDecorator_get_is_optimized(self, a0)
8296 def get_check_level(self):
8297 r"""get_check_level(_TrivialDecorator self) -> IMP::CheckLevel"""
8298 return _IMP_kernel._TrivialDecorator_get_check_level(self)
8300 def __eq__(self, *args):
8302 __eq__(_TrivialDecorator self, _TrivialDecorator o) -> bool
8303 __eq__(_TrivialDecorator self, Particle d) -> bool
8305 return _IMP_kernel._TrivialDecorator___eq__(self, *args)
8307 def __ne__(self, *args):
8309 __ne__(_TrivialDecorator self, _TrivialDecorator o) -> bool
8310 __ne__(_TrivialDecorator self, Particle d) -> bool
8312 return _IMP_kernel._TrivialDecorator___ne__(self, *args)
8314 def __le__(self, *args):
8316 __le__(_TrivialDecorator self, _TrivialDecorator o) -> bool
8317 __le__(_TrivialDecorator self, Particle d) -> bool
8319 return _IMP_kernel._TrivialDecorator___le__(self, *args)
8321 def __lt__(self, *args):
8323 __lt__(_TrivialDecorator self, _TrivialDecorator o) -> bool
8324 __lt__(_TrivialDecorator self, Particle d) -> bool
8326 return _IMP_kernel._TrivialDecorator___lt__(self, *args)
8328 def __ge__(self, *args):
8330 __ge__(_TrivialDecorator self, _TrivialDecorator o) -> bool
8331 __ge__(_TrivialDecorator self, Particle d) -> bool
8333 return _IMP_kernel._TrivialDecorator___ge__(self, *args)
8335 def __gt__(self, *args):
8337 __gt__(_TrivialDecorator self, _TrivialDecorator o) -> bool
8338 __gt__(_TrivialDecorator self, Particle d) -> bool
8340 return _IMP_kernel._TrivialDecorator___gt__(self, *args)
8343 r"""__hash__(_TrivialDecorator self) -> std::size_t"""
8344 return _IMP_kernel._TrivialDecorator___hash__(self)
8347 r"""__str__(_TrivialDecorator self) -> std::string"""
8348 return _IMP_kernel._TrivialDecorator___str__(self)
8351 r"""__repr__(_TrivialDecorator self) -> std::string"""
8352 return _IMP_kernel._TrivialDecorator___repr__(self)
8354 def _get_as_binary(self):
8355 r"""_get_as_binary(_TrivialDecorator self) -> PyObject *"""
8356 return _IMP_kernel._TrivialDecorator__get_as_binary(self)
8358 def _set_from_binary(self, p):
8359 r"""_set_from_binary(_TrivialDecorator self, PyObject * p)"""
8360 return _IMP_kernel._TrivialDecorator__set_from_binary(self, p)
8362 def __getstate__(self):
8363 p = self._get_as_binary()
8364 if len(self.__dict__) > 1:
8365 d = self.__dict__.copy()
8370 def __setstate__(self, p):
8371 if not hasattr(self,
'this'):
8373 if isinstance(p, tuple):
8375 self.__dict__.update(d)
8376 return self._set_from_binary(p)
8378 __swig_destroy__ = _IMP_kernel.delete__TrivialDecorator
8381 _IMP_kernel._TrivialDecorator_swigregister(_TrivialDecorator)
8382 class _TrivialDerivedDecorator(_TrivialDecorator):
8383 r"""Proxy of C++ IMP::internal::_TrivialDerivedDecorator class."""
8385 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
8387 def __init__(self, *args):
8389 __init__(_TrivialDerivedDecorator self) -> _TrivialDerivedDecorator
8390 __init__(_TrivialDerivedDecorator self, Model m, ParticleIndex id) -> _TrivialDerivedDecorator
8391 __init__(_TrivialDerivedDecorator self, _ParticleAdaptor d) -> _TrivialDerivedDecorator
8393 _IMP_kernel._TrivialDerivedDecorator_swiginit(self, _IMP_kernel.new__TrivialDerivedDecorator(*args))
8395 def show(self, *args):
8396 r"""show(_TrivialDerivedDecorator self, _ostream out=std::cout)"""
8397 return _IMP_kernel._TrivialDerivedDecorator_show(self, *args)
8400 def setup_particle(*args):
8402 setup_particle(Model m, ParticleIndex pi) -> _TrivialDerivedDecorator
8403 setup_particle(_ParticleAdaptor pa) -> _TrivialDerivedDecorator
8405 return _IMP_kernel._TrivialDerivedDecorator_setup_particle(*args)
8408 def get_is_setup(*args):
8410 get_is_setup(_ParticleAdaptor p) -> bool
8411 get_is_setup(Model m, ParticleIndex pi) -> bool
8413 return _IMP_kernel._TrivialDerivedDecorator_get_is_setup(*args)
8417 add_attribute(_TrivialDerivedDecorator self, FloatKey k, IMP::Float v, bool opt)
8418 add_attribute(_TrivialDerivedDecorator self, FloatKey a0, IMP::Float a1)
8419 add_attribute(_TrivialDerivedDecorator self, IntKey a0, IMP::Int a1)
8420 add_attribute(_TrivialDerivedDecorator self, FloatsKey a0, IMP::Floats a1)
8421 add_attribute(_TrivialDerivedDecorator self, IntsKey a0, IMP::Ints a1)
8422 add_attribute(_TrivialDerivedDecorator self, StringKey a0, IMP::String a1)
8423 add_attribute(_TrivialDerivedDecorator self, ParticleIndexKey a0, Particle a1)
8424 add_attribute(_TrivialDerivedDecorator self, ObjectKey a0, Object a1)
8425 add_attribute(_TrivialDerivedDecorator self, SparseFloatKey a0, IMP::Float a1)
8426 add_attribute(_TrivialDerivedDecorator self, SparseIntKey a0, IMP::Int a1)
8427 add_attribute(_TrivialDerivedDecorator self, SparseStringKey a0, IMP::String a1)
8428 add_attribute(_TrivialDerivedDecorator self, SparseParticleIndexKey a0, ParticleIndex a1)
8430 return _IMP_kernel._TrivialDerivedDecorator_add_attribute(self, *args)
8432 def get_value(self, *args):
8434 get_value(_TrivialDerivedDecorator self, FloatKey a0) -> IMP::Float
8435 get_value(_TrivialDerivedDecorator self, IntKey a0) -> IMP::Int
8436 get_value(_TrivialDerivedDecorator self, FloatsKey a0) -> IMP::Floats
8437 get_value(_TrivialDerivedDecorator self, IntsKey a0) -> IMP::Ints
8438 get_value(_TrivialDerivedDecorator self, StringKey a0) -> IMP::String
8439 get_value(_TrivialDerivedDecorator self, ParticleIndexKey a0) -> Particle
8440 get_value(_TrivialDerivedDecorator self, ObjectKey a0) -> Object
8441 get_value(_TrivialDerivedDecorator self, SparseFloatKey a0) -> IMP::Float
8442 get_value(_TrivialDerivedDecorator self, SparseIntKey a0) -> IMP::Int
8443 get_value(_TrivialDerivedDecorator self, SparseStringKey a0) -> IMP::String
8444 get_value(_TrivialDerivedDecorator self, SparseParticleIndexKey a0) -> ParticleIndex
8446 return _IMP_kernel._TrivialDerivedDecorator_get_value(self, *args)
8448 def set_value(self, *args):
8450 set_value(_TrivialDerivedDecorator self, FloatKey a0, IMP::Float a1)
8451 set_value(_TrivialDerivedDecorator self, IntKey a0, IMP::Int a1)
8452 set_value(_TrivialDerivedDecorator self, FloatsKey a0, IMP::Floats a1)
8453 set_value(_TrivialDerivedDecorator self, IntsKey a0, IMP::Ints a1)
8454 set_value(_TrivialDerivedDecorator self, StringKey a0, IMP::String a1)
8455 set_value(_TrivialDerivedDecorator self, ParticleIndexKey a0, Particle a1)
8456 set_value(_TrivialDerivedDecorator self, ObjectKey a0, Object a1)
8457 set_value(_TrivialDerivedDecorator self, SparseFloatKey a0, IMP::Float a1)
8458 set_value(_TrivialDerivedDecorator self, SparseIntKey a0, IMP::Int a1)
8459 set_value(_TrivialDerivedDecorator self, SparseStringKey a0, IMP::String a1)
8460 set_value(_TrivialDerivedDecorator self, SparseParticleIndexKey a0, ParticleIndex a1)
8462 return _IMP_kernel._TrivialDerivedDecorator_set_value(self, *args)
8466 remove_attribute(_TrivialDerivedDecorator self, FloatKey a0)
8467 remove_attribute(_TrivialDerivedDecorator self, IntKey a0)
8468 remove_attribute(_TrivialDerivedDecorator self, FloatsKey a0)
8469 remove_attribute(_TrivialDerivedDecorator self, IntsKey a0)
8470 remove_attribute(_TrivialDerivedDecorator self, StringKey a0)
8471 remove_attribute(_TrivialDerivedDecorator self, ParticleIndexKey a0)
8472 remove_attribute(_TrivialDerivedDecorator self, ObjectKey a0)
8473 remove_attribute(_TrivialDerivedDecorator self, SparseFloatKey a0)
8474 remove_attribute(_TrivialDerivedDecorator self, SparseIntKey a0)
8475 remove_attribute(_TrivialDerivedDecorator self, SparseStringKey a0)
8476 remove_attribute(_TrivialDerivedDecorator self, SparseParticleIndexKey a0)
8478 return _IMP_kernel._TrivialDerivedDecorator_remove_attribute(self, *args)
8480 def has_attribute(self, *args):
8482 has_attribute(_TrivialDerivedDecorator self, FloatKey a0) -> bool
8483 has_attribute(_TrivialDerivedDecorator self, IntKey a0) -> bool
8484 has_attribute(_TrivialDerivedDecorator self, FloatsKey a0) -> bool
8485 has_attribute(_TrivialDerivedDecorator self, IntsKey a0) -> bool
8486 has_attribute(_TrivialDerivedDecorator self, StringKey a0) -> bool
8487 has_attribute(_TrivialDerivedDecorator self, ParticleIndexKey a0) -> bool
8488 has_attribute(_TrivialDerivedDecorator self, ObjectKey a0) -> bool
8489 has_attribute(_TrivialDerivedDecorator self, SparseFloatKey a0) -> bool
8490 has_attribute(_TrivialDerivedDecorator self, SparseIntKey a0) -> bool
8491 has_attribute(_TrivialDerivedDecorator self, SparseStringKey a0) -> bool
8492 has_attribute(_TrivialDerivedDecorator self, SparseParticleIndexKey a0) -> bool
8494 return _IMP_kernel._TrivialDerivedDecorator_has_attribute(self, *args)
8496 def get_derivative(self, a0):
8497 r"""get_derivative(_TrivialDerivedDecorator self, FloatKey a0) -> double"""
8498 return _IMP_kernel._TrivialDerivedDecorator_get_derivative(self, a0)
8501 r"""get_name(_TrivialDerivedDecorator self) -> std::string"""
8502 return _IMP_kernel._TrivialDerivedDecorator_get_name(self)
8505 r"""clear_caches(_TrivialDerivedDecorator self)"""
8506 return _IMP_kernel._TrivialDerivedDecorator_clear_caches(self)
8508 def set_name(self, a0):
8509 r"""set_name(_TrivialDerivedDecorator self, std::string a0)"""
8510 return _IMP_kernel._TrivialDerivedDecorator_set_name(self, a0)
8513 r"""set_check_level(_TrivialDerivedDecorator self, IMP::CheckLevel a0)"""
8514 return _IMP_kernel._TrivialDerivedDecorator_set_check_level(self, a0)
8516 def add_to_derivative(self, a0, a1, a2):
8517 r"""add_to_derivative(_TrivialDerivedDecorator self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
8518 return _IMP_kernel._TrivialDerivedDecorator_add_to_derivative(self, a0, a1, a2)
8521 r"""set_is_optimized(_TrivialDerivedDecorator self, FloatKey a0, bool a1)"""
8522 return _IMP_kernel._TrivialDerivedDecorator_set_is_optimized(self, a0, a1)
8524 def get_is_optimized(self, a0):
8525 r"""get_is_optimized(_TrivialDerivedDecorator self, FloatKey a0) -> bool"""
8526 return _IMP_kernel._TrivialDerivedDecorator_get_is_optimized(self, a0)
8528 def get_check_level(self):
8529 r"""get_check_level(_TrivialDerivedDecorator self) -> IMP::CheckLevel"""
8530 return _IMP_kernel._TrivialDerivedDecorator_get_check_level(self)
8532 def __eq__(self, *args):
8534 __eq__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
8535 __eq__(_TrivialDerivedDecorator self, Particle d) -> bool
8537 return _IMP_kernel._TrivialDerivedDecorator___eq__(self, *args)
8539 def __ne__(self, *args):
8541 __ne__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
8542 __ne__(_TrivialDerivedDecorator self, Particle d) -> bool
8544 return _IMP_kernel._TrivialDerivedDecorator___ne__(self, *args)
8546 def __le__(self, *args):
8548 __le__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
8549 __le__(_TrivialDerivedDecorator self, Particle d) -> bool
8551 return _IMP_kernel._TrivialDerivedDecorator___le__(self, *args)
8553 def __lt__(self, *args):
8555 __lt__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
8556 __lt__(_TrivialDerivedDecorator self, Particle d) -> bool
8558 return _IMP_kernel._TrivialDerivedDecorator___lt__(self, *args)
8560 def __ge__(self, *args):
8562 __ge__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
8563 __ge__(_TrivialDerivedDecorator self, Particle d) -> bool
8565 return _IMP_kernel._TrivialDerivedDecorator___ge__(self, *args)
8567 def __gt__(self, *args):
8569 __gt__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
8570 __gt__(_TrivialDerivedDecorator self, Particle d) -> bool
8572 return _IMP_kernel._TrivialDerivedDecorator___gt__(self, *args)
8575 r"""__hash__(_TrivialDerivedDecorator self) -> std::size_t"""
8576 return _IMP_kernel._TrivialDerivedDecorator___hash__(self)
8579 r"""__str__(_TrivialDerivedDecorator self) -> std::string"""
8580 return _IMP_kernel._TrivialDerivedDecorator___str__(self)
8583 r"""__repr__(_TrivialDerivedDecorator self) -> std::string"""
8584 return _IMP_kernel._TrivialDerivedDecorator___repr__(self)
8586 def _get_as_binary(self):
8587 r"""_get_as_binary(_TrivialDerivedDecorator self) -> PyObject *"""
8588 return _IMP_kernel._TrivialDerivedDecorator__get_as_binary(self)
8590 def _set_from_binary(self, p):
8591 r"""_set_from_binary(_TrivialDerivedDecorator self, PyObject * p)"""
8592 return _IMP_kernel._TrivialDerivedDecorator__set_from_binary(self, p)
8594 def __getstate__(self):
8595 p = self._get_as_binary()
8596 if len(self.__dict__) > 1:
8597 d = self.__dict__.copy()
8602 def __setstate__(self, p):
8603 if not hasattr(self,
'this'):
8605 if isinstance(p, tuple):
8607 self.__dict__.update(d)
8608 return self._set_from_binary(p)
8610 __swig_destroy__ = _IMP_kernel.delete__TrivialDerivedDecorator
8613 _IMP_kernel._TrivialDerivedDecorator_swigregister(_TrivialDerivedDecorator)
8614 class _TrivialTraitsDecorator(
Decorator):
8615 r"""Proxy of C++ IMP::internal::_TrivialTraitsDecorator class."""
8617 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
8619 def get_decorator_traits(self):
8620 r"""get_decorator_traits(_TrivialTraitsDecorator self) -> StringKey"""
8621 return _IMP_kernel._TrivialTraitsDecorator_get_decorator_traits(self)
8624 def get_default_decorator_traits():
8625 r"""get_default_decorator_traits() -> StringKey"""
8626 return _IMP_kernel._TrivialTraitsDecorator_get_default_decorator_traits()
8628 def __init__(self, *args):
8630 __init__(_TrivialTraitsDecorator self) -> _TrivialTraitsDecorator
8631 __init__(_TrivialTraitsDecorator self, Model m, ParticleIndex id, StringKey tr=get_default_key()) -> _TrivialTraitsDecorator
8632 __init__(_TrivialTraitsDecorator self, _ParticleAdaptor d, StringKey tr=get_default_key()) -> _TrivialTraitsDecorator
8634 _IMP_kernel._TrivialTraitsDecorator_swiginit(self, _IMP_kernel.new__TrivialTraitsDecorator(*args))
8636 def show(self, *args):
8637 r"""show(_TrivialTraitsDecorator self, _ostream out=std::cout)"""
8638 return _IMP_kernel._TrivialTraitsDecorator_show(self, *args)
8641 def setup_particle(*args):
8643 setup_particle(Model m, ParticleIndex pi, StringKey tr=IMP::internal::_TrivialTraitsDecorator::get_default_decorator_traits()) -> _TrivialTraitsDecorator
8644 setup_particle(_ParticleAdaptor d, StringKey tr=IMP::internal::_TrivialTraitsDecorator::get_default_decorator_traits()) -> _TrivialTraitsDecorator
8646 return _IMP_kernel._TrivialTraitsDecorator_setup_particle(*args)
8649 def get_is_setup(*args):
8651 get_is_setup(_ParticleAdaptor p, StringKey tr=get_default_key()) -> bool
8652 get_is_setup(Model m, ParticleIndex pi, StringKey k=get_default_key()) -> bool
8654 return _IMP_kernel._TrivialTraitsDecorator_get_is_setup(*args)
8657 def get_default_key():
8658 r"""get_default_key() -> StringKey"""
8659 return _IMP_kernel._TrivialTraitsDecorator_get_default_key()
8663 add_attribute(_TrivialTraitsDecorator self, FloatKey k, IMP::Float v, bool opt)
8664 add_attribute(_TrivialTraitsDecorator self, FloatKey a0, IMP::Float a1)
8665 add_attribute(_TrivialTraitsDecorator self, IntKey a0, IMP::Int a1)
8666 add_attribute(_TrivialTraitsDecorator self, FloatsKey a0, IMP::Floats a1)
8667 add_attribute(_TrivialTraitsDecorator self, IntsKey a0, IMP::Ints a1)
8668 add_attribute(_TrivialTraitsDecorator self, StringKey a0, IMP::String a1)
8669 add_attribute(_TrivialTraitsDecorator self, ParticleIndexKey a0, Particle a1)
8670 add_attribute(_TrivialTraitsDecorator self, ObjectKey a0, Object a1)
8671 add_attribute(_TrivialTraitsDecorator self, SparseFloatKey a0, IMP::Float a1)
8672 add_attribute(_TrivialTraitsDecorator self, SparseIntKey a0, IMP::Int a1)
8673 add_attribute(_TrivialTraitsDecorator self, SparseStringKey a0, IMP::String a1)
8674 add_attribute(_TrivialTraitsDecorator self, SparseParticleIndexKey a0, ParticleIndex a1)
8676 return _IMP_kernel._TrivialTraitsDecorator_add_attribute(self, *args)
8678 def get_value(self, *args):
8680 get_value(_TrivialTraitsDecorator self, FloatKey a0) -> IMP::Float
8681 get_value(_TrivialTraitsDecorator self, IntKey a0) -> IMP::Int
8682 get_value(_TrivialTraitsDecorator self, FloatsKey a0) -> IMP::Floats
8683 get_value(_TrivialTraitsDecorator self, IntsKey a0) -> IMP::Ints
8684 get_value(_TrivialTraitsDecorator self, StringKey a0) -> IMP::String
8685 get_value(_TrivialTraitsDecorator self, ParticleIndexKey a0) -> Particle
8686 get_value(_TrivialTraitsDecorator self, ObjectKey a0) -> Object
8687 get_value(_TrivialTraitsDecorator self, SparseFloatKey a0) -> IMP::Float
8688 get_value(_TrivialTraitsDecorator self, SparseIntKey a0) -> IMP::Int
8689 get_value(_TrivialTraitsDecorator self, SparseStringKey a0) -> IMP::String
8690 get_value(_TrivialTraitsDecorator self, SparseParticleIndexKey a0) -> ParticleIndex
8692 return _IMP_kernel._TrivialTraitsDecorator_get_value(self, *args)
8694 def set_value(self, *args):
8696 set_value(_TrivialTraitsDecorator self, FloatKey a0, IMP::Float a1)
8697 set_value(_TrivialTraitsDecorator self, IntKey a0, IMP::Int a1)
8698 set_value(_TrivialTraitsDecorator self, FloatsKey a0, IMP::Floats a1)
8699 set_value(_TrivialTraitsDecorator self, IntsKey a0, IMP::Ints a1)
8700 set_value(_TrivialTraitsDecorator self, StringKey a0, IMP::String a1)
8701 set_value(_TrivialTraitsDecorator self, ParticleIndexKey a0, Particle a1)
8702 set_value(_TrivialTraitsDecorator self, ObjectKey a0, Object a1)
8703 set_value(_TrivialTraitsDecorator self, SparseFloatKey a0, IMP::Float a1)
8704 set_value(_TrivialTraitsDecorator self, SparseIntKey a0, IMP::Int a1)
8705 set_value(_TrivialTraitsDecorator self, SparseStringKey a0, IMP::String a1)
8706 set_value(_TrivialTraitsDecorator self, SparseParticleIndexKey a0, ParticleIndex a1)
8708 return _IMP_kernel._TrivialTraitsDecorator_set_value(self, *args)
8712 remove_attribute(_TrivialTraitsDecorator self, FloatKey a0)
8713 remove_attribute(_TrivialTraitsDecorator self, IntKey a0)
8714 remove_attribute(_TrivialTraitsDecorator self, FloatsKey a0)
8715 remove_attribute(_TrivialTraitsDecorator self, IntsKey a0)
8716 remove_attribute(_TrivialTraitsDecorator self, StringKey a0)
8717 remove_attribute(_TrivialTraitsDecorator self, ParticleIndexKey a0)
8718 remove_attribute(_TrivialTraitsDecorator self, ObjectKey a0)
8719 remove_attribute(_TrivialTraitsDecorator self, SparseFloatKey a0)
8720 remove_attribute(_TrivialTraitsDecorator self, SparseIntKey a0)
8721 remove_attribute(_TrivialTraitsDecorator self, SparseStringKey a0)
8722 remove_attribute(_TrivialTraitsDecorator self, SparseParticleIndexKey a0)
8724 return _IMP_kernel._TrivialTraitsDecorator_remove_attribute(self, *args)
8726 def has_attribute(self, *args):
8728 has_attribute(_TrivialTraitsDecorator self, FloatKey a0) -> bool
8729 has_attribute(_TrivialTraitsDecorator self, IntKey a0) -> bool
8730 has_attribute(_TrivialTraitsDecorator self, FloatsKey a0) -> bool
8731 has_attribute(_TrivialTraitsDecorator self, IntsKey a0) -> bool
8732 has_attribute(_TrivialTraitsDecorator self, StringKey a0) -> bool
8733 has_attribute(_TrivialTraitsDecorator self, ParticleIndexKey a0) -> bool
8734 has_attribute(_TrivialTraitsDecorator self, ObjectKey a0) -> bool
8735 has_attribute(_TrivialTraitsDecorator self, SparseFloatKey a0) -> bool
8736 has_attribute(_TrivialTraitsDecorator self, SparseIntKey a0) -> bool
8737 has_attribute(_TrivialTraitsDecorator self, SparseStringKey a0) -> bool
8738 has_attribute(_TrivialTraitsDecorator self, SparseParticleIndexKey a0) -> bool
8740 return _IMP_kernel._TrivialTraitsDecorator_has_attribute(self, *args)
8742 def get_derivative(self, a0):
8743 r"""get_derivative(_TrivialTraitsDecorator self, FloatKey a0) -> double"""
8744 return _IMP_kernel._TrivialTraitsDecorator_get_derivative(self, a0)
8747 r"""get_name(_TrivialTraitsDecorator self) -> std::string"""
8748 return _IMP_kernel._TrivialTraitsDecorator_get_name(self)
8751 r"""clear_caches(_TrivialTraitsDecorator self)"""
8752 return _IMP_kernel._TrivialTraitsDecorator_clear_caches(self)
8754 def set_name(self, a0):
8755 r"""set_name(_TrivialTraitsDecorator self, std::string a0)"""
8756 return _IMP_kernel._TrivialTraitsDecorator_set_name(self, a0)
8759 r"""set_check_level(_TrivialTraitsDecorator self, IMP::CheckLevel a0)"""
8760 return _IMP_kernel._TrivialTraitsDecorator_set_check_level(self, a0)
8762 def add_to_derivative(self, a0, a1, a2):
8763 r"""add_to_derivative(_TrivialTraitsDecorator self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
8764 return _IMP_kernel._TrivialTraitsDecorator_add_to_derivative(self, a0, a1, a2)
8767 r"""set_is_optimized(_TrivialTraitsDecorator self, FloatKey a0, bool a1)"""
8768 return _IMP_kernel._TrivialTraitsDecorator_set_is_optimized(self, a0, a1)
8770 def get_is_optimized(self, a0):
8771 r"""get_is_optimized(_TrivialTraitsDecorator self, FloatKey a0) -> bool"""
8772 return _IMP_kernel._TrivialTraitsDecorator_get_is_optimized(self, a0)
8774 def get_check_level(self):
8775 r"""get_check_level(_TrivialTraitsDecorator self) -> IMP::CheckLevel"""
8776 return _IMP_kernel._TrivialTraitsDecorator_get_check_level(self)
8778 def __eq__(self, *args):
8780 __eq__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
8781 __eq__(_TrivialTraitsDecorator self, Particle d) -> bool
8783 return _IMP_kernel._TrivialTraitsDecorator___eq__(self, *args)
8785 def __ne__(self, *args):
8787 __ne__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
8788 __ne__(_TrivialTraitsDecorator self, Particle d) -> bool
8790 return _IMP_kernel._TrivialTraitsDecorator___ne__(self, *args)
8792 def __le__(self, *args):
8794 __le__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
8795 __le__(_TrivialTraitsDecorator self, Particle d) -> bool
8797 return _IMP_kernel._TrivialTraitsDecorator___le__(self, *args)
8799 def __lt__(self, *args):
8801 __lt__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
8802 __lt__(_TrivialTraitsDecorator self, Particle d) -> bool
8804 return _IMP_kernel._TrivialTraitsDecorator___lt__(self, *args)
8806 def __ge__(self, *args):
8808 __ge__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
8809 __ge__(_TrivialTraitsDecorator self, Particle d) -> bool
8811 return _IMP_kernel._TrivialTraitsDecorator___ge__(self, *args)
8813 def __gt__(self, *args):
8815 __gt__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
8816 __gt__(_TrivialTraitsDecorator self, Particle d) -> bool
8818 return _IMP_kernel._TrivialTraitsDecorator___gt__(self, *args)
8821 r"""__hash__(_TrivialTraitsDecorator self) -> std::size_t"""
8822 return _IMP_kernel._TrivialTraitsDecorator___hash__(self)
8825 r"""__str__(_TrivialTraitsDecorator self) -> std::string"""
8826 return _IMP_kernel._TrivialTraitsDecorator___str__(self)
8829 r"""__repr__(_TrivialTraitsDecorator self) -> std::string"""
8830 return _IMP_kernel._TrivialTraitsDecorator___repr__(self)
8831 __swig_destroy__ = _IMP_kernel.delete__TrivialTraitsDecorator
8834 _IMP_kernel._TrivialTraitsDecorator_swigregister(_TrivialTraitsDecorator)
8836 def __lshift__(*args):
8838 __lshift__(_ostream out, _TrivialDecorator n) -> _ostream
8839 __lshift__(_ostream out, _TrivialDerivedDecorator n) -> _ostream
8840 __lshift__(_ostream out, _TrivialTraitsDecorator n) -> _ostream
8842 return _IMP_kernel.__lshift__(*args)
8844 r"""Proxy of C++ IMP::internal::_ConstOptimizer class."""
8846 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
8848 def __init__(self, *args):
8850 __init__(_ConstOptimizer self, Model m) -> _ConstOptimizer
8851 __init__(_ConstOptimizer self) -> _ConstOptimizer
8853 _IMP_kernel._ConstOptimizer_swiginit(self, _IMP_kernel.new__ConstOptimizer(*args))
8855 def do_optimize(self, max_steps):
8856 r"""do_optimize(_ConstOptimizer self, unsigned int max_steps) -> IMP::Float"""
8857 return _IMP_kernel._ConstOptimizer_do_optimize(self, max_steps)
8860 r"""get_version_info(_ConstOptimizer self) -> VersionInfo"""
8861 return _IMP_kernel._ConstOptimizer_get_version_info(self)
8862 __swig_destroy__ = _IMP_kernel.delete__ConstOptimizer
8865 r"""__str__(_ConstOptimizer self) -> std::string"""
8866 return _IMP_kernel._ConstOptimizer___str__(self)
8869 r"""__repr__(_ConstOptimizer self) -> std::string"""
8870 return _IMP_kernel._ConstOptimizer___repr__(self)
8874 return _object_cast_to__ConstOptimizer(o)
8877 def _get_as_binary(self):
8878 r"""_get_as_binary(_ConstOptimizer self) -> PyObject *"""
8879 return _IMP_kernel._ConstOptimizer__get_as_binary(self)
8881 def _set_from_binary(self, p):
8882 r"""_set_from_binary(_ConstOptimizer self, PyObject * p)"""
8883 return _IMP_kernel._ConstOptimizer__set_from_binary(self, p)
8885 def __getstate__(self):
8886 p = self._get_as_binary()
8887 if len(self.__dict__) > 1:
8888 d = self.__dict__.copy()
8893 def __setstate__(self, p):
8894 if not hasattr(self,
'this'):
8896 if isinstance(p, tuple):
8898 self.__dict__.update(d)
8899 return self._set_from_binary(p)
8903 _IMP_kernel._ConstOptimizer_swigregister(_ConstOptimizer)
8906 r"""get_particle(Particle p) -> Particle"""
8907 return _IMP_kernel.get_particle(p)
8909 def _decorator_test(p):
8910 r"""_decorator_test(Particle p)"""
8911 return _IMP_kernel._decorator_test(p)
8913 def _overloaded_decorator(*args):
8915 _overloaded_decorator(_TrivialDecorator a) -> int
8916 _overloaded_decorator(_TrivialDerivedDecorator a) -> int
8918 return _IMP_kernel._overloaded_decorator(*args)
8920 def _take_particles(*args):
8922 _take_particles(IMP::Particles const & ps) -> unsigned int
8923 _take_particles(Model m, IMP::Particles const & ps) -> unsigned int
8924 _take_particles(Model m, IMP::Particles const & ps, TextOutput out) -> unsigned int
8926 return _IMP_kernel._take_particles(*args)
8928 def _give_particles(m):
8929 r"""_give_particles(Model m) -> IMP::Particles const &"""
8930 return _IMP_kernel._give_particles(m)
8932 def _pass_particles(ps):
8933 r"""_pass_particles(IMP::Particles const & ps) -> IMP::Particles const &"""
8934 return _IMP_kernel._pass_particles(ps)
8936 def _pass_particle(ps):
8937 r"""_pass_particle(Particle ps) -> Particle"""
8938 return _IMP_kernel._pass_particle(ps)
8940 def _pass_particle_pair(pp):
8941 r"""_pass_particle_pair(IMP::ParticlePair const & pp) -> IMP::ParticlePair const &"""
8942 return _IMP_kernel._pass_particle_pair(pp)
8944 def _give_particles_copy(m):
8945 r"""_give_particles_copy(Model m) -> IMP::Particles"""
8946 return _IMP_kernel._give_particles_copy(m)
8948 def _pass_float_keys(input):
8949 r"""_pass_float_keys(IMP::FloatKeys const & input) -> IMP::FloatKeys"""
8950 return _IMP_kernel._pass_float_keys(input)
8954 _pass(IMP::Particles const & p) -> IMP::Particles const
8955 _pass(IMP::Restraints const & p) -> IMP::Restraints const &
8957 return _IMP_kernel._pass(*args)
8959 def _pass_decorators(p):
8960 r"""_pass_decorators(IMP::internal::_TrivialDecorators const & p) -> IMP::internal::_TrivialDecorators const &"""
8961 return _IMP_kernel._pass_decorators(p)
8963 def _pass_decorator_traits(p):
8964 r"""_pass_decorator_traits(IMP::internal::_TrivialTraitsDecorators const & p) -> IMP::internal::_TrivialTraitsDecorators const &"""
8965 return _IMP_kernel._pass_decorator_traits(p)
8967 def _pass_particle_pairs(p):
8968 r"""_pass_particle_pairs(IMP::ParticlePairsTemp const & p) -> IMP::ParticlePairsTemp"""
8969 return _IMP_kernel._pass_particle_pairs(p)
8971 def _pass_particle_index_pairs(p):
8972 r"""_pass_particle_index_pairs(IMP::ParticleIndexPairs const & p) -> IMP::ParticleIndexPairs"""
8973 return _IMP_kernel._pass_particle_index_pairs(p)
8975 def _pass_model_objects(p):
8976 r"""_pass_model_objects(IMP::ModelObjectsTemp const & p) -> IMP::ModelObjectsTemp"""
8977 return _IMP_kernel._pass_model_objects(p)
8979 def _pass_particles_temps(ps):
8980 r"""_pass_particles_temps(IMP::ParticlesTemps const & ps) -> IMP::ParticlesTemps"""
8981 return _IMP_kernel._pass_particles_temps(ps)
8983 def _test_overload(*args):
8985 _test_overload(IMP::Particles const & ps) -> int
8986 _test_overload(IMP::Restraints const & ps) -> int
8988 return _IMP_kernel._test_overload(*args)
8990 def _get_range(m, k):
8991 r"""_get_range(Model m, FloatKey k) -> IMP::FloatRange"""
8992 return _IMP_kernel._get_range(m, k)
8994 def _create_particles_from_pdb(name, m):
8995 r"""_create_particles_from_pdb(std::string name, Model m) -> IMP::ParticleIndexes"""
8996 return _IMP_kernel._create_particles_from_pdb(name, m)
8998 r"""Proxy of C++ IMP::internal::_LogPairScore class."""
9000 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
9001 __repr__ = _swig_repr
9004 r"""__init__(_LogPairScore self) -> _LogPairScore"""
9005 _IMP_kernel._LogPairScore_swiginit(self, _IMP_kernel.new__LogPairScore())
9007 def do_get_inputs(self, arg2, arg3):
9008 r"""do_get_inputs(_LogPairScore self, Model arg2, IMP::ParticleIndexes const & arg3) -> IMP::ModelObjectsTemp"""
9009 return _IMP_kernel._LogPairScore_do_get_inputs(self, arg2, arg3)
9011 def evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked=False):
9012 r"""evaluate_indexes(_LogPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
9013 return _IMP_kernel._LogPairScore_evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked)
9015 def evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked=False):
9016 r"""evaluate_indexes_scores(_LogPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
9017 return _IMP_kernel._LogPairScore_evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked)
9019 def evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked=False):
9020 r"""evaluate_indexes_delta(_LogPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, std::vector< unsigned int,std::allocator< unsigned int > > const & indexes, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
9021 return _IMP_kernel._LogPairScore_evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked)
9023 def evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked=False):
9024 r"""evaluate_if_good_indexes(_LogPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
9025 return _IMP_kernel._LogPairScore_evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked)
9028 r"""get_version_info(_LogPairScore self) -> VersionInfo"""
9029 return _IMP_kernel._LogPairScore_get_version_info(self)
9030 __swig_destroy__ = _IMP_kernel.delete__LogPairScore
9032 def get_particle_pairs(self):
9033 r"""get_particle_pairs(_LogPairScore self) -> IMP::ParticlePairsTemp"""
9034 return _IMP_kernel._LogPairScore_get_particle_pairs(self)
9037 r"""clear(_LogPairScore self)"""
9038 return _IMP_kernel._LogPairScore_clear(self)
9040 def get_contains(self, pp):
9041 r"""get_contains(_LogPairScore self, IMP::ParticlePair const & pp) -> bool"""
9042 return _IMP_kernel._LogPairScore_get_contains(self, pp)
9045 _IMP_kernel._LogPairScore_swigregister(_LogPairScore)
9047 def _overloaded_particles(*args):
9049 _overloaded_particles(Particle arg1)
9050 _overloaded_particles(IMP::Particles const & arg1)
9051 _overloaded_particles(IMP::ParticlesTemp const & arg1)
9052 _overloaded_particles(Model arg1, IMP::ParticleIndexes const & arg2)
9053 _overloaded_particles(IMP::internal::_TrivialDecorators const & arg1)
9054 _overloaded_particles(_TrivialDecorator arg1)
9056 return _IMP_kernel._overloaded_particles(*args)
9057 class _ImplicitParticles(object):
9058 r"""Proxy of C++ IMP::internal::_ImplicitParticles class."""
9060 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
9061 __repr__ = _swig_repr
9063 def __init__(self, *args):
9065 __init__(_ImplicitParticles self, Particle arg2) -> _ImplicitParticles
9066 __init__(_ImplicitParticles self, IMP::Particles const & arg2) -> _ImplicitParticles
9067 __init__(_ImplicitParticles self, IMP::ParticlesTemp const & arg2) -> _ImplicitParticles
9068 __init__(_ImplicitParticles self, Model arg2, IMP::ParticleIndexes const & arg3) -> _ImplicitParticles
9069 __init__(_ImplicitParticles self, IMP::internal::_TrivialDecorators const & arg2) -> _ImplicitParticles
9070 __init__(_ImplicitParticles self, _TrivialDecorator arg2) -> _ImplicitParticles
9072 _IMP_kernel._ImplicitParticles_swiginit(self, _IMP_kernel.new__ImplicitParticles(*args))
9073 __swig_destroy__ = _IMP_kernel.delete__ImplicitParticles
9076 _IMP_kernel._ImplicitParticles_swigregister(_ImplicitParticles)
9078 def _implicit_particles(arg1):
9079 r"""_implicit_particles(_ImplicitParticles arg1)"""
9080 return _IMP_kernel._implicit_particles(arg1)
9082 def _take_particle_adaptor(pa):
9083 r"""_take_particle_adaptor(_ParticleAdaptor pa) -> ParticleIndex"""
9084 return _IMP_kernel._take_particle_adaptor(pa)
9086 def _take_particle_indexes_adaptor(pa):
9087 r"""_take_particle_indexes_adaptor(_ParticleIndexesAdaptor pa) -> IMP::ParticleIndexes"""
9088 return _IMP_kernel._take_particle_indexes_adaptor(pa)
9090 r"""Proxy of C++ IMP::ScopedSetAttribute< IMP::FloatKey,IMP::Float > class."""
9092 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
9094 def __init__(self, *args):
9096 __init__(ScopedSetFloatAttribute self) -> ScopedSetFloatAttribute
9097 __init__(ScopedSetFloatAttribute self, Particle p, FloatKey key, double const & value) -> ScopedSetFloatAttribute
9099 _IMP_kernel.ScopedSetFloatAttribute_swiginit(self, _IMP_kernel.new_ScopedSetFloatAttribute(*args))
9101 def set(self, p, key, value):
9102 r"""set(ScopedSetFloatAttribute self, Particle p, FloatKey key, double const & value)"""
9103 return _IMP_kernel.ScopedSetFloatAttribute_set(self, p, key, value)
9106 r"""reset(ScopedSetFloatAttribute self)"""
9107 return _IMP_kernel.ScopedSetFloatAttribute_reset(self)
9108 __swig_destroy__ = _IMP_kernel.delete_ScopedSetFloatAttribute
9110 def show(self, *args):
9111 r"""show(ScopedSetFloatAttribute self, _ostream out=std::cout)"""
9112 return _IMP_kernel.ScopedSetFloatAttribute_show(self, *args)
9115 r"""__str__(ScopedSetFloatAttribute self) -> std::string"""
9116 return _IMP_kernel.ScopedSetFloatAttribute___str__(self)
9119 r"""__repr__(ScopedSetFloatAttribute self) -> std::string"""
9120 return _IMP_kernel.ScopedSetFloatAttribute___repr__(self)
9123 _IMP_kernel.ScopedSetFloatAttribute_swigregister(ScopedSetFloatAttribute)
9125 def _get_module_data_path(module, file_name):
9126 r"""_get_module_data_path(std::string module, std::string file_name) -> std::string"""
9127 return _IMP_kernel._get_module_data_path(module, file_name)
9129 def _get_module_example_path(module, file_name):
9130 r"""_get_module_example_path(std::string module, std::string file_name) -> std::string"""
9131 return _IMP_kernel._get_module_example_path(module, file_name)
9140 if sys.platform ==
'win32' and 'IMP_LD_PATH' in os.environ:
9141 dirs = os.environ[
'IMP_LD_PATH'].split(
":")
9142 pathcomps = os.environ[
'PATH'].split(
";")
9144 if d
not in pathcomps:
9145 os.environ[
'PATH'] = d +
';' + os.environ[
'PATH']
9153 """Allow command line tools to easily implement multiple commands.
9154 Typically, an IMP command line tool will use an instance of this class
9155 to provide a consistent interface to multiple distinct commands
9156 from a single binary, rather than providing a potentially large
9157 number of binaries. This is similar to the way a number of common
9158 command line tools outside of IMP function (e.g. Git provides a single
9159 `git` tool which implements multiple commands - `git add`, `git commit`,
9160 `git push` and so on).
9162 Each command is implemented with a Python module of the same name
9163 that can be imported from the module (for example, if `module_name`
9164 is `IMP.foo`, the `bar` command is provided by the `IMP.foo.bar` Python
9165 module, which would usually be found as `modules/foo/pyext/src/bar.py`).
9166 Each such module should have a docstring and a `%main()` method
9167 that takes no arguments (the module should also call its `%main()` method
9168 if it is run directly, i.e. with something like
9169 `if __name__=="__main__": %main()`). The encompassing module
9170 (`IMP.foo` in the example) should define `_all_commands` as a Python
9171 list of all valid commands.
9173 See the `multifit` and `cnmultifit` command line tools for example
9177 def __init__(self, short_help, long_help, module_name):
9179 @param short_help A few words that describe the command line tool.
9180 @param long_help Longer text, used in the `help` command.
9181 @param module_name Name of the module (e.g. `IMP.foo`) that
9182 implements the commands.
9184 self.short_help = short_help
9185 self.long_help = long_help
9186 self.module_name = module_name
9187 self._all_commands = self.import_module()._all_commands
9188 self._progname = os.path.basename(sys.argv[0])
9191 """Call this method to act upon the user-provided command line"""
9192 if len(sys.argv) <= 1:
9193 print(self.short_help +
" Use '%s help' for help." % self._progname)
9195 command = sys.argv[1]
9196 if command
in (
'help',
'--help',
'-h'):
9197 if len(sys.argv) == 3:
9198 self.show_command_help(sys.argv[2])
9201 elif command ==
'--version':
9203 elif command
in self._all_commands:
9204 self.do_command(command)
9206 self.unknown_command(command)
9208 def import_module(self, mod=None):
9209 modname = self.module_name
9211 modname +=
"." + mod
9212 return __import__(modname, {}, {}, [
''])
9214 def unknown_command(self, command):
9215 print(
"Unknown command: '%s'" % command)
9216 print(
"Use '%s help' for help." % self._progname)
9219 def _get_version(self):
9222 def show_version(self):
9223 print(self._progname +
' ' + self._get_version())
9225 def show_help(self):
9226 ver = self._get_version()
9227 print(
"%s, version %s." % (self._progname, ver))
9228 print(self.long_help +
"""
9230 This program is part of IMP, the Integrative Modeling Platform,
9232 For additional information about IMP, see <https://integrativemodeling.org>.
9234 Usage: %s <command> [options] [args]
9237 commands = self._all_commands[:] + [
'help']
9239 cmdlen = max([len(c)
for c
in commands])
9242 doc =
'Get help on using %s.' % self._progname
9244 doc = self.import_module(c).__doc__
or "<no help>"
9245 c +=
' ' * (cmdlen - len(c))
9246 print(
' ' + c +
' ' + doc)
9248 Use "%s help <command>" for detailed help on any command
9249 or "%s --version" to see the version number.""" % (self._progname,
9252 def do_command(self, command):
9253 mod = self.import_module(command)
9254 sys.argv[0] = self._progname +
' ' + command
9258 def show_command_help(self, command):
9259 if command ==
'help':
9261 elif command
in self._all_commands
or command ==
'help':
9262 mod = self.import_module(command)
9263 sys.argv = [self._progname +
' ' + command,
'--help']
9266 self.unknown_command(command)
9273 g = networkx.DiGraph()
9274 if len(ig.get_vertices()) == 0:
9283 return self.p.get_name()
9285 def __call__(self, name):
9286 return self.p.__call__(name)
9288 for vi
in ig.get_vertices():
9289 n = ig.get_vertex_name(vi)
9290 g.add_node(NodeWrapper(n))
9291 for vi
in ig.get_vertices():
9292 n = ig.get_vertex_name(vi)
9293 for ni
in ig.get_out_neighbors(vi):
9294 nn = ig.get_vertex_name(ni)
9295 g.add_edge(NodeWrapper(n), NodeWrapper(nn))
9302 n0 = name.get_name()
9305 n1 = str(n0).replace(
'"',
'')
9306 n2 = n1.replace(
"\n",
'')
9309 from altgraph
import Graph, Dot
9310 graph = Graph.Graph()
9311 for i, v
in enumerate(g.get_vertices()):
9313 for i, v
in enumerate(g.get_vertices()):
9314 for n
in g.get_out_neighbors(v):
9315 graph.add_edge(v, n)
9316 dot = Dot.Dot(graph)
9317 for i, v
in enumerate(g.get_vertices()):
9318 dot.node_style(i, label=clean(g.get_vertex_name(v)))
9326 st = g.get_graphviz_string()
9327 with open(tfn,
"w")
as fh:
9330 print(
"running dot")
9331 sp = subprocess.Popen([
"dot",
"-Tpdf", tfn,
"-o" + tfon])
9335 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")
9338 if platform.system() ==
"Darwin":
9341 cmd = [
"gv",
"acroread",
"xpdf"]
9344 print(
"launching viewer " + c)
9346 subprocess.check_call([c, tfon])
9352 print(
"Could not display file. It is saved at " + tfon)
9362 """Mark a Python module as deprecated.
9363 @note The `module` argument would normally be `__name__`.
9364 @see [deprecation support](@ref deprecation)."""
9366 "Module %s is deprecated. %s\n" % (module, help_message))
9369 """Python decorator to mark a class as deprecated.
9370 @see [deprecation support](@ref deprecation)."""
9372 orig_init = obj.__init__
9375 @functools.wraps(orig_init, (
'__name__',
'__doc__'))
9376 def __init__(obj, *args, **keys):
9378 % (type(obj), help_message))
9379 orig_init(obj, *args, **keys)
9380 obj.__init__ = __init__
9385 """Python decorator to mark a method as deprecated.
9386 @see [deprecation support](@ref deprecation)."""
9387 def out_wrapper(obj):
9388 @functools.wraps(obj)
9389 def wrapper(cls, *args, **keys):
9391 % (obj.__name__, type(cls), help_message))
9392 return obj(cls, *args, **keys)
9397 """Python decorator to mark a function as deprecated.
9398 @see [deprecation support](@ref deprecation)."""
9399 def out_wrapper(obj):
9400 @functools.wraps(obj)
9401 def wrapper(*args, **keys):
9403 % (obj.__name__, help_message))
9404 return obj(*args, **keys)
9408 @contextlib.contextmanager
9410 """Context manager to temporarily allow (or disallow) deprecated code.
9411 @see [deprecation support](@ref deprecation)."""
9418 def _get_all_flags(ntokens):
9419 r"""_get_all_flags(unsigned int ntokens) -> IMP::Strings"""
9420 return _IMP_kernel._get_all_flags(ntokens)
9422 def _print_internal_help(out, description):
9423 r"""_print_internal_help(_ostream out, std::string description)"""
9424 return _IMP_kernel._print_internal_help(out, description)
9430 class _PassThroughAction(argparse.Action):
9431 """Pass an argument through to the IMP Boost parser"""
9432 def __call__(self, parser, namespace, values, option_string=None):
9433 parser._boost_command_line.append(option_string)
9435 parser._boost_command_line.append(values)
9438 if option_string
in (
'-h',
'--help',
'--help_advanced',
'--version'):
9439 parser._handle_boost()
9443 """IMP-specific subclass of argparse.ArgumentParser.
9444 This adds options common to all IMP applications
9445 (see IMP::setup_from_argv()).
9448 def __init__(self, *args, **kwargs):
9450 kwargs[
'add_help'] =
False
9451 super().__init__(*args, **kwargs)
9452 for ntoken
in (0, 1):
9453 flags = _get_all_flags(ntoken)
9455 arg = [
'-h',
'--help']
if f ==
'help' else [
'--' + f]
9456 self.add_argument(*arg, help=argparse.SUPPRESS,
9457 nargs=
None if ntoken
else 0,
9458 action=_PassThroughAction,
9459 default=argparse.SUPPRESS)
9462 """Parse the command line and return optional and positional arguments.
9463 This functions in the same way as the method in the base class
9464 argparse.ArgumentParser, except that it also processes optional
9465 arguments common to all IMP applications (these are not returned
9466 in `args`, but can be obtained in the usual way, e.g. by calling
9467 IMP::get_string_flag()).
9470 self._boost_command_line = [sys.argv[0]]
9472 if len(self._boost_command_line) > 1:
9473 self._handle_boost()
9476 def _get_description(self):
9477 return self.format_help() +
"\nOptions common to all IMP applications:"
9479 def print_help(self, file=None):
9480 _print_internal_help(file
if file
else sys.stdout,
9481 self._get_description())
9483 def _handle_boost(self):
9485 self._get_description(),
9488 class RandomNumberGenerator(object):
9489 r"""Proxy of C++ IMP::RandomNumberGenerator class."""
9491 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
9492 __repr__ = _swig_repr
9495 r"""seed(RandomNumberGenerator self, int x)"""
9496 return _IMP_kernel.RandomNumberGenerator_seed(self, x)
9499 r"""__call__(RandomNumberGenerator self) -> int"""
9500 return _IMP_kernel.RandomNumberGenerator___call__(self)
9503 r"""__init__(RandomNumberGenerator self) -> RandomNumberGenerator"""
9504 _IMP_kernel.RandomNumberGenerator_swiginit(self, _IMP_kernel.new_RandomNumberGenerator())
9505 __swig_destroy__ = _IMP_kernel.delete_RandomNumberGenerator
9508 _IMP_kernel.RandomNumberGenerator_swigregister(RandomNumberGenerator)
9512 get_random_float_uniform() -> float
9513 get_random_float_uniform(float min, float max) -> float
9515 return _IMP_kernel.get_random_float_uniform(*args)
9519 get_random_double_uniform() -> double
9520 get_random_double_uniform(double min, double max) -> double
9522 return _IMP_kernel.get_random_double_uniform(*args)
9524 def get_random_floats_normal(n, mean=0.0, stddev=1.0):
9525 r"""get_random_floats_normal(unsigned int n, float mean=0.0, float stddev=1.0) -> IMP::Vector< float,std::allocator< float > >"""
9526 return _IMP_kernel.get_random_floats_normal(n, mean, stddev)
9528 def get_random_doubles_normal(n, mean=0.0, stddev=1.0):
9529 r"""get_random_doubles_normal(unsigned int n, double mean=0.0, double stddev=1.0) -> IMP::Vector< double,std::allocator< double > >"""
9530 return _IMP_kernel.get_random_doubles_normal(n, mean, stddev)
9532 def get_random_floats_uniform(n):
9533 r"""get_random_floats_uniform(unsigned int n) -> IMP::Vector< float,std::allocator< float > >"""
9534 return _IMP_kernel.get_random_floats_uniform(n)
9536 def get_random_doubles_uniform(n):
9537 r"""get_random_doubles_uniform(unsigned int n) -> IMP::Vector< double,std::allocator< double > >"""
9538 return _IMP_kernel.get_random_doubles_uniform(n)
9541 r"""get_random_seed() -> boost::uint64_t"""
9542 return _IMP_kernel.get_random_seed()
9544 def _get_derivatives_numpy(m, k, m_pyobj):
9545 r"""_get_derivatives_numpy(Model m, FloatKey k, PyObject * m_pyobj) -> PyObject *"""
9546 return _IMP_kernel._get_derivatives_numpy(m, k, m_pyobj)
9548 def _get_floats_numpy(m, k, m_pyobj):
9549 r"""_get_floats_numpy(Model m, FloatKey k, PyObject * m_pyobj) -> PyObject *"""
9550 return _IMP_kernel._get_floats_numpy(m, k, m_pyobj)
9552 def _get_ints_numpy(m, k, m_pyobj):
9553 r"""_get_ints_numpy(Model m, IntKey k, PyObject * m_pyobj) -> PyObject *"""
9554 return _IMP_kernel._get_ints_numpy(m, k, m_pyobj)
9556 def _get_spheres_numpy(m, m_pyobj):
9557 r"""_get_spheres_numpy(Model m, PyObject * m_pyobj) -> PyObject *"""
9558 return _IMP_kernel._get_spheres_numpy(m, m_pyobj)
9560 def _get_sphere_derivatives_numpy(m, m_pyobj):
9561 r"""_get_sphere_derivatives_numpy(Model m, PyObject * m_pyobj) -> PyObject *"""
9562 return _IMP_kernel._get_sphere_derivatives_numpy(m, m_pyobj)
9566 ParticleIndex = numpy.intc
9571 def get_module_name():
9572 r"""get_module_name() -> std::string const"""
9573 return _IMP_kernel.get_module_name()
9576 r"""get_module_version() -> std::string const"""
9577 return _IMP_kernel.get_module_version()
9580 r"""get_example_path(std::string fname) -> std::string"""
9581 return _IMP_kernel.get_example_path(fname)
9584 r"""get_data_path(std::string fname) -> std::string"""
9585 return _IMP_kernel.get_data_path(fname)
9587 from .
import _version_check
9592 random_number_generator = cvar.random_number_generator
Particle * get_particle(ParticleIndex p) const
Get the particle from an index.
A base class for modifiers of ParticlesTemp.
A class to store a configuration of a model.
def get_ints_numpy
Get the model's attribute array for IntKey k as a NumPy array.
Abstract class for scoring object(s) of type ParticleIndexPair.
A shared container for Pairs.
virtual std::string get_type_name() const
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.
Abstract predicate function.
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)
def get_floats_numpy
Get the model's attribute array for FloatKey k as a NumPy array.
Objects get_live_objects()
Return pointers to all live objects.
def get_derived_object
Return this object cast to the most derived subclass.
Vector< char > write_particles_to_buffer(const ParticlesTemp &particles, const FloatKeys &keys)
return a binary buffer with the data
def main
Call this method to act upon the user-provided command line.
ContainersTemp get_input_containers(const ModelObjectsTemp &mos)
Return all the input particles for a given ModelObject.
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.
Array< 4, WeakPointer< Particle >, Particle * > ParticleQuad
bool get_bool_flag(std::string name)
A FloatIndex identifies an optimized attribute in a model.
void handle_use_deprecated(std::string message)
Break in this method in gdb to find deprecated uses at runtime.
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.
virtual ::IMP::VersionInfo get_version_info() const override
Get information about the module and version of the object.
void remove_attribute(TypeKey attribute_key, ParticleIndex particle)
remove particle attribute with the specified key
ParticlesTemp get_particles(Model *m, const ParticleIndexes &ps)
Get the particles from a list of indexes.
Array< 3, WeakPointer< Particle >, Particle * > ParticleTriplet
ContainersTemp get_output_containers(const ModelObjectsTemp &mos)
Return all the output particles for a given ModelObject.
Base class for all samplers.
void add_particle(RMF::FileHandle fh, Particle *hs)
virtual void clear_caches()
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.
def get_sphere_derivatives_numpy
Get the model's XYZR attribute derivatives arrays as NumPy arrays.
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="")
Create a temporary file. The path can be extracted from the TextOutput.
Warnings with the same key within the context are only output once.
ParticlesTemp get_output_particles(const ModelObjectsTemp &mos)
Return all the output particles for a given ModelObject.
ScoringFunction * create_scoring_function(RestraintType *rs, double weight=1.0, double max=NO_MAX, std::string name=std::string())
Create a ScoringFunction on a single restraint.
A base class for modifiers of ParticlePairsTemp.
Object used to hold a set of restraints.
Implement a constraint on the Model.
Class for storing model, its restraints, constraints, and 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)
Abstract class for scoring object(s) of type ParticleIndexQuad.
Base class for objects in a Model that depend on other objects.
boost::uint64_t get_random_seed()
Return the initial random seed.
Abstract predicate function.
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_attribute(TypeKey attribute_key, ParticleIndex particle, Type value)
add particle attribute with the specified key and initial value
void add_float_flag(std::string name, double default_value, std::string description)
virtual void do_destroy()
Ints get_index(const ParticlesTemp &particles, const Subset &subset, const Subsets &excluded)
Common base class for heavy weight IMP objects.
ParticleIndexes get_particle_indexes(ParticlesTemp const &particles)
def deprecated_method
Python decorator to mark a method as deprecated.
Abstract class for scoring object(s) of type ParticleIndex.
ScoreStates maintain invariants in the Model.
A class to change and restore log state.
Base class for all optimizers.
void reset_log_timer()
Reset the log timer.
void add_restraints(RMF::FileHandle fh, const Restraints &hs)
Class for adding up scores during ScoringFunction evaluation.
void add_to_log(LogLevel level, std::string to_write)
Write a string to the log, for Python.
def parse_args
Parse the command line and return optional and positional arguments.
void set_is_optimized(TypeKey attribute_key, ParticleIndex particle, bool true_or_false)
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.
A class to store a set of configurations of a model.
A shared container for Quads.
A shared container for Singletons.
void set_deprecation_exceptions(bool tf)
Toggle whether an exception is thrown when a deprecated method is used.
Report key:value information on restraints.
def get_spheres_numpy
Get the model's XYZR attribute arrays as NumPy arrays.
Interface to specialized Particle types (e.g. atoms)
IMP-specific subclass of argparse.ArgumentParser.
A class to change and restore check state.
def get_derivatives_numpy
Get the model's attribute derivatives array for FloatKey k as a NumPy array.
std::ostream & show(Hierarchy h, std::ostream &out=std::cout)
Print the hierarchy using a given decorator to display each node.
std::string get_absolute_path(std::string file)
Convert a possibly relative path to an absolute path.
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.
Base class for optimizers that act on individual attributes.
void set_show_leaked_objects(bool tf)
Set whether to complain about objects not being properly cleaned up.
Abstract predicate function.
bool get_deprecation_exceptions()
Get whether an exception is thrown when a deprecated method is used.
Represents a scoring function on the model.
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.
Array< 2, WeakPointer< Particle >, Particle * > ParticlePair
virtual VersionInfo get_version_info() const
Get information about the module and version of the object.
Restraints create_restraints(RMF::FileConstHandle fh, Model *m)
Shared optimizer state that is invoked upon commitment of new coordinates.
Abstract predicate function.
Abstract class to implement hierarchical methods.
Class to handle individual particles of a Model object.
A base class for modifiers of ParticleTripletsTemp.
std::string show_graphviz(Graph g)
void set_check_level(CheckLevel l)
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)
A base class for modifiers of ParticleQuadsTemp.
A shared container for Triplets.
Abstract class for scoring object(s) of type ParticleIndexTriplet.
void show_altgraph(Graph g)
void update()
Sometimes it is useful to be able to make sure the model is up to date.
void setup_from_argv(int argc, char **argv, std::string description)
Parse the command line flags and return the positional arguments.
Create a new log context.
void add_bool_flag(std::string name, std::string description)
ParticleIndexes get_indexes(const ParticlesTemp &ps)
Get the indexes from a list of particles.
Abstract class for containers of particles.
void read_particles_from_buffer(const Vector< char > &buffer, const ParticlesTemp &particles, const FloatKeys &keys)
load found attributes into the particles
Abstract single variable functor class for score functions.
void set_number_of_threads(unsigned int n)
Class for adding derivatives from restraints to the model.
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 get_module_version()
Return the version of this module, as a string.
std::string create_temporary_file_name(std::string prefix="imp_temp", std::string suffix="")
Create a temporary file.
A restraint is a term in an IMP ScoringFunction.
std::string get_copyright()
Get the IMP copyright notice.