10 from __future__
import print_function, division, absolute_import
15 from sys
import version_info
16 if version_info >= (2, 6, 0):
17 def swig_import_helper():
18 from os.path
import dirname
22 fp, pathname, description = imp.find_module(
'_IMP_kernel', [dirname(__file__)])
28 _mod = imp.load_module(
'_IMP_kernel', fp, pathname, description)
32 _IMP_kernel = swig_import_helper()
33 del swig_import_helper
38 _swig_property = property
43 def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
44 if (name ==
"thisown"):
45 return self.this.own(value)
47 if type(value).__name__ ==
'SwigPyObject':
48 self.__dict__[name] = value
50 method = class_type.__swig_setmethods__.get(name,
None)
52 return method(self, value)
54 object.__setattr__(self, name, value)
56 raise AttributeError(
"You cannot add attributes to %s" % self)
59 def _swig_setattr(self, class_type, name, value):
60 return _swig_setattr_nondynamic(self, class_type, name, value, 0)
63 def _swig_getattr_nondynamic(self, class_type, name, static=1):
64 if (name ==
"thisown"):
65 return self.this.own()
66 method = class_type.__swig_getmethods__.get(name,
None)
70 return object.__getattr__(self, name)
72 raise AttributeError(name)
74 def _swig_getattr(self, class_type, name):
75 return _swig_getattr_nondynamic(self, class_type, name, 0)
80 strthis =
"proxy of " + self.this.__repr__()
83 return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
88 except AttributeError:
95 def _swig_setattr_nondynamic_method(set):
96 def set_attr(self, name, value):
97 if (name ==
"thisown"):
98 return self.this.own(value)
99 if hasattr(self, name)
or (name ==
"this"):
100 set(self, name, value)
102 raise AttributeError(
"You cannot add attributes to %s" % self)
108 weakref_proxy = weakref.proxy
110 weakref_proxy =
lambda x: x
113 class IMP_KERNEL_SwigPyIterator(object):
114 """Proxy of C++ swig::IMP_KERNEL_SwigPyIterator class"""
115 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
117 def __init__(self, *args, **kwargs):
118 raise AttributeError(
"No constructor defined - class is abstract")
119 __repr__ = _swig_repr
120 __swig_destroy__ = _IMP_kernel.delete_IMP_KERNEL_SwigPyIterator
121 __del__ =
lambda self:
None
124 """value(IMP_KERNEL_SwigPyIterator self) -> PyObject *"""
125 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_value(self)
130 incr(IMP_KERNEL_SwigPyIterator self, size_t n=1) -> IMP_KERNEL_SwigPyIterator
131 incr(IMP_KERNEL_SwigPyIterator self) -> IMP_KERNEL_SwigPyIterator
133 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_incr(self, n)
138 decr(IMP_KERNEL_SwigPyIterator self, size_t n=1) -> IMP_KERNEL_SwigPyIterator
139 decr(IMP_KERNEL_SwigPyIterator self) -> IMP_KERNEL_SwigPyIterator
141 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_decr(self, n)
144 def distance(self, x):
145 """distance(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> ptrdiff_t"""
146 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_distance(self, x)
150 """equal(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> bool"""
151 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_equal(self, x)
155 """copy(IMP_KERNEL_SwigPyIterator self) -> IMP_KERNEL_SwigPyIterator"""
156 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_copy(self)
160 """next(IMP_KERNEL_SwigPyIterator self) -> PyObject *"""
161 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_next(self)
165 """__next__(IMP_KERNEL_SwigPyIterator self) -> PyObject *"""
166 return _IMP_kernel.IMP_KERNEL_SwigPyIterator___next__(self)
170 """previous(IMP_KERNEL_SwigPyIterator self) -> PyObject *"""
171 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_previous(self)
174 def advance(self, n):
175 """advance(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator"""
176 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_advance(self, n)
180 """__eq__(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> bool"""
181 return _IMP_kernel.IMP_KERNEL_SwigPyIterator___eq__(self, x)
185 """__ne__(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> bool"""
186 return _IMP_kernel.IMP_KERNEL_SwigPyIterator___ne__(self, x)
189 def __iadd__(self, n):
190 """__iadd__(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator"""
191 return _IMP_kernel.IMP_KERNEL_SwigPyIterator___iadd__(self, n)
194 def __isub__(self, n):
195 """__isub__(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator"""
196 return _IMP_kernel.IMP_KERNEL_SwigPyIterator___isub__(self, n)
199 def __add__(self, n):
200 """__add__(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator"""
201 return _IMP_kernel.IMP_KERNEL_SwigPyIterator___add__(self, n)
204 def __sub__(self, *args):
206 __sub__(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator
207 __sub__(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> ptrdiff_t
209 return _IMP_kernel.IMP_KERNEL_SwigPyIterator___sub__(self, *args)
213 IMP_KERNEL_SwigPyIterator_swigregister = _IMP_kernel.IMP_KERNEL_SwigPyIterator_swigregister
214 IMP_KERNEL_SwigPyIterator_swigregister(IMP_KERNEL_SwigPyIterator)
223 _IMP_kernel.IMP_DEBUG_swigconstant(_IMP_kernel)
224 IMP_DEBUG = _IMP_kernel.IMP_DEBUG
226 _IMP_kernel.IMP_RELEASE_swigconstant(_IMP_kernel)
227 IMP_RELEASE = _IMP_kernel.IMP_RELEASE
229 _IMP_kernel.IMP_SILENT_swigconstant(_IMP_kernel)
230 IMP_SILENT = _IMP_kernel.IMP_SILENT
232 _IMP_kernel.IMP_PROGRESS_swigconstant(_IMP_kernel)
233 IMP_PROGRESS = _IMP_kernel.IMP_PROGRESS
235 _IMP_kernel.IMP_TERSE_swigconstant(_IMP_kernel)
236 IMP_TERSE = _IMP_kernel.IMP_TERSE
238 _IMP_kernel.IMP_VERBOSE_swigconstant(_IMP_kernel)
239 IMP_VERBOSE = _IMP_kernel.IMP_VERBOSE
241 _IMP_kernel.IMP_MEMORY_swigconstant(_IMP_kernel)
242 IMP_MEMORY = _IMP_kernel.IMP_MEMORY
244 _IMP_kernel.IMP_NONE_swigconstant(_IMP_kernel)
245 IMP_NONE = _IMP_kernel.IMP_NONE
247 _IMP_kernel.IMP_USAGE_swigconstant(_IMP_kernel)
248 IMP_USAGE = _IMP_kernel.IMP_USAGE
250 _IMP_kernel.IMP_INTERNAL_swigconstant(_IMP_kernel)
251 IMP_INTERNAL = _IMP_kernel.IMP_INTERNAL
253 _IMP_kernel.IMP_KERNEL_HAS_LOG4CXX_swigconstant(_IMP_kernel)
254 IMP_KERNEL_HAS_LOG4CXX = _IMP_kernel.IMP_KERNEL_HAS_LOG4CXX
256 _IMP_kernel.IMP_COMPILER_HAS_AUTO_swigconstant(_IMP_kernel)
257 IMP_COMPILER_HAS_AUTO = _IMP_kernel.IMP_COMPILER_HAS_AUTO
259 _IMP_kernel.IMP_COMPILER_HAS_DEBUG_VECTOR_swigconstant(_IMP_kernel)
260 IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_kernel.IMP_COMPILER_HAS_DEBUG_VECTOR
262 _IMP_kernel.IMP_COMPILER_HAS_UNIQUE_PTR_swigconstant(_IMP_kernel)
263 IMP_COMPILER_HAS_UNIQUE_PTR = _IMP_kernel.IMP_COMPILER_HAS_UNIQUE_PTR
265 _IMP_kernel.IMP_KERNEL_HAS_BOOST_RANDOM_swigconstant(_IMP_kernel)
266 IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_kernel.IMP_KERNEL_HAS_BOOST_RANDOM
268 _IMP_kernel.IMP_KERNEL_HAS_NUMPY_swigconstant(_IMP_kernel)
269 IMP_KERNEL_HAS_NUMPY = _IMP_kernel.IMP_KERNEL_HAS_NUMPY
271 _IMP_kernel.IMP_KERNEL_HAS_GPERFTOOLS_swigconstant(_IMP_kernel)
272 IMP_KERNEL_HAS_GPERFTOOLS = _IMP_kernel.IMP_KERNEL_HAS_GPERFTOOLS
274 _IMP_kernel.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER_swigconstant(_IMP_kernel)
275 IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER = _IMP_kernel.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER
277 _IMP_kernel.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER_swigconstant(_IMP_kernel)
278 IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER = _IMP_kernel.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER
280 _IMP_kernel.IMPKERNEL_SHOW_WARNINGS_swigconstant(_IMP_kernel)
281 IMPKERNEL_SHOW_WARNINGS = _IMP_kernel.IMPKERNEL_SHOW_WARNINGS
284 class _DirectorObjects(object):
285 """@internal Simple class to keep references to director objects
286 to prevent premature deletion."""
289 def register(self, obj):
290 """Take a reference to a director object; will only work for
291 refcounted C++ classes"""
292 if hasattr(obj,
'get_ref_count'):
293 self._objects.append(obj)
295 """Only drop our reference and allow cleanup by Python if no other
296 Python references exist (we hold 3 references: one in self._objects,
297 one in x, and one in the argument list for getrefcount) *and* no
298 other C++ references exist (the Python object always holds one)"""
299 objs = [x
for x
in self._objects
if sys.getrefcount(x) > 3 \
300 or x.get_ref_count() > 1]
304 def get_object_count(self):
305 """Get number of director objects (useful for testing only)"""
306 return len(self._objects)
307 _director_objects = _DirectorObjects()
310 _IMP_kernel.DEFAULT_CHECK_swigconstant(_IMP_kernel)
311 DEFAULT_CHECK = _IMP_kernel.DEFAULT_CHECK
313 _IMP_kernel.NONE_swigconstant(_IMP_kernel)
314 NONE = _IMP_kernel.NONE
316 _IMP_kernel.USAGE_swigconstant(_IMP_kernel)
317 USAGE = _IMP_kernel.USAGE
319 _IMP_kernel.USAGE_AND_INTERNAL_swigconstant(_IMP_kernel)
320 USAGE_AND_INTERNAL = _IMP_kernel.USAGE_AND_INTERNAL
323 """set_check_level(IMP::CheckLevel tf)"""
324 return _IMP_kernel.set_check_level(tf)
327 """get_check_level() -> IMP::CheckLevel"""
328 return _IMP_kernel.get_check_level()
330 from _IMP_kernel
import Exception, InternalException, ModelException, EventException
331 from _IMP_kernel
import UsageException, IndexException, IOException, ValueException
332 from _IMP_kernel
import TypeException
334 class _ostream(object):
335 """Proxy of C++ std::ostream class"""
336 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
338 def __init__(self, *args, **kwargs):
339 raise AttributeError(
"No constructor defined")
340 __repr__ = _swig_repr
342 def write(self, osa_buf):
343 """write(_ostream self, char const * osa_buf)"""
344 return _IMP_kernel._ostream_write(self, osa_buf)
346 _ostream_swigregister = _IMP_kernel._ostream_swigregister
347 _ostream_swigregister(_ostream)
350 _IMP_kernel.IMP_COMPILER_HAS_OVERRIDE_swigconstant(_IMP_kernel)
351 IMP_COMPILER_HAS_OVERRIDE = _IMP_kernel.IMP_COMPILER_HAS_OVERRIDE
353 _IMP_kernel.IMP_COMPILER_HAS_FINAL_swigconstant(_IMP_kernel)
354 IMP_COMPILER_HAS_FINAL = _IMP_kernel.IMP_COMPILER_HAS_FINAL
356 _IMP_kernel.IMP_HAS_NOEXCEPT_swigconstant(_IMP_kernel)
357 IMP_HAS_NOEXCEPT = _IMP_kernel.IMP_HAS_NOEXCEPT
359 _IMP_kernel.IMP_C_OPEN_BINARY_swigconstant(_IMP_kernel)
360 IMP_C_OPEN_BINARY = _IMP_kernel.IMP_C_OPEN_BINARY
362 _raii_types.append(
"SetLogState")
365 _raii_types.append(
"SetNumberOfThreads")
368 _raii_types.append(
"SetCheckState")
371 _object_types.append(
"Object")
374 def _object_cast_to_Object(o):
375 """_object_cast_to_Object(Object * o) -> Object"""
376 return _IMP_kernel._object_cast_to_Object(o)
378 _object_types.append(
"_TestObject")
381 def _object_cast_to__TestObject(o):
382 """_object_cast_to__TestObject(Object * o) -> _TestObject"""
383 return _IMP_kernel._object_cast_to__TestObject(o)
386 _plural_types.append(
"VersionInfos")
387 _value_types.append(
"VersionInfo")
390 _raii_types.append(
"CreateLogContext")
393 _raii_types.append(
"WarningContext")
396 _raii_types.append(
"SetLogTarget")
400 _plural_types.append(
"_TestValues")
401 _value_types.append(
"_TestValue")
405 _plural_types.append(
"Floats")
406 _value_types.append(
"Float")
410 _plural_types.append(
"Ints")
411 _value_types.append(
"Int")
415 _plural_types.append(
"Strings")
416 _value_types.append(
"String")
420 _plural_types.append(
"_Protections")
421 _value_types.append(
"_Protection")
423 class _InputAdaptor(object):
424 """Proxy of C++ IMP::InputAdaptor class"""
425 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
427 def __init__(self, *args, **kwargs):
428 raise AttributeError(
"No constructor defined")
429 __repr__ = _swig_repr
430 __swig_destroy__ = _IMP_kernel.delete__InputAdaptor
431 __del__ =
lambda self:
None
432 _InputAdaptor_swigregister = _IMP_kernel._InputAdaptor_swigregister
433 _InputAdaptor_swigregister(_InputAdaptor)
435 class _NonCopyable(object):
436 """Proxy of C++ IMP::NonCopyable class"""
437 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
439 def __init__(self, *args, **kwargs):
440 raise AttributeError(
"No constructor defined")
441 __repr__ = _swig_repr
442 __swig_destroy__ = _IMP_kernel.delete__NonCopyable
443 __del__ =
lambda self:
None
444 _NonCopyable_swigregister = _IMP_kernel._NonCopyable_swigregister
445 _NonCopyable_swigregister(_NonCopyable)
447 class _RAII(_NonCopyable):
448 """Proxy of C++ IMP::RAII class"""
449 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
451 def __init__(self, *args, **kwargs):
452 raise AttributeError(
"No constructor defined")
453 __repr__ = _swig_repr
454 __swig_destroy__ = _IMP_kernel.delete__RAII
455 __del__ =
lambda self:
None
456 _RAII_swigregister = _IMP_kernel._RAII_swigregister
457 _RAII_swigregister(_RAII)
459 class _Value(object):
460 """Proxy of C++ IMP::Value class"""
461 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
463 def __init__(self, *args, **kwargs):
464 raise AttributeError(
"No constructor defined")
465 __repr__ = _swig_repr
466 __swig_destroy__ = _IMP_kernel.delete__Value
467 __del__ =
lambda self:
None
468 _Value_swigregister = _IMP_kernel._Value_swigregister
469 _Value_swigregister(_Value)
473 """get_executable_name() -> std::string"""
474 return _IMP_kernel.get_executable_name()
478 setup_from_argv(IMP::Strings const & argv, std::string description)
479 setup_from_argv(IMP::Strings const & argv, std::string description, std::string positional_description, int num_positional) -> IMP::Strings
481 return _IMP_kernel.setup_from_argv(*args)
484 """add_string_flag(std::string name, std::string default_value, std::string description)"""
485 return _IMP_kernel.add_string_flag(name, default_value, description)
488 """get_string_flag(std::string name) -> std::string"""
489 return _IMP_kernel.get_string_flag(name)
492 """add_int_flag(std::string name, size_t default_value, std::string description)"""
493 return _IMP_kernel.add_int_flag(name, default_value, description)
496 """get_int_flag(std::string name) -> size_t"""
497 return _IMP_kernel.get_int_flag(name)
500 """add_bool_flag(std::string name, std::string description)"""
501 return _IMP_kernel.add_bool_flag(name, description)
504 """get_bool_flag(std::string name) -> bool"""
505 return _IMP_kernel.get_bool_flag(name)
508 """add_float_flag(std::string name, double default_value, std::string description)"""
509 return _IMP_kernel.add_float_flag(name, default_value, description)
512 """get_float_flag(std::string name) -> double"""
513 return _IMP_kernel.get_float_flag(name)
517 write_help(_ostream out)
520 return _IMP_kernel.write_help(*args)
523 """get_is_quick_test() -> bool"""
524 return _IMP_kernel.get_is_quick_test()
526 _IMP_kernel.DEFAULT_swigconstant(_IMP_kernel)
527 DEFAULT = _IMP_kernel.DEFAULT
529 _IMP_kernel.SILENT_swigconstant(_IMP_kernel)
530 SILENT = _IMP_kernel.SILENT
532 _IMP_kernel.WARNING_swigconstant(_IMP_kernel)
533 WARNING = _IMP_kernel.WARNING
535 _IMP_kernel.PROGRESS_swigconstant(_IMP_kernel)
536 PROGRESS = _IMP_kernel.PROGRESS
538 _IMP_kernel.TERSE_swigconstant(_IMP_kernel)
539 TERSE = _IMP_kernel.TERSE
541 _IMP_kernel.VERBOSE_swigconstant(_IMP_kernel)
542 VERBOSE = _IMP_kernel.VERBOSE
544 _IMP_kernel.MEMORY_swigconstant(_IMP_kernel)
545 MEMORY = _IMP_kernel.MEMORY
547 _IMP_kernel.ALL_LOG_swigconstant(_IMP_kernel)
548 ALL_LOG = _IMP_kernel.ALL_LOG
549 class VersionInfo(_Value):
550 """Proxy of C++ IMP::VersionInfo class"""
551 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
553 def __init__(self, *args):
555 __init__(IMP::VersionInfo self, std::string module, std::string version) -> VersionInfo
556 __init__(IMP::VersionInfo self) -> VersionInfo
558 this = _IMP_kernel.new_VersionInfo(*args)
560 self.this.append(this)
564 def get_module(self):
565 """get_module(VersionInfo self) -> std::string"""
566 return _IMP_kernel.VersionInfo_get_module(self)
569 def get_version(self):
570 """get_version(VersionInfo self) -> std::string"""
571 return _IMP_kernel.VersionInfo_get_version(self)
574 def show(self, *args):
576 show(VersionInfo self, _ostream out)
577 show(VersionInfo self)
579 return _IMP_kernel.VersionInfo_show(self, *args)
582 def __cmp__(self, o):
583 """__cmp__(VersionInfo self, VersionInfo o) -> int"""
584 return _IMP_kernel.VersionInfo___cmp__(self, o)
588 """__eq__(VersionInfo self, VersionInfo o) -> bool"""
589 return _IMP_kernel.VersionInfo___eq__(self, o)
593 """__ne__(VersionInfo self, VersionInfo o) -> bool"""
594 return _IMP_kernel.VersionInfo___ne__(self, o)
598 """__lt__(VersionInfo self, VersionInfo o) -> bool"""
599 return _IMP_kernel.VersionInfo___lt__(self, o)
603 """__gt__(VersionInfo self, VersionInfo o) -> bool"""
604 return _IMP_kernel.VersionInfo___gt__(self, o)
608 """__ge__(VersionInfo self, VersionInfo o) -> bool"""
609 return _IMP_kernel.VersionInfo___ge__(self, o)
613 """__le__(VersionInfo self, VersionInfo o) -> bool"""
614 return _IMP_kernel.VersionInfo___le__(self, o)
618 """__str__(VersionInfo self) -> std::string"""
619 return _IMP_kernel.VersionInfo___str__(self)
623 """__repr__(VersionInfo self) -> std::string"""
624 return _IMP_kernel.VersionInfo___repr__(self)
626 __swig_destroy__ = _IMP_kernel.delete_VersionInfo
627 __del__ =
lambda self:
None
628 VersionInfo_swigregister = _IMP_kernel.VersionInfo_swigregister
629 VersionInfo_swigregister(VersionInfo)
631 class TextOutput(_InputAdaptor):
632 """Proxy of C++ IMP::TextOutput class"""
633 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
634 __repr__ = _swig_repr
636 def __init__(self, *args):
638 __init__(IMP::TextOutput self, int arg2) -> TextOutput
639 __init__(IMP::TextOutput self, double arg2) -> TextOutput
640 __init__(IMP::TextOutput self, char const * c, bool append=False) -> TextOutput
641 __init__(IMP::TextOutput self, char const * c) -> TextOutput
642 __init__(IMP::TextOutput self, IMP::TextProxy< std::ostream > p) -> TextOutput
643 __init__(IMP::TextOutput self) -> TextOutput
644 __init__(IMP::TextOutput self, std::string file_name, bool append=False) -> TextOutput
645 __init__(IMP::TextOutput self, std::string file_name) -> TextOutput
647 this = _IMP_kernel.new_TextOutput(*args)
649 self.this.append(this)
653 def show(self, *args):
655 show(TextOutput self, _ostream out)
656 show(TextOutput self)
658 return _IMP_kernel.TextOutput_show(self, *args)
662 """get_name(TextOutput self) -> std::string"""
663 return _IMP_kernel.TextOutput_get_name(self)
665 __swig_destroy__ = _IMP_kernel.delete_TextOutput
666 __del__ =
lambda self:
None
667 TextOutput_swigregister = _IMP_kernel.TextOutput_swigregister
668 TextOutput_swigregister(TextOutput)
670 class TextInput(_InputAdaptor):
671 """Proxy of C++ IMP::TextInput class"""
672 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
673 __repr__ = _swig_repr
675 def __init__(self, *args):
677 __init__(IMP::TextInput self, int arg2) -> TextInput
678 __init__(IMP::TextInput self, double arg2) -> TextInput
679 __init__(IMP::TextInput self, char const * c) -> TextInput
680 __init__(IMP::TextInput self, IMP::TextProxy< std::istream > p) -> TextInput
681 __init__(IMP::TextInput self) -> TextInput
682 __init__(IMP::TextInput self, std::string file_name) -> TextInput
684 this = _IMP_kernel.new_TextInput(*args)
686 self.this.append(this)
690 def show(self, *args):
692 show(TextInput self, _ostream out)
695 return _IMP_kernel.TextInput_show(self, *args)
699 """get_name(TextInput self) -> std::string"""
700 return _IMP_kernel.TextInput_get_name(self)
702 __swig_destroy__ = _IMP_kernel.delete_TextInput
703 __del__ =
lambda self:
None
704 TextInput_swigregister = _IMP_kernel.TextInput_swigregister
705 TextInput_swigregister(TextInput)
707 class SetLogTarget(_RAII):
708 """Proxy of C++ IMP::SetLogTarget class"""
709 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
711 def __init__(self, *args):
713 __init__(IMP::SetLogTarget self) -> SetLogTarget
714 __init__(IMP::SetLogTarget self, TextOutput to) -> SetLogTarget
716 this = _IMP_kernel.new_SetLogTarget(*args)
718 self.this.append(this)
723 """set(SetLogTarget self, TextOutput to)"""
724 return _IMP_kernel.SetLogTarget_set(self, to)
728 """reset(SetLogTarget self)"""
729 return _IMP_kernel.SetLogTarget_reset(self)
731 __swig_destroy__ = _IMP_kernel.delete_SetLogTarget
732 __del__ =
lambda self:
None
734 def show(self, *args):
736 show(SetLogTarget self, _ostream out)
737 show(SetLogTarget self)
739 return _IMP_kernel.SetLogTarget_show(self, *args)
744 def __exit__(self, exc_type, exc_val, exc_tb):
750 """__str__(SetLogTarget self) -> std::string"""
751 return _IMP_kernel.SetLogTarget___str__(self)
755 """__repr__(SetLogTarget self) -> std::string"""
756 return _IMP_kernel.SetLogTarget___repr__(self)
758 SetLogTarget_swigregister = _IMP_kernel.SetLogTarget_swigregister
759 SetLogTarget_swigregister(SetLogTarget)
764 create_temporary_file(std::string prefix, std::string suffix) -> TextOutput
765 create_temporary_file(std::string prefix) -> TextOutput
766 create_temporary_file() -> TextOutput
768 return _IMP_kernel.create_temporary_file(*args)
772 create_temporary_file_name(std::string prefix, std::string suffix) -> std::string
773 create_temporary_file_name(std::string prefix) -> std::string
774 create_temporary_file_name() -> std::string
776 return _IMP_kernel.create_temporary_file_name(*args)
779 """get_relative_path(std::string base, std::string relative) -> std::string"""
780 return _IMP_kernel.get_relative_path(base, relative)
783 """get_absolute_path(std::string file) -> std::string"""
784 return _IMP_kernel.get_absolute_path(file)
786 def push_log_context(functionname, object):
787 """push_log_context(char const * functionname, void const * object)"""
788 return _IMP_kernel.push_log_context(functionname, object)
790 def pop_log_context():
791 """pop_log_context()"""
792 return _IMP_kernel.pop_log_context()
796 add_to_log(std::string to_write)
797 add_to_log(IMP::LogLevel level, std::string to_write)
799 return _IMP_kernel.add_to_log(*args)
802 """set_log_level(IMP::LogLevel l)"""
803 return _IMP_kernel.set_log_level(l)
806 """set_log_timer(bool tb)"""
807 return _IMP_kernel.set_log_timer(tb)
810 """reset_log_timer()"""
811 return _IMP_kernel.reset_log_timer()
814 """get_log_level() -> IMP::LogLevel"""
815 return _IMP_kernel.get_log_level()
818 """set_progress_display(std::string description, unsigned int steps)"""
819 return _IMP_kernel.set_progress_display(description, steps)
823 add_to_progress_display(unsigned int step=1)
824 add_to_progress_display()
826 return _IMP_kernel.add_to_progress_display(step)
827 class Object(_NonCopyable):
828 """Proxy of C++ IMP::Object class"""
829 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
831 def __init__(self, name):
832 """__init__(IMP::Object self, std::string name) -> Object"""
833 if self.__class__ == Object:
837 this = _IMP_kernel.new_Object(_self, name)
839 self.this.append(this)
843 if self.__class__ != Object:
844 _director_objects.register(self)
848 __swig_destroy__ = _IMP_kernel.delete_Object
849 __del__ =
lambda self:
None
852 """__hash__(Object self) -> std::size_t"""
853 return _IMP_kernel.Object___hash__(self)
857 """set_log_level(Object self, IMP::LogLevel l)"""
858 return _IMP_kernel.Object_set_log_level(self, l)
862 """set_check_level(Object self, IMP::CheckLevel l)"""
863 return _IMP_kernel.Object_set_check_level(self, l)
867 """get_log_level(Object self) -> IMP::LogLevel"""
868 return _IMP_kernel.Object_get_log_level(self)
872 """get_check_level(Object self) -> IMP::CheckLevel"""
873 return _IMP_kernel.Object_get_check_level(self)
876 def get_version_info(self):
877 """get_version_info(Object self) -> VersionInfo"""
878 return _IMP_kernel.Object_get_version_info(self)
882 """get_name(Object self) -> std::string const &"""
883 return _IMP_kernel.Object_get_name(self)
886 def set_name(self, name):
887 """set_name(Object self, std::string name)"""
888 return _IMP_kernel.Object_set_name(self, name)
891 def get_type_name(self):
892 """get_type_name(Object self) -> std::string"""
893 return _IMP_kernel.Object_get_type_name(self)
896 def set_was_used(self, tf):
897 """set_was_used(Object self, bool tf)"""
898 return _IMP_kernel.Object_set_was_used(self, tf)
901 def show(self, *args):
903 show(Object self, _ostream out)
906 return _IMP_kernel.Object_show(self, *args)
909 def get_string(self):
910 """get_string(Object self) -> std::string"""
911 return _IMP_kernel.Object_get_string(self)
914 def _on_destruction(self):
915 """_on_destruction(Object self)"""
916 return _IMP_kernel.Object__on_destruction(self)
919 def get_is_valid(self):
920 """get_is_valid(Object self) -> bool"""
921 return _IMP_kernel.Object_get_is_valid(self)
924 def get_ref_count(self):
925 """get_ref_count(Object self) -> unsigned int"""
926 return _IMP_kernel.Object_get_ref_count(self)
929 def get_number_of_live_objects():
930 """get_number_of_live_objects() -> unsigned int"""
931 return _IMP_kernel.Object_get_number_of_live_objects()
933 get_number_of_live_objects = staticmethod(get_number_of_live_objects)
935 def get_is_shared(self):
936 """get_is_shared(Object self) -> bool"""
937 return _IMP_kernel.Object_get_is_shared(self)
940 def clear_caches(self):
941 """clear_caches(Object self)"""
942 return _IMP_kernel.Object_clear_caches(self)
945 def do_destroy(self):
946 """do_destroy(Object self)"""
947 return _IMP_kernel.Object_do_destroy(self)
951 """__eq__(Object self, Object o) -> bool"""
952 return _IMP_kernel.Object___eq__(self, o)
956 """__ne__(Object self, Object o) -> bool"""
957 return _IMP_kernel.Object___ne__(self, o)
961 """__le__(Object self, Object o) -> bool"""
962 return _IMP_kernel.Object___le__(self, o)
966 """__lt__(Object self, Object o) -> bool"""
967 return _IMP_kernel.Object___lt__(self, o)
971 """__ge__(Object self, Object o) -> bool"""
972 return _IMP_kernel.Object___ge__(self, o)
976 """__gt__(Object self, Object o) -> bool"""
977 return _IMP_kernel.Object___gt__(self, o)
981 """__str__(Object self) -> std::string"""
982 return _IMP_kernel.Object___str__(self)
986 """__repr__(Object self) -> std::string"""
987 return _IMP_kernel.Object___repr__(self)
992 return _object_cast_to_Object(o)
994 def __disown__(self):
996 _IMP_kernel.disown_Object(self)
997 return weakref_proxy(self)
998 Object_swigregister = _IMP_kernel.Object_swigregister
999 Object_swigregister(Object)
1001 def Object_get_number_of_live_objects():
1002 """Object_get_number_of_live_objects() -> unsigned int"""
1003 return _IMP_kernel.Object_get_number_of_live_objects()
1005 class SetLogState(_RAII):
1006 """Proxy of C++ IMP::SetLogState class"""
1007 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
1010 """reset(SetLogState self)"""
1011 return _IMP_kernel.SetLogState_reset(self)
1013 __swig_destroy__ = _IMP_kernel.delete_SetLogState
1014 __del__ =
lambda self:
None
1016 def show(self, *args):
1018 show(SetLogState self, _ostream out)
1019 show(SetLogState self)
1021 return _IMP_kernel.SetLogState_show(self, *args)
1024 def __init__(self, *args):
1026 __init__(IMP::SetLogState self) -> SetLogState
1027 __init__(IMP::SetLogState self, Object o, IMP::LogLevel l) -> SetLogState
1028 __init__(IMP::SetLogState self, IMP::LogLevel l) -> SetLogState
1030 this = _IMP_kernel.new_SetLogState(*args)
1032 self.this.append(this)
1036 def set(self, *args):
1038 set(SetLogState self, Object o, IMP::LogLevel l)
1039 set(SetLogState self, IMP::LogLevel l)
1041 return _IMP_kernel.SetLogState_set(self, *args)
1044 def __enter__(self):
1046 def __exit__(self, exc_type, exc_val, exc_tb):
1052 """__str__(SetLogState self) -> std::string"""
1053 return _IMP_kernel.SetLogState___str__(self)
1057 """__repr__(SetLogState self) -> std::string"""
1058 return _IMP_kernel.SetLogState___repr__(self)
1060 SetLogState_swigregister = _IMP_kernel.SetLogState_swigregister
1061 SetLogState_swigregister(SetLogState)
1063 class WarningContext(object):
1064 """Proxy of C++ IMP::WarningContext class"""
1065 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
1066 data_ = _swig_property(_IMP_kernel.WarningContext_data__get, _IMP_kernel.WarningContext_data__set)
1068 def add_warning(self, key, warning):
1069 """add_warning(WarningContext self, std::string key, std::string warning)"""
1070 return _IMP_kernel.WarningContext_add_warning(self, key, warning)
1073 def clear_warnings(self):
1074 """clear_warnings(WarningContext self)"""
1075 return _IMP_kernel.WarningContext_clear_warnings(self)
1078 def dump_warnings(self):
1079 """dump_warnings(WarningContext self)"""
1080 return _IMP_kernel.WarningContext_dump_warnings(self)
1082 __swig_destroy__ = _IMP_kernel.delete_WarningContext
1083 __del__ =
lambda self:
None
1085 def show(self, *args):
1087 show(WarningContext self, _ostream out)
1088 show(WarningContext self)
1090 return _IMP_kernel.WarningContext_show(self, *args)
1093 def __enter__(self):
1095 def __exit__(self, exc_type, exc_val, exc_tb):
1101 """__str__(WarningContext self) -> std::string"""
1102 return _IMP_kernel.WarningContext___str__(self)
1106 """__repr__(WarningContext self) -> std::string"""
1107 return _IMP_kernel.WarningContext___repr__(self)
1111 """__init__(IMP::WarningContext self) -> WarningContext"""
1112 this = _IMP_kernel.new_WarningContext()
1114 self.this.append(this)
1117 WarningContext_swigregister = _IMP_kernel.WarningContext_swigregister
1118 WarningContext_swigregister(WarningContext)
1120 class CreateLogContext(_RAII):
1121 """Proxy of C++ IMP::CreateLogContext class"""
1122 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
1124 def __init__(self, *args):
1126 __init__(IMP::CreateLogContext self, std::string fname, Object object=None) -> CreateLogContext
1127 __init__(IMP::CreateLogContext self, std::string fname) -> CreateLogContext
1128 __init__(IMP::CreateLogContext self) -> CreateLogContext
1129 __init__(IMP::CreateLogContext self, char const * fname, Object object=None) -> CreateLogContext
1130 __init__(IMP::CreateLogContext self, char const * fname) -> CreateLogContext
1132 this = _IMP_kernel.new_CreateLogContext(*args)
1134 self.this.append(this)
1138 def set(self, fname, object=None):
1140 set(CreateLogContext self, char const * fname, Object object=None)
1141 set(CreateLogContext self, char const * fname)
1143 return _IMP_kernel.CreateLogContext_set(self, fname, object)
1147 """reset(CreateLogContext self)"""
1148 return _IMP_kernel.CreateLogContext_reset(self)
1150 __swig_destroy__ = _IMP_kernel.delete_CreateLogContext
1151 __del__ =
lambda self:
None
1153 def show(self, *args):
1155 show(CreateLogContext self, _ostream out)
1156 show(CreateLogContext self)
1158 return _IMP_kernel.CreateLogContext_show(self, *args)
1161 def __enter__(self):
1163 def __exit__(self, exc_type, exc_val, exc_tb):
1169 """__str__(CreateLogContext self) -> std::string"""
1170 return _IMP_kernel.CreateLogContext___str__(self)
1174 """__repr__(CreateLogContext self) -> std::string"""
1175 return _IMP_kernel.CreateLogContext___repr__(self)
1177 CreateLogContext_swigregister = _IMP_kernel.CreateLogContext_swigregister
1178 CreateLogContext_swigregister(CreateLogContext)
1180 class SetCheckState(_RAII):
1181 """Proxy of C++ IMP::SetCheckState class"""
1182 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
1185 """reset(SetCheckState self)"""
1186 return _IMP_kernel.SetCheckState_reset(self)
1188 __swig_destroy__ = _IMP_kernel.delete_SetCheckState
1189 __del__ =
lambda self:
None
1191 def show(self, *args):
1193 show(SetCheckState self, _ostream out)
1194 show(SetCheckState self)
1196 return _IMP_kernel.SetCheckState_show(self, *args)
1199 def __init__(self, *args):
1201 __init__(IMP::SetCheckState self) -> SetCheckState
1202 __init__(IMP::SetCheckState self, Object o, IMP::CheckLevel l) -> SetCheckState
1203 __init__(IMP::SetCheckState self, IMP::CheckLevel l) -> SetCheckState
1205 this = _IMP_kernel.new_SetCheckState(*args)
1207 self.this.append(this)
1211 def set(self, *args):
1213 set(SetCheckState self, Object o, IMP::CheckLevel l)
1214 set(SetCheckState self, IMP::CheckLevel l)
1216 return _IMP_kernel.SetCheckState_set(self, *args)
1219 def __enter__(self):
1221 def __exit__(self, exc_type, exc_val, exc_tb):
1227 """__str__(SetCheckState self) -> std::string"""
1228 return _IMP_kernel.SetCheckState___str__(self)
1232 """__repr__(SetCheckState self) -> std::string"""
1233 return _IMP_kernel.SetCheckState___repr__(self)
1235 SetCheckState_swigregister = _IMP_kernel.SetCheckState_swigregister
1236 SetCheckState_swigregister(SetCheckState)
1240 """get_unique_name(std::string templ) -> std::string"""
1241 return _IMP_kernel.get_unique_name(templ)
1242 class _Protection(object):
1243 """Proxy of C++ IMP::internal::_Protection class"""
1244 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
1246 def __init__(self, *args, **kwargs):
1247 raise AttributeError(
"No constructor defined")
1249 def show(self, *args):
1251 show(_Protection self, _ostream out)
1252 show(_Protection self)
1254 return _IMP_kernel._Protection_show(self, *args)
1258 """__str__(_Protection self) -> std::string"""
1259 return _IMP_kernel._Protection___str__(self)
1263 """__repr__(_Protection self) -> std::string"""
1264 return _IMP_kernel._Protection___repr__(self)
1266 __swig_destroy__ = _IMP_kernel.delete__Protection
1267 __del__ =
lambda self:
None
1268 _Protection_swigregister = _IMP_kernel._Protection_swigregister
1269 _Protection_swigregister(_Protection)
1274 return _IMP_kernel._test_log()
1276 def _test_intranges(ips):
1277 """_test_intranges(IMP::IntRanges const & ips) -> int"""
1278 return _IMP_kernel._test_intranges(ips)
1280 def _test_intrange(*args):
1282 _test_intrange(IMP::IntRange const & ips) -> IMP::IntRange
1283 _test_intrange() -> IMP::IntRange
1285 return _IMP_kernel._test_intrange(*args)
1288 """_test_ifile(TextInput a) -> std::string"""
1289 return _IMP_kernel._test_ifile(a)
1292 """_test_ofile(TextOutput a) -> std::string"""
1293 return _IMP_kernel._test_ofile(a)
1295 def _test_ifile_overloaded(*args):
1297 _test_ifile_overloaded(TextInput a, int i) -> std::string
1298 _test_ifile_overloaded(TextInput a, std::string st) -> std::string
1300 return _IMP_kernel._test_ifile_overloaded(*args)
1302 def _test_ofile_overloaded(*args):
1304 _test_ofile_overloaded(TextOutput a, int i) -> std::string
1305 _test_ofile_overloaded(TextOutput a, std::string st) -> std::string
1307 return _IMP_kernel._test_ofile_overloaded(*args)
1308 class _TestValue(object):
1309 """Proxy of C++ IMP::internal::_TestValue class"""
1310 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
1312 def __init__(self, i):
1313 """__init__(IMP::internal::_TestValue self, int i) -> _TestValue"""
1314 this = _IMP_kernel.new__TestValue(i)
1316 self.this.append(this)
1320 def show(self, *args):
1322 show(_TestValue self, _ostream out)
1323 show(_TestValue self)
1325 return _IMP_kernel._TestValue_show(self, *args)
1328 def __cmp__(self, o):
1329 """__cmp__(_TestValue self, _TestValue o) -> int"""
1330 return _IMP_kernel._TestValue___cmp__(self, o)
1333 def __eq__(self, o):
1334 """__eq__(_TestValue self, _TestValue o) -> bool"""
1335 return _IMP_kernel._TestValue___eq__(self, o)
1338 def __ne__(self, o):
1339 """__ne__(_TestValue self, _TestValue o) -> bool"""
1340 return _IMP_kernel._TestValue___ne__(self, o)
1343 def __lt__(self, o):
1344 """__lt__(_TestValue self, _TestValue o) -> bool"""
1345 return _IMP_kernel._TestValue___lt__(self, o)
1348 def __gt__(self, o):
1349 """__gt__(_TestValue self, _TestValue o) -> bool"""
1350 return _IMP_kernel._TestValue___gt__(self, o)
1353 def __ge__(self, o):
1354 """__ge__(_TestValue self, _TestValue o) -> bool"""
1355 return _IMP_kernel._TestValue___ge__(self, o)
1358 def __le__(self, o):
1359 """__le__(_TestValue self, _TestValue o) -> bool"""
1360 return _IMP_kernel._TestValue___le__(self, o)
1364 """get(_TestValue self) -> int"""
1365 return _IMP_kernel._TestValue_get(self)
1368 def get_float(self):
1369 """get_float(_TestValue self) -> float const &"""
1370 return _IMP_kernel._TestValue_get_float(self)
1373 def get_double(self):
1374 """get_double(_TestValue self) -> double const &"""
1375 return _IMP_kernel._TestValue_get_double(self)
1378 def get_Float(self):
1379 """get_Float(_TestValue self) -> IMP::Float const &"""
1380 return _IMP_kernel._TestValue_get_Float(self)
1384 """get_int(_TestValue self) -> int const &"""
1385 return _IMP_kernel._TestValue_get_int(self)
1389 """get_Int(_TestValue self) -> IMP::Int const &"""
1390 return _IMP_kernel._TestValue_get_Int(self)
1393 def get_string(self):
1394 """get_string(_TestValue self) -> std::string const &"""
1395 return _IMP_kernel._TestValue_get_string(self)
1398 def get_String(self):
1399 """get_String(_TestValue self) -> IMP::String const &"""
1400 return _IMP_kernel._TestValue_get_String(self)
1404 """__str__(_TestValue self) -> std::string"""
1405 return _IMP_kernel._TestValue___str__(self)
1409 """__repr__(_TestValue self) -> std::string"""
1410 return _IMP_kernel._TestValue___repr__(self)
1412 __swig_destroy__ = _IMP_kernel.delete__TestValue
1413 __del__ =
lambda self:
None
1414 _TestValue_swigregister = _IMP_kernel._TestValue_swigregister
1415 _TestValue_swigregister(_TestValue)
1418 def _pass_plain_pair(p):
1419 """_pass_plain_pair(IMP::FloatPair p) -> IMP::FloatPair"""
1420 return _IMP_kernel._pass_plain_pair(p)
1422 def _pass_overloaded_strings(*args):
1424 _pass_overloaded_strings(IMP::Strings const & a, int arg2) -> IMP::Strings
1425 _pass_overloaded_strings(IMP::Strings const & a) -> IMP::Strings
1427 return _IMP_kernel._pass_overloaded_strings(*args)
1430 """_pass_pair(IMP::DerivativePair const & p) -> IMP::DerivativePair"""
1431 return _IMP_kernel._pass_pair(p)
1433 def _pass_floats(input):
1434 """_pass_floats(IMP::Floats const & input) -> IMP::Floats"""
1435 return _IMP_kernel._pass_floats(input)
1437 def _pass_ints(input):
1438 """_pass_ints(IMP::Ints input) -> IMP::Ints"""
1439 return _IMP_kernel._pass_ints(input)
1441 def _pass_ints_list(input):
1442 """_pass_ints_list(IMP::IntsList const & input) -> IMP::IntsList"""
1443 return _IMP_kernel._pass_ints_list(input)
1445 def _pass_ints_lists(input):
1446 """_pass_ints_lists(IMP::IntsLists const & input) -> IMP::IntsLists"""
1447 return _IMP_kernel._pass_ints_lists(input)
1449 def _pass_strings(input):
1450 """_pass_strings(IMP::Strings const & input) -> IMP::Strings const &"""
1451 return _IMP_kernel._pass_strings(input)
1452 class _TestObject(Object):
1453 """Proxy of C++ IMP::internal::_TestObject class"""
1454 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
1457 """__init__(IMP::internal::_TestObject self) -> _TestObject"""
1458 this = _IMP_kernel.new__TestObject()
1460 self.this.append(this)
1464 def get_version_info(self):
1465 """get_version_info(_TestObject self) -> VersionInfo"""
1466 return _IMP_kernel._TestObject_get_version_info(self)
1470 """__str__(_TestObject self) -> std::string"""
1471 return _IMP_kernel._TestObject___str__(self)
1475 """__repr__(_TestObject self) -> std::string"""
1476 return _IMP_kernel._TestObject___repr__(self)
1481 return _object_cast_to__TestObject(o)
1483 _TestObject_swigregister = _IMP_kernel._TestObject_swigregister
1484 _TestObject_swigregister(_TestObject)
1488 """get_live_object_names() -> IMP::Strings"""
1489 return _IMP_kernel.get_live_object_names()
1492 """get_live_objects() -> IMP::Objects"""
1493 return _IMP_kernel.get_live_objects()
1496 """set_show_leaked_objects(bool tf)"""
1497 return _IMP_kernel.set_show_leaked_objects(tf)
1500 """set_deprecation_warnings(bool tf)"""
1501 return _IMP_kernel.set_deprecation_warnings(tf)
1504 """set_deprecation_exceptions(bool tf)"""
1505 return _IMP_kernel.set_deprecation_exceptions(tf)
1508 """get_deprecation_exceptions() -> bool"""
1509 return _IMP_kernel.get_deprecation_exceptions()
1512 """handle_use_deprecated(std::string message)"""
1513 return _IMP_kernel.handle_use_deprecated(message)
1516 """get_number_of_threads() -> unsigned int"""
1517 return _IMP_kernel.get_number_of_threads()
1520 """set_number_of_threads(unsigned int n)"""
1521 return _IMP_kernel.set_number_of_threads(n)
1522 class SetNumberOfThreads(_RAII):
1523 """Proxy of C++ IMP::SetNumberOfThreads class"""
1524 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
1526 def __init__(self, *args):
1528 __init__(IMP::SetNumberOfThreads self) -> SetNumberOfThreads
1529 __init__(IMP::SetNumberOfThreads self, unsigned int n) -> SetNumberOfThreads
1531 this = _IMP_kernel.new_SetNumberOfThreads(*args)
1533 self.this.append(this)
1538 """set(SetNumberOfThreads self, unsigned int n)"""
1539 return _IMP_kernel.SetNumberOfThreads_set(self, n)
1543 """reset(SetNumberOfThreads self)"""
1544 return _IMP_kernel.SetNumberOfThreads_reset(self)
1546 __swig_destroy__ = _IMP_kernel.delete_SetNumberOfThreads
1547 __del__ =
lambda self:
None
1549 def show(self, *args):
1551 show(SetNumberOfThreads self, _ostream out)
1552 show(SetNumberOfThreads self)
1554 return _IMP_kernel.SetNumberOfThreads_show(self, *args)
1557 def __enter__(self):
1559 def __exit__(self, exc_type, exc_val, exc_tb):
1565 """__str__(SetNumberOfThreads self) -> std::string"""
1566 return _IMP_kernel.SetNumberOfThreads___str__(self)
1570 """__repr__(SetNumberOfThreads self) -> std::string"""
1571 return _IMP_kernel.SetNumberOfThreads___repr__(self)
1573 SetNumberOfThreads_swigregister = _IMP_kernel.SetNumberOfThreads_swigregister
1574 SetNumberOfThreads_swigregister(SetNumberOfThreads)
1578 i_m_p=
"IMP_MODULE_PATH"
1579 if i_m_p
in os.environ.keys():
1580 __path__.insert(0, os.environ[i_m_p])
1582 def _forward_add_attribute(self, name, value, opt=None):
1584 self.get_particle().add_attribute(name, value, opt)
1586 self.get_particle().add_attribute(name, value)
1587 def _forward_get_value(self, name):
1588 self.get_particle().get_value(name)
1589 def _forward_set_value(self, name, value):
1590 self.get_particle().set_value(name, value)
1596 _object_types.append(
"Constraint")
1599 def _object_cast_to_Constraint(o):
1600 """_object_cast_to_Constraint(Object o) -> Constraint"""
1601 return _IMP_kernel._object_cast_to_Constraint(o)
1603 _object_types.append(
"Undecorator")
1606 def _object_cast_to_Undecorator(o):
1607 """_object_cast_to_Undecorator(Object o) -> Undecorator"""
1608 return _IMP_kernel._object_cast_to_Undecorator(o)
1610 _object_types.append(
"Container")
1613 def _object_cast_to_Container(o):
1614 """_object_cast_to_Container(Object o) -> Container"""
1615 return _IMP_kernel._object_cast_to_Container(o)
1617 _object_types.append(
"Optimizer")
1620 def _object_cast_to_Optimizer(o):
1621 """_object_cast_to_Optimizer(Object o) -> Optimizer"""
1622 return _IMP_kernel._object_cast_to_Optimizer(o)
1624 _object_types.append(
"AttributeOptimizer")
1627 def _object_cast_to_AttributeOptimizer(o):
1628 """_object_cast_to_AttributeOptimizer(Object o) -> AttributeOptimizer"""
1629 return _IMP_kernel._object_cast_to_AttributeOptimizer(o)
1631 _object_types.append(
"OptimizerState")
1634 def _object_cast_to_OptimizerState(o):
1635 """_object_cast_to_OptimizerState(Object o) -> OptimizerState"""
1636 return _IMP_kernel._object_cast_to_OptimizerState(o)
1638 _object_types.append(
"PairContainer")
1641 def _object_cast_to_PairContainer(o):
1642 """_object_cast_to_PairContainer(Object o) -> PairContainer"""
1643 return _IMP_kernel._object_cast_to_PairContainer(o)
1645 _object_types.append(
"PairModifier")
1648 def _object_cast_to_PairModifier(o):
1649 """_object_cast_to_PairModifier(Object o) -> PairModifier"""
1650 return _IMP_kernel._object_cast_to_PairModifier(o)
1652 _object_types.append(
"PairScore")
1655 def _object_cast_to_PairScore(o):
1656 """_object_cast_to_PairScore(Object o) -> PairScore"""
1657 return _IMP_kernel._object_cast_to_PairScore(o)
1659 _object_types.append(
"QuadContainer")
1662 def _object_cast_to_QuadContainer(o):
1663 """_object_cast_to_QuadContainer(Object o) -> QuadContainer"""
1664 return _IMP_kernel._object_cast_to_QuadContainer(o)
1666 _object_types.append(
"QuadModifier")
1669 def _object_cast_to_QuadModifier(o):
1670 """_object_cast_to_QuadModifier(Object o) -> QuadModifier"""
1671 return _IMP_kernel._object_cast_to_QuadModifier(o)
1673 _object_types.append(
"QuadScore")
1676 def _object_cast_to_QuadScore(o):
1677 """_object_cast_to_QuadScore(Object o) -> QuadScore"""
1678 return _IMP_kernel._object_cast_to_QuadScore(o)
1680 _object_types.append(
"Refiner")
1683 def _object_cast_to_Refiner(o):
1684 """_object_cast_to_Refiner(Object o) -> Refiner"""
1685 return _IMP_kernel._object_cast_to_Refiner(o)
1687 _object_types.append(
"Restraint")
1690 def _object_cast_to_Restraint(o):
1691 """_object_cast_to_Restraint(Object o) -> Restraint"""
1692 return _IMP_kernel._object_cast_to_Restraint(o)
1694 _object_types.append(
"Sampler")
1697 def _object_cast_to_Sampler(o):
1698 """_object_cast_to_Sampler(Object o) -> Sampler"""
1699 return _IMP_kernel._object_cast_to_Sampler(o)
1701 _object_types.append(
"ScoreState")
1704 def _object_cast_to_ScoreState(o):
1705 """_object_cast_to_ScoreState(Object o) -> ScoreState"""
1706 return _IMP_kernel._object_cast_to_ScoreState(o)
1708 _object_types.append(
"SingletonContainer")
1711 def _object_cast_to_SingletonContainer(o):
1712 """_object_cast_to_SingletonContainer(Object o) -> SingletonContainer"""
1713 return _IMP_kernel._object_cast_to_SingletonContainer(o)
1715 _object_types.append(
"SingletonModifier")
1718 def _object_cast_to_SingletonModifier(o):
1719 """_object_cast_to_SingletonModifier(Object o) -> SingletonModifier"""
1720 return _IMP_kernel._object_cast_to_SingletonModifier(o)
1722 _object_types.append(
"SingletonScore")
1725 def _object_cast_to_SingletonScore(o):
1726 """_object_cast_to_SingletonScore(Object o) -> SingletonScore"""
1727 return _IMP_kernel._object_cast_to_SingletonScore(o)
1729 _object_types.append(
"TripletContainer")
1732 def _object_cast_to_TripletContainer(o):
1733 """_object_cast_to_TripletContainer(Object o) -> TripletContainer"""
1734 return _IMP_kernel._object_cast_to_TripletContainer(o)
1736 _object_types.append(
"TripletModifier")
1739 def _object_cast_to_TripletModifier(o):
1740 """_object_cast_to_TripletModifier(Object o) -> TripletModifier"""
1741 return _IMP_kernel._object_cast_to_TripletModifier(o)
1743 _object_types.append(
"TripletScore")
1746 def _object_cast_to_TripletScore(o):
1747 """_object_cast_to_TripletScore(Object o) -> TripletScore"""
1748 return _IMP_kernel._object_cast_to_TripletScore(o)
1750 _object_types.append(
"UnaryFunction")
1753 def _object_cast_to_UnaryFunction(o):
1754 """_object_cast_to_UnaryFunction(Object o) -> UnaryFunction"""
1755 return _IMP_kernel._object_cast_to_UnaryFunction(o)
1757 _object_types.append(
"RestraintInfo")
1760 def _object_cast_to_RestraintInfo(o):
1761 """_object_cast_to_RestraintInfo(Object o) -> RestraintInfo"""
1762 return _IMP_kernel._object_cast_to_RestraintInfo(o)
1764 _object_types.append(
"ConfigurationSet")
1767 def _object_cast_to_ConfigurationSet(o):
1768 """_object_cast_to_ConfigurationSet(Object o) -> ConfigurationSet"""
1769 return _IMP_kernel._object_cast_to_ConfigurationSet(o)
1771 _object_types.append(
"Configuration")
1774 def _object_cast_to_Configuration(o):
1775 """_object_cast_to_Configuration(Object o) -> Configuration"""
1776 return _IMP_kernel._object_cast_to_Configuration(o)
1778 _object_types.append(
"Model")
1781 def _object_cast_to_Model(o):
1782 """_object_cast_to_Model(Object o) -> Model"""
1783 return _IMP_kernel._object_cast_to_Model(o)
1785 _object_types.append(
"Particle")
1788 def _object_cast_to_Particle(o):
1789 """_object_cast_to_Particle(Object o) -> Particle"""
1790 return _IMP_kernel._object_cast_to_Particle(o)
1792 _object_types.append(
"RestraintSet")
1795 def _object_cast_to_RestraintSet(o):
1796 """_object_cast_to_RestraintSet(Object o) -> RestraintSet"""
1797 return _IMP_kernel._object_cast_to_RestraintSet(o)
1799 ParticlePairsTemp=list
1800 _plural_types.append(
"ParticlePairsTemp")
1801 _value_types.append(
"ParticlePair")
1804 ParticleTripletsTemp=list
1805 _plural_types.append(
"ParticleTripletsTemp")
1806 _value_types.append(
"ParticleTriplet")
1809 ParticleQuadsTemp=list
1810 _plural_types.append(
"ParticleQuadsTemp")
1811 _value_types.append(
"ParticleQuad")
1814 ParticleIndexPairs=list
1815 _plural_types.append(
"ParticleIndexPairs")
1816 _value_types.append(
"ParticleIndexPair")
1819 ParticleIndexTriplets=list
1820 _plural_types.append(
"ParticleIndexTriplets")
1821 _value_types.append(
"ParticleIndexTriplet")
1824 ParticleIndexQuads=list
1825 _plural_types.append(
"ParticleIndexQuads")
1826 _value_types.append(
"ParticleIndexQuad")
1829 _object_types.append(
"SingletonPredicate")
1832 def _object_cast_to_SingletonPredicate(o):
1833 """_object_cast_to_SingletonPredicate(Object o) -> SingletonPredicate"""
1834 return _IMP_kernel._object_cast_to_SingletonPredicate(o)
1836 _object_types.append(
"PairPredicate")
1839 def _object_cast_to_PairPredicate(o):
1840 """_object_cast_to_PairPredicate(Object o) -> PairPredicate"""
1841 return _IMP_kernel._object_cast_to_PairPredicate(o)
1843 _object_types.append(
"TripletPredicate")
1846 def _object_cast_to_TripletPredicate(o):
1847 """_object_cast_to_TripletPredicate(Object o) -> TripletPredicate"""
1848 return _IMP_kernel._object_cast_to_TripletPredicate(o)
1850 _object_types.append(
"QuadPredicate")
1853 def _object_cast_to_QuadPredicate(o):
1854 """_object_cast_to_QuadPredicate(Object o) -> QuadPredicate"""
1855 return _IMP_kernel._object_cast_to_QuadPredicate(o)
1857 _object_types.append(
"SaveToConfigurationSetOptimizerState")
1860 def _object_cast_to_SaveToConfigurationSetOptimizerState(o):
1861 """_object_cast_to_SaveToConfigurationSetOptimizerState(Object o) -> SaveToConfigurationSetOptimizerState"""
1862 return _IMP_kernel._object_cast_to_SaveToConfigurationSetOptimizerState(o)
1864 EvaluationStates=list
1865 _plural_types.append(
"EvaluationStates")
1866 _value_types.append(
"EvaluationState")
1869 ScoreAccumulators=list
1870 _plural_types.append(
"ScoreAccumulators")
1871 _value_types.append(
"ScoreAccumulator")
1874 ParticleIndexes=list
1875 _plural_types.append(
"ParticleIndexes")
1876 _value_types.append(
"ParticleIndex")
1880 _plural_types.append(
"FloatIndexes")
1881 _value_types.append(
"FloatIndex")
1885 _plural_types.append(
"FloatKeys")
1886 _value_types.append(
"FloatKey")
1890 _plural_types.append(
"FloatsKeys")
1891 _value_types.append(
"FloatsKey")
1895 _plural_types.append(
"IntKeys")
1896 _value_types.append(
"IntKey")
1900 _plural_types.append(
"IntsKeys")
1901 _value_types.append(
"IntsKey")
1905 _plural_types.append(
"StringKeys")
1906 _value_types.append(
"StringKey")
1909 ParticleIndexKeys=list
1910 _plural_types.append(
"ParticleIndexKeys")
1911 _value_types.append(
"ParticleIndexKey")
1914 ParticleIndexesKeys=list
1915 _plural_types.append(
"ParticleIndexesKeys")
1916 _value_types.append(
"ParticleIndexesKey")
1920 _plural_types.append(
"ObjectKeys")
1921 _value_types.append(
"ObjectKey")
1925 _plural_types.append(
"ModelKeys")
1926 _value_types.append(
"ModelKey")
1929 _raii_types.append(
"ScopedSetFloatAttribute")
1932 _object_types.append(
"ScoringFunction")
1935 def _object_cast_to_ScoringFunction(o):
1936 """_object_cast_to_ScoringFunction(Object o) -> ScoringFunction"""
1937 return _IMP_kernel._object_cast_to_ScoringFunction(o)
1939 _object_types.append(
"ModelObject")
1942 def _object_cast_to_ModelObject(o):
1943 """_object_cast_to_ModelObject(Object o) -> ModelObject"""
1944 return _IMP_kernel._object_cast_to_ModelObject(o)
1946 def _TrivialDecorators(l=[]):
1947 return [_TrivialDecorator(x)
for x
in l]
1948 _plural_types.append(
"_TrivialDecorators")
1951 _value_types.append(
"_TrivialDecorator")
1954 def _TrivialDerivedDecorators(l=[]):
1955 return [_TrivialDerivedDecorator(x)
for x
in l]
1956 _plural_types.append(
"_TrivialDerivedDecorators")
1959 _value_types.append(
"_TrivialDerivedDecorator")
1962 def _TrivialTraitsDecorators(l=[]):
1963 return [_TrivialTraitsDecorator(x)
for x
in l]
1964 _plural_types.append(
"_TrivialTraitsDecorators")
1967 _value_types.append(
"_TrivialTraitsDecorator")
1970 _object_types.append(
"_ConstRestraint")
1973 def _object_cast_to__ConstRestraint(o):
1974 """_object_cast_to__ConstRestraint(Object o) -> _ConstRestraint"""
1975 return _IMP_kernel._object_cast_to__ConstRestraint(o)
1977 _object_types.append(
"_ConstOptimizer")
1980 def _object_cast_to__ConstOptimizer(o):
1981 """_object_cast_to__ConstOptimizer(Object o) -> _ConstOptimizer"""
1982 return _IMP_kernel._object_cast_to__ConstOptimizer(o)
1984 """Proxy of C++ IMP::internal::BoostDigraph<(IMP::DependencyGraph,p.IMP::ModelObject,IMP::ShowDependencyGraphVertex)> class"""
1985 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
1986 __repr__ = _swig_repr
1989 """__init__(IMP::internal::BoostDigraph<(IMP::DependencyGraph,p.IMP::ModelObject,IMP::ShowDependencyGraphVertex)> self) -> DependencyGraph"""
1990 this = _IMP_kernel.new_DependencyGraph()
1992 self.this.append(this)
1996 def get_graph(self):
1997 """get_graph(DependencyGraph self) -> IMP::DependencyGraph const &"""
1998 return _IMP_kernel.DependencyGraph_get_graph(self)
2002 """get_vertices(DependencyGraph self) -> IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptors"""
2003 return _IMP_kernel.DependencyGraph_get_vertices(self)
2006 def get_vertex_name(self, i):
2007 """get_vertex_name(DependencyGraph self, IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptor i) -> ModelObject"""
2008 return _IMP_kernel.DependencyGraph_get_vertex_name(self, i)
2011 def get_in_neighbors(self, v):
2012 """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"""
2013 return _IMP_kernel.DependencyGraph_get_in_neighbors(self, v)
2016 def get_out_neighbors(self, v):
2017 """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"""
2018 return _IMP_kernel.DependencyGraph_get_out_neighbors(self, v)
2023 show_graphviz(DependencyGraph self, _ostream out)
2024 show_graphviz(DependencyGraph self)
2026 return _IMP_kernel.DependencyGraph_show_graphviz(self, *args)
2029 def get_graphviz_string(self):
2030 """get_graphviz_string(DependencyGraph self) -> std::string"""
2031 return _IMP_kernel.DependencyGraph_get_graphviz_string(self)
2034 def add_edge(self, v0, v1):
2035 """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)"""
2036 return _IMP_kernel.DependencyGraph_add_edge(self, v0, v1)
2039 def add_vertex(self, l):
2040 """add_vertex(DependencyGraph self, ModelObject l) -> IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptor"""
2041 return _IMP_kernel.DependencyGraph_add_vertex(self, l)
2044 def remove_vertex(self, l):
2045 """remove_vertex(DependencyGraph self, IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptor l)"""
2046 return _IMP_kernel.DependencyGraph_remove_vertex(self, l)
2048 __swig_destroy__ = _IMP_kernel.delete_DependencyGraph
2049 __del__ =
lambda self:
None
2050 DependencyGraph_swigregister = _IMP_kernel.DependencyGraph_swigregister
2051 DependencyGraph_swigregister(DependencyGraph)
2054 _value_types.append(
"DependencyGraph")
2057 """Proxy of C++ IMP::Key<(0)> class"""
2058 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
2060 def __init__(self, *args):
2062 __init__(IMP::Key<(0)> self) -> FloatKey
2063 __init__(IMP::Key<(0)> self, std::string const & c, bool is_implicit_add_permitted=True) -> FloatKey
2064 __init__(IMP::Key<(0)> self, std::string const & c) -> FloatKey
2065 __init__(IMP::Key<(0)> self, unsigned int i) -> FloatKey
2067 this = _IMP_kernel.new_FloatKey(*args)
2069 self.this.append(this)
2074 """add_key(std::string sc) -> unsigned int"""
2075 return _IMP_kernel.FloatKey_add_key(sc)
2077 add_key = staticmethod(add_key)
2079 def get_key_exists(sc):
2080 """get_key_exists(std::string sc) -> bool"""
2081 return _IMP_kernel.FloatKey_get_key_exists(sc)
2083 get_key_exists = staticmethod(get_key_exists)
2085 def get_string(self):
2086 """get_string(FloatKey self) -> std::string const"""
2087 return _IMP_kernel.FloatKey_get_string(self)
2090 def __cmp__(self, o):
2091 """__cmp__(FloatKey self, FloatKey o) -> int"""
2092 return _IMP_kernel.FloatKey___cmp__(self, o)
2095 def __eq__(self, o):
2096 """__eq__(FloatKey self, FloatKey o) -> bool"""
2097 return _IMP_kernel.FloatKey___eq__(self, o)
2100 def __ne__(self, o):
2101 """__ne__(FloatKey self, FloatKey o) -> bool"""
2102 return _IMP_kernel.FloatKey___ne__(self, o)
2105 def __lt__(self, o):
2106 """__lt__(FloatKey self, FloatKey o) -> bool"""
2107 return _IMP_kernel.FloatKey___lt__(self, o)
2110 def __gt__(self, o):
2111 """__gt__(FloatKey self, FloatKey o) -> bool"""
2112 return _IMP_kernel.FloatKey___gt__(self, o)
2115 def __ge__(self, o):
2116 """__ge__(FloatKey self, FloatKey o) -> bool"""
2117 return _IMP_kernel.FloatKey___ge__(self, o)
2120 def __le__(self, o):
2121 """__le__(FloatKey self, FloatKey o) -> bool"""
2122 return _IMP_kernel.FloatKey___le__(self, o)
2126 """__hash__(FloatKey self) -> std::size_t"""
2127 return _IMP_kernel.FloatKey___hash__(self)
2130 def show(self, *args):
2132 show(FloatKey self, _ostream out)
2135 return _IMP_kernel.FloatKey_show(self, *args)
2138 def add_alias(old_key, new_name):
2139 """add_alias(FloatKey old_key, std::string new_name) -> FloatKey"""
2140 return _IMP_kernel.FloatKey_add_alias(old_key, new_name)
2142 add_alias = staticmethod(add_alias)
2144 def get_number_of_keys():
2145 """get_number_of_keys() -> unsigned int"""
2146 return _IMP_kernel.FloatKey_get_number_of_keys()
2148 get_number_of_keys = staticmethod(get_number_of_keys)
2151 """get_index(FloatKey self) -> unsigned int"""
2152 return _IMP_kernel.FloatKey_get_index(self)
2156 """show_all(_ostream out)"""
2157 return _IMP_kernel.FloatKey_show_all(out)
2159 show_all = staticmethod(show_all)
2161 def get_all_strings():
2162 """get_all_strings() -> IMP::Vector< std::string >"""
2163 return _IMP_kernel.FloatKey_get_all_strings()
2165 get_all_strings = staticmethod(get_all_strings)
2167 def get_number_unique():
2168 """get_number_unique() -> unsigned int"""
2169 return _IMP_kernel.FloatKey_get_number_unique()
2171 get_number_unique = staticmethod(get_number_unique)
2174 """__str__(FloatKey self) -> std::string"""
2175 return _IMP_kernel.FloatKey___str__(self)
2179 """__repr__(FloatKey self) -> std::string"""
2180 return _IMP_kernel.FloatKey___repr__(self)
2182 __swig_destroy__ = _IMP_kernel.delete_FloatKey
2183 __del__ =
lambda self:
None
2184 FloatKey_swigregister = _IMP_kernel.FloatKey_swigregister
2185 FloatKey_swigregister(FloatKey)
2187 def FloatKey_add_key(sc):
2188 """FloatKey_add_key(std::string sc) -> unsigned int"""
2189 return _IMP_kernel.FloatKey_add_key(sc)
2191 def FloatKey_get_key_exists(sc):
2192 """FloatKey_get_key_exists(std::string sc) -> bool"""
2193 return _IMP_kernel.FloatKey_get_key_exists(sc)
2195 def FloatKey_add_alias(old_key, new_name):
2196 """FloatKey_add_alias(FloatKey old_key, std::string new_name) -> FloatKey"""
2197 return _IMP_kernel.FloatKey_add_alias(old_key, new_name)
2199 def FloatKey_get_number_of_keys():
2200 """FloatKey_get_number_of_keys() -> unsigned int"""
2201 return _IMP_kernel.FloatKey_get_number_of_keys()
2203 def FloatKey_show_all(out):
2204 """FloatKey_show_all(_ostream out)"""
2205 return _IMP_kernel.FloatKey_show_all(out)
2207 def FloatKey_get_all_strings():
2208 """FloatKey_get_all_strings() -> IMP::Vector< std::string >"""
2209 return _IMP_kernel.FloatKey_get_all_strings()
2211 def FloatKey_get_number_unique():
2212 """FloatKey_get_number_unique() -> unsigned int"""
2213 return _IMP_kernel.FloatKey_get_number_unique()
2216 """Proxy of C++ IMP::Key<(1)> class"""
2217 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
2219 def __init__(self, *args):
2221 __init__(IMP::Key<(1)> self) -> IntKey
2222 __init__(IMP::Key<(1)> self, std::string const & c, bool is_implicit_add_permitted=True) -> IntKey
2223 __init__(IMP::Key<(1)> self, std::string const & c) -> IntKey
2224 __init__(IMP::Key<(1)> self, unsigned int i) -> IntKey
2226 this = _IMP_kernel.new_IntKey(*args)
2228 self.this.append(this)
2233 """add_key(std::string sc) -> unsigned int"""
2234 return _IMP_kernel.IntKey_add_key(sc)
2236 add_key = staticmethod(add_key)
2238 def get_key_exists(sc):
2239 """get_key_exists(std::string sc) -> bool"""
2240 return _IMP_kernel.IntKey_get_key_exists(sc)
2242 get_key_exists = staticmethod(get_key_exists)
2244 def get_string(self):
2245 """get_string(IntKey self) -> std::string const"""
2246 return _IMP_kernel.IntKey_get_string(self)
2249 def __cmp__(self, o):
2250 """__cmp__(IntKey self, IntKey o) -> int"""
2251 return _IMP_kernel.IntKey___cmp__(self, o)
2254 def __eq__(self, o):
2255 """__eq__(IntKey self, IntKey o) -> bool"""
2256 return _IMP_kernel.IntKey___eq__(self, o)
2259 def __ne__(self, o):
2260 """__ne__(IntKey self, IntKey o) -> bool"""
2261 return _IMP_kernel.IntKey___ne__(self, o)
2264 def __lt__(self, o):
2265 """__lt__(IntKey self, IntKey o) -> bool"""
2266 return _IMP_kernel.IntKey___lt__(self, o)
2269 def __gt__(self, o):
2270 """__gt__(IntKey self, IntKey o) -> bool"""
2271 return _IMP_kernel.IntKey___gt__(self, o)
2274 def __ge__(self, o):
2275 """__ge__(IntKey self, IntKey o) -> bool"""
2276 return _IMP_kernel.IntKey___ge__(self, o)
2279 def __le__(self, o):
2280 """__le__(IntKey self, IntKey o) -> bool"""
2281 return _IMP_kernel.IntKey___le__(self, o)
2285 """__hash__(IntKey self) -> std::size_t"""
2286 return _IMP_kernel.IntKey___hash__(self)
2289 def show(self, *args):
2291 show(IntKey self, _ostream out)
2294 return _IMP_kernel.IntKey_show(self, *args)
2297 def add_alias(old_key, new_name):
2298 """add_alias(IntKey old_key, std::string new_name) -> IntKey"""
2299 return _IMP_kernel.IntKey_add_alias(old_key, new_name)
2301 add_alias = staticmethod(add_alias)
2303 def get_number_of_keys():
2304 """get_number_of_keys() -> unsigned int"""
2305 return _IMP_kernel.IntKey_get_number_of_keys()
2307 get_number_of_keys = staticmethod(get_number_of_keys)
2310 """get_index(IntKey self) -> unsigned int"""
2311 return _IMP_kernel.IntKey_get_index(self)
2315 """show_all(_ostream out)"""
2316 return _IMP_kernel.IntKey_show_all(out)
2318 show_all = staticmethod(show_all)
2320 def get_all_strings():
2321 """get_all_strings() -> IMP::Vector< std::string >"""
2322 return _IMP_kernel.IntKey_get_all_strings()
2324 get_all_strings = staticmethod(get_all_strings)
2326 def get_number_unique():
2327 """get_number_unique() -> unsigned int"""
2328 return _IMP_kernel.IntKey_get_number_unique()
2330 get_number_unique = staticmethod(get_number_unique)
2333 """__str__(IntKey self) -> std::string"""
2334 return _IMP_kernel.IntKey___str__(self)
2338 """__repr__(IntKey self) -> std::string"""
2339 return _IMP_kernel.IntKey___repr__(self)
2341 __swig_destroy__ = _IMP_kernel.delete_IntKey
2342 __del__ =
lambda self:
None
2343 IntKey_swigregister = _IMP_kernel.IntKey_swigregister
2344 IntKey_swigregister(IntKey)
2346 def IntKey_add_key(sc):
2347 """IntKey_add_key(std::string sc) -> unsigned int"""
2348 return _IMP_kernel.IntKey_add_key(sc)
2350 def IntKey_get_key_exists(sc):
2351 """IntKey_get_key_exists(std::string sc) -> bool"""
2352 return _IMP_kernel.IntKey_get_key_exists(sc)
2354 def IntKey_add_alias(old_key, new_name):
2355 """IntKey_add_alias(IntKey old_key, std::string new_name) -> IntKey"""
2356 return _IMP_kernel.IntKey_add_alias(old_key, new_name)
2358 def IntKey_get_number_of_keys():
2359 """IntKey_get_number_of_keys() -> unsigned int"""
2360 return _IMP_kernel.IntKey_get_number_of_keys()
2362 def IntKey_show_all(out):
2363 """IntKey_show_all(_ostream out)"""
2364 return _IMP_kernel.IntKey_show_all(out)
2366 def IntKey_get_all_strings():
2367 """IntKey_get_all_strings() -> IMP::Vector< std::string >"""
2368 return _IMP_kernel.IntKey_get_all_strings()
2370 def IntKey_get_number_unique():
2371 """IntKey_get_number_unique() -> unsigned int"""
2372 return _IMP_kernel.IntKey_get_number_unique()
2375 """Proxy of C++ IMP::Key<(2)> class"""
2376 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
2378 def __init__(self, *args):
2380 __init__(IMP::Key<(2)> self) -> StringKey
2381 __init__(IMP::Key<(2)> self, std::string const & c, bool is_implicit_add_permitted=True) -> StringKey
2382 __init__(IMP::Key<(2)> self, std::string const & c) -> StringKey
2383 __init__(IMP::Key<(2)> self, unsigned int i) -> StringKey
2385 this = _IMP_kernel.new_StringKey(*args)
2387 self.this.append(this)
2392 """add_key(std::string sc) -> unsigned int"""
2393 return _IMP_kernel.StringKey_add_key(sc)
2395 add_key = staticmethod(add_key)
2397 def get_key_exists(sc):
2398 """get_key_exists(std::string sc) -> bool"""
2399 return _IMP_kernel.StringKey_get_key_exists(sc)
2401 get_key_exists = staticmethod(get_key_exists)
2403 def get_string(self):
2404 """get_string(StringKey self) -> std::string const"""
2405 return _IMP_kernel.StringKey_get_string(self)
2408 def __cmp__(self, o):
2409 """__cmp__(StringKey self, StringKey o) -> int"""
2410 return _IMP_kernel.StringKey___cmp__(self, o)
2413 def __eq__(self, o):
2414 """__eq__(StringKey self, StringKey o) -> bool"""
2415 return _IMP_kernel.StringKey___eq__(self, o)
2418 def __ne__(self, o):
2419 """__ne__(StringKey self, StringKey o) -> bool"""
2420 return _IMP_kernel.StringKey___ne__(self, o)
2423 def __lt__(self, o):
2424 """__lt__(StringKey self, StringKey o) -> bool"""
2425 return _IMP_kernel.StringKey___lt__(self, o)
2428 def __gt__(self, o):
2429 """__gt__(StringKey self, StringKey o) -> bool"""
2430 return _IMP_kernel.StringKey___gt__(self, o)
2433 def __ge__(self, o):
2434 """__ge__(StringKey self, StringKey o) -> bool"""
2435 return _IMP_kernel.StringKey___ge__(self, o)
2438 def __le__(self, o):
2439 """__le__(StringKey self, StringKey o) -> bool"""
2440 return _IMP_kernel.StringKey___le__(self, o)
2444 """__hash__(StringKey self) -> std::size_t"""
2445 return _IMP_kernel.StringKey___hash__(self)
2448 def show(self, *args):
2450 show(StringKey self, _ostream out)
2451 show(StringKey self)
2453 return _IMP_kernel.StringKey_show(self, *args)
2456 def add_alias(old_key, new_name):
2457 """add_alias(StringKey old_key, std::string new_name) -> StringKey"""
2458 return _IMP_kernel.StringKey_add_alias(old_key, new_name)
2460 add_alias = staticmethod(add_alias)
2462 def get_number_of_keys():
2463 """get_number_of_keys() -> unsigned int"""
2464 return _IMP_kernel.StringKey_get_number_of_keys()
2466 get_number_of_keys = staticmethod(get_number_of_keys)
2469 """get_index(StringKey self) -> unsigned int"""
2470 return _IMP_kernel.StringKey_get_index(self)
2474 """show_all(_ostream out)"""
2475 return _IMP_kernel.StringKey_show_all(out)
2477 show_all = staticmethod(show_all)
2479 def get_all_strings():
2480 """get_all_strings() -> IMP::Vector< std::string >"""
2481 return _IMP_kernel.StringKey_get_all_strings()
2483 get_all_strings = staticmethod(get_all_strings)
2485 def get_number_unique():
2486 """get_number_unique() -> unsigned int"""
2487 return _IMP_kernel.StringKey_get_number_unique()
2489 get_number_unique = staticmethod(get_number_unique)
2492 """__str__(StringKey self) -> std::string"""
2493 return _IMP_kernel.StringKey___str__(self)
2497 """__repr__(StringKey self) -> std::string"""
2498 return _IMP_kernel.StringKey___repr__(self)
2500 __swig_destroy__ = _IMP_kernel.delete_StringKey
2501 __del__ =
lambda self:
None
2502 StringKey_swigregister = _IMP_kernel.StringKey_swigregister
2503 StringKey_swigregister(StringKey)
2505 def StringKey_add_key(sc):
2506 """StringKey_add_key(std::string sc) -> unsigned int"""
2507 return _IMP_kernel.StringKey_add_key(sc)
2509 def StringKey_get_key_exists(sc):
2510 """StringKey_get_key_exists(std::string sc) -> bool"""
2511 return _IMP_kernel.StringKey_get_key_exists(sc)
2513 def StringKey_add_alias(old_key, new_name):
2514 """StringKey_add_alias(StringKey old_key, std::string new_name) -> StringKey"""
2515 return _IMP_kernel.StringKey_add_alias(old_key, new_name)
2517 def StringKey_get_number_of_keys():
2518 """StringKey_get_number_of_keys() -> unsigned int"""
2519 return _IMP_kernel.StringKey_get_number_of_keys()
2521 def StringKey_show_all(out):
2522 """StringKey_show_all(_ostream out)"""
2523 return _IMP_kernel.StringKey_show_all(out)
2525 def StringKey_get_all_strings():
2526 """StringKey_get_all_strings() -> IMP::Vector< std::string >"""
2527 return _IMP_kernel.StringKey_get_all_strings()
2529 def StringKey_get_number_unique():
2530 """StringKey_get_number_unique() -> unsigned int"""
2531 return _IMP_kernel.StringKey_get_number_unique()
2534 """Proxy of C++ IMP::Key<(3)> class"""
2535 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
2537 def __init__(self, *args):
2539 __init__(IMP::Key<(3)> self) -> ParticleIndexKey
2540 __init__(IMP::Key<(3)> self, std::string const & c, bool is_implicit_add_permitted=True) -> ParticleIndexKey
2541 __init__(IMP::Key<(3)> self, std::string const & c) -> ParticleIndexKey
2542 __init__(IMP::Key<(3)> self, unsigned int i) -> ParticleIndexKey
2544 this = _IMP_kernel.new_ParticleIndexKey(*args)
2546 self.this.append(this)
2551 """add_key(std::string sc) -> unsigned int"""
2552 return _IMP_kernel.ParticleIndexKey_add_key(sc)
2554 add_key = staticmethod(add_key)
2556 def get_key_exists(sc):
2557 """get_key_exists(std::string sc) -> bool"""
2558 return _IMP_kernel.ParticleIndexKey_get_key_exists(sc)
2560 get_key_exists = staticmethod(get_key_exists)
2562 def get_string(self):
2563 """get_string(ParticleIndexKey self) -> std::string const"""
2564 return _IMP_kernel.ParticleIndexKey_get_string(self)
2567 def __cmp__(self, o):
2568 """__cmp__(ParticleIndexKey self, ParticleIndexKey o) -> int"""
2569 return _IMP_kernel.ParticleIndexKey___cmp__(self, o)
2572 def __eq__(self, o):
2573 """__eq__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2574 return _IMP_kernel.ParticleIndexKey___eq__(self, o)
2577 def __ne__(self, o):
2578 """__ne__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2579 return _IMP_kernel.ParticleIndexKey___ne__(self, o)
2582 def __lt__(self, o):
2583 """__lt__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2584 return _IMP_kernel.ParticleIndexKey___lt__(self, o)
2587 def __gt__(self, o):
2588 """__gt__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2589 return _IMP_kernel.ParticleIndexKey___gt__(self, o)
2592 def __ge__(self, o):
2593 """__ge__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2594 return _IMP_kernel.ParticleIndexKey___ge__(self, o)
2597 def __le__(self, o):
2598 """__le__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2599 return _IMP_kernel.ParticleIndexKey___le__(self, o)
2603 """__hash__(ParticleIndexKey self) -> std::size_t"""
2604 return _IMP_kernel.ParticleIndexKey___hash__(self)
2607 def show(self, *args):
2609 show(ParticleIndexKey self, _ostream out)
2610 show(ParticleIndexKey self)
2612 return _IMP_kernel.ParticleIndexKey_show(self, *args)
2615 def add_alias(old_key, new_name):
2616 """add_alias(ParticleIndexKey old_key, std::string new_name) -> ParticleIndexKey"""
2617 return _IMP_kernel.ParticleIndexKey_add_alias(old_key, new_name)
2619 add_alias = staticmethod(add_alias)
2621 def get_number_of_keys():
2622 """get_number_of_keys() -> unsigned int"""
2623 return _IMP_kernel.ParticleIndexKey_get_number_of_keys()
2625 get_number_of_keys = staticmethod(get_number_of_keys)
2628 """get_index(ParticleIndexKey self) -> unsigned int"""
2629 return _IMP_kernel.ParticleIndexKey_get_index(self)
2633 """show_all(_ostream out)"""
2634 return _IMP_kernel.ParticleIndexKey_show_all(out)
2636 show_all = staticmethod(show_all)
2638 def get_all_strings():
2639 """get_all_strings() -> IMP::Vector< std::string >"""
2640 return _IMP_kernel.ParticleIndexKey_get_all_strings()
2642 get_all_strings = staticmethod(get_all_strings)
2644 def get_number_unique():
2645 """get_number_unique() -> unsigned int"""
2646 return _IMP_kernel.ParticleIndexKey_get_number_unique()
2648 get_number_unique = staticmethod(get_number_unique)
2651 """__str__(ParticleIndexKey self) -> std::string"""
2652 return _IMP_kernel.ParticleIndexKey___str__(self)
2656 """__repr__(ParticleIndexKey self) -> std::string"""
2657 return _IMP_kernel.ParticleIndexKey___repr__(self)
2659 __swig_destroy__ = _IMP_kernel.delete_ParticleIndexKey
2660 __del__ =
lambda self:
None
2661 ParticleIndexKey_swigregister = _IMP_kernel.ParticleIndexKey_swigregister
2662 ParticleIndexKey_swigregister(ParticleIndexKey)
2664 def ParticleIndexKey_add_key(sc):
2665 """ParticleIndexKey_add_key(std::string sc) -> unsigned int"""
2666 return _IMP_kernel.ParticleIndexKey_add_key(sc)
2668 def ParticleIndexKey_get_key_exists(sc):
2669 """ParticleIndexKey_get_key_exists(std::string sc) -> bool"""
2670 return _IMP_kernel.ParticleIndexKey_get_key_exists(sc)
2672 def ParticleIndexKey_add_alias(old_key, new_name):
2673 """ParticleIndexKey_add_alias(ParticleIndexKey old_key, std::string new_name) -> ParticleIndexKey"""
2674 return _IMP_kernel.ParticleIndexKey_add_alias(old_key, new_name)
2676 def ParticleIndexKey_get_number_of_keys():
2677 """ParticleIndexKey_get_number_of_keys() -> unsigned int"""
2678 return _IMP_kernel.ParticleIndexKey_get_number_of_keys()
2680 def ParticleIndexKey_show_all(out):
2681 """ParticleIndexKey_show_all(_ostream out)"""
2682 return _IMP_kernel.ParticleIndexKey_show_all(out)
2684 def ParticleIndexKey_get_all_strings():
2685 """ParticleIndexKey_get_all_strings() -> IMP::Vector< std::string >"""
2686 return _IMP_kernel.ParticleIndexKey_get_all_strings()
2688 def ParticleIndexKey_get_number_unique():
2689 """ParticleIndexKey_get_number_unique() -> unsigned int"""
2690 return _IMP_kernel.ParticleIndexKey_get_number_unique()
2693 """Proxy of C++ IMP::Key<(4)> class"""
2694 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
2696 def __init__(self, *args):
2698 __init__(IMP::Key<(4)> self) -> ObjectKey
2699 __init__(IMP::Key<(4)> self, std::string const & c, bool is_implicit_add_permitted=True) -> ObjectKey
2700 __init__(IMP::Key<(4)> self, std::string const & c) -> ObjectKey
2701 __init__(IMP::Key<(4)> self, unsigned int i) -> ObjectKey
2703 this = _IMP_kernel.new_ObjectKey(*args)
2705 self.this.append(this)
2710 """add_key(std::string sc) -> unsigned int"""
2711 return _IMP_kernel.ObjectKey_add_key(sc)
2713 add_key = staticmethod(add_key)
2715 def get_key_exists(sc):
2716 """get_key_exists(std::string sc) -> bool"""
2717 return _IMP_kernel.ObjectKey_get_key_exists(sc)
2719 get_key_exists = staticmethod(get_key_exists)
2721 def get_string(self):
2722 """get_string(ObjectKey self) -> std::string const"""
2723 return _IMP_kernel.ObjectKey_get_string(self)
2726 def __cmp__(self, o):
2727 """__cmp__(ObjectKey self, ObjectKey o) -> int"""
2728 return _IMP_kernel.ObjectKey___cmp__(self, o)
2731 def __eq__(self, o):
2732 """__eq__(ObjectKey self, ObjectKey o) -> bool"""
2733 return _IMP_kernel.ObjectKey___eq__(self, o)
2736 def __ne__(self, o):
2737 """__ne__(ObjectKey self, ObjectKey o) -> bool"""
2738 return _IMP_kernel.ObjectKey___ne__(self, o)
2741 def __lt__(self, o):
2742 """__lt__(ObjectKey self, ObjectKey o) -> bool"""
2743 return _IMP_kernel.ObjectKey___lt__(self, o)
2746 def __gt__(self, o):
2747 """__gt__(ObjectKey self, ObjectKey o) -> bool"""
2748 return _IMP_kernel.ObjectKey___gt__(self, o)
2751 def __ge__(self, o):
2752 """__ge__(ObjectKey self, ObjectKey o) -> bool"""
2753 return _IMP_kernel.ObjectKey___ge__(self, o)
2756 def __le__(self, o):
2757 """__le__(ObjectKey self, ObjectKey o) -> bool"""
2758 return _IMP_kernel.ObjectKey___le__(self, o)
2762 """__hash__(ObjectKey self) -> std::size_t"""
2763 return _IMP_kernel.ObjectKey___hash__(self)
2766 def show(self, *args):
2768 show(ObjectKey self, _ostream out)
2769 show(ObjectKey self)
2771 return _IMP_kernel.ObjectKey_show(self, *args)
2774 def add_alias(old_key, new_name):
2775 """add_alias(ObjectKey old_key, std::string new_name) -> ObjectKey"""
2776 return _IMP_kernel.ObjectKey_add_alias(old_key, new_name)
2778 add_alias = staticmethod(add_alias)
2780 def get_number_of_keys():
2781 """get_number_of_keys() -> unsigned int"""
2782 return _IMP_kernel.ObjectKey_get_number_of_keys()
2784 get_number_of_keys = staticmethod(get_number_of_keys)
2787 """get_index(ObjectKey self) -> unsigned int"""
2788 return _IMP_kernel.ObjectKey_get_index(self)
2792 """show_all(_ostream out)"""
2793 return _IMP_kernel.ObjectKey_show_all(out)
2795 show_all = staticmethod(show_all)
2797 def get_all_strings():
2798 """get_all_strings() -> IMP::Vector< std::string >"""
2799 return _IMP_kernel.ObjectKey_get_all_strings()
2801 get_all_strings = staticmethod(get_all_strings)
2803 def get_number_unique():
2804 """get_number_unique() -> unsigned int"""
2805 return _IMP_kernel.ObjectKey_get_number_unique()
2807 get_number_unique = staticmethod(get_number_unique)
2810 """__str__(ObjectKey self) -> std::string"""
2811 return _IMP_kernel.ObjectKey___str__(self)
2815 """__repr__(ObjectKey self) -> std::string"""
2816 return _IMP_kernel.ObjectKey___repr__(self)
2818 __swig_destroy__ = _IMP_kernel.delete_ObjectKey
2819 __del__ =
lambda self:
None
2820 ObjectKey_swigregister = _IMP_kernel.ObjectKey_swigregister
2821 ObjectKey_swigregister(ObjectKey)
2823 def ObjectKey_add_key(sc):
2824 """ObjectKey_add_key(std::string sc) -> unsigned int"""
2825 return _IMP_kernel.ObjectKey_add_key(sc)
2827 def ObjectKey_get_key_exists(sc):
2828 """ObjectKey_get_key_exists(std::string sc) -> bool"""
2829 return _IMP_kernel.ObjectKey_get_key_exists(sc)
2831 def ObjectKey_add_alias(old_key, new_name):
2832 """ObjectKey_add_alias(ObjectKey old_key, std::string new_name) -> ObjectKey"""
2833 return _IMP_kernel.ObjectKey_add_alias(old_key, new_name)
2835 def ObjectKey_get_number_of_keys():
2836 """ObjectKey_get_number_of_keys() -> unsigned int"""
2837 return _IMP_kernel.ObjectKey_get_number_of_keys()
2839 def ObjectKey_show_all(out):
2840 """ObjectKey_show_all(_ostream out)"""
2841 return _IMP_kernel.ObjectKey_show_all(out)
2843 def ObjectKey_get_all_strings():
2844 """ObjectKey_get_all_strings() -> IMP::Vector< std::string >"""
2845 return _IMP_kernel.ObjectKey_get_all_strings()
2847 def ObjectKey_get_number_unique():
2848 """ObjectKey_get_number_unique() -> unsigned int"""
2849 return _IMP_kernel.ObjectKey_get_number_unique()
2852 """Proxy of C++ IMP::Key<(5)> class"""
2853 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
2855 def __init__(self, *args):
2857 __init__(IMP::Key<(5)> self) -> IntsKey
2858 __init__(IMP::Key<(5)> self, std::string const & c, bool is_implicit_add_permitted=True) -> IntsKey
2859 __init__(IMP::Key<(5)> self, std::string const & c) -> IntsKey
2860 __init__(IMP::Key<(5)> self, unsigned int i) -> IntsKey
2862 this = _IMP_kernel.new_IntsKey(*args)
2864 self.this.append(this)
2869 """add_key(std::string sc) -> unsigned int"""
2870 return _IMP_kernel.IntsKey_add_key(sc)
2872 add_key = staticmethod(add_key)
2874 def get_key_exists(sc):
2875 """get_key_exists(std::string sc) -> bool"""
2876 return _IMP_kernel.IntsKey_get_key_exists(sc)
2878 get_key_exists = staticmethod(get_key_exists)
2880 def get_string(self):
2881 """get_string(IntsKey self) -> std::string const"""
2882 return _IMP_kernel.IntsKey_get_string(self)
2885 def __cmp__(self, o):
2886 """__cmp__(IntsKey self, IntsKey o) -> int"""
2887 return _IMP_kernel.IntsKey___cmp__(self, o)
2890 def __eq__(self, o):
2891 """__eq__(IntsKey self, IntsKey o) -> bool"""
2892 return _IMP_kernel.IntsKey___eq__(self, o)
2895 def __ne__(self, o):
2896 """__ne__(IntsKey self, IntsKey o) -> bool"""
2897 return _IMP_kernel.IntsKey___ne__(self, o)
2900 def __lt__(self, o):
2901 """__lt__(IntsKey self, IntsKey o) -> bool"""
2902 return _IMP_kernel.IntsKey___lt__(self, o)
2905 def __gt__(self, o):
2906 """__gt__(IntsKey self, IntsKey o) -> bool"""
2907 return _IMP_kernel.IntsKey___gt__(self, o)
2910 def __ge__(self, o):
2911 """__ge__(IntsKey self, IntsKey o) -> bool"""
2912 return _IMP_kernel.IntsKey___ge__(self, o)
2915 def __le__(self, o):
2916 """__le__(IntsKey self, IntsKey o) -> bool"""
2917 return _IMP_kernel.IntsKey___le__(self, o)
2921 """__hash__(IntsKey self) -> std::size_t"""
2922 return _IMP_kernel.IntsKey___hash__(self)
2925 def show(self, *args):
2927 show(IntsKey self, _ostream out)
2930 return _IMP_kernel.IntsKey_show(self, *args)
2933 def add_alias(old_key, new_name):
2934 """add_alias(IntsKey old_key, std::string new_name) -> IntsKey"""
2935 return _IMP_kernel.IntsKey_add_alias(old_key, new_name)
2937 add_alias = staticmethod(add_alias)
2939 def get_number_of_keys():
2940 """get_number_of_keys() -> unsigned int"""
2941 return _IMP_kernel.IntsKey_get_number_of_keys()
2943 get_number_of_keys = staticmethod(get_number_of_keys)
2946 """get_index(IntsKey self) -> unsigned int"""
2947 return _IMP_kernel.IntsKey_get_index(self)
2951 """show_all(_ostream out)"""
2952 return _IMP_kernel.IntsKey_show_all(out)
2954 show_all = staticmethod(show_all)
2956 def get_all_strings():
2957 """get_all_strings() -> IMP::Vector< std::string >"""
2958 return _IMP_kernel.IntsKey_get_all_strings()
2960 get_all_strings = staticmethod(get_all_strings)
2962 def get_number_unique():
2963 """get_number_unique() -> unsigned int"""
2964 return _IMP_kernel.IntsKey_get_number_unique()
2966 get_number_unique = staticmethod(get_number_unique)
2969 """__str__(IntsKey self) -> std::string"""
2970 return _IMP_kernel.IntsKey___str__(self)
2974 """__repr__(IntsKey self) -> std::string"""
2975 return _IMP_kernel.IntsKey___repr__(self)
2977 __swig_destroy__ = _IMP_kernel.delete_IntsKey
2978 __del__ =
lambda self:
None
2979 IntsKey_swigregister = _IMP_kernel.IntsKey_swigregister
2980 IntsKey_swigregister(IntsKey)
2982 def IntsKey_add_key(sc):
2983 """IntsKey_add_key(std::string sc) -> unsigned int"""
2984 return _IMP_kernel.IntsKey_add_key(sc)
2986 def IntsKey_get_key_exists(sc):
2987 """IntsKey_get_key_exists(std::string sc) -> bool"""
2988 return _IMP_kernel.IntsKey_get_key_exists(sc)
2990 def IntsKey_add_alias(old_key, new_name):
2991 """IntsKey_add_alias(IntsKey old_key, std::string new_name) -> IntsKey"""
2992 return _IMP_kernel.IntsKey_add_alias(old_key, new_name)
2994 def IntsKey_get_number_of_keys():
2995 """IntsKey_get_number_of_keys() -> unsigned int"""
2996 return _IMP_kernel.IntsKey_get_number_of_keys()
2998 def IntsKey_show_all(out):
2999 """IntsKey_show_all(_ostream out)"""
3000 return _IMP_kernel.IntsKey_show_all(out)
3002 def IntsKey_get_all_strings():
3003 """IntsKey_get_all_strings() -> IMP::Vector< std::string >"""
3004 return _IMP_kernel.IntsKey_get_all_strings()
3006 def IntsKey_get_number_unique():
3007 """IntsKey_get_number_unique() -> unsigned int"""
3008 return _IMP_kernel.IntsKey_get_number_unique()
3011 """Proxy of C++ IMP::Key<(6)> class"""
3012 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3014 def __init__(self, *args):
3016 __init__(IMP::Key<(6)> self) -> ParticleIndexesKey
3017 __init__(IMP::Key<(6)> self, std::string const & c, bool is_implicit_add_permitted=True) -> ParticleIndexesKey
3018 __init__(IMP::Key<(6)> self, std::string const & c) -> ParticleIndexesKey
3019 __init__(IMP::Key<(6)> self, unsigned int i) -> ParticleIndexesKey
3021 this = _IMP_kernel.new_ParticleIndexesKey(*args)
3023 self.this.append(this)
3028 """add_key(std::string sc) -> unsigned int"""
3029 return _IMP_kernel.ParticleIndexesKey_add_key(sc)
3031 add_key = staticmethod(add_key)
3033 def get_key_exists(sc):
3034 """get_key_exists(std::string sc) -> bool"""
3035 return _IMP_kernel.ParticleIndexesKey_get_key_exists(sc)
3037 get_key_exists = staticmethod(get_key_exists)
3039 def get_string(self):
3040 """get_string(ParticleIndexesKey self) -> std::string const"""
3041 return _IMP_kernel.ParticleIndexesKey_get_string(self)
3044 def __cmp__(self, o):
3045 """__cmp__(ParticleIndexesKey self, ParticleIndexesKey o) -> int"""
3046 return _IMP_kernel.ParticleIndexesKey___cmp__(self, o)
3049 def __eq__(self, o):
3050 """__eq__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
3051 return _IMP_kernel.ParticleIndexesKey___eq__(self, o)
3054 def __ne__(self, o):
3055 """__ne__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
3056 return _IMP_kernel.ParticleIndexesKey___ne__(self, o)
3059 def __lt__(self, o):
3060 """__lt__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
3061 return _IMP_kernel.ParticleIndexesKey___lt__(self, o)
3064 def __gt__(self, o):
3065 """__gt__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
3066 return _IMP_kernel.ParticleIndexesKey___gt__(self, o)
3069 def __ge__(self, o):
3070 """__ge__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
3071 return _IMP_kernel.ParticleIndexesKey___ge__(self, o)
3074 def __le__(self, o):
3075 """__le__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
3076 return _IMP_kernel.ParticleIndexesKey___le__(self, o)
3080 """__hash__(ParticleIndexesKey self) -> std::size_t"""
3081 return _IMP_kernel.ParticleIndexesKey___hash__(self)
3084 def show(self, *args):
3086 show(ParticleIndexesKey self, _ostream out)
3087 show(ParticleIndexesKey self)
3089 return _IMP_kernel.ParticleIndexesKey_show(self, *args)
3092 def add_alias(old_key, new_name):
3093 """add_alias(ParticleIndexesKey old_key, std::string new_name) -> ParticleIndexesKey"""
3094 return _IMP_kernel.ParticleIndexesKey_add_alias(old_key, new_name)
3096 add_alias = staticmethod(add_alias)
3098 def get_number_of_keys():
3099 """get_number_of_keys() -> unsigned int"""
3100 return _IMP_kernel.ParticleIndexesKey_get_number_of_keys()
3102 get_number_of_keys = staticmethod(get_number_of_keys)
3105 """get_index(ParticleIndexesKey self) -> unsigned int"""
3106 return _IMP_kernel.ParticleIndexesKey_get_index(self)
3110 """show_all(_ostream out)"""
3111 return _IMP_kernel.ParticleIndexesKey_show_all(out)
3113 show_all = staticmethod(show_all)
3115 def get_all_strings():
3116 """get_all_strings() -> IMP::Vector< std::string >"""
3117 return _IMP_kernel.ParticleIndexesKey_get_all_strings()
3119 get_all_strings = staticmethod(get_all_strings)
3121 def get_number_unique():
3122 """get_number_unique() -> unsigned int"""
3123 return _IMP_kernel.ParticleIndexesKey_get_number_unique()
3125 get_number_unique = staticmethod(get_number_unique)
3128 """__str__(ParticleIndexesKey self) -> std::string"""
3129 return _IMP_kernel.ParticleIndexesKey___str__(self)
3133 """__repr__(ParticleIndexesKey self) -> std::string"""
3134 return _IMP_kernel.ParticleIndexesKey___repr__(self)
3136 __swig_destroy__ = _IMP_kernel.delete_ParticleIndexesKey
3137 __del__ =
lambda self:
None
3138 ParticleIndexesKey_swigregister = _IMP_kernel.ParticleIndexesKey_swigregister
3139 ParticleIndexesKey_swigregister(ParticleIndexesKey)
3141 def ParticleIndexesKey_add_key(sc):
3142 """ParticleIndexesKey_add_key(std::string sc) -> unsigned int"""
3143 return _IMP_kernel.ParticleIndexesKey_add_key(sc)
3145 def ParticleIndexesKey_get_key_exists(sc):
3146 """ParticleIndexesKey_get_key_exists(std::string sc) -> bool"""
3147 return _IMP_kernel.ParticleIndexesKey_get_key_exists(sc)
3149 def ParticleIndexesKey_add_alias(old_key, new_name):
3150 """ParticleIndexesKey_add_alias(ParticleIndexesKey old_key, std::string new_name) -> ParticleIndexesKey"""
3151 return _IMP_kernel.ParticleIndexesKey_add_alias(old_key, new_name)
3153 def ParticleIndexesKey_get_number_of_keys():
3154 """ParticleIndexesKey_get_number_of_keys() -> unsigned int"""
3155 return _IMP_kernel.ParticleIndexesKey_get_number_of_keys()
3157 def ParticleIndexesKey_show_all(out):
3158 """ParticleIndexesKey_show_all(_ostream out)"""
3159 return _IMP_kernel.ParticleIndexesKey_show_all(out)
3161 def ParticleIndexesKey_get_all_strings():
3162 """ParticleIndexesKey_get_all_strings() -> IMP::Vector< std::string >"""
3163 return _IMP_kernel.ParticleIndexesKey_get_all_strings()
3165 def ParticleIndexesKey_get_number_unique():
3166 """ParticleIndexesKey_get_number_unique() -> unsigned int"""
3167 return _IMP_kernel.ParticleIndexesKey_get_number_unique()
3170 """Proxy of C++ IMP::Key<(8)> class"""
3171 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3173 def __init__(self, *args):
3175 __init__(IMP::Key<(8)> self) -> ModelKey
3176 __init__(IMP::Key<(8)> self, std::string const & c, bool is_implicit_add_permitted=True) -> ModelKey
3177 __init__(IMP::Key<(8)> self, std::string const & c) -> ModelKey
3178 __init__(IMP::Key<(8)> self, unsigned int i) -> ModelKey
3180 this = _IMP_kernel.new_ModelKey(*args)
3182 self.this.append(this)
3187 """add_key(std::string sc) -> unsigned int"""
3188 return _IMP_kernel.ModelKey_add_key(sc)
3190 add_key = staticmethod(add_key)
3192 def get_key_exists(sc):
3193 """get_key_exists(std::string sc) -> bool"""
3194 return _IMP_kernel.ModelKey_get_key_exists(sc)
3196 get_key_exists = staticmethod(get_key_exists)
3198 def get_string(self):
3199 """get_string(ModelKey self) -> std::string const"""
3200 return _IMP_kernel.ModelKey_get_string(self)
3203 def __cmp__(self, o):
3204 """__cmp__(ModelKey self, ModelKey o) -> int"""
3205 return _IMP_kernel.ModelKey___cmp__(self, o)
3208 def __eq__(self, o):
3209 """__eq__(ModelKey self, ModelKey o) -> bool"""
3210 return _IMP_kernel.ModelKey___eq__(self, o)
3213 def __ne__(self, o):
3214 """__ne__(ModelKey self, ModelKey o) -> bool"""
3215 return _IMP_kernel.ModelKey___ne__(self, o)
3218 def __lt__(self, o):
3219 """__lt__(ModelKey self, ModelKey o) -> bool"""
3220 return _IMP_kernel.ModelKey___lt__(self, o)
3223 def __gt__(self, o):
3224 """__gt__(ModelKey self, ModelKey o) -> bool"""
3225 return _IMP_kernel.ModelKey___gt__(self, o)
3228 def __ge__(self, o):
3229 """__ge__(ModelKey self, ModelKey o) -> bool"""
3230 return _IMP_kernel.ModelKey___ge__(self, o)
3233 def __le__(self, o):
3234 """__le__(ModelKey self, ModelKey o) -> bool"""
3235 return _IMP_kernel.ModelKey___le__(self, o)
3239 """__hash__(ModelKey self) -> std::size_t"""
3240 return _IMP_kernel.ModelKey___hash__(self)
3243 def show(self, *args):
3245 show(ModelKey self, _ostream out)
3248 return _IMP_kernel.ModelKey_show(self, *args)
3251 def add_alias(old_key, new_name):
3252 """add_alias(ModelKey old_key, std::string new_name) -> ModelKey"""
3253 return _IMP_kernel.ModelKey_add_alias(old_key, new_name)
3255 add_alias = staticmethod(add_alias)
3257 def get_number_of_keys():
3258 """get_number_of_keys() -> unsigned int"""
3259 return _IMP_kernel.ModelKey_get_number_of_keys()
3261 get_number_of_keys = staticmethod(get_number_of_keys)
3264 """get_index(ModelKey self) -> unsigned int"""
3265 return _IMP_kernel.ModelKey_get_index(self)
3269 """show_all(_ostream out)"""
3270 return _IMP_kernel.ModelKey_show_all(out)
3272 show_all = staticmethod(show_all)
3274 def get_all_strings():
3275 """get_all_strings() -> IMP::Vector< std::string >"""
3276 return _IMP_kernel.ModelKey_get_all_strings()
3278 get_all_strings = staticmethod(get_all_strings)
3280 def get_number_unique():
3281 """get_number_unique() -> unsigned int"""
3282 return _IMP_kernel.ModelKey_get_number_unique()
3284 get_number_unique = staticmethod(get_number_unique)
3287 """__str__(ModelKey self) -> std::string"""
3288 return _IMP_kernel.ModelKey___str__(self)
3292 """__repr__(ModelKey self) -> std::string"""
3293 return _IMP_kernel.ModelKey___repr__(self)
3295 __swig_destroy__ = _IMP_kernel.delete_ModelKey
3296 __del__ =
lambda self:
None
3297 ModelKey_swigregister = _IMP_kernel.ModelKey_swigregister
3298 ModelKey_swigregister(ModelKey)
3300 def ModelKey_add_key(sc):
3301 """ModelKey_add_key(std::string sc) -> unsigned int"""
3302 return _IMP_kernel.ModelKey_add_key(sc)
3304 def ModelKey_get_key_exists(sc):
3305 """ModelKey_get_key_exists(std::string sc) -> bool"""
3306 return _IMP_kernel.ModelKey_get_key_exists(sc)
3308 def ModelKey_add_alias(old_key, new_name):
3309 """ModelKey_add_alias(ModelKey old_key, std::string new_name) -> ModelKey"""
3310 return _IMP_kernel.ModelKey_add_alias(old_key, new_name)
3312 def ModelKey_get_number_of_keys():
3313 """ModelKey_get_number_of_keys() -> unsigned int"""
3314 return _IMP_kernel.ModelKey_get_number_of_keys()
3316 def ModelKey_show_all(out):
3317 """ModelKey_show_all(_ostream out)"""
3318 return _IMP_kernel.ModelKey_show_all(out)
3320 def ModelKey_get_all_strings():
3321 """ModelKey_get_all_strings() -> IMP::Vector< std::string >"""
3322 return _IMP_kernel.ModelKey_get_all_strings()
3324 def ModelKey_get_number_unique():
3325 """ModelKey_get_number_unique() -> unsigned int"""
3326 return _IMP_kernel.ModelKey_get_number_unique()
3329 """Proxy of C++ IMP::Index<(IMP::ParticleIndexTag)> class"""
3330 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3332 def __init__(self, *args):
3334 __init__(IMP::Index<(IMP::ParticleIndexTag)> self, int i) -> ParticleIndex
3335 __init__(IMP::Index<(IMP::ParticleIndexTag)> self) -> ParticleIndex
3337 this = _IMP_kernel.new_ParticleIndex(*args)
3339 self.this.append(this)
3344 """get_index(ParticleIndex self) -> int"""
3345 return _IMP_kernel.ParticleIndex_get_index(self)
3348 def __cmp__(self, o):
3349 """__cmp__(ParticleIndex self, ParticleIndex o) -> int"""
3350 return _IMP_kernel.ParticleIndex___cmp__(self, o)
3353 def __eq__(self, o):
3354 """__eq__(ParticleIndex self, ParticleIndex o) -> bool"""
3355 return _IMP_kernel.ParticleIndex___eq__(self, o)
3358 def __ne__(self, o):
3359 """__ne__(ParticleIndex self, ParticleIndex o) -> bool"""
3360 return _IMP_kernel.ParticleIndex___ne__(self, o)
3363 def __lt__(self, o):
3364 """__lt__(ParticleIndex self, ParticleIndex o) -> bool"""
3365 return _IMP_kernel.ParticleIndex___lt__(self, o)
3368 def __gt__(self, o):
3369 """__gt__(ParticleIndex self, ParticleIndex o) -> bool"""
3370 return _IMP_kernel.ParticleIndex___gt__(self, o)
3373 def __ge__(self, o):
3374 """__ge__(ParticleIndex self, ParticleIndex o) -> bool"""
3375 return _IMP_kernel.ParticleIndex___ge__(self, o)
3378 def __le__(self, o):
3379 """__le__(ParticleIndex self, ParticleIndex o) -> bool"""
3380 return _IMP_kernel.ParticleIndex___le__(self, o)
3383 def show(self, *args):
3385 show(ParticleIndex self, _ostream out)
3386 show(ParticleIndex self)
3388 return _IMP_kernel.ParticleIndex_show(self, *args)
3392 """__hash__(ParticleIndex self) -> std::size_t"""
3393 return _IMP_kernel.ParticleIndex___hash__(self)
3397 """__str__(ParticleIndex self) -> std::string"""
3398 return _IMP_kernel.ParticleIndex___str__(self)
3402 """__repr__(ParticleIndex self) -> std::string"""
3403 return _IMP_kernel.ParticleIndex___repr__(self)
3405 __swig_destroy__ = _IMP_kernel.delete_ParticleIndex
3406 __del__ =
lambda self:
None
3407 ParticleIndex_swigregister = _IMP_kernel.ParticleIndex_swigregister
3408 ParticleIndex_swigregister(ParticleIndex)
3411 """Proxy of C++ IMP::Key<(10)> class"""
3412 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3414 def __init__(self, *args):
3416 __init__(IMP::Key<(10)> self) -> FloatsKey
3417 __init__(IMP::Key<(10)> self, std::string const & c, bool is_implicit_add_permitted=True) -> FloatsKey
3418 __init__(IMP::Key<(10)> self, std::string const & c) -> FloatsKey
3419 __init__(IMP::Key<(10)> self, unsigned int i) -> FloatsKey
3421 this = _IMP_kernel.new_FloatsKey(*args)
3423 self.this.append(this)
3428 """add_key(std::string sc) -> unsigned int"""
3429 return _IMP_kernel.FloatsKey_add_key(sc)
3431 add_key = staticmethod(add_key)
3433 def get_key_exists(sc):
3434 """get_key_exists(std::string sc) -> bool"""
3435 return _IMP_kernel.FloatsKey_get_key_exists(sc)
3437 get_key_exists = staticmethod(get_key_exists)
3439 def get_string(self):
3440 """get_string(FloatsKey self) -> std::string const"""
3441 return _IMP_kernel.FloatsKey_get_string(self)
3444 def __cmp__(self, o):
3445 """__cmp__(FloatsKey self, FloatsKey o) -> int"""
3446 return _IMP_kernel.FloatsKey___cmp__(self, o)
3449 def __eq__(self, o):
3450 """__eq__(FloatsKey self, FloatsKey o) -> bool"""
3451 return _IMP_kernel.FloatsKey___eq__(self, o)
3454 def __ne__(self, o):
3455 """__ne__(FloatsKey self, FloatsKey o) -> bool"""
3456 return _IMP_kernel.FloatsKey___ne__(self, o)
3459 def __lt__(self, o):
3460 """__lt__(FloatsKey self, FloatsKey o) -> bool"""
3461 return _IMP_kernel.FloatsKey___lt__(self, o)
3464 def __gt__(self, o):
3465 """__gt__(FloatsKey self, FloatsKey o) -> bool"""
3466 return _IMP_kernel.FloatsKey___gt__(self, o)
3469 def __ge__(self, o):
3470 """__ge__(FloatsKey self, FloatsKey o) -> bool"""
3471 return _IMP_kernel.FloatsKey___ge__(self, o)
3474 def __le__(self, o):
3475 """__le__(FloatsKey self, FloatsKey o) -> bool"""
3476 return _IMP_kernel.FloatsKey___le__(self, o)
3480 """__hash__(FloatsKey self) -> std::size_t"""
3481 return _IMP_kernel.FloatsKey___hash__(self)
3484 def show(self, *args):
3486 show(FloatsKey self, _ostream out)
3487 show(FloatsKey self)
3489 return _IMP_kernel.FloatsKey_show(self, *args)
3492 def add_alias(old_key, new_name):
3493 """add_alias(FloatsKey old_key, std::string new_name) -> FloatsKey"""
3494 return _IMP_kernel.FloatsKey_add_alias(old_key, new_name)
3496 add_alias = staticmethod(add_alias)
3498 def get_number_of_keys():
3499 """get_number_of_keys() -> unsigned int"""
3500 return _IMP_kernel.FloatsKey_get_number_of_keys()
3502 get_number_of_keys = staticmethod(get_number_of_keys)
3505 """get_index(FloatsKey self) -> unsigned int"""
3506 return _IMP_kernel.FloatsKey_get_index(self)
3510 """show_all(_ostream out)"""
3511 return _IMP_kernel.FloatsKey_show_all(out)
3513 show_all = staticmethod(show_all)
3515 def get_all_strings():
3516 """get_all_strings() -> IMP::Vector< std::string >"""
3517 return _IMP_kernel.FloatsKey_get_all_strings()
3519 get_all_strings = staticmethod(get_all_strings)
3521 def get_number_unique():
3522 """get_number_unique() -> unsigned int"""
3523 return _IMP_kernel.FloatsKey_get_number_unique()
3525 get_number_unique = staticmethod(get_number_unique)
3528 """__str__(FloatsKey self) -> std::string"""
3529 return _IMP_kernel.FloatsKey___str__(self)
3533 """__repr__(FloatsKey self) -> std::string"""
3534 return _IMP_kernel.FloatsKey___repr__(self)
3536 __swig_destroy__ = _IMP_kernel.delete_FloatsKey
3537 __del__ =
lambda self:
None
3538 FloatsKey_swigregister = _IMP_kernel.FloatsKey_swigregister
3539 FloatsKey_swigregister(FloatsKey)
3541 def FloatsKey_add_key(sc):
3542 """FloatsKey_add_key(std::string sc) -> unsigned int"""
3543 return _IMP_kernel.FloatsKey_add_key(sc)
3545 def FloatsKey_get_key_exists(sc):
3546 """FloatsKey_get_key_exists(std::string sc) -> bool"""
3547 return _IMP_kernel.FloatsKey_get_key_exists(sc)
3549 def FloatsKey_add_alias(old_key, new_name):
3550 """FloatsKey_add_alias(FloatsKey old_key, std::string new_name) -> FloatsKey"""
3551 return _IMP_kernel.FloatsKey_add_alias(old_key, new_name)
3553 def FloatsKey_get_number_of_keys():
3554 """FloatsKey_get_number_of_keys() -> unsigned int"""
3555 return _IMP_kernel.FloatsKey_get_number_of_keys()
3557 def FloatsKey_show_all(out):
3558 """FloatsKey_show_all(_ostream out)"""
3559 return _IMP_kernel.FloatsKey_show_all(out)
3561 def FloatsKey_get_all_strings():
3562 """FloatsKey_get_all_strings() -> IMP::Vector< std::string >"""
3563 return _IMP_kernel.FloatsKey_get_all_strings()
3565 def FloatsKey_get_number_unique():
3566 """FloatsKey_get_number_unique() -> unsigned int"""
3567 return _IMP_kernel.FloatsKey_get_number_unique()
3577 class FloatIndex(_Value):
3578 """Proxy of C++ IMP::FloatIndex class"""
3579 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3581 def __init__(self, *args):
3583 __init__(IMP::FloatIndex self, ParticleIndex i0, FloatKey i1) -> FloatIndex
3584 __init__(IMP::FloatIndex self, ParticleIndex i0) -> FloatIndex
3585 __init__(IMP::FloatIndex self) -> FloatIndex
3587 this = _IMP_kernel.new_FloatIndex(*args)
3589 self.this.append(this)
3594 """__hash__(FloatIndex self) -> std::size_t"""
3595 return _IMP_kernel.FloatIndex___hash__(self)
3598 def show(self, *args):
3600 show(FloatIndex self, _ostream out)
3601 show(FloatIndex self)
3603 return _IMP_kernel.FloatIndex_show(self, *args)
3606 def __cmp__(self, o):
3607 """__cmp__(FloatIndex self, FloatIndex o) -> int"""
3608 return _IMP_kernel.FloatIndex___cmp__(self, o)
3611 def __eq__(self, o):
3612 """__eq__(FloatIndex self, FloatIndex o) -> bool"""
3613 return _IMP_kernel.FloatIndex___eq__(self, o)
3616 def __ne__(self, o):
3617 """__ne__(FloatIndex self, FloatIndex o) -> bool"""
3618 return _IMP_kernel.FloatIndex___ne__(self, o)
3621 def __lt__(self, o):
3622 """__lt__(FloatIndex self, FloatIndex o) -> bool"""
3623 return _IMP_kernel.FloatIndex___lt__(self, o)
3626 def __gt__(self, o):
3627 """__gt__(FloatIndex self, FloatIndex o) -> bool"""
3628 return _IMP_kernel.FloatIndex___gt__(self, o)
3631 def __ge__(self, o):
3632 """__ge__(FloatIndex self, FloatIndex o) -> bool"""
3633 return _IMP_kernel.FloatIndex___ge__(self, o)
3636 def __le__(self, o):
3637 """__le__(FloatIndex self, FloatIndex o) -> bool"""
3638 return _IMP_kernel.FloatIndex___le__(self, o)
3641 def get_particle(self):
3642 """get_particle(FloatIndex self) -> ParticleIndex const &"""
3643 return _IMP_kernel.FloatIndex_get_particle(self)
3646 def set_particle(self, v):
3647 """set_particle(FloatIndex self, ParticleIndex const & v)"""
3648 return _IMP_kernel.FloatIndex_set_particle(self, v)
3652 """get_key(FloatIndex self) -> FloatKey const &"""
3653 return _IMP_kernel.FloatIndex_get_key(self)
3656 def set_key(self, v):
3657 """set_key(FloatIndex self, FloatKey const & v)"""
3658 return _IMP_kernel.FloatIndex_set_key(self, v)
3662 """__str__(FloatIndex self) -> std::string"""
3663 return _IMP_kernel.FloatIndex___str__(self)
3667 """__repr__(FloatIndex self) -> std::string"""
3668 return _IMP_kernel.FloatIndex___repr__(self)
3670 __swig_destroy__ = _IMP_kernel.delete_FloatIndex
3671 __del__ =
lambda self:
None
3672 FloatIndex_swigregister = _IMP_kernel.FloatIndex_swigregister
3673 FloatIndex_swigregister(FloatIndex)
3675 class _ParticleIndexTag(object):
3676 """Proxy of C++ IMP::ParticleIndexTag class"""
3677 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3678 __repr__ = _swig_repr
3681 """__init__(IMP::ParticleIndexTag self) -> _ParticleIndexTag"""
3682 this = _IMP_kernel.new__ParticleIndexTag()
3684 self.this.append(this)
3687 __swig_destroy__ = _IMP_kernel.delete__ParticleIndexTag
3688 __del__ =
lambda self:
None
3689 _ParticleIndexTag_swigregister = _IMP_kernel._ParticleIndexTag_swigregister
3690 _ParticleIndexTag_swigregister(_ParticleIndexTag)
3692 class ModelObject(Object):
3693 """Proxy of C++ IMP::ModelObject class"""
3694 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3696 def __init__(self, m, name):
3697 """__init__(IMP::ModelObject self, Model m, std::string name) -> ModelObject"""
3698 if self.__class__ == ModelObject:
3702 this = _IMP_kernel.new_ModelObject(_self, m, name)
3704 self.this.append(this)
3708 if self.__class__ != ModelObject:
3709 _director_objects.register(self)
3713 __swig_destroy__ = _IMP_kernel.delete_ModelObject
3714 __del__ =
lambda self:
None
3716 def get_model(self):
3717 """get_model(ModelObject self) -> Model"""
3718 return _IMP_kernel.ModelObject_get_model(self)
3721 def get_inputs(self):
3722 """get_inputs(ModelObject self) -> IMP::ModelObjectsTemp"""
3723 return _IMP_kernel.ModelObject_get_inputs(self)
3726 def get_outputs(self):
3727 """get_outputs(ModelObject self) -> IMP::ModelObjectsTemp"""
3728 return _IMP_kernel.ModelObject_get_outputs(self)
3731 def get_interactions(self):
3732 """get_interactions(ModelObject self) -> IMP::ModelObjectsTemps"""
3733 return _IMP_kernel.ModelObject_get_interactions(self)
3736 def get_has_dependencies(self):
3737 """get_has_dependencies(ModelObject self) -> bool"""
3738 return _IMP_kernel.ModelObject_get_has_dependencies(self)
3741 def set_has_dependencies(self, tf):
3742 """set_has_dependencies(ModelObject self, bool tf)"""
3743 return _IMP_kernel.ModelObject_set_has_dependencies(self, tf)
3746 def set_has_required_score_states(self, tf):
3747 """set_has_required_score_states(ModelObject self, bool tf)"""
3748 return _IMP_kernel.ModelObject_set_has_required_score_states(self, tf)
3751 def get_has_required_score_states(self):
3752 """get_has_required_score_states(ModelObject self) -> bool"""
3753 return _IMP_kernel.ModelObject_get_has_required_score_states(self)
3757 """get_required_score_states(ModelObject self) -> IMP::ScoreStatesTemp const &"""
3758 return _IMP_kernel.ModelObject_get_required_score_states(self)
3761 def handle_set_has_required_score_states(self, arg0):
3762 """handle_set_has_required_score_states(ModelObject self, bool arg0)"""
3763 return _IMP_kernel.ModelObject_handle_set_has_required_score_states(self, arg0)
3766 def do_get_inputs(self):
3767 """do_get_inputs(ModelObject self) -> IMP::ModelObjectsTemp"""
3768 return _IMP_kernel.ModelObject_do_get_inputs(self)
3771 def do_get_outputs(self):
3772 """do_get_outputs(ModelObject self) -> IMP::ModelObjectsTemp"""
3773 return _IMP_kernel.ModelObject_do_get_outputs(self)
3776 def do_get_interactions(self):
3777 """do_get_interactions(ModelObject self) -> IMP::ModelObjectsTemps"""
3778 return _IMP_kernel.ModelObject_do_get_interactions(self)
3782 """__str__(ModelObject self) -> std::string"""
3783 return _IMP_kernel.ModelObject___str__(self)
3787 """__repr__(ModelObject self) -> std::string"""
3788 return _IMP_kernel.ModelObject___repr__(self)
3793 return _object_cast_to_ModelObject(o)
3796 def get_type_name(self):
3797 return self.__class__.__name__
3798 def do_show(self, out):
3800 def get_version_info(self):
3802 return VersionInfo(self.__module__,
3809 return _object_cast_to_ModelObject(o)
3811 def __disown__(self):
3813 _IMP_kernel.disown_ModelObject(self)
3814 return weakref_proxy(self)
3816 def do_destroy(self):
3817 """do_destroy(ModelObject self)"""
3818 return _IMP_kernel.ModelObject_do_destroy(self)
3820 ModelObject_swigregister = _IMP_kernel.ModelObject_swigregister
3821 ModelObject_swigregister(ModelObject)
3822 cvar = _IMP_kernel.cvar
3823 NO_MAX = cvar.NO_MAX
3824 BAD_SCORE = cvar.BAD_SCORE
3826 class _ParticleInputs(object):
3827 """Proxy of C++ IMP::ParticleInputs class"""
3828 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3830 def __init__(self, *args, **kwargs):
3831 raise AttributeError(
"No constructor defined - class is abstract")
3832 __repr__ = _swig_repr
3834 def get_inputs(self, m, pis):
3835 """get_inputs(_ParticleInputs self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
3836 return _IMP_kernel._ParticleInputs_get_inputs(self, m, pis)
3838 _ParticleInputs_swigregister = _IMP_kernel._ParticleInputs_swigregister
3839 _ParticleInputs_swigregister(_ParticleInputs)
3841 class _ParticleOutputs(object):
3842 """Proxy of C++ IMP::ParticleOutputs class"""
3843 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3845 def __init__(self, *args, **kwargs):
3846 raise AttributeError(
"No constructor defined - class is abstract")
3847 __repr__ = _swig_repr
3849 def get_outputs(self, m, pis):
3850 """get_outputs(_ParticleOutputs self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
3851 return _IMP_kernel._ParticleOutputs_get_outputs(self, m, pis)
3853 _ParticleOutputs_swigregister = _IMP_kernel._ParticleOutputs_swigregister
3854 _ParticleOutputs_swigregister(_ParticleOutputs)
3858 """get_input_particles(IMP::ModelObjectsTemp const & mos) -> IMP::ParticlesTemp"""
3859 return _IMP_kernel.get_input_particles(mos)
3862 """get_input_containers(IMP::ModelObjectsTemp const & mos) -> IMP::ContainersTemp"""
3863 return _IMP_kernel.get_input_containers(mos)
3866 """get_output_particles(IMP::ModelObjectsTemp const & mos) -> IMP::ParticlesTemp"""
3867 return _IMP_kernel.get_output_particles(mos)
3870 """get_output_containers(IMP::ModelObjectsTemp const & mos) -> IMP::ContainersTemp"""
3871 return _IMP_kernel.get_output_containers(mos)
3872 class DerivativeAccumulator(object):
3873 """Proxy of C++ IMP::DerivativeAccumulator class"""
3874 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3875 __repr__ = _swig_repr
3877 def __init__(self, *args):
3879 __init__(IMP::DerivativeAccumulator self, double weight=1.0) -> DerivativeAccumulator
3880 __init__(IMP::DerivativeAccumulator self) -> DerivativeAccumulator
3881 __init__(IMP::DerivativeAccumulator self, DerivativeAccumulator copy, double weight) -> DerivativeAccumulator
3883 this = _IMP_kernel.new_DerivativeAccumulator(*args)
3885 self.this.append(this)
3889 def __call__(self, value):
3890 """__call__(DerivativeAccumulator self, double const value) -> double"""
3891 return _IMP_kernel.DerivativeAccumulator___call__(self, value)
3894 def get_weight(self):
3895 """get_weight(DerivativeAccumulator self) -> double"""
3896 return _IMP_kernel.DerivativeAccumulator_get_weight(self)
3899 def show(self, *args):
3901 show(DerivativeAccumulator self, _ostream out)
3902 show(DerivativeAccumulator self)
3904 return _IMP_kernel.DerivativeAccumulator_show(self, *args)
3906 __swig_destroy__ = _IMP_kernel.delete_DerivativeAccumulator
3907 __del__ =
lambda self:
None
3908 DerivativeAccumulator_swigregister = _IMP_kernel.DerivativeAccumulator_swigregister
3909 DerivativeAccumulator_swigregister(DerivativeAccumulator)
3911 class EvaluationState(object):
3912 """Proxy of C++ IMP::EvaluationState class"""
3913 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3914 score = _swig_property(_IMP_kernel.EvaluationState_score_get, _IMP_kernel.EvaluationState_score_set)
3915 good = _swig_property(_IMP_kernel.EvaluationState_good_get, _IMP_kernel.EvaluationState_good_set)
3917 def __init__(self, *args):
3919 __init__(IMP::EvaluationState self, double oscore, bool ogood) -> EvaluationState
3920 __init__(IMP::EvaluationState self) -> EvaluationState
3922 this = _IMP_kernel.new_EvaluationState(*args)
3924 self.this.append(this)
3928 def show(self, *args):
3930 show(EvaluationState self, _ostream out)
3931 show(EvaluationState self)
3933 return _IMP_kernel.EvaluationState_show(self, *args)
3937 """__str__(EvaluationState self) -> std::string"""
3938 return _IMP_kernel.EvaluationState___str__(self)
3942 """__repr__(EvaluationState self) -> std::string"""
3943 return _IMP_kernel.EvaluationState___repr__(self)
3945 __swig_destroy__ = _IMP_kernel.delete_EvaluationState
3946 __del__ =
lambda self:
None
3947 EvaluationState_swigregister = _IMP_kernel.EvaluationState_swigregister
3948 EvaluationState_swigregister(EvaluationState)
3950 class ScoreAccumulator(_Value):
3951 """Proxy of C++ IMP::ScoreAccumulator class"""
3952 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3954 def __init__(self, *args):
3956 __init__(IMP::ScoreAccumulator self) -> ScoreAccumulator
3957 __init__(IMP::ScoreAccumulator self, ScoreAccumulator o, Restraint r) -> ScoreAccumulator
3958 __init__(IMP::ScoreAccumulator self, ScoreAccumulator o, double weight, double local_max) -> ScoreAccumulator
3960 this = _IMP_kernel.new_ScoreAccumulator(*args)
3962 self.this.append(this)
3966 def add_score(self, score):
3967 """add_score(ScoreAccumulator self, double score)"""
3968 return _IMP_kernel.ScoreAccumulator_add_score(self, score)
3971 def get_abort_evaluation(self):
3972 """get_abort_evaluation(ScoreAccumulator self) -> bool"""
3973 return _IMP_kernel.ScoreAccumulator_get_abort_evaluation(self)
3976 def get_is_evaluate_if_below(self):
3977 """get_is_evaluate_if_below(ScoreAccumulator self) -> bool"""
3978 return _IMP_kernel.ScoreAccumulator_get_is_evaluate_if_below(self)
3981 def get_is_evaluate_if_good(self):
3982 """get_is_evaluate_if_good(ScoreAccumulator self) -> bool"""
3983 return _IMP_kernel.ScoreAccumulator_get_is_evaluate_if_good(self)
3986 def get_maximum(self):
3987 """get_maximum(ScoreAccumulator self) -> double"""
3988 return _IMP_kernel.ScoreAccumulator_get_maximum(self)
3991 def get_derivative_accumulator(self):
3992 """get_derivative_accumulator(ScoreAccumulator self) -> DerivativeAccumulator"""
3993 return _IMP_kernel.ScoreAccumulator_get_derivative_accumulator(self)
3996 def show(self, *args):
3998 show(ScoreAccumulator self, _ostream out)
3999 show(ScoreAccumulator self)
4001 return _IMP_kernel.ScoreAccumulator_show(self, *args)
4005 """__str__(ScoreAccumulator self) -> std::string"""
4006 return _IMP_kernel.ScoreAccumulator___str__(self)
4010 """__repr__(ScoreAccumulator self) -> std::string"""
4011 return _IMP_kernel.ScoreAccumulator___repr__(self)
4013 __swig_destroy__ = _IMP_kernel.delete_ScoreAccumulator
4014 __del__ =
lambda self:
None
4015 ScoreAccumulator_swigregister = _IMP_kernel.ScoreAccumulator_swigregister
4016 ScoreAccumulator_swigregister(ScoreAccumulator)
4018 class ScoreState(ModelObject):
4019 """Proxy of C++ IMP::ScoreState class"""
4020 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
4022 def __init__(self, m, name):
4023 """__init__(IMP::ScoreState self, Model m, std::string name) -> ScoreState"""
4024 if self.__class__ == ScoreState:
4028 this = _IMP_kernel.new_ScoreState(_self, m, name)
4030 self.this.append(this)
4034 if self.__class__ != ScoreState:
4035 _director_objects.register(self)
4040 def before_evaluate(self):
4041 """before_evaluate(ScoreState self)"""
4042 return _IMP_kernel.ScoreState_before_evaluate(self)
4045 def after_evaluate(self, accpt):
4046 """after_evaluate(ScoreState self, DerivativeAccumulator accpt)"""
4047 return _IMP_kernel.ScoreState_after_evaluate(self, accpt)
4050 def get_has_update_order(self):
4051 """get_has_update_order(ScoreState self) -> bool"""
4052 return _IMP_kernel.ScoreState_get_has_update_order(self)
4056 """get_update_order(ScoreState self) -> unsigned int"""
4057 return _IMP_kernel.ScoreState_get_update_order(self)
4060 def handle_set_has_required_score_states(self, tf):
4061 """handle_set_has_required_score_states(ScoreState self, bool tf)"""
4062 return _IMP_kernel.ScoreState_handle_set_has_required_score_states(self, tf)
4065 def do_before_evaluate(self):
4066 """do_before_evaluate(ScoreState self)"""
4067 return _IMP_kernel.ScoreState_do_before_evaluate(self)
4070 def do_after_evaluate(self, accpt):
4071 """do_after_evaluate(ScoreState self, DerivativeAccumulator accpt)"""
4072 return _IMP_kernel.ScoreState_do_after_evaluate(self, accpt)
4074 __swig_destroy__ = _IMP_kernel.delete_ScoreState
4075 __del__ =
lambda self:
None
4078 """__str__(ScoreState self) -> std::string"""
4079 return _IMP_kernel.ScoreState___str__(self)
4083 """__repr__(ScoreState self) -> std::string"""
4084 return _IMP_kernel.ScoreState___repr__(self)
4089 return _object_cast_to_ScoreState(o)
4092 def get_type_name(self):
4093 return self.__class__.__name__
4094 def do_show(self, out):
4096 def get_version_info(self):
4098 return VersionInfo(self.__module__,
4105 return _object_cast_to_ScoreState(o)
4107 def __disown__(self):
4109 _IMP_kernel.disown_ScoreState(self)
4110 return weakref_proxy(self)
4112 def do_destroy(self):
4113 """do_destroy(ScoreState self)"""
4114 return _IMP_kernel.ScoreState_do_destroy(self)
4117 def do_get_inputs(self):
4118 """do_get_inputs(ScoreState self) -> IMP::ModelObjectsTemp"""
4119 return _IMP_kernel.ScoreState_do_get_inputs(self)
4122 def do_get_outputs(self):
4123 """do_get_outputs(ScoreState self) -> IMP::ModelObjectsTemp"""
4124 return _IMP_kernel.ScoreState_do_get_outputs(self)
4127 def do_get_interactions(self):
4128 """do_get_interactions(ScoreState self) -> IMP::ModelObjectsTemps"""
4129 return _IMP_kernel.ScoreState_do_get_interactions(self)
4131 ScoreState_swigregister = _IMP_kernel.ScoreState_swigregister
4132 ScoreState_swigregister(ScoreState)
4136 """get_update_order(IMP::ScoreStatesTemp input) -> IMP::ScoreStatesTemp"""
4137 return _IMP_kernel.get_update_order(input)
4138 class Constraint(ScoreState):
4139 """Proxy of C++ IMP::Constraint class"""
4140 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
4142 def __init__(self, *args):
4144 __init__(IMP::Constraint self, Model m, std::string name) -> Constraint
4145 __init__(IMP::Constraint self, Model m) -> Constraint
4147 if self.__class__ == Constraint:
4151 this = _IMP_kernel.new_Constraint(_self, *args)
4153 self.this.append(this)
4157 if self.__class__ != Constraint:
4158 _director_objects.register(self)
4163 def do_update_attributes(self):
4164 """do_update_attributes(Constraint self)"""
4165 return _IMP_kernel.Constraint_do_update_attributes(self)
4168 def do_update_derivatives(self, da):
4169 """do_update_derivatives(Constraint self, DerivativeAccumulator da)"""
4170 return _IMP_kernel.Constraint_do_update_derivatives(self, da)
4173 def do_before_evaluate(self):
4174 """do_before_evaluate(Constraint self)"""
4175 return _IMP_kernel.Constraint_do_before_evaluate(self)
4178 def do_after_evaluate(self, da):
4179 """do_after_evaluate(Constraint self, DerivativeAccumulator da)"""
4180 return _IMP_kernel.Constraint_do_after_evaluate(self, da)
4182 __swig_destroy__ = _IMP_kernel.delete_Constraint
4183 __del__ =
lambda self:
None
4186 """__str__(Constraint self) -> std::string"""
4187 return _IMP_kernel.Constraint___str__(self)
4191 """__repr__(Constraint self) -> std::string"""
4192 return _IMP_kernel.Constraint___repr__(self)
4197 return _object_cast_to_Constraint(o)
4200 def get_type_name(self):
4201 return self.__class__.__name__
4202 def do_show(self, out):
4204 def get_version_info(self):
4206 return VersionInfo(self.__module__,
4213 return _object_cast_to_Constraint(o)
4215 def __disown__(self):
4217 _IMP_kernel.disown_Constraint(self)
4218 return weakref_proxy(self)
4220 def do_destroy(self):
4221 """do_destroy(Constraint self)"""
4222 return _IMP_kernel.Constraint_do_destroy(self)
4225 def do_get_inputs(self):
4226 """do_get_inputs(Constraint self) -> IMP::ModelObjectsTemp"""
4227 return _IMP_kernel.Constraint_do_get_inputs(self)
4230 def do_get_outputs(self):
4231 """do_get_outputs(Constraint self) -> IMP::ModelObjectsTemp"""
4232 return _IMP_kernel.Constraint_do_get_outputs(self)
4235 def do_get_interactions(self):
4236 """do_get_interactions(Constraint self) -> IMP::ModelObjectsTemps"""
4237 return _IMP_kernel.Constraint_do_get_interactions(self)
4239 Constraint_swigregister = _IMP_kernel.Constraint_swigregister
4240 Constraint_swigregister(Constraint)
4242 class Container(ModelObject):
4243 """Proxy of C++ IMP::Container class"""
4244 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
4246 def __init__(self, *args):
4248 __init__(IMP::Container self, Model m, std::string name) -> Container
4249 __init__(IMP::Container self, Model m) -> Container
4251 if self.__class__ == Container:
4255 this = _IMP_kernel.new_Container(_self, *args)
4257 self.this.append(this)
4261 if self.__class__ != Container:
4262 _director_objects.register(self)
4267 def do_get_contents_hash(self):
4268 """do_get_contents_hash(Container self) -> std::size_t"""
4269 return _IMP_kernel.Container_do_get_contents_hash(self)
4272 def get_all_possible_indexes(self):
4273 """get_all_possible_indexes(Container self) -> IMP::ParticleIndexes"""
4274 return _IMP_kernel.Container_get_all_possible_indexes(self)
4277 def get_contents_hash(self):
4278 """get_contents_hash(Container self) -> std::size_t"""
4279 return _IMP_kernel.Container_get_contents_hash(self)
4282 def do_get_outputs(self):
4283 """do_get_outputs(Container self) -> IMP::ModelObjectsTemp"""
4284 return _IMP_kernel.Container_do_get_outputs(self)
4287 def get_is_decomposable(self):
4288 """get_is_decomposable(Container self) -> bool"""
4289 return _IMP_kernel.Container_get_is_decomposable(self)
4292 def validate_readable(self):
4293 """validate_readable(Container self)"""
4294 return _IMP_kernel.Container_validate_readable(self)
4297 def validate_writable(self):
4298 """validate_writable(Container self)"""
4299 return _IMP_kernel.Container_validate_writable(self)
4302 def set_is_readable(self, tf):
4303 """set_is_readable(Container self, bool tf)"""
4304 return _IMP_kernel.Container_set_is_readable(self, tf)
4307 def set_is_writable(self, tf):
4308 """set_is_writable(Container self, bool tf)"""
4309 return _IMP_kernel.Container_set_is_writable(self, tf)
4311 __swig_destroy__ = _IMP_kernel.delete_Container
4312 __del__ =
lambda self:
None
4315 """__str__(Container self) -> std::string"""
4316 return _IMP_kernel.Container___str__(self)
4320 """__repr__(Container self) -> std::string"""
4321 return _IMP_kernel.Container___repr__(self)
4326 return _object_cast_to_Container(o)
4329 def get_type_name(self):
4330 return self.__class__.__name__
4331 def do_show(self, out):
4333 def get_version_info(self):
4335 return VersionInfo(self.__module__,
4342 return _object_cast_to_Container(o)
4344 def __disown__(self):
4346 _IMP_kernel.disown_Container(self)
4347 return weakref_proxy(self)
4349 def do_destroy(self):
4350 """do_destroy(Container self)"""
4351 return _IMP_kernel.Container_do_destroy(self)
4354 def handle_set_has_required_score_states(self, arg0):
4355 """handle_set_has_required_score_states(Container self, bool arg0)"""
4356 return _IMP_kernel.Container_handle_set_has_required_score_states(self, arg0)
4359 def do_get_inputs(self):
4360 """do_get_inputs(Container self) -> IMP::ModelObjectsTemp"""
4361 return _IMP_kernel.Container_do_get_inputs(self)
4364 def do_get_interactions(self):
4365 """do_get_interactions(Container self) -> IMP::ModelObjectsTemps"""
4366 return _IMP_kernel.Container_do_get_interactions(self)
4368 Container_swigregister = _IMP_kernel.Container_swigregister
4369 Container_swigregister(Container)
4371 class RestraintInfo(Object):
4372 """Proxy of C++ IMP::RestraintInfo class"""
4373 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
4375 def __init__(self, *args):
4377 __init__(IMP::RestraintInfo self, std::string name) -> RestraintInfo
4378 __init__(IMP::RestraintInfo self) -> RestraintInfo
4380 this = _IMP_kernel.new_RestraintInfo(*args)
4382 self.this.append(this)
4386 def add_int(self, key, value):
4387 """add_int(RestraintInfo self, std::string key, int value)"""
4388 return _IMP_kernel.RestraintInfo_add_int(self, key, value)
4391 def get_number_of_int(self):
4392 """get_number_of_int(RestraintInfo self) -> unsigned int"""
4393 return _IMP_kernel.RestraintInfo_get_number_of_int(self)
4396 def get_int_key(self, i):
4397 """get_int_key(RestraintInfo self, unsigned int i) -> std::string"""
4398 return _IMP_kernel.RestraintInfo_get_int_key(self, i)
4401 def get_int_value(self, i):
4402 """get_int_value(RestraintInfo self, unsigned int i) -> int"""
4403 return _IMP_kernel.RestraintInfo_get_int_value(self, i)
4406 def add_float(self, key, value):
4407 """add_float(RestraintInfo self, std::string key, double value)"""
4408 return _IMP_kernel.RestraintInfo_add_float(self, key, value)
4411 def get_number_of_float(self):
4412 """get_number_of_float(RestraintInfo self) -> unsigned int"""
4413 return _IMP_kernel.RestraintInfo_get_number_of_float(self)
4416 def get_float_key(self, i):
4417 """get_float_key(RestraintInfo self, unsigned int i) -> std::string"""
4418 return _IMP_kernel.RestraintInfo_get_float_key(self, i)
4421 def get_float_value(self, i):
4422 """get_float_value(RestraintInfo self, unsigned int i) -> double"""
4423 return _IMP_kernel.RestraintInfo_get_float_value(self, i)
4426 def add_string(self, key, value):
4427 """add_string(RestraintInfo self, std::string key, std::string value)"""
4428 return _IMP_kernel.RestraintInfo_add_string(self, key, value)
4431 def get_number_of_string(self):
4432 """get_number_of_string(RestraintInfo self) -> unsigned int"""
4433 return _IMP_kernel.RestraintInfo_get_number_of_string(self)
4436 def get_string_key(self, i):
4437 """get_string_key(RestraintInfo self, unsigned int i) -> std::string"""
4438 return _IMP_kernel.RestraintInfo_get_string_key(self, i)
4441 def get_string_value(self, i):
4442 """get_string_value(RestraintInfo self, unsigned int i) -> std::string"""
4443 return _IMP_kernel.RestraintInfo_get_string_value(self, i)
4446 def add_filename(self, key, value):
4447 """add_filename(RestraintInfo self, std::string key, std::string value)"""
4448 return _IMP_kernel.RestraintInfo_add_filename(self, key, value)
4451 def get_number_of_filename(self):
4452 """get_number_of_filename(RestraintInfo self) -> unsigned int"""
4453 return _IMP_kernel.RestraintInfo_get_number_of_filename(self)
4456 def get_filename_key(self, i):
4457 """get_filename_key(RestraintInfo self, unsigned int i) -> std::string"""
4458 return _IMP_kernel.RestraintInfo_get_filename_key(self, i)
4461 def get_filename_value(self, i):
4462 """get_filename_value(RestraintInfo self, unsigned int i) -> std::string"""
4463 return _IMP_kernel.RestraintInfo_get_filename_value(self, i)
4466 def add_floats(self, key, value):
4467 """add_floats(RestraintInfo self, std::string key, IMP::Floats value)"""
4468 return _IMP_kernel.RestraintInfo_add_floats(self, key, value)
4471 def get_number_of_floats(self):
4472 """get_number_of_floats(RestraintInfo self) -> unsigned int"""
4473 return _IMP_kernel.RestraintInfo_get_number_of_floats(self)
4476 def get_floats_key(self, i):
4477 """get_floats_key(RestraintInfo self, unsigned int i) -> std::string"""
4478 return _IMP_kernel.RestraintInfo_get_floats_key(self, i)
4481 def get_floats_value(self, i):
4482 """get_floats_value(RestraintInfo self, unsigned int i) -> IMP::Floats"""
4483 return _IMP_kernel.RestraintInfo_get_floats_value(self, i)
4486 def add_ints(self, key, value):
4487 """add_ints(RestraintInfo self, std::string key, IMP::Ints value)"""
4488 return _IMP_kernel.RestraintInfo_add_ints(self, key, value)
4491 def get_number_of_ints(self):
4492 """get_number_of_ints(RestraintInfo self) -> unsigned int"""
4493 return _IMP_kernel.RestraintInfo_get_number_of_ints(self)
4496 def get_ints_key(self, i):
4497 """get_ints_key(RestraintInfo self, unsigned int i) -> std::string"""
4498 return _IMP_kernel.RestraintInfo_get_ints_key(self, i)
4501 def get_ints_value(self, i):
4502 """get_ints_value(RestraintInfo self, unsigned int i) -> IMP::Ints"""
4503 return _IMP_kernel.RestraintInfo_get_ints_value(self, i)
4506 def add_strings(self, key, value):
4507 """add_strings(RestraintInfo self, std::string key, IMP::Strings value)"""
4508 return _IMP_kernel.RestraintInfo_add_strings(self, key, value)
4511 def get_number_of_strings(self):
4512 """get_number_of_strings(RestraintInfo self) -> unsigned int"""
4513 return _IMP_kernel.RestraintInfo_get_number_of_strings(self)
4516 def get_strings_key(self, i):
4517 """get_strings_key(RestraintInfo self, unsigned int i) -> std::string"""
4518 return _IMP_kernel.RestraintInfo_get_strings_key(self, i)
4521 def get_strings_value(self, i):
4522 """get_strings_value(RestraintInfo self, unsigned int i) -> IMP::Strings"""
4523 return _IMP_kernel.RestraintInfo_get_strings_value(self, i)
4526 def add_filenames(self, key, value):
4527 """add_filenames(RestraintInfo self, std::string key, IMP::Strings value)"""
4528 return _IMP_kernel.RestraintInfo_add_filenames(self, key, value)
4531 def get_number_of_filenames(self):
4532 """get_number_of_filenames(RestraintInfo self) -> unsigned int"""
4533 return _IMP_kernel.RestraintInfo_get_number_of_filenames(self)
4536 def get_filenames_key(self, i):
4537 """get_filenames_key(RestraintInfo self, unsigned int i) -> std::string"""
4538 return _IMP_kernel.RestraintInfo_get_filenames_key(self, i)
4541 def get_filenames_value(self, i):
4542 """get_filenames_value(RestraintInfo self, unsigned int i) -> IMP::Strings"""
4543 return _IMP_kernel.RestraintInfo_get_filenames_value(self, i)
4546 def add_particle_indexes(self, key, value):
4547 """add_particle_indexes(RestraintInfo self, std::string key, IMP::ParticleIndexes value)"""
4548 return _IMP_kernel.RestraintInfo_add_particle_indexes(self, key, value)
4551 def get_number_of_particle_indexes(self):
4552 """get_number_of_particle_indexes(RestraintInfo self) -> unsigned int"""
4553 return _IMP_kernel.RestraintInfo_get_number_of_particle_indexes(self)
4556 def get_particle_indexes_key(self, i):
4557 """get_particle_indexes_key(RestraintInfo self, unsigned int i) -> std::string"""
4558 return _IMP_kernel.RestraintInfo_get_particle_indexes_key(self, i)
4561 def get_particle_indexes_value(self, i):
4562 """get_particle_indexes_value(RestraintInfo self, unsigned int i) -> IMP::ParticleIndexes"""
4563 return _IMP_kernel.RestraintInfo_get_particle_indexes_value(self, i)
4566 def get_version_info(self):
4567 """get_version_info(RestraintInfo self) -> VersionInfo"""
4568 return _IMP_kernel.RestraintInfo_get_version_info(self)
4572 """__str__(RestraintInfo self) -> std::string"""
4573 return _IMP_kernel.RestraintInfo___str__(self)
4577 """__repr__(RestraintInfo self) -> std::string"""
4578 return _IMP_kernel.RestraintInfo___repr__(self)
4583 return _object_cast_to_RestraintInfo(o)
4585 RestraintInfo_swigregister = _IMP_kernel.RestraintInfo_swigregister
4586 RestraintInfo_swigregister(RestraintInfo)
4588 class Restraint(ModelObject):
4589 """Proxy of C++ IMP::Restraint class"""
4590 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
4592 def __init__(self, m, name):
4593 """__init__(IMP::Restraint self, Model m, std::string name) -> Restraint"""
4594 if self.__class__ == Restraint:
4598 this = _IMP_kernel.new_Restraint(_self, m, name)
4600 self.this.append(this)
4604 if self.__class__ != Restraint:
4605 _director_objects.register(self)
4610 def get_score(self):
4611 """get_score(Restraint self) -> double"""
4612 return _IMP_kernel.Restraint_get_score(self)
4615 def evaluate(self, calc_derivs):
4616 """evaluate(Restraint self, bool calc_derivs) -> double"""
4617 return _IMP_kernel.Restraint_evaluate(self, calc_derivs)
4620 def evaluate_if_good(self, calc_derivatives):
4621 """evaluate_if_good(Restraint self, bool calc_derivatives) -> double"""
4622 return _IMP_kernel.Restraint_evaluate_if_good(self, calc_derivatives)
4625 def evaluate_if_below(self, calc_derivatives, max):
4626 """evaluate_if_below(Restraint self, bool calc_derivatives, double max) -> double"""
4627 return _IMP_kernel.Restraint_evaluate_if_below(self, calc_derivatives, max)
4630 def unprotected_evaluate(self, da):
4631 """unprotected_evaluate(Restraint self, DerivativeAccumulator da) -> double"""
4632 return _IMP_kernel.Restraint_unprotected_evaluate(self, da)
4635 def unprotected_evaluate_if_good(self, da, max):
4636 """unprotected_evaluate_if_good(Restraint self, DerivativeAccumulator da, double max) -> double"""
4637 return _IMP_kernel.Restraint_unprotected_evaluate_if_good(self, da, max)
4640 def unprotected_evaluate_if_below(self, da, max):
4641 """unprotected_evaluate_if_below(Restraint self, DerivativeAccumulator da, double max) -> double"""
4642 return _IMP_kernel.Restraint_unprotected_evaluate_if_below(self, da, max)
4645 def get_static_info(self):
4646 """get_static_info(Restraint self) -> RestraintInfo"""
4647 return _IMP_kernel.Restraint_get_static_info(self)
4650 def get_dynamic_info(self):
4651 """get_dynamic_info(Restraint self) -> RestraintInfo"""
4652 return _IMP_kernel.Restraint_get_dynamic_info(self)
4655 def add_score_and_derivatives(self, sa):
4656 """add_score_and_derivatives(Restraint self, ScoreAccumulator sa)"""
4657 return _IMP_kernel.Restraint_add_score_and_derivatives(self, sa)
4661 """create_decomposition(Restraint self) -> Restraint"""
4662 return _IMP_kernel.Restraint_create_decomposition(self)
4665 def create_current_decomposition(self):
4666 """create_current_decomposition(Restraint self) -> Restraint"""
4667 return _IMP_kernel.Restraint_create_current_decomposition(self)
4670 def set_weight(self, weight):
4671 """set_weight(Restraint self, IMP::Float weight)"""
4672 return _IMP_kernel.Restraint_set_weight(self, weight)
4675 def get_weight(self):
4676 """get_weight(Restraint self) -> IMP::Float"""
4677 return _IMP_kernel.Restraint_get_weight(self)
4680 def get_maximum_score(self):
4681 """get_maximum_score(Restraint self) -> double"""
4682 return _IMP_kernel.Restraint_get_maximum_score(self)
4685 def set_maximum_score(self, s):
4686 """set_maximum_score(Restraint self, double s)"""
4687 return _IMP_kernel.Restraint_set_maximum_score(self, s)
4692 create_scoring_function(Restraint self, double weight=1.0, double max) -> ScoringFunction
4693 create_scoring_function(Restraint self, double weight=1.0) -> ScoringFunction
4694 create_scoring_function(Restraint self) -> ScoringFunction
4696 return _IMP_kernel.Restraint_create_scoring_function(self, *args)
4699 def set_last_score(self, s):
4700 """set_last_score(Restraint self, double s)"""
4701 return _IMP_kernel.Restraint_set_last_score(self, s)
4704 def get_last_score(self):
4705 """get_last_score(Restraint self) -> double"""
4706 return _IMP_kernel.Restraint_get_last_score(self)
4709 def get_was_good(self):
4710 """get_was_good(Restraint self) -> bool"""
4711 return _IMP_kernel.Restraint_get_was_good(self)
4713 __swig_destroy__ = _IMP_kernel.delete_Restraint
4714 __del__ =
lambda self:
None
4716 def do_create_decomposition(self):
4717 """do_create_decomposition(Restraint self) -> IMP::Restraints"""
4718 return _IMP_kernel.Restraint_do_create_decomposition(self)
4721 def do_create_current_decomposition(self):
4722 """do_create_current_decomposition(Restraint self) -> IMP::Restraints"""
4723 return _IMP_kernel.Restraint_do_create_current_decomposition(self)
4726 def do_add_score_and_derivatives(self, sa):
4727 """do_add_score_and_derivatives(Restraint self, ScoreAccumulator sa)"""
4728 return _IMP_kernel.Restraint_do_add_score_and_derivatives(self, sa)
4731 def do_get_outputs(self):
4732 """do_get_outputs(Restraint self) -> IMP::ModelObjectsTemp"""
4733 return _IMP_kernel.Restraint_do_get_outputs(self)
4737 """__str__(Restraint self) -> std::string"""
4738 return _IMP_kernel.Restraint___str__(self)
4742 """__repr__(Restraint self) -> std::string"""
4743 return _IMP_kernel.Restraint___repr__(self)
4748 return _object_cast_to_Restraint(o)
4751 def get_type_name(self):
4752 return self.__class__.__name__
4753 def do_show(self, out):
4755 def get_version_info(self):
4757 return VersionInfo(self.__module__,
4764 return _object_cast_to_Restraint(o)
4766 def __disown__(self):
4768 _IMP_kernel.disown_Restraint(self)
4769 return weakref_proxy(self)
4771 def do_destroy(self):
4772 """do_destroy(Restraint self)"""
4773 return _IMP_kernel.Restraint_do_destroy(self)
4776 def handle_set_has_required_score_states(self, arg0):
4777 """handle_set_has_required_score_states(Restraint self, bool arg0)"""
4778 return _IMP_kernel.Restraint_handle_set_has_required_score_states(self, arg0)
4781 def do_get_inputs(self):
4782 """do_get_inputs(Restraint self) -> IMP::ModelObjectsTemp"""
4783 return _IMP_kernel.Restraint_do_get_inputs(self)
4786 def do_get_interactions(self):
4787 """do_get_interactions(Restraint self) -> IMP::ModelObjectsTemps"""
4788 return _IMP_kernel.Restraint_do_get_interactions(self)
4790 Restraint_swigregister = _IMP_kernel.Restraint_swigregister
4791 Restraint_swigregister(Restraint)
4793 class _RestraintsAdaptor(_InputAdaptor):
4794 """Proxy of C++ IMP::RestraintsAdaptor class"""
4795 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
4796 __repr__ = _swig_repr
4798 def __init__(self, *args):
4800 __init__(IMP::RestraintsAdaptor self) -> _RestraintsAdaptor
4801 __init__(IMP::RestraintsAdaptor self, IMP::Restraints const & sf) -> _RestraintsAdaptor
4802 __init__(IMP::RestraintsAdaptor self, IMP::RestraintsTemp const & sf) -> _RestraintsAdaptor
4803 __init__(IMP::RestraintsAdaptor self, Restraint sf) -> _RestraintsAdaptor
4805 this = _IMP_kernel.new__RestraintsAdaptor(*args)
4807 self.this.append(this)
4810 __swig_destroy__ = _IMP_kernel.delete__RestraintsAdaptor
4811 __del__ =
lambda self:
None
4812 _RestraintsAdaptor_swigregister = _IMP_kernel._RestraintsAdaptor_swigregister
4813 _RestraintsAdaptor_swigregister(_RestraintsAdaptor)
4815 class RestraintSet(Restraint):
4816 """Proxy of C++ IMP::RestraintSet class"""
4817 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
4819 def __init__(self, *args):
4821 __init__(IMP::RestraintSet self, Model m, double weight, std::string const & name) -> RestraintSet
4822 __init__(IMP::RestraintSet self, Model m, double weight) -> RestraintSet
4823 __init__(IMP::RestraintSet self, Model m, std::string const & name) -> RestraintSet
4824 __init__(IMP::RestraintSet self, Model m) -> RestraintSet
4825 __init__(IMP::RestraintSet self, IMP::RestraintsTemp const & rs, double weight, std::string const & name) -> RestraintSet
4826 __init__(IMP::RestraintSet self, IMP::RestraintsTemp const & rs, double weight) -> RestraintSet
4828 if self.__class__ == RestraintSet:
4832 this = _IMP_kernel.new_RestraintSet(_self, *args)
4834 self.this.append(this)
4838 if self.__class__ != RestraintSet:
4839 _director_objects.register(self)
4844 def unprotected_evaluate(self, da):
4845 """unprotected_evaluate(RestraintSet self, DerivativeAccumulator da) -> double"""
4846 return _IMP_kernel.RestraintSet_unprotected_evaluate(self, da)
4849 def get_type_name(self):
4850 """get_type_name(RestraintSet self) -> std::string"""
4851 return _IMP_kernel.RestraintSet_get_type_name(self)
4854 def get_version_info(self):
4855 """get_version_info(RestraintSet self) -> VersionInfo"""
4856 return _IMP_kernel.RestraintSet_get_version_info(self)
4859 def remove_restraint(self, d):
4860 """remove_restraint(RestraintSet self, Restraint d)"""
4861 return _IMP_kernel.RestraintSet_remove_restraint(self, d)
4864 def remove_restraints(self, d):
4865 """remove_restraints(RestraintSet self, IMP::Restraints const & d)"""
4866 return _IMP_kernel.RestraintSet_remove_restraints(self, d)
4869 def set_restraints(self, ps):
4870 """set_restraints(RestraintSet self, IMP::Restraints const & ps)"""
4871 return _IMP_kernel.RestraintSet_set_restraints(self, ps)
4874 def set_restraints_order(self, objs):
4875 """set_restraints_order(RestraintSet self, IMP::Restraints const & objs)"""
4876 return _IMP_kernel.RestraintSet_set_restraints_order(self, objs)
4880 """add_restraint(RestraintSet self, Restraint obj) -> unsigned int"""
4881 return _IMP_kernel.RestraintSet_add_restraint(self, obj)
4885 """add_restraints(RestraintSet self, IMP::Restraints const & objs)"""
4886 return _IMP_kernel.RestraintSet_add_restraints(self, objs)
4889 def clear_restraints(self):
4890 """clear_restraints(RestraintSet self)"""
4891 return _IMP_kernel.RestraintSet_clear_restraints(self)
4894 def get_number_of_restraints(self):
4895 """get_number_of_restraints(RestraintSet self) -> unsigned int"""
4896 return _IMP_kernel.RestraintSet_get_number_of_restraints(self)
4899 def get_has_restraints(self):
4900 """get_has_restraints(RestraintSet self) -> bool"""
4901 return _IMP_kernel.RestraintSet_get_has_restraints(self)
4904 def get_restraint(self, i):
4905 """get_restraint(RestraintSet self, unsigned int i) -> Restraint"""
4906 return _IMP_kernel.RestraintSet_get_restraint(self, i)
4909 def get_restraints(self):
4910 """get_restraints(RestraintSet self) -> IMP::Restraints"""
4911 return _IMP_kernel.RestraintSet_get_restraints(self)
4914 def reserve_restraints(self, sz):
4915 """reserve_restraints(RestraintSet self, unsigned int sz)"""
4916 return _IMP_kernel.RestraintSet_reserve_restraints(self, sz)
4919 def get_non_sets_and_sets(self):
4920 """get_non_sets_and_sets(RestraintSet self) -> std::pair< IMP::RestraintsTemp,IMP::RestraintSetsTemp >"""
4921 return _IMP_kernel.RestraintSet_get_non_sets_and_sets(self)
4924 def do_get_inputs(self):
4925 """do_get_inputs(RestraintSet self) -> IMP::ModelObjectsTemp"""
4926 return _IMP_kernel.RestraintSet_do_get_inputs(self)
4931 create_scoring_function(RestraintSet self, double weight=1.0, double max) -> ScoringFunction
4932 create_scoring_function(RestraintSet self, double weight=1.0) -> ScoringFunction
4933 create_scoring_function(RestraintSet self) -> ScoringFunction
4935 return _IMP_kernel.RestraintSet_create_scoring_function(self, *args)
4938 def get_last_score(self):
4939 """get_last_score(RestraintSet self) -> double"""
4940 return _IMP_kernel.RestraintSet_get_last_score(self)
4944 """__str__(RestraintSet self) -> std::string"""
4945 return _IMP_kernel.RestraintSet___str__(self)
4949 """__repr__(RestraintSet self) -> std::string"""
4950 return _IMP_kernel.RestraintSet___repr__(self)
4955 return _object_cast_to_RestraintSet(o)
4958 def get_type_name(self):
4959 return self.__class__.__name__
4960 def do_show(self, out):
4962 def get_version_info(self):
4964 return VersionInfo(self.__module__,
4971 return _object_cast_to_RestraintSet(o)
4973 def __disown__(self):
4975 _IMP_kernel.disown_RestraintSet(self)
4976 return weakref_proxy(self)
4978 def do_destroy(self):
4979 """do_destroy(RestraintSet self)"""
4980 return _IMP_kernel.RestraintSet_do_destroy(self)
4983 def handle_set_has_required_score_states(self, arg0):
4984 """handle_set_has_required_score_states(RestraintSet self, bool arg0)"""
4985 return _IMP_kernel.RestraintSet_handle_set_has_required_score_states(self, arg0)
4988 def do_get_outputs(self):
4989 """do_get_outputs(RestraintSet self) -> IMP::ModelObjectsTemp"""
4990 return _IMP_kernel.RestraintSet_do_get_outputs(self)
4993 def do_get_interactions(self):
4994 """do_get_interactions(RestraintSet self) -> IMP::ModelObjectsTemps"""
4995 return _IMP_kernel.RestraintSet_do_get_interactions(self)
4998 def do_create_decomposition(self):
4999 """do_create_decomposition(RestraintSet self) -> IMP::Restraints"""
5000 return _IMP_kernel.RestraintSet_do_create_decomposition(self)
5003 def do_create_current_decomposition(self):
5004 """do_create_current_decomposition(RestraintSet self) -> IMP::Restraints"""
5005 return _IMP_kernel.RestraintSet_do_create_current_decomposition(self)
5008 def do_add_score_and_derivatives(self, sa):
5009 """do_add_score_and_derivatives(RestraintSet self, ScoreAccumulator sa)"""
5010 return _IMP_kernel.RestraintSet_do_add_score_and_derivatives(self, sa)
5012 RestraintSet_swigregister = _IMP_kernel.RestraintSet_swigregister
5013 RestraintSet_swigregister(RestraintSet)
5016 def get_restraints(rs):
5017 """get_restraints(IMP::RestraintsTemp const & rs) -> IMP::RestraintsTemp"""
5018 return _IMP_kernel.get_restraints(rs)
5020 def _check_particle(p, a):
5021 if (
not p.get_is_active()):
5022 raise ValueError(
"Inactive Particle")
5023 if (type(a)() == a):
5024 raise IndexError(
"Cannot use default Index")
5025 if (
not p.has_attribute(a)):
5026 raise IndexError(
"Particle does not have attribute")
5028 class Particle(ModelObject):
5029 """Proxy of C++ IMP::Particle class"""
5030 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
5032 def get_version_info(self):
5033 """get_version_info(Particle self) -> VersionInfo"""
5034 return _IMP_kernel.Particle_get_version_info(self)
5037 def __init__(self, *args):
5039 __init__(IMP::Particle self, Model m, std::string name) -> Particle
5040 __init__(IMP::Particle self, Model m) -> Particle
5042 this = _IMP_kernel.new_Particle(*args)
5044 self.this.append(this)
5048 def get_float_keys(self):
5049 """get_float_keys(Particle self) -> IMP::FloatKeys"""
5050 return _IMP_kernel.Particle_get_float_keys(self)
5053 def get_floats_keys(self):
5054 """get_floats_keys(Particle self) -> IMP::FloatsKeys"""
5055 return _IMP_kernel.Particle_get_floats_keys(self)
5058 def get_int_keys(self):
5059 """get_int_keys(Particle self) -> IMP::IntKeys"""
5060 return _IMP_kernel.Particle_get_int_keys(self)
5063 def get_ints_keys(self):
5064 """get_ints_keys(Particle self) -> IMP::IntsKeys"""
5065 return _IMP_kernel.Particle_get_ints_keys(self)
5068 def get_string_keys(self):
5069 """get_string_keys(Particle self) -> IMP::StringKeys"""
5070 return _IMP_kernel.Particle_get_string_keys(self)
5073 def get_object_keys(self):
5074 """get_object_keys(Particle self) -> IMP::ObjectKeys"""
5075 return _IMP_kernel.Particle_get_object_keys(self)
5078 def add_cache_attribute(self, *args):
5080 add_cache_attribute(Particle self, FloatKey name, IMP::Float value)
5081 add_cache_attribute(Particle self, FloatsKey name, IMP::Floats value)
5082 add_cache_attribute(Particle self, IntKey name, IMP::Int value)
5083 add_cache_attribute(Particle self, IntsKey name, IMP::Ints value)
5084 add_cache_attribute(Particle self, StringKey name, IMP::String value)
5085 add_cache_attribute(Particle self, ObjectKey name, Object value)
5086 add_cache_attribute(Particle self, IMP::WeakObjectKey name, Object value)
5088 return _IMP_kernel.Particle_add_cache_attribute(self, *args)
5091 def get_weak_object_keys(self):
5092 """get_weak_object_keys(Particle self) -> IMP::WeakObjectKeys"""
5093 return _IMP_kernel.Particle_get_weak_object_keys(self)
5096 def add_to_derivative(self, key, value, da):
5097 """add_to_derivative(Particle self, FloatKey key, IMP::Float value, DerivativeAccumulator da)"""
5098 return _IMP_kernel.Particle_add_to_derivative(self, key, value, da)
5101 def set_is_optimized(self, k, tf):
5102 """set_is_optimized(Particle self, FloatKey k, bool tf)"""
5103 return _IMP_kernel.Particle_set_is_optimized(self, k, tf)
5106 def get_is_optimized(self, k):
5107 """get_is_optimized(Particle self, FloatKey k) -> bool"""
5108 return _IMP_kernel.Particle_get_is_optimized(self, k)
5111 def get_derivative(self, k):
5112 """get_derivative(Particle self, FloatKey k) -> IMP::Float"""
5113 return _IMP_kernel.Particle_get_derivative(self, k)
5116 def add_attribute(self, *args):
5118 add_attribute(Particle self, FloatKey name, IMP::Float initial_value)
5119 add_attribute(Particle self, FloatsKey name, IMP::Floats initial_value)
5120 add_attribute(Particle self, IntKey name, IMP::Int initial_value)
5121 add_attribute(Particle self, IntsKey name, IMP::Ints initial_value)
5122 add_attribute(Particle self, StringKey name, IMP::String initial_value)
5123 add_attribute(Particle self, ObjectKey name, Object initial_value)
5124 add_attribute(Particle self, IMP::WeakObjectKey name, Object initial_value)
5125 add_attribute(Particle self, FloatKey name, IMP::Float const initial_value, bool optimized)
5126 add_attribute(Particle self, ParticleIndexKey k, Particle v)
5128 return _IMP_kernel.Particle_add_attribute(self, *args)
5131 def has_attribute(self, *args):
5133 has_attribute(Particle self, FloatKey name) -> bool
5134 has_attribute(Particle self, FloatsKey name) -> bool
5135 has_attribute(Particle self, IntKey name) -> bool
5136 has_attribute(Particle self, IntsKey name) -> bool
5137 has_attribute(Particle self, StringKey name) -> bool
5138 has_attribute(Particle self, ObjectKey name) -> bool
5139 has_attribute(Particle self, IMP::WeakObjectKey name) -> bool
5140 has_attribute(Particle self, ParticleIndexKey k) -> bool
5142 return _IMP_kernel.Particle_has_attribute(self, *args)
5145 def set_value(self, *args):
5147 set_value(Particle self, FloatKey name, IMP::Float value)
5148 set_value(Particle self, FloatsKey name, IMP::Floats value)
5149 set_value(Particle self, IntKey name, IMP::Int value)
5150 set_value(Particle self, IntsKey name, IMP::Ints value)
5151 set_value(Particle self, StringKey name, IMP::String value)
5152 set_value(Particle self, ObjectKey name, Object value)
5153 set_value(Particle self, IMP::WeakObjectKey name, Object value)
5154 set_value(Particle self, ParticleIndexKey k, Particle v)
5156 return _IMP_kernel.Particle_set_value(self, *args)
5159 def get_value(self, *args):
5161 get_value(Particle self, FloatKey name) -> IMP::Float
5162 get_value(Particle self, FloatsKey name) -> IMP::Floats
5163 get_value(Particle self, IntKey name) -> IMP::Int
5164 get_value(Particle self, IntsKey name) -> IMP::Ints
5165 get_value(Particle self, StringKey name) -> IMP::String
5166 get_value(Particle self, ObjectKey name) -> Object
5167 get_value(Particle self, IMP::WeakObjectKey name) -> Object
5168 get_value(Particle self, ParticleIndexKey k) -> Particle
5170 return _IMP_kernel.Particle_get_value(self, *args)
5173 def remove_attribute(self, *args):
5175 remove_attribute(Particle self, FloatKey name)
5176 remove_attribute(Particle self, FloatsKey name)
5177 remove_attribute(Particle self, IntKey name)
5178 remove_attribute(Particle self, IntsKey name)
5179 remove_attribute(Particle self, StringKey name)
5180 remove_attribute(Particle self, ObjectKey name)
5181 remove_attribute(Particle self, IMP::WeakObjectKey name)
5182 remove_attribute(Particle self, ParticleIndexKey k)
5184 return _IMP_kernel.Particle_remove_attribute(self, *args)
5187 def get_particle_keys(self):
5188 """get_particle_keys(Particle self) -> IMP::ParticleIndexKeys"""
5189 return _IMP_kernel.Particle_get_particle_keys(self)
5192 def show(self, *args):
5194 show(Particle self, _ostream out)
5197 return _IMP_kernel.Particle_show(self, *args)
5200 def get_is_active(self):
5201 """get_is_active(Particle self) -> bool"""
5202 return _IMP_kernel.Particle_get_is_active(self)
5206 """get_index(Particle self) -> ParticleIndex"""
5207 return _IMP_kernel.Particle_get_index(self)
5210 def __eq__(self, *args):
5212 __eq__(Particle self, Particle o) -> bool
5213 __eq__(Particle self, Decorator d) -> bool
5215 return _IMP_kernel.Particle___eq__(self, *args)
5218 def __ne__(self, *args):
5220 __ne__(Particle self, Particle o) -> bool
5221 __ne__(Particle self, Decorator d) -> bool
5223 return _IMP_kernel.Particle___ne__(self, *args)
5226 def __le__(self, *args):
5228 __le__(Particle self, Particle o) -> bool
5229 __le__(Particle self, Decorator d) -> bool
5231 return _IMP_kernel.Particle___le__(self, *args)
5234 def __lt__(self, *args):
5236 __lt__(Particle self, Particle o) -> bool
5237 __lt__(Particle self, Decorator d) -> bool
5239 return _IMP_kernel.Particle___lt__(self, *args)
5242 def __ge__(self, *args):
5244 __ge__(Particle self, Particle o) -> bool
5245 __ge__(Particle self, Decorator d) -> bool
5247 return _IMP_kernel.Particle___ge__(self, *args)
5250 def __gt__(self, *args):
5252 __gt__(Particle self, Particle o) -> bool
5253 __gt__(Particle self, Decorator d) -> bool
5255 return _IMP_kernel.Particle___gt__(self, *args)
5258 __hash__ = ModelObject.__hash__
5262 """__str__(Particle self) -> std::string"""
5263 return _IMP_kernel.Particle___str__(self)
5267 """__repr__(Particle self) -> std::string"""
5268 return _IMP_kernel.Particle___repr__(self)
5273 return _object_cast_to_Particle(o)
5275 Particle_swigregister = _IMP_kernel.Particle_swigregister
5276 Particle_swigregister(Particle)
5278 class _ParticleAdaptor(_InputAdaptor):
5279 """Proxy of C++ IMP::ParticleAdaptor class"""
5280 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
5281 __repr__ = _swig_repr
5283 def __init__(self, *args):
5285 __init__(IMP::ParticleAdaptor self) -> _ParticleAdaptor
5286 __init__(IMP::ParticleAdaptor self, Particle p) -> _ParticleAdaptor
5287 __init__(IMP::ParticleAdaptor self, Decorator d) -> _ParticleAdaptor
5289 this = _IMP_kernel.new__ParticleAdaptor(*args)
5291 self.this.append(this)
5295 def get_model(self):
5296 """get_model(_ParticleAdaptor self) -> Model"""
5297 return _IMP_kernel._ParticleAdaptor_get_model(self)
5300 def get_particle_index(self):
5301 """get_particle_index(_ParticleAdaptor self) -> ParticleIndex"""
5302 return _IMP_kernel._ParticleAdaptor_get_particle_index(self)
5304 __swig_destroy__ = _IMP_kernel.delete__ParticleAdaptor
5305 __del__ =
lambda self:
None
5306 _ParticleAdaptor_swigregister = _IMP_kernel._ParticleAdaptor_swigregister
5307 _ParticleAdaptor_swigregister(_ParticleAdaptor)
5309 class _DependencyGraphVertexIndex(object):
5310 """Proxy of C++ IMP::DependencyGraphVertexIndex class"""
5311 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
5312 __repr__ = _swig_repr
5315 """__init__(IMP::DependencyGraphVertexIndex self) -> _DependencyGraphVertexIndex"""
5316 this = _IMP_kernel.new__DependencyGraphVertexIndex()
5318 self.this.append(this)
5321 __swig_destroy__ = _IMP_kernel.delete__DependencyGraphVertexIndex
5322 __del__ =
lambda self:
None
5323 _DependencyGraphVertexIndex_swigregister = _IMP_kernel._DependencyGraphVertexIndex_swigregister
5324 _DependencyGraphVertexIndex_swigregister(_DependencyGraphVertexIndex)
5327 def show_as_graphviz(name, out):
5328 """show_as_graphviz(IMP::DependencyGraph const & name, TextOutput out)"""
5329 return _IMP_kernel.show_as_graphviz(name, out)
5331 def get_vertex_index(g):
5332 """get_vertex_index(IMP::DependencyGraph const & g) -> _DependencyGraphVertexIndex"""
5333 return _IMP_kernel.get_vertex_index(g)
5336 """get_dependency_graph(Model m) -> IMP::DependencyGraph"""
5337 return _IMP_kernel.get_dependency_graph(m)
5340 """get_pruned_dependency_graph(Model m) -> IMP::DependencyGraph"""
5341 return _IMP_kernel.get_pruned_dependency_graph(m)
5345 get_required_score_states(IMP::ModelObjectsTemp const & mos, IMP::ScoreStatesTemp exclude) -> IMP::ScoreStatesTemp
5346 get_required_score_states(IMP::ModelObjectsTemp const & mos) -> IMP::ScoreStatesTemp
5347 get_required_score_states(ModelObject p, IMP::ModelObjectsTemp const & all, IMP::DependencyGraph const & dg, _DependencyGraphVertexIndex index) -> IMP::ScoreStatesTemp
5349 return _IMP_kernel.get_required_score_states(*args)
5352 """get_dependent_particles(ModelObject p, IMP::ModelObjectsTemp const & all, IMP::DependencyGraph const & dg, _DependencyGraphVertexIndex index) -> IMP::ParticlesTemp"""
5353 return _IMP_kernel.get_dependent_particles(p, all, dg, index)
5355 def get_dependent_restraints(m, pi):
5356 """get_dependent_restraints(Model m, ParticleIndex pi) -> IMP::RestraintsTemp"""
5357 return _IMP_kernel.get_dependent_restraints(m, pi)
5358 class ScoringFunction(ModelObject):
5359 """Proxy of C++ IMP::ScoringFunction class"""
5360 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
5362 def do_add_score_and_derivatives(self, sa, ss):
5363 """do_add_score_and_derivatives(ScoringFunction self, ScoreAccumulator sa, IMP::ScoreStatesTemp const & ss)"""
5364 return _IMP_kernel.ScoringFunction_do_add_score_and_derivatives(self, sa, ss)
5367 def get_score_accumulator_if_below(self, deriv, max):
5368 """get_score_accumulator_if_below(ScoringFunction self, bool deriv, double max) -> ScoreAccumulator"""
5369 return _IMP_kernel.ScoringFunction_get_score_accumulator_if_below(self, deriv, max)
5372 def get_score_accumulator_if_good(self, deriv):
5373 """get_score_accumulator_if_good(ScoringFunction self, bool deriv) -> ScoreAccumulator"""
5374 return _IMP_kernel.ScoringFunction_get_score_accumulator_if_good(self, deriv)
5377 def get_score_accumulator(self, deriv):
5378 """get_score_accumulator(ScoringFunction self, bool deriv) -> ScoreAccumulator"""
5379 return _IMP_kernel.ScoringFunction_get_score_accumulator(self, deriv)
5382 def __init__(self, m, name):
5383 """__init__(IMP::ScoringFunction self, Model m, std::string name) -> ScoringFunction"""
5384 if self.__class__ == ScoringFunction:
5388 this = _IMP_kernel.new_ScoringFunction(_self, m, name)
5390 self.this.append(this)
5394 if self.__class__ != ScoringFunction:
5395 _director_objects.register(self)
5400 def do_get_outputs(self):
5401 """do_get_outputs(ScoringFunction self) -> IMP::ModelObjectsTemp"""
5402 return _IMP_kernel.ScoringFunction_do_get_outputs(self)
5405 def evaluate_if_good(self, derivatives):
5406 """evaluate_if_good(ScoringFunction self, bool derivatives) -> double"""
5407 return _IMP_kernel.ScoringFunction_evaluate_if_good(self, derivatives)
5410 def evaluate(self, derivatives):
5411 """evaluate(ScoringFunction self, bool derivatives) -> double"""
5412 return _IMP_kernel.ScoringFunction_evaluate(self, derivatives)
5415 def evaluate_if_below(self, derivatives, max):
5416 """evaluate_if_below(ScoringFunction self, bool derivatives, double max) -> double"""
5417 return _IMP_kernel.ScoringFunction_evaluate_if_below(self, derivatives, max)
5420 def get_had_good_score(self):
5421 """get_had_good_score(ScoringFunction self) -> bool"""
5422 return _IMP_kernel.ScoringFunction_get_had_good_score(self)
5425 def get_last_score(self):
5426 """get_last_score(ScoringFunction self) -> double"""
5427 return _IMP_kernel.ScoringFunction_get_last_score(self)
5431 """create_restraints(ScoringFunction self) -> IMP::Restraints"""
5432 return _IMP_kernel.ScoringFunction_create_restraints(self)
5436 """__str__(ScoringFunction self) -> std::string"""
5437 return _IMP_kernel.ScoringFunction___str__(self)
5441 """__repr__(ScoringFunction self) -> std::string"""
5442 return _IMP_kernel.ScoringFunction___repr__(self)
5447 return _object_cast_to_ScoringFunction(o)
5450 def get_type_name(self):
5451 return self.__class__.__name__
5452 def do_show(self, out):
5454 def get_version_info(self):
5456 return VersionInfo(self.__module__,
5463 return _object_cast_to_ScoringFunction(o)
5465 __swig_destroy__ = _IMP_kernel.delete_ScoringFunction
5466 __del__ =
lambda self:
None
5467 def __disown__(self):
5469 _IMP_kernel.disown_ScoringFunction(self)
5470 return weakref_proxy(self)
5472 def do_destroy(self):
5473 """do_destroy(ScoringFunction self)"""
5474 return _IMP_kernel.ScoringFunction_do_destroy(self)
5477 def handle_set_has_required_score_states(self, arg0):
5478 """handle_set_has_required_score_states(ScoringFunction self, bool arg0)"""
5479 return _IMP_kernel.ScoringFunction_handle_set_has_required_score_states(self, arg0)
5482 def do_get_inputs(self):
5483 """do_get_inputs(ScoringFunction self) -> IMP::ModelObjectsTemp"""
5484 return _IMP_kernel.ScoringFunction_do_get_inputs(self)
5487 def do_get_interactions(self):
5488 """do_get_interactions(ScoringFunction self) -> IMP::ModelObjectsTemps"""
5489 return _IMP_kernel.ScoringFunction_do_get_interactions(self)
5491 ScoringFunction_swigregister = _IMP_kernel.ScoringFunction_swigregister
5492 ScoringFunction_swigregister(ScoringFunction)
5497 create_decomposition(IMP::RestraintsTemp const & rs) -> IMP::Restraints
5498 create_decomposition(ScoringFunction sf) -> IMP::ScoringFunctions
5500 return _IMP_kernel.create_decomposition(*args)
5501 class _ScoringFunctionAdaptor(_InputAdaptor):
5502 """Proxy of C++ IMP::ScoringFunctionAdaptor class"""
5503 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
5504 __repr__ = _swig_repr
5506 def __init__(self, *args):
5508 __init__(IMP::ScoringFunctionAdaptor self) -> _ScoringFunctionAdaptor
5509 __init__(IMP::ScoringFunctionAdaptor self, ScoringFunction sf) -> _ScoringFunctionAdaptor
5510 __init__(IMP::ScoringFunctionAdaptor self, IMP::RestraintsTemp const & sf) -> _ScoringFunctionAdaptor
5511 __init__(IMP::ScoringFunctionAdaptor self, IMP::Restraints const & sf) -> _ScoringFunctionAdaptor
5512 __init__(IMP::ScoringFunctionAdaptor self, Restraint sf) -> _ScoringFunctionAdaptor
5514 this = _IMP_kernel.new__ScoringFunctionAdaptor(*args)
5516 self.this.append(this)
5519 __swig_destroy__ = _IMP_kernel.delete__ScoringFunctionAdaptor
5520 __del__ =
lambda self:
None
5521 _ScoringFunctionAdaptor_swigregister = _IMP_kernel._ScoringFunctionAdaptor_swigregister
5522 _ScoringFunctionAdaptor_swigregister(_ScoringFunctionAdaptor)
5527 show_restraint_hierarchy(_ScoringFunctionAdaptor rs, _ostream out)
5528 show_restraint_hierarchy(_ScoringFunctionAdaptor rs)
5530 return _IMP_kernel.show_restraint_hierarchy(*args)
5531 class Undecorator(Object):
5532 """Proxy of C++ IMP::Undecorator class"""
5533 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
5535 def __init__(self, m, name):
5536 """__init__(IMP::Undecorator self, Model m, std::string name) -> Undecorator"""
5537 if self.__class__ == Undecorator:
5541 this = _IMP_kernel.new_Undecorator(_self, m, name)
5543 self.this.append(this)
5547 if self.__class__ != Undecorator:
5548 _director_objects.register(self)
5553 def teardown(self, pi):
5554 """teardown(Undecorator self, ParticleIndex pi)"""
5555 return _IMP_kernel.Undecorator_teardown(self, pi)
5559 """__str__(Undecorator self) -> std::string"""
5560 return _IMP_kernel.Undecorator___str__(self)
5564 """__repr__(Undecorator self) -> std::string"""
5565 return _IMP_kernel.Undecorator___repr__(self)
5570 return _object_cast_to_Undecorator(o)
5573 def get_type_name(self):
5574 return self.__class__.__name__
5575 def do_show(self, out):
5577 def get_version_info(self):
5579 return VersionInfo(self.__module__,
5586 return _object_cast_to_Undecorator(o)
5588 __swig_destroy__ = _IMP_kernel.delete_Undecorator
5589 __del__ =
lambda self:
None
5590 def __disown__(self):
5592 _IMP_kernel.disown_Undecorator(self)
5593 return weakref_proxy(self)
5595 def do_destroy(self):
5596 """do_destroy(Undecorator self)"""
5597 return _IMP_kernel.Undecorator_do_destroy(self)
5599 Undecorator_swigregister = _IMP_kernel.Undecorator_swigregister
5600 Undecorator_swigregister(Undecorator)
5602 class Model(Object):
5603 """Proxy of C++ IMP::Model class"""
5604 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
5606 def __init__(self, *args):
5608 __init__(IMP::Model self, std::string name) -> Model
5609 __init__(IMP::Model self) -> Model
5611 this = _IMP_kernel.new_Model(*args)
5613 self.this.append(this)
5617 def clear_particle_caches(self, pi):
5618 """clear_particle_caches(Model self, ParticleIndex pi)"""
5619 return _IMP_kernel.Model_clear_particle_caches(self, pi)
5623 """add_particle(Model self, std::string name) -> ParticleIndex"""
5624 return _IMP_kernel.Model_add_particle(self, name)
5627 def get_particle_name(self, pi):
5628 """get_particle_name(Model self, ParticleIndex pi) -> std::string"""
5629 return _IMP_kernel.Model_get_particle_name(self, pi)
5632 def add_undecorator(self, pi, d):
5633 """add_undecorator(Model self, ParticleIndex pi, Undecorator d)"""
5634 return _IMP_kernel.Model_add_undecorator(self, pi, d)
5637 def remove_score_state(self, d):
5638 """remove_score_state(Model self, ScoreState d)"""
5639 return _IMP_kernel.Model_remove_score_state(self, d)
5642 def remove_score_states(self, d):
5643 """remove_score_states(Model self, IMP::ScoreStates const & d)"""
5644 return _IMP_kernel.Model_remove_score_states(self, d)
5647 def set_score_states(self, ps):
5648 """set_score_states(Model self, IMP::ScoreStates const & ps)"""
5649 return _IMP_kernel.Model_set_score_states(self, ps)
5652 def set_score_states_order(self, objs):
5653 """set_score_states_order(Model self, IMP::ScoreStates const & objs)"""
5654 return _IMP_kernel.Model_set_score_states_order(self, objs)
5657 def add_score_state(self, obj):
5658 """add_score_state(Model self, ScoreState obj) -> unsigned int"""
5659 return _IMP_kernel.Model_add_score_state(self, obj)
5662 def add_score_states(self, objs):
5663 """add_score_states(Model self, IMP::ScoreStates const & objs)"""
5664 return _IMP_kernel.Model_add_score_states(self, objs)
5667 def clear_score_states(self):
5668 """clear_score_states(Model self)"""
5669 return _IMP_kernel.Model_clear_score_states(self)
5672 def get_number_of_score_states(self):
5673 """get_number_of_score_states(Model self) -> unsigned int"""
5674 return _IMP_kernel.Model_get_number_of_score_states(self)
5677 def get_has_score_states(self):
5678 """get_has_score_states(Model self) -> bool"""
5679 return _IMP_kernel.Model_get_has_score_states(self)
5682 def get_score_state(self, i):
5683 """get_score_state(Model self, unsigned int i) -> ScoreState"""
5684 return _IMP_kernel.Model_get_score_state(self, i)
5687 def get_score_states(self):
5688 """get_score_states(Model self) -> IMP::ScoreStates"""
5689 return _IMP_kernel.Model_get_score_states(self)
5692 def reserve_score_states(self, sz):
5693 """reserve_score_states(Model self, unsigned int sz)"""
5694 return _IMP_kernel.Model_reserve_score_states(self, sz)
5698 """update(Model self)"""
5699 return _IMP_kernel.Model_update(self)
5702 def add_attribute(self, *args):
5704 add_attribute(Model self, FloatKey attribute_key, ParticleIndex particle, IMP::Float value)
5705 add_attribute(Model self, IntKey attribute_key, ParticleIndex particle, IMP::Int value)
5706 add_attribute(Model self, FloatsKey attribute_key, ParticleIndex particle, IMP::Floats value)
5707 add_attribute(Model self, IntsKey attribute_key, ParticleIndex particle, IMP::Ints value)
5708 add_attribute(Model self, StringKey attribute_key, ParticleIndex particle, IMP::String value)
5709 add_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle, IMP::ParticleIndexes value)
5710 add_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle, ParticleIndex value)
5711 add_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle, Object value)
5712 add_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle, Object value)
5714 return _IMP_kernel.Model_add_attribute(self, *args)
5717 def remove_attribute(self, *args):
5719 remove_attribute(Model self, FloatKey attribute_key, ParticleIndex particle)
5720 remove_attribute(Model self, IntKey attribute_key, ParticleIndex particle)
5721 remove_attribute(Model self, FloatsKey attribute_key, ParticleIndex particle)
5722 remove_attribute(Model self, IntsKey attribute_key, ParticleIndex particle)
5723 remove_attribute(Model self, StringKey attribute_key, ParticleIndex particle)
5724 remove_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle)
5725 remove_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle)
5726 remove_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle)
5727 remove_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle)
5729 return _IMP_kernel.Model_remove_attribute(self, *args)
5732 def get_has_attribute(self, *args):
5734 get_has_attribute(Model self, FloatKey attribute_key, ParticleIndex particle) -> bool
5735 get_has_attribute(Model self, IntKey attribute_key, ParticleIndex particle) -> bool
5736 get_has_attribute(Model self, FloatsKey attribute_key, ParticleIndex particle) -> bool
5737 get_has_attribute(Model self, IntsKey attribute_key, ParticleIndex particle) -> bool
5738 get_has_attribute(Model self, StringKey attribute_key, ParticleIndex particle) -> bool
5739 get_has_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle) -> bool
5740 get_has_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle) -> bool
5741 get_has_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle) -> bool
5742 get_has_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle) -> bool
5744 return _IMP_kernel.Model_get_has_attribute(self, *args)
5747 def set_attribute(self, *args):
5749 set_attribute(Model self, FloatKey attribute_key, ParticleIndex particle, IMP::Float value)
5750 set_attribute(Model self, IntKey attribute_key, ParticleIndex particle, IMP::Int value)
5751 set_attribute(Model self, FloatsKey attribute_key, ParticleIndex particle, IMP::Floats value)
5752 set_attribute(Model self, IntsKey attribute_key, ParticleIndex particle, IMP::Ints value)
5753 set_attribute(Model self, StringKey attribute_key, ParticleIndex particle, IMP::String value)
5754 set_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle, IMP::ParticleIndexes value)
5755 set_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle, ParticleIndex value)
5756 set_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle, Object value)
5757 set_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle, Object value)
5759 return _IMP_kernel.Model_set_attribute(self, *args)
5762 def get_attribute(self, *args):
5764 get_attribute(Model self, FloatKey attribute_key, ParticleIndex particle) -> IMP::Float
5765 get_attribute(Model self, IntKey attribute_key, ParticleIndex particle) -> IMP::Int
5766 get_attribute(Model self, FloatsKey attribute_key, ParticleIndex particle) -> IMP::Floats
5767 get_attribute(Model self, IntsKey attribute_key, ParticleIndex particle) -> IMP::Ints
5768 get_attribute(Model self, StringKey attribute_key, ParticleIndex particle) -> IMP::String
5769 get_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle) -> IMP::ParticleIndexes
5770 get_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle) -> ParticleIndex
5771 get_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle) -> Object
5772 get_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle) -> Object
5774 return _IMP_kernel.Model_get_attribute(self, *args)
5777 def add_cache_attribute(self, *args):
5779 add_cache_attribute(Model self, FloatKey attribute_key, ParticleIndex particle, IMP::Float value)
5780 add_cache_attribute(Model self, IntKey attribute_key, ParticleIndex particle, IMP::Int value)
5781 add_cache_attribute(Model self, FloatsKey attribute_key, ParticleIndex particle, IMP::Floats value)
5782 add_cache_attribute(Model self, IntsKey attribute_key, ParticleIndex particle, IMP::Ints value)
5783 add_cache_attribute(Model self, StringKey attribute_key, ParticleIndex particle, IMP::String value)
5784 add_cache_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle, IMP::ParticleIndexes value)
5785 add_cache_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle, ParticleIndex value)
5786 add_cache_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle, Object value)
5787 add_cache_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle, Object value)
5789 return _IMP_kernel.Model_add_cache_attribute(self, *args)
5792 def set_is_optimized(self, arg2, arg3, arg4):
5793 """set_is_optimized(Model self, FloatKey arg2, ParticleIndex arg3, bool arg4)"""
5794 return _IMP_kernel.Model_set_is_optimized(self, arg2, arg3, arg4)
5797 def add_to_derivative(self, k, particle, v, da):
5798 """add_to_derivative(Model self, FloatKey k, ParticleIndex particle, double v, DerivativeAccumulator da)"""
5799 return _IMP_kernel.Model_add_to_derivative(self, k, particle, v, da)
5802 def get_particle(self, p):
5803 """get_particle(Model self, ParticleIndex p) -> Particle"""
5804 return _IMP_kernel.Model_get_particle(self, p)
5807 def get_has_particle(self, p):
5808 """get_has_particle(Model self, ParticleIndex p) -> bool"""
5809 return _IMP_kernel.Model_get_has_particle(self, p)
5813 """get_particle_indexes(Model self) -> IMP::ParticleIndexes"""
5814 return _IMP_kernel.Model_get_particle_indexes(self)
5817 def get_model_objects(self):
5818 """get_model_objects(Model self) -> IMP::ModelObjectsTemp"""
5819 return _IMP_kernel.Model_get_model_objects(self)
5822 def remove_particle(self, pi):
5823 """remove_particle(Model self, ParticleIndex pi)"""
5824 return _IMP_kernel.Model_remove_particle(self, pi)
5827 def add_data(self, mk, o):
5828 """add_data(Model self, ModelKey mk, Object o)"""
5829 return _IMP_kernel.Model_add_data(self, mk, o)
5832 def get_data(self, mk):
5833 """get_data(Model self, ModelKey mk) -> Object"""
5834 return _IMP_kernel.Model_get_data(self, mk)
5837 def remove_data(self, mk):
5838 """remove_data(Model self, ModelKey mk)"""
5839 return _IMP_kernel.Model_remove_data(self, mk)
5842 def get_has_data(self, mk):
5843 """get_has_data(Model self, ModelKey mk) -> bool"""
5844 return _IMP_kernel.Model_get_has_data(self, mk)
5847 def get_version_info(self):
5848 """get_version_info(Model self) -> VersionInfo"""
5849 return _IMP_kernel.Model_get_version_info(self)
5852 def do_destroy(self):
5853 """do_destroy(Model self)"""
5854 return _IMP_kernel.Model_do_destroy(self)
5858 """__str__(Model self) -> std::string"""
5859 return _IMP_kernel.Model___str__(self)
5863 """__repr__(Model self) -> std::string"""
5864 return _IMP_kernel.Model___repr__(self)
5869 return _object_cast_to_Model(o)
5872 def _get_ints_numpy(self, k):
5873 return _get_ints_numpy(self, k, self)
5875 def _get_floats_numpy(self, k):
5876 return _get_floats_numpy(self, k, self)
5878 def _get_derivatives_numpy(self, k):
5879 return _get_derivatives_numpy(self, k, self)
5881 def _get_spheres_numpy(self):
5882 return _get_spheres_numpy(self, self)
5884 def _get_sphere_derivatives_numpy(self):
5885 return _get_sphere_derivatives_numpy(self, self)
5887 Model_swigregister = _IMP_kernel.Model_swigregister
5888 Model_swigregister(Model)
5890 class Decorator(_Value):
5891 """Proxy of C++ IMP::Decorator class"""
5892 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
5893 __repr__ = _swig_repr
5895 def __init__(self, p):
5896 """__init__(IMP::Decorator self, _ParticleAdaptor p) -> Decorator"""
5897 this = _IMP_kernel.new_Decorator(p)
5899 self.this.append(this)
5903 def __ne__(self, o):
5904 """__ne__(Decorator self, Object o) -> bool"""
5905 return _IMP_kernel.Decorator___ne__(self, o)
5908 def __lt__(self, o):
5909 """__lt__(Decorator self, Object o) -> bool"""
5910 return _IMP_kernel.Decorator___lt__(self, o)
5913 def __gt__(self, o):
5914 """__gt__(Decorator self, Object o) -> bool"""
5915 return _IMP_kernel.Decorator___gt__(self, o)
5918 def __ge__(self, o):
5919 """__ge__(Decorator self, Object o) -> bool"""
5920 return _IMP_kernel.Decorator___ge__(self, o)
5923 def __le__(self, o):
5924 """__le__(Decorator self, Object o) -> bool"""
5925 return _IMP_kernel.Decorator___le__(self, o)
5928 def get_particle(self):
5929 """get_particle(Decorator self) -> Particle"""
5930 return _IMP_kernel.Decorator_get_particle(self)
5933 def get_particle_index(self):
5934 """get_particle_index(Decorator self) -> ParticleIndex"""
5935 return _IMP_kernel.Decorator_get_particle_index(self)
5938 def get_model(self):
5939 """get_model(Decorator self) -> Model"""
5940 return _IMP_kernel.Decorator_get_model(self)
5943 def get_is_valid(self):
5944 """get_is_valid(Decorator self) -> bool"""
5945 return _IMP_kernel.Decorator_get_is_valid(self)
5949 """__hash__(Decorator self) -> std::size_t"""
5950 return _IMP_kernel.Decorator___hash__(self)
5953 def __eq__(self, *args):
5955 __eq__(Decorator self, Object o) -> bool
5956 __eq__(Decorator self, Decorator o) -> bool
5957 __eq__(Decorator self, Particle o) -> bool
5959 return _IMP_kernel.Decorator___eq__(self, *args)
5963 """__bool__(Decorator self) -> bool"""
5964 return _IMP_kernel.Decorator___bool__(self)
5967 __nonzero__ = __bool__
5969 __swig_destroy__ = _IMP_kernel.delete_Decorator
5970 __del__ =
lambda self:
None
5971 Decorator_swigregister = _IMP_kernel.Decorator_swigregister
5972 Decorator_swigregister(Decorator)
5975 def check_particle(m, pi):
5976 """check_particle(Model m, ParticleIndex pi)"""
5977 return _IMP_kernel.check_particle(m, pi)
5978 class UnaryFunction(Object):
5979 """Proxy of C++ IMP::UnaryFunction class"""
5980 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
5982 def __init__(self, *args):
5984 __init__(IMP::UnaryFunction self, std::string name) -> UnaryFunction
5985 __init__(IMP::UnaryFunction self) -> UnaryFunction
5987 if self.__class__ == UnaryFunction:
5991 this = _IMP_kernel.new_UnaryFunction(_self, *args)
5993 self.this.append(this)
5997 if self.__class__ != UnaryFunction:
5998 _director_objects.register(self)
6003 def evaluate(self, feature):
6004 """evaluate(UnaryFunction self, double feature) -> double"""
6005 return _IMP_kernel.UnaryFunction_evaluate(self, feature)
6008 def evaluate_with_derivative(self, feature):
6009 """evaluate_with_derivative(UnaryFunction self, double feature) -> IMP::DerivativePair"""
6010 return _IMP_kernel.UnaryFunction_evaluate_with_derivative(self, feature)
6012 __swig_destroy__ = _IMP_kernel.delete_UnaryFunction
6013 __del__ =
lambda self:
None
6016 """__str__(UnaryFunction self) -> std::string"""
6017 return _IMP_kernel.UnaryFunction___str__(self)
6021 """__repr__(UnaryFunction self) -> std::string"""
6022 return _IMP_kernel.UnaryFunction___repr__(self)
6027 return _object_cast_to_UnaryFunction(o)
6030 def get_type_name(self):
6031 return self.__class__.__name__
6032 def do_show(self, out):
6034 def get_version_info(self):
6036 return VersionInfo(self.__module__,
6043 return _object_cast_to_UnaryFunction(o)
6045 def __disown__(self):
6047 _IMP_kernel.disown_UnaryFunction(self)
6048 return weakref_proxy(self)
6050 def do_destroy(self):
6051 """do_destroy(UnaryFunction self)"""
6052 return _IMP_kernel.UnaryFunction_do_destroy(self)
6054 UnaryFunction_swigregister = _IMP_kernel.UnaryFunction_swigregister
6055 UnaryFunction_swigregister(UnaryFunction)
6057 class OptimizerState(ModelObject):
6058 """Proxy of C++ IMP::OptimizerState class"""
6059 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6061 def __init__(self, m, name):
6062 """__init__(IMP::OptimizerState self, Model m, std::string name) -> OptimizerState"""
6063 if self.__class__ == OptimizerState:
6067 this = _IMP_kernel.new_OptimizerState(_self, m, name)
6069 self.this.append(this)
6073 if self.__class__ != OptimizerState:
6074 _director_objects.register(self)
6080 """update(OptimizerState self)"""
6081 return _IMP_kernel.OptimizerState_update(self)
6084 def set_is_optimizing(self, arg0):
6085 """set_is_optimizing(OptimizerState self, bool arg0)"""
6086 return _IMP_kernel.OptimizerState_set_is_optimizing(self, arg0)
6089 def get_optimizer(self):
6090 """get_optimizer(OptimizerState self) -> Optimizer"""
6091 return _IMP_kernel.OptimizerState_get_optimizer(self)
6094 def set_period(self, p):
6095 """set_period(OptimizerState self, unsigned int p)"""
6096 return _IMP_kernel.OptimizerState_set_period(self, p)
6099 def get_period(self):
6100 """get_period(OptimizerState self) -> unsigned int"""
6101 return _IMP_kernel.OptimizerState_get_period(self)
6105 """reset(OptimizerState self)"""
6106 return _IMP_kernel.OptimizerState_reset(self)
6109 def update_always(self):
6110 """update_always(OptimizerState self)"""
6111 return _IMP_kernel.OptimizerState_update_always(self)
6114 def get_number_of_updates(self):
6115 """get_number_of_updates(OptimizerState self) -> unsigned int"""
6116 return _IMP_kernel.OptimizerState_get_number_of_updates(self)
6119 def set_number_of_updates(self, n):
6120 """set_number_of_updates(OptimizerState self, unsigned int n)"""
6121 return _IMP_kernel.OptimizerState_set_number_of_updates(self, n)
6123 __swig_destroy__ = _IMP_kernel.delete_OptimizerState
6124 __del__ =
lambda self:
None
6126 def do_update(self, arg0):
6127 """do_update(OptimizerState self, unsigned int arg0)"""
6128 return _IMP_kernel.OptimizerState_do_update(self, arg0)
6131 def do_set_is_optimizing(self, arg0):
6132 """do_set_is_optimizing(OptimizerState self, bool arg0)"""
6133 return _IMP_kernel.OptimizerState_do_set_is_optimizing(self, arg0)
6136 def do_get_inputs(self):
6137 """do_get_inputs(OptimizerState self) -> IMP::ModelObjectsTemp"""
6138 return _IMP_kernel.OptimizerState_do_get_inputs(self)
6141 def do_get_outputs(self):
6142 """do_get_outputs(OptimizerState self) -> IMP::ModelObjectsTemp"""
6143 return _IMP_kernel.OptimizerState_do_get_outputs(self)
6147 """__str__(OptimizerState self) -> std::string"""
6148 return _IMP_kernel.OptimizerState___str__(self)
6152 """__repr__(OptimizerState self) -> std::string"""
6153 return _IMP_kernel.OptimizerState___repr__(self)
6158 return _object_cast_to_OptimizerState(o)
6161 def get_type_name(self):
6162 return self.__class__.__name__
6163 def do_show(self, out):
6165 def get_version_info(self):
6167 return VersionInfo(self.__module__,
6174 return _object_cast_to_OptimizerState(o)
6176 def __disown__(self):
6178 _IMP_kernel.disown_OptimizerState(self)
6179 return weakref_proxy(self)
6181 def do_destroy(self):
6182 """do_destroy(OptimizerState self)"""
6183 return _IMP_kernel.OptimizerState_do_destroy(self)
6186 def handle_set_has_required_score_states(self, arg0):
6187 """handle_set_has_required_score_states(OptimizerState self, bool arg0)"""
6188 return _IMP_kernel.OptimizerState_handle_set_has_required_score_states(self, arg0)
6191 def do_get_interactions(self):
6192 """do_get_interactions(OptimizerState self) -> IMP::ModelObjectsTemps"""
6193 return _IMP_kernel.OptimizerState_do_get_interactions(self)
6195 OptimizerState_swigregister = _IMP_kernel.OptimizerState_swigregister
6196 OptimizerState_swigregister(OptimizerState)
6198 class Refiner(_ParticleInputs, Object):
6199 """Proxy of C++ IMP::Refiner class"""
6200 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6202 def __init__(self, *args):
6204 __init__(IMP::Refiner self, std::string name, bool is_by_ref=False) -> Refiner
6205 __init__(IMP::Refiner self, std::string name) -> Refiner
6206 __init__(IMP::Refiner self) -> Refiner
6208 if self.__class__ == Refiner:
6212 this = _IMP_kernel.new_Refiner(_self, *args)
6214 self.this.append(this)
6218 if self.__class__ != Refiner:
6219 _director_objects.register(self)
6224 def get_can_refine(self, arg0):
6225 """get_can_refine(Refiner self, Particle arg0) -> bool"""
6226 return _IMP_kernel.Refiner_get_can_refine(self, arg0)
6229 def get_refined_indexes(self, m, pi):
6230 """get_refined_indexes(Refiner self, Model m, ParticleIndex pi) -> IMP::ParticleIndexes"""
6231 return _IMP_kernel.Refiner_get_refined_indexes(self, m, pi)
6234 def get_refined_indexes_by_ref(self, m, pi):
6235 """get_refined_indexes_by_ref(Refiner self, Model m, ParticleIndex pi) -> IMP::ParticleIndexes const &"""
6236 return _IMP_kernel.Refiner_get_refined_indexes_by_ref(self, m, pi)
6239 def get_is_by_ref_supported(self):
6240 """get_is_by_ref_supported(Refiner self) -> bool"""
6241 return _IMP_kernel.Refiner_get_is_by_ref_supported(self)
6244 def get_refined(self, *args):
6246 get_refined(Refiner self, Particle a) -> IMP::ParticlesTemp const
6247 get_refined(Refiner self, Particle a, unsigned int i) -> Particle
6249 return _IMP_kernel.Refiner_get_refined(self, *args)
6252 def get_number_of_refined(self, a):
6253 """get_number_of_refined(Refiner self, Particle a) -> unsigned int"""
6254 return _IMP_kernel.Refiner_get_number_of_refined(self, a)
6258 """__str__(Refiner self) -> std::string"""
6259 return _IMP_kernel.Refiner___str__(self)
6263 """__repr__(Refiner self) -> std::string"""
6264 return _IMP_kernel.Refiner___repr__(self)
6269 return _object_cast_to_Refiner(o)
6272 def get_type_name(self):
6273 return self.__class__.__name__
6274 def do_show(self, out):
6276 def get_version_info(self):
6278 return VersionInfo(self.__module__,
6285 return _object_cast_to_Refiner(o)
6287 __swig_destroy__ = _IMP_kernel.delete_Refiner
6288 __del__ =
lambda self:
None
6289 def __disown__(self):
6291 _IMP_kernel.disown_Refiner(self)
6292 return weakref_proxy(self)
6294 def do_get_inputs(self, m, pis):
6295 """do_get_inputs(Refiner self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6296 return _IMP_kernel.Refiner_do_get_inputs(self, m, pis)
6299 def do_destroy(self):
6300 """do_destroy(Refiner self)"""
6301 return _IMP_kernel.Refiner_do_destroy(self)
6303 Refiner_swigregister = _IMP_kernel.Refiner_swigregister
6304 Refiner_swigregister(Refiner)
6306 class Optimizer(ModelObject):
6307 """Proxy of C++ IMP::Optimizer class"""
6308 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6310 def set_is_optimizing_states(self, tf):
6311 """set_is_optimizing_states(Optimizer self, bool tf)"""
6312 return _IMP_kernel.Optimizer_set_is_optimizing_states(self, tf)
6315 def get_optimizer_state_inputs(self):
6316 """get_optimizer_state_inputs(Optimizer self) -> IMP::ModelObjectsTemp"""
6317 return _IMP_kernel.Optimizer_get_optimizer_state_inputs(self)
6320 def do_get_inputs(self):
6321 """do_get_inputs(Optimizer self) -> IMP::ModelObjectsTemp"""
6322 return _IMP_kernel.Optimizer_do_get_inputs(self)
6325 def do_get_outputs(self):
6326 """do_get_outputs(Optimizer self) -> IMP::ModelObjectsTemp"""
6327 return _IMP_kernel.Optimizer_do_get_outputs(self)
6330 def __init__(self, *args):
6332 __init__(IMP::Optimizer self, Model m, std::string name) -> Optimizer
6333 __init__(IMP::Optimizer self, Model m) -> Optimizer
6335 if self.__class__ == Optimizer:
6339 this = _IMP_kernel.new_Optimizer(_self, *args)
6341 self.this.append(this)
6345 if self.__class__ != Optimizer:
6346 _director_objects.register(self)
6351 def optimize(self, max_steps):
6352 """optimize(Optimizer self, unsigned int max_steps) -> double"""
6353 return _IMP_kernel.Optimizer_optimize(self, max_steps)
6356 def set_stop_on_good_score(self, tf):
6357 """set_stop_on_good_score(Optimizer self, bool tf)"""
6358 return _IMP_kernel.Optimizer_set_stop_on_good_score(self, tf)
6361 def get_stop_on_good_score(self):
6362 """get_stop_on_good_score(Optimizer self) -> bool"""
6363 return _IMP_kernel.Optimizer_get_stop_on_good_score(self)
6366 def get_last_score(self):
6367 """get_last_score(Optimizer self) -> double"""
6368 return _IMP_kernel.Optimizer_get_last_score(self)
6371 def get_scoring_function(self):
6372 """get_scoring_function(Optimizer self) -> ScoringFunction"""
6373 return _IMP_kernel.Optimizer_get_scoring_function(self)
6376 def remove_optimizer_state(self, d):
6377 """remove_optimizer_state(Optimizer self, OptimizerState d)"""
6378 return _IMP_kernel.Optimizer_remove_optimizer_state(self, d)
6381 def remove_optimizer_states(self, d):
6382 """remove_optimizer_states(Optimizer self, IMP::OptimizerStates const & d)"""
6383 return _IMP_kernel.Optimizer_remove_optimizer_states(self, d)
6386 def set_optimizer_states(self, ps):
6387 """set_optimizer_states(Optimizer self, IMP::OptimizerStates const & ps)"""
6388 return _IMP_kernel.Optimizer_set_optimizer_states(self, ps)
6391 def set_optimizer_states_order(self, objs):
6392 """set_optimizer_states_order(Optimizer self, IMP::OptimizerStates const & objs)"""
6393 return _IMP_kernel.Optimizer_set_optimizer_states_order(self, objs)
6396 def add_optimizer_state(self, obj):
6397 """add_optimizer_state(Optimizer self, OptimizerState obj) -> unsigned int"""
6398 return _IMP_kernel.Optimizer_add_optimizer_state(self, obj)
6401 def add_optimizer_states(self, objs):
6402 """add_optimizer_states(Optimizer self, IMP::OptimizerStates const & objs)"""
6403 return _IMP_kernel.Optimizer_add_optimizer_states(self, objs)
6406 def clear_optimizer_states(self):
6407 """clear_optimizer_states(Optimizer self)"""
6408 return _IMP_kernel.Optimizer_clear_optimizer_states(self)
6411 def get_number_of_optimizer_states(self):
6412 """get_number_of_optimizer_states(Optimizer self) -> unsigned int"""
6413 return _IMP_kernel.Optimizer_get_number_of_optimizer_states(self)
6416 def get_has_optimizer_states(self):
6417 """get_has_optimizer_states(Optimizer self) -> bool"""
6418 return _IMP_kernel.Optimizer_get_has_optimizer_states(self)
6421 def get_optimizer_state(self, i):
6422 """get_optimizer_state(Optimizer self, unsigned int i) -> OptimizerState"""
6423 return _IMP_kernel.Optimizer_get_optimizer_state(self, i)
6426 def get_optimizer_states(self):
6427 """get_optimizer_states(Optimizer self) -> IMP::OptimizerStates"""
6428 return _IMP_kernel.Optimizer_get_optimizer_states(self)
6431 def reserve_optimizer_states(self, sz):
6432 """reserve_optimizer_states(Optimizer self, unsigned int sz)"""
6433 return _IMP_kernel.Optimizer_reserve_optimizer_states(self, sz)
6436 def set_scoring_function(self, sf):
6437 """set_scoring_function(Optimizer self, _ScoringFunctionAdaptor sf)"""
6438 return _IMP_kernel.Optimizer_set_scoring_function(self, sf)
6440 __swig_destroy__ = _IMP_kernel.delete_Optimizer
6442 """__del__(IMP::Optimizer self)"""
6444 _director_objects.cleanup()
6450 def do_optimize(self, ns):
6451 """do_optimize(Optimizer self, unsigned int ns) -> double"""
6452 return _IMP_kernel.Optimizer_do_optimize(self, ns)
6455 def update_states(self):
6456 """update_states(Optimizer self)"""
6457 return _IMP_kernel.Optimizer_update_states(self)
6461 """__str__(Optimizer self) -> std::string"""
6462 return _IMP_kernel.Optimizer___str__(self)
6466 """__repr__(Optimizer self) -> std::string"""
6467 return _IMP_kernel.Optimizer___repr__(self)
6472 return _object_cast_to_Optimizer(o)
6475 def get_type_name(self):
6476 return self.__class__.__name__
6477 def do_show(self, out):
6479 def get_version_info(self):
6481 return VersionInfo(self.__module__,
6488 return _object_cast_to_Optimizer(o)
6490 def __disown__(self):
6492 _IMP_kernel.disown_Optimizer(self)
6493 return weakref_proxy(self)
6495 def do_destroy(self):
6496 """do_destroy(Optimizer self)"""
6497 return _IMP_kernel.Optimizer_do_destroy(self)
6500 def handle_set_has_required_score_states(self, arg0):
6501 """handle_set_has_required_score_states(Optimizer self, bool arg0)"""
6502 return _IMP_kernel.Optimizer_handle_set_has_required_score_states(self, arg0)
6505 def do_get_interactions(self):
6506 """do_get_interactions(Optimizer self) -> IMP::ModelObjectsTemps"""
6507 return _IMP_kernel.Optimizer_do_get_interactions(self)
6509 Optimizer_swigregister = _IMP_kernel.Optimizer_swigregister
6510 Optimizer_swigregister(Optimizer)
6512 class AttributeOptimizer(Optimizer):
6513 """Proxy of C++ IMP::AttributeOptimizer class"""
6514 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6516 def __init__(self, *args):
6518 __init__(IMP::AttributeOptimizer self, Model m, std::string name) -> AttributeOptimizer
6519 __init__(IMP::AttributeOptimizer self, Model m) -> AttributeOptimizer
6521 if self.__class__ == AttributeOptimizer:
6525 this = _IMP_kernel.new_AttributeOptimizer(_self, *args)
6527 self.this.append(this)
6531 if self.__class__ != AttributeOptimizer:
6532 _director_objects.register(self)
6537 def get_optimized_attributes(self):
6538 """get_optimized_attributes(AttributeOptimizer self) -> IMP::FloatIndexes"""
6539 return _IMP_kernel.AttributeOptimizer_get_optimized_attributes(self)
6542 def set_value(self, fi, v):
6543 """set_value(AttributeOptimizer self, FloatIndex fi, double v)"""
6544 return _IMP_kernel.AttributeOptimizer_set_value(self, fi, v)
6547 def get_value(self, fi):
6548 """get_value(AttributeOptimizer self, FloatIndex fi) -> IMP::Float"""
6549 return _IMP_kernel.AttributeOptimizer_get_value(self, fi)
6552 def get_derivative(self, fi):
6553 """get_derivative(AttributeOptimizer self, FloatIndex fi) -> IMP::Float"""
6554 return _IMP_kernel.AttributeOptimizer_get_derivative(self, fi)
6557 def get_width(self, k):
6558 """get_width(AttributeOptimizer self, FloatKey k) -> double"""
6559 return _IMP_kernel.AttributeOptimizer_get_width(self, k)
6562 def set_scaled_value(self, fi, v):
6563 """set_scaled_value(AttributeOptimizer self, FloatIndex fi, IMP::Float v)"""
6564 return _IMP_kernel.AttributeOptimizer_set_scaled_value(self, fi, v)
6567 def get_scaled_value(self, fi):
6568 """get_scaled_value(AttributeOptimizer self, FloatIndex fi) -> double"""
6569 return _IMP_kernel.AttributeOptimizer_get_scaled_value(self, fi)
6572 def get_scaled_derivative(self, fi):
6573 """get_scaled_derivative(AttributeOptimizer self, FloatIndex fi) -> double"""
6574 return _IMP_kernel.AttributeOptimizer_get_scaled_derivative(self, fi)
6577 def clear_range_cache(self):
6578 """clear_range_cache(AttributeOptimizer self)"""
6579 return _IMP_kernel.AttributeOptimizer_clear_range_cache(self)
6583 """__str__(AttributeOptimizer self) -> std::string"""
6584 return _IMP_kernel.AttributeOptimizer___str__(self)
6588 """__repr__(AttributeOptimizer self) -> std::string"""
6589 return _IMP_kernel.AttributeOptimizer___repr__(self)
6594 return _object_cast_to_AttributeOptimizer(o)
6597 def get_type_name(self):
6598 return self.__class__.__name__
6599 def do_show(self, out):
6601 def get_version_info(self):
6603 return VersionInfo(self.__module__,
6610 return _object_cast_to_AttributeOptimizer(o)
6612 __swig_destroy__ = _IMP_kernel.delete_AttributeOptimizer
6613 __del__ =
lambda self:
None
6614 def __disown__(self):
6616 _IMP_kernel.disown_AttributeOptimizer(self)
6617 return weakref_proxy(self)
6619 def do_destroy(self):
6620 """do_destroy(AttributeOptimizer self)"""
6621 return _IMP_kernel.AttributeOptimizer_do_destroy(self)
6624 def handle_set_has_required_score_states(self, arg0):
6625 """handle_set_has_required_score_states(AttributeOptimizer self, bool arg0)"""
6626 return _IMP_kernel.AttributeOptimizer_handle_set_has_required_score_states(self, arg0)
6629 def do_get_inputs(self):
6630 """do_get_inputs(AttributeOptimizer self) -> IMP::ModelObjectsTemp"""
6631 return _IMP_kernel.AttributeOptimizer_do_get_inputs(self)
6634 def do_get_outputs(self):
6635 """do_get_outputs(AttributeOptimizer self) -> IMP::ModelObjectsTemp"""
6636 return _IMP_kernel.AttributeOptimizer_do_get_outputs(self)
6639 def do_get_interactions(self):
6640 """do_get_interactions(AttributeOptimizer self) -> IMP::ModelObjectsTemps"""
6641 return _IMP_kernel.AttributeOptimizer_do_get_interactions(self)
6644 def do_optimize(self, ns):
6645 """do_optimize(AttributeOptimizer self, unsigned int ns) -> double"""
6646 return _IMP_kernel.AttributeOptimizer_do_optimize(self, ns)
6648 AttributeOptimizer_swigregister = _IMP_kernel.AttributeOptimizer_swigregister
6649 AttributeOptimizer_swigregister(AttributeOptimizer)
6651 class ConfigurationSet(Object):
6652 """Proxy of C++ IMP::ConfigurationSet class"""
6653 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6655 def __init__(self, *args):
6657 __init__(IMP::ConfigurationSet self, Model m, std::string name) -> ConfigurationSet
6658 __init__(IMP::ConfigurationSet self, Model m) -> ConfigurationSet
6660 this = _IMP_kernel.new_ConfigurationSet(*args)
6662 self.this.append(this)
6666 def save_configuration(self):
6667 """save_configuration(ConfigurationSet self)"""
6668 return _IMP_kernel.ConfigurationSet_save_configuration(self)
6671 def get_number_of_configurations(self):
6672 """get_number_of_configurations(ConfigurationSet self) -> unsigned int"""
6673 return _IMP_kernel.ConfigurationSet_get_number_of_configurations(self)
6676 def load_configuration(self, i):
6677 """load_configuration(ConfigurationSet self, int i)"""
6678 return _IMP_kernel.ConfigurationSet_load_configuration(self, i)
6681 def remove_configuration(self, i):
6682 """remove_configuration(ConfigurationSet self, unsigned int i)"""
6683 return _IMP_kernel.ConfigurationSet_remove_configuration(self, i)
6686 def get_model(self):
6687 """get_model(ConfigurationSet self) -> Model"""
6688 return _IMP_kernel.ConfigurationSet_get_model(self)
6691 def get_version_info(self):
6692 """get_version_info(ConfigurationSet self) -> VersionInfo"""
6693 return _IMP_kernel.ConfigurationSet_get_version_info(self)
6697 """__str__(ConfigurationSet self) -> std::string"""
6698 return _IMP_kernel.ConfigurationSet___str__(self)
6702 """__repr__(ConfigurationSet self) -> std::string"""
6703 return _IMP_kernel.ConfigurationSet___repr__(self)
6708 return _object_cast_to_ConfigurationSet(o)
6710 ConfigurationSet_swigregister = _IMP_kernel.ConfigurationSet_swigregister
6711 ConfigurationSet_swigregister(ConfigurationSet)
6713 class SaveToConfigurationSetOptimizerState(OptimizerState):
6714 """Proxy of C++ IMP::SaveToConfigurationSetOptimizerState class"""
6715 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6717 def __init__(self, cs):
6718 """__init__(IMP::SaveToConfigurationSetOptimizerState self, ConfigurationSet cs) -> SaveToConfigurationSetOptimizerState"""
6719 this = _IMP_kernel.new_SaveToConfigurationSetOptimizerState(cs)
6721 self.this.append(this)
6725 def get_version_info(self):
6726 """get_version_info(SaveToConfigurationSetOptimizerState self) -> VersionInfo"""
6727 return _IMP_kernel.SaveToConfigurationSetOptimizerState_get_version_info(self)
6731 """__str__(SaveToConfigurationSetOptimizerState self) -> std::string"""
6732 return _IMP_kernel.SaveToConfigurationSetOptimizerState___str__(self)
6736 """__repr__(SaveToConfigurationSetOptimizerState self) -> std::string"""
6737 return _IMP_kernel.SaveToConfigurationSetOptimizerState___repr__(self)
6742 return _object_cast_to_SaveToConfigurationSetOptimizerState(o)
6744 SaveToConfigurationSetOptimizerState_swigregister = _IMP_kernel.SaveToConfigurationSetOptimizerState_swigregister
6745 SaveToConfigurationSetOptimizerState_swigregister(SaveToConfigurationSetOptimizerState)
6747 class Configuration(Object):
6748 """Proxy of C++ IMP::Configuration class"""
6749 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6751 def __init__(self, *args):
6753 __init__(IMP::Configuration self, Model m, std::string name) -> Configuration
6754 __init__(IMP::Configuration self, Model m) -> Configuration
6755 __init__(IMP::Configuration self, Model m, Configuration base, std::string name) -> Configuration
6756 __init__(IMP::Configuration self, Model m, Configuration base) -> Configuration
6758 this = _IMP_kernel.new_Configuration(*args)
6760 self.this.append(this)
6764 def load_configuration(self):
6765 """load_configuration(Configuration self)"""
6766 return _IMP_kernel.Configuration_load_configuration(self)
6769 def swap_configuration(self):
6770 """swap_configuration(Configuration self)"""
6771 return _IMP_kernel.Configuration_swap_configuration(self)
6774 def get_version_info(self):
6775 """get_version_info(Configuration self) -> VersionInfo"""
6776 return _IMP_kernel.Configuration_get_version_info(self)
6780 """__str__(Configuration self) -> std::string"""
6781 return _IMP_kernel.Configuration___str__(self)
6785 """__repr__(Configuration self) -> std::string"""
6786 return _IMP_kernel.Configuration___repr__(self)
6791 return _object_cast_to_Configuration(o)
6793 Configuration_swigregister = _IMP_kernel.Configuration_swigregister
6794 Configuration_swigregister(Configuration)
6796 class Sampler(Object):
6797 """Proxy of C++ IMP::Sampler class"""
6798 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6800 def __init__(self, *args):
6802 __init__(IMP::Sampler self, Model m, std::string name) -> Sampler
6803 __init__(IMP::Sampler self, Model m) -> Sampler
6805 if self.__class__ == Sampler:
6809 this = _IMP_kernel.new_Sampler(_self, *args)
6811 self.this.append(this)
6815 if self.__class__ != Sampler:
6816 _director_objects.register(self)
6821 def create_sample(self):
6822 """create_sample(Sampler self) -> ConfigurationSet"""
6823 return _IMP_kernel.Sampler_create_sample(self)
6826 def get_scoring_function(self):
6827 """get_scoring_function(Sampler self) -> ScoringFunction"""
6828 return _IMP_kernel.Sampler_get_scoring_function(self)
6831 def set_scoring_function(self, sf):
6832 """set_scoring_function(Sampler self, _ScoringFunctionAdaptor sf)"""
6833 return _IMP_kernel.Sampler_set_scoring_function(self, sf)
6836 def get_model(self):
6837 """get_model(Sampler self) -> Model"""
6838 return _IMP_kernel.Sampler_get_model(self)
6841 def do_sample(self):
6842 """do_sample(Sampler self) -> ConfigurationSet"""
6843 return _IMP_kernel.Sampler_do_sample(self)
6845 __swig_destroy__ = _IMP_kernel.delete_Sampler
6846 __del__ =
lambda self:
None
6849 """__str__(Sampler self) -> std::string"""
6850 return _IMP_kernel.Sampler___str__(self)
6854 """__repr__(Sampler self) -> std::string"""
6855 return _IMP_kernel.Sampler___repr__(self)
6860 return _object_cast_to_Sampler(o)
6863 def get_type_name(self):
6864 return self.__class__.__name__
6865 def do_show(self, out):
6867 def get_version_info(self):
6869 return VersionInfo(self.__module__,
6876 return _object_cast_to_Sampler(o)
6878 def __disown__(self):
6880 _IMP_kernel.disown_Sampler(self)
6881 return weakref_proxy(self)
6883 def do_destroy(self):
6884 """do_destroy(Sampler self)"""
6885 return _IMP_kernel.Sampler_do_destroy(self)
6887 Sampler_swigregister = _IMP_kernel.Sampler_swigregister
6888 Sampler_swigregister(Sampler)
6890 class PairModifier(_ParticleInputs, _ParticleOutputs, Object):
6891 """Proxy of C++ IMP::PairModifier class"""
6892 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6894 def __init__(self, *args):
6896 __init__(IMP::PairModifier self, std::string name) -> PairModifier
6897 __init__(IMP::PairModifier self) -> PairModifier
6899 if self.__class__ == PairModifier:
6903 this = _IMP_kernel.new_PairModifier(_self, *args)
6905 self.this.append(this)
6909 if self.__class__ != PairModifier:
6910 _director_objects.register(self)
6915 def apply_index(self, m, v):
6916 """apply_index(PairModifier self, Model m, IMP::ParticleIndexPair const & v)"""
6917 return _IMP_kernel.PairModifier_apply_index(self, m, v)
6920 def apply_indexes(self, m, o, lower_bound, upper_bound):
6921 """apply_indexes(PairModifier self, Model m, IMP::ParticleIndexPairs const & o, unsigned int lower_bound, unsigned int upper_bound)"""
6922 return _IMP_kernel.PairModifier_apply_indexes(self, m, o, lower_bound, upper_bound)
6926 """__str__(PairModifier self) -> std::string"""
6927 return _IMP_kernel.PairModifier___str__(self)
6931 """__repr__(PairModifier self) -> std::string"""
6932 return _IMP_kernel.PairModifier___repr__(self)
6937 return _object_cast_to_PairModifier(o)
6940 def get_type_name(self):
6941 return self.__class__.__name__
6942 def do_show(self, out):
6944 def get_version_info(self):
6946 return VersionInfo(self.__module__,
6953 return _object_cast_to_PairModifier(o)
6955 __swig_destroy__ = _IMP_kernel.delete_PairModifier
6956 __del__ =
lambda self:
None
6957 def __disown__(self):
6959 _IMP_kernel.disown_PairModifier(self)
6960 return weakref_proxy(self)
6962 def do_get_inputs(self, m, pis):
6963 """do_get_inputs(PairModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6964 return _IMP_kernel.PairModifier_do_get_inputs(self, m, pis)
6967 def do_get_outputs(self, m, pis):
6968 """do_get_outputs(PairModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6969 return _IMP_kernel.PairModifier_do_get_outputs(self, m, pis)
6972 def do_destroy(self):
6973 """do_destroy(PairModifier self)"""
6974 return _IMP_kernel.PairModifier_do_destroy(self)
6976 PairModifier_swigregister = _IMP_kernel.PairModifier_swigregister
6977 PairModifier_swigregister(PairModifier)
6979 class PairScore(_ParticleInputs, Object):
6980 """Proxy of C++ IMP::PairScore class"""
6981 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6983 def __init__(self, *args):
6985 __init__(IMP::PairScore self, std::string name) -> PairScore
6986 __init__(IMP::PairScore self) -> PairScore
6988 if self.__class__ == PairScore:
6992 this = _IMP_kernel.new_PairScore(_self, *args)
6994 self.this.append(this)
6998 if self.__class__ != PairScore:
6999 _director_objects.register(self)
7004 def evaluate_index(self, m, vt, da):
7005 """evaluate_index(PairScore self, Model m, IMP::ParticleIndexPair const & vt, DerivativeAccumulator da) -> double"""
7006 return _IMP_kernel.PairScore_evaluate_index(self, m, vt, da)
7009 def evaluate_indexes(self, m, o, da, lower_bound, upper_bound):
7010 """evaluate_indexes(PairScore self, Model m, IMP::ParticleIndexPairs const & o, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound) -> double"""
7011 return _IMP_kernel.PairScore_evaluate_indexes(self, m, o, da, lower_bound, upper_bound)
7014 def evaluate_if_good_index(self, m, vt, da, max):
7015 """evaluate_if_good_index(PairScore self, Model m, IMP::ParticleIndexPair const & vt, DerivativeAccumulator da, double max) -> double"""
7016 return _IMP_kernel.PairScore_evaluate_if_good_index(self, m, vt, da, max)
7019 def evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound):
7020 """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"""
7021 return _IMP_kernel.PairScore_evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound)
7024 def create_current_decomposition(self, m, vt):
7025 """create_current_decomposition(PairScore self, Model m, IMP::ParticleIndexPair const & vt) -> IMP::Restraints"""
7026 return _IMP_kernel.PairScore_create_current_decomposition(self, m, vt)
7029 def do_create_current_decomposition(self, m, vt):
7030 """do_create_current_decomposition(PairScore self, Model m, IMP::ParticleIndexPair const & vt) -> IMP::Restraints"""
7031 return _IMP_kernel.PairScore_do_create_current_decomposition(self, m, vt)
7033 __swig_destroy__ = _IMP_kernel.delete_PairScore
7034 __del__ =
lambda self:
None
7037 """__str__(PairScore self) -> std::string"""
7038 return _IMP_kernel.PairScore___str__(self)
7042 """__repr__(PairScore self) -> std::string"""
7043 return _IMP_kernel.PairScore___repr__(self)
7048 return _object_cast_to_PairScore(o)
7051 def get_type_name(self):
7052 return self.__class__.__name__
7053 def do_show(self, out):
7055 def get_version_info(self):
7057 return VersionInfo(self.__module__,
7064 return _object_cast_to_PairScore(o)
7066 def __disown__(self):
7068 _IMP_kernel.disown_PairScore(self)
7069 return weakref_proxy(self)
7071 def do_get_inputs(self, m, pis):
7072 """do_get_inputs(PairScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7073 return _IMP_kernel.PairScore_do_get_inputs(self, m, pis)
7076 def do_destroy(self):
7077 """do_destroy(PairScore self)"""
7078 return _IMP_kernel.PairScore_do_destroy(self)
7080 PairScore_swigregister = _IMP_kernel.PairScore_swigregister
7081 PairScore_swigregister(PairScore)
7083 class PairPredicate(_ParticleInputs, Object):
7084 """Proxy of C++ IMP::PairPredicate class"""
7085 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
7087 def __init__(self, *args):
7089 __init__(IMP::PairPredicate self, std::string name) -> PairPredicate
7090 __init__(IMP::PairPredicate self) -> PairPredicate
7092 if self.__class__ == PairPredicate:
7096 this = _IMP_kernel.new_PairPredicate(_self, *args)
7098 self.this.append(this)
7102 if self.__class__ != PairPredicate:
7103 _director_objects.register(self)
7108 def get_value(self, *args):
7110 get_value(PairPredicate self, IMP::ParticlePair const & vt) -> int
7111 get_value(PairPredicate self, IMP::ParticlePairsTemp const & o) -> IMP::Ints
7113 return _IMP_kernel.PairPredicate_get_value(self, *args)
7116 def setup_for_get_value_index_in_batch(self, arg0):
7117 """setup_for_get_value_index_in_batch(PairPredicate self, Model arg0)"""
7118 return _IMP_kernel.PairPredicate_setup_for_get_value_index_in_batch(self, arg0)
7121 def get_value_index_in_batch(self, m, vt):
7122 """get_value_index_in_batch(PairPredicate self, Model m, IMP::ParticleIndexPair const & vt) -> int"""
7123 return _IMP_kernel.PairPredicate_get_value_index_in_batch(self, m, vt)
7126 def __call__(self, m, vt):
7127 """__call__(PairPredicate self, Model m, IMP::ParticleIndexPair const & vt) -> int"""
7128 return _IMP_kernel.PairPredicate___call__(self, m, vt)
7131 def get_value_index(self, *args):
7133 get_value_index(PairPredicate self, Model m, IMP::ParticleIndexPair const & vt) -> int
7134 get_value_index(PairPredicate self, Model m, IMP::ParticleIndexPairs const & o) -> IMP::Ints
7136 return _IMP_kernel.PairPredicate_get_value_index(self, *args)
7138 __swig_destroy__ = _IMP_kernel.delete_PairPredicate
7139 __del__ =
lambda self:
None
7142 """__str__(PairPredicate self) -> std::string"""
7143 return _IMP_kernel.PairPredicate___str__(self)
7147 """__repr__(PairPredicate self) -> std::string"""
7148 return _IMP_kernel.PairPredicate___repr__(self)
7153 return _object_cast_to_PairPredicate(o)
7156 def get_type_name(self):
7157 return self.__class__.__name__
7158 def do_show(self, out):
7160 def get_version_info(self):
7162 return VersionInfo(self.__module__,
7169 return _object_cast_to_PairPredicate(o)
7171 def __disown__(self):
7173 _IMP_kernel.disown_PairPredicate(self)
7174 return weakref_proxy(self)
7176 def do_get_inputs(self, m, pis):
7177 """do_get_inputs(PairPredicate self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7178 return _IMP_kernel.PairPredicate_do_get_inputs(self, m, pis)
7181 def do_destroy(self):
7182 """do_destroy(PairPredicate self)"""
7183 return _IMP_kernel.PairPredicate_do_destroy(self)
7185 PairPredicate_swigregister = _IMP_kernel.PairPredicate_swigregister
7186 PairPredicate_swigregister(PairPredicate)
7188 class PairContainer(Container):
7189 """Proxy of C++ IMP::PairContainer class"""
7190 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
7192 def apply_generic(self, m):
7193 """apply_generic(PairContainer self, PairModifier m)"""
7194 return _IMP_kernel.PairContainer_apply_generic(self, m)
7197 def apply(self, sm):
7198 """apply(PairContainer self, PairModifier sm)"""
7199 return _IMP_kernel.PairContainer_apply(self, sm)
7202 def get_range_indexes(self):
7203 """get_range_indexes(PairContainer self) -> IMP::ParticleIndexPairs"""
7204 return _IMP_kernel.PairContainer_get_range_indexes(self)
7207 def get_contents(self):
7208 """get_contents(PairContainer self) -> IMP::ParticleIndexPairs const &"""
7209 return _IMP_kernel.PairContainer_get_contents(self)
7213 """get_indexes(PairContainer self) -> IMP::ParticleIndexPairs"""
7214 return _IMP_kernel.PairContainer_get_indexes(self)
7217 def get(self, *args):
7219 get(PairContainer self) -> IMP::ParticlePairsTemp
7220 get(PairContainer self, unsigned int i) -> IMP::ParticlePair
7222 return _IMP_kernel.PairContainer_get(self, *args)
7225 def get_number(self):
7226 """get_number(PairContainer self) -> unsigned int"""
7227 return _IMP_kernel.PairContainer_get_number(self)
7230 def get_particle_pairs(self):
7231 """get_particle_pairs(PairContainer self) -> IMP::ParticlePairsTemp"""
7232 return _IMP_kernel.PairContainer_get_particle_pairs(self)
7235 def __init__(self, *args):
7237 __init__(IMP::PairContainer self, Model m, std::string name) -> PairContainer
7238 __init__(IMP::PairContainer self, Model m) -> PairContainer
7240 if self.__class__ == PairContainer:
7244 this = _IMP_kernel.new_PairContainer(_self, *args)
7246 self.this.append(this)
7250 if self.__class__ != PairContainer:
7251 _director_objects.register(self)
7256 def do_apply(self, sm):
7257 """do_apply(PairContainer self, PairModifier sm)"""
7258 return _IMP_kernel.PairContainer_do_apply(self, sm)
7261 def do_get_provides_access(self):
7262 """do_get_provides_access(PairContainer self) -> bool"""
7263 return _IMP_kernel.PairContainer_do_get_provides_access(self)
7265 __swig_destroy__ = _IMP_kernel.delete_PairContainer
7266 __del__ =
lambda self:
None
7269 """__str__(PairContainer self) -> std::string"""
7270 return _IMP_kernel.PairContainer___str__(self)
7274 """__repr__(PairContainer self) -> std::string"""
7275 return _IMP_kernel.PairContainer___repr__(self)
7280 return _object_cast_to_PairContainer(o)
7283 def get_type_name(self):
7284 return self.__class__.__name__
7285 def do_show(self, out):
7287 def get_version_info(self):
7289 return VersionInfo(self.__module__,
7296 return _object_cast_to_PairContainer(o)
7298 def __disown__(self):
7300 _IMP_kernel.disown_PairContainer(self)
7301 return weakref_proxy(self)
7303 def do_destroy(self):
7304 """do_destroy(PairContainer self)"""
7305 return _IMP_kernel.PairContainer_do_destroy(self)
7308 def handle_set_has_required_score_states(self, arg0):
7309 """handle_set_has_required_score_states(PairContainer self, bool arg0)"""
7310 return _IMP_kernel.PairContainer_handle_set_has_required_score_states(self, arg0)
7313 def do_get_inputs(self):
7314 """do_get_inputs(PairContainer self) -> IMP::ModelObjectsTemp"""
7315 return _IMP_kernel.PairContainer_do_get_inputs(self)
7318 def do_get_interactions(self):
7319 """do_get_interactions(PairContainer self) -> IMP::ModelObjectsTemps"""
7320 return _IMP_kernel.PairContainer_do_get_interactions(self)
7323 def do_get_contents_hash(self):
7324 """do_get_contents_hash(PairContainer self) -> std::size_t"""
7325 return _IMP_kernel.PairContainer_do_get_contents_hash(self)
7327 PairContainer_swigregister = _IMP_kernel.PairContainer_swigregister
7328 PairContainer_swigregister(PairContainer)
7330 class _PairContainerAdaptor(_InputAdaptor):
7331 """Proxy of C++ IMP::PairContainerAdaptor class"""
7332 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
7333 __repr__ = _swig_repr
7335 def __init__(self, *args):
7337 __init__(IMP::PairContainerAdaptor self) -> _PairContainerAdaptor
7338 __init__(IMP::PairContainerAdaptor self, PairContainer c) -> _PairContainerAdaptor
7339 __init__(IMP::PairContainerAdaptor self, IMP::ParticlePairsTemp const & t) -> _PairContainerAdaptor
7341 this = _IMP_kernel.new__PairContainerAdaptor(*args)
7343 self.this.append(this)
7347 def set_name_if_default(self, name):
7348 """set_name_if_default(_PairContainerAdaptor self, std::string name)"""
7349 return _IMP_kernel._PairContainerAdaptor_set_name_if_default(self, name)
7351 __swig_destroy__ = _IMP_kernel.delete__PairContainerAdaptor
7352 __del__ =
lambda self:
None
7353 _PairContainerAdaptor_swigregister = _IMP_kernel._PairContainerAdaptor_swigregister
7354 _PairContainerAdaptor_swigregister(_PairContainerAdaptor)
7356 class QuadModifier(_ParticleInputs, _ParticleOutputs, Object):
7357 """Proxy of C++ IMP::QuadModifier class"""
7358 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
7360 def __init__(self, *args):
7362 __init__(IMP::QuadModifier self, std::string name) -> QuadModifier
7363 __init__(IMP::QuadModifier self) -> QuadModifier
7365 if self.__class__ == QuadModifier:
7369 this = _IMP_kernel.new_QuadModifier(_self, *args)
7371 self.this.append(this)
7375 if self.__class__ != QuadModifier:
7376 _director_objects.register(self)
7381 def apply_index(self, m, v):
7382 """apply_index(QuadModifier self, Model m, IMP::ParticleIndexQuad const & v)"""
7383 return _IMP_kernel.QuadModifier_apply_index(self, m, v)
7386 def apply_indexes(self, m, o, lower_bound, upper_bound):
7387 """apply_indexes(QuadModifier self, Model m, IMP::ParticleIndexQuads const & o, unsigned int lower_bound, unsigned int upper_bound)"""
7388 return _IMP_kernel.QuadModifier_apply_indexes(self, m, o, lower_bound, upper_bound)
7392 """__str__(QuadModifier self) -> std::string"""
7393 return _IMP_kernel.QuadModifier___str__(self)
7397 """__repr__(QuadModifier self) -> std::string"""
7398 return _IMP_kernel.QuadModifier___repr__(self)
7403 return _object_cast_to_QuadModifier(o)
7406 def get_type_name(self):
7407 return self.__class__.__name__
7408 def do_show(self, out):
7410 def get_version_info(self):
7412 return VersionInfo(self.__module__,
7419 return _object_cast_to_QuadModifier(o)
7421 __swig_destroy__ = _IMP_kernel.delete_QuadModifier
7422 __del__ =
lambda self:
None
7423 def __disown__(self):
7425 _IMP_kernel.disown_QuadModifier(self)
7426 return weakref_proxy(self)
7428 def do_get_inputs(self, m, pis):
7429 """do_get_inputs(QuadModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7430 return _IMP_kernel.QuadModifier_do_get_inputs(self, m, pis)
7433 def do_get_outputs(self, m, pis):
7434 """do_get_outputs(QuadModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7435 return _IMP_kernel.QuadModifier_do_get_outputs(self, m, pis)
7438 def do_destroy(self):
7439 """do_destroy(QuadModifier self)"""
7440 return _IMP_kernel.QuadModifier_do_destroy(self)
7442 QuadModifier_swigregister = _IMP_kernel.QuadModifier_swigregister
7443 QuadModifier_swigregister(QuadModifier)
7445 class QuadScore(_ParticleInputs, Object):
7446 """Proxy of C++ IMP::QuadScore class"""
7447 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
7449 def __init__(self, *args):
7451 __init__(IMP::QuadScore self, std::string name) -> QuadScore
7452 __init__(IMP::QuadScore self) -> QuadScore
7454 if self.__class__ == QuadScore:
7458 this = _IMP_kernel.new_QuadScore(_self, *args)
7460 self.this.append(this)
7464 if self.__class__ != QuadScore:
7465 _director_objects.register(self)
7470 def evaluate_index(self, m, vt, da):
7471 """evaluate_index(QuadScore self, Model m, IMP::ParticleIndexQuad const & vt, DerivativeAccumulator da) -> double"""
7472 return _IMP_kernel.QuadScore_evaluate_index(self, m, vt, da)
7475 def evaluate_indexes(self, m, o, da, lower_bound, upper_bound):
7476 """evaluate_indexes(QuadScore self, Model m, IMP::ParticleIndexQuads const & o, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound) -> double"""
7477 return _IMP_kernel.QuadScore_evaluate_indexes(self, m, o, da, lower_bound, upper_bound)
7480 def evaluate_if_good_index(self, m, vt, da, max):
7481 """evaluate_if_good_index(QuadScore self, Model m, IMP::ParticleIndexQuad const & vt, DerivativeAccumulator da, double max) -> double"""
7482 return _IMP_kernel.QuadScore_evaluate_if_good_index(self, m, vt, da, max)
7485 def evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound):
7486 """evaluate_if_good_indexes(QuadScore self, Model m, IMP::ParticleIndexQuads const & o, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound) -> double"""
7487 return _IMP_kernel.QuadScore_evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound)
7490 def create_current_decomposition(self, m, vt):
7491 """create_current_decomposition(QuadScore self, Model m, IMP::ParticleIndexQuad const & vt) -> IMP::Restraints"""
7492 return _IMP_kernel.QuadScore_create_current_decomposition(self, m, vt)
7495 def do_create_current_decomposition(self, m, vt):
7496 """do_create_current_decomposition(QuadScore self, Model m, IMP::ParticleIndexQuad const & vt) -> IMP::Restraints"""
7497 return _IMP_kernel.QuadScore_do_create_current_decomposition(self, m, vt)
7499 __swig_destroy__ = _IMP_kernel.delete_QuadScore
7500 __del__ =
lambda self:
None
7503 """__str__(QuadScore self) -> std::string"""
7504 return _IMP_kernel.QuadScore___str__(self)
7508 """__repr__(QuadScore self) -> std::string"""
7509 return _IMP_kernel.QuadScore___repr__(self)
7514 return _object_cast_to_QuadScore(o)
7517 def get_type_name(self):
7518 return self.__class__.__name__
7519 def do_show(self, out):
7521 def get_version_info(self):
7523 return VersionInfo(self.__module__,
7530 return _object_cast_to_QuadScore(o)
7532 def __disown__(self):
7534 _IMP_kernel.disown_QuadScore(self)
7535 return weakref_proxy(self)
7537 def do_get_inputs(self, m, pis):
7538 """do_get_inputs(QuadScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7539 return _IMP_kernel.QuadScore_do_get_inputs(self, m, pis)
7542 def do_destroy(self):
7543 """do_destroy(QuadScore self)"""
7544 return _IMP_kernel.QuadScore_do_destroy(self)
7546 QuadScore_swigregister = _IMP_kernel.QuadScore_swigregister
7547 QuadScore_swigregister(QuadScore)
7549 class QuadPredicate(_ParticleInputs, Object):
7550 """Proxy of C++ IMP::QuadPredicate class"""
7551 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
7553 def __init__(self, *args):
7555 __init__(IMP::QuadPredicate self, std::string name) -> QuadPredicate
7556 __init__(IMP::QuadPredicate self) -> QuadPredicate
7558 if self.__class__ == QuadPredicate:
7562 this = _IMP_kernel.new_QuadPredicate(_self, *args)
7564 self.this.append(this)
7568 if self.__class__ != QuadPredicate:
7569 _director_objects.register(self)
7574 def get_value(self, *args):
7576 get_value(QuadPredicate self, IMP::ParticleQuad const & vt) -> int
7577 get_value(QuadPredicate self, IMP::ParticleQuadsTemp const & o) -> IMP::Ints
7579 return _IMP_kernel.QuadPredicate_get_value(self, *args)
7582 def setup_for_get_value_index_in_batch(self, arg0):
7583 """setup_for_get_value_index_in_batch(QuadPredicate self, Model arg0)"""
7584 return _IMP_kernel.QuadPredicate_setup_for_get_value_index_in_batch(self, arg0)
7587 def get_value_index_in_batch(self, m, vt):
7588 """get_value_index_in_batch(QuadPredicate self, Model m, IMP::ParticleIndexQuad const & vt) -> int"""
7589 return _IMP_kernel.QuadPredicate_get_value_index_in_batch(self, m, vt)
7592 def __call__(self, m, vt):
7593 """__call__(QuadPredicate self, Model m, IMP::ParticleIndexQuad const & vt) -> int"""
7594 return _IMP_kernel.QuadPredicate___call__(self, m, vt)
7597 def get_value_index(self, *args):
7599 get_value_index(QuadPredicate self, Model m, IMP::ParticleIndexQuad const & vt) -> int
7600 get_value_index(QuadPredicate self, Model m, IMP::ParticleIndexQuads const & o) -> IMP::Ints
7602 return _IMP_kernel.QuadPredicate_get_value_index(self, *args)
7604 __swig_destroy__ = _IMP_kernel.delete_QuadPredicate
7605 __del__ =
lambda self:
None
7608 """__str__(QuadPredicate self) -> std::string"""
7609 return _IMP_kernel.QuadPredicate___str__(self)
7613 """__repr__(QuadPredicate self) -> std::string"""
7614 return _IMP_kernel.QuadPredicate___repr__(self)
7619 return _object_cast_to_QuadPredicate(o)
7622 def get_type_name(self):
7623 return self.__class__.__name__
7624 def do_show(self, out):
7626 def get_version_info(self):
7628 return VersionInfo(self.__module__,
7635 return _object_cast_to_QuadPredicate(o)
7637 def __disown__(self):
7639 _IMP_kernel.disown_QuadPredicate(self)
7640 return weakref_proxy(self)
7642 def do_get_inputs(self, m, pis):
7643 """do_get_inputs(QuadPredicate self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7644 return _IMP_kernel.QuadPredicate_do_get_inputs(self, m, pis)
7647 def do_destroy(self):
7648 """do_destroy(QuadPredicate self)"""
7649 return _IMP_kernel.QuadPredicate_do_destroy(self)
7651 QuadPredicate_swigregister = _IMP_kernel.QuadPredicate_swigregister
7652 QuadPredicate_swigregister(QuadPredicate)
7654 class QuadContainer(Container):
7655 """Proxy of C++ IMP::QuadContainer class"""
7656 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
7658 def apply_generic(self, m):
7659 """apply_generic(QuadContainer self, QuadModifier m)"""
7660 return _IMP_kernel.QuadContainer_apply_generic(self, m)
7663 def apply(self, sm):
7664 """apply(QuadContainer self, QuadModifier sm)"""
7665 return _IMP_kernel.QuadContainer_apply(self, sm)
7668 def get_range_indexes(self):
7669 """get_range_indexes(QuadContainer self) -> IMP::ParticleIndexQuads"""
7670 return _IMP_kernel.QuadContainer_get_range_indexes(self)
7673 def get_contents(self):
7674 """get_contents(QuadContainer self) -> IMP::ParticleIndexQuads const &"""
7675 return _IMP_kernel.QuadContainer_get_contents(self)
7679 """get_indexes(QuadContainer self) -> IMP::ParticleIndexQuads"""
7680 return _IMP_kernel.QuadContainer_get_indexes(self)
7683 def get(self, *args):
7685 get(QuadContainer self) -> IMP::ParticleQuadsTemp
7686 get(QuadContainer self, unsigned int i) -> IMP::ParticleQuad
7688 return _IMP_kernel.QuadContainer_get(self, *args)
7691 def get_number(self):
7692 """get_number(QuadContainer self) -> unsigned int"""
7693 return _IMP_kernel.QuadContainer_get_number(self)
7696 def get_particle_quads(self):
7697 """get_particle_quads(QuadContainer self) -> IMP::ParticleQuadsTemp"""
7698 return _IMP_kernel.QuadContainer_get_particle_quads(self)
7701 def __init__(self, *args):
7703 __init__(IMP::QuadContainer self, Model m, std::string name) -> QuadContainer
7704 __init__(IMP::QuadContainer self, Model m) -> QuadContainer
7706 if self.__class__ == QuadContainer:
7710 this = _IMP_kernel.new_QuadContainer(_self, *args)
7712 self.this.append(this)
7716 if self.__class__ != QuadContainer:
7717 _director_objects.register(self)
7722 def do_apply(self, sm):
7723 """do_apply(QuadContainer self, QuadModifier sm)"""
7724 return _IMP_kernel.QuadContainer_do_apply(self, sm)
7727 def do_get_provides_access(self):
7728 """do_get_provides_access(QuadContainer self) -> bool"""
7729 return _IMP_kernel.QuadContainer_do_get_provides_access(self)
7731 __swig_destroy__ = _IMP_kernel.delete_QuadContainer
7732 __del__ =
lambda self:
None
7735 """__str__(QuadContainer self) -> std::string"""
7736 return _IMP_kernel.QuadContainer___str__(self)
7740 """__repr__(QuadContainer self) -> std::string"""
7741 return _IMP_kernel.QuadContainer___repr__(self)
7746 return _object_cast_to_QuadContainer(o)
7749 def get_type_name(self):
7750 return self.__class__.__name__
7751 def do_show(self, out):
7753 def get_version_info(self):
7755 return VersionInfo(self.__module__,
7762 return _object_cast_to_QuadContainer(o)
7764 def __disown__(self):
7766 _IMP_kernel.disown_QuadContainer(self)
7767 return weakref_proxy(self)
7769 def do_destroy(self):
7770 """do_destroy(QuadContainer self)"""
7771 return _IMP_kernel.QuadContainer_do_destroy(self)
7774 def handle_set_has_required_score_states(self, arg0):
7775 """handle_set_has_required_score_states(QuadContainer self, bool arg0)"""
7776 return _IMP_kernel.QuadContainer_handle_set_has_required_score_states(self, arg0)
7779 def do_get_inputs(self):
7780 """do_get_inputs(QuadContainer self) -> IMP::ModelObjectsTemp"""
7781 return _IMP_kernel.QuadContainer_do_get_inputs(self)
7784 def do_get_interactions(self):
7785 """do_get_interactions(QuadContainer self) -> IMP::ModelObjectsTemps"""
7786 return _IMP_kernel.QuadContainer_do_get_interactions(self)
7789 def do_get_contents_hash(self):
7790 """do_get_contents_hash(QuadContainer self) -> std::size_t"""
7791 return _IMP_kernel.QuadContainer_do_get_contents_hash(self)
7793 QuadContainer_swigregister = _IMP_kernel.QuadContainer_swigregister
7794 QuadContainer_swigregister(QuadContainer)
7796 class _QuadContainerAdaptor(_InputAdaptor):
7797 """Proxy of C++ IMP::QuadContainerAdaptor class"""
7798 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
7799 __repr__ = _swig_repr
7801 def __init__(self, *args):
7803 __init__(IMP::QuadContainerAdaptor self) -> _QuadContainerAdaptor
7804 __init__(IMP::QuadContainerAdaptor self, QuadContainer c) -> _QuadContainerAdaptor
7805 __init__(IMP::QuadContainerAdaptor self, IMP::ParticleQuadsTemp const & t) -> _QuadContainerAdaptor
7807 this = _IMP_kernel.new__QuadContainerAdaptor(*args)
7809 self.this.append(this)
7813 def set_name_if_default(self, name):
7814 """set_name_if_default(_QuadContainerAdaptor self, std::string name)"""
7815 return _IMP_kernel._QuadContainerAdaptor_set_name_if_default(self, name)
7817 __swig_destroy__ = _IMP_kernel.delete__QuadContainerAdaptor
7818 __del__ =
lambda self:
None
7819 _QuadContainerAdaptor_swigregister = _IMP_kernel._QuadContainerAdaptor_swigregister
7820 _QuadContainerAdaptor_swigregister(_QuadContainerAdaptor)
7822 class SingletonModifier(_ParticleInputs, _ParticleOutputs, Object):
7823 """Proxy of C++ IMP::SingletonModifier class"""
7824 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
7826 def __init__(self, *args):
7828 __init__(IMP::SingletonModifier self, std::string name) -> SingletonModifier
7829 __init__(IMP::SingletonModifier self) -> SingletonModifier
7831 if self.__class__ == SingletonModifier:
7835 this = _IMP_kernel.new_SingletonModifier(_self, *args)
7837 self.this.append(this)
7841 if self.__class__ != SingletonModifier:
7842 _director_objects.register(self)
7847 def apply_index(self, m, v):
7848 """apply_index(SingletonModifier self, Model m, ParticleIndex v)"""
7849 return _IMP_kernel.SingletonModifier_apply_index(self, m, v)
7852 def apply_indexes(self, m, o, lower_bound, upper_bound):
7853 """apply_indexes(SingletonModifier self, Model m, IMP::ParticleIndexes const & o, unsigned int lower_bound, unsigned int upper_bound)"""
7854 return _IMP_kernel.SingletonModifier_apply_indexes(self, m, o, lower_bound, upper_bound)
7858 """__str__(SingletonModifier self) -> std::string"""
7859 return _IMP_kernel.SingletonModifier___str__(self)
7863 """__repr__(SingletonModifier self) -> std::string"""
7864 return _IMP_kernel.SingletonModifier___repr__(self)
7869 return _object_cast_to_SingletonModifier(o)
7872 def get_type_name(self):
7873 return self.__class__.__name__
7874 def do_show(self, out):
7876 def get_version_info(self):
7878 return VersionInfo(self.__module__,
7885 return _object_cast_to_SingletonModifier(o)
7887 __swig_destroy__ = _IMP_kernel.delete_SingletonModifier
7888 __del__ =
lambda self:
None
7889 def __disown__(self):
7891 _IMP_kernel.disown_SingletonModifier(self)
7892 return weakref_proxy(self)
7894 def do_get_inputs(self, m, pis):
7895 """do_get_inputs(SingletonModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7896 return _IMP_kernel.SingletonModifier_do_get_inputs(self, m, pis)
7899 def do_get_outputs(self, m, pis):
7900 """do_get_outputs(SingletonModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7901 return _IMP_kernel.SingletonModifier_do_get_outputs(self, m, pis)
7904 def do_destroy(self):
7905 """do_destroy(SingletonModifier self)"""
7906 return _IMP_kernel.SingletonModifier_do_destroy(self)
7908 SingletonModifier_swigregister = _IMP_kernel.SingletonModifier_swigregister
7909 SingletonModifier_swigregister(SingletonModifier)
7911 class SingletonScore(_ParticleInputs, Object):
7912 """Proxy of C++ IMP::SingletonScore class"""
7913 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
7915 def __init__(self, *args):
7917 __init__(IMP::SingletonScore self, std::string name) -> SingletonScore
7918 __init__(IMP::SingletonScore self) -> SingletonScore
7920 if self.__class__ == SingletonScore:
7924 this = _IMP_kernel.new_SingletonScore(_self, *args)
7926 self.this.append(this)
7930 if self.__class__ != SingletonScore:
7931 _director_objects.register(self)
7936 def evaluate_index(self, m, vt, da):
7937 """evaluate_index(SingletonScore self, Model m, ParticleIndex vt, DerivativeAccumulator da) -> double"""
7938 return _IMP_kernel.SingletonScore_evaluate_index(self, m, vt, da)
7941 def evaluate_indexes(self, m, o, da, lower_bound, upper_bound):
7942 """evaluate_indexes(SingletonScore self, Model m, IMP::ParticleIndexes const & o, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound) -> double"""
7943 return _IMP_kernel.SingletonScore_evaluate_indexes(self, m, o, da, lower_bound, upper_bound)
7946 def evaluate_if_good_index(self, m, vt, da, max):
7947 """evaluate_if_good_index(SingletonScore self, Model m, ParticleIndex vt, DerivativeAccumulator da, double max) -> double"""
7948 return _IMP_kernel.SingletonScore_evaluate_if_good_index(self, m, vt, da, max)
7951 def evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound):
7952 """evaluate_if_good_indexes(SingletonScore self, Model m, IMP::ParticleIndexes const & o, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound) -> double"""
7953 return _IMP_kernel.SingletonScore_evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound)
7956 def create_current_decomposition(self, m, vt):
7957 """create_current_decomposition(SingletonScore self, Model m, ParticleIndex vt) -> IMP::Restraints"""
7958 return _IMP_kernel.SingletonScore_create_current_decomposition(self, m, vt)
7961 def do_create_current_decomposition(self, m, vt):
7962 """do_create_current_decomposition(SingletonScore self, Model m, ParticleIndex vt) -> IMP::Restraints"""
7963 return _IMP_kernel.SingletonScore_do_create_current_decomposition(self, m, vt)
7965 __swig_destroy__ = _IMP_kernel.delete_SingletonScore
7966 __del__ =
lambda self:
None
7969 """__str__(SingletonScore self) -> std::string"""
7970 return _IMP_kernel.SingletonScore___str__(self)
7974 """__repr__(SingletonScore self) -> std::string"""
7975 return _IMP_kernel.SingletonScore___repr__(self)
7980 return _object_cast_to_SingletonScore(o)
7983 def get_type_name(self):
7984 return self.__class__.__name__
7985 def do_show(self, out):
7987 def get_version_info(self):
7989 return VersionInfo(self.__module__,
7996 return _object_cast_to_SingletonScore(o)
7998 def __disown__(self):
8000 _IMP_kernel.disown_SingletonScore(self)
8001 return weakref_proxy(self)
8003 def do_get_inputs(self, m, pis):
8004 """do_get_inputs(SingletonScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
8005 return _IMP_kernel.SingletonScore_do_get_inputs(self, m, pis)
8008 def do_destroy(self):
8009 """do_destroy(SingletonScore self)"""
8010 return _IMP_kernel.SingletonScore_do_destroy(self)
8012 SingletonScore_swigregister = _IMP_kernel.SingletonScore_swigregister
8013 SingletonScore_swigregister(SingletonScore)
8015 class SingletonPredicate(_ParticleInputs, Object):
8016 """Proxy of C++ IMP::SingletonPredicate class"""
8017 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
8019 def __init__(self, *args):
8021 __init__(IMP::SingletonPredicate self, std::string name) -> SingletonPredicate
8022 __init__(IMP::SingletonPredicate self) -> SingletonPredicate
8024 if self.__class__ == SingletonPredicate:
8028 this = _IMP_kernel.new_SingletonPredicate(_self, *args)
8030 self.this.append(this)
8034 if self.__class__ != SingletonPredicate:
8035 _director_objects.register(self)
8040 def get_value(self, *args):
8042 get_value(SingletonPredicate self, Particle vt) -> int
8043 get_value(SingletonPredicate self, IMP::ParticlesTemp const & o) -> IMP::Ints
8045 return _IMP_kernel.SingletonPredicate_get_value(self, *args)
8048 def setup_for_get_value_index_in_batch(self, arg0):
8049 """setup_for_get_value_index_in_batch(SingletonPredicate self, Model arg0)"""
8050 return _IMP_kernel.SingletonPredicate_setup_for_get_value_index_in_batch(self, arg0)
8053 def get_value_index_in_batch(self, m, vt):
8054 """get_value_index_in_batch(SingletonPredicate self, Model m, ParticleIndex vt) -> int"""
8055 return _IMP_kernel.SingletonPredicate_get_value_index_in_batch(self, m, vt)
8058 def __call__(self, m, vt):
8059 """__call__(SingletonPredicate self, Model m, ParticleIndex vt) -> int"""
8060 return _IMP_kernel.SingletonPredicate___call__(self, m, vt)
8063 def get_value_index(self, *args):
8065 get_value_index(SingletonPredicate self, Model m, ParticleIndex vt) -> int
8066 get_value_index(SingletonPredicate self, Model m, IMP::ParticleIndexes const & o) -> IMP::Ints
8068 return _IMP_kernel.SingletonPredicate_get_value_index(self, *args)
8070 __swig_destroy__ = _IMP_kernel.delete_SingletonPredicate
8071 __del__ =
lambda self:
None
8074 """__str__(SingletonPredicate self) -> std::string"""
8075 return _IMP_kernel.SingletonPredicate___str__(self)
8079 """__repr__(SingletonPredicate self) -> std::string"""
8080 return _IMP_kernel.SingletonPredicate___repr__(self)
8085 return _object_cast_to_SingletonPredicate(o)
8088 def get_type_name(self):
8089 return self.__class__.__name__
8090 def do_show(self, out):
8092 def get_version_info(self):
8094 return VersionInfo(self.__module__,
8101 return _object_cast_to_SingletonPredicate(o)
8103 def __disown__(self):
8105 _IMP_kernel.disown_SingletonPredicate(self)
8106 return weakref_proxy(self)
8108 def do_get_inputs(self, m, pis):
8109 """do_get_inputs(SingletonPredicate self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
8110 return _IMP_kernel.SingletonPredicate_do_get_inputs(self, m, pis)
8113 def do_destroy(self):
8114 """do_destroy(SingletonPredicate self)"""
8115 return _IMP_kernel.SingletonPredicate_do_destroy(self)
8117 SingletonPredicate_swigregister = _IMP_kernel.SingletonPredicate_swigregister
8118 SingletonPredicate_swigregister(SingletonPredicate)
8120 class SingletonContainer(Container):
8121 """Proxy of C++ IMP::SingletonContainer class"""
8122 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
8124 def apply_generic(self, m):
8125 """apply_generic(SingletonContainer self, SingletonModifier m)"""
8126 return _IMP_kernel.SingletonContainer_apply_generic(self, m)
8129 def apply(self, sm):
8130 """apply(SingletonContainer self, SingletonModifier sm)"""
8131 return _IMP_kernel.SingletonContainer_apply(self, sm)
8134 def get_range_indexes(self):
8135 """get_range_indexes(SingletonContainer self) -> IMP::ParticleIndexes"""
8136 return _IMP_kernel.SingletonContainer_get_range_indexes(self)
8139 def get_contents(self):
8140 """get_contents(SingletonContainer self) -> IMP::ParticleIndexes const &"""
8141 return _IMP_kernel.SingletonContainer_get_contents(self)
8145 """get_indexes(SingletonContainer self) -> IMP::ParticleIndexes"""
8146 return _IMP_kernel.SingletonContainer_get_indexes(self)
8149 def get(self, *args):
8151 get(SingletonContainer self) -> IMP::ParticlesTemp
8152 get(SingletonContainer self, unsigned int i) -> Particle
8154 return _IMP_kernel.SingletonContainer_get(self, *args)
8157 def get_number(self):
8158 """get_number(SingletonContainer self) -> unsigned int"""
8159 return _IMP_kernel.SingletonContainer_get_number(self)
8163 """get_particles(SingletonContainer self) -> IMP::ParticlesTemp"""
8164 return _IMP_kernel.SingletonContainer_get_particles(self)
8167 def __init__(self, *args):
8169 __init__(IMP::SingletonContainer self, Model m, std::string name) -> SingletonContainer
8170 __init__(IMP::SingletonContainer self, Model m) -> SingletonContainer
8172 if self.__class__ == SingletonContainer:
8176 this = _IMP_kernel.new_SingletonContainer(_self, *args)
8178 self.this.append(this)
8182 if self.__class__ != SingletonContainer:
8183 _director_objects.register(self)
8188 def do_apply(self, sm):
8189 """do_apply(SingletonContainer self, SingletonModifier sm)"""
8190 return _IMP_kernel.SingletonContainer_do_apply(self, sm)
8193 def do_get_provides_access(self):
8194 """do_get_provides_access(SingletonContainer self) -> bool"""
8195 return _IMP_kernel.SingletonContainer_do_get_provides_access(self)
8197 __swig_destroy__ = _IMP_kernel.delete_SingletonContainer
8198 __del__ =
lambda self:
None
8201 """__str__(SingletonContainer self) -> std::string"""
8202 return _IMP_kernel.SingletonContainer___str__(self)
8206 """__repr__(SingletonContainer self) -> std::string"""
8207 return _IMP_kernel.SingletonContainer___repr__(self)
8212 return _object_cast_to_SingletonContainer(o)
8215 def get_type_name(self):
8216 return self.__class__.__name__
8217 def do_show(self, out):
8219 def get_version_info(self):
8221 return VersionInfo(self.__module__,
8228 return _object_cast_to_SingletonContainer(o)
8230 def __disown__(self):
8232 _IMP_kernel.disown_SingletonContainer(self)
8233 return weakref_proxy(self)
8235 def do_destroy(self):
8236 """do_destroy(SingletonContainer self)"""
8237 return _IMP_kernel.SingletonContainer_do_destroy(self)
8240 def handle_set_has_required_score_states(self, arg0):
8241 """handle_set_has_required_score_states(SingletonContainer self, bool arg0)"""
8242 return _IMP_kernel.SingletonContainer_handle_set_has_required_score_states(self, arg0)
8245 def do_get_inputs(self):
8246 """do_get_inputs(SingletonContainer self) -> IMP::ModelObjectsTemp"""
8247 return _IMP_kernel.SingletonContainer_do_get_inputs(self)
8250 def do_get_interactions(self):
8251 """do_get_interactions(SingletonContainer self) -> IMP::ModelObjectsTemps"""
8252 return _IMP_kernel.SingletonContainer_do_get_interactions(self)
8255 def do_get_contents_hash(self):
8256 """do_get_contents_hash(SingletonContainer self) -> std::size_t"""
8257 return _IMP_kernel.SingletonContainer_do_get_contents_hash(self)
8259 SingletonContainer_swigregister = _IMP_kernel.SingletonContainer_swigregister
8260 SingletonContainer_swigregister(SingletonContainer)
8262 class _SingletonContainerAdaptor(_InputAdaptor):
8263 """Proxy of C++ IMP::SingletonContainerAdaptor class"""
8264 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
8265 __repr__ = _swig_repr
8267 def __init__(self, *args):
8269 __init__(IMP::SingletonContainerAdaptor self) -> _SingletonContainerAdaptor
8270 __init__(IMP::SingletonContainerAdaptor self, SingletonContainer c) -> _SingletonContainerAdaptor
8271 __init__(IMP::SingletonContainerAdaptor self, IMP::ParticlesTemp const & t) -> _SingletonContainerAdaptor
8273 this = _IMP_kernel.new__SingletonContainerAdaptor(*args)
8275 self.this.append(this)
8279 def set_name_if_default(self, name):
8280 """set_name_if_default(_SingletonContainerAdaptor self, std::string name)"""
8281 return _IMP_kernel._SingletonContainerAdaptor_set_name_if_default(self, name)
8283 __swig_destroy__ = _IMP_kernel.delete__SingletonContainerAdaptor
8284 __del__ =
lambda self:
None
8285 _SingletonContainerAdaptor_swigregister = _IMP_kernel._SingletonContainerAdaptor_swigregister
8286 _SingletonContainerAdaptor_swigregister(_SingletonContainerAdaptor)
8288 class TripletModifier(_ParticleInputs, _ParticleOutputs, Object):
8289 """Proxy of C++ IMP::TripletModifier class"""
8290 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
8292 def __init__(self, *args):
8294 __init__(IMP::TripletModifier self, std::string name) -> TripletModifier
8295 __init__(IMP::TripletModifier self) -> TripletModifier
8297 if self.__class__ == TripletModifier:
8301 this = _IMP_kernel.new_TripletModifier(_self, *args)
8303 self.this.append(this)
8307 if self.__class__ != TripletModifier:
8308 _director_objects.register(self)
8313 def apply_index(self, m, v):
8314 """apply_index(TripletModifier self, Model m, IMP::ParticleIndexTriplet const & v)"""
8315 return _IMP_kernel.TripletModifier_apply_index(self, m, v)
8318 def apply_indexes(self, m, o, lower_bound, upper_bound):
8319 """apply_indexes(TripletModifier self, Model m, IMP::ParticleIndexTriplets const & o, unsigned int lower_bound, unsigned int upper_bound)"""
8320 return _IMP_kernel.TripletModifier_apply_indexes(self, m, o, lower_bound, upper_bound)
8324 """__str__(TripletModifier self) -> std::string"""
8325 return _IMP_kernel.TripletModifier___str__(self)
8329 """__repr__(TripletModifier self) -> std::string"""
8330 return _IMP_kernel.TripletModifier___repr__(self)
8335 return _object_cast_to_TripletModifier(o)
8338 def get_type_name(self):
8339 return self.__class__.__name__
8340 def do_show(self, out):
8342 def get_version_info(self):
8344 return VersionInfo(self.__module__,
8351 return _object_cast_to_TripletModifier(o)
8353 __swig_destroy__ = _IMP_kernel.delete_TripletModifier
8354 __del__ =
lambda self:
None
8355 def __disown__(self):
8357 _IMP_kernel.disown_TripletModifier(self)
8358 return weakref_proxy(self)
8360 def do_get_inputs(self, m, pis):
8361 """do_get_inputs(TripletModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
8362 return _IMP_kernel.TripletModifier_do_get_inputs(self, m, pis)
8365 def do_get_outputs(self, m, pis):
8366 """do_get_outputs(TripletModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
8367 return _IMP_kernel.TripletModifier_do_get_outputs(self, m, pis)
8370 def do_destroy(self):
8371 """do_destroy(TripletModifier self)"""
8372 return _IMP_kernel.TripletModifier_do_destroy(self)
8374 TripletModifier_swigregister = _IMP_kernel.TripletModifier_swigregister
8375 TripletModifier_swigregister(TripletModifier)
8377 class TripletScore(_ParticleInputs, Object):
8378 """Proxy of C++ IMP::TripletScore class"""
8379 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
8381 def __init__(self, *args):
8383 __init__(IMP::TripletScore self, std::string name) -> TripletScore
8384 __init__(IMP::TripletScore self) -> TripletScore
8386 if self.__class__ == TripletScore:
8390 this = _IMP_kernel.new_TripletScore(_self, *args)
8392 self.this.append(this)
8396 if self.__class__ != TripletScore:
8397 _director_objects.register(self)
8402 def evaluate_index(self, m, vt, da):
8403 """evaluate_index(TripletScore self, Model m, IMP::ParticleIndexTriplet const & vt, DerivativeAccumulator da) -> double"""
8404 return _IMP_kernel.TripletScore_evaluate_index(self, m, vt, da)
8407 def evaluate_indexes(self, m, o, da, lower_bound, upper_bound):
8408 """evaluate_indexes(TripletScore self, Model m, IMP::ParticleIndexTriplets const & o, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound) -> double"""
8409 return _IMP_kernel.TripletScore_evaluate_indexes(self, m, o, da, lower_bound, upper_bound)
8412 def evaluate_if_good_index(self, m, vt, da, max):
8413 """evaluate_if_good_index(TripletScore self, Model m, IMP::ParticleIndexTriplet const & vt, DerivativeAccumulator da, double max) -> double"""
8414 return _IMP_kernel.TripletScore_evaluate_if_good_index(self, m, vt, da, max)
8417 def evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound):
8418 """evaluate_if_good_indexes(TripletScore self, Model m, IMP::ParticleIndexTriplets const & o, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound) -> double"""
8419 return _IMP_kernel.TripletScore_evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound)
8422 def create_current_decomposition(self, m, vt):
8423 """create_current_decomposition(TripletScore self, Model m, IMP::ParticleIndexTriplet const & vt) -> IMP::Restraints"""
8424 return _IMP_kernel.TripletScore_create_current_decomposition(self, m, vt)
8427 def do_create_current_decomposition(self, m, vt):
8428 """do_create_current_decomposition(TripletScore self, Model m, IMP::ParticleIndexTriplet const & vt) -> IMP::Restraints"""
8429 return _IMP_kernel.TripletScore_do_create_current_decomposition(self, m, vt)
8431 __swig_destroy__ = _IMP_kernel.delete_TripletScore
8432 __del__ =
lambda self:
None
8435 """__str__(TripletScore self) -> std::string"""
8436 return _IMP_kernel.TripletScore___str__(self)
8440 """__repr__(TripletScore self) -> std::string"""
8441 return _IMP_kernel.TripletScore___repr__(self)
8446 return _object_cast_to_TripletScore(o)
8449 def get_type_name(self):
8450 return self.__class__.__name__
8451 def do_show(self, out):
8453 def get_version_info(self):
8455 return VersionInfo(self.__module__,
8462 return _object_cast_to_TripletScore(o)
8464 def __disown__(self):
8466 _IMP_kernel.disown_TripletScore(self)
8467 return weakref_proxy(self)
8469 def do_get_inputs(self, m, pis):
8470 """do_get_inputs(TripletScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
8471 return _IMP_kernel.TripletScore_do_get_inputs(self, m, pis)
8474 def do_destroy(self):
8475 """do_destroy(TripletScore self)"""
8476 return _IMP_kernel.TripletScore_do_destroy(self)
8478 TripletScore_swigregister = _IMP_kernel.TripletScore_swigregister
8479 TripletScore_swigregister(TripletScore)
8481 class TripletPredicate(_ParticleInputs, Object):
8482 """Proxy of C++ IMP::TripletPredicate class"""
8483 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
8485 def __init__(self, *args):
8487 __init__(IMP::TripletPredicate self, std::string name) -> TripletPredicate
8488 __init__(IMP::TripletPredicate self) -> TripletPredicate
8490 if self.__class__ == TripletPredicate:
8494 this = _IMP_kernel.new_TripletPredicate(_self, *args)
8496 self.this.append(this)
8500 if self.__class__ != TripletPredicate:
8501 _director_objects.register(self)
8506 def get_value(self, *args):
8508 get_value(TripletPredicate self, IMP::ParticleTriplet const & vt) -> int
8509 get_value(TripletPredicate self, IMP::ParticleTripletsTemp const & o) -> IMP::Ints
8511 return _IMP_kernel.TripletPredicate_get_value(self, *args)
8514 def setup_for_get_value_index_in_batch(self, arg0):
8515 """setup_for_get_value_index_in_batch(TripletPredicate self, Model arg0)"""
8516 return _IMP_kernel.TripletPredicate_setup_for_get_value_index_in_batch(self, arg0)
8519 def get_value_index_in_batch(self, m, vt):
8520 """get_value_index_in_batch(TripletPredicate self, Model m, IMP::ParticleIndexTriplet const & vt) -> int"""
8521 return _IMP_kernel.TripletPredicate_get_value_index_in_batch(self, m, vt)
8524 def __call__(self, m, vt):
8525 """__call__(TripletPredicate self, Model m, IMP::ParticleIndexTriplet const & vt) -> int"""
8526 return _IMP_kernel.TripletPredicate___call__(self, m, vt)
8529 def get_value_index(self, *args):
8531 get_value_index(TripletPredicate self, Model m, IMP::ParticleIndexTriplet const & vt) -> int
8532 get_value_index(TripletPredicate self, Model m, IMP::ParticleIndexTriplets const & o) -> IMP::Ints
8534 return _IMP_kernel.TripletPredicate_get_value_index(self, *args)
8536 __swig_destroy__ = _IMP_kernel.delete_TripletPredicate
8537 __del__ =
lambda self:
None
8540 """__str__(TripletPredicate self) -> std::string"""
8541 return _IMP_kernel.TripletPredicate___str__(self)
8545 """__repr__(TripletPredicate self) -> std::string"""
8546 return _IMP_kernel.TripletPredicate___repr__(self)
8551 return _object_cast_to_TripletPredicate(o)
8554 def get_type_name(self):
8555 return self.__class__.__name__
8556 def do_show(self, out):
8558 def get_version_info(self):
8560 return VersionInfo(self.__module__,
8567 return _object_cast_to_TripletPredicate(o)
8569 def __disown__(self):
8571 _IMP_kernel.disown_TripletPredicate(self)
8572 return weakref_proxy(self)
8574 def do_get_inputs(self, m, pis):
8575 """do_get_inputs(TripletPredicate self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
8576 return _IMP_kernel.TripletPredicate_do_get_inputs(self, m, pis)
8579 def do_destroy(self):
8580 """do_destroy(TripletPredicate self)"""
8581 return _IMP_kernel.TripletPredicate_do_destroy(self)
8583 TripletPredicate_swigregister = _IMP_kernel.TripletPredicate_swigregister
8584 TripletPredicate_swigregister(TripletPredicate)
8586 class TripletContainer(Container):
8587 """Proxy of C++ IMP::TripletContainer class"""
8588 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
8590 def apply_generic(self, m):
8591 """apply_generic(TripletContainer self, TripletModifier m)"""
8592 return _IMP_kernel.TripletContainer_apply_generic(self, m)
8595 def apply(self, sm):
8596 """apply(TripletContainer self, TripletModifier sm)"""
8597 return _IMP_kernel.TripletContainer_apply(self, sm)
8600 def get_range_indexes(self):
8601 """get_range_indexes(TripletContainer self) -> IMP::ParticleIndexTriplets"""
8602 return _IMP_kernel.TripletContainer_get_range_indexes(self)
8605 def get_contents(self):
8606 """get_contents(TripletContainer self) -> IMP::ParticleIndexTriplets const &"""
8607 return _IMP_kernel.TripletContainer_get_contents(self)
8611 """get_indexes(TripletContainer self) -> IMP::ParticleIndexTriplets"""
8612 return _IMP_kernel.TripletContainer_get_indexes(self)
8615 def get(self, *args):
8617 get(TripletContainer self) -> IMP::ParticleTripletsTemp
8618 get(TripletContainer self, unsigned int i) -> IMP::ParticleTriplet
8620 return _IMP_kernel.TripletContainer_get(self, *args)
8623 def get_number(self):
8624 """get_number(TripletContainer self) -> unsigned int"""
8625 return _IMP_kernel.TripletContainer_get_number(self)
8628 def get_particle_triplets(self):
8629 """get_particle_triplets(TripletContainer self) -> IMP::ParticleTripletsTemp"""
8630 return _IMP_kernel.TripletContainer_get_particle_triplets(self)
8633 def __init__(self, *args):
8635 __init__(IMP::TripletContainer self, Model m, std::string name) -> TripletContainer
8636 __init__(IMP::TripletContainer self, Model m) -> TripletContainer
8638 if self.__class__ == TripletContainer:
8642 this = _IMP_kernel.new_TripletContainer(_self, *args)
8644 self.this.append(this)
8648 if self.__class__ != TripletContainer:
8649 _director_objects.register(self)
8654 def do_apply(self, sm):
8655 """do_apply(TripletContainer self, TripletModifier sm)"""
8656 return _IMP_kernel.TripletContainer_do_apply(self, sm)
8659 def do_get_provides_access(self):
8660 """do_get_provides_access(TripletContainer self) -> bool"""
8661 return _IMP_kernel.TripletContainer_do_get_provides_access(self)
8663 __swig_destroy__ = _IMP_kernel.delete_TripletContainer
8664 __del__ =
lambda self:
None
8667 """__str__(TripletContainer self) -> std::string"""
8668 return _IMP_kernel.TripletContainer___str__(self)
8672 """__repr__(TripletContainer self) -> std::string"""
8673 return _IMP_kernel.TripletContainer___repr__(self)
8678 return _object_cast_to_TripletContainer(o)
8681 def get_type_name(self):
8682 return self.__class__.__name__
8683 def do_show(self, out):
8685 def get_version_info(self):
8687 return VersionInfo(self.__module__,
8694 return _object_cast_to_TripletContainer(o)
8696 def __disown__(self):
8698 _IMP_kernel.disown_TripletContainer(self)
8699 return weakref_proxy(self)
8701 def do_destroy(self):
8702 """do_destroy(TripletContainer self)"""
8703 return _IMP_kernel.TripletContainer_do_destroy(self)
8706 def handle_set_has_required_score_states(self, arg0):
8707 """handle_set_has_required_score_states(TripletContainer self, bool arg0)"""
8708 return _IMP_kernel.TripletContainer_handle_set_has_required_score_states(self, arg0)
8711 def do_get_inputs(self):
8712 """do_get_inputs(TripletContainer self) -> IMP::ModelObjectsTemp"""
8713 return _IMP_kernel.TripletContainer_do_get_inputs(self)
8716 def do_get_interactions(self):
8717 """do_get_interactions(TripletContainer self) -> IMP::ModelObjectsTemps"""
8718 return _IMP_kernel.TripletContainer_do_get_interactions(self)
8721 def do_get_contents_hash(self):
8722 """do_get_contents_hash(TripletContainer self) -> std::size_t"""
8723 return _IMP_kernel.TripletContainer_do_get_contents_hash(self)
8725 TripletContainer_swigregister = _IMP_kernel.TripletContainer_swigregister
8726 TripletContainer_swigregister(TripletContainer)
8728 class _TripletContainerAdaptor(_InputAdaptor):
8729 """Proxy of C++ IMP::TripletContainerAdaptor class"""
8730 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
8731 __repr__ = _swig_repr
8733 def __init__(self, *args):
8735 __init__(IMP::TripletContainerAdaptor self) -> _TripletContainerAdaptor
8736 __init__(IMP::TripletContainerAdaptor self, TripletContainer c) -> _TripletContainerAdaptor
8737 __init__(IMP::TripletContainerAdaptor self, IMP::ParticleTripletsTemp const & t) -> _TripletContainerAdaptor
8739 this = _IMP_kernel.new__TripletContainerAdaptor(*args)
8741 self.this.append(this)
8745 def set_name_if_default(self, name):
8746 """set_name_if_default(_TripletContainerAdaptor self, std::string name)"""
8747 return _IMP_kernel._TripletContainerAdaptor_set_name_if_default(self, name)
8749 __swig_destroy__ = _IMP_kernel.delete__TripletContainerAdaptor
8750 __del__ =
lambda self:
None
8751 _TripletContainerAdaptor_swigregister = _IMP_kernel._TripletContainerAdaptor_swigregister
8752 _TripletContainerAdaptor_swigregister(_TripletContainerAdaptor)
8756 """write_particles_to_buffer(IMP::ParticlesTemp const & particles, IMP::FloatKeys const & keys) -> IMP::Vector< char >"""
8757 return _IMP_kernel.write_particles_to_buffer(particles, keys)
8760 """read_particles_from_buffer(IMP::Vector< char > const & buffer, IMP::ParticlesTemp const & particles, IMP::FloatKeys const & keys)"""
8761 return _IMP_kernel.read_particles_from_buffer(buffer, particles, keys)
8764 """get_particles(Model m, IMP::ParticleIndexes const & ps) -> IMP::ParticlesTemp"""
8765 return _IMP_kernel.get_particles(m, ps)
8769 get_indexes(IMP::ParticlesTemp const & ps) -> IMP::ParticleIndexes
8770 get_indexes(IMP::ParticlePairsTemp const & ps) -> IMP::ParticleIndexPairs
8772 return _IMP_kernel.get_indexes(*args)
8773 class _ParticleIndexAdaptor(object):
8774 """Proxy of C++ IMP::ParticleIndexAdaptor class"""
8775 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
8776 __repr__ = _swig_repr
8778 def __init__(self, *args):
8780 __init__(IMP::ParticleIndexAdaptor self, Particle p) -> _ParticleIndexAdaptor
8781 __init__(IMP::ParticleIndexAdaptor self, ParticleIndex pi) -> _ParticleIndexAdaptor
8782 __init__(IMP::ParticleIndexAdaptor self, Decorator d) -> _ParticleIndexAdaptor
8784 this = _IMP_kernel.new__ParticleIndexAdaptor(*args)
8786 self.this.append(this)
8789 __swig_destroy__ = _IMP_kernel.delete__ParticleIndexAdaptor
8790 __del__ =
lambda self:
None
8791 _ParticleIndexAdaptor_swigregister = _IMP_kernel._ParticleIndexAdaptor_swigregister
8792 _ParticleIndexAdaptor_swigregister(_ParticleIndexAdaptor)
8794 class _ParticleIndexesAdaptor(_InputAdaptor):
8795 """Proxy of C++ IMP::ParticleIndexesAdaptor class"""
8796 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
8797 __repr__ = _swig_repr
8799 def __init__(self, *args):
8801 __init__(IMP::ParticleIndexesAdaptor self, IMP::ParticlesTemp const & ps) -> _ParticleIndexesAdaptor
8802 __init__(IMP::ParticleIndexesAdaptor self, IMP::ParticleIndexes const & pi) -> _ParticleIndexesAdaptor
8803 __init__(IMP::ParticleIndexesAdaptor self) -> _ParticleIndexesAdaptor
8805 this = _IMP_kernel.new__ParticleIndexesAdaptor(*args)
8807 self.this.append(this)
8810 __swig_destroy__ = _IMP_kernel.delete__ParticleIndexesAdaptor
8811 __del__ =
lambda self:
None
8812 _ParticleIndexesAdaptor_swigregister = _IMP_kernel._ParticleIndexesAdaptor_swigregister
8813 _ParticleIndexesAdaptor_swigregister(_ParticleIndexesAdaptor)
8815 class _ParticleIndexPairsAdaptor(object):
8816 """Proxy of C++ IMP::ParticleIndexPairsAdaptor class"""
8817 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
8818 __repr__ = _swig_repr
8820 def __init__(self, *args):
8822 __init__(IMP::ParticleIndexPairsAdaptor self, IMP::ParticlePairsTemp const & ps) -> _ParticleIndexPairsAdaptor
8823 __init__(IMP::ParticleIndexPairsAdaptor self, IMP::ParticleIndexPairs const & pi) -> _ParticleIndexPairsAdaptor
8824 __init__(IMP::ParticleIndexPairsAdaptor self) -> _ParticleIndexPairsAdaptor
8826 this = _IMP_kernel.new__ParticleIndexPairsAdaptor(*args)
8828 self.this.append(this)
8831 __swig_destroy__ = _IMP_kernel.delete__ParticleIndexPairsAdaptor
8832 __del__ =
lambda self:
None
8833 _ParticleIndexPairsAdaptor_swigregister = _IMP_kernel._ParticleIndexPairsAdaptor_swigregister
8834 _ParticleIndexPairsAdaptor_swigregister(_ParticleIndexPairsAdaptor)
8836 class _ConstRestraint(Restraint):
8837 """Proxy of C++ IMP::internal::_ConstRestraint class"""
8838 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
8840 def __init__(self, *args):
8842 __init__(IMP::internal::_ConstRestraint self, double v, IMP::ParticlesTemp const ps) -> _ConstRestraint
8843 __init__(IMP::internal::_ConstRestraint self, Model m, IMP::ParticleIndexes const & pis, double v) -> _ConstRestraint
8845 this = _IMP_kernel.new__ConstRestraint(*args)
8847 self.this.append(this)
8851 def get_value(self):
8852 """get_value(_ConstRestraint self) -> double"""
8853 return _IMP_kernel._ConstRestraint_get_value(self)
8856 def do_create_decomposition(self):
8857 """do_create_decomposition(_ConstRestraint self) -> IMP::Restraints"""
8858 return _IMP_kernel._ConstRestraint_do_create_decomposition(self)
8861 def do_get_inputs(self):
8862 """do_get_inputs(_ConstRestraint self) -> IMP::ModelObjectsTemp"""
8863 return _IMP_kernel._ConstRestraint_do_get_inputs(self)
8866 def get_version_info(self):
8867 """get_version_info(_ConstRestraint self) -> VersionInfo"""
8868 return _IMP_kernel._ConstRestraint_get_version_info(self)
8872 """__str__(_ConstRestraint self) -> std::string"""
8873 return _IMP_kernel._ConstRestraint___str__(self)
8877 """__repr__(_ConstRestraint self) -> std::string"""
8878 return _IMP_kernel._ConstRestraint___repr__(self)
8883 return _object_cast_to__ConstRestraint(o)
8885 _ConstRestraint_swigregister = _IMP_kernel._ConstRestraint_swigregister
8886 _ConstRestraint_swigregister(_ConstRestraint)
8888 class _ConstSingletonScore(SingletonScore):
8889 """Proxy of C++ IMP::internal::_ConstSingletonScore class"""
8890 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
8891 __repr__ = _swig_repr
8893 def __init__(self, v):
8894 """__init__(IMP::internal::_ConstSingletonScore self, double v) -> _ConstSingletonScore"""
8895 this = _IMP_kernel.new__ConstSingletonScore(v)
8897 self.this.append(this)
8901 def do_get_inputs(self, arg2, arg3):
8902 """do_get_inputs(_ConstSingletonScore self, Model arg2, IMP::ParticleIndexes const & arg3) -> IMP::ModelObjectsTemp"""
8903 return _IMP_kernel._ConstSingletonScore_do_get_inputs(self, arg2, arg3)
8906 def get_version_info(self):
8907 """get_version_info(_ConstSingletonScore self) -> VersionInfo"""
8908 return _IMP_kernel._ConstSingletonScore_get_version_info(self)
8910 _ConstSingletonScore_swigregister = _IMP_kernel._ConstSingletonScore_swigregister
8911 _ConstSingletonScore_swigregister(_ConstSingletonScore)
8913 class _ConstPairScore(PairScore):
8914 """Proxy of C++ IMP::internal::_ConstPairScore class"""
8915 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
8916 __repr__ = _swig_repr
8918 def __init__(self, v):
8919 """__init__(IMP::internal::_ConstPairScore self, double v) -> _ConstPairScore"""
8920 this = _IMP_kernel.new__ConstPairScore(v)
8922 self.this.append(this)
8926 def do_get_inputs(self, arg2, arg3):
8927 """do_get_inputs(_ConstPairScore self, Model arg2, IMP::ParticleIndexes const & arg3) -> IMP::ModelObjectsTemp"""
8928 return _IMP_kernel._ConstPairScore_do_get_inputs(self, arg2, arg3)
8931 def get_version_info(self):
8932 """get_version_info(_ConstPairScore self) -> VersionInfo"""
8933 return _IMP_kernel._ConstPairScore_get_version_info(self)
8935 _ConstPairScore_swigregister = _IMP_kernel._ConstPairScore_swigregister
8936 _ConstPairScore_swigregister(_ConstPairScore)
8938 class _TrivialDecorator(Decorator):
8939 """Proxy of C++ IMP::internal::_TrivialDecorator class"""
8940 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
8942 def __init__(self, *args):
8944 __init__(IMP::internal::_TrivialDecorator self) -> _TrivialDecorator
8945 __init__(IMP::internal::_TrivialDecorator self, Model m, ParticleIndex id) -> _TrivialDecorator
8946 __init__(IMP::internal::_TrivialDecorator self, _ParticleAdaptor d) -> _TrivialDecorator
8948 this = _IMP_kernel.new__TrivialDecorator(*args)
8950 self.this.append(this)
8954 def show(self, *args):
8956 show(_TrivialDecorator self, _ostream out)
8957 show(_TrivialDecorator self)
8959 return _IMP_kernel._TrivialDecorator_show(self, *args)
8962 def setup_particle(*args):
8964 setup_particle(Model m, ParticleIndex pi) -> _TrivialDecorator
8965 setup_particle(_ParticleAdaptor decorator) -> _TrivialDecorator
8967 return _IMP_kernel._TrivialDecorator_setup_particle(*args)
8969 setup_particle = staticmethod(setup_particle)
8971 def get_is_setup(*args):
8973 get_is_setup(_ParticleAdaptor p) -> bool
8974 get_is_setup(Model m, ParticleIndex pi) -> bool
8976 return _IMP_kernel._TrivialDecorator_get_is_setup(*args)
8978 get_is_setup = staticmethod(get_is_setup)
8980 def add_attribute(self, *args):
8982 add_attribute(_TrivialDecorator self, FloatKey k, IMP::Float v, bool opt)
8983 add_attribute(_TrivialDecorator self, FloatKey a0, IMP::Float a1)
8984 add_attribute(_TrivialDecorator self, IntKey a0, IMP::Int a1)
8985 add_attribute(_TrivialDecorator self, FloatsKey a0, IMP::Floats a1)
8986 add_attribute(_TrivialDecorator self, IntsKey a0, IMP::Ints a1)
8987 add_attribute(_TrivialDecorator self, StringKey a0, IMP::String a1)
8988 add_attribute(_TrivialDecorator self, ParticleIndexKey a0, Particle a1)
8989 add_attribute(_TrivialDecorator self, ObjectKey a0, Object a1)
8991 return _IMP_kernel._TrivialDecorator_add_attribute(self, *args)
8994 def get_value(self, *args):
8996 get_value(_TrivialDecorator self, FloatKey a0) -> IMP::Float
8997 get_value(_TrivialDecorator self, IntKey a0) -> IMP::Int
8998 get_value(_TrivialDecorator self, FloatsKey a0) -> IMP::Floats
8999 get_value(_TrivialDecorator self, IntsKey a0) -> IMP::Ints
9000 get_value(_TrivialDecorator self, StringKey a0) -> IMP::String
9001 get_value(_TrivialDecorator self, ParticleIndexKey a0) -> Particle
9002 get_value(_TrivialDecorator self, ObjectKey a0) -> Object
9004 return _IMP_kernel._TrivialDecorator_get_value(self, *args)
9007 def set_value(self, *args):
9009 set_value(_TrivialDecorator self, FloatKey a0, IMP::Float a1)
9010 set_value(_TrivialDecorator self, IntKey a0, IMP::Int a1)
9011 set_value(_TrivialDecorator self, FloatsKey a0, IMP::Floats a1)
9012 set_value(_TrivialDecorator self, IntsKey a0, IMP::Ints a1)
9013 set_value(_TrivialDecorator self, StringKey a0, IMP::String a1)
9014 set_value(_TrivialDecorator self, ParticleIndexKey a0, Particle a1)
9015 set_value(_TrivialDecorator self, ObjectKey a0, Object a1)
9017 return _IMP_kernel._TrivialDecorator_set_value(self, *args)
9020 def remove_attribute(self, *args):
9022 remove_attribute(_TrivialDecorator self, FloatKey a0)
9023 remove_attribute(_TrivialDecorator self, IntKey a0)
9024 remove_attribute(_TrivialDecorator self, FloatsKey a0)
9025 remove_attribute(_TrivialDecorator self, IntsKey a0)
9026 remove_attribute(_TrivialDecorator self, StringKey a0)
9027 remove_attribute(_TrivialDecorator self, ParticleIndexKey a0)
9028 remove_attribute(_TrivialDecorator self, ObjectKey a0)
9030 return _IMP_kernel._TrivialDecorator_remove_attribute(self, *args)
9033 def has_attribute(self, *args):
9035 has_attribute(_TrivialDecorator self, FloatKey a0) -> bool
9036 has_attribute(_TrivialDecorator self, IntKey a0) -> bool
9037 has_attribute(_TrivialDecorator self, FloatsKey a0) -> bool
9038 has_attribute(_TrivialDecorator self, IntsKey a0) -> bool
9039 has_attribute(_TrivialDecorator self, StringKey a0) -> bool
9040 has_attribute(_TrivialDecorator self, ParticleIndexKey a0) -> bool
9041 has_attribute(_TrivialDecorator self, ObjectKey a0) -> bool
9043 return _IMP_kernel._TrivialDecorator_has_attribute(self, *args)
9046 def get_derivative(self, a0):
9047 """get_derivative(_TrivialDecorator self, FloatKey a0) -> double"""
9048 return _IMP_kernel._TrivialDecorator_get_derivative(self, a0)
9052 """get_name(_TrivialDecorator self) -> std::string"""
9053 return _IMP_kernel._TrivialDecorator_get_name(self)
9056 def clear_caches(self):
9057 """clear_caches(_TrivialDecorator self)"""
9058 return _IMP_kernel._TrivialDecorator_clear_caches(self)
9061 def set_name(self, a0):
9062 """set_name(_TrivialDecorator self, std::string a0)"""
9063 return _IMP_kernel._TrivialDecorator_set_name(self, a0)
9067 """set_check_level(_TrivialDecorator self, IMP::CheckLevel a0)"""
9068 return _IMP_kernel._TrivialDecorator_set_check_level(self, a0)
9071 def add_to_derivative(self, a0, a1, a2):
9072 """add_to_derivative(_TrivialDecorator self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
9073 return _IMP_kernel._TrivialDecorator_add_to_derivative(self, a0, a1, a2)
9076 def set_is_optimized(self, a0, a1):
9077 """set_is_optimized(_TrivialDecorator self, FloatKey a0, bool a1)"""
9078 return _IMP_kernel._TrivialDecorator_set_is_optimized(self, a0, a1)
9081 def get_is_optimized(self, a0):
9082 """get_is_optimized(_TrivialDecorator self, FloatKey a0) -> bool"""
9083 return _IMP_kernel._TrivialDecorator_get_is_optimized(self, a0)
9087 """get_check_level(_TrivialDecorator self) -> IMP::CheckLevel"""
9088 return _IMP_kernel._TrivialDecorator_get_check_level(self)
9091 def __eq__(self, *args):
9093 __eq__(_TrivialDecorator self, _TrivialDecorator o) -> bool
9094 __eq__(_TrivialDecorator self, Particle d) -> bool
9096 return _IMP_kernel._TrivialDecorator___eq__(self, *args)
9099 def __ne__(self, *args):
9101 __ne__(_TrivialDecorator self, _TrivialDecorator o) -> bool
9102 __ne__(_TrivialDecorator self, Particle d) -> bool
9104 return _IMP_kernel._TrivialDecorator___ne__(self, *args)
9107 def __le__(self, *args):
9109 __le__(_TrivialDecorator self, _TrivialDecorator o) -> bool
9110 __le__(_TrivialDecorator self, Particle d) -> bool
9112 return _IMP_kernel._TrivialDecorator___le__(self, *args)
9115 def __lt__(self, *args):
9117 __lt__(_TrivialDecorator self, _TrivialDecorator o) -> bool
9118 __lt__(_TrivialDecorator self, Particle d) -> bool
9120 return _IMP_kernel._TrivialDecorator___lt__(self, *args)
9123 def __ge__(self, *args):
9125 __ge__(_TrivialDecorator self, _TrivialDecorator o) -> bool
9126 __ge__(_TrivialDecorator self, Particle d) -> bool
9128 return _IMP_kernel._TrivialDecorator___ge__(self, *args)
9131 def __gt__(self, *args):
9133 __gt__(_TrivialDecorator self, _TrivialDecorator o) -> bool
9134 __gt__(_TrivialDecorator self, Particle d) -> bool
9136 return _IMP_kernel._TrivialDecorator___gt__(self, *args)
9140 """__hash__(_TrivialDecorator self) -> std::size_t"""
9141 return _IMP_kernel._TrivialDecorator___hash__(self)
9145 """__str__(_TrivialDecorator self) -> std::string"""
9146 return _IMP_kernel._TrivialDecorator___str__(self)
9150 """__repr__(_TrivialDecorator self) -> std::string"""
9151 return _IMP_kernel._TrivialDecorator___repr__(self)
9153 __swig_destroy__ = _IMP_kernel.delete__TrivialDecorator
9154 __del__ =
lambda self:
None
9155 _TrivialDecorator_swigregister = _IMP_kernel._TrivialDecorator_swigregister
9156 _TrivialDecorator_swigregister(_TrivialDecorator)
9158 def _TrivialDecorator_setup_particle(*args):
9160 setup_particle(Model m, ParticleIndex pi) -> _TrivialDecorator
9161 _TrivialDecorator_setup_particle(_ParticleAdaptor decorator) -> _TrivialDecorator
9163 return _IMP_kernel._TrivialDecorator_setup_particle(*args)
9165 def _TrivialDecorator_get_is_setup(*args):
9167 get_is_setup(_ParticleAdaptor p) -> bool
9168 _TrivialDecorator_get_is_setup(Model m, ParticleIndex pi) -> bool
9170 return _IMP_kernel._TrivialDecorator_get_is_setup(*args)
9172 class _TrivialDerivedDecorator(_TrivialDecorator):
9173 """Proxy of C++ IMP::internal::_TrivialDerivedDecorator class"""
9174 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
9176 def __init__(self, *args):
9178 __init__(IMP::internal::_TrivialDerivedDecorator self) -> _TrivialDerivedDecorator
9179 __init__(IMP::internal::_TrivialDerivedDecorator self, Model m, ParticleIndex id) -> _TrivialDerivedDecorator
9180 __init__(IMP::internal::_TrivialDerivedDecorator self, _ParticleAdaptor d) -> _TrivialDerivedDecorator
9182 this = _IMP_kernel.new__TrivialDerivedDecorator(*args)
9184 self.this.append(this)
9188 def show(self, *args):
9190 show(_TrivialDerivedDecorator self, _ostream out)
9191 show(_TrivialDerivedDecorator self)
9193 return _IMP_kernel._TrivialDerivedDecorator_show(self, *args)
9196 def setup_particle(*args):
9198 setup_particle(Model m, ParticleIndex pi) -> _TrivialDerivedDecorator
9199 setup_particle(_ParticleAdaptor decorator) -> _TrivialDerivedDecorator
9201 return _IMP_kernel._TrivialDerivedDecorator_setup_particle(*args)
9203 setup_particle = staticmethod(setup_particle)
9205 def get_is_setup(*args):
9207 get_is_setup(_ParticleAdaptor p) -> bool
9208 get_is_setup(Model m, ParticleIndex pi) -> bool
9210 return _IMP_kernel._TrivialDerivedDecorator_get_is_setup(*args)
9212 get_is_setup = staticmethod(get_is_setup)
9214 def add_attribute(self, *args):
9216 add_attribute(_TrivialDerivedDecorator self, FloatKey k, IMP::Float v, bool opt)
9217 add_attribute(_TrivialDerivedDecorator self, FloatKey a0, IMP::Float a1)
9218 add_attribute(_TrivialDerivedDecorator self, IntKey a0, IMP::Int a1)
9219 add_attribute(_TrivialDerivedDecorator self, FloatsKey a0, IMP::Floats a1)
9220 add_attribute(_TrivialDerivedDecorator self, IntsKey a0, IMP::Ints a1)
9221 add_attribute(_TrivialDerivedDecorator self, StringKey a0, IMP::String a1)
9222 add_attribute(_TrivialDerivedDecorator self, ParticleIndexKey a0, Particle a1)
9223 add_attribute(_TrivialDerivedDecorator self, ObjectKey a0, Object a1)
9225 return _IMP_kernel._TrivialDerivedDecorator_add_attribute(self, *args)
9228 def get_value(self, *args):
9230 get_value(_TrivialDerivedDecorator self, FloatKey a0) -> IMP::Float
9231 get_value(_TrivialDerivedDecorator self, IntKey a0) -> IMP::Int
9232 get_value(_TrivialDerivedDecorator self, FloatsKey a0) -> IMP::Floats
9233 get_value(_TrivialDerivedDecorator self, IntsKey a0) -> IMP::Ints
9234 get_value(_TrivialDerivedDecorator self, StringKey a0) -> IMP::String
9235 get_value(_TrivialDerivedDecorator self, ParticleIndexKey a0) -> Particle
9236 get_value(_TrivialDerivedDecorator self, ObjectKey a0) -> Object
9238 return _IMP_kernel._TrivialDerivedDecorator_get_value(self, *args)
9241 def set_value(self, *args):
9243 set_value(_TrivialDerivedDecorator self, FloatKey a0, IMP::Float a1)
9244 set_value(_TrivialDerivedDecorator self, IntKey a0, IMP::Int a1)
9245 set_value(_TrivialDerivedDecorator self, FloatsKey a0, IMP::Floats a1)
9246 set_value(_TrivialDerivedDecorator self, IntsKey a0, IMP::Ints a1)
9247 set_value(_TrivialDerivedDecorator self, StringKey a0, IMP::String a1)
9248 set_value(_TrivialDerivedDecorator self, ParticleIndexKey a0, Particle a1)
9249 set_value(_TrivialDerivedDecorator self, ObjectKey a0, Object a1)
9251 return _IMP_kernel._TrivialDerivedDecorator_set_value(self, *args)
9254 def remove_attribute(self, *args):
9256 remove_attribute(_TrivialDerivedDecorator self, FloatKey a0)
9257 remove_attribute(_TrivialDerivedDecorator self, IntKey a0)
9258 remove_attribute(_TrivialDerivedDecorator self, FloatsKey a0)
9259 remove_attribute(_TrivialDerivedDecorator self, IntsKey a0)
9260 remove_attribute(_TrivialDerivedDecorator self, StringKey a0)
9261 remove_attribute(_TrivialDerivedDecorator self, ParticleIndexKey a0)
9262 remove_attribute(_TrivialDerivedDecorator self, ObjectKey a0)
9264 return _IMP_kernel._TrivialDerivedDecorator_remove_attribute(self, *args)
9267 def has_attribute(self, *args):
9269 has_attribute(_TrivialDerivedDecorator self, FloatKey a0) -> bool
9270 has_attribute(_TrivialDerivedDecorator self, IntKey a0) -> bool
9271 has_attribute(_TrivialDerivedDecorator self, FloatsKey a0) -> bool
9272 has_attribute(_TrivialDerivedDecorator self, IntsKey a0) -> bool
9273 has_attribute(_TrivialDerivedDecorator self, StringKey a0) -> bool
9274 has_attribute(_TrivialDerivedDecorator self, ParticleIndexKey a0) -> bool
9275 has_attribute(_TrivialDerivedDecorator self, ObjectKey a0) -> bool
9277 return _IMP_kernel._TrivialDerivedDecorator_has_attribute(self, *args)
9280 def get_derivative(self, a0):
9281 """get_derivative(_TrivialDerivedDecorator self, FloatKey a0) -> double"""
9282 return _IMP_kernel._TrivialDerivedDecorator_get_derivative(self, a0)
9286 """get_name(_TrivialDerivedDecorator self) -> std::string"""
9287 return _IMP_kernel._TrivialDerivedDecorator_get_name(self)
9290 def clear_caches(self):
9291 """clear_caches(_TrivialDerivedDecorator self)"""
9292 return _IMP_kernel._TrivialDerivedDecorator_clear_caches(self)
9295 def set_name(self, a0):
9296 """set_name(_TrivialDerivedDecorator self, std::string a0)"""
9297 return _IMP_kernel._TrivialDerivedDecorator_set_name(self, a0)
9301 """set_check_level(_TrivialDerivedDecorator self, IMP::CheckLevel a0)"""
9302 return _IMP_kernel._TrivialDerivedDecorator_set_check_level(self, a0)
9305 def add_to_derivative(self, a0, a1, a2):
9306 """add_to_derivative(_TrivialDerivedDecorator self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
9307 return _IMP_kernel._TrivialDerivedDecorator_add_to_derivative(self, a0, a1, a2)
9310 def set_is_optimized(self, a0, a1):
9311 """set_is_optimized(_TrivialDerivedDecorator self, FloatKey a0, bool a1)"""
9312 return _IMP_kernel._TrivialDerivedDecorator_set_is_optimized(self, a0, a1)
9315 def get_is_optimized(self, a0):
9316 """get_is_optimized(_TrivialDerivedDecorator self, FloatKey a0) -> bool"""
9317 return _IMP_kernel._TrivialDerivedDecorator_get_is_optimized(self, a0)
9321 """get_check_level(_TrivialDerivedDecorator self) -> IMP::CheckLevel"""
9322 return _IMP_kernel._TrivialDerivedDecorator_get_check_level(self)
9325 def __eq__(self, *args):
9327 __eq__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
9328 __eq__(_TrivialDerivedDecorator self, Particle d) -> bool
9330 return _IMP_kernel._TrivialDerivedDecorator___eq__(self, *args)
9333 def __ne__(self, *args):
9335 __ne__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
9336 __ne__(_TrivialDerivedDecorator self, Particle d) -> bool
9338 return _IMP_kernel._TrivialDerivedDecorator___ne__(self, *args)
9341 def __le__(self, *args):
9343 __le__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
9344 __le__(_TrivialDerivedDecorator self, Particle d) -> bool
9346 return _IMP_kernel._TrivialDerivedDecorator___le__(self, *args)
9349 def __lt__(self, *args):
9351 __lt__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
9352 __lt__(_TrivialDerivedDecorator self, Particle d) -> bool
9354 return _IMP_kernel._TrivialDerivedDecorator___lt__(self, *args)
9357 def __ge__(self, *args):
9359 __ge__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
9360 __ge__(_TrivialDerivedDecorator self, Particle d) -> bool
9362 return _IMP_kernel._TrivialDerivedDecorator___ge__(self, *args)
9365 def __gt__(self, *args):
9367 __gt__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
9368 __gt__(_TrivialDerivedDecorator self, Particle d) -> bool
9370 return _IMP_kernel._TrivialDerivedDecorator___gt__(self, *args)
9374 """__hash__(_TrivialDerivedDecorator self) -> std::size_t"""
9375 return _IMP_kernel._TrivialDerivedDecorator___hash__(self)
9379 """__str__(_TrivialDerivedDecorator self) -> std::string"""
9380 return _IMP_kernel._TrivialDerivedDecorator___str__(self)
9384 """__repr__(_TrivialDerivedDecorator self) -> std::string"""
9385 return _IMP_kernel._TrivialDerivedDecorator___repr__(self)
9387 __swig_destroy__ = _IMP_kernel.delete__TrivialDerivedDecorator
9388 __del__ =
lambda self:
None
9389 _TrivialDerivedDecorator_swigregister = _IMP_kernel._TrivialDerivedDecorator_swigregister
9390 _TrivialDerivedDecorator_swigregister(_TrivialDerivedDecorator)
9392 def _TrivialDerivedDecorator_setup_particle(*args):
9394 setup_particle(Model m, ParticleIndex pi) -> _TrivialDerivedDecorator
9395 _TrivialDerivedDecorator_setup_particle(_ParticleAdaptor decorator) -> _TrivialDerivedDecorator
9397 return _IMP_kernel._TrivialDerivedDecorator_setup_particle(*args)
9399 def _TrivialDerivedDecorator_get_is_setup(*args):
9401 get_is_setup(_ParticleAdaptor p) -> bool
9402 _TrivialDerivedDecorator_get_is_setup(Model m, ParticleIndex pi) -> bool
9404 return _IMP_kernel._TrivialDerivedDecorator_get_is_setup(*args)
9406 class _TrivialTraitsDecorator(Decorator):
9407 """Proxy of C++ IMP::internal::_TrivialTraitsDecorator class"""
9408 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
9410 def get_decorator_traits(self):
9411 """get_decorator_traits(_TrivialTraitsDecorator self) -> StringKey"""
9412 return _IMP_kernel._TrivialTraitsDecorator_get_decorator_traits(self)
9415 def get_default_decorator_traits():
9416 """get_default_decorator_traits() -> StringKey"""
9417 return _IMP_kernel._TrivialTraitsDecorator_get_default_decorator_traits()
9419 get_default_decorator_traits = staticmethod(get_default_decorator_traits)
9421 def __init__(self, *args):
9423 __init__(IMP::internal::_TrivialTraitsDecorator self) -> _TrivialTraitsDecorator
9424 __init__(IMP::internal::_TrivialTraitsDecorator self, Model m, ParticleIndex id, StringKey tr) -> _TrivialTraitsDecorator
9425 __init__(IMP::internal::_TrivialTraitsDecorator self, Model m, ParticleIndex id) -> _TrivialTraitsDecorator
9426 __init__(IMP::internal::_TrivialTraitsDecorator self, _ParticleAdaptor d, StringKey tr) -> _TrivialTraitsDecorator
9427 __init__(IMP::internal::_TrivialTraitsDecorator self, _ParticleAdaptor d) -> _TrivialTraitsDecorator
9429 this = _IMP_kernel.new__TrivialTraitsDecorator(*args)
9431 self.this.append(this)
9435 def show(self, *args):
9437 show(_TrivialTraitsDecorator self, _ostream out)
9438 show(_TrivialTraitsDecorator self)
9440 return _IMP_kernel._TrivialTraitsDecorator_show(self, *args)
9443 def setup_particle(*args):
9445 setup_particle(Model m, ParticleIndex pi, StringKey tr) -> _TrivialTraitsDecorator
9446 setup_particle(Model m, ParticleIndex pi) -> _TrivialTraitsDecorator
9447 setup_particle(_ParticleAdaptor d, StringKey tr) -> _TrivialTraitsDecorator
9448 setup_particle(_ParticleAdaptor d) -> _TrivialTraitsDecorator
9450 return _IMP_kernel._TrivialTraitsDecorator_setup_particle(*args)
9452 setup_particle = staticmethod(setup_particle)
9454 def get_is_setup(*args):
9456 get_is_setup(_ParticleAdaptor p, StringKey tr) -> bool
9457 get_is_setup(_ParticleAdaptor p) -> bool
9458 get_is_setup(Model m, ParticleIndex pi, StringKey k) -> bool
9459 get_is_setup(Model m, ParticleIndex pi) -> bool
9461 return _IMP_kernel._TrivialTraitsDecorator_get_is_setup(*args)
9463 get_is_setup = staticmethod(get_is_setup)
9465 def get_default_key():
9466 """get_default_key() -> StringKey"""
9467 return _IMP_kernel._TrivialTraitsDecorator_get_default_key()
9469 get_default_key = staticmethod(get_default_key)
9471 def add_attribute(self, *args):
9473 add_attribute(_TrivialTraitsDecorator self, FloatKey k, IMP::Float v, bool opt)
9474 add_attribute(_TrivialTraitsDecorator self, FloatKey a0, IMP::Float a1)
9475 add_attribute(_TrivialTraitsDecorator self, IntKey a0, IMP::Int a1)
9476 add_attribute(_TrivialTraitsDecorator self, FloatsKey a0, IMP::Floats a1)
9477 add_attribute(_TrivialTraitsDecorator self, IntsKey a0, IMP::Ints a1)
9478 add_attribute(_TrivialTraitsDecorator self, StringKey a0, IMP::String a1)
9479 add_attribute(_TrivialTraitsDecorator self, ParticleIndexKey a0, Particle a1)
9480 add_attribute(_TrivialTraitsDecorator self, ObjectKey a0, Object a1)
9482 return _IMP_kernel._TrivialTraitsDecorator_add_attribute(self, *args)
9485 def get_value(self, *args):
9487 get_value(_TrivialTraitsDecorator self, FloatKey a0) -> IMP::Float
9488 get_value(_TrivialTraitsDecorator self, IntKey a0) -> IMP::Int
9489 get_value(_TrivialTraitsDecorator self, FloatsKey a0) -> IMP::Floats
9490 get_value(_TrivialTraitsDecorator self, IntsKey a0) -> IMP::Ints
9491 get_value(_TrivialTraitsDecorator self, StringKey a0) -> IMP::String
9492 get_value(_TrivialTraitsDecorator self, ParticleIndexKey a0) -> Particle
9493 get_value(_TrivialTraitsDecorator self, ObjectKey a0) -> Object
9495 return _IMP_kernel._TrivialTraitsDecorator_get_value(self, *args)
9498 def set_value(self, *args):
9500 set_value(_TrivialTraitsDecorator self, FloatKey a0, IMP::Float a1)
9501 set_value(_TrivialTraitsDecorator self, IntKey a0, IMP::Int a1)
9502 set_value(_TrivialTraitsDecorator self, FloatsKey a0, IMP::Floats a1)
9503 set_value(_TrivialTraitsDecorator self, IntsKey a0, IMP::Ints a1)
9504 set_value(_TrivialTraitsDecorator self, StringKey a0, IMP::String a1)
9505 set_value(_TrivialTraitsDecorator self, ParticleIndexKey a0, Particle a1)
9506 set_value(_TrivialTraitsDecorator self, ObjectKey a0, Object a1)
9508 return _IMP_kernel._TrivialTraitsDecorator_set_value(self, *args)
9511 def remove_attribute(self, *args):
9513 remove_attribute(_TrivialTraitsDecorator self, FloatKey a0)
9514 remove_attribute(_TrivialTraitsDecorator self, IntKey a0)
9515 remove_attribute(_TrivialTraitsDecorator self, FloatsKey a0)
9516 remove_attribute(_TrivialTraitsDecorator self, IntsKey a0)
9517 remove_attribute(_TrivialTraitsDecorator self, StringKey a0)
9518 remove_attribute(_TrivialTraitsDecorator self, ParticleIndexKey a0)
9519 remove_attribute(_TrivialTraitsDecorator self, ObjectKey a0)
9521 return _IMP_kernel._TrivialTraitsDecorator_remove_attribute(self, *args)
9524 def has_attribute(self, *args):
9526 has_attribute(_TrivialTraitsDecorator self, FloatKey a0) -> bool
9527 has_attribute(_TrivialTraitsDecorator self, IntKey a0) -> bool
9528 has_attribute(_TrivialTraitsDecorator self, FloatsKey a0) -> bool
9529 has_attribute(_TrivialTraitsDecorator self, IntsKey a0) -> bool
9530 has_attribute(_TrivialTraitsDecorator self, StringKey a0) -> bool
9531 has_attribute(_TrivialTraitsDecorator self, ParticleIndexKey a0) -> bool
9532 has_attribute(_TrivialTraitsDecorator self, ObjectKey a0) -> bool
9534 return _IMP_kernel._TrivialTraitsDecorator_has_attribute(self, *args)
9537 def get_derivative(self, a0):
9538 """get_derivative(_TrivialTraitsDecorator self, FloatKey a0) -> double"""
9539 return _IMP_kernel._TrivialTraitsDecorator_get_derivative(self, a0)
9543 """get_name(_TrivialTraitsDecorator self) -> std::string"""
9544 return _IMP_kernel._TrivialTraitsDecorator_get_name(self)
9547 def clear_caches(self):
9548 """clear_caches(_TrivialTraitsDecorator self)"""
9549 return _IMP_kernel._TrivialTraitsDecorator_clear_caches(self)
9552 def set_name(self, a0):
9553 """set_name(_TrivialTraitsDecorator self, std::string a0)"""
9554 return _IMP_kernel._TrivialTraitsDecorator_set_name(self, a0)
9558 """set_check_level(_TrivialTraitsDecorator self, IMP::CheckLevel a0)"""
9559 return _IMP_kernel._TrivialTraitsDecorator_set_check_level(self, a0)
9562 def add_to_derivative(self, a0, a1, a2):
9563 """add_to_derivative(_TrivialTraitsDecorator self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
9564 return _IMP_kernel._TrivialTraitsDecorator_add_to_derivative(self, a0, a1, a2)
9567 def set_is_optimized(self, a0, a1):
9568 """set_is_optimized(_TrivialTraitsDecorator self, FloatKey a0, bool a1)"""
9569 return _IMP_kernel._TrivialTraitsDecorator_set_is_optimized(self, a0, a1)
9572 def get_is_optimized(self, a0):
9573 """get_is_optimized(_TrivialTraitsDecorator self, FloatKey a0) -> bool"""
9574 return _IMP_kernel._TrivialTraitsDecorator_get_is_optimized(self, a0)
9578 """get_check_level(_TrivialTraitsDecorator self) -> IMP::CheckLevel"""
9579 return _IMP_kernel._TrivialTraitsDecorator_get_check_level(self)
9582 def __eq__(self, *args):
9584 __eq__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
9585 __eq__(_TrivialTraitsDecorator self, Particle d) -> bool
9587 return _IMP_kernel._TrivialTraitsDecorator___eq__(self, *args)
9590 def __ne__(self, *args):
9592 __ne__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
9593 __ne__(_TrivialTraitsDecorator self, Particle d) -> bool
9595 return _IMP_kernel._TrivialTraitsDecorator___ne__(self, *args)
9598 def __le__(self, *args):
9600 __le__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
9601 __le__(_TrivialTraitsDecorator self, Particle d) -> bool
9603 return _IMP_kernel._TrivialTraitsDecorator___le__(self, *args)
9606 def __lt__(self, *args):
9608 __lt__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
9609 __lt__(_TrivialTraitsDecorator self, Particle d) -> bool
9611 return _IMP_kernel._TrivialTraitsDecorator___lt__(self, *args)
9614 def __ge__(self, *args):
9616 __ge__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
9617 __ge__(_TrivialTraitsDecorator self, Particle d) -> bool
9619 return _IMP_kernel._TrivialTraitsDecorator___ge__(self, *args)
9622 def __gt__(self, *args):
9624 __gt__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
9625 __gt__(_TrivialTraitsDecorator self, Particle d) -> bool
9627 return _IMP_kernel._TrivialTraitsDecorator___gt__(self, *args)
9631 """__hash__(_TrivialTraitsDecorator self) -> std::size_t"""
9632 return _IMP_kernel._TrivialTraitsDecorator___hash__(self)
9636 """__str__(_TrivialTraitsDecorator self) -> std::string"""
9637 return _IMP_kernel._TrivialTraitsDecorator___str__(self)
9641 """__repr__(_TrivialTraitsDecorator self) -> std::string"""
9642 return _IMP_kernel._TrivialTraitsDecorator___repr__(self)
9644 __swig_destroy__ = _IMP_kernel.delete__TrivialTraitsDecorator
9645 __del__ =
lambda self:
None
9646 _TrivialTraitsDecorator_swigregister = _IMP_kernel._TrivialTraitsDecorator_swigregister
9647 _TrivialTraitsDecorator_swigregister(_TrivialTraitsDecorator)
9649 def _TrivialTraitsDecorator_get_default_decorator_traits():
9650 """_TrivialTraitsDecorator_get_default_decorator_traits() -> StringKey"""
9651 return _IMP_kernel._TrivialTraitsDecorator_get_default_decorator_traits()
9653 def _TrivialTraitsDecorator_setup_particle(*args):
9655 setup_particle(Model m, ParticleIndex pi, StringKey tr) -> _TrivialTraitsDecorator
9656 setup_particle(Model m, ParticleIndex pi) -> _TrivialTraitsDecorator
9657 setup_particle(_ParticleAdaptor d, StringKey tr) -> _TrivialTraitsDecorator
9658 _TrivialTraitsDecorator_setup_particle(_ParticleAdaptor d) -> _TrivialTraitsDecorator
9660 return _IMP_kernel._TrivialTraitsDecorator_setup_particle(*args)
9662 def _TrivialTraitsDecorator_get_is_setup(*args):
9664 get_is_setup(_ParticleAdaptor p, StringKey tr) -> bool
9665 get_is_setup(_ParticleAdaptor p) -> bool
9666 get_is_setup(Model m, ParticleIndex pi, StringKey k) -> bool
9667 _TrivialTraitsDecorator_get_is_setup(Model m, ParticleIndex pi) -> bool
9669 return _IMP_kernel._TrivialTraitsDecorator_get_is_setup(*args)
9671 def _TrivialTraitsDecorator_get_default_key():
9672 """_TrivialTraitsDecorator_get_default_key() -> StringKey"""
9673 return _IMP_kernel._TrivialTraitsDecorator_get_default_key()
9676 def __lshift__(*args):
9678 __lshift__(_ostream out, _TrivialDecorator n) -> _ostream
9679 __lshift__(_ostream out, _TrivialDerivedDecorator n) -> _ostream
9680 __lshift__(_ostream out, _TrivialTraitsDecorator n) -> _ostream
9682 return _IMP_kernel.__lshift__(*args)
9683 class _ConstOptimizer(Optimizer):
9684 """Proxy of C++ IMP::internal::_ConstOptimizer class"""
9685 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
9687 def __init__(self, m):
9688 """__init__(IMP::internal::_ConstOptimizer self, Model m) -> _ConstOptimizer"""
9689 this = _IMP_kernel.new__ConstOptimizer(m)
9691 self.this.append(this)
9695 def do_optimize(self, max_steps):
9696 """do_optimize(_ConstOptimizer self, unsigned int max_steps) -> IMP::Float"""
9697 return _IMP_kernel._ConstOptimizer_do_optimize(self, max_steps)
9700 def get_version_info(self):
9701 """get_version_info(_ConstOptimizer self) -> VersionInfo"""
9702 return _IMP_kernel._ConstOptimizer_get_version_info(self)
9706 """__str__(_ConstOptimizer self) -> std::string"""
9707 return _IMP_kernel._ConstOptimizer___str__(self)
9711 """__repr__(_ConstOptimizer self) -> std::string"""
9712 return _IMP_kernel._ConstOptimizer___repr__(self)
9717 return _object_cast_to__ConstOptimizer(o)
9719 _ConstOptimizer_swigregister = _IMP_kernel._ConstOptimizer_swigregister
9720 _ConstOptimizer_swigregister(_ConstOptimizer)
9723 def get_particle(p):
9724 """get_particle(Particle p) -> Particle"""
9725 return _IMP_kernel.get_particle(p)
9727 def _decorator_test(p):
9728 """_decorator_test(Particle p)"""
9729 return _IMP_kernel._decorator_test(p)
9731 def _overloaded_decorator(*args):
9733 _overloaded_decorator(_TrivialDecorator a) -> int
9734 _overloaded_decorator(_TrivialDerivedDecorator a) -> int
9736 return _IMP_kernel._overloaded_decorator(*args)
9738 def _take_particles(*args):
9740 _take_particles(IMP::Particles const & ps) -> unsigned int
9741 _take_particles(Model m, IMP::Particles const & ps) -> unsigned int
9742 _take_particles(Model m, IMP::Particles const & ps, TextOutput out) -> unsigned int
9744 return _IMP_kernel._take_particles(*args)
9746 def _give_particles(m):
9747 """_give_particles(Model m) -> IMP::Particles const &"""
9748 return _IMP_kernel._give_particles(m)
9750 def _pass_particles(ps):
9751 """_pass_particles(IMP::Particles const & ps) -> IMP::Particles const &"""
9752 return _IMP_kernel._pass_particles(ps)
9754 def _pass_particle(ps):
9755 """_pass_particle(Particle ps) -> Particle"""
9756 return _IMP_kernel._pass_particle(ps)
9758 def _pass_particle_pair(pp):
9759 """_pass_particle_pair(IMP::ParticlePair const & pp) -> IMP::ParticlePair const &"""
9760 return _IMP_kernel._pass_particle_pair(pp)
9762 def _give_particles_copy(m):
9763 """_give_particles_copy(Model m) -> IMP::Particles"""
9764 return _IMP_kernel._give_particles_copy(m)
9766 def _pass_float_keys(input):
9767 """_pass_float_keys(IMP::FloatKeys const & input) -> IMP::FloatKeys"""
9768 return _IMP_kernel._pass_float_keys(input)
9772 _pass(IMP::Particles const & p) -> IMP::Particles const
9773 _pass(IMP::Restraints const & p) -> IMP::Restraints const &
9775 return _IMP_kernel._pass(*args)
9777 def _pass_decorators(p):
9778 """_pass_decorators(IMP::internal::_TrivialDecorators const & p) -> IMP::internal::_TrivialDecorators const &"""
9779 return _IMP_kernel._pass_decorators(p)
9781 def _pass_decorator_traits(p):
9782 """_pass_decorator_traits(IMP::internal::_TrivialTraitsDecorators const & p) -> IMP::internal::_TrivialTraitsDecorators const &"""
9783 return _IMP_kernel._pass_decorator_traits(p)
9785 def _pass_particle_pairs(p):
9786 """_pass_particle_pairs(IMP::ParticlePairsTemp const & p) -> IMP::ParticlePairsTemp"""
9787 return _IMP_kernel._pass_particle_pairs(p)
9789 def _pass_particle_index_pairs(p):
9790 """_pass_particle_index_pairs(IMP::ParticleIndexPairs const & p) -> IMP::ParticleIndexPairs"""
9791 return _IMP_kernel._pass_particle_index_pairs(p)
9793 def _pass_model_objects(p):
9794 """_pass_model_objects(IMP::ModelObjectsTemp const & p) -> IMP::ModelObjectsTemp"""
9795 return _IMP_kernel._pass_model_objects(p)
9797 def _pass_particles_temps(ps):
9798 """_pass_particles_temps(IMP::ParticlesTemps const & ps) -> IMP::ParticlesTemps"""
9799 return _IMP_kernel._pass_particles_temps(ps)
9801 def _test_overload(*args):
9803 _test_overload(IMP::Particles const & ps) -> int
9804 _test_overload(IMP::Restraints const & ps) -> int
9806 return _IMP_kernel._test_overload(*args)
9808 def _get_range(m, k):
9809 """_get_range(Model m, FloatKey k) -> IMP::FloatRange"""
9810 return _IMP_kernel._get_range(m, k)
9812 def _create_particles_from_pdb(name, m):
9813 """_create_particles_from_pdb(std::string name, Model m) -> IMP::ParticleIndexes"""
9814 return _IMP_kernel._create_particles_from_pdb(name, m)
9815 class _LogPairScore(PairScore):
9816 """Proxy of C++ IMP::internal::_LogPairScore class"""
9817 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
9818 __repr__ = _swig_repr
9821 """__init__(IMP::internal::_LogPairScore self) -> _LogPairScore"""
9822 this = _IMP_kernel.new__LogPairScore()
9824 self.this.append(this)
9828 def do_get_inputs(self, arg2, arg3):
9829 """do_get_inputs(_LogPairScore self, Model arg2, IMP::ParticleIndexes const & arg3) -> IMP::ModelObjectsTemp"""
9830 return _IMP_kernel._LogPairScore_do_get_inputs(self, arg2, arg3)
9833 def get_version_info(self):
9834 """get_version_info(_LogPairScore self) -> VersionInfo"""
9835 return _IMP_kernel._LogPairScore_get_version_info(self)
9838 def get_particle_pairs(self):
9839 """get_particle_pairs(_LogPairScore self) -> IMP::ParticlePairsTemp"""
9840 return _IMP_kernel._LogPairScore_get_particle_pairs(self)
9844 """clear(_LogPairScore self)"""
9845 return _IMP_kernel._LogPairScore_clear(self)
9848 def get_contains(self, pp):
9849 """get_contains(_LogPairScore self, IMP::ParticlePair const & pp) -> bool"""
9850 return _IMP_kernel._LogPairScore_get_contains(self, pp)
9852 _LogPairScore_swigregister = _IMP_kernel._LogPairScore_swigregister
9853 _LogPairScore_swigregister(_LogPairScore)
9856 def _overloaded_particles(*args):
9858 _overloaded_particles(Particle arg1)
9859 _overloaded_particles(IMP::Particles const & arg1)
9860 _overloaded_particles(IMP::ParticlesTemp const & arg1)
9861 _overloaded_particles(Model arg1, IMP::ParticleIndexes const & arg2)
9862 _overloaded_particles(IMP::internal::_TrivialDecorators const & arg1)
9863 _overloaded_particles(_TrivialDecorator arg1)
9865 return _IMP_kernel._overloaded_particles(*args)
9866 class _ImplicitParticles(object):
9867 """Proxy of C++ IMP::internal::_ImplicitParticles class"""
9868 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
9869 __repr__ = _swig_repr
9871 def __init__(self, *args):
9873 __init__(IMP::internal::_ImplicitParticles self, Particle arg2) -> _ImplicitParticles
9874 __init__(IMP::internal::_ImplicitParticles self, IMP::Particles const & arg2) -> _ImplicitParticles
9875 __init__(IMP::internal::_ImplicitParticles self, IMP::ParticlesTemp const & arg2) -> _ImplicitParticles
9876 __init__(IMP::internal::_ImplicitParticles self, Model arg2, IMP::ParticleIndexes const & arg3) -> _ImplicitParticles
9877 __init__(IMP::internal::_ImplicitParticles self, IMP::internal::_TrivialDecorators const & arg2) -> _ImplicitParticles
9878 __init__(IMP::internal::_ImplicitParticles self, _TrivialDecorator arg2) -> _ImplicitParticles
9880 this = _IMP_kernel.new__ImplicitParticles(*args)
9882 self.this.append(this)
9885 __swig_destroy__ = _IMP_kernel.delete__ImplicitParticles
9886 __del__ =
lambda self:
None
9887 _ImplicitParticles_swigregister = _IMP_kernel._ImplicitParticles_swigregister
9888 _ImplicitParticles_swigregister(_ImplicitParticles)
9891 def _implicit_particles(arg1):
9892 """_implicit_particles(_ImplicitParticles arg1)"""
9893 return _IMP_kernel._implicit_particles(arg1)
9895 def _take_particle_adaptor(pa):
9896 """_take_particle_adaptor(_ParticleAdaptor pa) -> ParticleIndex"""
9897 return _IMP_kernel._take_particle_adaptor(pa)
9899 def _take_particle_indexes_adaptor(pa):
9900 """_take_particle_indexes_adaptor(_ParticleIndexesAdaptor pa) -> IMP::ParticleIndexes"""
9901 return _IMP_kernel._take_particle_indexes_adaptor(pa)
9902 class ScopedSetFloatAttribute(_RAII):
9903 """Proxy of C++ IMP::ScopedSetAttribute<(FloatKey,IMP::Float)> class"""
9904 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
9906 def __init__(self, *args):
9908 __init__(IMP::ScopedSetAttribute<(FloatKey,IMP::Float)> self) -> ScopedSetFloatAttribute
9909 __init__(IMP::ScopedSetAttribute<(FloatKey,IMP::Float)> self, Particle p, FloatKey key, double const & value) -> ScopedSetFloatAttribute
9911 this = _IMP_kernel.new_ScopedSetFloatAttribute(*args)
9913 self.this.append(this)
9917 def set(self, p, key, value):
9918 """set(ScopedSetFloatAttribute self, Particle p, FloatKey key, double const & value)"""
9919 return _IMP_kernel.ScopedSetFloatAttribute_set(self, p, key, value)
9923 """reset(ScopedSetFloatAttribute self)"""
9924 return _IMP_kernel.ScopedSetFloatAttribute_reset(self)
9926 __swig_destroy__ = _IMP_kernel.delete_ScopedSetFloatAttribute
9927 __del__ =
lambda self:
None
9929 def show(self, *args):
9931 show(ScopedSetFloatAttribute self, _ostream out)
9932 show(ScopedSetFloatAttribute self)
9934 return _IMP_kernel.ScopedSetFloatAttribute_show(self, *args)
9938 """__str__(ScopedSetFloatAttribute self) -> std::string"""
9939 return _IMP_kernel.ScopedSetFloatAttribute___str__(self)
9943 """__repr__(ScopedSetFloatAttribute self) -> std::string"""
9944 return _IMP_kernel.ScopedSetFloatAttribute___repr__(self)
9946 ScopedSetFloatAttribute_swigregister = _IMP_kernel.ScopedSetFloatAttribute_swigregister
9947 ScopedSetFloatAttribute_swigregister(ScopedSetFloatAttribute)
9950 def _get_module_data_path(module, file_name):
9951 """_get_module_data_path(std::string module, std::string file_name) -> std::string"""
9952 return _IMP_kernel._get_module_data_path(module, file_name)
9954 def _get_module_example_path(module, file_name):
9955 """_get_module_example_path(std::string module, std::string file_name) -> std::string"""
9956 return _IMP_kernel._get_module_example_path(module, file_name)
9965 if sys.platform ==
'win32' and 'IMP_LD_PATH' in os.environ:
9966 dirs = os.environ[
'IMP_LD_PATH'].split(
":")
9967 pathcomps = os.environ[
'PATH'].split(
";")
9969 if d
not in pathcomps:
9970 os.environ[
'PATH'] = d +
';' + os.environ[
'PATH']
9978 """Allow command line tools to easily implement multiple commands.
9979 Typically, an IMP command line tool will use an instance of this class
9980 to provide a consistent interface to multiple distinct commands
9981 from a single binary, rather than providing a potentially large
9982 number of binaries. This is similar to the way a number of common
9983 command line tools outside of IMP function (e.g. Git provides a single
9984 `git` tool which implements multiple commands - `git add`, `git commit`,
9985 `git push` and so on).
9987 Each command is implemented with a Python module of the same name
9988 that can be imported from the module (for example, if `module_name`
9989 is `IMP.foo`, the `bar` command is provided by the `IMP.foo.bar` Python
9990 module, which would usually be found as `modules/foo/pyext/src/bar.py`).
9991 Each such module should have a docstring and a `%main()` method
9992 that takes no arguments (the module should also call its `%main()` method
9993 if it is run directly, i.e. with something like
9994 `if __name__=="__main__": %main()`). The encompassing module
9995 (`IMP.foo` in the example) should define `_all_commands` as a Python
9996 list of all valid commands.
9998 See the `multifit` and `cnmultifit` command line tools for example
10004 @param short_help A few words that describe the command line tool.
10005 @param long_help Longer text, used in the `help` command.
10006 @param module_name Name of the module (e.g. `IMP.foo`) that
10007 implements the commands.
10009 self.short_help = short_help
10010 self.long_help = long_help
10011 self.module_name = module_name
10012 self._all_commands = self.import_module()._all_commands
10013 self._progname = os.path.basename(sys.argv[0])
10016 """Call this method to act upon the user-provided command line"""
10017 if len(sys.argv) <= 1:
10018 print(self.short_help +
" Use '%s help' for help." % self._progname)
10020 command = sys.argv[1]
10021 if command
in (
'help',
'--help',
'-h'):
10022 if len(sys.argv) == 3:
10023 self.show_command_help(sys.argv[2])
10026 elif command ==
'--version':
10027 self.show_version()
10028 elif command
in self._all_commands:
10029 self.do_command(command)
10031 self.unknown_command(command)
10033 def import_module(self, mod=None):
10034 modname = self.module_name
10035 if mod
is not None:
10036 modname +=
"." + mod
10037 return __import__(modname, {}, {}, [
''])
10039 def unknown_command(self, command):
10040 print(
"Unknown command: '%s'" % command)
10041 print(
"Use '%s help' for help." % self._progname)
10044 def _get_version(self):
10047 def show_version(self):
10048 print(self._progname +
' ' + self._get_version())
10050 def show_help(self):
10051 ver = self._get_version()
10052 print(
"%s, version %s." % (self._progname, ver))
10053 print(self.long_help +
"""
10055 This program is part of IMP, the Integrative Modeling Platform,
10056 which is Copyright 2007-2021 IMP Inventors.
10057 For additional information about IMP, see <https://integrativemodeling.org>.
10059 Usage: %s <command> [options] [args]
10061 Commands:""" % self._progname)
10062 commands = self._all_commands[:] + [
'help']
10064 cmdlen = max([len(c)
for c
in commands])
10067 doc =
'Get help on using %s.' % self._progname
10069 doc = self.import_module(c).__doc__
or "<no help>"
10070 c +=
' ' * (cmdlen - len(c))
10071 print(
' ' + c +
' ' + doc)
10073 Use "%s help <command>" for detailed help on any command
10074 or "%s --version" to see the version number.""" % (self._progname,
10077 def do_command(self, command):
10078 mod = self.import_module(command)
10079 sys.argv[0] = self._progname +
' ' + command
10083 def show_command_help(self, command):
10084 if command ==
'help':
10086 elif command
in self._all_commands
or command ==
'help':
10087 mod = self.import_module(command)
10088 sys.argv = [self._progname +
' ' + command,
'--help']
10091 self.unknown_command(command)
10098 g = networkx.DiGraph()
10099 if len(ig.get_vertices()) == 0:
10108 return self.p.get_name()
10110 def __call__(self, name):
10111 return self.p.__call__(name)
10113 for vi
in ig.get_vertices():
10114 n = ig.get_vertex_name(vi)
10115 g.add_node(NodeWrapper(n))
10116 for vi
in ig.get_vertices():
10117 n = ig.get_vertex_name(vi)
10118 for ni
in ig.get_out_neighbors(vi):
10119 nn = ig.get_vertex_name(ni)
10120 g.add_edge(NodeWrapper(n), NodeWrapper(nn))
10127 n0 = name.get_name()
10130 n1 = str(n0).replace(
'"',
'')
10131 n2 = n1.replace(
"\n",
'')
10134 from altgraph
import Graph, Dot
10135 graph = Graph.Graph()
10136 for i, v
in enumerate(g.get_vertices()):
10138 for i, v
in enumerate(g.get_vertices()):
10139 for n
in g.get_out_neighbors(v):
10140 graph.add_edge(v, n)
10141 dot = Dot.Dot(graph)
10142 for i, v
in enumerate(g.get_vertices()):
10143 dot.node_style(i, label=clean(g.get_vertex_name(v)))
10150 st = g.get_graphviz_string()
10151 open(tfn,
"w").write(st)
10154 except ImportError:
10156 sys.stderr.write(
"Cannot run dot on Python 2.3 systems.\n")
10159 print(
"running dot")
10160 sp = subprocess.Popen([
"dot",
"-Tpdf", tfn,
"-o" + tfon])
10164 sys.stderr.write(
"The dot command from the graphviz package was not found. Please make sure it is in the PATH passed to IMP.\n")
10167 if platform.system() ==
"Darwin":
10170 cmd = [
"gv",
"acroread",
"xpdf"]
10173 print(
"launching viewer " + c)
10175 subprocess.check_call([c, tfon])
10181 print(
"Could not display file. It is saved at " + tfon)
10191 """Mark a Python module as deprecated.
10192 @note The `module` argument would normally be `__name__`.
10193 @see [deprecation support](@ref deprecation)."""
10195 "Module %s is deprecated. %s\n" % (module, help_message))
10198 """Python decorator to mark a class as deprecated.
10199 @see [deprecation support](@ref deprecation)."""
10201 orig_init = obj.__init__
10204 @functools.wraps(orig_init, (
'__name__',
'__doc__'))
10205 def __init__(obj, *args, **keys):
10207 % (type(obj), help_message))
10208 orig_init(obj, *args, **keys)
10209 obj.__init__ = __init__
10214 """Python decorator to mark a method as deprecated.
10215 @see [deprecation support](@ref deprecation)."""
10216 def out_wrapper(obj):
10217 @functools.wraps(obj)
10218 def wrapper(cls, *args, **keys):
10220 % (obj.__name__, type(cls), help_message))
10221 return obj(cls, *args, **keys)
10226 """Python decorator to mark a function as deprecated.
10227 @see [deprecation support](@ref deprecation)."""
10228 def out_wrapper(obj):
10229 @functools.wraps(obj)
10230 def wrapper(*args, **keys):
10232 % (obj.__name__, help_message))
10233 return obj(*args, **keys)
10237 @contextlib.contextmanager
10239 """Context manager to temporarily allow (or disallow) deprecated code.
10240 @see [deprecation support](@ref deprecation)."""
10247 def _get_all_flags(ntokens):
10248 """_get_all_flags(unsigned int ntokens) -> IMP::Strings"""
10249 return _IMP_kernel._get_all_flags(ntokens)
10251 def _print_internal_help(out, description):
10252 """_print_internal_help(_ostream out, std::string description)"""
10253 return _IMP_kernel._print_internal_help(out, description)
10259 class _PassThroughAction(argparse.Action):
10260 """Pass an argument through to the IMP Boost parser"""
10261 def __call__(self, parser, namespace, values, option_string=None):
10262 parser._boost_command_line.append(option_string)
10264 parser._boost_command_line.append(values)
10267 if option_string
in (
'-h',
'--help',
'--help_advanced',
'--version'):
10268 parser._handle_boost()
10272 """IMP-specific subclass of argparse.ArgumentParser.
10273 This adds options common to all IMP applications
10274 (see IMP::setup_from_argv()).
10277 def __init__(self, *args, **kwargs):
10279 kwargs[
'add_help'] =
False
10280 super(ArgumentParser, self).__init__(*args, **kwargs)
10281 for ntoken
in (0, 1):
10282 flags = _get_all_flags(ntoken)
10284 arg = [
'-h',
'--help']
if f ==
'help' else [
'--' + f]
10285 self.add_argument(*arg, help=argparse.SUPPRESS,
10286 nargs=
None if ntoken
else 0,
10287 action=_PassThroughAction,
10288 default=argparse.SUPPRESS)
10291 """Parse the command line and return optional and positional arguments.
10292 This functions in the same way as the method in the base class
10293 argparse.ArgumentParser, except that it also processes optional
10294 arguments common to all IMP applications (these are not returned
10295 in `args`, but can be obtained in the usual way, e.g. by calling
10296 IMP::get_string_flag()).
10299 self._boost_command_line = [sys.argv[0]]
10300 ret = super(ArgumentParser, self).
parse_args(args, namespace)
10301 if len(self._boost_command_line) > 1:
10302 self._handle_boost()
10305 def _get_description(self):
10306 return self.format_help() +
"\nOptions common to all IMP applications:"
10308 def print_help(self, file=None):
10309 _print_internal_help(file
if file
else sys.stdout,
10310 self._get_description())
10312 def _handle_boost(self):
10314 self._get_description(),
10317 class RandomNumberGenerator(object):
10318 """Proxy of C++ IMP::RandomNumberGenerator class"""
10319 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
10320 __repr__ = _swig_repr
10323 """seed(RandomNumberGenerator self, ::boost::int32_t x)"""
10324 return _IMP_kernel.RandomNumberGenerator_seed(self, x)
10327 def __call__(self):
10328 """__call__(RandomNumberGenerator self) -> int"""
10329 return _IMP_kernel.RandomNumberGenerator___call__(self)
10332 def __init__(self):
10333 """__init__(IMP::RandomNumberGenerator self) -> RandomNumberGenerator"""
10334 this = _IMP_kernel.new_RandomNumberGenerator()
10336 self.this.append(this)
10339 __swig_destroy__ = _IMP_kernel.delete_RandomNumberGenerator
10340 __del__ =
lambda self:
None
10341 RandomNumberGenerator_swigregister = _IMP_kernel.RandomNumberGenerator_swigregister
10342 RandomNumberGenerator_swigregister(RandomNumberGenerator)
10347 get_random_float_uniform() -> float
10348 get_random_float_uniform(float min, float max) -> float
10350 return _IMP_kernel.get_random_float_uniform(*args)
10354 get_random_double_uniform() -> double
10355 get_random_double_uniform(double min, double max) -> double
10357 return _IMP_kernel.get_random_double_uniform(*args)
10359 def get_random_floats_normal(n, mean=0.0, stddev=1.0):
10361 get_random_floats_normal(unsigned int n, float mean=0.0, float stddev=1.0) -> IMP::Vector< float >
10362 get_random_floats_normal(unsigned int n, float mean=0.0) -> IMP::Vector< float >
10363 get_random_floats_normal(unsigned int n) -> IMP::Vector< float >
10365 return _IMP_kernel.get_random_floats_normal(n, mean, stddev)
10367 def get_random_doubles_normal(n, mean=0.0, stddev=1.0):
10369 get_random_doubles_normal(unsigned int n, double mean=0.0, double stddev=1.0) -> IMP::Vector< double >
10370 get_random_doubles_normal(unsigned int n, double mean=0.0) -> IMP::Vector< double >
10371 get_random_doubles_normal(unsigned int n) -> IMP::Vector< double >
10373 return _IMP_kernel.get_random_doubles_normal(n, mean, stddev)
10375 def get_random_floats_uniform(n):
10376 """get_random_floats_uniform(unsigned int n) -> IMP::Vector< float >"""
10377 return _IMP_kernel.get_random_floats_uniform(n)
10379 def get_random_doubles_uniform(n):
10380 """get_random_doubles_uniform(unsigned int n) -> IMP::Vector< double >"""
10381 return _IMP_kernel.get_random_doubles_uniform(n)
10384 """get_random_seed() -> boost::uint64_t"""
10385 return _IMP_kernel.get_random_seed()
10387 def _get_derivatives_numpy(m, k, m_pyobj):
10388 """_get_derivatives_numpy(Model m, FloatKey k, PyObject * m_pyobj) -> PyObject *"""
10389 return _IMP_kernel._get_derivatives_numpy(m, k, m_pyobj)
10391 def _get_floats_numpy(m, k, m_pyobj):
10392 """_get_floats_numpy(Model m, FloatKey k, PyObject * m_pyobj) -> PyObject *"""
10393 return _IMP_kernel._get_floats_numpy(m, k, m_pyobj)
10395 def _get_ints_numpy(m, k, m_pyobj):
10396 """_get_ints_numpy(Model m, IntKey k, PyObject * m_pyobj) -> PyObject *"""
10397 return _IMP_kernel._get_ints_numpy(m, k, m_pyobj)
10399 def _get_spheres_numpy(m, m_pyobj):
10400 """_get_spheres_numpy(Model m, PyObject * m_pyobj) -> PyObject *"""
10401 return _IMP_kernel._get_spheres_numpy(m, m_pyobj)
10403 def _get_sphere_derivatives_numpy(m, m_pyobj):
10404 """_get_sphere_derivatives_numpy(Model m, PyObject * m_pyobj) -> PyObject *"""
10405 return _IMP_kernel._get_sphere_derivatives_numpy(m, m_pyobj)
10408 """get_module_version() -> std::string const"""
10409 return _IMP_kernel.get_module_version()
10412 """get_example_path(std::string fname) -> std::string"""
10413 return _IMP_kernel.get_example_path(fname)
10416 """get_data_path(std::string fname) -> std::string"""
10417 return _IMP_kernel.get_data_path(fname)
10419 from .
import _version_check
10424 random_number_generator = cvar.random_number_generator
void add_int_flag(std::string name, size_t default_value, std::string description)
Allow command line tools to easily implement multiple commands.
CheckLevel get_check_level()
Get the current audit mode.
Key< 0 > FloatKey
The type used to identify float attributes in the Particles.
def allow_deprecated
Context manager to temporarily allow (or disallow) deprecated code.
std::string get_unique_name(std::string templ)
Return a unique name produced from the string.
DependencyGraph get_dependency_graph(Model *m)
Objects get_live_objects()
Return pointers to all live objects.
Vector< char > write_particles_to_buffer(const ParticlesTemp &particles, const FloatKeys &keys)
return a binary buffer with the data
def main
Call this method to act upon the user-provided command line.
boost::graph DependencyGraph
Directed graph on the interactions between the various objects in the model.
ContainersTemp get_input_containers(const ModelObjectsTemp &mos)
Return all the input particles for a given ModelObject.
ParticlesTemp get_dependent_particles(ModelObject *p, const ModelObjectsTemp &all, const DependencyGraph &dg, const DependencyGraphVertexIndex &index)
def deprecated_module
Mark a Python module as deprecated.
Vector< VectorD< D > > get_vertices(const BoundingBoxD< D > &bb)
Return a list of the 2^D bounding points for the bounding box.
Array< 4, WeakPointer< Particle >, Particle * > ParticleQuad
bool get_bool_flag(std::string name)
void handle_use_deprecated(std::string message)
Break in this method in gdb to find deprecated uses at runtime.
void set_progress_display(std::string description, unsigned int steps)
Set up the progress bar with the passed description.
def deprecated_function
Python decorator to mark a function as deprecated.
Index< ParticleIndexTag > ParticleIndex
ParticlesTemp get_particles(Model *m, const ParticleIndexes &ps)
Get the particles from a list of indexes.
Key< 6 > ParticleIndexesKey
The type used to identify a particle attribute in the Particles.
Array< 3, WeakPointer< Particle >, Particle * > ParticleTriplet
ContainersTemp get_output_containers(const ModelObjectsTemp &mos)
Return all the output particles for a given ModelObject.
void add_particle(RMF::FileHandle fh, Particle *hs)
std::string get_data_path(std::string file_name)
Return the full path to one of this module's data files.
void add_string_flag(std::string name, std::string default_value, std::string description)
LogLevel get_log_level()
Get the currently active global log level.
void set_deprecation_warnings(bool tf)
Toggle printing of warnings on using deprecated classes.
TextOutput create_temporary_file(std::string prefix="imp_temp", std::string suffix="")
ParticlesTemp get_output_particles(const ModelObjectsTemp &mos)
Return all the output particles for a given ModelObject.
ScoringFunction * create_scoring_function(RestraintType *rs, double weight=1.0, double max=NO_MAX, std::string name=std::string())
Create a ScoringFunction on a single restraint.
void write_help(std::ostream &out=std::cerr)
Key< 2 > StringKey
The type used to identify string attributes in the Particles.
size_t get_int_flag(std::string name)
Key< 10 > FloatsKey
The type used to identify float vector attributes in the Particles.
void add_restraint(RMF::FileHandle fh, Restraint *hs)
ScoreStatesTemp get_required_score_states(ModelObject *p, const ModelObjectsTemp &all, const DependencyGraph &dg, const DependencyGraphVertexIndex &index)
boost::uint64_t get_random_seed()
Return the initial random seed.
Key< 3 > ParticleIndexKey
The type used to identify a particle attribute in the Particles.
Strings get_live_object_names()
Return the names of all live objects.
void add_to_progress_display(unsigned int step=1)
Set the current progress.
void add_float_flag(std::string name, double default_value, std::string description)
Ints get_index(const ParticlesTemp &particles, const Subset &subset, const Subsets &excluded)
ParticleIndexes get_particle_indexes(ParticlesTemp const &particles)
def deprecated_method
Python decorator to mark a method as deprecated.
void reset_log_timer()
Reset the log timer.
void add_restraints(RMF::FileHandle fh, const Restraints &hs)
void add_to_log(LogLevel level, std::string to_write)
Write a string to the log, for Python.
def parse_args
Parse the command line and return optional and positional arguments.
Key< 1 > IntKey
The type used to identify int attributes in the Particles.
Version and module information for Objects.
Restraints create_decomposition(const RestraintsTemp &rs)
Return the decomposition of a list of restraints.
std::string get_relative_path(std::string base, std::string relative)
Return a path to a file relative to another file.
void set_deprecation_exceptions(bool tf)
Toggle whether an exception is thrown when a deprecated method is used.
Key< 4 > ObjectKey
The type used to identify an Object attribute.
IMP-specific subclass of argparse.ArgumentParser.
std::ostream & show(Hierarchy h, std::ostream &out=std::cout)
Print the hierarchy using a given decorator to display each node.
std::string get_absolute_path(std::string file)
Convert a possibly relative path to an absolute path.
std::string get_executable_name()
Return the name of the current executable.
void set_log_level(LogLevel l)
Set the current global log level.
unsigned int get_number_of_threads()
float get_random_float_uniform()
Return a uniformly distributed float number in range [0..1)
def deprecated_object
Python decorator to mark a class as deprecated.
ParticlesTemp get_input_particles(const ModelObjectsTemp &mos)
Return all the input particles for a given ModelObject.
void set_show_leaked_objects(bool tf)
Set whether to complain about objects not being properly cleaned up.
bool get_deprecation_exceptions()
Get whether an exception is thrown when a deprecated method is used.
void set_log_timer(bool tb)
Set whether log messages are tagged with the current log time.
void show_restraint_hierarchy(ScoringFunctionAdaptor rs, std::ostream &out=std::cout)
Print the hierarchy of restraints.
DependencyGraph get_pruned_dependency_graph(Model *m)
std::string get_example_path(std::string file_name)
Return the full path to one of this module's example files.
Array< 2, WeakPointer< Particle >, Particle * > ParticlePair
Key< 5 > IntsKey
The type used to identify int attributes in the Particles.
Restraints create_restraints(RMF::FileConstHandle fh, Model *m)
std::string show_graphviz(Graph g)
std::string get_string_flag(std::string name)
networkx::DiGraph get_networkx_graph(Graph g)
double get_random_double_uniform()
Return a uniformly distributed double number in range [0..1)
Key< 8 > ModelKey
The type used to identify data stored directly in the model.
void show_altgraph(Graph g)
void setup_from_argv(int argc, char **argv, std::string description)
Parse the command line flags and return the positional arguments.
void add_bool_flag(std::string name, std::string description)
ParticleIndexes get_indexes(const ParticlesTemp &ps)
Get the indexes from a list of particles.
void read_particles_from_buffer(const Vector< char > &buffer, const ParticlesTemp &particles, const FloatKeys &keys)
load found attributes into the particles
void set_number_of_threads(unsigned int n)
double get_float_flag(std::string name)
void set_check_level(CheckLevel tf)
Control runtime checks in the code.
ScoreStatesTemp get_update_order(ScoreStatesTemp input)
std::string get_module_version()
Return the version of this module, as a string.
std::string create_temporary_file_name(std::string prefix="imp_temp", std::string suffix="")
Create a temporary file.