11 from __future__
import print_function, division, absolute_import
15 from sys
import version_info
as _swig_python_version_info
19 import builtins
as __builtin__
25 strthis =
"proxy of " + self.this.__repr__()
26 except __builtin__.Exception:
28 return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
31 def _swig_setattr_nondynamic_instance_variable(set):
32 def set_instance_attr(self, name, value):
34 set(self, name, value)
35 elif name ==
"thisown":
37 elif hasattr(self, name)
and isinstance(getattr(type(self), name), property):
38 set(self, name, value)
40 raise AttributeError(
"You cannot add instance attributes to %s" % self)
41 return set_instance_attr
44 def _swig_setattr_nondynamic_class_variable(set):
45 def set_class_attr(cls, name, value):
46 if hasattr(cls, name)
and not isinstance(getattr(cls, name), property):
49 raise AttributeError(
"You cannot add class attributes to %s" % cls)
53 def _swig_add_metaclass(metaclass):
54 """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
56 return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
60 class _SwigNonDynamicMeta(type):
61 """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
62 __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)
67 class IMP_KERNEL_SwigPyIterator(object):
68 r"""Proxy of C++ swig::IMP_KERNEL_SwigPyIterator class."""
70 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
72 def __init__(self, *args, **kwargs):
73 raise AttributeError(
"No constructor defined - class is abstract")
75 __swig_destroy__ = _IMP_kernel.delete_IMP_KERNEL_SwigPyIterator
78 r"""value(IMP_KERNEL_SwigPyIterator self) -> PyObject *"""
79 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_value(self)
82 r"""incr(IMP_KERNEL_SwigPyIterator self, size_t n=1) -> IMP_KERNEL_SwigPyIterator"""
83 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_incr(self, n)
86 r"""decr(IMP_KERNEL_SwigPyIterator self, size_t n=1) -> IMP_KERNEL_SwigPyIterator"""
87 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_decr(self, n)
89 def distance(self, x):
90 r"""distance(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> ptrdiff_t"""
91 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_distance(self, x)
94 r"""equal(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> bool"""
95 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_equal(self, x)
98 r"""copy(IMP_KERNEL_SwigPyIterator self) -> IMP_KERNEL_SwigPyIterator"""
99 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_copy(self)
102 r"""next(IMP_KERNEL_SwigPyIterator self) -> PyObject *"""
103 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_next(self)
106 r"""__next__(IMP_KERNEL_SwigPyIterator self) -> PyObject *"""
107 return _IMP_kernel.IMP_KERNEL_SwigPyIterator___next__(self)
110 r"""previous(IMP_KERNEL_SwigPyIterator self) -> PyObject *"""
111 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_previous(self)
113 def advance(self, n):
114 r"""advance(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator"""
115 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_advance(self, n)
118 r"""__eq__(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> bool"""
119 return _IMP_kernel.IMP_KERNEL_SwigPyIterator___eq__(self, x)
122 r"""__ne__(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> bool"""
123 return _IMP_kernel.IMP_KERNEL_SwigPyIterator___ne__(self, x)
125 def __iadd__(self, n):
126 r"""__iadd__(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator"""
127 return _IMP_kernel.IMP_KERNEL_SwigPyIterator___iadd__(self, n)
129 def __isub__(self, n):
130 r"""__isub__(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator"""
131 return _IMP_kernel.IMP_KERNEL_SwigPyIterator___isub__(self, n)
133 def __add__(self, n):
134 r"""__add__(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator"""
135 return _IMP_kernel.IMP_KERNEL_SwigPyIterator___add__(self, n)
137 def __sub__(self, *args):
139 __sub__(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator
140 __sub__(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> ptrdiff_t
142 return _IMP_kernel.IMP_KERNEL_SwigPyIterator___sub__(self, *args)
147 _IMP_kernel.IMP_KERNEL_SwigPyIterator_swigregister(IMP_KERNEL_SwigPyIterator)
154 IMP_DEBUG = _IMP_kernel.IMP_DEBUG
156 IMP_RELEASE = _IMP_kernel.IMP_RELEASE
158 IMP_SILENT = _IMP_kernel.IMP_SILENT
160 IMP_PROGRESS = _IMP_kernel.IMP_PROGRESS
162 IMP_TERSE = _IMP_kernel.IMP_TERSE
164 IMP_VERBOSE = _IMP_kernel.IMP_VERBOSE
166 IMP_MEMORY = _IMP_kernel.IMP_MEMORY
168 IMP_NONE = _IMP_kernel.IMP_NONE
170 IMP_USAGE = _IMP_kernel.IMP_USAGE
172 IMP_INTERNAL = _IMP_kernel.IMP_INTERNAL
174 IMP_KERNEL_HAS_LOG4CXX = _IMP_kernel.IMP_KERNEL_HAS_LOG4CXX
176 IMP_COMPILER_HAS_CEREAL_RAW_POINTER = _IMP_kernel.IMP_COMPILER_HAS_CEREAL_RAW_POINTER
178 IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_kernel.IMP_COMPILER_HAS_DEBUG_VECTOR
180 IMP_COMPILER_HAS_RANDOM_SHUFFLE = _IMP_kernel.IMP_COMPILER_HAS_RANDOM_SHUFFLE
182 IMP_COMPILER_HAS_THREE_WAY = _IMP_kernel.IMP_COMPILER_HAS_THREE_WAY
184 IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_kernel.IMP_KERNEL_HAS_BOOST_RANDOM
186 IMP_KERNEL_HAS_NUMPY = _IMP_kernel.IMP_KERNEL_HAS_NUMPY
188 IMP_KERNEL_HAS_GPERFTOOLS = _IMP_kernel.IMP_KERNEL_HAS_GPERFTOOLS
190 IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER = _IMP_kernel.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER
192 IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER = _IMP_kernel.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER
194 IMPKERNEL_SHOW_WARNINGS = _IMP_kernel.IMPKERNEL_SHOW_WARNINGS
198 class _DirectorObjects(object):
199 """@internal Simple class to keep references to director objects
200 to prevent premature deletion."""
203 def register(self, obj):
204 """Take a reference to a director object; will only work for
205 refcounted C++ classes"""
206 if hasattr(obj,
'get_ref_count'):
207 self._objects.append(obj)
209 """Only drop our reference and allow cleanup by Python if no other
210 Python references exist (we hold 3 references: one in self._objects,
211 one in x, and one in the argument list for getrefcount) *and* no
212 other C++ references exist (the Python object always holds one)"""
213 objs = [x
for x
in self._objects
if sys.getrefcount(x) > 3 \
214 or x.get_ref_count() > 1]
218 def get_object_count(self):
219 """Get number of director objects (useful for testing only)"""
220 return len(self._objects)
221 _director_objects = _DirectorObjects()
223 DEFAULT_CHECK = _IMP_kernel.DEFAULT_CHECK
225 NONE = _IMP_kernel.NONE
227 USAGE = _IMP_kernel.USAGE
229 USAGE_AND_INTERNAL = _IMP_kernel.USAGE_AND_INTERNAL
233 r"""set_check_level(IMP::CheckLevel tf)"""
234 return _IMP_kernel.set_check_level(tf)
237 r"""get_check_level() -> IMP::CheckLevel"""
238 return _IMP_kernel.get_check_level()
240 from _IMP_kernel
import Exception, InternalException, ModelException, EventException
241 from _IMP_kernel
import UsageException, IndexException, IOException, ValueException
242 from _IMP_kernel
import TypeException
244 class _ostream(object):
245 r"""Proxy of C++ std::ostream class."""
247 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
249 def __init__(self, *args, **kwargs):
250 raise AttributeError(
"No constructor defined")
251 __repr__ = _swig_repr
253 def write(self, osa_buf):
254 r"""write(_ostream self, char const * osa_buf)"""
255 return _IMP_kernel._ostream_write(self, osa_buf)
258 _IMP_kernel._ostream_swigregister(_ostream)
259 IMP_C_OPEN_BINARY = _IMP_kernel.IMP_C_OPEN_BINARY
262 from .
import _list_util
265 _models_set = weakref.WeakSet()
267 def _models_set_get(m):
268 for x
in _models_set:
273 _raii_types.append(
"SetLogState")
276 _raii_types.append(
"SetNumberOfThreads")
279 _raii_types.append(
"SetCheckState")
282 _object_types.append(
"Object")
285 def _object_cast_to_Object(o):
286 r"""_object_cast_to_Object(Object * o) -> Object"""
287 return _IMP_kernel._object_cast_to_Object(o)
289 _object_types.append(
"_TestObject")
292 def _object_cast_to__TestObject(o):
293 r"""_object_cast_to__TestObject(Object * o) -> _TestObject"""
294 return _IMP_kernel._object_cast_to__TestObject(o)
297 _plural_types.append(
"VersionInfos")
298 _value_types.append(
"VersionInfo")
301 _raii_types.append(
"CreateLogContext")
304 _raii_types.append(
"WarningContext")
307 _raii_types.append(
"SetLogTarget")
311 _plural_types.append(
"_TestValues")
312 _value_types.append(
"_TestValue")
316 _plural_types.append(
"Floats")
317 _value_types.append(
"Float")
321 _plural_types.append(
"Ints")
322 _value_types.append(
"Int")
326 _plural_types.append(
"Strings")
327 _value_types.append(
"String")
331 _plural_types.append(
"_Protections")
332 _value_types.append(
"_Protection")
334 class _InputAdaptor(object):
335 r"""Proxy of C++ IMP::InputAdaptor class."""
337 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
339 def __init__(self, *args, **kwargs):
340 raise AttributeError(
"No constructor defined")
341 __repr__ = _swig_repr
343 def __getstate__(self):
344 raise NotImplementedError(str(self.__class__)
345 +
" does not support serialization")
347 __swig_destroy__ = _IMP_kernel.delete__InputAdaptor
350 _IMP_kernel._InputAdaptor_swigregister(_InputAdaptor)
351 class _NonCopyable(object):
352 r"""Proxy of C++ IMP::NonCopyable class."""
354 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
356 def __init__(self, *args, **kwargs):
357 raise AttributeError(
"No constructor defined")
358 __repr__ = _swig_repr
359 __swig_destroy__ = _IMP_kernel.delete__NonCopyable
362 _IMP_kernel._NonCopyable_swigregister(_NonCopyable)
363 class _RAII(_NonCopyable):
364 r"""Proxy of C++ IMP::RAII class."""
366 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
368 def __init__(self, *args, **kwargs):
369 raise AttributeError(
"No constructor defined")
370 __repr__ = _swig_repr
371 __swig_destroy__ = _IMP_kernel.delete__RAII
374 _IMP_kernel._RAII_swigregister(_RAII)
375 class _Value(object):
376 r"""Proxy of C++ IMP::Value class."""
378 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
380 def __init__(self, *args, **kwargs):
381 raise AttributeError(
"No constructor defined")
382 __repr__ = _swig_repr
384 def __getstate__(self):
385 raise NotImplementedError(str(self.__class__)
386 +
" does not support serialization")
388 __swig_destroy__ = _IMP_kernel.delete__Value
391 _IMP_kernel._Value_swigregister(_Value)
394 r"""get_executable_name() -> std::string"""
395 return _IMP_kernel.get_executable_name()
399 setup_from_argv(IMP::Strings const & argv, std::string description)
400 setup_from_argv(IMP::Strings const & argv, std::string description, std::string positional_description, int num_positional) -> IMP::Strings
402 return _IMP_kernel.setup_from_argv(*args)
405 r"""add_string_flag(std::string name, std::string default_value, std::string description)"""
406 return _IMP_kernel.add_string_flag(name, default_value, description)
409 r"""get_string_flag(std::string name) -> std::string"""
410 return _IMP_kernel.get_string_flag(name)
413 r"""add_int_flag(std::string name, size_t default_value, std::string description)"""
414 return _IMP_kernel.add_int_flag(name, default_value, description)
417 r"""get_int_flag(std::string name) -> size_t"""
418 return _IMP_kernel.get_int_flag(name)
421 r"""add_bool_flag(std::string name, std::string description)"""
422 return _IMP_kernel.add_bool_flag(name, description)
425 r"""get_bool_flag(std::string name) -> bool"""
426 return _IMP_kernel.get_bool_flag(name)
429 r"""add_float_flag(std::string name, double default_value, std::string description)"""
430 return _IMP_kernel.add_float_flag(name, default_value, description)
433 r"""get_float_flag(std::string name) -> double"""
434 return _IMP_kernel.get_float_flag(name)
437 r"""write_help(_ostream out=std::cerr)"""
438 return _IMP_kernel.write_help(*args)
441 r"""get_is_quick_test() -> bool"""
442 return _IMP_kernel.get_is_quick_test()
443 DEFAULT = _IMP_kernel.DEFAULT
445 SILENT = _IMP_kernel.SILENT
447 WARNING = _IMP_kernel.WARNING
449 PROGRESS = _IMP_kernel.PROGRESS
451 TERSE = _IMP_kernel.TERSE
453 VERBOSE = _IMP_kernel.VERBOSE
455 MEMORY = _IMP_kernel.MEMORY
457 ALL_LOG = _IMP_kernel.ALL_LOG
459 class VersionInfo(_Value):
460 r"""Proxy of C++ IMP::VersionInfo class."""
462 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
464 def __init__(self, *args):
466 __init__(VersionInfo self, std::string module, std::string version) -> VersionInfo
467 __init__(VersionInfo self) -> VersionInfo
469 _IMP_kernel.VersionInfo_swiginit(self, _IMP_kernel.new_VersionInfo(*args))
471 def get_module(self):
472 r"""get_module(VersionInfo self) -> std::string"""
473 return _IMP_kernel.VersionInfo_get_module(self)
475 def get_version(self):
476 r"""get_version(VersionInfo self) -> std::string"""
477 return _IMP_kernel.VersionInfo_get_version(self)
479 def show(self, *args):
480 r"""show(VersionInfo self, _ostream out=std::cout)"""
481 return _IMP_kernel.VersionInfo_show(self, *args)
483 def __cmp__(self, o):
484 r"""__cmp__(VersionInfo self, VersionInfo o) -> int"""
485 return _IMP_kernel.VersionInfo___cmp__(self, o)
488 r"""__eq__(VersionInfo self, VersionInfo o) -> bool"""
489 return _IMP_kernel.VersionInfo___eq__(self, o)
492 r"""__ne__(VersionInfo self, VersionInfo o) -> bool"""
493 return _IMP_kernel.VersionInfo___ne__(self, o)
496 r"""__lt__(VersionInfo self, VersionInfo o) -> bool"""
497 return _IMP_kernel.VersionInfo___lt__(self, o)
500 r"""__gt__(VersionInfo self, VersionInfo o) -> bool"""
501 return _IMP_kernel.VersionInfo___gt__(self, o)
504 r"""__ge__(VersionInfo self, VersionInfo o) -> bool"""
505 return _IMP_kernel.VersionInfo___ge__(self, o)
508 r"""__le__(VersionInfo self, VersionInfo o) -> bool"""
509 return _IMP_kernel.VersionInfo___le__(self, o)
512 r"""__str__(VersionInfo self) -> std::string"""
513 return _IMP_kernel.VersionInfo___str__(self)
516 r"""__repr__(VersionInfo self) -> std::string"""
517 return _IMP_kernel.VersionInfo___repr__(self)
519 def _get_as_binary(self):
520 r"""_get_as_binary(VersionInfo self) -> PyObject *"""
521 return _IMP_kernel.VersionInfo__get_as_binary(self)
523 def _set_from_binary(self, p):
524 r"""_set_from_binary(VersionInfo self, PyObject * p)"""
525 return _IMP_kernel.VersionInfo__set_from_binary(self, p)
527 def __getstate__(self):
528 p = self._get_as_binary()
529 if len(self.__dict__) > 1:
530 d = self.__dict__.copy()
535 def __setstate__(self, p):
536 if not hasattr(self,
'this'):
538 if isinstance(p, tuple):
540 self.__dict__.update(d)
541 return self._set_from_binary(p)
543 __swig_destroy__ = _IMP_kernel.delete_VersionInfo
546 _IMP_kernel.VersionInfo_swigregister(VersionInfo)
547 class TextOutput(_InputAdaptor):
548 r"""Proxy of C++ IMP::TextOutput class."""
550 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
551 __repr__ = _swig_repr
553 def __init__(self, *args):
555 __init__(TextOutput self, int arg2) -> TextOutput
556 __init__(TextOutput self, double arg2) -> TextOutput
557 __init__(TextOutput self, char const * c, bool append=False) -> TextOutput
558 __init__(TextOutput self, IMP::TextProxy< std::ostream > p) -> TextOutput
559 __init__(TextOutput self) -> TextOutput
560 __init__(TextOutput self, std::string file_name, bool append=False) -> TextOutput
562 _IMP_kernel.TextOutput_swiginit(self, _IMP_kernel.new_TextOutput(*args))
564 def show(self, *args):
565 r"""show(TextOutput self, _ostream out=std::cout)"""
566 return _IMP_kernel.TextOutput_show(self, *args)
569 r"""get_name(TextOutput self) -> std::string"""
570 return _IMP_kernel.TextOutput_get_name(self)
571 __swig_destroy__ = _IMP_kernel.delete_TextOutput
574 _IMP_kernel.TextOutput_swigregister(TextOutput)
575 class TextInput(_InputAdaptor):
576 r"""Proxy of C++ IMP::TextInput class."""
578 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
579 __repr__ = _swig_repr
581 def __init__(self, *args):
583 __init__(TextInput self, int arg2) -> TextInput
584 __init__(TextInput self, double arg2) -> TextInput
585 __init__(TextInput self, char const * c) -> TextInput
586 __init__(TextInput self, IMP::TextProxy< std::istream > p) -> TextInput
587 __init__(TextInput self) -> TextInput
588 __init__(TextInput self, std::string file_name) -> TextInput
590 _IMP_kernel.TextInput_swiginit(self, _IMP_kernel.new_TextInput(*args))
592 def show(self, *args):
593 r"""show(TextInput self, _ostream out=std::cout)"""
594 return _IMP_kernel.TextInput_show(self, *args)
597 r"""get_name(TextInput self) -> std::string"""
598 return _IMP_kernel.TextInput_get_name(self)
599 __swig_destroy__ = _IMP_kernel.delete_TextInput
602 _IMP_kernel.TextInput_swigregister(TextInput)
603 class SetLogTarget(_RAII):
604 r"""Proxy of C++ IMP::SetLogTarget class."""
606 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
608 def __init__(self, *args):
610 __init__(SetLogTarget self) -> SetLogTarget
611 __init__(SetLogTarget self, TextOutput to) -> SetLogTarget
613 _IMP_kernel.SetLogTarget_swiginit(self, _IMP_kernel.new_SetLogTarget(*args))
616 r"""set(SetLogTarget self, TextOutput to)"""
617 return _IMP_kernel.SetLogTarget_set(self, to)
620 r"""reset(SetLogTarget self)"""
621 return _IMP_kernel.SetLogTarget_reset(self)
622 __swig_destroy__ = _IMP_kernel.delete_SetLogTarget
624 def show(self, *args):
625 r"""show(SetLogTarget self, _ostream out=std::cout)"""
626 return _IMP_kernel.SetLogTarget_show(self, *args)
630 def __exit__(self, exc_type, exc_val, exc_tb):
636 r"""__str__(SetLogTarget self) -> std::string"""
637 return _IMP_kernel.SetLogTarget___str__(self)
640 r"""__repr__(SetLogTarget self) -> std::string"""
641 return _IMP_kernel.SetLogTarget___repr__(self)
644 _IMP_kernel.SetLogTarget_swigregister(SetLogTarget)
647 r"""create_temporary_file(std::string prefix="imp_temp", std::string suffix="") -> TextOutput"""
648 return _IMP_kernel.create_temporary_file(*args)
651 r"""create_temporary_file_name(std::string prefix="imp_temp", std::string suffix="") -> std::string"""
652 return _IMP_kernel.create_temporary_file_name(*args)
655 r"""get_relative_path(std::string base, std::string relative) -> std::string"""
656 return _IMP_kernel.get_relative_path(base, relative)
659 r"""get_absolute_path(std::string file) -> std::string"""
660 return _IMP_kernel.get_absolute_path(file)
662 def push_log_context(functionname, object):
663 r"""push_log_context(char const * functionname, void const * object)"""
664 return _IMP_kernel.push_log_context(functionname, object)
666 def pop_log_context():
667 r"""pop_log_context()"""
668 return _IMP_kernel.pop_log_context()
672 add_to_log(std::string to_write)
673 add_to_log(IMP::LogLevel level, std::string to_write)
675 return _IMP_kernel.add_to_log(*args)
678 r"""set_log_level(IMP::LogLevel l)"""
679 return _IMP_kernel.set_log_level(l)
682 r"""set_log_timer(bool tb)"""
683 return _IMP_kernel.set_log_timer(tb)
686 r"""reset_log_timer()"""
687 return _IMP_kernel.reset_log_timer()
690 r"""get_log_level() -> IMP::LogLevel"""
691 return _IMP_kernel.get_log_level()
694 r"""set_progress_display(std::string description, unsigned int steps)"""
695 return _IMP_kernel.set_progress_display(description, steps)
698 r"""add_to_progress_display(unsigned int step=1)"""
699 return _IMP_kernel.add_to_progress_display(step)
700 class Object(_NonCopyable):
701 r"""Proxy of C++ IMP::Object class."""
703 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
705 def __init__(self, name):
706 r"""__init__(Object self, std::string name) -> Object"""
707 if self.__class__ == Object:
711 _IMP_kernel.Object_swiginit(self, _IMP_kernel.new_Object(_self, name))
713 if self.__class__ != Object:
714 _director_objects.register(self)
718 __swig_destroy__ = _IMP_kernel.delete_Object
721 r"""__hash__(Object self) -> std::size_t"""
722 return _IMP_kernel.Object___hash__(self)
725 r"""set_log_level(Object self, IMP::LogLevel l)"""
726 return _IMP_kernel.Object_set_log_level(self, l)
729 r"""set_check_level(Object self, IMP::CheckLevel l)"""
730 return _IMP_kernel.Object_set_check_level(self, l)
733 r"""get_log_level(Object self) -> IMP::LogLevel"""
734 return _IMP_kernel.Object_get_log_level(self)
737 r"""get_check_level(Object self) -> IMP::CheckLevel"""
738 return _IMP_kernel.Object_get_check_level(self)
740 def get_version_info(self):
741 r"""get_version_info(Object self) -> VersionInfo"""
742 return _IMP_kernel.Object_get_version_info(self)
745 r"""get_name(Object self) -> std::string const &"""
746 return _IMP_kernel.Object_get_name(self)
748 def set_name(self, name):
749 r"""set_name(Object self, std::string name)"""
750 return _IMP_kernel.Object_set_name(self, name)
752 def get_type_name(self):
753 r"""get_type_name(Object self) -> std::string"""
754 return _IMP_kernel.Object_get_type_name(self)
756 def set_was_used(self, tf):
757 r"""set_was_used(Object self, bool tf)"""
758 return _IMP_kernel.Object_set_was_used(self, tf)
760 def show(self, *args):
761 r"""show(Object self, _ostream out=std::cout)"""
762 return _IMP_kernel.Object_show(self, *args)
764 def get_string(self):
765 r"""get_string(Object self) -> std::string"""
766 return _IMP_kernel.Object_get_string(self)
768 def _on_destruction(self):
769 r"""_on_destruction(Object self)"""
770 return _IMP_kernel.Object__on_destruction(self)
772 def get_is_valid(self):
773 r"""get_is_valid(Object self) -> bool"""
774 return _IMP_kernel.Object_get_is_valid(self)
776 def get_ref_count(self):
777 r"""get_ref_count(Object self) -> unsigned int"""
778 return _IMP_kernel.Object_get_ref_count(self)
781 def get_number_of_live_objects():
782 r"""get_number_of_live_objects() -> unsigned int"""
783 return _IMP_kernel.Object_get_number_of_live_objects()
785 def get_is_shared(self):
786 r"""get_is_shared(Object self) -> bool"""
787 return _IMP_kernel.Object_get_is_shared(self)
789 def clear_caches(self):
790 r"""clear_caches(Object self)"""
791 return _IMP_kernel.Object_clear_caches(self)
793 def do_destroy(self):
794 r"""do_destroy(Object self)"""
795 return _IMP_kernel.Object_do_destroy(self)
797 def __getstate__(self):
798 raise NotImplementedError(str(self.__class__)
799 +
" does not support serialization")
803 r"""__eq__(Object self, Object o) -> bool"""
804 return _IMP_kernel.Object___eq__(self, o)
807 r"""__ne__(Object self, Object o) -> bool"""
808 return _IMP_kernel.Object___ne__(self, o)
811 r"""__le__(Object self, Object o) -> bool"""
812 return _IMP_kernel.Object___le__(self, o)
815 r"""__lt__(Object self, Object o) -> bool"""
816 return _IMP_kernel.Object___lt__(self, o)
819 r"""__ge__(Object self, Object o) -> bool"""
820 return _IMP_kernel.Object___ge__(self, o)
823 r"""__gt__(Object self, Object o) -> bool"""
824 return _IMP_kernel.Object___gt__(self, o)
827 r"""__str__(Object self) -> std::string"""
828 return _IMP_kernel.Object___str__(self)
831 r"""__repr__(Object self) -> std::string"""
832 return _IMP_kernel.Object___repr__(self)
836 return _object_cast_to_Object(o)
838 def __disown__(self):
840 _IMP_kernel.disown_Object(self)
841 return weakref.proxy(self)
844 _IMP_kernel.Object_swigregister(Object)
845 class SetLogState(_RAII):
846 r"""Proxy of C++ IMP::SetLogState class."""
848 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
851 r"""reset(SetLogState self)"""
852 return _IMP_kernel.SetLogState_reset(self)
853 __swig_destroy__ = _IMP_kernel.delete_SetLogState
855 def show(self, *args):
856 r"""show(SetLogState self, _ostream out=std::cout)"""
857 return _IMP_kernel.SetLogState_show(self, *args)
859 def __init__(self, *args):
861 __init__(SetLogState self) -> SetLogState
862 __init__(SetLogState self, Object o, IMP::LogLevel l) -> SetLogState
863 __init__(SetLogState self, IMP::LogLevel l) -> SetLogState
865 _IMP_kernel.SetLogState_swiginit(self, _IMP_kernel.new_SetLogState(*args))
867 def set(self, *args):
869 set(SetLogState self, Object o, IMP::LogLevel l)
870 set(SetLogState self, IMP::LogLevel l)
872 return _IMP_kernel.SetLogState_set(self, *args)
876 def __exit__(self, exc_type, exc_val, exc_tb):
882 r"""__str__(SetLogState self) -> std::string"""
883 return _IMP_kernel.SetLogState___str__(self)
886 r"""__repr__(SetLogState self) -> std::string"""
887 return _IMP_kernel.SetLogState___repr__(self)
890 _IMP_kernel.SetLogState_swigregister(SetLogState)
891 class WarningContext(object):
892 r"""Proxy of C++ IMP::WarningContext class."""
894 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
895 data_ = property(_IMP_kernel.WarningContext_data__get, _IMP_kernel.WarningContext_data__set, doc=
r"""data_ : boost::unordered_set<(std::string)>""")
897 def add_warning(self, key, warning):
898 r"""add_warning(WarningContext self, std::string key, std::string warning)"""
899 return _IMP_kernel.WarningContext_add_warning(self, key, warning)
901 def clear_warnings(self):
902 r"""clear_warnings(WarningContext self)"""
903 return _IMP_kernel.WarningContext_clear_warnings(self)
905 def dump_warnings(self):
906 r"""dump_warnings(WarningContext self)"""
907 return _IMP_kernel.WarningContext_dump_warnings(self)
908 __swig_destroy__ = _IMP_kernel.delete_WarningContext
910 def show(self, *args):
911 r"""show(WarningContext self, _ostream out=std::cout)"""
912 return _IMP_kernel.WarningContext_show(self, *args)
916 def __exit__(self, exc_type, exc_val, exc_tb):
922 r"""__str__(WarningContext self) -> std::string"""
923 return _IMP_kernel.WarningContext___str__(self)
926 r"""__repr__(WarningContext self) -> std::string"""
927 return _IMP_kernel.WarningContext___repr__(self)
930 r"""__init__(WarningContext self) -> WarningContext"""
931 _IMP_kernel.WarningContext_swiginit(self, _IMP_kernel.new_WarningContext())
934 _IMP_kernel.WarningContext_swigregister(WarningContext)
935 class CreateLogContext(_RAII):
936 r"""Proxy of C++ IMP::CreateLogContext class."""
938 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
940 def __init__(self, *args):
942 __init__(CreateLogContext self, std::string fname, Object object=None) -> CreateLogContext
943 __init__(CreateLogContext self) -> CreateLogContext
944 __init__(CreateLogContext self, char const * fname, Object object=None) -> CreateLogContext
946 _IMP_kernel.CreateLogContext_swiginit(self, _IMP_kernel.new_CreateLogContext(*args))
948 def set(self, fname, object=None):
949 r"""set(CreateLogContext self, char const * fname, Object object=None)"""
950 return _IMP_kernel.CreateLogContext_set(self, fname, object)
953 r"""reset(CreateLogContext self)"""
954 return _IMP_kernel.CreateLogContext_reset(self)
955 __swig_destroy__ = _IMP_kernel.delete_CreateLogContext
957 def show(self, *args):
958 r"""show(CreateLogContext self, _ostream out=std::cout)"""
959 return _IMP_kernel.CreateLogContext_show(self, *args)
963 def __exit__(self, exc_type, exc_val, exc_tb):
969 r"""__str__(CreateLogContext self) -> std::string"""
970 return _IMP_kernel.CreateLogContext___str__(self)
973 r"""__repr__(CreateLogContext self) -> std::string"""
974 return _IMP_kernel.CreateLogContext___repr__(self)
977 _IMP_kernel.CreateLogContext_swigregister(CreateLogContext)
978 class SetCheckState(_RAII):
979 r"""Proxy of C++ IMP::SetCheckState class."""
981 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
984 r"""reset(SetCheckState self)"""
985 return _IMP_kernel.SetCheckState_reset(self)
986 __swig_destroy__ = _IMP_kernel.delete_SetCheckState
988 def show(self, *args):
989 r"""show(SetCheckState self, _ostream out=std::cout)"""
990 return _IMP_kernel.SetCheckState_show(self, *args)
992 def __init__(self, *args):
994 __init__(SetCheckState self) -> SetCheckState
995 __init__(SetCheckState self, Object o, IMP::CheckLevel l) -> SetCheckState
996 __init__(SetCheckState self, IMP::CheckLevel l) -> SetCheckState
998 _IMP_kernel.SetCheckState_swiginit(self, _IMP_kernel.new_SetCheckState(*args))
1000 def set(self, *args):
1002 set(SetCheckState self, Object o, IMP::CheckLevel l)
1003 set(SetCheckState self, IMP::CheckLevel l)
1005 return _IMP_kernel.SetCheckState_set(self, *args)
1007 def __enter__(self):
1009 def __exit__(self, exc_type, exc_val, exc_tb):
1015 r"""__str__(SetCheckState self) -> std::string"""
1016 return _IMP_kernel.SetCheckState___str__(self)
1019 r"""__repr__(SetCheckState self) -> std::string"""
1020 return _IMP_kernel.SetCheckState___repr__(self)
1023 _IMP_kernel.SetCheckState_swigregister(SetCheckState)
1026 r"""get_unique_name(std::string templ) -> std::string"""
1027 return _IMP_kernel.get_unique_name(templ)
1030 r"""get_copyright() -> std::string"""
1031 return _IMP_kernel.get_copyright()
1032 class _Protection(object):
1033 r"""Proxy of C++ IMP::internal::_Protection class."""
1035 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1037 def __init__(self, *args, **kwargs):
1038 raise AttributeError(
"No constructor defined")
1040 def show(self, *args):
1041 r"""show(_Protection self, _ostream out=std::cout)"""
1042 return _IMP_kernel._Protection_show(self, *args)
1045 r"""__str__(_Protection self) -> std::string"""
1046 return _IMP_kernel._Protection___str__(self)
1049 r"""__repr__(_Protection self) -> std::string"""
1050 return _IMP_kernel._Protection___repr__(self)
1051 __swig_destroy__ = _IMP_kernel.delete__Protection
1054 _IMP_kernel._Protection_swigregister(_Protection)
1058 return _IMP_kernel._test_log()
1060 def _test_intranges(ips):
1061 r"""_test_intranges(IMP::IntRanges const & ips) -> int"""
1062 return _IMP_kernel._test_intranges(ips)
1064 def _test_intrange(*args):
1066 _test_intrange(IMP::IntRange const & ips) -> IMP::IntRange
1067 _test_intrange() -> IMP::IntRange
1069 return _IMP_kernel._test_intrange(*args)
1072 r"""_test_ifile(TextInput a) -> std::string"""
1073 return _IMP_kernel._test_ifile(a)
1076 r"""_test_ofile(TextOutput a) -> std::string"""
1077 return _IMP_kernel._test_ofile(a)
1079 def _test_ifile_overloaded(*args):
1081 _test_ifile_overloaded(TextInput a, int i) -> std::string
1082 _test_ifile_overloaded(TextInput a, std::string st) -> std::string
1084 return _IMP_kernel._test_ifile_overloaded(*args)
1086 def _test_ofile_overloaded(*args):
1088 _test_ofile_overloaded(TextOutput a, int i) -> std::string
1089 _test_ofile_overloaded(TextOutput a, std::string st) -> std::string
1091 return _IMP_kernel._test_ofile_overloaded(*args)
1092 class _TestValue(object):
1093 r"""Proxy of C++ IMP::internal::_TestValue class."""
1095 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1097 def __init__(self, i):
1098 r"""__init__(_TestValue self, int i) -> _TestValue"""
1099 _IMP_kernel._TestValue_swiginit(self, _IMP_kernel.new__TestValue(i))
1101 def show(self, *args):
1102 r"""show(_TestValue self, _ostream out=std::cout)"""
1103 return _IMP_kernel._TestValue_show(self, *args)
1105 def __cmp__(self, o):
1106 r"""__cmp__(_TestValue self, _TestValue o) -> int"""
1107 return _IMP_kernel._TestValue___cmp__(self, o)
1109 def __eq__(self, o):
1110 r"""__eq__(_TestValue self, _TestValue o) -> bool"""
1111 return _IMP_kernel._TestValue___eq__(self, o)
1113 def __ne__(self, o):
1114 r"""__ne__(_TestValue self, _TestValue o) -> bool"""
1115 return _IMP_kernel._TestValue___ne__(self, o)
1117 def __lt__(self, o):
1118 r"""__lt__(_TestValue self, _TestValue o) -> bool"""
1119 return _IMP_kernel._TestValue___lt__(self, o)
1121 def __gt__(self, o):
1122 r"""__gt__(_TestValue self, _TestValue o) -> bool"""
1123 return _IMP_kernel._TestValue___gt__(self, o)
1125 def __ge__(self, o):
1126 r"""__ge__(_TestValue self, _TestValue o) -> bool"""
1127 return _IMP_kernel._TestValue___ge__(self, o)
1129 def __le__(self, o):
1130 r"""__le__(_TestValue self, _TestValue o) -> bool"""
1131 return _IMP_kernel._TestValue___le__(self, o)
1134 r"""get(_TestValue self) -> int"""
1135 return _IMP_kernel._TestValue_get(self)
1137 def get_float(self):
1138 r"""get_float(_TestValue self) -> float const &"""
1139 return _IMP_kernel._TestValue_get_float(self)
1141 def get_double(self):
1142 r"""get_double(_TestValue self) -> double const &"""
1143 return _IMP_kernel._TestValue_get_double(self)
1145 def get_Float(self):
1146 r"""get_Float(_TestValue self) -> IMP::Float const &"""
1147 return _IMP_kernel._TestValue_get_Float(self)
1150 r"""get_int(_TestValue self) -> int const &"""
1151 return _IMP_kernel._TestValue_get_int(self)
1154 r"""get_Int(_TestValue self) -> IMP::Int const &"""
1155 return _IMP_kernel._TestValue_get_Int(self)
1157 def get_string(self):
1158 r"""get_string(_TestValue self) -> std::string const &"""
1159 return _IMP_kernel._TestValue_get_string(self)
1161 def get_String(self):
1162 r"""get_String(_TestValue self) -> IMP::String const &"""
1163 return _IMP_kernel._TestValue_get_String(self)
1166 r"""__str__(_TestValue self) -> std::string"""
1167 return _IMP_kernel._TestValue___str__(self)
1170 r"""__repr__(_TestValue self) -> std::string"""
1171 return _IMP_kernel._TestValue___repr__(self)
1172 __swig_destroy__ = _IMP_kernel.delete__TestValue
1175 _IMP_kernel._TestValue_swigregister(_TestValue)
1177 def _pass_plain_pair(p):
1178 r"""_pass_plain_pair(IMP::FloatPair p) -> IMP::FloatPair"""
1179 return _IMP_kernel._pass_plain_pair(p)
1181 def _pass_overloaded_strings(*args):
1183 _pass_overloaded_strings(IMP::Strings const & a, int arg2) -> IMP::Strings
1184 _pass_overloaded_strings(IMP::Strings const & a) -> IMP::Strings
1186 return _IMP_kernel._pass_overloaded_strings(*args)
1189 r"""_pass_pair(IMP::DerivativePair const & p) -> IMP::DerivativePair"""
1190 return _IMP_kernel._pass_pair(p)
1192 def _pass_floats(input):
1193 r"""_pass_floats(IMP::Floats const & input) -> IMP::Floats"""
1194 return _IMP_kernel._pass_floats(input)
1196 def _pass_ints(input):
1197 r"""_pass_ints(IMP::Ints input) -> IMP::Ints"""
1198 return _IMP_kernel._pass_ints(input)
1200 def _pass_ints_list(input):
1201 r"""_pass_ints_list(IMP::IntsList const & input) -> IMP::IntsList"""
1202 return _IMP_kernel._pass_ints_list(input)
1204 def _pass_ints_lists(input):
1205 r"""_pass_ints_lists(IMP::IntsLists const & input) -> IMP::IntsLists"""
1206 return _IMP_kernel._pass_ints_lists(input)
1208 def _pass_strings(input):
1209 r"""_pass_strings(IMP::Strings const & input) -> IMP::Strings const &"""
1210 return _IMP_kernel._pass_strings(input)
1211 class _TestObject(Object):
1212 r"""Proxy of C++ IMP::internal::_TestObject class."""
1214 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1217 r"""__init__(_TestObject self) -> _TestObject"""
1218 _IMP_kernel._TestObject_swiginit(self, _IMP_kernel.new__TestObject())
1220 def get_version_info(self):
1221 r"""get_version_info(_TestObject self) -> VersionInfo"""
1222 return _IMP_kernel._TestObject_get_version_info(self)
1223 __swig_destroy__ = _IMP_kernel.delete__TestObject
1226 r"""__str__(_TestObject self) -> std::string"""
1227 return _IMP_kernel._TestObject___str__(self)
1230 r"""__repr__(_TestObject self) -> std::string"""
1231 return _IMP_kernel._TestObject___repr__(self)
1235 return _object_cast_to__TestObject(o)
1239 _IMP_kernel._TestObject_swigregister(_TestObject)
1242 r"""get_live_object_names() -> IMP::Strings"""
1243 return _IMP_kernel.get_live_object_names()
1246 r"""get_live_objects() -> IMP::Objects"""
1247 return _IMP_kernel.get_live_objects()
1250 r"""set_show_leaked_objects(bool tf)"""
1251 return _IMP_kernel.set_show_leaked_objects(tf)
1254 r"""set_deprecation_warnings(bool tf)"""
1255 return _IMP_kernel.set_deprecation_warnings(tf)
1258 r"""set_deprecation_exceptions(bool tf)"""
1259 return _IMP_kernel.set_deprecation_exceptions(tf)
1262 r"""get_deprecation_exceptions() -> bool"""
1263 return _IMP_kernel.get_deprecation_exceptions()
1266 r"""handle_use_deprecated(std::string message)"""
1267 return _IMP_kernel.handle_use_deprecated(message)
1270 r"""get_number_of_threads() -> unsigned int"""
1271 return _IMP_kernel.get_number_of_threads()
1274 r"""set_number_of_threads(unsigned int n)"""
1275 return _IMP_kernel.set_number_of_threads(n)
1276 class SetNumberOfThreads(_RAII):
1277 r"""Proxy of C++ IMP::SetNumberOfThreads class."""
1279 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1281 def __init__(self, *args):
1283 __init__(SetNumberOfThreads self) -> SetNumberOfThreads
1284 __init__(SetNumberOfThreads self, unsigned int n) -> SetNumberOfThreads
1286 _IMP_kernel.SetNumberOfThreads_swiginit(self, _IMP_kernel.new_SetNumberOfThreads(*args))
1289 r"""set(SetNumberOfThreads self, unsigned int n)"""
1290 return _IMP_kernel.SetNumberOfThreads_set(self, n)
1293 r"""reset(SetNumberOfThreads self)"""
1294 return _IMP_kernel.SetNumberOfThreads_reset(self)
1295 __swig_destroy__ = _IMP_kernel.delete_SetNumberOfThreads
1297 def show(self, *args):
1298 r"""show(SetNumberOfThreads self, _ostream out=std::cout)"""
1299 return _IMP_kernel.SetNumberOfThreads_show(self, *args)
1301 def __enter__(self):
1303 def __exit__(self, exc_type, exc_val, exc_tb):
1309 r"""__str__(SetNumberOfThreads self) -> std::string"""
1310 return _IMP_kernel.SetNumberOfThreads___str__(self)
1313 r"""__repr__(SetNumberOfThreads self) -> std::string"""
1314 return _IMP_kernel.SetNumberOfThreads___repr__(self)
1317 _IMP_kernel.SetNumberOfThreads_swigregister(SetNumberOfThreads)
1320 i_m_p=
"IMP_MODULE_PATH"
1321 if i_m_p
in os.environ.keys():
1322 __path__.insert(0, os.environ[i_m_p])
1324 def _forward_add_attribute(self, name, value, opt=None):
1326 self.get_particle().add_attribute(name, value, opt)
1328 self.get_particle().add_attribute(name, value)
1329 def _forward_get_value(self, name):
1330 self.get_particle().get_value(name)
1331 def _forward_set_value(self, name, value):
1332 self.get_particle().set_value(name, value)
1338 _object_types.append(
"Constraint")
1341 def _object_cast_to_Constraint(o):
1342 r"""_object_cast_to_Constraint(Object o) -> Constraint"""
1343 return _IMP_kernel._object_cast_to_Constraint(o)
1345 _object_types.append(
"Undecorator")
1348 def _object_cast_to_Undecorator(o):
1349 r"""_object_cast_to_Undecorator(Object o) -> Undecorator"""
1350 return _IMP_kernel._object_cast_to_Undecorator(o)
1352 _object_types.append(
"Container")
1355 def _object_cast_to_Container(o):
1356 r"""_object_cast_to_Container(Object o) -> Container"""
1357 return _IMP_kernel._object_cast_to_Container(o)
1359 _object_types.append(
"Optimizer")
1362 def _object_cast_to_Optimizer(o):
1363 r"""_object_cast_to_Optimizer(Object o) -> Optimizer"""
1364 return _IMP_kernel._object_cast_to_Optimizer(o)
1366 _object_types.append(
"AttributeOptimizer")
1369 def _object_cast_to_AttributeOptimizer(o):
1370 r"""_object_cast_to_AttributeOptimizer(Object o) -> AttributeOptimizer"""
1371 return _IMP_kernel._object_cast_to_AttributeOptimizer(o)
1373 _object_types.append(
"OptimizerState")
1376 def _object_cast_to_OptimizerState(o):
1377 r"""_object_cast_to_OptimizerState(Object o) -> OptimizerState"""
1378 return _IMP_kernel._object_cast_to_OptimizerState(o)
1380 _object_types.append(
"PairContainer")
1383 def _object_cast_to_PairContainer(o):
1384 r"""_object_cast_to_PairContainer(Object o) -> PairContainer"""
1385 return _IMP_kernel._object_cast_to_PairContainer(o)
1387 _object_types.append(
"PairModifier")
1390 def _object_cast_to_PairModifier(o):
1391 r"""_object_cast_to_PairModifier(Object o) -> PairModifier"""
1392 return _IMP_kernel._object_cast_to_PairModifier(o)
1394 _object_types.append(
"PairScore")
1397 def _object_cast_to_PairScore(o):
1398 r"""_object_cast_to_PairScore(Object o) -> PairScore"""
1399 return _IMP_kernel._object_cast_to_PairScore(o)
1401 _object_types.append(
"QuadContainer")
1404 def _object_cast_to_QuadContainer(o):
1405 r"""_object_cast_to_QuadContainer(Object o) -> QuadContainer"""
1406 return _IMP_kernel._object_cast_to_QuadContainer(o)
1408 _object_types.append(
"QuadModifier")
1411 def _object_cast_to_QuadModifier(o):
1412 r"""_object_cast_to_QuadModifier(Object o) -> QuadModifier"""
1413 return _IMP_kernel._object_cast_to_QuadModifier(o)
1415 _object_types.append(
"QuadScore")
1418 def _object_cast_to_QuadScore(o):
1419 r"""_object_cast_to_QuadScore(Object o) -> QuadScore"""
1420 return _IMP_kernel._object_cast_to_QuadScore(o)
1422 _object_types.append(
"Refiner")
1425 def _object_cast_to_Refiner(o):
1426 r"""_object_cast_to_Refiner(Object o) -> Refiner"""
1427 return _IMP_kernel._object_cast_to_Refiner(o)
1429 _object_types.append(
"Restraint")
1432 def _object_cast_to_Restraint(o):
1433 r"""_object_cast_to_Restraint(Object o) -> Restraint"""
1434 return _IMP_kernel._object_cast_to_Restraint(o)
1436 _object_types.append(
"Sampler")
1439 def _object_cast_to_Sampler(o):
1440 r"""_object_cast_to_Sampler(Object o) -> Sampler"""
1441 return _IMP_kernel._object_cast_to_Sampler(o)
1443 _object_types.append(
"ScoreState")
1446 def _object_cast_to_ScoreState(o):
1447 r"""_object_cast_to_ScoreState(Object o) -> ScoreState"""
1448 return _IMP_kernel._object_cast_to_ScoreState(o)
1450 _object_types.append(
"SingletonContainer")
1453 def _object_cast_to_SingletonContainer(o):
1454 r"""_object_cast_to_SingletonContainer(Object o) -> SingletonContainer"""
1455 return _IMP_kernel._object_cast_to_SingletonContainer(o)
1457 _object_types.append(
"SingletonModifier")
1460 def _object_cast_to_SingletonModifier(o):
1461 r"""_object_cast_to_SingletonModifier(Object o) -> SingletonModifier"""
1462 return _IMP_kernel._object_cast_to_SingletonModifier(o)
1464 _object_types.append(
"SingletonScore")
1467 def _object_cast_to_SingletonScore(o):
1468 r"""_object_cast_to_SingletonScore(Object o) -> SingletonScore"""
1469 return _IMP_kernel._object_cast_to_SingletonScore(o)
1471 _object_types.append(
"TripletContainer")
1474 def _object_cast_to_TripletContainer(o):
1475 r"""_object_cast_to_TripletContainer(Object o) -> TripletContainer"""
1476 return _IMP_kernel._object_cast_to_TripletContainer(o)
1478 _object_types.append(
"TripletModifier")
1481 def _object_cast_to_TripletModifier(o):
1482 r"""_object_cast_to_TripletModifier(Object o) -> TripletModifier"""
1483 return _IMP_kernel._object_cast_to_TripletModifier(o)
1485 _object_types.append(
"TripletScore")
1488 def _object_cast_to_TripletScore(o):
1489 r"""_object_cast_to_TripletScore(Object o) -> TripletScore"""
1490 return _IMP_kernel._object_cast_to_TripletScore(o)
1492 _object_types.append(
"UnaryFunction")
1495 def _object_cast_to_UnaryFunction(o):
1496 r"""_object_cast_to_UnaryFunction(Object o) -> UnaryFunction"""
1497 return _IMP_kernel._object_cast_to_UnaryFunction(o)
1499 _object_types.append(
"RestraintInfo")
1502 def _object_cast_to_RestraintInfo(o):
1503 r"""_object_cast_to_RestraintInfo(Object o) -> RestraintInfo"""
1504 return _IMP_kernel._object_cast_to_RestraintInfo(o)
1506 _object_types.append(
"ConfigurationSet")
1509 def _object_cast_to_ConfigurationSet(o):
1510 r"""_object_cast_to_ConfigurationSet(Object o) -> ConfigurationSet"""
1511 return _IMP_kernel._object_cast_to_ConfigurationSet(o)
1513 _object_types.append(
"Configuration")
1516 def _object_cast_to_Configuration(o):
1517 r"""_object_cast_to_Configuration(Object o) -> Configuration"""
1518 return _IMP_kernel._object_cast_to_Configuration(o)
1520 _object_types.append(
"Model")
1523 def _object_cast_to_Model(o):
1524 r"""_object_cast_to_Model(Object o) -> Model"""
1525 return _IMP_kernel._object_cast_to_Model(o)
1527 _object_types.append(
"Particle")
1530 def _object_cast_to_Particle(o):
1531 r"""_object_cast_to_Particle(Object o) -> Particle"""
1532 return _IMP_kernel._object_cast_to_Particle(o)
1534 _object_types.append(
"RestraintSet")
1537 def _object_cast_to_RestraintSet(o):
1538 r"""_object_cast_to_RestraintSet(Object o) -> RestraintSet"""
1539 return _IMP_kernel._object_cast_to_RestraintSet(o)
1541 ParticlePairsTemp=list
1542 _plural_types.append(
"ParticlePairsTemp")
1543 _value_types.append(
"ParticlePair")
1546 ParticleTripletsTemp=list
1547 _plural_types.append(
"ParticleTripletsTemp")
1548 _value_types.append(
"ParticleTriplet")
1551 ParticleQuadsTemp=list
1552 _plural_types.append(
"ParticleQuadsTemp")
1553 _value_types.append(
"ParticleQuad")
1556 ParticleIndexPairs=list
1557 _plural_types.append(
"ParticleIndexPairs")
1558 _value_types.append(
"ParticleIndexPair")
1561 ParticleIndexTriplets=list
1562 _plural_types.append(
"ParticleIndexTriplets")
1563 _value_types.append(
"ParticleIndexTriplet")
1566 ParticleIndexQuads=list
1567 _plural_types.append(
"ParticleIndexQuads")
1568 _value_types.append(
"ParticleIndexQuad")
1571 _object_types.append(
"SingletonPredicate")
1574 def _object_cast_to_SingletonPredicate(o):
1575 r"""_object_cast_to_SingletonPredicate(Object o) -> SingletonPredicate"""
1576 return _IMP_kernel._object_cast_to_SingletonPredicate(o)
1578 _object_types.append(
"PairPredicate")
1581 def _object_cast_to_PairPredicate(o):
1582 r"""_object_cast_to_PairPredicate(Object o) -> PairPredicate"""
1583 return _IMP_kernel._object_cast_to_PairPredicate(o)
1585 _object_types.append(
"TripletPredicate")
1588 def _object_cast_to_TripletPredicate(o):
1589 r"""_object_cast_to_TripletPredicate(Object o) -> TripletPredicate"""
1590 return _IMP_kernel._object_cast_to_TripletPredicate(o)
1592 _object_types.append(
"QuadPredicate")
1595 def _object_cast_to_QuadPredicate(o):
1596 r"""_object_cast_to_QuadPredicate(Object o) -> QuadPredicate"""
1597 return _IMP_kernel._object_cast_to_QuadPredicate(o)
1599 _object_types.append(
"SaveToConfigurationSetOptimizerState")
1602 def _object_cast_to_SaveToConfigurationSetOptimizerState(o):
1603 r"""_object_cast_to_SaveToConfigurationSetOptimizerState(Object o) -> SaveToConfigurationSetOptimizerState"""
1604 return _IMP_kernel._object_cast_to_SaveToConfigurationSetOptimizerState(o)
1606 EvaluationStates=list
1607 _plural_types.append(
"EvaluationStates")
1608 _value_types.append(
"EvaluationState")
1611 ScoreAccumulators=list
1612 _plural_types.append(
"ScoreAccumulators")
1613 _value_types.append(
"ScoreAccumulator")
1616 ParticleIndexes=list
1617 _plural_types.append(
"ParticleIndexes")
1618 _value_types.append(
"ParticleIndex")
1622 _plural_types.append(
"FloatIndexes")
1623 _value_types.append(
"FloatIndex")
1627 _plural_types.append(
"FloatKeys")
1628 _value_types.append(
"FloatKey")
1632 _plural_types.append(
"FloatsKeys")
1633 _value_types.append(
"FloatsKey")
1637 _plural_types.append(
"IntKeys")
1638 _value_types.append(
"IntKey")
1642 _plural_types.append(
"IntsKeys")
1643 _value_types.append(
"IntsKey")
1647 _plural_types.append(
"StringKeys")
1648 _value_types.append(
"StringKey")
1651 ParticleIndexKeys=list
1652 _plural_types.append(
"ParticleIndexKeys")
1653 _value_types.append(
"ParticleIndexKey")
1656 ParticleIndexesKeys=list
1657 _plural_types.append(
"ParticleIndexesKeys")
1658 _value_types.append(
"ParticleIndexesKey")
1662 _plural_types.append(
"ObjectKeys")
1663 _value_types.append(
"ObjectKey")
1667 _plural_types.append(
"ModelKeys")
1668 _value_types.append(
"ModelKey")
1672 _plural_types.append(
"TriggerKeys")
1673 _value_types.append(
"TriggerKey")
1676 SparseFloatKeys=list
1677 _plural_types.append(
"SparseFloatKeys")
1678 _value_types.append(
"SparseFloatKey")
1682 _plural_types.append(
"SparseIntKeys")
1683 _value_types.append(
"SparseIntKey")
1686 SparseStringKeys=list
1687 _plural_types.append(
"SparseStringKeys")
1688 _value_types.append(
"SparseStringKey")
1691 SparseParticleIndexKeys=list
1692 _plural_types.append(
"SparseParticleIndexKeys")
1693 _value_types.append(
"SparseParticleIndexKey")
1696 _raii_types.append(
"ScopedSetFloatAttribute")
1699 _object_types.append(
"ScoringFunction")
1702 def _object_cast_to_ScoringFunction(o):
1703 r"""_object_cast_to_ScoringFunction(Object o) -> ScoringFunction"""
1704 return _IMP_kernel._object_cast_to_ScoringFunction(o)
1706 _object_types.append(
"ModelObject")
1709 def _object_cast_to_ModelObject(o):
1710 r"""_object_cast_to_ModelObject(Object o) -> ModelObject"""
1711 return _IMP_kernel._object_cast_to_ModelObject(o)
1713 def _TrivialDecorators(l=[]):
1714 return [_TrivialDecorator(x)
for x
in l]
1715 _plural_types.append(
"_TrivialDecorators")
1718 _value_types.append(
"_TrivialDecorator")
1721 def _TrivialDerivedDecorators(l=[]):
1722 return [_TrivialDerivedDecorator(x)
for x
in l]
1723 _plural_types.append(
"_TrivialDerivedDecorators")
1726 _value_types.append(
"_TrivialDerivedDecorator")
1729 def _TrivialTraitsDecorators(l=[]):
1730 return [_TrivialTraitsDecorator(x)
for x
in l]
1731 _plural_types.append(
"_TrivialTraitsDecorators")
1734 _value_types.append(
"_TrivialTraitsDecorator")
1737 _object_types.append(
"_ConstRestraint")
1740 def _object_cast_to__ConstRestraint(o):
1741 r"""_object_cast_to__ConstRestraint(Object o) -> _ConstRestraint"""
1742 return _IMP_kernel._object_cast_to__ConstRestraint(o)
1744 _object_types.append(
"_ConstOptimizer")
1747 def _object_cast_to__ConstOptimizer(o):
1748 r"""_object_cast_to__ConstOptimizer(Object o) -> _ConstOptimizer"""
1749 return _IMP_kernel._object_cast_to__ConstOptimizer(o)
1751 _object_types.append(
"_ConstSingletonScore")
1754 def _object_cast_to__ConstSingletonScore(o):
1755 r"""_object_cast_to__ConstSingletonScore(Object o) -> _ConstSingletonScore"""
1756 return _IMP_kernel._object_cast_to__ConstSingletonScore(o)
1758 _object_types.append(
"_ConstPairScore")
1761 def _object_cast_to__ConstPairScore(o):
1762 r"""_object_cast_to__ConstPairScore(Object o) -> _ConstPairScore"""
1763 return _IMP_kernel._object_cast_to__ConstPairScore(o)
1765 r"""Proxy of C++ IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex > class."""
1767 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1768 __repr__ = _swig_repr
1771 r"""__init__(DependencyGraph self) -> DependencyGraph"""
1772 _IMP_kernel.DependencyGraph_swiginit(self, _IMP_kernel.new_DependencyGraph())
1774 def get_graph(self):
1775 r"""get_graph(DependencyGraph self) -> IMP::DependencyGraph const &"""
1776 return _IMP_kernel.DependencyGraph_get_graph(self)
1779 r"""get_vertices(DependencyGraph self) -> IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptors"""
1780 return _IMP_kernel.DependencyGraph_get_vertices(self)
1782 def get_vertex_name(self, i):
1783 r"""get_vertex_name(DependencyGraph self, IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptor i) -> ModelObject"""
1784 return _IMP_kernel.DependencyGraph_get_vertex_name(self, i)
1786 def get_in_neighbors(self, v):
1787 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"""
1788 return _IMP_kernel.DependencyGraph_get_in_neighbors(self, v)
1790 def get_out_neighbors(self, v):
1791 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"""
1792 return _IMP_kernel.DependencyGraph_get_out_neighbors(self, v)
1795 r"""show_graphviz(DependencyGraph self, _ostream out=std::cout)"""
1796 return _IMP_kernel.DependencyGraph_show_graphviz(self, *args)
1798 def get_graphviz_string(self):
1799 r"""get_graphviz_string(DependencyGraph self) -> std::string"""
1800 return _IMP_kernel.DependencyGraph_get_graphviz_string(self)
1802 def add_edge(self, v0, v1):
1803 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)"""
1804 return _IMP_kernel.DependencyGraph_add_edge(self, v0, v1)
1806 def add_vertex(self, l):
1807 r"""add_vertex(DependencyGraph self, ModelObject l) -> IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptor"""
1808 return _IMP_kernel.DependencyGraph_add_vertex(self, l)
1810 def remove_vertex(self, l):
1811 r"""remove_vertex(DependencyGraph self, IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptor l)"""
1812 return _IMP_kernel.DependencyGraph_remove_vertex(self, l)
1813 __swig_destroy__ = _IMP_kernel.delete_DependencyGraph
1816 _IMP_kernel.DependencyGraph_swigregister(DependencyGraph)
1818 _value_types.append(
"DependencyGraph")
1821 r"""Proxy of C++ IMP::Key< 0 > class."""
1823 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1825 def __init__(self, *args):
1827 __init__(FloatKey self) -> FloatKey
1828 __init__(FloatKey self, std::string const & c, bool is_implicit_add_permitted=True) -> FloatKey
1829 __init__(FloatKey self, unsigned int i) -> FloatKey
1831 _IMP_kernel.FloatKey_swiginit(self, _IMP_kernel.new_FloatKey(*args))
1835 r"""add_key(std::string sc) -> unsigned int"""
1836 return _IMP_kernel.FloatKey_add_key(sc)
1839 def get_key_exists(sc):
1840 r"""get_key_exists(std::string sc) -> bool"""
1841 return _IMP_kernel.FloatKey_get_key_exists(sc)
1843 def get_string(self):
1844 r"""get_string(FloatKey self) -> std::string const"""
1845 return _IMP_kernel.FloatKey_get_string(self)
1847 def __cmp__(self, o):
1848 r"""__cmp__(FloatKey self, FloatKey o) -> int"""
1849 return _IMP_kernel.FloatKey___cmp__(self, o)
1851 def __eq__(self, o):
1852 r"""__eq__(FloatKey self, FloatKey o) -> bool"""
1853 return _IMP_kernel.FloatKey___eq__(self, o)
1855 def __ne__(self, o):
1856 r"""__ne__(FloatKey self, FloatKey o) -> bool"""
1857 return _IMP_kernel.FloatKey___ne__(self, o)
1859 def __lt__(self, o):
1860 r"""__lt__(FloatKey self, FloatKey o) -> bool"""
1861 return _IMP_kernel.FloatKey___lt__(self, o)
1863 def __gt__(self, o):
1864 r"""__gt__(FloatKey self, FloatKey o) -> bool"""
1865 return _IMP_kernel.FloatKey___gt__(self, o)
1867 def __ge__(self, o):
1868 r"""__ge__(FloatKey self, FloatKey o) -> bool"""
1869 return _IMP_kernel.FloatKey___ge__(self, o)
1871 def __le__(self, o):
1872 r"""__le__(FloatKey self, FloatKey o) -> bool"""
1873 return _IMP_kernel.FloatKey___le__(self, o)
1876 r"""__hash__(FloatKey self) -> std::size_t"""
1877 return _IMP_kernel.FloatKey___hash__(self)
1879 def show(self, *args):
1880 r"""show(FloatKey self, _ostream out=std::cout)"""
1881 return _IMP_kernel.FloatKey_show(self, *args)
1884 def add_alias(old_key, new_name):
1885 r"""add_alias(FloatKey old_key, std::string new_name) -> FloatKey"""
1886 return _IMP_kernel.FloatKey_add_alias(old_key, new_name)
1889 def get_number_of_keys():
1890 r"""get_number_of_keys() -> unsigned int"""
1891 return _IMP_kernel.FloatKey_get_number_of_keys()
1894 r"""get_index(FloatKey self) -> unsigned int"""
1895 return _IMP_kernel.FloatKey_get_index(self)
1899 r"""show_all(_ostream out)"""
1900 return _IMP_kernel.FloatKey_show_all(out)
1903 def get_all_strings():
1904 r"""get_all_strings() -> IMP::Vector< std::string >"""
1905 return _IMP_kernel.FloatKey_get_all_strings()
1908 def get_number_unique():
1909 r"""get_number_unique() -> unsigned int"""
1910 return _IMP_kernel.FloatKey_get_number_unique()
1913 r"""__str__(FloatKey self) -> std::string"""
1914 return _IMP_kernel.FloatKey___str__(self)
1917 r"""__repr__(FloatKey self) -> std::string"""
1918 return _IMP_kernel.FloatKey___repr__(self)
1919 __swig_destroy__ = _IMP_kernel.delete_FloatKey
1922 _IMP_kernel.FloatKey_swigregister(FloatKey)
1924 r"""Proxy of C++ IMP::Key< 1 > class."""
1926 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1928 def __init__(self, *args):
1930 __init__(IntKey self) -> IntKey
1931 __init__(IntKey self, std::string const & c, bool is_implicit_add_permitted=True) -> IntKey
1932 __init__(IntKey self, unsigned int i) -> IntKey
1934 _IMP_kernel.IntKey_swiginit(self, _IMP_kernel.new_IntKey(*args))
1938 r"""add_key(std::string sc) -> unsigned int"""
1939 return _IMP_kernel.IntKey_add_key(sc)
1942 def get_key_exists(sc):
1943 r"""get_key_exists(std::string sc) -> bool"""
1944 return _IMP_kernel.IntKey_get_key_exists(sc)
1946 def get_string(self):
1947 r"""get_string(IntKey self) -> std::string const"""
1948 return _IMP_kernel.IntKey_get_string(self)
1950 def __cmp__(self, o):
1951 r"""__cmp__(IntKey self, IntKey o) -> int"""
1952 return _IMP_kernel.IntKey___cmp__(self, o)
1954 def __eq__(self, o):
1955 r"""__eq__(IntKey self, IntKey o) -> bool"""
1956 return _IMP_kernel.IntKey___eq__(self, o)
1958 def __ne__(self, o):
1959 r"""__ne__(IntKey self, IntKey o) -> bool"""
1960 return _IMP_kernel.IntKey___ne__(self, o)
1962 def __lt__(self, o):
1963 r"""__lt__(IntKey self, IntKey o) -> bool"""
1964 return _IMP_kernel.IntKey___lt__(self, o)
1966 def __gt__(self, o):
1967 r"""__gt__(IntKey self, IntKey o) -> bool"""
1968 return _IMP_kernel.IntKey___gt__(self, o)
1970 def __ge__(self, o):
1971 r"""__ge__(IntKey self, IntKey o) -> bool"""
1972 return _IMP_kernel.IntKey___ge__(self, o)
1974 def __le__(self, o):
1975 r"""__le__(IntKey self, IntKey o) -> bool"""
1976 return _IMP_kernel.IntKey___le__(self, o)
1979 r"""__hash__(IntKey self) -> std::size_t"""
1980 return _IMP_kernel.IntKey___hash__(self)
1982 def show(self, *args):
1983 r"""show(IntKey self, _ostream out=std::cout)"""
1984 return _IMP_kernel.IntKey_show(self, *args)
1987 def add_alias(old_key, new_name):
1988 r"""add_alias(IntKey old_key, std::string new_name) -> IntKey"""
1989 return _IMP_kernel.IntKey_add_alias(old_key, new_name)
1992 def get_number_of_keys():
1993 r"""get_number_of_keys() -> unsigned int"""
1994 return _IMP_kernel.IntKey_get_number_of_keys()
1997 r"""get_index(IntKey self) -> unsigned int"""
1998 return _IMP_kernel.IntKey_get_index(self)
2002 r"""show_all(_ostream out)"""
2003 return _IMP_kernel.IntKey_show_all(out)
2006 def get_all_strings():
2007 r"""get_all_strings() -> IMP::Vector< std::string >"""
2008 return _IMP_kernel.IntKey_get_all_strings()
2011 def get_number_unique():
2012 r"""get_number_unique() -> unsigned int"""
2013 return _IMP_kernel.IntKey_get_number_unique()
2016 r"""__str__(IntKey self) -> std::string"""
2017 return _IMP_kernel.IntKey___str__(self)
2020 r"""__repr__(IntKey self) -> std::string"""
2021 return _IMP_kernel.IntKey___repr__(self)
2022 __swig_destroy__ = _IMP_kernel.delete_IntKey
2025 _IMP_kernel.IntKey_swigregister(IntKey)
2027 r"""Proxy of C++ IMP::Key< 2 > class."""
2029 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2031 def __init__(self, *args):
2033 __init__(StringKey self) -> StringKey
2034 __init__(StringKey self, std::string const & c, bool is_implicit_add_permitted=True) -> StringKey
2035 __init__(StringKey self, unsigned int i) -> StringKey
2037 _IMP_kernel.StringKey_swiginit(self, _IMP_kernel.new_StringKey(*args))
2041 r"""add_key(std::string sc) -> unsigned int"""
2042 return _IMP_kernel.StringKey_add_key(sc)
2045 def get_key_exists(sc):
2046 r"""get_key_exists(std::string sc) -> bool"""
2047 return _IMP_kernel.StringKey_get_key_exists(sc)
2049 def get_string(self):
2050 r"""get_string(StringKey self) -> std::string const"""
2051 return _IMP_kernel.StringKey_get_string(self)
2053 def __cmp__(self, o):
2054 r"""__cmp__(StringKey self, StringKey o) -> int"""
2055 return _IMP_kernel.StringKey___cmp__(self, o)
2057 def __eq__(self, o):
2058 r"""__eq__(StringKey self, StringKey o) -> bool"""
2059 return _IMP_kernel.StringKey___eq__(self, o)
2061 def __ne__(self, o):
2062 r"""__ne__(StringKey self, StringKey o) -> bool"""
2063 return _IMP_kernel.StringKey___ne__(self, o)
2065 def __lt__(self, o):
2066 r"""__lt__(StringKey self, StringKey o) -> bool"""
2067 return _IMP_kernel.StringKey___lt__(self, o)
2069 def __gt__(self, o):
2070 r"""__gt__(StringKey self, StringKey o) -> bool"""
2071 return _IMP_kernel.StringKey___gt__(self, o)
2073 def __ge__(self, o):
2074 r"""__ge__(StringKey self, StringKey o) -> bool"""
2075 return _IMP_kernel.StringKey___ge__(self, o)
2077 def __le__(self, o):
2078 r"""__le__(StringKey self, StringKey o) -> bool"""
2079 return _IMP_kernel.StringKey___le__(self, o)
2082 r"""__hash__(StringKey self) -> std::size_t"""
2083 return _IMP_kernel.StringKey___hash__(self)
2085 def show(self, *args):
2086 r"""show(StringKey self, _ostream out=std::cout)"""
2087 return _IMP_kernel.StringKey_show(self, *args)
2090 def add_alias(old_key, new_name):
2091 r"""add_alias(StringKey old_key, std::string new_name) -> StringKey"""
2092 return _IMP_kernel.StringKey_add_alias(old_key, new_name)
2095 def get_number_of_keys():
2096 r"""get_number_of_keys() -> unsigned int"""
2097 return _IMP_kernel.StringKey_get_number_of_keys()
2100 r"""get_index(StringKey self) -> unsigned int"""
2101 return _IMP_kernel.StringKey_get_index(self)
2105 r"""show_all(_ostream out)"""
2106 return _IMP_kernel.StringKey_show_all(out)
2109 def get_all_strings():
2110 r"""get_all_strings() -> IMP::Vector< std::string >"""
2111 return _IMP_kernel.StringKey_get_all_strings()
2114 def get_number_unique():
2115 r"""get_number_unique() -> unsigned int"""
2116 return _IMP_kernel.StringKey_get_number_unique()
2119 r"""__str__(StringKey self) -> std::string"""
2120 return _IMP_kernel.StringKey___str__(self)
2123 r"""__repr__(StringKey self) -> std::string"""
2124 return _IMP_kernel.StringKey___repr__(self)
2125 __swig_destroy__ = _IMP_kernel.delete_StringKey
2128 _IMP_kernel.StringKey_swigregister(StringKey)
2130 r"""Proxy of C++ IMP::Key< 3 > class."""
2132 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2134 def __init__(self, *args):
2136 __init__(ParticleIndexKey self) -> ParticleIndexKey
2137 __init__(ParticleIndexKey self, std::string const & c, bool is_implicit_add_permitted=True) -> ParticleIndexKey
2138 __init__(ParticleIndexKey self, unsigned int i) -> ParticleIndexKey
2140 _IMP_kernel.ParticleIndexKey_swiginit(self, _IMP_kernel.new_ParticleIndexKey(*args))
2144 r"""add_key(std::string sc) -> unsigned int"""
2145 return _IMP_kernel.ParticleIndexKey_add_key(sc)
2148 def get_key_exists(sc):
2149 r"""get_key_exists(std::string sc) -> bool"""
2150 return _IMP_kernel.ParticleIndexKey_get_key_exists(sc)
2152 def get_string(self):
2153 r"""get_string(ParticleIndexKey self) -> std::string const"""
2154 return _IMP_kernel.ParticleIndexKey_get_string(self)
2156 def __cmp__(self, o):
2157 r"""__cmp__(ParticleIndexKey self, ParticleIndexKey o) -> int"""
2158 return _IMP_kernel.ParticleIndexKey___cmp__(self, o)
2160 def __eq__(self, o):
2161 r"""__eq__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2162 return _IMP_kernel.ParticleIndexKey___eq__(self, o)
2164 def __ne__(self, o):
2165 r"""__ne__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2166 return _IMP_kernel.ParticleIndexKey___ne__(self, o)
2168 def __lt__(self, o):
2169 r"""__lt__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2170 return _IMP_kernel.ParticleIndexKey___lt__(self, o)
2172 def __gt__(self, o):
2173 r"""__gt__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2174 return _IMP_kernel.ParticleIndexKey___gt__(self, o)
2176 def __ge__(self, o):
2177 r"""__ge__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2178 return _IMP_kernel.ParticleIndexKey___ge__(self, o)
2180 def __le__(self, o):
2181 r"""__le__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2182 return _IMP_kernel.ParticleIndexKey___le__(self, o)
2185 r"""__hash__(ParticleIndexKey self) -> std::size_t"""
2186 return _IMP_kernel.ParticleIndexKey___hash__(self)
2188 def show(self, *args):
2189 r"""show(ParticleIndexKey self, _ostream out=std::cout)"""
2190 return _IMP_kernel.ParticleIndexKey_show(self, *args)
2193 def add_alias(old_key, new_name):
2194 r"""add_alias(ParticleIndexKey old_key, std::string new_name) -> ParticleIndexKey"""
2195 return _IMP_kernel.ParticleIndexKey_add_alias(old_key, new_name)
2198 def get_number_of_keys():
2199 r"""get_number_of_keys() -> unsigned int"""
2200 return _IMP_kernel.ParticleIndexKey_get_number_of_keys()
2203 r"""get_index(ParticleIndexKey self) -> unsigned int"""
2204 return _IMP_kernel.ParticleIndexKey_get_index(self)
2208 r"""show_all(_ostream out)"""
2209 return _IMP_kernel.ParticleIndexKey_show_all(out)
2212 def get_all_strings():
2213 r"""get_all_strings() -> IMP::Vector< std::string >"""
2214 return _IMP_kernel.ParticleIndexKey_get_all_strings()
2217 def get_number_unique():
2218 r"""get_number_unique() -> unsigned int"""
2219 return _IMP_kernel.ParticleIndexKey_get_number_unique()
2222 r"""__str__(ParticleIndexKey self) -> std::string"""
2223 return _IMP_kernel.ParticleIndexKey___str__(self)
2226 r"""__repr__(ParticleIndexKey self) -> std::string"""
2227 return _IMP_kernel.ParticleIndexKey___repr__(self)
2228 __swig_destroy__ = _IMP_kernel.delete_ParticleIndexKey
2231 _IMP_kernel.ParticleIndexKey_swigregister(ParticleIndexKey)
2233 r"""Proxy of C++ IMP::Key< 4 > class."""
2235 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2237 def __init__(self, *args):
2239 __init__(ObjectKey self) -> ObjectKey
2240 __init__(ObjectKey self, std::string const & c, bool is_implicit_add_permitted=True) -> ObjectKey
2241 __init__(ObjectKey self, unsigned int i) -> ObjectKey
2243 _IMP_kernel.ObjectKey_swiginit(self, _IMP_kernel.new_ObjectKey(*args))
2247 r"""add_key(std::string sc) -> unsigned int"""
2248 return _IMP_kernel.ObjectKey_add_key(sc)
2251 def get_key_exists(sc):
2252 r"""get_key_exists(std::string sc) -> bool"""
2253 return _IMP_kernel.ObjectKey_get_key_exists(sc)
2255 def get_string(self):
2256 r"""get_string(ObjectKey self) -> std::string const"""
2257 return _IMP_kernel.ObjectKey_get_string(self)
2259 def __cmp__(self, o):
2260 r"""__cmp__(ObjectKey self, ObjectKey o) -> int"""
2261 return _IMP_kernel.ObjectKey___cmp__(self, o)
2263 def __eq__(self, o):
2264 r"""__eq__(ObjectKey self, ObjectKey o) -> bool"""
2265 return _IMP_kernel.ObjectKey___eq__(self, o)
2267 def __ne__(self, o):
2268 r"""__ne__(ObjectKey self, ObjectKey o) -> bool"""
2269 return _IMP_kernel.ObjectKey___ne__(self, o)
2271 def __lt__(self, o):
2272 r"""__lt__(ObjectKey self, ObjectKey o) -> bool"""
2273 return _IMP_kernel.ObjectKey___lt__(self, o)
2275 def __gt__(self, o):
2276 r"""__gt__(ObjectKey self, ObjectKey o) -> bool"""
2277 return _IMP_kernel.ObjectKey___gt__(self, o)
2279 def __ge__(self, o):
2280 r"""__ge__(ObjectKey self, ObjectKey o) -> bool"""
2281 return _IMP_kernel.ObjectKey___ge__(self, o)
2283 def __le__(self, o):
2284 r"""__le__(ObjectKey self, ObjectKey o) -> bool"""
2285 return _IMP_kernel.ObjectKey___le__(self, o)
2288 r"""__hash__(ObjectKey self) -> std::size_t"""
2289 return _IMP_kernel.ObjectKey___hash__(self)
2291 def show(self, *args):
2292 r"""show(ObjectKey self, _ostream out=std::cout)"""
2293 return _IMP_kernel.ObjectKey_show(self, *args)
2296 def add_alias(old_key, new_name):
2297 r"""add_alias(ObjectKey old_key, std::string new_name) -> ObjectKey"""
2298 return _IMP_kernel.ObjectKey_add_alias(old_key, new_name)
2301 def get_number_of_keys():
2302 r"""get_number_of_keys() -> unsigned int"""
2303 return _IMP_kernel.ObjectKey_get_number_of_keys()
2306 r"""get_index(ObjectKey self) -> unsigned int"""
2307 return _IMP_kernel.ObjectKey_get_index(self)
2311 r"""show_all(_ostream out)"""
2312 return _IMP_kernel.ObjectKey_show_all(out)
2315 def get_all_strings():
2316 r"""get_all_strings() -> IMP::Vector< std::string >"""
2317 return _IMP_kernel.ObjectKey_get_all_strings()
2320 def get_number_unique():
2321 r"""get_number_unique() -> unsigned int"""
2322 return _IMP_kernel.ObjectKey_get_number_unique()
2325 r"""__str__(ObjectKey self) -> std::string"""
2326 return _IMP_kernel.ObjectKey___str__(self)
2329 r"""__repr__(ObjectKey self) -> std::string"""
2330 return _IMP_kernel.ObjectKey___repr__(self)
2331 __swig_destroy__ = _IMP_kernel.delete_ObjectKey
2334 _IMP_kernel.ObjectKey_swigregister(ObjectKey)
2336 r"""Proxy of C++ IMP::Key< 5 > class."""
2338 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2340 def __init__(self, *args):
2342 __init__(IntsKey self) -> IntsKey
2343 __init__(IntsKey self, std::string const & c, bool is_implicit_add_permitted=True) -> IntsKey
2344 __init__(IntsKey self, unsigned int i) -> IntsKey
2346 _IMP_kernel.IntsKey_swiginit(self, _IMP_kernel.new_IntsKey(*args))
2350 r"""add_key(std::string sc) -> unsigned int"""
2351 return _IMP_kernel.IntsKey_add_key(sc)
2354 def get_key_exists(sc):
2355 r"""get_key_exists(std::string sc) -> bool"""
2356 return _IMP_kernel.IntsKey_get_key_exists(sc)
2358 def get_string(self):
2359 r"""get_string(IntsKey self) -> std::string const"""
2360 return _IMP_kernel.IntsKey_get_string(self)
2362 def __cmp__(self, o):
2363 r"""__cmp__(IntsKey self, IntsKey o) -> int"""
2364 return _IMP_kernel.IntsKey___cmp__(self, o)
2366 def __eq__(self, o):
2367 r"""__eq__(IntsKey self, IntsKey o) -> bool"""
2368 return _IMP_kernel.IntsKey___eq__(self, o)
2370 def __ne__(self, o):
2371 r"""__ne__(IntsKey self, IntsKey o) -> bool"""
2372 return _IMP_kernel.IntsKey___ne__(self, o)
2374 def __lt__(self, o):
2375 r"""__lt__(IntsKey self, IntsKey o) -> bool"""
2376 return _IMP_kernel.IntsKey___lt__(self, o)
2378 def __gt__(self, o):
2379 r"""__gt__(IntsKey self, IntsKey o) -> bool"""
2380 return _IMP_kernel.IntsKey___gt__(self, o)
2382 def __ge__(self, o):
2383 r"""__ge__(IntsKey self, IntsKey o) -> bool"""
2384 return _IMP_kernel.IntsKey___ge__(self, o)
2386 def __le__(self, o):
2387 r"""__le__(IntsKey self, IntsKey o) -> bool"""
2388 return _IMP_kernel.IntsKey___le__(self, o)
2391 r"""__hash__(IntsKey self) -> std::size_t"""
2392 return _IMP_kernel.IntsKey___hash__(self)
2394 def show(self, *args):
2395 r"""show(IntsKey self, _ostream out=std::cout)"""
2396 return _IMP_kernel.IntsKey_show(self, *args)
2399 def add_alias(old_key, new_name):
2400 r"""add_alias(IntsKey old_key, std::string new_name) -> IntsKey"""
2401 return _IMP_kernel.IntsKey_add_alias(old_key, new_name)
2404 def get_number_of_keys():
2405 r"""get_number_of_keys() -> unsigned int"""
2406 return _IMP_kernel.IntsKey_get_number_of_keys()
2409 r"""get_index(IntsKey self) -> unsigned int"""
2410 return _IMP_kernel.IntsKey_get_index(self)
2414 r"""show_all(_ostream out)"""
2415 return _IMP_kernel.IntsKey_show_all(out)
2418 def get_all_strings():
2419 r"""get_all_strings() -> IMP::Vector< std::string >"""
2420 return _IMP_kernel.IntsKey_get_all_strings()
2423 def get_number_unique():
2424 r"""get_number_unique() -> unsigned int"""
2425 return _IMP_kernel.IntsKey_get_number_unique()
2428 r"""__str__(IntsKey self) -> std::string"""
2429 return _IMP_kernel.IntsKey___str__(self)
2432 r"""__repr__(IntsKey self) -> std::string"""
2433 return _IMP_kernel.IntsKey___repr__(self)
2434 __swig_destroy__ = _IMP_kernel.delete_IntsKey
2437 _IMP_kernel.IntsKey_swigregister(IntsKey)
2439 r"""Proxy of C++ IMP::Key< 6 > class."""
2441 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2443 def __init__(self, *args):
2445 __init__(ParticleIndexesKey self) -> ParticleIndexesKey
2446 __init__(ParticleIndexesKey self, std::string const & c, bool is_implicit_add_permitted=True) -> ParticleIndexesKey
2447 __init__(ParticleIndexesKey self, unsigned int i) -> ParticleIndexesKey
2449 _IMP_kernel.ParticleIndexesKey_swiginit(self, _IMP_kernel.new_ParticleIndexesKey(*args))
2453 r"""add_key(std::string sc) -> unsigned int"""
2454 return _IMP_kernel.ParticleIndexesKey_add_key(sc)
2457 def get_key_exists(sc):
2458 r"""get_key_exists(std::string sc) -> bool"""
2459 return _IMP_kernel.ParticleIndexesKey_get_key_exists(sc)
2461 def get_string(self):
2462 r"""get_string(ParticleIndexesKey self) -> std::string const"""
2463 return _IMP_kernel.ParticleIndexesKey_get_string(self)
2465 def __cmp__(self, o):
2466 r"""__cmp__(ParticleIndexesKey self, ParticleIndexesKey o) -> int"""
2467 return _IMP_kernel.ParticleIndexesKey___cmp__(self, o)
2469 def __eq__(self, o):
2470 r"""__eq__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
2471 return _IMP_kernel.ParticleIndexesKey___eq__(self, o)
2473 def __ne__(self, o):
2474 r"""__ne__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
2475 return _IMP_kernel.ParticleIndexesKey___ne__(self, o)
2477 def __lt__(self, o):
2478 r"""__lt__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
2479 return _IMP_kernel.ParticleIndexesKey___lt__(self, o)
2481 def __gt__(self, o):
2482 r"""__gt__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
2483 return _IMP_kernel.ParticleIndexesKey___gt__(self, o)
2485 def __ge__(self, o):
2486 r"""__ge__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
2487 return _IMP_kernel.ParticleIndexesKey___ge__(self, o)
2489 def __le__(self, o):
2490 r"""__le__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
2491 return _IMP_kernel.ParticleIndexesKey___le__(self, o)
2494 r"""__hash__(ParticleIndexesKey self) -> std::size_t"""
2495 return _IMP_kernel.ParticleIndexesKey___hash__(self)
2497 def show(self, *args):
2498 r"""show(ParticleIndexesKey self, _ostream out=std::cout)"""
2499 return _IMP_kernel.ParticleIndexesKey_show(self, *args)
2502 def add_alias(old_key, new_name):
2503 r"""add_alias(ParticleIndexesKey old_key, std::string new_name) -> ParticleIndexesKey"""
2504 return _IMP_kernel.ParticleIndexesKey_add_alias(old_key, new_name)
2507 def get_number_of_keys():
2508 r"""get_number_of_keys() -> unsigned int"""
2509 return _IMP_kernel.ParticleIndexesKey_get_number_of_keys()
2512 r"""get_index(ParticleIndexesKey self) -> unsigned int"""
2513 return _IMP_kernel.ParticleIndexesKey_get_index(self)
2517 r"""show_all(_ostream out)"""
2518 return _IMP_kernel.ParticleIndexesKey_show_all(out)
2521 def get_all_strings():
2522 r"""get_all_strings() -> IMP::Vector< std::string >"""
2523 return _IMP_kernel.ParticleIndexesKey_get_all_strings()
2526 def get_number_unique():
2527 r"""get_number_unique() -> unsigned int"""
2528 return _IMP_kernel.ParticleIndexesKey_get_number_unique()
2531 r"""__str__(ParticleIndexesKey self) -> std::string"""
2532 return _IMP_kernel.ParticleIndexesKey___str__(self)
2535 r"""__repr__(ParticleIndexesKey self) -> std::string"""
2536 return _IMP_kernel.ParticleIndexesKey___repr__(self)
2537 __swig_destroy__ = _IMP_kernel.delete_ParticleIndexesKey
2540 _IMP_kernel.ParticleIndexesKey_swigregister(ParticleIndexesKey)
2542 r"""Proxy of C++ IMP::Key< 8 > class."""
2544 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2546 def __init__(self, *args):
2548 __init__(ModelKey self) -> ModelKey
2549 __init__(ModelKey self, std::string const & c, bool is_implicit_add_permitted=True) -> ModelKey
2550 __init__(ModelKey self, unsigned int i) -> ModelKey
2552 _IMP_kernel.ModelKey_swiginit(self, _IMP_kernel.new_ModelKey(*args))
2556 r"""add_key(std::string sc) -> unsigned int"""
2557 return _IMP_kernel.ModelKey_add_key(sc)
2560 def get_key_exists(sc):
2561 r"""get_key_exists(std::string sc) -> bool"""
2562 return _IMP_kernel.ModelKey_get_key_exists(sc)
2564 def get_string(self):
2565 r"""get_string(ModelKey self) -> std::string const"""
2566 return _IMP_kernel.ModelKey_get_string(self)
2568 def __cmp__(self, o):
2569 r"""__cmp__(ModelKey self, ModelKey o) -> int"""
2570 return _IMP_kernel.ModelKey___cmp__(self, o)
2572 def __eq__(self, o):
2573 r"""__eq__(ModelKey self, ModelKey o) -> bool"""
2574 return _IMP_kernel.ModelKey___eq__(self, o)
2576 def __ne__(self, o):
2577 r"""__ne__(ModelKey self, ModelKey o) -> bool"""
2578 return _IMP_kernel.ModelKey___ne__(self, o)
2580 def __lt__(self, o):
2581 r"""__lt__(ModelKey self, ModelKey o) -> bool"""
2582 return _IMP_kernel.ModelKey___lt__(self, o)
2584 def __gt__(self, o):
2585 r"""__gt__(ModelKey self, ModelKey o) -> bool"""
2586 return _IMP_kernel.ModelKey___gt__(self, o)
2588 def __ge__(self, o):
2589 r"""__ge__(ModelKey self, ModelKey o) -> bool"""
2590 return _IMP_kernel.ModelKey___ge__(self, o)
2592 def __le__(self, o):
2593 r"""__le__(ModelKey self, ModelKey o) -> bool"""
2594 return _IMP_kernel.ModelKey___le__(self, o)
2597 r"""__hash__(ModelKey self) -> std::size_t"""
2598 return _IMP_kernel.ModelKey___hash__(self)
2600 def show(self, *args):
2601 r"""show(ModelKey self, _ostream out=std::cout)"""
2602 return _IMP_kernel.ModelKey_show(self, *args)
2605 def add_alias(old_key, new_name):
2606 r"""add_alias(ModelKey old_key, std::string new_name) -> ModelKey"""
2607 return _IMP_kernel.ModelKey_add_alias(old_key, new_name)
2610 def get_number_of_keys():
2611 r"""get_number_of_keys() -> unsigned int"""
2612 return _IMP_kernel.ModelKey_get_number_of_keys()
2615 r"""get_index(ModelKey self) -> unsigned int"""
2616 return _IMP_kernel.ModelKey_get_index(self)
2620 r"""show_all(_ostream out)"""
2621 return _IMP_kernel.ModelKey_show_all(out)
2624 def get_all_strings():
2625 r"""get_all_strings() -> IMP::Vector< std::string >"""
2626 return _IMP_kernel.ModelKey_get_all_strings()
2629 def get_number_unique():
2630 r"""get_number_unique() -> unsigned int"""
2631 return _IMP_kernel.ModelKey_get_number_unique()
2634 r"""__str__(ModelKey self) -> std::string"""
2635 return _IMP_kernel.ModelKey___str__(self)
2638 r"""__repr__(ModelKey self) -> std::string"""
2639 return _IMP_kernel.ModelKey___repr__(self)
2640 __swig_destroy__ = _IMP_kernel.delete_ModelKey
2643 _IMP_kernel.ModelKey_swigregister(ModelKey)
2645 r"""Proxy of C++ IMP::Key< 11 > class."""
2647 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2649 def __init__(self, *args):
2651 __init__(TriggerKey self) -> TriggerKey
2652 __init__(TriggerKey self, std::string const & c, bool is_implicit_add_permitted=True) -> TriggerKey
2653 __init__(TriggerKey self, unsigned int i) -> TriggerKey
2655 _IMP_kernel.TriggerKey_swiginit(self, _IMP_kernel.new_TriggerKey(*args))
2659 r"""add_key(std::string sc) -> unsigned int"""
2660 return _IMP_kernel.TriggerKey_add_key(sc)
2663 def get_key_exists(sc):
2664 r"""get_key_exists(std::string sc) -> bool"""
2665 return _IMP_kernel.TriggerKey_get_key_exists(sc)
2667 def get_string(self):
2668 r"""get_string(TriggerKey self) -> std::string const"""
2669 return _IMP_kernel.TriggerKey_get_string(self)
2671 def __cmp__(self, o):
2672 r"""__cmp__(TriggerKey self, TriggerKey o) -> int"""
2673 return _IMP_kernel.TriggerKey___cmp__(self, o)
2675 def __eq__(self, o):
2676 r"""__eq__(TriggerKey self, TriggerKey o) -> bool"""
2677 return _IMP_kernel.TriggerKey___eq__(self, o)
2679 def __ne__(self, o):
2680 r"""__ne__(TriggerKey self, TriggerKey o) -> bool"""
2681 return _IMP_kernel.TriggerKey___ne__(self, o)
2683 def __lt__(self, o):
2684 r"""__lt__(TriggerKey self, TriggerKey o) -> bool"""
2685 return _IMP_kernel.TriggerKey___lt__(self, o)
2687 def __gt__(self, o):
2688 r"""__gt__(TriggerKey self, TriggerKey o) -> bool"""
2689 return _IMP_kernel.TriggerKey___gt__(self, o)
2691 def __ge__(self, o):
2692 r"""__ge__(TriggerKey self, TriggerKey o) -> bool"""
2693 return _IMP_kernel.TriggerKey___ge__(self, o)
2695 def __le__(self, o):
2696 r"""__le__(TriggerKey self, TriggerKey o) -> bool"""
2697 return _IMP_kernel.TriggerKey___le__(self, o)
2700 r"""__hash__(TriggerKey self) -> std::size_t"""
2701 return _IMP_kernel.TriggerKey___hash__(self)
2703 def show(self, *args):
2704 r"""show(TriggerKey self, _ostream out=std::cout)"""
2705 return _IMP_kernel.TriggerKey_show(self, *args)
2708 def add_alias(old_key, new_name):
2709 r"""add_alias(TriggerKey old_key, std::string new_name) -> TriggerKey"""
2710 return _IMP_kernel.TriggerKey_add_alias(old_key, new_name)
2713 def get_number_of_keys():
2714 r"""get_number_of_keys() -> unsigned int"""
2715 return _IMP_kernel.TriggerKey_get_number_of_keys()
2718 r"""get_index(TriggerKey self) -> unsigned int"""
2719 return _IMP_kernel.TriggerKey_get_index(self)
2723 r"""show_all(_ostream out)"""
2724 return _IMP_kernel.TriggerKey_show_all(out)
2727 def get_all_strings():
2728 r"""get_all_strings() -> IMP::Vector< std::string >"""
2729 return _IMP_kernel.TriggerKey_get_all_strings()
2732 def get_number_unique():
2733 r"""get_number_unique() -> unsigned int"""
2734 return _IMP_kernel.TriggerKey_get_number_unique()
2737 r"""__str__(TriggerKey self) -> std::string"""
2738 return _IMP_kernel.TriggerKey___str__(self)
2741 r"""__repr__(TriggerKey self) -> std::string"""
2742 return _IMP_kernel.TriggerKey___repr__(self)
2743 __swig_destroy__ = _IMP_kernel.delete_TriggerKey
2746 _IMP_kernel.TriggerKey_swigregister(TriggerKey)
2748 r"""Proxy of C++ IMP::Index< IMP::ParticleIndexTag > class."""
2750 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2752 def __init__(self, *args):
2754 __init__(ParticleIndex self, int i) -> ParticleIndex
2755 __init__(ParticleIndex self) -> ParticleIndex
2757 _IMP_kernel.ParticleIndex_swiginit(self, _IMP_kernel.new_ParticleIndex(*args))
2760 r"""get_index(ParticleIndex self) -> int"""
2761 return _IMP_kernel.ParticleIndex_get_index(self)
2763 def __cmp__(self, o):
2764 r"""__cmp__(ParticleIndex self, ParticleIndex o) -> int"""
2765 return _IMP_kernel.ParticleIndex___cmp__(self, o)
2767 def __eq__(self, o):
2768 r"""__eq__(ParticleIndex self, ParticleIndex o) -> bool"""
2769 return _IMP_kernel.ParticleIndex___eq__(self, o)
2771 def __ne__(self, o):
2772 r"""__ne__(ParticleIndex self, ParticleIndex o) -> bool"""
2773 return _IMP_kernel.ParticleIndex___ne__(self, o)
2775 def __lt__(self, o):
2776 r"""__lt__(ParticleIndex self, ParticleIndex o) -> bool"""
2777 return _IMP_kernel.ParticleIndex___lt__(self, o)
2779 def __gt__(self, o):
2780 r"""__gt__(ParticleIndex self, ParticleIndex o) -> bool"""
2781 return _IMP_kernel.ParticleIndex___gt__(self, o)
2783 def __ge__(self, o):
2784 r"""__ge__(ParticleIndex self, ParticleIndex o) -> bool"""
2785 return _IMP_kernel.ParticleIndex___ge__(self, o)
2787 def __le__(self, o):
2788 r"""__le__(ParticleIndex self, ParticleIndex o) -> bool"""
2789 return _IMP_kernel.ParticleIndex___le__(self, o)
2791 def show(self, *args):
2792 r"""show(ParticleIndex self, _ostream out=std::cout)"""
2793 return _IMP_kernel.ParticleIndex_show(self, *args)
2796 r"""__hash__(ParticleIndex self) -> std::size_t"""
2797 return _IMP_kernel.ParticleIndex___hash__(self)
2800 r"""__str__(ParticleIndex self) -> std::string"""
2801 return _IMP_kernel.ParticleIndex___str__(self)
2804 r"""__repr__(ParticleIndex self) -> std::string"""
2805 return _IMP_kernel.ParticleIndex___repr__(self)
2806 __swig_destroy__ = _IMP_kernel.delete_ParticleIndex
2809 _IMP_kernel.ParticleIndex_swigregister(ParticleIndex)
2811 r"""Proxy of C++ IMP::Key< 10 > class."""
2813 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2815 def __init__(self, *args):
2817 __init__(FloatsKey self) -> FloatsKey
2818 __init__(FloatsKey self, std::string const & c, bool is_implicit_add_permitted=True) -> FloatsKey
2819 __init__(FloatsKey self, unsigned int i) -> FloatsKey
2821 _IMP_kernel.FloatsKey_swiginit(self, _IMP_kernel.new_FloatsKey(*args))
2825 r"""add_key(std::string sc) -> unsigned int"""
2826 return _IMP_kernel.FloatsKey_add_key(sc)
2829 def get_key_exists(sc):
2830 r"""get_key_exists(std::string sc) -> bool"""
2831 return _IMP_kernel.FloatsKey_get_key_exists(sc)
2833 def get_string(self):
2834 r"""get_string(FloatsKey self) -> std::string const"""
2835 return _IMP_kernel.FloatsKey_get_string(self)
2837 def __cmp__(self, o):
2838 r"""__cmp__(FloatsKey self, FloatsKey o) -> int"""
2839 return _IMP_kernel.FloatsKey___cmp__(self, o)
2841 def __eq__(self, o):
2842 r"""__eq__(FloatsKey self, FloatsKey o) -> bool"""
2843 return _IMP_kernel.FloatsKey___eq__(self, o)
2845 def __ne__(self, o):
2846 r"""__ne__(FloatsKey self, FloatsKey o) -> bool"""
2847 return _IMP_kernel.FloatsKey___ne__(self, o)
2849 def __lt__(self, o):
2850 r"""__lt__(FloatsKey self, FloatsKey o) -> bool"""
2851 return _IMP_kernel.FloatsKey___lt__(self, o)
2853 def __gt__(self, o):
2854 r"""__gt__(FloatsKey self, FloatsKey o) -> bool"""
2855 return _IMP_kernel.FloatsKey___gt__(self, o)
2857 def __ge__(self, o):
2858 r"""__ge__(FloatsKey self, FloatsKey o) -> bool"""
2859 return _IMP_kernel.FloatsKey___ge__(self, o)
2861 def __le__(self, o):
2862 r"""__le__(FloatsKey self, FloatsKey o) -> bool"""
2863 return _IMP_kernel.FloatsKey___le__(self, o)
2866 r"""__hash__(FloatsKey self) -> std::size_t"""
2867 return _IMP_kernel.FloatsKey___hash__(self)
2869 def show(self, *args):
2870 r"""show(FloatsKey self, _ostream out=std::cout)"""
2871 return _IMP_kernel.FloatsKey_show(self, *args)
2874 def add_alias(old_key, new_name):
2875 r"""add_alias(FloatsKey old_key, std::string new_name) -> FloatsKey"""
2876 return _IMP_kernel.FloatsKey_add_alias(old_key, new_name)
2879 def get_number_of_keys():
2880 r"""get_number_of_keys() -> unsigned int"""
2881 return _IMP_kernel.FloatsKey_get_number_of_keys()
2884 r"""get_index(FloatsKey self) -> unsigned int"""
2885 return _IMP_kernel.FloatsKey_get_index(self)
2889 r"""show_all(_ostream out)"""
2890 return _IMP_kernel.FloatsKey_show_all(out)
2893 def get_all_strings():
2894 r"""get_all_strings() -> IMP::Vector< std::string >"""
2895 return _IMP_kernel.FloatsKey_get_all_strings()
2898 def get_number_unique():
2899 r"""get_number_unique() -> unsigned int"""
2900 return _IMP_kernel.FloatsKey_get_number_unique()
2903 r"""__str__(FloatsKey self) -> std::string"""
2904 return _IMP_kernel.FloatsKey___str__(self)
2907 r"""__repr__(FloatsKey self) -> std::string"""
2908 return _IMP_kernel.FloatsKey___repr__(self)
2909 __swig_destroy__ = _IMP_kernel.delete_FloatsKey
2912 _IMP_kernel.FloatsKey_swigregister(FloatsKey)
2914 r"""Proxy of C++ IMP::Key< 12 > class."""
2916 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2918 def __init__(self, *args):
2920 __init__(SparseStringKey self) -> SparseStringKey
2921 __init__(SparseStringKey self, std::string const & c, bool is_implicit_add_permitted=True) -> SparseStringKey
2922 __init__(SparseStringKey self, unsigned int i) -> SparseStringKey
2924 _IMP_kernel.SparseStringKey_swiginit(self, _IMP_kernel.new_SparseStringKey(*args))
2928 r"""add_key(std::string sc) -> unsigned int"""
2929 return _IMP_kernel.SparseStringKey_add_key(sc)
2932 def get_key_exists(sc):
2933 r"""get_key_exists(std::string sc) -> bool"""
2934 return _IMP_kernel.SparseStringKey_get_key_exists(sc)
2936 def get_string(self):
2937 r"""get_string(SparseStringKey self) -> std::string const"""
2938 return _IMP_kernel.SparseStringKey_get_string(self)
2940 def __cmp__(self, o):
2941 r"""__cmp__(SparseStringKey self, SparseStringKey o) -> int"""
2942 return _IMP_kernel.SparseStringKey___cmp__(self, o)
2944 def __eq__(self, o):
2945 r"""__eq__(SparseStringKey self, SparseStringKey o) -> bool"""
2946 return _IMP_kernel.SparseStringKey___eq__(self, o)
2948 def __ne__(self, o):
2949 r"""__ne__(SparseStringKey self, SparseStringKey o) -> bool"""
2950 return _IMP_kernel.SparseStringKey___ne__(self, o)
2952 def __lt__(self, o):
2953 r"""__lt__(SparseStringKey self, SparseStringKey o) -> bool"""
2954 return _IMP_kernel.SparseStringKey___lt__(self, o)
2956 def __gt__(self, o):
2957 r"""__gt__(SparseStringKey self, SparseStringKey o) -> bool"""
2958 return _IMP_kernel.SparseStringKey___gt__(self, o)
2960 def __ge__(self, o):
2961 r"""__ge__(SparseStringKey self, SparseStringKey o) -> bool"""
2962 return _IMP_kernel.SparseStringKey___ge__(self, o)
2964 def __le__(self, o):
2965 r"""__le__(SparseStringKey self, SparseStringKey o) -> bool"""
2966 return _IMP_kernel.SparseStringKey___le__(self, o)
2969 r"""__hash__(SparseStringKey self) -> std::size_t"""
2970 return _IMP_kernel.SparseStringKey___hash__(self)
2972 def show(self, *args):
2973 r"""show(SparseStringKey self, _ostream out=std::cout)"""
2974 return _IMP_kernel.SparseStringKey_show(self, *args)
2977 def add_alias(old_key, new_name):
2978 r"""add_alias(SparseStringKey old_key, std::string new_name) -> SparseStringKey"""
2979 return _IMP_kernel.SparseStringKey_add_alias(old_key, new_name)
2982 def get_number_of_keys():
2983 r"""get_number_of_keys() -> unsigned int"""
2984 return _IMP_kernel.SparseStringKey_get_number_of_keys()
2987 r"""get_index(SparseStringKey self) -> unsigned int"""
2988 return _IMP_kernel.SparseStringKey_get_index(self)
2992 r"""show_all(_ostream out)"""
2993 return _IMP_kernel.SparseStringKey_show_all(out)
2996 def get_all_strings():
2997 r"""get_all_strings() -> IMP::Vector< std::string >"""
2998 return _IMP_kernel.SparseStringKey_get_all_strings()
3001 def get_number_unique():
3002 r"""get_number_unique() -> unsigned int"""
3003 return _IMP_kernel.SparseStringKey_get_number_unique()
3006 r"""__str__(SparseStringKey self) -> std::string"""
3007 return _IMP_kernel.SparseStringKey___str__(self)
3010 r"""__repr__(SparseStringKey self) -> std::string"""
3011 return _IMP_kernel.SparseStringKey___repr__(self)
3012 __swig_destroy__ = _IMP_kernel.delete_SparseStringKey
3015 _IMP_kernel.SparseStringKey_swigregister(SparseStringKey)
3017 r"""Proxy of C++ IMP::Key< 13 > class."""
3019 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3021 def __init__(self, *args):
3023 __init__(SparseIntKey self) -> SparseIntKey
3024 __init__(SparseIntKey self, std::string const & c, bool is_implicit_add_permitted=True) -> SparseIntKey
3025 __init__(SparseIntKey self, unsigned int i) -> SparseIntKey
3027 _IMP_kernel.SparseIntKey_swiginit(self, _IMP_kernel.new_SparseIntKey(*args))
3031 r"""add_key(std::string sc) -> unsigned int"""
3032 return _IMP_kernel.SparseIntKey_add_key(sc)
3035 def get_key_exists(sc):
3036 r"""get_key_exists(std::string sc) -> bool"""
3037 return _IMP_kernel.SparseIntKey_get_key_exists(sc)
3039 def get_string(self):
3040 r"""get_string(SparseIntKey self) -> std::string const"""
3041 return _IMP_kernel.SparseIntKey_get_string(self)
3043 def __cmp__(self, o):
3044 r"""__cmp__(SparseIntKey self, SparseIntKey o) -> int"""
3045 return _IMP_kernel.SparseIntKey___cmp__(self, o)
3047 def __eq__(self, o):
3048 r"""__eq__(SparseIntKey self, SparseIntKey o) -> bool"""
3049 return _IMP_kernel.SparseIntKey___eq__(self, o)
3051 def __ne__(self, o):
3052 r"""__ne__(SparseIntKey self, SparseIntKey o) -> bool"""
3053 return _IMP_kernel.SparseIntKey___ne__(self, o)
3055 def __lt__(self, o):
3056 r"""__lt__(SparseIntKey self, SparseIntKey o) -> bool"""
3057 return _IMP_kernel.SparseIntKey___lt__(self, o)
3059 def __gt__(self, o):
3060 r"""__gt__(SparseIntKey self, SparseIntKey o) -> bool"""
3061 return _IMP_kernel.SparseIntKey___gt__(self, o)
3063 def __ge__(self, o):
3064 r"""__ge__(SparseIntKey self, SparseIntKey o) -> bool"""
3065 return _IMP_kernel.SparseIntKey___ge__(self, o)
3067 def __le__(self, o):
3068 r"""__le__(SparseIntKey self, SparseIntKey o) -> bool"""
3069 return _IMP_kernel.SparseIntKey___le__(self, o)
3072 r"""__hash__(SparseIntKey self) -> std::size_t"""
3073 return _IMP_kernel.SparseIntKey___hash__(self)
3075 def show(self, *args):
3076 r"""show(SparseIntKey self, _ostream out=std::cout)"""
3077 return _IMP_kernel.SparseIntKey_show(self, *args)
3080 def add_alias(old_key, new_name):
3081 r"""add_alias(SparseIntKey old_key, std::string new_name) -> SparseIntKey"""
3082 return _IMP_kernel.SparseIntKey_add_alias(old_key, new_name)
3085 def get_number_of_keys():
3086 r"""get_number_of_keys() -> unsigned int"""
3087 return _IMP_kernel.SparseIntKey_get_number_of_keys()
3090 r"""get_index(SparseIntKey self) -> unsigned int"""
3091 return _IMP_kernel.SparseIntKey_get_index(self)
3095 r"""show_all(_ostream out)"""
3096 return _IMP_kernel.SparseIntKey_show_all(out)
3099 def get_all_strings():
3100 r"""get_all_strings() -> IMP::Vector< std::string >"""
3101 return _IMP_kernel.SparseIntKey_get_all_strings()
3104 def get_number_unique():
3105 r"""get_number_unique() -> unsigned int"""
3106 return _IMP_kernel.SparseIntKey_get_number_unique()
3109 r"""__str__(SparseIntKey self) -> std::string"""
3110 return _IMP_kernel.SparseIntKey___str__(self)
3113 r"""__repr__(SparseIntKey self) -> std::string"""
3114 return _IMP_kernel.SparseIntKey___repr__(self)
3115 __swig_destroy__ = _IMP_kernel.delete_SparseIntKey
3118 _IMP_kernel.SparseIntKey_swigregister(SparseIntKey)
3120 r"""Proxy of C++ IMP::Key< 14 > class."""
3122 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3124 def __init__(self, *args):
3126 __init__(SparseFloatKey self) -> SparseFloatKey
3127 __init__(SparseFloatKey self, std::string const & c, bool is_implicit_add_permitted=True) -> SparseFloatKey
3128 __init__(SparseFloatKey self, unsigned int i) -> SparseFloatKey
3130 _IMP_kernel.SparseFloatKey_swiginit(self, _IMP_kernel.new_SparseFloatKey(*args))
3134 r"""add_key(std::string sc) -> unsigned int"""
3135 return _IMP_kernel.SparseFloatKey_add_key(sc)
3138 def get_key_exists(sc):
3139 r"""get_key_exists(std::string sc) -> bool"""
3140 return _IMP_kernel.SparseFloatKey_get_key_exists(sc)
3142 def get_string(self):
3143 r"""get_string(SparseFloatKey self) -> std::string const"""
3144 return _IMP_kernel.SparseFloatKey_get_string(self)
3146 def __cmp__(self, o):
3147 r"""__cmp__(SparseFloatKey self, SparseFloatKey o) -> int"""
3148 return _IMP_kernel.SparseFloatKey___cmp__(self, o)
3150 def __eq__(self, o):
3151 r"""__eq__(SparseFloatKey self, SparseFloatKey o) -> bool"""
3152 return _IMP_kernel.SparseFloatKey___eq__(self, o)
3154 def __ne__(self, o):
3155 r"""__ne__(SparseFloatKey self, SparseFloatKey o) -> bool"""
3156 return _IMP_kernel.SparseFloatKey___ne__(self, o)
3158 def __lt__(self, o):
3159 r"""__lt__(SparseFloatKey self, SparseFloatKey o) -> bool"""
3160 return _IMP_kernel.SparseFloatKey___lt__(self, o)
3162 def __gt__(self, o):
3163 r"""__gt__(SparseFloatKey self, SparseFloatKey o) -> bool"""
3164 return _IMP_kernel.SparseFloatKey___gt__(self, o)
3166 def __ge__(self, o):
3167 r"""__ge__(SparseFloatKey self, SparseFloatKey o) -> bool"""
3168 return _IMP_kernel.SparseFloatKey___ge__(self, o)
3170 def __le__(self, o):
3171 r"""__le__(SparseFloatKey self, SparseFloatKey o) -> bool"""
3172 return _IMP_kernel.SparseFloatKey___le__(self, o)
3175 r"""__hash__(SparseFloatKey self) -> std::size_t"""
3176 return _IMP_kernel.SparseFloatKey___hash__(self)
3178 def show(self, *args):
3179 r"""show(SparseFloatKey self, _ostream out=std::cout)"""
3180 return _IMP_kernel.SparseFloatKey_show(self, *args)
3183 def add_alias(old_key, new_name):
3184 r"""add_alias(SparseFloatKey old_key, std::string new_name) -> SparseFloatKey"""
3185 return _IMP_kernel.SparseFloatKey_add_alias(old_key, new_name)
3188 def get_number_of_keys():
3189 r"""get_number_of_keys() -> unsigned int"""
3190 return _IMP_kernel.SparseFloatKey_get_number_of_keys()
3193 r"""get_index(SparseFloatKey self) -> unsigned int"""
3194 return _IMP_kernel.SparseFloatKey_get_index(self)
3198 r"""show_all(_ostream out)"""
3199 return _IMP_kernel.SparseFloatKey_show_all(out)
3202 def get_all_strings():
3203 r"""get_all_strings() -> IMP::Vector< std::string >"""
3204 return _IMP_kernel.SparseFloatKey_get_all_strings()
3207 def get_number_unique():
3208 r"""get_number_unique() -> unsigned int"""
3209 return _IMP_kernel.SparseFloatKey_get_number_unique()
3212 r"""__str__(SparseFloatKey self) -> std::string"""
3213 return _IMP_kernel.SparseFloatKey___str__(self)
3216 r"""__repr__(SparseFloatKey self) -> std::string"""
3217 return _IMP_kernel.SparseFloatKey___repr__(self)
3218 __swig_destroy__ = _IMP_kernel.delete_SparseFloatKey
3221 _IMP_kernel.SparseFloatKey_swigregister(SparseFloatKey)
3223 r"""Proxy of C++ IMP::Key< 15 > class."""
3225 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3227 def __init__(self, *args):
3229 __init__(SparseParticleIndexKey self) -> SparseParticleIndexKey
3230 __init__(SparseParticleIndexKey self, std::string const & c, bool is_implicit_add_permitted=True) -> SparseParticleIndexKey
3231 __init__(SparseParticleIndexKey self, unsigned int i) -> SparseParticleIndexKey
3233 _IMP_kernel.SparseParticleIndexKey_swiginit(self, _IMP_kernel.new_SparseParticleIndexKey(*args))
3237 r"""add_key(std::string sc) -> unsigned int"""
3238 return _IMP_kernel.SparseParticleIndexKey_add_key(sc)
3241 def get_key_exists(sc):
3242 r"""get_key_exists(std::string sc) -> bool"""
3243 return _IMP_kernel.SparseParticleIndexKey_get_key_exists(sc)
3245 def get_string(self):
3246 r"""get_string(SparseParticleIndexKey self) -> std::string const"""
3247 return _IMP_kernel.SparseParticleIndexKey_get_string(self)
3249 def __cmp__(self, o):
3250 r"""__cmp__(SparseParticleIndexKey self, SparseParticleIndexKey o) -> int"""
3251 return _IMP_kernel.SparseParticleIndexKey___cmp__(self, o)
3253 def __eq__(self, o):
3254 r"""__eq__(SparseParticleIndexKey self, SparseParticleIndexKey o) -> bool"""
3255 return _IMP_kernel.SparseParticleIndexKey___eq__(self, o)
3257 def __ne__(self, o):
3258 r"""__ne__(SparseParticleIndexKey self, SparseParticleIndexKey o) -> bool"""
3259 return _IMP_kernel.SparseParticleIndexKey___ne__(self, o)
3261 def __lt__(self, o):
3262 r"""__lt__(SparseParticleIndexKey self, SparseParticleIndexKey o) -> bool"""
3263 return _IMP_kernel.SparseParticleIndexKey___lt__(self, o)
3265 def __gt__(self, o):
3266 r"""__gt__(SparseParticleIndexKey self, SparseParticleIndexKey o) -> bool"""
3267 return _IMP_kernel.SparseParticleIndexKey___gt__(self, o)
3269 def __ge__(self, o):
3270 r"""__ge__(SparseParticleIndexKey self, SparseParticleIndexKey o) -> bool"""
3271 return _IMP_kernel.SparseParticleIndexKey___ge__(self, o)
3273 def __le__(self, o):
3274 r"""__le__(SparseParticleIndexKey self, SparseParticleIndexKey o) -> bool"""
3275 return _IMP_kernel.SparseParticleIndexKey___le__(self, o)
3278 r"""__hash__(SparseParticleIndexKey self) -> std::size_t"""
3279 return _IMP_kernel.SparseParticleIndexKey___hash__(self)
3281 def show(self, *args):
3282 r"""show(SparseParticleIndexKey self, _ostream out=std::cout)"""
3283 return _IMP_kernel.SparseParticleIndexKey_show(self, *args)
3286 def add_alias(old_key, new_name):
3287 r"""add_alias(SparseParticleIndexKey old_key, std::string new_name) -> SparseParticleIndexKey"""
3288 return _IMP_kernel.SparseParticleIndexKey_add_alias(old_key, new_name)
3291 def get_number_of_keys():
3292 r"""get_number_of_keys() -> unsigned int"""
3293 return _IMP_kernel.SparseParticleIndexKey_get_number_of_keys()
3296 r"""get_index(SparseParticleIndexKey self) -> unsigned int"""
3297 return _IMP_kernel.SparseParticleIndexKey_get_index(self)
3301 r"""show_all(_ostream out)"""
3302 return _IMP_kernel.SparseParticleIndexKey_show_all(out)
3305 def get_all_strings():
3306 r"""get_all_strings() -> IMP::Vector< std::string >"""
3307 return _IMP_kernel.SparseParticleIndexKey_get_all_strings()
3310 def get_number_unique():
3311 r"""get_number_unique() -> unsigned int"""
3312 return _IMP_kernel.SparseParticleIndexKey_get_number_unique()
3315 r"""__str__(SparseParticleIndexKey self) -> std::string"""
3316 return _IMP_kernel.SparseParticleIndexKey___str__(self)
3319 r"""__repr__(SparseParticleIndexKey self) -> std::string"""
3320 return _IMP_kernel.SparseParticleIndexKey___repr__(self)
3321 __swig_destroy__ = _IMP_kernel.delete_SparseParticleIndexKey
3324 _IMP_kernel.SparseParticleIndexKey_swigregister(SparseParticleIndexKey)
3333 class FloatIndex(_Value):
3334 r"""Proxy of C++ IMP::FloatIndex class."""
3336 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3338 def __init__(self, *args):
3339 r"""__init__(FloatIndex self, ParticleIndex i0=ParticleIndex(), FloatKey i1=FloatKey()) -> FloatIndex"""
3340 _IMP_kernel.FloatIndex_swiginit(self, _IMP_kernel.new_FloatIndex(*args))
3343 r"""__hash__(FloatIndex self) -> std::size_t"""
3344 return _IMP_kernel.FloatIndex___hash__(self)
3346 def show(self, *args):
3347 r"""show(FloatIndex self, _ostream out=std::cout)"""
3348 return _IMP_kernel.FloatIndex_show(self, *args)
3350 def __cmp__(self, o):
3351 r"""__cmp__(FloatIndex self, FloatIndex o) -> int"""
3352 return _IMP_kernel.FloatIndex___cmp__(self, o)
3354 def __eq__(self, o):
3355 r"""__eq__(FloatIndex self, FloatIndex o) -> bool"""
3356 return _IMP_kernel.FloatIndex___eq__(self, o)
3358 def __ne__(self, o):
3359 r"""__ne__(FloatIndex self, FloatIndex o) -> bool"""
3360 return _IMP_kernel.FloatIndex___ne__(self, o)
3362 def __lt__(self, o):
3363 r"""__lt__(FloatIndex self, FloatIndex o) -> bool"""
3364 return _IMP_kernel.FloatIndex___lt__(self, o)
3366 def __gt__(self, o):
3367 r"""__gt__(FloatIndex self, FloatIndex o) -> bool"""
3368 return _IMP_kernel.FloatIndex___gt__(self, o)
3370 def __ge__(self, o):
3371 r"""__ge__(FloatIndex self, FloatIndex o) -> bool"""
3372 return _IMP_kernel.FloatIndex___ge__(self, o)
3374 def __le__(self, o):
3375 r"""__le__(FloatIndex self, FloatIndex o) -> bool"""
3376 return _IMP_kernel.FloatIndex___le__(self, o)
3378 def get_particle(self):
3379 r"""get_particle(FloatIndex self) -> ParticleIndex const &"""
3380 return _IMP_kernel.FloatIndex_get_particle(self)
3382 def set_particle(self, v):
3383 r"""set_particle(FloatIndex self, ParticleIndex const & v)"""
3384 return _IMP_kernel.FloatIndex_set_particle(self, v)
3387 r"""get_key(FloatIndex self) -> FloatKey const &"""
3388 return _IMP_kernel.FloatIndex_get_key(self)
3390 def set_key(self, v):
3391 r"""set_key(FloatIndex self, FloatKey const & v)"""
3392 return _IMP_kernel.FloatIndex_set_key(self, v)
3395 r"""__str__(FloatIndex self) -> std::string"""
3396 return _IMP_kernel.FloatIndex___str__(self)
3399 r"""__repr__(FloatIndex self) -> std::string"""
3400 return _IMP_kernel.FloatIndex___repr__(self)
3401 __swig_destroy__ = _IMP_kernel.delete_FloatIndex
3404 _IMP_kernel.FloatIndex_swigregister(FloatIndex)
3405 class _ParticleIndexTag(object):
3406 r"""Proxy of C++ IMP::ParticleIndexTag class."""
3408 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3409 __repr__ = _swig_repr
3412 r"""__init__(_ParticleIndexTag self) -> _ParticleIndexTag"""
3413 _IMP_kernel._ParticleIndexTag_swiginit(self, _IMP_kernel.new__ParticleIndexTag())
3414 __swig_destroy__ = _IMP_kernel.delete__ParticleIndexTag
3417 _IMP_kernel._ParticleIndexTag_swigregister(_ParticleIndexTag)
3418 class ModelObject(Object):
3419 r"""Proxy of C++ IMP::ModelObject class."""
3421 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3423 def __init__(self, *args):
3425 __init__(ModelObject self, Model m, std::string name) -> ModelObject
3426 __init__(ModelObject self) -> ModelObject
3428 if self.__class__ == ModelObject:
3432 _IMP_kernel.ModelObject_swiginit(self, _IMP_kernel.new_ModelObject(_self, *args))
3434 if self.__class__ != ModelObject:
3435 _director_objects.register(self)
3439 __swig_destroy__ = _IMP_kernel.delete_ModelObject
3441 def get_model(self):
3442 m = _IMP_kernel.ModelObject_get_model(self)
3443 if m
in _models_set:
3444 m = _models_set_get(m)
3449 def get_inputs(self):
3450 r"""get_inputs(ModelObject self) -> IMP::ModelObjectsTemp"""
3451 return _IMP_kernel.ModelObject_get_inputs(self)
3453 def get_outputs(self):
3454 r"""get_outputs(ModelObject self) -> IMP::ModelObjectsTemp"""
3455 return _IMP_kernel.ModelObject_get_outputs(self)
3457 def get_interactions(self):
3458 r"""get_interactions(ModelObject self) -> IMP::ModelObjectsTemps"""
3459 return _IMP_kernel.ModelObject_get_interactions(self)
3461 def get_has_dependencies(self):
3462 r"""get_has_dependencies(ModelObject self) -> bool"""
3463 return _IMP_kernel.ModelObject_get_has_dependencies(self)
3465 def set_has_dependencies(self, tf):
3466 r"""set_has_dependencies(ModelObject self, bool tf)"""
3467 return _IMP_kernel.ModelObject_set_has_dependencies(self, tf)
3469 def set_has_required_score_states(self, tf):
3470 r"""set_has_required_score_states(ModelObject self, bool tf)"""
3471 return _IMP_kernel.ModelObject_set_has_required_score_states(self, tf)
3473 def get_has_required_score_states(self):
3474 r"""get_has_required_score_states(ModelObject self) -> bool"""
3475 return _IMP_kernel.ModelObject_get_has_required_score_states(self)
3477 def get_required_score_states(self):
3478 r"""get_required_score_states(ModelObject self) -> IMP::ScoreStatesTemp const &"""
3479 return _IMP_kernel.ModelObject_get_required_score_states(self)
3481 def handle_set_has_required_score_states(self, arg0):
3482 r"""handle_set_has_required_score_states(ModelObject self, bool arg0)"""
3483 return _IMP_kernel.ModelObject_handle_set_has_required_score_states(self, arg0)
3485 def do_get_inputs(self):
3486 r"""do_get_inputs(ModelObject self) -> IMP::ModelObjectsTemp"""
3487 return _IMP_kernel.ModelObject_do_get_inputs(self)
3489 def do_get_outputs(self):
3490 r"""do_get_outputs(ModelObject self) -> IMP::ModelObjectsTemp"""
3491 return _IMP_kernel.ModelObject_do_get_outputs(self)
3493 def do_get_interactions(self):
3494 r"""do_get_interactions(ModelObject self) -> IMP::ModelObjectsTemps"""
3495 return _IMP_kernel.ModelObject_do_get_interactions(self)
3498 r"""__str__(ModelObject self) -> std::string"""
3499 return _IMP_kernel.ModelObject___str__(self)
3502 r"""__repr__(ModelObject self) -> std::string"""
3503 return _IMP_kernel.ModelObject___repr__(self)
3507 return _object_cast_to_ModelObject(o)
3510 def get_type_name(self):
3511 return self.__class__.__name__
3512 def do_show(self, out):
3514 def get_version_info(self):
3516 return VersionInfo(self.__module__,
3523 return _object_cast_to_ModelObject(o)
3525 def __disown__(self):
3527 _IMP_kernel.disown_ModelObject(self)
3528 return weakref.proxy(self)
3530 def do_destroy(self):
3531 r"""do_destroy(ModelObject self)"""
3532 return _IMP_kernel.ModelObject_do_destroy(self)
3535 _IMP_kernel.ModelObject_swigregister(ModelObject)
3536 cvar = _IMP_kernel.cvar
3537 NO_MAX = cvar.NO_MAX
3538 BAD_SCORE = cvar.BAD_SCORE
3540 class _ParticleInputs(object):
3541 r"""Proxy of C++ IMP::ParticleInputs class."""
3543 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3545 def __init__(self, *args, **kwargs):
3546 raise AttributeError(
"No constructor defined - class is abstract")
3547 __repr__ = _swig_repr
3549 def get_inputs(self, m, pis):
3550 r"""get_inputs(_ParticleInputs self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
3551 return _IMP_kernel._ParticleInputs_get_inputs(self, m, pis)
3554 _IMP_kernel._ParticleInputs_swigregister(_ParticleInputs)
3555 class _ParticleOutputs(object):
3556 r"""Proxy of C++ IMP::ParticleOutputs class."""
3558 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3560 def __init__(self, *args, **kwargs):
3561 raise AttributeError(
"No constructor defined - class is abstract")
3562 __repr__ = _swig_repr
3564 def get_outputs(self, m, pis):
3565 r"""get_outputs(_ParticleOutputs self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
3566 return _IMP_kernel._ParticleOutputs_get_outputs(self, m, pis)
3569 _IMP_kernel._ParticleOutputs_swigregister(_ParticleOutputs)
3572 r"""get_input_particles(IMP::ModelObjectsTemp const & mos) -> IMP::ParticlesTemp"""
3573 return _IMP_kernel.get_input_particles(mos)
3576 r"""get_input_containers(IMP::ModelObjectsTemp const & mos) -> IMP::ContainersTemp"""
3577 return _IMP_kernel.get_input_containers(mos)
3580 r"""get_output_particles(IMP::ModelObjectsTemp const & mos) -> IMP::ParticlesTemp"""
3581 return _IMP_kernel.get_output_particles(mos)
3584 r"""get_output_containers(IMP::ModelObjectsTemp const & mos) -> IMP::ContainersTemp"""
3585 return _IMP_kernel.get_output_containers(mos)
3586 class DerivativeAccumulator(object):
3587 r"""Proxy of C++ IMP::DerivativeAccumulator class."""
3589 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3590 __repr__ = _swig_repr
3592 def __init__(self, *args):
3594 __init__(DerivativeAccumulator self, DerivativeAccumulator arg2) -> DerivativeAccumulator
3595 __init__(DerivativeAccumulator self, double weight=1.0) -> DerivativeAccumulator
3596 __init__(DerivativeAccumulator self, DerivativeAccumulator copy, double weight) -> DerivativeAccumulator
3598 _IMP_kernel.DerivativeAccumulator_swiginit(self, _IMP_kernel.new_DerivativeAccumulator(*args))
3600 def __call__(self, value):
3601 r"""__call__(DerivativeAccumulator self, double const value) -> double"""
3602 return _IMP_kernel.DerivativeAccumulator___call__(self, value)
3604 def get_weight(self):
3605 r"""get_weight(DerivativeAccumulator self) -> double"""
3606 return _IMP_kernel.DerivativeAccumulator_get_weight(self)
3608 def show(self, *args):
3609 r"""show(DerivativeAccumulator self, _ostream out=std::cout)"""
3610 return _IMP_kernel.DerivativeAccumulator_show(self, *args)
3611 __swig_destroy__ = _IMP_kernel.delete_DerivativeAccumulator
3614 _IMP_kernel.DerivativeAccumulator_swigregister(DerivativeAccumulator)
3615 class EvaluationState(object):
3616 r"""Proxy of C++ IMP::EvaluationState class."""
3618 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3619 score = property(_IMP_kernel.EvaluationState_score_get, _IMP_kernel.EvaluationState_score_set, doc=
r"""score : double""")
3620 good = property(_IMP_kernel.EvaluationState_good_get, _IMP_kernel.EvaluationState_good_set, doc=
r"""good : bool""")
3622 def __init__(self, *args):
3624 __init__(EvaluationState self, double oscore, bool ogood) -> EvaluationState
3625 __init__(EvaluationState self) -> EvaluationState
3627 _IMP_kernel.EvaluationState_swiginit(self, _IMP_kernel.new_EvaluationState(*args))
3629 def show(self, *args):
3630 r"""show(EvaluationState self, _ostream out=std::cout)"""
3631 return _IMP_kernel.EvaluationState_show(self, *args)
3634 r"""__str__(EvaluationState self) -> std::string"""
3635 return _IMP_kernel.EvaluationState___str__(self)
3638 r"""__repr__(EvaluationState self) -> std::string"""
3639 return _IMP_kernel.EvaluationState___repr__(self)
3640 __swig_destroy__ = _IMP_kernel.delete_EvaluationState
3643 _IMP_kernel.EvaluationState_swigregister(EvaluationState)
3644 class ScoreAccumulator(_Value):
3645 r"""Proxy of C++ IMP::ScoreAccumulator class."""
3647 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3649 def __init__(self, *args):
3651 __init__(ScoreAccumulator self, ScoreAccumulator arg2) -> ScoreAccumulator
3652 __init__(ScoreAccumulator self) -> ScoreAccumulator
3653 __init__(ScoreAccumulator self, ScoreAccumulator o, Restraint r) -> ScoreAccumulator
3654 __init__(ScoreAccumulator self, ScoreAccumulator o, double weight, double local_max) -> ScoreAccumulator
3656 _IMP_kernel.ScoreAccumulator_swiginit(self, _IMP_kernel.new_ScoreAccumulator(*args))
3658 def add_score(self, score):
3659 r"""add_score(ScoreAccumulator self, double score)"""
3660 return _IMP_kernel.ScoreAccumulator_add_score(self, score)
3662 def get_abort_evaluation(self):
3663 r"""get_abort_evaluation(ScoreAccumulator self) -> bool"""
3664 return _IMP_kernel.ScoreAccumulator_get_abort_evaluation(self)
3666 def get_is_evaluate_if_below(self):
3667 r"""get_is_evaluate_if_below(ScoreAccumulator self) -> bool"""
3668 return _IMP_kernel.ScoreAccumulator_get_is_evaluate_if_below(self)
3670 def get_is_evaluate_if_good(self):
3671 r"""get_is_evaluate_if_good(ScoreAccumulator self) -> bool"""
3672 return _IMP_kernel.ScoreAccumulator_get_is_evaluate_if_good(self)
3674 def get_maximum(self):
3675 r"""get_maximum(ScoreAccumulator self) -> double"""
3676 return _IMP_kernel.ScoreAccumulator_get_maximum(self)
3678 def get_derivative_accumulator(self):
3679 r"""get_derivative_accumulator(ScoreAccumulator self) -> DerivativeAccumulator"""
3680 return _IMP_kernel.ScoreAccumulator_get_derivative_accumulator(self)
3682 def show(self, *args):
3683 r"""show(ScoreAccumulator self, _ostream out=std::cout)"""
3684 return _IMP_kernel.ScoreAccumulator_show(self, *args)
3687 r"""__str__(ScoreAccumulator self) -> std::string"""
3688 return _IMP_kernel.ScoreAccumulator___str__(self)
3691 r"""__repr__(ScoreAccumulator self) -> std::string"""
3692 return _IMP_kernel.ScoreAccumulator___repr__(self)
3693 __swig_destroy__ = _IMP_kernel.delete_ScoreAccumulator
3696 _IMP_kernel.ScoreAccumulator_swigregister(ScoreAccumulator)
3697 class ScoreState(ModelObject):
3698 r"""Proxy of C++ IMP::ScoreState class."""
3700 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3702 def set_can_skip(self, can_skip):
3703 r"""set_can_skip(ScoreState self, bool can_skip)"""
3704 return _IMP_kernel.ScoreState_set_can_skip(self, can_skip)
3706 def __init__(self, *args):
3708 __init__(ScoreState self, Model m, std::string name) -> ScoreState
3709 __init__(ScoreState self) -> ScoreState
3711 if self.__class__ == ScoreState:
3715 _IMP_kernel.ScoreState_swiginit(self, _IMP_kernel.new_ScoreState(_self, *args))
3717 if self.__class__ != ScoreState:
3718 _director_objects.register(self)
3723 def before_evaluate(self):
3724 r"""before_evaluate(ScoreState self)"""
3725 return _IMP_kernel.ScoreState_before_evaluate(self)
3727 def after_evaluate(self, accpt):
3728 r"""after_evaluate(ScoreState self, DerivativeAccumulator accpt)"""
3729 return _IMP_kernel.ScoreState_after_evaluate(self, accpt)
3731 def get_can_skip(self):
3732 r"""get_can_skip(ScoreState self) -> bool"""
3733 return _IMP_kernel.ScoreState_get_can_skip(self)
3735 def get_has_update_order(self):
3736 r"""get_has_update_order(ScoreState self) -> bool"""
3737 return _IMP_kernel.ScoreState_get_has_update_order(self)
3740 r"""get_update_order(ScoreState self) -> unsigned int"""
3741 return _IMP_kernel.ScoreState_get_update_order(self)
3743 def handle_set_has_required_score_states(self, tf):
3744 r"""handle_set_has_required_score_states(ScoreState self, bool tf)"""
3745 return _IMP_kernel.ScoreState_handle_set_has_required_score_states(self, tf)
3747 def do_before_evaluate(self):
3748 r"""do_before_evaluate(ScoreState self)"""
3749 return _IMP_kernel.ScoreState_do_before_evaluate(self)
3751 def do_after_evaluate(self, accpt):
3752 r"""do_after_evaluate(ScoreState self, DerivativeAccumulator accpt)"""
3753 return _IMP_kernel.ScoreState_do_after_evaluate(self, accpt)
3754 __swig_destroy__ = _IMP_kernel.delete_ScoreState
3757 r"""__str__(ScoreState self) -> std::string"""
3758 return _IMP_kernel.ScoreState___str__(self)
3761 r"""__repr__(ScoreState self) -> std::string"""
3762 return _IMP_kernel.ScoreState___repr__(self)
3766 return _object_cast_to_ScoreState(o)
3769 def get_type_name(self):
3770 return self.__class__.__name__
3771 def do_show(self, out):
3773 def get_version_info(self):
3775 return VersionInfo(self.__module__,
3782 return _object_cast_to_ScoreState(o)
3784 def __disown__(self):
3786 _IMP_kernel.disown_ScoreState(self)
3787 return weakref.proxy(self)
3789 def do_destroy(self):
3790 r"""do_destroy(ScoreState self)"""
3791 return _IMP_kernel.ScoreState_do_destroy(self)
3793 def do_get_inputs(self):
3794 r"""do_get_inputs(ScoreState self) -> IMP::ModelObjectsTemp"""
3795 return _IMP_kernel.ScoreState_do_get_inputs(self)
3797 def do_get_outputs(self):
3798 r"""do_get_outputs(ScoreState self) -> IMP::ModelObjectsTemp"""
3799 return _IMP_kernel.ScoreState_do_get_outputs(self)
3801 def do_get_interactions(self):
3802 r"""do_get_interactions(ScoreState self) -> IMP::ModelObjectsTemps"""
3803 return _IMP_kernel.ScoreState_do_get_interactions(self)
3806 _IMP_kernel.ScoreState_swigregister(ScoreState)
3809 r"""get_update_order(IMP::ScoreStatesTemp input) -> IMP::ScoreStatesTemp"""
3810 return _IMP_kernel.get_update_order(input)
3811 class Constraint(ScoreState):
3812 r"""Proxy of C++ IMP::Constraint class."""
3814 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3816 def __init__(self, *args):
3818 __init__(Constraint self, Model m, std::string name="Constraint %1%") -> Constraint
3819 __init__(Constraint self) -> Constraint
3821 if self.__class__ == Constraint:
3825 _IMP_kernel.Constraint_swiginit(self, _IMP_kernel.new_Constraint(_self, *args))
3827 if self.__class__ != Constraint:
3828 _director_objects.register(self)
3833 def do_update_attributes(self):
3834 r"""do_update_attributes(Constraint self)"""
3835 return _IMP_kernel.Constraint_do_update_attributes(self)
3837 def do_update_derivatives(self, da):
3838 r"""do_update_derivatives(Constraint self, DerivativeAccumulator da)"""
3839 return _IMP_kernel.Constraint_do_update_derivatives(self, da)
3841 def do_before_evaluate(self):
3842 r"""do_before_evaluate(Constraint self)"""
3843 return _IMP_kernel.Constraint_do_before_evaluate(self)
3845 def do_after_evaluate(self, da):
3846 r"""do_after_evaluate(Constraint self, DerivativeAccumulator da)"""
3847 return _IMP_kernel.Constraint_do_after_evaluate(self, da)
3848 __swig_destroy__ = _IMP_kernel.delete_Constraint
3851 r"""__str__(Constraint self) -> std::string"""
3852 return _IMP_kernel.Constraint___str__(self)
3855 r"""__repr__(Constraint self) -> std::string"""
3856 return _IMP_kernel.Constraint___repr__(self)
3860 return _object_cast_to_Constraint(o)
3863 def get_type_name(self):
3864 return self.__class__.__name__
3865 def do_show(self, out):
3867 def get_version_info(self):
3869 return VersionInfo(self.__module__,
3876 return _object_cast_to_Constraint(o)
3878 def __disown__(self):
3880 _IMP_kernel.disown_Constraint(self)
3881 return weakref.proxy(self)
3883 def do_destroy(self):
3884 r"""do_destroy(Constraint self)"""
3885 return _IMP_kernel.Constraint_do_destroy(self)
3887 def do_get_inputs(self):
3888 r"""do_get_inputs(Constraint self) -> IMP::ModelObjectsTemp"""
3889 return _IMP_kernel.Constraint_do_get_inputs(self)
3891 def do_get_outputs(self):
3892 r"""do_get_outputs(Constraint self) -> IMP::ModelObjectsTemp"""
3893 return _IMP_kernel.Constraint_do_get_outputs(self)
3895 def do_get_interactions(self):
3896 r"""do_get_interactions(Constraint self) -> IMP::ModelObjectsTemps"""
3897 return _IMP_kernel.Constraint_do_get_interactions(self)
3900 _IMP_kernel.Constraint_swigregister(Constraint)
3901 class Container(ModelObject):
3902 r"""Proxy of C++ IMP::Container class."""
3904 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3906 def __init__(self, *args):
3908 __init__(Container self, Model m, std::string name="Container %1%") -> Container
3909 __init__(Container self) -> Container
3911 if self.__class__ == Container:
3915 _IMP_kernel.Container_swiginit(self, _IMP_kernel.new_Container(_self, *args))
3917 if self.__class__ != Container:
3918 _director_objects.register(self)
3923 def do_get_contents_hash(self):
3924 r"""do_get_contents_hash(Container self) -> std::size_t"""
3925 return _IMP_kernel.Container_do_get_contents_hash(self)
3927 def get_all_possible_indexes(self):
3928 r"""get_all_possible_indexes(Container self) -> IMP::ParticleIndexes"""
3929 return _IMP_kernel.Container_get_all_possible_indexes(self)
3931 def get_contents_hash(self):
3932 r"""get_contents_hash(Container self) -> std::size_t"""
3933 return _IMP_kernel.Container_get_contents_hash(self)
3935 def do_get_outputs(self):
3936 r"""do_get_outputs(Container self) -> IMP::ModelObjectsTemp"""
3937 return _IMP_kernel.Container_do_get_outputs(self)
3939 def get_is_decomposable(self):
3940 r"""get_is_decomposable(Container self) -> bool"""
3941 return _IMP_kernel.Container_get_is_decomposable(self)
3943 def validate_readable(self):
3944 r"""validate_readable(Container self)"""
3945 return _IMP_kernel.Container_validate_readable(self)
3947 def validate_writable(self):
3948 r"""validate_writable(Container self)"""
3949 return _IMP_kernel.Container_validate_writable(self)
3951 def set_is_readable(self, tf):
3952 r"""set_is_readable(Container self, bool tf)"""
3953 return _IMP_kernel.Container_set_is_readable(self, tf)
3955 def set_is_writable(self, tf):
3956 r"""set_is_writable(Container self, bool tf)"""
3957 return _IMP_kernel.Container_set_is_writable(self, tf)
3958 __swig_destroy__ = _IMP_kernel.delete_Container
3961 r"""__str__(Container self) -> std::string"""
3962 return _IMP_kernel.Container___str__(self)
3965 r"""__repr__(Container self) -> std::string"""
3966 return _IMP_kernel.Container___repr__(self)
3970 return _object_cast_to_Container(o)
3973 def get_type_name(self):
3974 return self.__class__.__name__
3975 def do_show(self, out):
3977 def get_version_info(self):
3979 return VersionInfo(self.__module__,
3986 return _object_cast_to_Container(o)
3988 def __disown__(self):
3990 _IMP_kernel.disown_Container(self)
3991 return weakref.proxy(self)
3993 def do_destroy(self):
3994 r"""do_destroy(Container self)"""
3995 return _IMP_kernel.Container_do_destroy(self)
3997 def handle_set_has_required_score_states(self, arg0):
3998 r"""handle_set_has_required_score_states(Container self, bool arg0)"""
3999 return _IMP_kernel.Container_handle_set_has_required_score_states(self, arg0)
4001 def do_get_inputs(self):
4002 r"""do_get_inputs(Container self) -> IMP::ModelObjectsTemp"""
4003 return _IMP_kernel.Container_do_get_inputs(self)
4005 def do_get_interactions(self):
4006 r"""do_get_interactions(Container self) -> IMP::ModelObjectsTemps"""
4007 return _IMP_kernel.Container_do_get_interactions(self)
4010 _IMP_kernel.Container_swigregister(Container)
4011 class RestraintInfo(Object):
4012 r"""Proxy of C++ IMP::RestraintInfo class."""
4014 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
4016 def __init__(self, *args):
4017 r"""__init__(RestraintInfo self, std::string name="RestraintInfo %1%") -> RestraintInfo"""
4018 _IMP_kernel.RestraintInfo_swiginit(self, _IMP_kernel.new_RestraintInfo(*args))
4021 r"""clear(RestraintInfo self)"""
4022 return _IMP_kernel.RestraintInfo_clear(self)
4024 def add_int(self, key, value):
4025 r"""add_int(RestraintInfo self, std::string key, int value)"""
4026 return _IMP_kernel.RestraintInfo_add_int(self, key, value)
4028 def get_number_of_int(self):
4029 r"""get_number_of_int(RestraintInfo self) -> unsigned int"""
4030 return _IMP_kernel.RestraintInfo_get_number_of_int(self)
4032 def get_int_key(self, i):
4033 r"""get_int_key(RestraintInfo self, unsigned int i) -> std::string"""
4034 return _IMP_kernel.RestraintInfo_get_int_key(self, i)
4036 def get_int_value(self, i):
4037 r"""get_int_value(RestraintInfo self, unsigned int i) -> int"""
4038 return _IMP_kernel.RestraintInfo_get_int_value(self, i)
4040 def add_float(self, key, value):
4041 r"""add_float(RestraintInfo self, std::string key, double value)"""
4042 return _IMP_kernel.RestraintInfo_add_float(self, key, value)
4044 def get_number_of_float(self):
4045 r"""get_number_of_float(RestraintInfo self) -> unsigned int"""
4046 return _IMP_kernel.RestraintInfo_get_number_of_float(self)
4048 def get_float_key(self, i):
4049 r"""get_float_key(RestraintInfo self, unsigned int i) -> std::string"""
4050 return _IMP_kernel.RestraintInfo_get_float_key(self, i)
4052 def get_float_value(self, i):
4053 r"""get_float_value(RestraintInfo self, unsigned int i) -> double"""
4054 return _IMP_kernel.RestraintInfo_get_float_value(self, i)
4056 def add_string(self, key, value):
4057 r"""add_string(RestraintInfo self, std::string key, std::string value)"""
4058 return _IMP_kernel.RestraintInfo_add_string(self, key, value)
4060 def get_number_of_string(self):
4061 r"""get_number_of_string(RestraintInfo self) -> unsigned int"""
4062 return _IMP_kernel.RestraintInfo_get_number_of_string(self)
4064 def get_string_key(self, i):
4065 r"""get_string_key(RestraintInfo self, unsigned int i) -> std::string"""
4066 return _IMP_kernel.RestraintInfo_get_string_key(self, i)
4068 def get_string_value(self, i):
4069 r"""get_string_value(RestraintInfo self, unsigned int i) -> std::string"""
4070 return _IMP_kernel.RestraintInfo_get_string_value(self, i)
4072 def add_filename(self, key, value):
4073 r"""add_filename(RestraintInfo self, std::string key, std::string value)"""
4074 return _IMP_kernel.RestraintInfo_add_filename(self, key, value)
4076 def get_number_of_filename(self):
4077 r"""get_number_of_filename(RestraintInfo self) -> unsigned int"""
4078 return _IMP_kernel.RestraintInfo_get_number_of_filename(self)
4080 def get_filename_key(self, i):
4081 r"""get_filename_key(RestraintInfo self, unsigned int i) -> std::string"""
4082 return _IMP_kernel.RestraintInfo_get_filename_key(self, i)
4084 def get_filename_value(self, i):
4085 r"""get_filename_value(RestraintInfo self, unsigned int i) -> std::string"""
4086 return _IMP_kernel.RestraintInfo_get_filename_value(self, i)
4088 def add_floats(self, key, value):
4089 r"""add_floats(RestraintInfo self, std::string key, IMP::Floats value)"""
4090 return _IMP_kernel.RestraintInfo_add_floats(self, key, value)
4092 def get_number_of_floats(self):
4093 r"""get_number_of_floats(RestraintInfo self) -> unsigned int"""
4094 return _IMP_kernel.RestraintInfo_get_number_of_floats(self)
4096 def get_floats_key(self, i):
4097 r"""get_floats_key(RestraintInfo self, unsigned int i) -> std::string"""
4098 return _IMP_kernel.RestraintInfo_get_floats_key(self, i)
4100 def get_floats_value(self, i):
4101 r"""get_floats_value(RestraintInfo self, unsigned int i) -> IMP::Floats"""
4102 return _IMP_kernel.RestraintInfo_get_floats_value(self, i)
4104 def add_ints(self, key, value):
4105 r"""add_ints(RestraintInfo self, std::string key, IMP::Ints value)"""
4106 return _IMP_kernel.RestraintInfo_add_ints(self, key, value)
4108 def get_number_of_ints(self):
4109 r"""get_number_of_ints(RestraintInfo self) -> unsigned int"""
4110 return _IMP_kernel.RestraintInfo_get_number_of_ints(self)
4112 def get_ints_key(self, i):
4113 r"""get_ints_key(RestraintInfo self, unsigned int i) -> std::string"""
4114 return _IMP_kernel.RestraintInfo_get_ints_key(self, i)
4116 def get_ints_value(self, i):
4117 r"""get_ints_value(RestraintInfo self, unsigned int i) -> IMP::Ints"""
4118 return _IMP_kernel.RestraintInfo_get_ints_value(self, i)
4120 def add_strings(self, key, value):
4121 r"""add_strings(RestraintInfo self, std::string key, IMP::Strings value)"""
4122 return _IMP_kernel.RestraintInfo_add_strings(self, key, value)
4124 def get_number_of_strings(self):
4125 r"""get_number_of_strings(RestraintInfo self) -> unsigned int"""
4126 return _IMP_kernel.RestraintInfo_get_number_of_strings(self)
4128 def get_strings_key(self, i):
4129 r"""get_strings_key(RestraintInfo self, unsigned int i) -> std::string"""
4130 return _IMP_kernel.RestraintInfo_get_strings_key(self, i)
4132 def get_strings_value(self, i):
4133 r"""get_strings_value(RestraintInfo self, unsigned int i) -> IMP::Strings"""
4134 return _IMP_kernel.RestraintInfo_get_strings_value(self, i)
4136 def add_filenames(self, key, value):
4137 r"""add_filenames(RestraintInfo self, std::string key, IMP::Strings value)"""
4138 return _IMP_kernel.RestraintInfo_add_filenames(self, key, value)
4140 def get_number_of_filenames(self):
4141 r"""get_number_of_filenames(RestraintInfo self) -> unsigned int"""
4142 return _IMP_kernel.RestraintInfo_get_number_of_filenames(self)
4144 def get_filenames_key(self, i):
4145 r"""get_filenames_key(RestraintInfo self, unsigned int i) -> std::string"""
4146 return _IMP_kernel.RestraintInfo_get_filenames_key(self, i)
4148 def get_filenames_value(self, i):
4149 r"""get_filenames_value(RestraintInfo self, unsigned int i) -> IMP::Strings"""
4150 return _IMP_kernel.RestraintInfo_get_filenames_value(self, i)
4152 def add_particle_indexes(self, key, value):
4153 r"""add_particle_indexes(RestraintInfo self, std::string key, IMP::ParticleIndexes value)"""
4154 return _IMP_kernel.RestraintInfo_add_particle_indexes(self, key, value)
4156 def get_number_of_particle_indexes(self):
4157 r"""get_number_of_particle_indexes(RestraintInfo self) -> unsigned int"""
4158 return _IMP_kernel.RestraintInfo_get_number_of_particle_indexes(self)
4160 def get_particle_indexes_key(self, i):
4161 r"""get_particle_indexes_key(RestraintInfo self, unsigned int i) -> std::string"""
4162 return _IMP_kernel.RestraintInfo_get_particle_indexes_key(self, i)
4164 def get_particle_indexes_value(self, i):
4165 r"""get_particle_indexes_value(RestraintInfo self, unsigned int i) -> IMP::ParticleIndexes"""
4166 return _IMP_kernel.RestraintInfo_get_particle_indexes_value(self, i)
4168 def get_version_info(self):
4169 r"""get_version_info(RestraintInfo self) -> VersionInfo"""
4170 return _IMP_kernel.RestraintInfo_get_version_info(self)
4171 __swig_destroy__ = _IMP_kernel.delete_RestraintInfo
4174 r"""__str__(RestraintInfo self) -> std::string"""
4175 return _IMP_kernel.RestraintInfo___str__(self)
4178 r"""__repr__(RestraintInfo self) -> std::string"""
4179 return _IMP_kernel.RestraintInfo___repr__(self)
4183 return _object_cast_to_RestraintInfo(o)
4187 _IMP_kernel.RestraintInfo_swigregister(RestraintInfo)
4188 class Restraint(ModelObject):
4189 r"""Proxy of C++ IMP::Restraint class."""
4191 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
4193 def __init__(self, *args):
4195 __init__(Restraint self, Model m, std::string name) -> Restraint
4196 __init__(Restraint self) -> Restraint
4198 if self.__class__ == Restraint:
4202 _IMP_kernel.Restraint_swiginit(self, _IMP_kernel.new_Restraint(_self, *args))
4204 if self.__class__ != Restraint:
4205 _director_objects.register(self)
4210 def get_score(self):
4211 r"""get_score(Restraint self) -> double"""
4212 return _IMP_kernel.Restraint_get_score(self)
4214 def evaluate(self, calc_derivs):
4215 r"""evaluate(Restraint self, bool calc_derivs) -> double"""
4216 return _IMP_kernel.Restraint_evaluate(self, calc_derivs)
4218 def evaluate_moved(self, calc_derivs, moved_pis, reset_pis):
4219 r"""evaluate_moved(Restraint self, bool calc_derivs, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis) -> double"""
4220 return _IMP_kernel.Restraint_evaluate_moved(self, calc_derivs, moved_pis, reset_pis)
4222 def evaluate_moved_if_below(self, calc_derivatives, moved_pis, reset_pis, max):
4223 r"""evaluate_moved_if_below(Restraint self, bool calc_derivatives, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis, double max) -> double"""
4224 return _IMP_kernel.Restraint_evaluate_moved_if_below(self, calc_derivatives, moved_pis, reset_pis, max)
4226 def evaluate_moved_if_good(self, calc_derivatives, moved_pis, reset_pis):
4227 r"""evaluate_moved_if_good(Restraint self, bool calc_derivatives, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis) -> double"""
4228 return _IMP_kernel.Restraint_evaluate_moved_if_good(self, calc_derivatives, moved_pis, reset_pis)
4230 def evaluate_if_good(self, calc_derivatives):
4231 r"""evaluate_if_good(Restraint self, bool calc_derivatives) -> double"""
4232 return _IMP_kernel.Restraint_evaluate_if_good(self, calc_derivatives)
4234 def evaluate_if_below(self, calc_derivatives, max):
4235 r"""evaluate_if_below(Restraint self, bool calc_derivatives, double max) -> double"""
4236 return _IMP_kernel.Restraint_evaluate_if_below(self, calc_derivatives, max)
4238 def unprotected_evaluate(self, da):
4239 r"""unprotected_evaluate(Restraint self, DerivativeAccumulator da) -> double"""
4240 return _IMP_kernel.Restraint_unprotected_evaluate(self, da)
4242 def unprotected_evaluate_moved(self, da, moved_pis, reset_pis):
4243 r"""unprotected_evaluate_moved(Restraint self, DerivativeAccumulator da, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis) -> double"""
4244 return _IMP_kernel.Restraint_unprotected_evaluate_moved(self, da, moved_pis, reset_pis)
4246 def unprotected_evaluate_if_good(self, da, max):
4247 r"""unprotected_evaluate_if_good(Restraint self, DerivativeAccumulator da, double max) -> double"""
4248 return _IMP_kernel.Restraint_unprotected_evaluate_if_good(self, da, max)
4250 def unprotected_evaluate_if_below(self, da, max):
4251 r"""unprotected_evaluate_if_below(Restraint self, DerivativeAccumulator da, double max) -> double"""
4252 return _IMP_kernel.Restraint_unprotected_evaluate_if_below(self, da, max)
4254 def unprotected_evaluate_moved_if_below(self, da, moved_pis, reset_pis, max):
4255 r"""unprotected_evaluate_moved_if_below(Restraint self, DerivativeAccumulator da, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis, double max) -> double"""
4256 return _IMP_kernel.Restraint_unprotected_evaluate_moved_if_below(self, da, moved_pis, reset_pis, max)
4258 def unprotected_evaluate_moved_if_good(self, da, moved_pis, reset_pis, max):
4259 r"""unprotected_evaluate_moved_if_good(Restraint self, DerivativeAccumulator da, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis, double max) -> double"""
4260 return _IMP_kernel.Restraint_unprotected_evaluate_moved_if_good(self, da, moved_pis, reset_pis, max)
4262 def get_static_info(self):
4263 r"""get_static_info(Restraint self) -> RestraintInfo"""
4264 return _IMP_kernel.Restraint_get_static_info(self)
4266 def get_dynamic_info(self):
4267 r"""get_dynamic_info(Restraint self) -> RestraintInfo"""
4268 return _IMP_kernel.Restraint_get_dynamic_info(self)
4270 def add_score_and_derivatives(self, sa):
4271 r"""add_score_and_derivatives(Restraint self, ScoreAccumulator sa)"""
4272 return _IMP_kernel.Restraint_add_score_and_derivatives(self, sa)
4274 def add_score_and_derivatives_moved(self, sa, moved_pis, reset_pis):
4275 r"""add_score_and_derivatives_moved(Restraint self, ScoreAccumulator sa, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis)"""
4276 return _IMP_kernel.Restraint_add_score_and_derivatives_moved(self, sa, moved_pis, reset_pis)
4279 r"""create_decomposition(Restraint self) -> Restraint"""
4280 return _IMP_kernel.Restraint_create_decomposition(self)
4282 def create_current_decomposition(self):
4283 r"""create_current_decomposition(Restraint self) -> Restraint"""
4284 return _IMP_kernel.Restraint_create_current_decomposition(self)
4286 def set_weight(self, weight):
4287 r"""set_weight(Restraint self, IMP::Float weight)"""
4288 return _IMP_kernel.Restraint_set_weight(self, weight)
4290 def get_weight(self):
4291 r"""get_weight(Restraint self) -> IMP::Float"""
4292 return _IMP_kernel.Restraint_get_weight(self)
4294 def get_maximum_score(self):
4295 r"""get_maximum_score(Restraint self) -> double"""
4296 return _IMP_kernel.Restraint_get_maximum_score(self)
4298 def set_maximum_score(self, s):
4299 r"""set_maximum_score(Restraint self, double s)"""
4300 return _IMP_kernel.Restraint_set_maximum_score(self, s)
4303 r"""create_scoring_function(Restraint self, double weight=1.0, double max=NO_MAX) -> ScoringFunction"""
4304 return _IMP_kernel.Restraint_create_scoring_function(self, *args)
4306 def set_last_score(self, s):
4307 r"""set_last_score(Restraint self, double s)"""
4308 return _IMP_kernel.Restraint_set_last_score(self, s)
4310 def set_last_last_score(self, s):
4311 r"""set_last_last_score(Restraint self, double s)"""
4312 return _IMP_kernel.Restraint_set_last_last_score(self, s)
4314 def get_last_score(self):
4315 r"""get_last_score(Restraint self) -> double"""
4316 return _IMP_kernel.Restraint_get_last_score(self)
4318 def get_last_last_score(self):
4319 r"""get_last_last_score(Restraint self) -> double"""
4320 return _IMP_kernel.Restraint_get_last_last_score(self)
4322 def get_is_aggregate(self):
4323 r"""get_is_aggregate(Restraint self) -> bool"""
4324 return _IMP_kernel.Restraint_get_is_aggregate(self)
4326 def get_was_good(self):
4327 r"""get_was_good(Restraint self) -> bool"""
4328 return _IMP_kernel.Restraint_get_was_good(self)
4329 __swig_destroy__ = _IMP_kernel.delete_Restraint
4331 def do_create_decomposition(self):
4332 r"""do_create_decomposition(Restraint self) -> IMP::Restraints"""
4333 return _IMP_kernel.Restraint_do_create_decomposition(self)
4335 def do_create_current_decomposition(self):
4336 r"""do_create_current_decomposition(Restraint self) -> IMP::Restraints"""
4337 return _IMP_kernel.Restraint_do_create_current_decomposition(self)
4339 def do_add_score_and_derivatives(self, sa):
4340 r"""do_add_score_and_derivatives(Restraint self, ScoreAccumulator sa)"""
4341 return _IMP_kernel.Restraint_do_add_score_and_derivatives(self, sa)
4343 def do_add_score_and_derivatives_moved(self, sa, moved_pis, reset_pis):
4344 r"""do_add_score_and_derivatives_moved(Restraint self, ScoreAccumulator sa, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis)"""
4345 return _IMP_kernel.Restraint_do_add_score_and_derivatives_moved(self, sa, moved_pis, reset_pis)
4347 def do_get_outputs(self):
4348 r"""do_get_outputs(Restraint self) -> IMP::ModelObjectsTemp"""
4349 return _IMP_kernel.Restraint_do_get_outputs(self)
4350 is_aggregate_ = property(_IMP_kernel.Restraint_is_aggregate__get, _IMP_kernel.Restraint_is_aggregate__set, doc=
r"""is_aggregate_ : bool""")
4353 r"""__str__(Restraint self) -> std::string"""
4354 return _IMP_kernel.Restraint___str__(self)
4357 r"""__repr__(Restraint self) -> std::string"""
4358 return _IMP_kernel.Restraint___repr__(self)
4362 return _object_cast_to_Restraint(o)
4365 def get_type_name(self):
4366 return self.__class__.__name__
4367 def do_show(self, out):
4369 def get_version_info(self):
4371 return VersionInfo(self.__module__,
4378 return _object_cast_to_Restraint(o)
4380 def __disown__(self):
4382 _IMP_kernel.disown_Restraint(self)
4383 return weakref.proxy(self)
4385 def do_destroy(self):
4386 r"""do_destroy(Restraint self)"""
4387 return _IMP_kernel.Restraint_do_destroy(self)
4389 def handle_set_has_required_score_states(self, arg0):
4390 r"""handle_set_has_required_score_states(Restraint self, bool arg0)"""
4391 return _IMP_kernel.Restraint_handle_set_has_required_score_states(self, arg0)
4393 def do_get_inputs(self):
4394 r"""do_get_inputs(Restraint self) -> IMP::ModelObjectsTemp"""
4395 return _IMP_kernel.Restraint_do_get_inputs(self)
4397 def do_get_interactions(self):
4398 r"""do_get_interactions(Restraint self) -> IMP::ModelObjectsTemps"""
4399 return _IMP_kernel.Restraint_do_get_interactions(self)
4402 _IMP_kernel.Restraint_swigregister(Restraint)
4403 class _RestraintsAdaptor(_InputAdaptor):
4404 r"""Proxy of C++ IMP::RestraintsAdaptor class."""
4406 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
4407 __repr__ = _swig_repr
4409 def __init__(self, *args):
4411 __init__(_RestraintsAdaptor self) -> _RestraintsAdaptor
4412 __init__(_RestraintsAdaptor self, IMP::Restraints const & sf) -> _RestraintsAdaptor
4413 __init__(_RestraintsAdaptor self, IMP::RestraintsTemp const & sf) -> _RestraintsAdaptor
4414 __init__(_RestraintsAdaptor self, Restraint sf) -> _RestraintsAdaptor
4416 _IMP_kernel._RestraintsAdaptor_swiginit(self, _IMP_kernel.new__RestraintsAdaptor(*args))
4417 __swig_destroy__ = _IMP_kernel.delete__RestraintsAdaptor
4420 _IMP_kernel._RestraintsAdaptor_swigregister(_RestraintsAdaptor)
4421 class RestraintSet(Restraint):
4422 r"""Proxy of C++ IMP::RestraintSet class."""
4424 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
4426 def __init__(self, *args):
4428 __init__(RestraintSet self, Model m, double weight, std::string const & name="RestraintSet %1%") -> RestraintSet
4429 __init__(RestraintSet self, Model m, std::string const & name="RestraintSet %1%") -> RestraintSet
4430 __init__(RestraintSet self, IMP::RestraintsTemp const & rs, double weight, std::string const & name="RestraintSet %1%") -> RestraintSet
4431 __init__(RestraintSet self) -> RestraintSet
4433 if self.__class__ == RestraintSet:
4437 _IMP_kernel.RestraintSet_swiginit(self, _IMP_kernel.new_RestraintSet(_self, *args))
4439 if self.__class__ != RestraintSet:
4440 _director_objects.register(self)
4445 def unprotected_evaluate(self, da):
4446 r"""unprotected_evaluate(RestraintSet self, DerivativeAccumulator da) -> double"""
4447 return _IMP_kernel.RestraintSet_unprotected_evaluate(self, da)
4449 def get_type_name(self):
4450 r"""get_type_name(RestraintSet self) -> std::string"""
4451 return _IMP_kernel.RestraintSet_get_type_name(self)
4453 def get_version_info(self):
4454 r"""get_version_info(RestraintSet self) -> VersionInfo"""
4455 return _IMP_kernel.RestraintSet_get_version_info(self)
4456 __swig_destroy__ = _IMP_kernel.delete_RestraintSet
4457 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)
4458 def __set_restraints(self, obj): _list_util.set_varlist(self.restraints, obj)
4459 def __del_restraints(self): _list_util.del_varlist(self.restraints)
4460 restraints = property(__get_restraints, __set_restraints, __del_restraints, doc=
"List of ##ucnames")
4462 def remove_restraint(self, d):
4463 r"""remove_restraint(RestraintSet self, Restraint d)"""
4464 return _IMP_kernel.RestraintSet_remove_restraint(self, d)
4466 def _python_index_restraint(self, d, start, stop):
4467 r"""_python_index_restraint(RestraintSet self, Restraint d, unsigned int start, unsigned int stop) -> unsigned int"""
4468 return _IMP_kernel.RestraintSet__python_index_restraint(self, d, start, stop)
4470 def remove_restraints(self, d):
4471 r"""remove_restraints(RestraintSet self, IMP::Restraints const & d)"""
4472 return _IMP_kernel.RestraintSet_remove_restraints(self, d)
4474 def set_restraints(self, ps):
4475 r"""set_restraints(RestraintSet self, IMP::Restraints const & ps)"""
4476 return _IMP_kernel.RestraintSet_set_restraints(self, ps)
4478 def set_restraints_order(self, objs):
4479 r"""set_restraints_order(RestraintSet self, IMP::Restraints const & objs)"""
4480 return _IMP_kernel.RestraintSet_set_restraints_order(self, objs)
4483 r"""add_restraint(RestraintSet self, Restraint obj) -> unsigned int"""
4484 return _IMP_kernel.RestraintSet_add_restraint(self, obj)
4487 r"""add_restraints(RestraintSet self, IMP::Restraints const & objs)"""
4488 return _IMP_kernel.RestraintSet_add_restraints(self, objs)
4490 def clear_restraints(self):
4491 r"""clear_restraints(RestraintSet self)"""
4492 return _IMP_kernel.RestraintSet_clear_restraints(self)
4494 def get_number_of_restraints(self):
4495 r"""get_number_of_restraints(RestraintSet self) -> unsigned int"""
4496 return _IMP_kernel.RestraintSet_get_number_of_restraints(self)
4498 def get_has_restraints(self):
4499 r"""get_has_restraints(RestraintSet self) -> bool"""
4500 return _IMP_kernel.RestraintSet_get_has_restraints(self)
4502 def get_restraint(self, i):
4503 r"""get_restraint(RestraintSet self, unsigned int i) -> Restraint"""
4504 return _IMP_kernel.RestraintSet_get_restraint(self, i)
4506 def get_restraints(self):
4507 r"""get_restraints(RestraintSet self) -> IMP::Restraints"""
4508 return _IMP_kernel.RestraintSet_get_restraints(self)
4510 def erase_restraint(self, i):
4511 r"""erase_restraint(RestraintSet self, unsigned int i)"""
4512 return _IMP_kernel.RestraintSet_erase_restraint(self, i)
4514 def reserve_restraints(self, sz):
4515 r"""reserve_restraints(RestraintSet self, unsigned int sz)"""
4516 return _IMP_kernel.RestraintSet_reserve_restraints(self, sz)
4518 def get_non_sets_and_sets(self):
4519 r"""get_non_sets_and_sets(RestraintSet self) -> std::pair< IMP::RestraintsTemp,IMP::RestraintSetsTemp >"""
4520 return _IMP_kernel.RestraintSet_get_non_sets_and_sets(self)
4522 def do_get_inputs(self):
4523 r"""do_get_inputs(RestraintSet self) -> IMP::ModelObjectsTemp"""
4524 return _IMP_kernel.RestraintSet_do_get_inputs(self)
4527 r"""create_scoring_function(RestraintSet self, double weight=1.0, double max=std::numeric_limits< double >::max()) -> ScoringFunction"""
4528 return _IMP_kernel.RestraintSet_create_scoring_function(self, *args)
4530 def get_last_score(self):
4531 r"""get_last_score(RestraintSet self) -> double"""
4532 return _IMP_kernel.RestraintSet_get_last_score(self)
4535 r"""__str__(RestraintSet self) -> std::string"""
4536 return _IMP_kernel.RestraintSet___str__(self)
4539 r"""__repr__(RestraintSet self) -> std::string"""
4540 return _IMP_kernel.RestraintSet___repr__(self)
4544 return _object_cast_to_RestraintSet(o)
4547 def get_type_name(self):
4548 return self.__class__.__name__
4549 def do_show(self, out):
4551 def get_version_info(self):
4553 return VersionInfo(self.__module__,
4560 return _object_cast_to_RestraintSet(o)
4563 def _get_as_binary(self):
4564 r"""_get_as_binary(RestraintSet self) -> PyObject *"""
4565 return _IMP_kernel.RestraintSet__get_as_binary(self)
4567 def _set_from_binary(self, p):
4568 r"""_set_from_binary(RestraintSet self, PyObject * p)"""
4569 return _IMP_kernel.RestraintSet__set_from_binary(self, p)
4571 def __getstate__(self):
4572 p = self._get_as_binary()
4573 if len(self.__dict__) > 1:
4574 d = self.__dict__.copy()
4579 def __setstate__(self, p):
4580 if not hasattr(self,
'this'):
4582 if isinstance(p, tuple):
4584 self.__dict__.update(d)
4585 return self._set_from_binary(p)
4587 def __disown__(self):
4589 _IMP_kernel.disown_RestraintSet(self)
4590 return weakref.proxy(self)
4592 def do_destroy(self):
4593 r"""do_destroy(RestraintSet self)"""
4594 return _IMP_kernel.RestraintSet_do_destroy(self)
4596 def handle_set_has_required_score_states(self, arg0):
4597 r"""handle_set_has_required_score_states(RestraintSet self, bool arg0)"""
4598 return _IMP_kernel.RestraintSet_handle_set_has_required_score_states(self, arg0)
4600 def do_get_outputs(self):
4601 r"""do_get_outputs(RestraintSet self) -> IMP::ModelObjectsTemp"""
4602 return _IMP_kernel.RestraintSet_do_get_outputs(self)
4604 def do_get_interactions(self):
4605 r"""do_get_interactions(RestraintSet self) -> IMP::ModelObjectsTemps"""
4606 return _IMP_kernel.RestraintSet_do_get_interactions(self)
4608 def do_create_decomposition(self):
4609 r"""do_create_decomposition(RestraintSet self) -> IMP::Restraints"""
4610 return _IMP_kernel.RestraintSet_do_create_decomposition(self)
4612 def do_create_current_decomposition(self):
4613 r"""do_create_current_decomposition(RestraintSet self) -> IMP::Restraints"""
4614 return _IMP_kernel.RestraintSet_do_create_current_decomposition(self)
4616 def do_add_score_and_derivatives(self, sa):
4617 r"""do_add_score_and_derivatives(RestraintSet self, ScoreAccumulator sa)"""
4618 return _IMP_kernel.RestraintSet_do_add_score_and_derivatives(self, sa)
4620 def do_add_score_and_derivatives_moved(self, sa, moved_pis, reset_pis):
4621 r"""do_add_score_and_derivatives_moved(RestraintSet self, ScoreAccumulator sa, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis)"""
4622 return _IMP_kernel.RestraintSet_do_add_score_and_derivatives_moved(self, sa, moved_pis, reset_pis)
4625 _IMP_kernel.RestraintSet_swigregister(RestraintSet)
4627 def get_restraints(rs):
4628 r"""get_restraints(IMP::RestraintsTemp const & rs) -> IMP::RestraintsTemp"""
4629 return _IMP_kernel.get_restraints(rs)
4631 def _check_particle(p, a):
4632 if (
not p.get_is_active()):
4633 raise ValueError(
"Inactive Particle")
4634 if (type(a)() == a):
4635 raise IndexError(
"Cannot use default Index")
4636 if (
not p.has_attribute(a)):
4637 raise IndexError(
"Particle does not have attribute")
4639 class Particle(ModelObject):
4640 r"""Proxy of C++ IMP::Particle class."""
4642 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
4644 def get_version_info(self):
4645 r"""get_version_info(Particle self) -> VersionInfo"""
4646 return _IMP_kernel.Particle_get_version_info(self)
4647 __swig_destroy__ = _IMP_kernel.delete_Particle
4649 def __init__(self, *args):
4651 __init__(Particle self, Model m, std::string name) -> Particle
4652 __init__(Particle self, Model m) -> Particle
4653 __init__(Particle self) -> Particle
4655 _IMP_kernel.Particle_swiginit(self, _IMP_kernel.new_Particle(*args))
4657 def get_float_keys(self):
4658 r"""get_float_keys(Particle self) -> IMP::FloatKeys"""
4659 return _IMP_kernel.Particle_get_float_keys(self)
4661 def get_floats_keys(self):
4662 r"""get_floats_keys(Particle self) -> IMP::FloatsKeys"""
4663 return _IMP_kernel.Particle_get_floats_keys(self)
4665 def get_int_keys(self):
4666 r"""get_int_keys(Particle self) -> IMP::IntKeys"""
4667 return _IMP_kernel.Particle_get_int_keys(self)
4669 def get_ints_keys(self):
4670 r"""get_ints_keys(Particle self) -> IMP::IntsKeys"""
4671 return _IMP_kernel.Particle_get_ints_keys(self)
4673 def get_string_keys(self):
4674 r"""get_string_keys(Particle self) -> IMP::StringKeys"""
4675 return _IMP_kernel.Particle_get_string_keys(self)
4677 def get_object_keys(self):
4678 r"""get_object_keys(Particle self) -> IMP::ObjectKeys"""
4679 return _IMP_kernel.Particle_get_object_keys(self)
4681 def add_cache_attribute(self, *args):
4683 add_cache_attribute(Particle self, FloatKey name, IMP::Float value)
4684 add_cache_attribute(Particle self, FloatsKey name, IMP::Floats value)
4685 add_cache_attribute(Particle self, IntKey name, IMP::Int value)
4686 add_cache_attribute(Particle self, IntsKey name, IMP::Ints value)
4687 add_cache_attribute(Particle self, StringKey name, IMP::String value)
4688 add_cache_attribute(Particle self, ObjectKey name, Object value)
4689 add_cache_attribute(Particle self, IMP::WeakObjectKey name, Object value)
4691 return _IMP_kernel.Particle_add_cache_attribute(self, *args)
4693 def get_weak_object_keys(self):
4694 r"""get_weak_object_keys(Particle self) -> IMP::WeakObjectKeys"""
4695 return _IMP_kernel.Particle_get_weak_object_keys(self)
4697 def add_to_derivative(self, key, value, da):
4698 r"""add_to_derivative(Particle self, FloatKey key, IMP::Float value, DerivativeAccumulator da)"""
4699 return _IMP_kernel.Particle_add_to_derivative(self, key, value, da)
4701 def set_is_optimized(self, k, tf):
4702 r"""set_is_optimized(Particle self, FloatKey k, bool tf)"""
4703 return _IMP_kernel.Particle_set_is_optimized(self, k, tf)
4705 def get_is_optimized(self, k):
4706 r"""get_is_optimized(Particle self, FloatKey k) -> bool"""
4707 return _IMP_kernel.Particle_get_is_optimized(self, k)
4709 def get_derivative(self, k):
4710 r"""get_derivative(Particle self, FloatKey k) -> IMP::Float"""
4711 return _IMP_kernel.Particle_get_derivative(self, k)
4713 def add_attribute(self, *args):
4715 add_attribute(Particle self, FloatKey name, IMP::Float initial_value)
4716 add_attribute(Particle self, FloatsKey name, IMP::Floats initial_value)
4717 add_attribute(Particle self, IntKey name, IMP::Int initial_value)
4718 add_attribute(Particle self, IntsKey name, IMP::Ints initial_value)
4719 add_attribute(Particle self, StringKey name, IMP::String initial_value)
4720 add_attribute(Particle self, ObjectKey name, Object initial_value)
4721 add_attribute(Particle self, IMP::WeakObjectKey name, Object initial_value)
4722 add_attribute(Particle self, SparseStringKey name, IMP::String initial_value)
4723 add_attribute(Particle self, SparseIntKey name, IMP::Int initial_value)
4724 add_attribute(Particle self, SparseFloatKey name, IMP::Float initial_value)
4725 add_attribute(Particle self, SparseParticleIndexKey name, ParticleIndex initial_value)
4726 add_attribute(Particle self, FloatKey name, IMP::Float const initial_value, bool optimized)
4727 add_attribute(Particle self, ParticleIndexKey k, Particle v)
4729 return _IMP_kernel.Particle_add_attribute(self, *args)
4731 def has_attribute(self, *args):
4733 has_attribute(Particle self, FloatKey name) -> bool
4734 has_attribute(Particle self, FloatsKey name) -> bool
4735 has_attribute(Particle self, IntKey name) -> bool
4736 has_attribute(Particle self, IntsKey name) -> bool
4737 has_attribute(Particle self, StringKey name) -> bool
4738 has_attribute(Particle self, ObjectKey name) -> bool
4739 has_attribute(Particle self, IMP::WeakObjectKey name) -> bool
4740 has_attribute(Particle self, SparseStringKey name) -> bool
4741 has_attribute(Particle self, SparseIntKey name) -> bool
4742 has_attribute(Particle self, SparseFloatKey name) -> bool
4743 has_attribute(Particle self, SparseParticleIndexKey name) -> bool
4744 has_attribute(Particle self, ParticleIndexKey k) -> bool
4746 return _IMP_kernel.Particle_has_attribute(self, *args)
4748 def set_value(self, *args):
4750 set_value(Particle self, FloatKey name, IMP::Float value)
4751 set_value(Particle self, FloatsKey name, IMP::Floats value)
4752 set_value(Particle self, IntKey name, IMP::Int value)
4753 set_value(Particle self, IntsKey name, IMP::Ints value)
4754 set_value(Particle self, StringKey name, IMP::String value)
4755 set_value(Particle self, ObjectKey name, Object value)
4756 set_value(Particle self, IMP::WeakObjectKey name, Object value)
4757 set_value(Particle self, SparseStringKey name, IMP::String value)
4758 set_value(Particle self, SparseIntKey name, IMP::Int value)
4759 set_value(Particle self, SparseFloatKey name, IMP::Float value)
4760 set_value(Particle self, SparseParticleIndexKey name, ParticleIndex value)
4761 set_value(Particle self, ParticleIndexKey k, Particle v)
4763 return _IMP_kernel.Particle_set_value(self, *args)
4765 def get_value(self, *args):
4767 get_value(Particle self, FloatKey name) -> IMP::Float
4768 get_value(Particle self, FloatsKey name) -> IMP::Floats
4769 get_value(Particle self, IntKey name) -> IMP::Int
4770 get_value(Particle self, IntsKey name) -> IMP::Ints
4771 get_value(Particle self, StringKey name) -> IMP::String
4772 get_value(Particle self, ObjectKey name) -> Object
4773 get_value(Particle self, IMP::WeakObjectKey name) -> Object
4774 get_value(Particle self, SparseStringKey name) -> IMP::String
4775 get_value(Particle self, SparseIntKey name) -> IMP::Int
4776 get_value(Particle self, SparseFloatKey name) -> IMP::Float
4777 get_value(Particle self, SparseParticleIndexKey name) -> ParticleIndex
4778 get_value(Particle self, ParticleIndexKey k) -> Particle
4780 return _IMP_kernel.Particle_get_value(self, *args)
4782 def remove_attribute(self, *args):
4784 remove_attribute(Particle self, FloatKey name)
4785 remove_attribute(Particle self, FloatsKey name)
4786 remove_attribute(Particle self, IntKey name)
4787 remove_attribute(Particle self, IntsKey name)
4788 remove_attribute(Particle self, StringKey name)
4789 remove_attribute(Particle self, ObjectKey name)
4790 remove_attribute(Particle self, IMP::WeakObjectKey name)
4791 remove_attribute(Particle self, SparseStringKey name)
4792 remove_attribute(Particle self, SparseIntKey name)
4793 remove_attribute(Particle self, SparseFloatKey name)
4794 remove_attribute(Particle self, SparseParticleIndexKey name)
4795 remove_attribute(Particle self, ParticleIndexKey k)
4797 return _IMP_kernel.Particle_remove_attribute(self, *args)
4799 def get_particle_keys(self):
4800 r"""get_particle_keys(Particle self) -> IMP::ParticleIndexKeys"""
4801 return _IMP_kernel.Particle_get_particle_keys(self)
4803 def show(self, *args):
4804 r"""show(Particle self, _ostream out=std::cout)"""
4805 return _IMP_kernel.Particle_show(self, *args)
4807 def get_is_active(self):
4808 r"""get_is_active(Particle self) -> bool"""
4809 return _IMP_kernel.Particle_get_is_active(self)
4812 r"""get_index(Particle self) -> ParticleIndex"""
4813 return _IMP_kernel.Particle_get_index(self)
4815 def __eq__(self, *args):
4817 __eq__(Particle self, Particle o) -> bool
4818 __eq__(Particle self, Decorator d) -> bool
4820 return _IMP_kernel.Particle___eq__(self, *args)
4822 def __ne__(self, *args):
4824 __ne__(Particle self, Particle o) -> bool
4825 __ne__(Particle self, Decorator d) -> bool
4827 return _IMP_kernel.Particle___ne__(self, *args)
4829 def __le__(self, *args):
4831 __le__(Particle self, Particle o) -> bool
4832 __le__(Particle self, Decorator d) -> bool
4834 return _IMP_kernel.Particle___le__(self, *args)
4836 def __lt__(self, *args):
4838 __lt__(Particle self, Particle o) -> bool
4839 __lt__(Particle self, Decorator d) -> bool
4841 return _IMP_kernel.Particle___lt__(self, *args)
4843 def __ge__(self, *args):
4845 __ge__(Particle self, Particle o) -> bool
4846 __ge__(Particle self, Decorator d) -> bool
4848 return _IMP_kernel.Particle___ge__(self, *args)
4850 def __gt__(self, *args):
4852 __gt__(Particle self, Particle o) -> bool
4853 __gt__(Particle self, Decorator d) -> bool
4855 return _IMP_kernel.Particle___gt__(self, *args)
4857 __hash__ = ModelObject.__hash__
4861 r"""__str__(Particle self) -> std::string"""
4862 return _IMP_kernel.Particle___str__(self)
4865 r"""__repr__(Particle self) -> std::string"""
4866 return _IMP_kernel.Particle___repr__(self)
4870 return _object_cast_to_Particle(o)
4873 def _get_as_binary(self):
4874 r"""_get_as_binary(Particle self) -> PyObject *"""
4875 return _IMP_kernel.Particle__get_as_binary(self)
4877 def _set_from_binary(self, p):
4878 r"""_set_from_binary(Particle self, PyObject * p)"""
4879 return _IMP_kernel.Particle__set_from_binary(self, p)
4881 def __getstate__(self):
4882 p = self._get_as_binary()
4883 if len(self.__dict__) > 1:
4884 d = self.__dict__.copy()
4889 def __setstate__(self, p):
4890 if not hasattr(self,
'this'):
4892 if isinstance(p, tuple):
4894 self.__dict__.update(d)
4895 return self._set_from_binary(p)
4899 _IMP_kernel.Particle_swigregister(Particle)
4900 class _ParticleAdaptor(_InputAdaptor):
4901 r"""Proxy of C++ IMP::ParticleAdaptor class."""
4903 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
4904 __repr__ = _swig_repr
4906 def __init__(self, *args):
4908 __init__(_ParticleAdaptor self) -> _ParticleAdaptor
4909 __init__(_ParticleAdaptor self, Particle p) -> _ParticleAdaptor
4910 __init__(_ParticleAdaptor self, Decorator d) -> _ParticleAdaptor
4912 _IMP_kernel._ParticleAdaptor_swiginit(self, _IMP_kernel.new__ParticleAdaptor(*args))
4914 def get_model(self):
4915 r"""get_model(_ParticleAdaptor self) -> Model"""
4916 return _IMP_kernel._ParticleAdaptor_get_model(self)
4918 def get_particle_index(self):
4919 r"""get_particle_index(_ParticleAdaptor self) -> ParticleIndex"""
4920 return _IMP_kernel._ParticleAdaptor_get_particle_index(self)
4921 __swig_destroy__ = _IMP_kernel.delete__ParticleAdaptor
4924 _IMP_kernel._ParticleAdaptor_swigregister(_ParticleAdaptor)
4925 class _DependencyGraphVertexIndex(object):
4926 r"""Proxy of C++ IMP::DependencyGraphVertexIndex class."""
4928 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
4929 __repr__ = _swig_repr
4932 r"""__init__(_DependencyGraphVertexIndex self) -> _DependencyGraphVertexIndex"""
4933 _IMP_kernel._DependencyGraphVertexIndex_swiginit(self, _IMP_kernel.new__DependencyGraphVertexIndex())
4934 __swig_destroy__ = _IMP_kernel.delete__DependencyGraphVertexIndex
4937 _IMP_kernel._DependencyGraphVertexIndex_swigregister(_DependencyGraphVertexIndex)
4939 def show_as_graphviz(name, out):
4940 r"""show_as_graphviz(IMP::DependencyGraph const & name, TextOutput out)"""
4941 return _IMP_kernel.show_as_graphviz(name, out)
4943 def get_vertex_index(g):
4944 r"""get_vertex_index(IMP::DependencyGraph const & g) -> _DependencyGraphVertexIndex"""
4945 return _IMP_kernel.get_vertex_index(g)
4948 r"""get_dependency_graph(Model m) -> IMP::DependencyGraph"""
4949 return _IMP_kernel.get_dependency_graph(m)
4952 r"""get_pruned_dependency_graph(Model m) -> IMP::DependencyGraph"""
4953 return _IMP_kernel.get_pruned_dependency_graph(m)
4955 def get_dependent_particles(p, all, dg, index):
4956 r"""get_dependent_particles(ModelObject p, IMP::ModelObjectsTemp const & all, IMP::DependencyGraph const & dg, _DependencyGraphVertexIndex index) -> IMP::ParticlesTemp"""
4957 return _IMP_kernel.get_dependent_particles(p, all, dg, index)
4959 def get_required_score_states(*args):
4961 get_required_score_states(IMP::ModelObjectsTemp const & mos, IMP::ScoreStatesTemp exclude=IMP::ScoreStatesTemp()) -> IMP::ScoreStatesTemp
4962 get_required_score_states(ModelObject p, IMP::ModelObjectsTemp const & all, IMP::DependencyGraph const & dg, _DependencyGraphVertexIndex index) -> IMP::ScoreStatesTemp
4963 get_required_score_states(Model m, ParticleIndex pi) -> IMP::ScoreStatesTemp
4965 return _IMP_kernel.get_required_score_states(*args)
4966 class ScoringFunction(ModelObject):
4967 r"""Proxy of C++ IMP::ScoringFunction class."""
4969 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
4971 def do_add_score_and_derivatives(self, sa, ss):
4972 r"""do_add_score_and_derivatives(ScoringFunction self, ScoreAccumulator sa, IMP::ScoreStatesTemp const & ss)"""
4973 return _IMP_kernel.ScoringFunction_do_add_score_and_derivatives(self, sa, ss)
4975 def do_add_score_and_derivatives_moved(self, sa, moved_pis, reset_pis, ss):
4976 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)"""
4977 return _IMP_kernel.ScoringFunction_do_add_score_and_derivatives_moved(self, sa, moved_pis, reset_pis, ss)
4979 def get_score_accumulator_if_below(self, deriv, max):
4980 r"""get_score_accumulator_if_below(ScoringFunction self, bool deriv, double max) -> ScoreAccumulator"""
4981 return _IMP_kernel.ScoringFunction_get_score_accumulator_if_below(self, deriv, max)
4983 def get_score_accumulator_if_good(self, deriv):
4984 r"""get_score_accumulator_if_good(ScoringFunction self, bool deriv) -> ScoreAccumulator"""
4985 return _IMP_kernel.ScoringFunction_get_score_accumulator_if_good(self, deriv)
4987 def get_score_accumulator(self, deriv):
4988 r"""get_score_accumulator(ScoringFunction self, bool deriv) -> ScoreAccumulator"""
4989 return _IMP_kernel.ScoringFunction_get_score_accumulator(self, deriv)
4991 def __init__(self, *args):
4993 __init__(ScoringFunction self, Model m, std::string name) -> ScoringFunction
4994 __init__(ScoringFunction self) -> ScoringFunction
4996 if self.__class__ == ScoringFunction:
5000 _IMP_kernel.ScoringFunction_swiginit(self, _IMP_kernel.new_ScoringFunction(_self, *args))
5002 if self.__class__ != ScoringFunction:
5003 _director_objects.register(self)
5008 def do_get_outputs(self):
5009 r"""do_get_outputs(ScoringFunction self) -> IMP::ModelObjectsTemp"""
5010 return _IMP_kernel.ScoringFunction_do_get_outputs(self)
5012 def evaluate(self, derivatives):
5013 r"""evaluate(ScoringFunction self, bool derivatives) -> double"""
5014 return _IMP_kernel.ScoringFunction_evaluate(self, derivatives)
5016 def evaluate_if_good(self, derivatives):
5017 r"""evaluate_if_good(ScoringFunction self, bool derivatives) -> double"""
5018 return _IMP_kernel.ScoringFunction_evaluate_if_good(self, derivatives)
5020 def evaluate_if_below(self, derivatives, max):
5021 r"""evaluate_if_below(ScoringFunction self, bool derivatives, double max) -> double"""
5022 return _IMP_kernel.ScoringFunction_evaluate_if_below(self, derivatives, max)
5024 def evaluate_moved(self, derivatives, moved_pis, reset_pis):
5025 r"""evaluate_moved(ScoringFunction self, bool derivatives, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis) -> double"""
5026 return _IMP_kernel.ScoringFunction_evaluate_moved(self, derivatives, moved_pis, reset_pis)
5028 def evaluate_moved_if_below(self, derivatives, moved_pis, reset_pis, max):
5029 r"""evaluate_moved_if_below(ScoringFunction self, bool derivatives, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis, double max) -> double"""
5030 return _IMP_kernel.ScoringFunction_evaluate_moved_if_below(self, derivatives, moved_pis, reset_pis, max)
5032 def evaluate_moved_if_good(self, derivatives, moved_pis, reset_pis):
5033 r"""evaluate_moved_if_good(ScoringFunction self, bool derivatives, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis) -> double"""
5034 return _IMP_kernel.ScoringFunction_evaluate_moved_if_good(self, derivatives, moved_pis, reset_pis)
5036 def get_had_good_score(self):
5037 r"""get_had_good_score(ScoringFunction self) -> bool"""
5038 return _IMP_kernel.ScoringFunction_get_had_good_score(self)
5040 def get_last_score(self):
5041 r"""get_last_score(ScoringFunction self) -> double"""
5042 return _IMP_kernel.ScoringFunction_get_last_score(self)
5045 r"""create_restraints(ScoringFunction self) -> IMP::Restraints"""
5046 return _IMP_kernel.ScoringFunction_create_restraints(self)
5049 r"""__str__(ScoringFunction self) -> std::string"""
5050 return _IMP_kernel.ScoringFunction___str__(self)
5053 r"""__repr__(ScoringFunction self) -> std::string"""
5054 return _IMP_kernel.ScoringFunction___repr__(self)
5058 return _object_cast_to_ScoringFunction(o)
5061 def get_type_name(self):
5062 return self.__class__.__name__
5063 def do_show(self, out):
5065 def get_version_info(self):
5067 return VersionInfo(self.__module__,
5074 return _object_cast_to_ScoringFunction(o)
5076 __swig_destroy__ = _IMP_kernel.delete_ScoringFunction
5077 def __disown__(self):
5079 _IMP_kernel.disown_ScoringFunction(self)
5080 return weakref.proxy(self)
5082 def do_destroy(self):
5083 r"""do_destroy(ScoringFunction self)"""
5084 return _IMP_kernel.ScoringFunction_do_destroy(self)
5086 def handle_set_has_required_score_states(self, arg0):
5087 r"""handle_set_has_required_score_states(ScoringFunction self, bool arg0)"""
5088 return _IMP_kernel.ScoringFunction_handle_set_has_required_score_states(self, arg0)
5090 def do_get_inputs(self):
5091 r"""do_get_inputs(ScoringFunction self) -> IMP::ModelObjectsTemp"""
5092 return _IMP_kernel.ScoringFunction_do_get_inputs(self)
5094 def do_get_interactions(self):
5095 r"""do_get_interactions(ScoringFunction self) -> IMP::ModelObjectsTemps"""
5096 return _IMP_kernel.ScoringFunction_do_get_interactions(self)
5099 _IMP_kernel.ScoringFunction_swigregister(ScoringFunction)
5103 create_decomposition(IMP::RestraintsTemp const & rs) -> IMP::Restraints
5104 create_decomposition(ScoringFunction sf) -> IMP::ScoringFunctions
5106 return _IMP_kernel.create_decomposition(*args)
5107 class _ScoringFunctionAdaptor(_InputAdaptor):
5108 r"""Proxy of C++ IMP::ScoringFunctionAdaptor class."""
5110 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5111 __repr__ = _swig_repr
5113 def __init__(self, *args):
5115 __init__(_ScoringFunctionAdaptor self) -> _ScoringFunctionAdaptor
5116 __init__(_ScoringFunctionAdaptor self, ScoringFunction sf) -> _ScoringFunctionAdaptor
5117 __init__(_ScoringFunctionAdaptor self, IMP::RestraintsTemp const & sf) -> _ScoringFunctionAdaptor
5118 __init__(_ScoringFunctionAdaptor self, IMP::Restraints const & sf) -> _ScoringFunctionAdaptor
5119 __init__(_ScoringFunctionAdaptor self, Restraint sf) -> _ScoringFunctionAdaptor
5121 _IMP_kernel._ScoringFunctionAdaptor_swiginit(self, _IMP_kernel.new__ScoringFunctionAdaptor(*args))
5122 __swig_destroy__ = _IMP_kernel.delete__ScoringFunctionAdaptor
5125 _IMP_kernel._ScoringFunctionAdaptor_swigregister(_ScoringFunctionAdaptor)
5128 r"""show_restraint_hierarchy(_ScoringFunctionAdaptor rs, _ostream out=std::cout)"""
5129 return _IMP_kernel.show_restraint_hierarchy(*args)
5130 class Undecorator(Object):
5131 r"""Proxy of C++ IMP::Undecorator class."""
5133 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5135 def __init__(self, m, name):
5136 r"""__init__(Undecorator self, Model m, std::string name) -> Undecorator"""
5137 if self.__class__ == Undecorator:
5141 _IMP_kernel.Undecorator_swiginit(self, _IMP_kernel.new_Undecorator(_self, m, name))
5143 if self.__class__ != Undecorator:
5144 _director_objects.register(self)
5149 def teardown(self, pi):
5150 r"""teardown(Undecorator self, ParticleIndex pi)"""
5151 return _IMP_kernel.Undecorator_teardown(self, pi)
5154 r"""__str__(Undecorator self) -> std::string"""
5155 return _IMP_kernel.Undecorator___str__(self)
5158 r"""__repr__(Undecorator self) -> std::string"""
5159 return _IMP_kernel.Undecorator___repr__(self)
5163 return _object_cast_to_Undecorator(o)
5166 def get_type_name(self):
5167 return self.__class__.__name__
5168 def do_show(self, out):
5170 def get_version_info(self):
5172 return VersionInfo(self.__module__,
5179 return _object_cast_to_Undecorator(o)
5181 __swig_destroy__ = _IMP_kernel.delete_Undecorator
5182 def __disown__(self):
5184 _IMP_kernel.disown_Undecorator(self)
5185 return weakref.proxy(self)
5187 def do_destroy(self):
5188 r"""do_destroy(Undecorator self)"""
5189 return _IMP_kernel.Undecorator_do_destroy(self)
5192 _IMP_kernel.Undecorator_swigregister(Undecorator)
5193 class Model(Object):
5194 r"""Proxy of C++ IMP::Model class."""
5196 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5198 def __init__(self, *args):
5199 r"""__init__(Model self, std::string name="Model %1%") -> Model"""
5200 _IMP_kernel.Model_swiginit(self, _IMP_kernel.new_Model(*args))
5202 if self
not in _models_set:
5203 _models_set.add(self)
5208 def clear_particle_caches(self, pi):
5209 r"""clear_particle_caches(Model self, ParticleIndex pi)"""
5210 return _IMP_kernel.Model_clear_particle_caches(self, pi)
5213 r"""add_particle(Model self, std::string name) -> ParticleIndex"""
5214 return _IMP_kernel.Model_add_particle(self, name)
5216 def get_particle_name(self, pi):
5217 r"""get_particle_name(Model self, ParticleIndex pi) -> std::string"""
5218 return _IMP_kernel.Model_get_particle_name(self, pi)
5220 def add_undecorator(self, pi, d):
5221 r"""add_undecorator(Model self, ParticleIndex pi, Undecorator d)"""
5222 return _IMP_kernel.Model_add_undecorator(self, pi, d)
5224 def get_dependent_restraints_uncached(self, pi):
5225 r"""get_dependent_restraints_uncached(Model self, ParticleIndex pi) -> IMP::RestraintsTemp"""
5226 return _IMP_kernel.Model_get_dependent_restraints_uncached(self, pi)
5228 def get_dependent_particles_uncached(self, pi):
5229 r"""get_dependent_particles_uncached(Model self, ParticleIndex pi) -> IMP::ParticlesTemp"""
5230 return _IMP_kernel.Model_get_dependent_particles_uncached(self, pi)
5232 def get_dependent_score_states_uncached(self, pi):
5233 r"""get_dependent_score_states_uncached(Model self, ParticleIndex pi) -> IMP::ScoreStatesTemp"""
5234 return _IMP_kernel.Model_get_dependent_score_states_uncached(self, pi)
5235 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)
5236 def __set_score_states(self, obj): _list_util.set_varlist(self.score_states, obj)
5237 def __del_score_states(self): _list_util.del_varlist(self.score_states)
5238 score_states = property(__get_score_states, __set_score_states, __del_score_states, doc=
"List of ##ucnames")
5240 def remove_score_state(self, d):
5241 r"""remove_score_state(Model self, ScoreState d)"""
5242 return _IMP_kernel.Model_remove_score_state(self, d)
5244 def _python_index_score_state(self, d, start, stop):
5245 r"""_python_index_score_state(Model self, ScoreState d, unsigned int start, unsigned int stop) -> unsigned int"""
5246 return _IMP_kernel.Model__python_index_score_state(self, d, start, stop)
5248 def remove_score_states(self, d):
5249 r"""remove_score_states(Model self, IMP::ScoreStates const & d)"""
5250 return _IMP_kernel.Model_remove_score_states(self, d)
5252 def set_score_states(self, ps):
5253 r"""set_score_states(Model self, IMP::ScoreStates const & ps)"""
5254 return _IMP_kernel.Model_set_score_states(self, ps)
5256 def set_score_states_order(self, objs):
5257 r"""set_score_states_order(Model self, IMP::ScoreStates const & objs)"""
5258 return _IMP_kernel.Model_set_score_states_order(self, objs)
5260 def add_score_state(self, obj):
5261 r"""add_score_state(Model self, ScoreState obj) -> unsigned int"""
5262 return _IMP_kernel.Model_add_score_state(self, obj)
5264 def add_score_states(self, objs):
5265 r"""add_score_states(Model self, IMP::ScoreStates const & objs)"""
5266 return _IMP_kernel.Model_add_score_states(self, objs)
5268 def clear_score_states(self):
5269 r"""clear_score_states(Model self)"""
5270 return _IMP_kernel.Model_clear_score_states(self)
5272 def get_number_of_score_states(self):
5273 r"""get_number_of_score_states(Model self) -> unsigned int"""
5274 return _IMP_kernel.Model_get_number_of_score_states(self)
5276 def get_has_score_states(self):
5277 r"""get_has_score_states(Model self) -> bool"""
5278 return _IMP_kernel.Model_get_has_score_states(self)
5280 def get_score_state(self, i):
5281 r"""get_score_state(Model self, unsigned int i) -> ScoreState"""
5282 return _IMP_kernel.Model_get_score_state(self, i)
5284 def get_score_states(self):
5285 r"""get_score_states(Model self) -> IMP::ScoreStates"""
5286 return _IMP_kernel.Model_get_score_states(self)
5288 def erase_score_state(self, i):
5289 r"""erase_score_state(Model self, unsigned int i)"""
5290 return _IMP_kernel.Model_erase_score_state(self, i)
5292 def reserve_score_states(self, sz):
5293 r"""reserve_score_states(Model self, unsigned int sz)"""
5294 return _IMP_kernel.Model_reserve_score_states(self, sz)
5297 r"""update(Model self)"""
5298 return _IMP_kernel.Model_update(self)
5300 def add_cache_attribute(self, *args):
5302 add_cache_attribute(Model self, FloatKey attribute_key, ParticleIndex particle, IMP::Float value)
5303 add_cache_attribute(Model self, IntKey attribute_key, ParticleIndex particle, IMP::Int value)
5304 add_cache_attribute(Model self, FloatsKey attribute_key, ParticleIndex particle, IMP::Floats value)
5305 add_cache_attribute(Model self, IntsKey attribute_key, ParticleIndex particle, IMP::Ints value)
5306 add_cache_attribute(Model self, StringKey attribute_key, ParticleIndex particle, IMP::String value)
5307 add_cache_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle, IMP::ParticleIndexes value)
5308 add_cache_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle, ParticleIndex value)
5309 add_cache_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle, Object value)
5310 add_cache_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle, Object value)
5312 return _IMP_kernel.Model_add_cache_attribute(self, *args)
5314 def add_attribute(self, *args):
5316 add_attribute(Model self, FloatKey attribute_key, ParticleIndex particle, IMP::Float value)
5317 add_attribute(Model self, IntKey attribute_key, ParticleIndex particle, IMP::Int value)
5318 add_attribute(Model self, FloatsKey attribute_key, ParticleIndex particle, IMP::Floats value)
5319 add_attribute(Model self, IntsKey attribute_key, ParticleIndex particle, IMP::Ints value)
5320 add_attribute(Model self, StringKey attribute_key, ParticleIndex particle, IMP::String value)
5321 add_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle, IMP::ParticleIndexes value)
5322 add_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle, ParticleIndex value)
5323 add_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle, Object value)
5324 add_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle, Object value)
5325 add_attribute(Model self, SparseStringKey attribute_key, ParticleIndex particle, IMP::String value)
5326 add_attribute(Model self, SparseIntKey attribute_key, ParticleIndex particle, IMP::Int value)
5327 add_attribute(Model self, SparseFloatKey attribute_key, ParticleIndex particle, IMP::Float value)
5328 add_attribute(Model self, SparseParticleIndexKey attribute_key, ParticleIndex particle, ParticleIndex value)
5330 return _IMP_kernel.Model_add_attribute(self, *args)
5332 def remove_attribute(self, *args):
5334 remove_attribute(Model self, FloatKey attribute_key, ParticleIndex particle)
5335 remove_attribute(Model self, IntKey attribute_key, ParticleIndex particle)
5336 remove_attribute(Model self, FloatsKey attribute_key, ParticleIndex particle)
5337 remove_attribute(Model self, IntsKey attribute_key, ParticleIndex particle)
5338 remove_attribute(Model self, StringKey attribute_key, ParticleIndex particle)
5339 remove_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle)
5340 remove_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle)
5341 remove_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle)
5342 remove_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle)
5343 remove_attribute(Model self, SparseStringKey attribute_key, ParticleIndex particle)
5344 remove_attribute(Model self, SparseIntKey attribute_key, ParticleIndex particle)
5345 remove_attribute(Model self, SparseFloatKey attribute_key, ParticleIndex particle)
5346 remove_attribute(Model self, SparseParticleIndexKey attribute_key, ParticleIndex particle)
5348 return _IMP_kernel.Model_remove_attribute(self, *args)
5350 def get_has_attribute(self, *args):
5352 get_has_attribute(Model self, FloatKey attribute_key, ParticleIndex particle) -> bool
5353 get_has_attribute(Model self, IntKey attribute_key, ParticleIndex particle) -> bool
5354 get_has_attribute(Model self, FloatsKey attribute_key, ParticleIndex particle) -> bool
5355 get_has_attribute(Model self, IntsKey attribute_key, ParticleIndex particle) -> bool
5356 get_has_attribute(Model self, StringKey attribute_key, ParticleIndex particle) -> bool
5357 get_has_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle) -> bool
5358 get_has_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle) -> bool
5359 get_has_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle) -> bool
5360 get_has_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle) -> bool
5361 get_has_attribute(Model self, SparseStringKey attribute_key, ParticleIndex particle) -> bool
5362 get_has_attribute(Model self, SparseIntKey attribute_key, ParticleIndex particle) -> bool
5363 get_has_attribute(Model self, SparseFloatKey attribute_key, ParticleIndex particle) -> bool
5364 get_has_attribute(Model self, SparseParticleIndexKey attribute_key, ParticleIndex particle) -> bool
5366 return _IMP_kernel.Model_get_has_attribute(self, *args)
5368 def set_attribute(self, *args):
5370 set_attribute(Model self, FloatKey attribute_key, ParticleIndex particle, IMP::Float value)
5371 set_attribute(Model self, IntKey attribute_key, ParticleIndex particle, IMP::Int value)
5372 set_attribute(Model self, FloatsKey attribute_key, ParticleIndex particle, IMP::Floats value)
5373 set_attribute(Model self, IntsKey attribute_key, ParticleIndex particle, IMP::Ints value)
5374 set_attribute(Model self, StringKey attribute_key, ParticleIndex particle, IMP::String value)
5375 set_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle, IMP::ParticleIndexes value)
5376 set_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle, ParticleIndex value)
5377 set_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle, Object value)
5378 set_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle, Object value)
5379 set_attribute(Model self, SparseStringKey attribute_key, ParticleIndex particle, IMP::String value)
5380 set_attribute(Model self, SparseIntKey attribute_key, ParticleIndex particle, IMP::Int value)
5381 set_attribute(Model self, SparseFloatKey attribute_key, ParticleIndex particle, IMP::Float value)
5382 set_attribute(Model self, SparseParticleIndexKey attribute_key, ParticleIndex particle, ParticleIndex value)
5384 return _IMP_kernel.Model_set_attribute(self, *args)
5386 def get_attribute(self, *args):
5388 get_attribute(Model self, FloatKey attribute_key, ParticleIndex particle) -> IMP::Float
5389 get_attribute(Model self, IntKey attribute_key, ParticleIndex particle) -> IMP::Int
5390 get_attribute(Model self, FloatsKey attribute_key, ParticleIndex particle) -> IMP::Floats
5391 get_attribute(Model self, IntsKey attribute_key, ParticleIndex particle) -> IMP::Ints
5392 get_attribute(Model self, StringKey attribute_key, ParticleIndex particle) -> IMP::String
5393 get_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle) -> IMP::ParticleIndexes
5394 get_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle) -> ParticleIndex
5395 get_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle) -> Object
5396 get_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle) -> Object
5397 get_attribute(Model self, SparseStringKey attribute_key, ParticleIndex particle) -> IMP::String
5398 get_attribute(Model self, SparseIntKey attribute_key, ParticleIndex particle) -> IMP::Int
5399 get_attribute(Model self, SparseFloatKey attribute_key, ParticleIndex particle) -> IMP::Float
5400 get_attribute(Model self, SparseParticleIndexKey attribute_key, ParticleIndex particle) -> ParticleIndex
5402 return _IMP_kernel.Model_get_attribute(self, *args)
5404 def set_is_optimized(self, arg2, arg3, arg4):
5405 r"""set_is_optimized(Model self, FloatKey arg2, ParticleIndex arg3, bool arg4)"""
5406 return _IMP_kernel.Model_set_is_optimized(self, arg2, arg3, arg4)
5408 def add_to_derivative(self, k, particle, v, da):
5409 r"""add_to_derivative(Model self, FloatKey k, ParticleIndex particle, double v, DerivativeAccumulator da)"""
5410 return _IMP_kernel.Model_add_to_derivative(self, k, particle, v, da)
5412 def get_particle(self, p):
5413 r"""get_particle(Model self, ParticleIndex p) -> Particle"""
5414 return _IMP_kernel.Model_get_particle(self, p)
5416 def get_has_particle(self, p):
5417 r"""get_has_particle(Model self, ParticleIndex p) -> bool"""
5418 return _IMP_kernel.Model_get_has_particle(self, p)
5421 r"""get_particle_indexes(Model self) -> IMP::ParticleIndexes"""
5422 return _IMP_kernel.Model_get_particle_indexes(self)
5424 def get_model_objects(self):
5425 r"""get_model_objects(Model self) -> IMP::ModelObjectsTemp"""
5426 return _IMP_kernel.Model_get_model_objects(self)
5428 def remove_particle(self, pi):
5429 r"""remove_particle(Model self, ParticleIndex pi)"""
5430 return _IMP_kernel.Model_remove_particle(self, pi)
5432 def add_data(self, mk, o):
5433 r"""add_data(Model self, ModelKey mk, Object o)"""
5434 return _IMP_kernel.Model_add_data(self, mk, o)
5436 def get_data(self, mk):
5437 r"""get_data(Model self, ModelKey mk) -> Object"""
5438 return _IMP_kernel.Model_get_data(self, mk)
5440 def remove_data(self, mk):
5441 r"""remove_data(Model self, ModelKey mk)"""
5442 return _IMP_kernel.Model_remove_data(self, mk)
5444 def get_has_data(self, mk):
5445 r"""get_has_data(Model self, ModelKey mk) -> bool"""
5446 return _IMP_kernel.Model_get_has_data(self, mk)
5449 r"""get_age(Model self) -> unsigned int"""
5450 return _IMP_kernel.Model_get_age(self)
5452 def get_trigger_last_updated(self, tk):
5453 r"""get_trigger_last_updated(Model self, TriggerKey tk) -> unsigned int"""
5454 return _IMP_kernel.Model_get_trigger_last_updated(self, tk)
5456 def set_trigger_updated(self, tk):
5457 r"""set_trigger_updated(Model self, TriggerKey tk)"""
5458 return _IMP_kernel.Model_set_trigger_updated(self, tk)
5460 def get_dependencies_updated(self):
5461 r"""get_dependencies_updated(Model self) -> unsigned int"""
5462 return _IMP_kernel.Model_get_dependencies_updated(self)
5464 def save_dependencies(self):
5465 r"""save_dependencies(Model self)"""
5466 return _IMP_kernel.Model_save_dependencies(self)
5468 def restore_dependencies(self):
5469 r"""restore_dependencies(Model self)"""
5470 return _IMP_kernel.Model_restore_dependencies(self)
5472 def get_particles_size(self):
5473 r"""get_particles_size(Model self) -> unsigned int"""
5474 return _IMP_kernel.Model_get_particles_size(self)
5476 def get_unique_id(self):
5477 r"""get_unique_id(Model self) -> uint32_t"""
5478 return _IMP_kernel.Model_get_unique_id(self)
5481 def get_by_unique_id(id):
5482 r"""get_by_unique_id(uint32_t id) -> Model"""
5483 return _IMP_kernel.Model_get_by_unique_id(id)
5485 def get_version_info(self):
5486 r"""get_version_info(Model self) -> VersionInfo"""
5487 return _IMP_kernel.Model_get_version_info(self)
5488 __swig_destroy__ = _IMP_kernel.delete_Model
5490 r"""__del__(Model self)"""
5492 _director_objects.cleanup()
5498 def do_destroy(self):
5499 r"""do_destroy(Model self)"""
5500 return _IMP_kernel.Model_do_destroy(self)
5503 r"""__str__(Model self) -> std::string"""
5504 return _IMP_kernel.Model___str__(self)
5507 r"""__repr__(Model self) -> std::string"""
5508 return _IMP_kernel.Model___repr__(self)
5512 return _object_cast_to_Model(o)
5515 def _get_as_binary(self):
5516 r"""_get_as_binary(Model self) -> PyObject *"""
5517 return _IMP_kernel.Model__get_as_binary(self)
5519 def _set_from_binary(self, p):
5520 r"""_set_from_binary(Model self, PyObject * p)"""
5521 return _IMP_kernel.Model__set_from_binary(self, p)
5523 def __getstate__(self):
5524 p = self._get_as_binary()
5525 if len(self.__dict__) > 1:
5526 d = self.__dict__.copy()
5531 def __setstate__(self, p):
5532 if not hasattr(self,
'this'):
5534 if isinstance(p, tuple):
5536 self.__dict__.update(d)
5537 return self._set_from_binary(p)
5541 """Get the model's attribute array for IntKey k as a NumPy array.
5542 The array is indexed by ParticleIndex; particles that don't have
5543 this attribute will either be off the end of the array or will have
5545 This is a NumPy view that shares memory with the Model. Thus,
5546 any changes to values in this list will be reflected in the Model.
5547 Also, if the Model attribute array moves in memory (e.g. if particles
5548 or attributes are added) this array will be invalidated, so it is
5549 unsafe to keep it around long term.
5551 return _get_ints_numpy(self, k, self)
5554 """Get the model's attribute array for FloatKey k as a NumPy array.
5555 See Model::get_ints_numpy() for more details."""
5556 return _get_floats_numpy(self, k, self)
5559 """Get the model's attribute derivatives array for FloatKey k
5560 as a NumPy array. See Model::get_ints_numpy() for more details."""
5561 return _get_derivatives_numpy(self, k, self)
5564 """Get the model's XYZR attribute arrays as NumPy arrays.
5565 The attribute arrays for Cartesian coordinates and radii are
5566 stored separately from those for other FloatKeys. This function
5567 returns a tuple of two NumPy arrays, the first of coordinates and
5568 the second of radii. See Model::get_ints_numpy() for more details."""
5569 return _get_spheres_numpy(self, self)
5572 """Get the model's XYZR attribute derivatives arrays as NumPy arrays.
5573 See Model::get_ints_numpy() for more details."""
5574 return _get_sphere_derivatives_numpy(self, self)
5578 _IMP_kernel.Model_swigregister(Model)
5580 r"""Proxy of C++ IMP::Decorator class."""
5582 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5583 __repr__ = _swig_repr
5585 def __init__(self, p):
5586 r"""__init__(Decorator self, _ParticleAdaptor p) -> Decorator"""
5587 _IMP_kernel.Decorator_swiginit(self, _IMP_kernel.new_Decorator(p))
5589 def __ne__(self, o):
5590 r"""__ne__(Decorator self, Object o) -> bool"""
5591 return _IMP_kernel.Decorator___ne__(self, o)
5593 def __lt__(self, o):
5594 r"""__lt__(Decorator self, Object o) -> bool"""
5595 return _IMP_kernel.Decorator___lt__(self, o)
5597 def __gt__(self, o):
5598 r"""__gt__(Decorator self, Object o) -> bool"""
5599 return _IMP_kernel.Decorator___gt__(self, o)
5601 def __ge__(self, o):
5602 r"""__ge__(Decorator self, Object o) -> bool"""
5603 return _IMP_kernel.Decorator___ge__(self, o)
5605 def __le__(self, o):
5606 r"""__le__(Decorator self, Object o) -> bool"""
5607 return _IMP_kernel.Decorator___le__(self, o)
5610 r"""get_particle(Decorator self) -> Particle"""
5611 return _IMP_kernel.Decorator_get_particle(self)
5613 def get_particle_index(self):
5614 r"""get_particle_index(Decorator self) -> ParticleIndex"""
5615 return _IMP_kernel.Decorator_get_particle_index(self)
5617 def get_model(self):
5618 m = _IMP_kernel.Decorator_get_model(self)
5619 if m
in _models_set:
5620 m = _models_set_get(m)
5625 def get_is_valid(self):
5626 r"""get_is_valid(Decorator self) -> bool"""
5627 return _IMP_kernel.Decorator_get_is_valid(self)
5630 r"""__hash__(Decorator self) -> std::size_t"""
5631 return _IMP_kernel.Decorator___hash__(self)
5633 def __eq__(self, *args):
5635 __eq__(Decorator self, Object o) -> bool
5636 __eq__(Decorator self, Decorator o) -> bool
5637 __eq__(Decorator self, Particle o) -> bool
5639 return _IMP_kernel.Decorator___eq__(self, *args)
5642 r"""__bool__(Decorator self) -> bool"""
5643 return _IMP_kernel.Decorator___bool__(self)
5645 __nonzero__ = __bool__
5647 __swig_destroy__ = _IMP_kernel.delete_Decorator
5650 _IMP_kernel.Decorator_swigregister(Decorator)
5652 def check_particle(m, pi):
5653 r"""check_particle(Model m, ParticleIndex pi)"""
5654 return _IMP_kernel.check_particle(m, pi)
5656 r"""Proxy of C++ IMP::UnaryFunction class."""
5658 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5660 def __init__(self, *args):
5661 r"""__init__(UnaryFunction self, std::string name="UnaryFunction%1%") -> UnaryFunction"""
5662 if self.__class__ == UnaryFunction:
5666 _IMP_kernel.UnaryFunction_swiginit(self, _IMP_kernel.new_UnaryFunction(_self, *args))
5668 if self.__class__ != UnaryFunction:
5669 _director_objects.register(self)
5674 def evaluate(self, feature):
5675 r"""evaluate(UnaryFunction self, double feature) -> double"""
5676 return _IMP_kernel.UnaryFunction_evaluate(self, feature)
5678 def evaluate_with_derivative(self, feature):
5679 r"""evaluate_with_derivative(UnaryFunction self, double feature) -> IMP::DerivativePair"""
5680 return _IMP_kernel.UnaryFunction_evaluate_with_derivative(self, feature)
5681 __swig_destroy__ = _IMP_kernel.delete_UnaryFunction
5684 r"""__str__(UnaryFunction self) -> std::string"""
5685 return _IMP_kernel.UnaryFunction___str__(self)
5688 r"""__repr__(UnaryFunction self) -> std::string"""
5689 return _IMP_kernel.UnaryFunction___repr__(self)
5693 return _object_cast_to_UnaryFunction(o)
5696 def get_type_name(self):
5697 return self.__class__.__name__
5698 def do_show(self, out):
5702 return VersionInfo(self.__module__,
5709 return _object_cast_to_UnaryFunction(o)
5711 def __disown__(self):
5713 _IMP_kernel.disown_UnaryFunction(self)
5714 return weakref.proxy(self)
5717 r"""do_destroy(UnaryFunction self)"""
5718 return _IMP_kernel.UnaryFunction_do_destroy(self)
5721 _IMP_kernel.UnaryFunction_swigregister(UnaryFunction)
5722 class OptimizerState(ModelObject):
5723 r"""Proxy of C++ IMP::OptimizerState class."""
5725 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5727 def __init__(self, *args):
5729 __init__(OptimizerState self, Model m, std::string name) -> OptimizerState
5730 __init__(OptimizerState self) -> OptimizerState
5732 if self.__class__ == OptimizerState:
5736 _IMP_kernel.OptimizerState_swiginit(self, _IMP_kernel.new_OptimizerState(_self, *args))
5738 if self.__class__ != OptimizerState:
5739 _director_objects.register(self)
5745 r"""update(OptimizerState self)"""
5746 return _IMP_kernel.OptimizerState_update(self)
5748 def set_is_optimizing(self, arg0):
5749 r"""set_is_optimizing(OptimizerState self, bool arg0)"""
5750 return _IMP_kernel.OptimizerState_set_is_optimizing(self, arg0)
5752 def get_optimizer(self):
5753 r"""get_optimizer(OptimizerState self) -> Optimizer"""
5754 return _IMP_kernel.OptimizerState_get_optimizer(self)
5756 def set_period(self, p):
5757 r"""set_period(OptimizerState self, unsigned int p)"""
5758 return _IMP_kernel.OptimizerState_set_period(self, p)
5760 def get_period(self):
5761 r"""get_period(OptimizerState self) -> unsigned int"""
5762 return _IMP_kernel.OptimizerState_get_period(self)
5765 r"""reset(OptimizerState self)"""
5766 return _IMP_kernel.OptimizerState_reset(self)
5768 def update_always(self):
5769 r"""update_always(OptimizerState self)"""
5770 return _IMP_kernel.OptimizerState_update_always(self)
5772 def get_number_of_updates(self):
5773 r"""get_number_of_updates(OptimizerState self) -> unsigned int"""
5774 return _IMP_kernel.OptimizerState_get_number_of_updates(self)
5776 def set_number_of_updates(self, n):
5777 r"""set_number_of_updates(OptimizerState self, unsigned int n)"""
5778 return _IMP_kernel.OptimizerState_set_number_of_updates(self, n)
5779 __swig_destroy__ = _IMP_kernel.delete_OptimizerState
5781 def do_update(self, arg0):
5782 r"""do_update(OptimizerState self, unsigned int arg0)"""
5783 return _IMP_kernel.OptimizerState_do_update(self, arg0)
5785 def do_set_is_optimizing(self, arg0):
5786 r"""do_set_is_optimizing(OptimizerState self, bool arg0)"""
5787 return _IMP_kernel.OptimizerState_do_set_is_optimizing(self, arg0)
5789 def do_get_inputs(self):
5790 r"""do_get_inputs(OptimizerState self) -> IMP::ModelObjectsTemp"""
5791 return _IMP_kernel.OptimizerState_do_get_inputs(self)
5793 def do_get_outputs(self):
5794 r"""do_get_outputs(OptimizerState self) -> IMP::ModelObjectsTemp"""
5795 return _IMP_kernel.OptimizerState_do_get_outputs(self)
5798 r"""__str__(OptimizerState self) -> std::string"""
5799 return _IMP_kernel.OptimizerState___str__(self)
5802 r"""__repr__(OptimizerState self) -> std::string"""
5803 return _IMP_kernel.OptimizerState___repr__(self)
5807 return _object_cast_to_OptimizerState(o)
5810 def get_type_name(self):
5811 return self.__class__.__name__
5812 def do_show(self, out):
5816 return VersionInfo(self.__module__,
5823 return _object_cast_to_OptimizerState(o)
5825 def __disown__(self):
5827 _IMP_kernel.disown_OptimizerState(self)
5828 return weakref.proxy(self)
5831 r"""do_destroy(OptimizerState self)"""
5832 return _IMP_kernel.OptimizerState_do_destroy(self)
5834 def handle_set_has_required_score_states(self, arg0):
5835 r"""handle_set_has_required_score_states(OptimizerState self, bool arg0)"""
5836 return _IMP_kernel.OptimizerState_handle_set_has_required_score_states(self, arg0)
5838 def do_get_interactions(self):
5839 r"""do_get_interactions(OptimizerState self) -> IMP::ModelObjectsTemps"""
5840 return _IMP_kernel.OptimizerState_do_get_interactions(self)
5843 _IMP_kernel.OptimizerState_swigregister(OptimizerState)
5844 class Refiner(_ParticleInputs,
Object):
5845 r"""Proxy of C++ IMP::Refiner class."""
5847 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5849 def __init__(self, *args):
5850 r"""__init__(Refiner self, std::string name="Refiner %1%", bool is_by_ref=False) -> Refiner"""
5851 if self.__class__ == Refiner:
5855 _IMP_kernel.Refiner_swiginit(self, _IMP_kernel.new_Refiner(_self, *args))
5857 if self.__class__ != Refiner:
5858 _director_objects.register(self)
5863 def get_can_refine(self, arg0):
5864 r"""get_can_refine(Refiner self, Particle arg0) -> bool"""
5865 return _IMP_kernel.Refiner_get_can_refine(self, arg0)
5867 def get_refined_indexes(self, m, pi):
5868 r"""get_refined_indexes(Refiner self, Model m, ParticleIndex pi) -> IMP::ParticleIndexes"""
5869 return _IMP_kernel.Refiner_get_refined_indexes(self, m, pi)
5871 def get_refined_indexes_by_ref(self, m, pi):
5872 r"""get_refined_indexes_by_ref(Refiner self, Model m, ParticleIndex pi) -> IMP::ParticleIndexes const &"""
5873 return _IMP_kernel.Refiner_get_refined_indexes_by_ref(self, m, pi)
5875 def get_is_by_ref_supported(self):
5876 r"""get_is_by_ref_supported(Refiner self) -> bool"""
5877 return _IMP_kernel.Refiner_get_is_by_ref_supported(self)
5879 def get_refined(self, *args):
5881 get_refined(Refiner self, Particle a) -> IMP::ParticlesTemp const
5882 get_refined(Refiner self, Particle a, unsigned int i) -> Particle
5884 return _IMP_kernel.Refiner_get_refined(self, *args)
5886 def get_number_of_refined(self, a):
5887 r"""get_number_of_refined(Refiner self, Particle a) -> unsigned int"""
5888 return _IMP_kernel.Refiner_get_number_of_refined(self, a)
5891 r"""__str__(Refiner self) -> std::string"""
5892 return _IMP_kernel.Refiner___str__(self)
5895 r"""__repr__(Refiner self) -> std::string"""
5896 return _IMP_kernel.Refiner___repr__(self)
5900 return _object_cast_to_Refiner(o)
5903 def get_type_name(self):
5904 return self.__class__.__name__
5905 def do_show(self, out):
5909 return VersionInfo(self.__module__,
5916 return _object_cast_to_Refiner(o)
5918 __swig_destroy__ = _IMP_kernel.delete_Refiner
5919 def __disown__(self):
5921 _IMP_kernel.disown_Refiner(self)
5922 return weakref.proxy(self)
5924 def do_get_inputs(self, m, pis):
5925 r"""do_get_inputs(Refiner self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
5926 return _IMP_kernel.Refiner_do_get_inputs(self, m, pis)
5929 r"""do_destroy(Refiner self)"""
5930 return _IMP_kernel.Refiner_do_destroy(self)
5933 _IMP_kernel.Refiner_swigregister(Refiner)
5934 class Optimizer(ModelObject):
5935 r"""Proxy of C++ IMP::Optimizer class."""
5937 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5939 def set_is_optimizing_states(self, tf):
5940 r"""set_is_optimizing_states(Optimizer self, bool tf)"""
5941 return _IMP_kernel.Optimizer_set_is_optimizing_states(self, tf)
5943 def get_optimizer_state_inputs(self):
5944 r"""get_optimizer_state_inputs(Optimizer self) -> IMP::ModelObjectsTemp"""
5945 return _IMP_kernel.Optimizer_get_optimizer_state_inputs(self)
5947 def do_get_inputs(self):
5948 r"""do_get_inputs(Optimizer self) -> IMP::ModelObjectsTemp"""
5949 return _IMP_kernel.Optimizer_do_get_inputs(self)
5951 def do_get_outputs(self):
5952 r"""do_get_outputs(Optimizer self) -> IMP::ModelObjectsTemp"""
5953 return _IMP_kernel.Optimizer_do_get_outputs(self)
5955 def __init__(self, *args):
5957 __init__(Optimizer self, Model m, std::string name="Optimizer %1%") -> Optimizer
5958 __init__(Optimizer self) -> Optimizer
5960 if self.__class__ == Optimizer:
5964 _IMP_kernel.Optimizer_swiginit(self, _IMP_kernel.new_Optimizer(_self, *args))
5966 if self.__class__ != Optimizer:
5967 _director_objects.register(self)
5972 def optimize(self, max_steps):
5973 r"""optimize(Optimizer self, unsigned int max_steps) -> double"""
5974 return _IMP_kernel.Optimizer_optimize(self, max_steps)
5976 def set_stop_on_good_score(self, tf):
5977 r"""set_stop_on_good_score(Optimizer self, bool tf)"""
5978 return _IMP_kernel.Optimizer_set_stop_on_good_score(self, tf)
5980 def get_stop_on_good_score(self):
5981 r"""get_stop_on_good_score(Optimizer self) -> bool"""
5982 return _IMP_kernel.Optimizer_get_stop_on_good_score(self)
5984 def get_last_score(self):
5985 r"""get_last_score(Optimizer self) -> double"""
5986 return _IMP_kernel.Optimizer_get_last_score(self)
5988 def get_scoring_function(self):
5989 r"""get_scoring_function(Optimizer self) -> ScoringFunction"""
5990 return _IMP_kernel.Optimizer_get_scoring_function(self)
5991 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)
5992 def __set_optimizer_states(self, obj): _list_util.set_varlist(self.optimizer_states, obj)
5993 def __del_optimizer_states(self): _list_util.del_varlist(self.optimizer_states)
5994 optimizer_states = property(__get_optimizer_states, __set_optimizer_states, __del_optimizer_states, doc=
"List of ##ucnames")
5996 def remove_optimizer_state(self, d):
5997 r"""remove_optimizer_state(Optimizer self, OptimizerState d)"""
5998 return _IMP_kernel.Optimizer_remove_optimizer_state(self, d)
6000 def _python_index_optimizer_state(self, d, start, stop):
6001 r"""_python_index_optimizer_state(Optimizer self, OptimizerState d, unsigned int start, unsigned int stop) -> unsigned int"""
6002 return _IMP_kernel.Optimizer__python_index_optimizer_state(self, d, start, stop)
6004 def remove_optimizer_states(self, d):
6005 r"""remove_optimizer_states(Optimizer self, IMP::OptimizerStates const & d)"""
6006 return _IMP_kernel.Optimizer_remove_optimizer_states(self, d)
6008 def set_optimizer_states(self, ps):
6009 r"""set_optimizer_states(Optimizer self, IMP::OptimizerStates const & ps)"""
6010 return _IMP_kernel.Optimizer_set_optimizer_states(self, ps)
6012 def set_optimizer_states_order(self, objs):
6013 r"""set_optimizer_states_order(Optimizer self, IMP::OptimizerStates const & objs)"""
6014 return _IMP_kernel.Optimizer_set_optimizer_states_order(self, objs)
6016 def add_optimizer_state(self, obj):
6017 r"""add_optimizer_state(Optimizer self, OptimizerState obj) -> unsigned int"""
6018 return _IMP_kernel.Optimizer_add_optimizer_state(self, obj)
6020 def add_optimizer_states(self, objs):
6021 r"""add_optimizer_states(Optimizer self, IMP::OptimizerStates const & objs)"""
6022 return _IMP_kernel.Optimizer_add_optimizer_states(self, objs)
6024 def clear_optimizer_states(self):
6025 r"""clear_optimizer_states(Optimizer self)"""
6026 return _IMP_kernel.Optimizer_clear_optimizer_states(self)
6028 def get_number_of_optimizer_states(self):
6029 r"""get_number_of_optimizer_states(Optimizer self) -> unsigned int"""
6030 return _IMP_kernel.Optimizer_get_number_of_optimizer_states(self)
6032 def get_has_optimizer_states(self):
6033 r"""get_has_optimizer_states(Optimizer self) -> bool"""
6034 return _IMP_kernel.Optimizer_get_has_optimizer_states(self)
6036 def get_optimizer_state(self, i):
6037 r"""get_optimizer_state(Optimizer self, unsigned int i) -> OptimizerState"""
6038 return _IMP_kernel.Optimizer_get_optimizer_state(self, i)
6040 def get_optimizer_states(self):
6041 r"""get_optimizer_states(Optimizer self) -> IMP::OptimizerStates"""
6042 return _IMP_kernel.Optimizer_get_optimizer_states(self)
6044 def erase_optimizer_state(self, i):
6045 r"""erase_optimizer_state(Optimizer self, unsigned int i)"""
6046 return _IMP_kernel.Optimizer_erase_optimizer_state(self, i)
6048 def reserve_optimizer_states(self, sz):
6049 r"""reserve_optimizer_states(Optimizer self, unsigned int sz)"""
6050 return _IMP_kernel.Optimizer_reserve_optimizer_states(self, sz)
6052 def set_scoring_function(self, sf):
6053 r"""set_scoring_function(Optimizer self, _ScoringFunctionAdaptor sf)"""
6054 return _IMP_kernel.Optimizer_set_scoring_function(self, sf)
6055 __swig_destroy__ = _IMP_kernel.delete_Optimizer
6057 r"""__del__(Optimizer self)"""
6059 _director_objects.cleanup()
6065 def do_optimize(self, ns):
6066 r"""do_optimize(Optimizer self, unsigned int ns) -> double"""
6067 return _IMP_kernel.Optimizer_do_optimize(self, ns)
6069 def update_states(self):
6070 r"""update_states(Optimizer self)"""
6071 return _IMP_kernel.Optimizer_update_states(self)
6074 r"""__str__(Optimizer self) -> std::string"""
6075 return _IMP_kernel.Optimizer___str__(self)
6078 r"""__repr__(Optimizer self) -> std::string"""
6079 return _IMP_kernel.Optimizer___repr__(self)
6083 return _object_cast_to_Optimizer(o)
6086 def get_type_name(self):
6087 return self.__class__.__name__
6088 def do_show(self, out):
6092 return VersionInfo(self.__module__,
6099 return _object_cast_to_Optimizer(o)
6101 def __disown__(self):
6103 _IMP_kernel.disown_Optimizer(self)
6104 return weakref.proxy(self)
6107 r"""do_destroy(Optimizer self)"""
6108 return _IMP_kernel.Optimizer_do_destroy(self)
6110 def handle_set_has_required_score_states(self, arg0):
6111 r"""handle_set_has_required_score_states(Optimizer self, bool arg0)"""
6112 return _IMP_kernel.Optimizer_handle_set_has_required_score_states(self, arg0)
6114 def do_get_interactions(self):
6115 r"""do_get_interactions(Optimizer self) -> IMP::ModelObjectsTemps"""
6116 return _IMP_kernel.Optimizer_do_get_interactions(self)
6119 _IMP_kernel.Optimizer_swigregister(Optimizer)
6120 class AttributeOptimizer(Optimizer):
6121 r"""Proxy of C++ IMP::AttributeOptimizer class."""
6123 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
6125 def __init__(self, *args):
6127 __init__(AttributeOptimizer self, Model m, std::string name="Optimizer %1%") -> AttributeOptimizer
6128 __init__(AttributeOptimizer self) -> AttributeOptimizer
6130 if self.__class__ == AttributeOptimizer:
6134 _IMP_kernel.AttributeOptimizer_swiginit(self, _IMP_kernel.new_AttributeOptimizer(_self, *args))
6136 if self.__class__ != AttributeOptimizer:
6137 _director_objects.register(self)
6142 def get_optimized_attributes(self):
6143 r"""get_optimized_attributes(AttributeOptimizer self) -> IMP::FloatIndexes"""
6144 return _IMP_kernel.AttributeOptimizer_get_optimized_attributes(self)
6146 def set_value(self, fi, v):
6147 r"""set_value(AttributeOptimizer self, FloatIndex fi, double v)"""
6148 return _IMP_kernel.AttributeOptimizer_set_value(self, fi, v)
6150 def get_value(self, fi):
6151 r"""get_value(AttributeOptimizer self, FloatIndex fi) -> IMP::Float"""
6152 return _IMP_kernel.AttributeOptimizer_get_value(self, fi)
6154 def get_derivative(self, fi):
6155 r"""get_derivative(AttributeOptimizer self, FloatIndex fi) -> IMP::Float"""
6156 return _IMP_kernel.AttributeOptimizer_get_derivative(self, fi)
6158 def get_width(self, k):
6159 r"""get_width(AttributeOptimizer self, FloatKey k) -> double"""
6160 return _IMP_kernel.AttributeOptimizer_get_width(self, k)
6162 def set_scaled_value(self, fi, v):
6163 r"""set_scaled_value(AttributeOptimizer self, FloatIndex fi, IMP::Float v)"""
6164 return _IMP_kernel.AttributeOptimizer_set_scaled_value(self, fi, v)
6166 def get_scaled_value(self, fi):
6167 r"""get_scaled_value(AttributeOptimizer self, FloatIndex fi) -> double"""
6168 return _IMP_kernel.AttributeOptimizer_get_scaled_value(self, fi)
6170 def get_scaled_derivative(self, fi):
6171 r"""get_scaled_derivative(AttributeOptimizer self, FloatIndex fi) -> double"""
6172 return _IMP_kernel.AttributeOptimizer_get_scaled_derivative(self, fi)
6174 def clear_range_cache(self):
6175 r"""clear_range_cache(AttributeOptimizer self)"""
6176 return _IMP_kernel.AttributeOptimizer_clear_range_cache(self)
6179 r"""__str__(AttributeOptimizer self) -> std::string"""
6180 return _IMP_kernel.AttributeOptimizer___str__(self)
6183 r"""__repr__(AttributeOptimizer self) -> std::string"""
6184 return _IMP_kernel.AttributeOptimizer___repr__(self)
6188 return _object_cast_to_AttributeOptimizer(o)
6191 def get_type_name(self):
6192 return self.__class__.__name__
6193 def do_show(self, out):
6197 return VersionInfo(self.__module__,
6204 return _object_cast_to_AttributeOptimizer(o)
6206 __swig_destroy__ = _IMP_kernel.delete_AttributeOptimizer
6207 def __disown__(self):
6209 _IMP_kernel.disown_AttributeOptimizer(self)
6210 return weakref.proxy(self)
6213 r"""do_destroy(AttributeOptimizer self)"""
6214 return _IMP_kernel.AttributeOptimizer_do_destroy(self)
6216 def handle_set_has_required_score_states(self, arg0):
6217 r"""handle_set_has_required_score_states(AttributeOptimizer self, bool arg0)"""
6218 return _IMP_kernel.AttributeOptimizer_handle_set_has_required_score_states(self, arg0)
6220 def do_get_inputs(self):
6221 r"""do_get_inputs(AttributeOptimizer self) -> IMP::ModelObjectsTemp"""
6222 return _IMP_kernel.AttributeOptimizer_do_get_inputs(self)
6224 def do_get_outputs(self):
6225 r"""do_get_outputs(AttributeOptimizer self) -> IMP::ModelObjectsTemp"""
6226 return _IMP_kernel.AttributeOptimizer_do_get_outputs(self)
6228 def do_get_interactions(self):
6229 r"""do_get_interactions(AttributeOptimizer self) -> IMP::ModelObjectsTemps"""
6230 return _IMP_kernel.AttributeOptimizer_do_get_interactions(self)
6232 def do_optimize(self, ns):
6233 r"""do_optimize(AttributeOptimizer self, unsigned int ns) -> double"""
6234 return _IMP_kernel.AttributeOptimizer_do_optimize(self, ns)
6237 _IMP_kernel.AttributeOptimizer_swigregister(AttributeOptimizer)
6238 class ConfigurationSet(
Object):
6239 r"""Proxy of C++ IMP::ConfigurationSet class."""
6241 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
6243 def __init__(self, *args):
6244 r"""__init__(ConfigurationSet self, Model m, std::string name="ConfigurationSet %1%") -> ConfigurationSet"""
6245 _IMP_kernel.ConfigurationSet_swiginit(self, _IMP_kernel.new_ConfigurationSet(*args))
6247 def save_configuration(self):
6248 r"""save_configuration(ConfigurationSet self)"""
6249 return _IMP_kernel.ConfigurationSet_save_configuration(self)
6251 def get_number_of_configurations(self):
6252 r"""get_number_of_configurations(ConfigurationSet self) -> unsigned int"""
6253 return _IMP_kernel.ConfigurationSet_get_number_of_configurations(self)
6255 def load_configuration(self, i):
6256 r"""load_configuration(ConfigurationSet self, int i)"""
6257 return _IMP_kernel.ConfigurationSet_load_configuration(self, i)
6259 def remove_configuration(self, i):
6260 r"""remove_configuration(ConfigurationSet self, unsigned int i)"""
6261 return _IMP_kernel.ConfigurationSet_remove_configuration(self, i)
6263 def get_model(self):
6264 r"""get_model(ConfigurationSet self) -> Model"""
6265 return _IMP_kernel.ConfigurationSet_get_model(self)
6268 r"""get_version_info(ConfigurationSet self) -> VersionInfo"""
6269 return _IMP_kernel.ConfigurationSet_get_version_info(self)
6270 __swig_destroy__ = _IMP_kernel.delete_ConfigurationSet
6273 r"""__str__(ConfigurationSet self) -> std::string"""
6274 return _IMP_kernel.ConfigurationSet___str__(self)
6277 r"""__repr__(ConfigurationSet self) -> std::string"""
6278 return _IMP_kernel.ConfigurationSet___repr__(self)
6282 return _object_cast_to_ConfigurationSet(o)
6286 _IMP_kernel.ConfigurationSet_swigregister(ConfigurationSet)
6287 class SaveToConfigurationSetOptimizerState(OptimizerState):
6288 r"""Proxy of C++ IMP::SaveToConfigurationSetOptimizerState class."""
6290 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
6292 def __init__(self, cs):
6293 r"""__init__(SaveToConfigurationSetOptimizerState self, ConfigurationSet cs) -> SaveToConfigurationSetOptimizerState"""
6294 _IMP_kernel.SaveToConfigurationSetOptimizerState_swiginit(self, _IMP_kernel.new_SaveToConfigurationSetOptimizerState(cs))
6297 r"""get_version_info(SaveToConfigurationSetOptimizerState self) -> VersionInfo"""
6298 return _IMP_kernel.SaveToConfigurationSetOptimizerState_get_version_info(self)
6299 __swig_destroy__ = _IMP_kernel.delete_SaveToConfigurationSetOptimizerState
6302 r"""__str__(SaveToConfigurationSetOptimizerState self) -> std::string"""
6303 return _IMP_kernel.SaveToConfigurationSetOptimizerState___str__(self)
6306 r"""__repr__(SaveToConfigurationSetOptimizerState self) -> std::string"""
6307 return _IMP_kernel.SaveToConfigurationSetOptimizerState___repr__(self)
6311 return _object_cast_to_SaveToConfigurationSetOptimizerState(o)
6315 _IMP_kernel.SaveToConfigurationSetOptimizerState_swigregister(SaveToConfigurationSetOptimizerState)
6316 class Configuration(
Object):
6317 r"""Proxy of C++ IMP::Configuration class."""
6319 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
6321 def __init__(self, *args):
6323 __init__(Configuration self, Model m, std::string name="Configuration %1%") -> Configuration
6324 __init__(Configuration self, Model m, Configuration base, std::string name="Configuration %1%") -> Configuration
6326 _IMP_kernel.Configuration_swiginit(self, _IMP_kernel.new_Configuration(*args))
6328 def load_configuration(self):
6329 r"""load_configuration(Configuration self)"""
6330 return _IMP_kernel.Configuration_load_configuration(self)
6332 def swap_configuration(self):
6333 r"""swap_configuration(Configuration self)"""
6334 return _IMP_kernel.Configuration_swap_configuration(self)
6337 r"""get_version_info(Configuration self) -> VersionInfo"""
6338 return _IMP_kernel.Configuration_get_version_info(self)
6339 __swig_destroy__ = _IMP_kernel.delete_Configuration
6342 r"""__str__(Configuration self) -> std::string"""
6343 return _IMP_kernel.Configuration___str__(self)
6346 r"""__repr__(Configuration self) -> std::string"""
6347 return _IMP_kernel.Configuration___repr__(self)
6351 return _object_cast_to_Configuration(o)
6355 _IMP_kernel.Configuration_swigregister(Configuration)
6357 r"""Proxy of C++ IMP::Sampler class."""
6359 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
6361 def __init__(self, *args):
6362 r"""__init__(Sampler self, Model m, std::string name="Sampler %1%") -> Sampler"""
6363 if self.__class__ == Sampler:
6367 _IMP_kernel.Sampler_swiginit(self, _IMP_kernel.new_Sampler(_self, *args))
6369 if self.__class__ != Sampler:
6370 _director_objects.register(self)
6375 def create_sample(self):
6376 r"""create_sample(Sampler self) -> ConfigurationSet"""
6377 return _IMP_kernel.Sampler_create_sample(self)
6379 def get_scoring_function(self):
6380 r"""get_scoring_function(Sampler self) -> ScoringFunction"""
6381 return _IMP_kernel.Sampler_get_scoring_function(self)
6383 def set_scoring_function(self, sf):
6384 r"""set_scoring_function(Sampler self, _ScoringFunctionAdaptor sf)"""
6385 return _IMP_kernel.Sampler_set_scoring_function(self, sf)
6387 def get_model(self):
6388 r"""get_model(Sampler self) -> Model"""
6389 return _IMP_kernel.Sampler_get_model(self)
6391 def do_sample(self):
6392 r"""do_sample(Sampler self) -> ConfigurationSet"""
6393 return _IMP_kernel.Sampler_do_sample(self)
6394 __swig_destroy__ = _IMP_kernel.delete_Sampler
6397 r"""__str__(Sampler self) -> std::string"""
6398 return _IMP_kernel.Sampler___str__(self)
6401 r"""__repr__(Sampler self) -> std::string"""
6402 return _IMP_kernel.Sampler___repr__(self)
6406 return _object_cast_to_Sampler(o)
6409 def get_type_name(self):
6410 return self.__class__.__name__
6411 def do_show(self, out):
6415 return VersionInfo(self.__module__,
6422 return _object_cast_to_Sampler(o)
6424 def __disown__(self):
6426 _IMP_kernel.disown_Sampler(self)
6427 return weakref.proxy(self)
6430 r"""do_destroy(Sampler self)"""
6431 return _IMP_kernel.Sampler_do_destroy(self)
6434 _IMP_kernel.Sampler_swigregister(Sampler)
6435 class PairModifier(_ParticleInputs, _ParticleOutputs,
Object):
6436 r"""Proxy of C++ IMP::PairModifier class."""
6438 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
6440 def __init__(self, *args):
6441 r"""__init__(PairModifier self, std::string name="PairModifier %1%") -> PairModifier"""
6442 if self.__class__ == PairModifier:
6446 _IMP_kernel.PairModifier_swiginit(self, _IMP_kernel.new_PairModifier(_self, *args))
6448 if self.__class__ != PairModifier:
6449 _director_objects.register(self)
6454 def apply_index(self, m, v):
6455 r"""apply_index(PairModifier self, Model m, IMP::ParticleIndexPair const & v)"""
6456 return _IMP_kernel.PairModifier_apply_index(self, m, v)
6458 def apply_indexes(self, m, o, lower_bound, upper_bound):
6459 r"""apply_indexes(PairModifier self, Model m, IMP::ParticleIndexPairs const & o, unsigned int lower_bound, unsigned int upper_bound)"""
6460 return _IMP_kernel.PairModifier_apply_indexes(self, m, o, lower_bound, upper_bound)
6462 def apply_indexes_moved(self, m, o, lower_bound, upper_bound, moved_pis, reset_pis):
6463 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)"""
6464 return _IMP_kernel.PairModifier_apply_indexes_moved(self, m, o, lower_bound, upper_bound, moved_pis, reset_pis)
6467 r"""__str__(PairModifier self) -> std::string"""
6468 return _IMP_kernel.PairModifier___str__(self)
6471 r"""__repr__(PairModifier self) -> std::string"""
6472 return _IMP_kernel.PairModifier___repr__(self)
6476 return _object_cast_to_PairModifier(o)
6479 def get_type_name(self):
6480 return self.__class__.__name__
6481 def do_show(self, out):
6485 return VersionInfo(self.__module__,
6492 return _object_cast_to_PairModifier(o)
6494 __swig_destroy__ = _IMP_kernel.delete_PairModifier
6495 def __disown__(self):
6497 _IMP_kernel.disown_PairModifier(self)
6498 return weakref.proxy(self)
6500 def do_get_inputs(self, m, pis):
6501 r"""do_get_inputs(PairModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6502 return _IMP_kernel.PairModifier_do_get_inputs(self, m, pis)
6504 def do_get_outputs(self, m, pis):
6505 r"""do_get_outputs(PairModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6506 return _IMP_kernel.PairModifier_do_get_outputs(self, m, pis)
6509 r"""do_destroy(PairModifier self)"""
6510 return _IMP_kernel.PairModifier_do_destroy(self)
6513 _IMP_kernel.PairModifier_swigregister(PairModifier)
6514 class PairScore(_ParticleInputs,
Object):
6515 r"""Proxy of C++ IMP::PairScore class."""
6517 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
6519 def __init__(self, *args):
6520 r"""__init__(PairScore self, std::string name="PairScore %1%") -> PairScore"""
6521 if self.__class__ == PairScore:
6525 _IMP_kernel.PairScore_swiginit(self, _IMP_kernel.new_PairScore(_self, *args))
6527 if self.__class__ != PairScore:
6528 _director_objects.register(self)
6533 def evaluate_index(self, m, vt, da):
6534 r"""evaluate_index(PairScore self, Model m, IMP::ParticleIndexPair const & vt, DerivativeAccumulator da) -> double"""
6535 return _IMP_kernel.PairScore_evaluate_index(self, m, vt, da)
6537 def evaluate_indexes(self, m, o, da, lower_bound, upper_bound):
6538 r"""evaluate_indexes(PairScore self, Model m, IMP::ParticleIndexPairs const & o, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound) -> double"""
6539 return _IMP_kernel.PairScore_evaluate_indexes(self, m, o, da, lower_bound, upper_bound)
6541 def evaluate_indexes_scores(self, m, o, da, lower_bound, upper_bound, score):
6542 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) -> double"""
6543 return _IMP_kernel.PairScore_evaluate_indexes_scores(self, m, o, da, lower_bound, upper_bound, score)
6545 def evaluate_indexes_delta(self, m, o, da, indexes, score):
6546 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) -> double"""
6547 return _IMP_kernel.PairScore_evaluate_indexes_delta(self, m, o, da, indexes, score)
6549 def evaluate_if_good_index(self, m, vt, da, max):
6550 r"""evaluate_if_good_index(PairScore self, Model m, IMP::ParticleIndexPair const & vt, DerivativeAccumulator da, double max) -> double"""
6551 return _IMP_kernel.PairScore_evaluate_if_good_index(self, m, vt, da, max)
6553 def evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound):
6554 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) -> double"""
6555 return _IMP_kernel.PairScore_evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound)
6557 def create_current_decomposition(self, m, vt):
6558 r"""create_current_decomposition(PairScore self, Model m, IMP::ParticleIndexPair const & vt) -> IMP::Restraints"""
6559 return _IMP_kernel.PairScore_create_current_decomposition(self, m, vt)
6561 def do_create_current_decomposition(self, m, vt):
6562 r"""do_create_current_decomposition(PairScore self, Model m, IMP::ParticleIndexPair const & vt) -> IMP::Restraints"""
6563 return _IMP_kernel.PairScore_do_create_current_decomposition(self, m, vt)
6564 __swig_destroy__ = _IMP_kernel.delete_PairScore
6567 r"""__str__(PairScore self) -> std::string"""
6568 return _IMP_kernel.PairScore___str__(self)
6571 r"""__repr__(PairScore self) -> std::string"""
6572 return _IMP_kernel.PairScore___repr__(self)
6576 return _object_cast_to_PairScore(o)
6579 def get_type_name(self):
6580 return self.__class__.__name__
6581 def do_show(self, out):
6585 return VersionInfo(self.__module__,
6592 return _object_cast_to_PairScore(o)
6594 def __disown__(self):
6596 _IMP_kernel.disown_PairScore(self)
6597 return weakref.proxy(self)
6599 def do_get_inputs(self, m, pis):
6600 r"""do_get_inputs(PairScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6601 return _IMP_kernel.PairScore_do_get_inputs(self, m, pis)
6604 r"""do_destroy(PairScore self)"""
6605 return _IMP_kernel.PairScore_do_destroy(self)
6608 _IMP_kernel.PairScore_swigregister(PairScore)
6609 class PairPredicate(_ParticleInputs,
Object):
6610 r"""Proxy of C++ IMP::PairPredicate class."""
6612 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
6614 def __init__(self, *args):
6615 r"""__init__(PairPredicate self, std::string name="PairPredicate %1%") -> PairPredicate"""
6616 if self.__class__ == PairPredicate:
6620 _IMP_kernel.PairPredicate_swiginit(self, _IMP_kernel.new_PairPredicate(_self, *args))
6622 if self.__class__ != PairPredicate:
6623 _director_objects.register(self)
6628 def setup_for_get_value_index_in_batch(self, arg0):
6629 r"""setup_for_get_value_index_in_batch(PairPredicate self, Model arg0)"""
6630 return _IMP_kernel.PairPredicate_setup_for_get_value_index_in_batch(self, arg0)
6632 def get_value_index_in_batch(self, m, vt):
6633 r"""get_value_index_in_batch(PairPredicate self, Model m, IMP::ParticleIndexPair const & vt) -> int"""
6634 return _IMP_kernel.PairPredicate_get_value_index_in_batch(self, m, vt)
6636 def __call__(self, m, vt):
6637 r"""__call__(PairPredicate self, Model m, IMP::ParticleIndexPair const & vt) -> int"""
6638 return _IMP_kernel.PairPredicate___call__(self, m, vt)
6640 def get_value_index(self, *args):
6642 get_value_index(PairPredicate self, Model m, IMP::ParticleIndexPair const & vt) -> int
6643 get_value_index(PairPredicate self, Model m, IMP::ParticleIndexPairs const & o) -> IMP::Ints
6645 return _IMP_kernel.PairPredicate_get_value_index(self, *args)
6646 __swig_destroy__ = _IMP_kernel.delete_PairPredicate
6649 r"""__str__(PairPredicate self) -> std::string"""
6650 return _IMP_kernel.PairPredicate___str__(self)
6653 r"""__repr__(PairPredicate self) -> std::string"""
6654 return _IMP_kernel.PairPredicate___repr__(self)
6658 return _object_cast_to_PairPredicate(o)
6661 def get_type_name(self):
6662 return self.__class__.__name__
6663 def do_show(self, out):
6667 return VersionInfo(self.__module__,
6674 return _object_cast_to_PairPredicate(o)
6676 def __disown__(self):
6678 _IMP_kernel.disown_PairPredicate(self)
6679 return weakref.proxy(self)
6681 def do_get_inputs(self, m, pis):
6682 r"""do_get_inputs(PairPredicate self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6683 return _IMP_kernel.PairPredicate_do_get_inputs(self, m, pis)
6686 r"""do_destroy(PairPredicate self)"""
6687 return _IMP_kernel.PairPredicate_do_destroy(self)
6690 _IMP_kernel.PairPredicate_swigregister(PairPredicate)
6691 class PairContainer(Container):
6692 r"""Proxy of C++ IMP::PairContainer class."""
6694 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
6696 def apply_generic(self, m):
6697 r"""apply_generic(PairContainer self, PairModifier m)"""
6698 return _IMP_kernel.PairContainer_apply_generic(self, m)
6700 def apply_generic_moved(self, m, moved_pis, reset_pis):
6701 r"""apply_generic_moved(PairContainer self, PairModifier m, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis)"""
6702 return _IMP_kernel.PairContainer_apply_generic_moved(self, m, moved_pis, reset_pis)
6704 def apply(self, sm):
6705 r"""apply(PairContainer self, PairModifier sm)"""
6706 return _IMP_kernel.PairContainer_apply(self, sm)
6708 def apply_moved(self, sm, moved_pis, reset_pis):
6709 r"""apply_moved(PairContainer self, PairModifier sm, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis)"""
6710 return _IMP_kernel.PairContainer_apply_moved(self, sm, moved_pis, reset_pis)
6712 def get_range_indexes(self):
6713 r"""get_range_indexes(PairContainer self) -> IMP::ParticleIndexPairs"""
6714 return _IMP_kernel.PairContainer_get_range_indexes(self)
6716 def get_contents(self):
6717 r"""get_contents(PairContainer self) -> IMP::ParticleIndexPairs const &"""
6718 return _IMP_kernel.PairContainer_get_contents(self)
6721 r"""get_indexes(PairContainer self) -> IMP::ParticleIndexPairs"""
6722 return _IMP_kernel.PairContainer_get_indexes(self)
6724 def get(self, *args):
6726 get(PairContainer self) -> IMP::ParticlePairsTemp
6727 get(PairContainer self, unsigned int i) -> IMP::ParticlePair
6729 return _IMP_kernel.PairContainer_get(self, *args)
6731 def get_number(self):
6732 r"""get_number(PairContainer self) -> unsigned int"""
6733 return _IMP_kernel.PairContainer_get_number(self)
6735 def __init__(self, *args):
6737 __init__(PairContainer self, Model m, std::string name="PairContainer %1%") -> PairContainer
6738 __init__(PairContainer self) -> PairContainer
6740 if self.__class__ == PairContainer:
6744 _IMP_kernel.PairContainer_swiginit(self, _IMP_kernel.new_PairContainer(_self, *args))
6746 if self.__class__ != PairContainer:
6747 _director_objects.register(self)
6752 def do_apply(self, sm):
6753 r"""do_apply(PairContainer self, PairModifier sm)"""
6754 return _IMP_kernel.PairContainer_do_apply(self, sm)
6756 def do_apply_moved(self, sm, moved_pis, reset_pis):
6757 r"""do_apply_moved(PairContainer self, PairModifier sm, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis)"""
6758 return _IMP_kernel.PairContainer_do_apply_moved(self, sm, moved_pis, reset_pis)
6760 def do_get_provides_access(self):
6761 r"""do_get_provides_access(PairContainer self) -> bool"""
6762 return _IMP_kernel.PairContainer_do_get_provides_access(self)
6763 __swig_destroy__ = _IMP_kernel.delete_PairContainer
6766 r"""__str__(PairContainer self) -> std::string"""
6767 return _IMP_kernel.PairContainer___str__(self)
6770 r"""__repr__(PairContainer self) -> std::string"""
6771 return _IMP_kernel.PairContainer___repr__(self)
6775 return _object_cast_to_PairContainer(o)
6778 def get_type_name(self):
6779 return self.__class__.__name__
6780 def do_show(self, out):
6784 return VersionInfo(self.__module__,