10 from __future__
import print_function, division, absolute_import
15 from sys
import version_info
as _swig_python_version_info
16 if _swig_python_version_info >= (2, 7, 0):
17 def swig_import_helper():
19 pkg = __name__.rpartition(
'.')[0]
20 mname =
'.'.join((pkg,
'_IMP_kernel')).lstrip(
'.')
22 return importlib.import_module(mname)
24 return importlib.import_module(
'_IMP_kernel')
25 _IMP_kernel = swig_import_helper()
26 del swig_import_helper
27 elif _swig_python_version_info >= (2, 6, 0):
28 def swig_import_helper():
29 from os.path
import dirname
33 fp, pathname, description = imp.find_module(
'_IMP_kernel', [dirname(__file__)])
39 _mod = imp.load_module(
'_IMP_kernel', fp, pathname, description)
43 _IMP_kernel = swig_import_helper()
44 del swig_import_helper
47 del _swig_python_version_info
49 _swig_property = property
54 import builtins
as __builtin__
58 def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
59 if (name ==
"thisown"):
60 return self.this.own(value)
62 if type(value).__name__ ==
'SwigPyObject':
63 self.__dict__[name] = value
65 method = class_type.__swig_setmethods__.get(name,
None)
67 return method(self, value)
69 object.__setattr__(self, name, value)
71 raise AttributeError(
"You cannot add attributes to %s" % self)
74 def _swig_setattr(self, class_type, name, value):
75 return _swig_setattr_nondynamic(self, class_type, name, value, 0)
78 def _swig_getattr(self, class_type, name):
79 if (name ==
"thisown"):
80 return self.this.own()
81 method = class_type.__swig_getmethods__.get(name,
None)
84 raise AttributeError(
"'%s' object has no attribute '%s'" % (class_type.__name__, name))
89 strthis =
"proxy of " + self.this.__repr__()
90 except __builtin__.Exception:
92 return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
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
109 except __builtin__.Exception:
110 weakref_proxy =
lambda x: x
113 class IMP_KERNEL_SwigPyIterator(object):
114 """Proxy of C++ swig::IMP_KERNEL_SwigPyIterator class."""
116 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
118 def __init__(self, *args, **kwargs):
119 raise AttributeError(
"No constructor defined - class is abstract")
120 __repr__ = _swig_repr
121 __swig_destroy__ = _IMP_kernel.delete_IMP_KERNEL_SwigPyIterator
122 __del__ =
lambda self:
None
125 """value(IMP_KERNEL_SwigPyIterator self) -> PyObject *"""
126 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_value(self)
131 incr(IMP_KERNEL_SwigPyIterator self, size_t n=1) -> IMP_KERNEL_SwigPyIterator
132 incr(IMP_KERNEL_SwigPyIterator self) -> IMP_KERNEL_SwigPyIterator
134 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_incr(self, n)
139 decr(IMP_KERNEL_SwigPyIterator self, size_t n=1) -> IMP_KERNEL_SwigPyIterator
140 decr(IMP_KERNEL_SwigPyIterator self) -> IMP_KERNEL_SwigPyIterator
142 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_decr(self, n)
145 def distance(self, x):
146 """distance(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> ptrdiff_t"""
147 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_distance(self, x)
151 """equal(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> bool"""
152 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_equal(self, x)
156 """copy(IMP_KERNEL_SwigPyIterator self) -> IMP_KERNEL_SwigPyIterator"""
157 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_copy(self)
161 """next(IMP_KERNEL_SwigPyIterator self) -> PyObject *"""
162 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_next(self)
166 """__next__(IMP_KERNEL_SwigPyIterator self) -> PyObject *"""
167 return _IMP_kernel.IMP_KERNEL_SwigPyIterator___next__(self)
171 """previous(IMP_KERNEL_SwigPyIterator self) -> PyObject *"""
172 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_previous(self)
175 def advance(self, n):
176 """advance(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator"""
177 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_advance(self, n)
181 """__eq__(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> bool"""
182 return _IMP_kernel.IMP_KERNEL_SwigPyIterator___eq__(self, x)
186 """__ne__(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> bool"""
187 return _IMP_kernel.IMP_KERNEL_SwigPyIterator___ne__(self, x)
190 def __iadd__(self, n):
191 """__iadd__(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator"""
192 return _IMP_kernel.IMP_KERNEL_SwigPyIterator___iadd__(self, n)
195 def __isub__(self, n):
196 """__isub__(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator"""
197 return _IMP_kernel.IMP_KERNEL_SwigPyIterator___isub__(self, n)
200 def __add__(self, n):
201 """__add__(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator"""
202 return _IMP_kernel.IMP_KERNEL_SwigPyIterator___add__(self, n)
205 def __sub__(self, *args):
207 __sub__(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator
208 __sub__(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> ptrdiff_t
210 return _IMP_kernel.IMP_KERNEL_SwigPyIterator___sub__(self, *args)
214 IMP_KERNEL_SwigPyIterator_swigregister = _IMP_kernel.IMP_KERNEL_SwigPyIterator_swigregister
215 IMP_KERNEL_SwigPyIterator_swigregister(IMP_KERNEL_SwigPyIterator)
223 IMP_DEBUG = _IMP_kernel.IMP_DEBUG
224 IMP_RELEASE = _IMP_kernel.IMP_RELEASE
225 IMP_SILENT = _IMP_kernel.IMP_SILENT
226 IMP_PROGRESS = _IMP_kernel.IMP_PROGRESS
227 IMP_TERSE = _IMP_kernel.IMP_TERSE
228 IMP_VERBOSE = _IMP_kernel.IMP_VERBOSE
229 IMP_MEMORY = _IMP_kernel.IMP_MEMORY
230 IMP_NONE = _IMP_kernel.IMP_NONE
231 IMP_USAGE = _IMP_kernel.IMP_USAGE
232 IMP_INTERNAL = _IMP_kernel.IMP_INTERNAL
233 IMP_KERNEL_HAS_LOG4CXX = _IMP_kernel.IMP_KERNEL_HAS_LOG4CXX
234 IMP_COMPILER_HAS_AUTO = _IMP_kernel.IMP_COMPILER_HAS_AUTO
235 IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_kernel.IMP_COMPILER_HAS_DEBUG_VECTOR
236 IMP_COMPILER_HAS_UNIQUE_PTR = _IMP_kernel.IMP_COMPILER_HAS_UNIQUE_PTR
237 IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_kernel.IMP_KERNEL_HAS_BOOST_RANDOM
238 IMP_KERNEL_HAS_GPERFTOOLS = _IMP_kernel.IMP_KERNEL_HAS_GPERFTOOLS
239 IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER = _IMP_kernel.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER
240 IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER = _IMP_kernel.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER
241 IMPKERNEL_SHOW_WARNINGS = _IMP_kernel.IMPKERNEL_SHOW_WARNINGS
244 class _DirectorObjects(object):
245 """@internal Simple class to keep references to director objects
246 to prevent premature deletion."""
249 def register(self, obj):
250 """Take a reference to a director object; will only work for
251 refcounted C++ classes"""
252 if hasattr(obj,
'get_ref_count'):
253 self._objects.append(obj)
255 """Only drop our reference and allow cleanup by Python if no other
256 Python references exist (we hold 3 references: one in self._objects,
257 one in x, and one in the argument list for getrefcount) *and* no
258 other C++ references exist (the Python object always holds one)"""
259 objs = [x
for x
in self._objects
if sys.getrefcount(x) > 3 \
260 or x.get_ref_count() > 1]
264 def get_object_count(self):
265 """Get number of director objects (useful for testing only)"""
266 return len(self._objects)
267 _director_objects = _DirectorObjects()
269 DEFAULT_CHECK = _IMP_kernel.DEFAULT_CHECK
270 NONE = _IMP_kernel.NONE
271 USAGE = _IMP_kernel.USAGE
272 USAGE_AND_INTERNAL = _IMP_kernel.USAGE_AND_INTERNAL
275 """set_check_level(IMP::CheckLevel tf)"""
276 return _IMP_kernel.set_check_level(tf)
279 """get_check_level() -> IMP::CheckLevel"""
280 return _IMP_kernel.get_check_level()
282 from _IMP_kernel
import Exception, InternalException, ModelException, EventException
283 from _IMP_kernel
import UsageException, IndexException, IOException, ValueException
284 from _IMP_kernel
import TypeException
286 class _ostream(object):
287 """Proxy of C++ std::ostream class."""
289 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
291 def __init__(self, *args, **kwargs):
292 raise AttributeError(
"No constructor defined")
293 __repr__ = _swig_repr
295 def write(self, osa_buf):
296 """write(_ostream self, char const * osa_buf)"""
297 return _IMP_kernel._ostream_write(self, osa_buf)
299 _ostream_swigregister = _IMP_kernel._ostream_swigregister
300 _ostream_swigregister(_ostream)
302 IMP_COMPILER_HAS_OVERRIDE = _IMP_kernel.IMP_COMPILER_HAS_OVERRIDE
303 IMP_COMPILER_HAS_FINAL = _IMP_kernel.IMP_COMPILER_HAS_FINAL
304 IMP_HAS_NOEXCEPT = _IMP_kernel.IMP_HAS_NOEXCEPT
306 _raii_types.append(
"SetLogState")
309 _raii_types.append(
"SetNumberOfThreads")
312 _raii_types.append(
"SetCheckState")
315 _object_types.append(
"Object")
318 def _object_cast_to_Object(o):
319 """_object_cast_to_Object(Object * o) -> Object"""
320 return _IMP_kernel._object_cast_to_Object(o)
322 _object_types.append(
"_TestObject")
325 def _object_cast_to__TestObject(o):
326 """_object_cast_to__TestObject(Object * o) -> _TestObject"""
327 return _IMP_kernel._object_cast_to__TestObject(o)
330 _plural_types.append(
"VersionInfos")
331 _value_types.append(
"VersionInfo")
334 _raii_types.append(
"CreateLogContext")
337 _raii_types.append(
"WarningContext")
340 _raii_types.append(
"SetLogTarget")
344 _plural_types.append(
"_TestValues")
345 _value_types.append(
"_TestValue")
349 _plural_types.append(
"Floats")
350 _value_types.append(
"Float")
354 _plural_types.append(
"Ints")
355 _value_types.append(
"Int")
359 _plural_types.append(
"Strings")
360 _value_types.append(
"String")
364 _plural_types.append(
"_Protections")
365 _value_types.append(
"_Protection")
367 class _InputAdaptor(object):
368 """Proxy of C++ IMP::InputAdaptor class."""
370 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
372 def __init__(self, *args, **kwargs):
373 raise AttributeError(
"No constructor defined")
374 __repr__ = _swig_repr
375 __swig_destroy__ = _IMP_kernel.delete__InputAdaptor
376 __del__ =
lambda self:
None
377 _InputAdaptor_swigregister = _IMP_kernel._InputAdaptor_swigregister
378 _InputAdaptor_swigregister(_InputAdaptor)
380 class _NonCopyable(object):
381 """Proxy of C++ IMP::NonCopyable class."""
383 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
385 def __init__(self, *args, **kwargs):
386 raise AttributeError(
"No constructor defined")
387 __repr__ = _swig_repr
388 __swig_destroy__ = _IMP_kernel.delete__NonCopyable
389 __del__ =
lambda self:
None
390 _NonCopyable_swigregister = _IMP_kernel._NonCopyable_swigregister
391 _NonCopyable_swigregister(_NonCopyable)
393 class _RAII(_NonCopyable):
394 """Proxy of C++ IMP::RAII class."""
396 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
398 def __init__(self, *args, **kwargs):
399 raise AttributeError(
"No constructor defined")
400 __repr__ = _swig_repr
401 __swig_destroy__ = _IMP_kernel.delete__RAII
402 __del__ =
lambda self:
None
403 _RAII_swigregister = _IMP_kernel._RAII_swigregister
404 _RAII_swigregister(_RAII)
406 class _Value(object):
407 """Proxy of C++ IMP::Value class."""
409 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
411 def __init__(self, *args, **kwargs):
412 raise AttributeError(
"No constructor defined")
413 __repr__ = _swig_repr
414 __swig_destroy__ = _IMP_kernel.delete__Value
415 __del__ =
lambda self:
None
416 _Value_swigregister = _IMP_kernel._Value_swigregister
417 _Value_swigregister(_Value)
421 """get_executable_name() -> std::string"""
422 return _IMP_kernel.get_executable_name()
426 setup_from_argv(IMP::Strings const & argv, std::string description)
427 setup_from_argv(IMP::Strings const & argv, std::string description, std::string positional_description, int num_positional) -> IMP::Strings
429 return _IMP_kernel.setup_from_argv(*args)
432 """add_string_flag(std::string name, std::string default_value, std::string description)"""
433 return _IMP_kernel.add_string_flag(name, default_value, description)
436 """get_string_flag(std::string name) -> std::string"""
437 return _IMP_kernel.get_string_flag(name)
440 """add_int_flag(std::string name, size_t default_value, std::string description)"""
441 return _IMP_kernel.add_int_flag(name, default_value, description)
444 """get_int_flag(std::string name) -> size_t"""
445 return _IMP_kernel.get_int_flag(name)
448 """add_bool_flag(std::string name, std::string description)"""
449 return _IMP_kernel.add_bool_flag(name, description)
452 """get_bool_flag(std::string name) -> bool"""
453 return _IMP_kernel.get_bool_flag(name)
456 """add_float_flag(std::string name, double default_value, std::string description)"""
457 return _IMP_kernel.add_float_flag(name, default_value, description)
460 """get_float_flag(std::string name) -> double"""
461 return _IMP_kernel.get_float_flag(name)
465 write_help(_ostream out)
468 return _IMP_kernel.write_help(*args)
471 """get_is_quick_test() -> bool"""
472 return _IMP_kernel.get_is_quick_test()
473 DEFAULT = _IMP_kernel.DEFAULT
474 SILENT = _IMP_kernel.SILENT
475 WARNING = _IMP_kernel.WARNING
476 PROGRESS = _IMP_kernel.PROGRESS
477 TERSE = _IMP_kernel.TERSE
478 VERBOSE = _IMP_kernel.VERBOSE
479 MEMORY = _IMP_kernel.MEMORY
480 ALL_LOG = _IMP_kernel.ALL_LOG
481 NO_STATISTICS = _IMP_kernel.NO_STATISTICS
482 ALL_STATISTICS = _IMP_kernel.ALL_STATISTICS
483 class VersionInfo(_Value):
484 """Proxy of C++ IMP::VersionInfo class."""
486 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
488 def __init__(self, *args):
490 __init__(IMP::VersionInfo self, std::string module, std::string version) -> VersionInfo
491 __init__(IMP::VersionInfo self) -> VersionInfo
493 this = _IMP_kernel.new_VersionInfo(*args)
495 self.this.append(this)
496 except __builtin__.Exception:
499 def get_module(self):
500 """get_module(VersionInfo self) -> std::string"""
501 return _IMP_kernel.VersionInfo_get_module(self)
504 def get_version(self):
505 """get_version(VersionInfo self) -> std::string"""
506 return _IMP_kernel.VersionInfo_get_version(self)
509 def show(self, *args):
511 show(VersionInfo self, _ostream out)
512 show(VersionInfo self)
514 return _IMP_kernel.VersionInfo_show(self, *args)
517 def __cmp__(self, o):
518 """__cmp__(VersionInfo self, VersionInfo o) -> int"""
519 return _IMP_kernel.VersionInfo___cmp__(self, o)
523 """__eq__(VersionInfo self, VersionInfo o) -> bool"""
524 return _IMP_kernel.VersionInfo___eq__(self, o)
528 """__ne__(VersionInfo self, VersionInfo o) -> bool"""
529 return _IMP_kernel.VersionInfo___ne__(self, o)
533 """__lt__(VersionInfo self, VersionInfo o) -> bool"""
534 return _IMP_kernel.VersionInfo___lt__(self, o)
538 """__gt__(VersionInfo self, VersionInfo o) -> bool"""
539 return _IMP_kernel.VersionInfo___gt__(self, o)
543 """__ge__(VersionInfo self, VersionInfo o) -> bool"""
544 return _IMP_kernel.VersionInfo___ge__(self, o)
548 """__le__(VersionInfo self, VersionInfo o) -> bool"""
549 return _IMP_kernel.VersionInfo___le__(self, o)
553 """__str__(VersionInfo self) -> std::string"""
554 return _IMP_kernel.VersionInfo___str__(self)
558 """__repr__(VersionInfo self) -> std::string"""
559 return _IMP_kernel.VersionInfo___repr__(self)
561 __swig_destroy__ = _IMP_kernel.delete_VersionInfo
562 __del__ =
lambda self:
None
563 VersionInfo_swigregister = _IMP_kernel.VersionInfo_swigregister
564 VersionInfo_swigregister(VersionInfo)
566 class TextOutput(_InputAdaptor):
567 """Proxy of C++ IMP::TextOutput class."""
569 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
570 __repr__ = _swig_repr
572 def __init__(self, *args):
574 __init__(IMP::TextOutput self, int arg2) -> TextOutput
575 __init__(IMP::TextOutput self, double arg2) -> TextOutput
576 __init__(IMP::TextOutput self, char const * c, bool append=False) -> TextOutput
577 __init__(IMP::TextOutput self, char const * c) -> TextOutput
578 __init__(IMP::TextOutput self, IMP::TextProxy< std::ostream > p) -> TextOutput
579 __init__(IMP::TextOutput self) -> TextOutput
580 __init__(IMP::TextOutput self, std::string file_name, bool append=False) -> TextOutput
581 __init__(IMP::TextOutput self, std::string file_name) -> TextOutput
583 this = _IMP_kernel.new_TextOutput(*args)
585 self.this.append(this)
586 except __builtin__.Exception:
589 def show(self, *args):
591 show(TextOutput self, _ostream out)
592 show(TextOutput self)
594 return _IMP_kernel.TextOutput_show(self, *args)
598 """get_name(TextOutput self) -> std::string"""
599 return _IMP_kernel.TextOutput_get_name(self)
601 __swig_destroy__ = _IMP_kernel.delete_TextOutput
602 __del__ =
lambda self:
None
603 TextOutput_swigregister = _IMP_kernel.TextOutput_swigregister
604 TextOutput_swigregister(TextOutput)
606 class TextInput(_InputAdaptor):
607 """Proxy of C++ IMP::TextInput class."""
609 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
610 __repr__ = _swig_repr
612 def __init__(self, *args):
614 __init__(IMP::TextInput self, int arg2) -> TextInput
615 __init__(IMP::TextInput self, double arg2) -> TextInput
616 __init__(IMP::TextInput self, char const * c) -> TextInput
617 __init__(IMP::TextInput self, IMP::TextProxy< std::istream > p) -> TextInput
618 __init__(IMP::TextInput self) -> TextInput
619 __init__(IMP::TextInput self, std::string file_name) -> TextInput
621 this = _IMP_kernel.new_TextInput(*args)
623 self.this.append(this)
624 except __builtin__.Exception:
627 def show(self, *args):
629 show(TextInput self, _ostream out)
632 return _IMP_kernel.TextInput_show(self, *args)
636 """get_name(TextInput self) -> std::string"""
637 return _IMP_kernel.TextInput_get_name(self)
639 __swig_destroy__ = _IMP_kernel.delete_TextInput
640 __del__ =
lambda self:
None
641 TextInput_swigregister = _IMP_kernel.TextInput_swigregister
642 TextInput_swigregister(TextInput)
644 class SetLogTarget(_RAII):
645 """Proxy of C++ IMP::SetLogTarget class."""
647 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
649 def __init__(self, *args):
651 __init__(IMP::SetLogTarget self) -> SetLogTarget
652 __init__(IMP::SetLogTarget self, TextOutput to) -> SetLogTarget
654 this = _IMP_kernel.new_SetLogTarget(*args)
656 self.this.append(this)
657 except __builtin__.Exception:
661 """set(SetLogTarget self, TextOutput to)"""
662 return _IMP_kernel.SetLogTarget_set(self, to)
666 """reset(SetLogTarget self)"""
667 return _IMP_kernel.SetLogTarget_reset(self)
669 __swig_destroy__ = _IMP_kernel.delete_SetLogTarget
670 __del__ =
lambda self:
None
672 def show(self, *args):
674 show(SetLogTarget self, _ostream out)
675 show(SetLogTarget self)
677 return _IMP_kernel.SetLogTarget_show(self, *args)
682 def __exit__(self, exc_type, exc_val, exc_tb):
688 """__str__(SetLogTarget self) -> std::string"""
689 return _IMP_kernel.SetLogTarget___str__(self)
693 """__repr__(SetLogTarget self) -> std::string"""
694 return _IMP_kernel.SetLogTarget___repr__(self)
696 SetLogTarget_swigregister = _IMP_kernel.SetLogTarget_swigregister
697 SetLogTarget_swigregister(SetLogTarget)
702 create_temporary_file(std::string prefix, std::string suffix) -> TextOutput
703 create_temporary_file(std::string prefix) -> TextOutput
704 create_temporary_file() -> TextOutput
706 return _IMP_kernel.create_temporary_file(*args)
710 create_temporary_file_name(std::string prefix, std::string suffix) -> std::string
711 create_temporary_file_name(std::string prefix) -> std::string
712 create_temporary_file_name() -> std::string
714 return _IMP_kernel.create_temporary_file_name(*args)
717 """get_relative_path(std::string base, std::string relative) -> std::string"""
718 return _IMP_kernel.get_relative_path(base, relative)
720 def push_log_context(functionname, object):
721 """push_log_context(char const * functionname, void const * object)"""
722 return _IMP_kernel.push_log_context(functionname, object)
724 def pop_log_context():
725 """pop_log_context()"""
726 return _IMP_kernel.pop_log_context()
730 add_to_log(std::string to_write)
731 add_to_log(IMP::LogLevel level, std::string to_write)
733 return _IMP_kernel.add_to_log(*args)
736 """set_log_level(IMP::LogLevel l)"""
737 return _IMP_kernel.set_log_level(l)
740 """set_log_timer(bool tb)"""
741 return _IMP_kernel.set_log_timer(tb)
744 """reset_log_timer()"""
745 return _IMP_kernel.reset_log_timer()
748 """get_log_level() -> IMP::LogLevel"""
749 return _IMP_kernel.get_log_level()
752 """set_progress_display(std::string description, unsigned int steps)"""
753 return _IMP_kernel.set_progress_display(description, steps)
757 add_to_progress_display(unsigned int step=1)
758 add_to_progress_display()
760 return _IMP_kernel.add_to_progress_display(step)
761 class Object(_NonCopyable):
762 """Proxy of C++ IMP::Object class."""
764 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
766 def __init__(self, name):
767 """__init__(IMP::Object self, std::string name) -> Object"""
768 if self.__class__ == Object:
772 this = _IMP_kernel.new_Object(_self, name)
774 self.this.append(this)
775 except __builtin__.Exception:
778 if self.__class__ != Object:
779 _director_objects.register(self)
783 __swig_destroy__ = _IMP_kernel.delete_Object
784 __del__ =
lambda self:
None
787 """__hash__(Object self) -> std::size_t"""
788 return _IMP_kernel.Object___hash__(self)
792 """set_log_level(Object self, IMP::LogLevel l)"""
793 return _IMP_kernel.Object_set_log_level(self, l)
797 """set_check_level(Object self, IMP::CheckLevel l)"""
798 return _IMP_kernel.Object_set_check_level(self, l)
802 """get_log_level(Object self) -> IMP::LogLevel"""
803 return _IMP_kernel.Object_get_log_level(self)
807 """get_check_level(Object self) -> IMP::CheckLevel"""
808 return _IMP_kernel.Object_get_check_level(self)
811 def get_version_info(self):
812 """get_version_info(Object self) -> VersionInfo"""
813 return _IMP_kernel.Object_get_version_info(self)
817 """get_name(Object self) -> std::string const &"""
818 return _IMP_kernel.Object_get_name(self)
821 def set_name(self, name):
822 """set_name(Object self, std::string name)"""
823 return _IMP_kernel.Object_set_name(self, name)
826 def get_type_name(self):
827 """get_type_name(Object self) -> std::string"""
828 return _IMP_kernel.Object_get_type_name(self)
831 def set_was_used(self, tf):
832 """set_was_used(Object self, bool tf)"""
833 return _IMP_kernel.Object_set_was_used(self, tf)
836 def show(self, *args):
838 show(Object self, _ostream out)
841 return _IMP_kernel.Object_show(self, *args)
844 def get_string(self):
845 """get_string(Object self) -> std::string"""
846 return _IMP_kernel.Object_get_string(self)
849 def _on_destruction(self):
850 """_on_destruction(Object self)"""
851 return _IMP_kernel.Object__on_destruction(self)
854 def get_is_valid(self):
855 """get_is_valid(Object self) -> bool"""
856 return _IMP_kernel.Object_get_is_valid(self)
859 def get_ref_count(self):
860 """get_ref_count(Object self) -> unsigned int"""
861 return _IMP_kernel.Object_get_ref_count(self)
864 def get_number_of_live_objects():
865 """get_number_of_live_objects() -> unsigned int"""
866 return _IMP_kernel.Object_get_number_of_live_objects()
868 get_number_of_live_objects = staticmethod(get_number_of_live_objects)
870 def get_is_shared(self):
871 """get_is_shared(Object self) -> bool"""
872 return _IMP_kernel.Object_get_is_shared(self)
875 def clear_caches(self):
876 """clear_caches(Object self)"""
877 return _IMP_kernel.Object_clear_caches(self)
880 def do_destroy(self):
881 """do_destroy(Object self)"""
882 return _IMP_kernel.Object_do_destroy(self)
886 """__eq__(Object self, Object o) -> bool"""
887 return _IMP_kernel.Object___eq__(self, o)
891 """__ne__(Object self, Object o) -> bool"""
892 return _IMP_kernel.Object___ne__(self, o)
896 """__le__(Object self, Object o) -> bool"""
897 return _IMP_kernel.Object___le__(self, o)
901 """__lt__(Object self, Object o) -> bool"""
902 return _IMP_kernel.Object___lt__(self, o)
906 """__ge__(Object self, Object o) -> bool"""
907 return _IMP_kernel.Object___ge__(self, o)
911 """__gt__(Object self, Object o) -> bool"""
912 return _IMP_kernel.Object___gt__(self, o)
916 """__str__(Object self) -> std::string"""
917 return _IMP_kernel.Object___str__(self)
921 """__repr__(Object self) -> std::string"""
922 return _IMP_kernel.Object___repr__(self)
927 return _object_cast_to_Object(o)
929 def __disown__(self):
931 _IMP_kernel.disown_Object(self)
932 return weakref_proxy(self)
933 Object_swigregister = _IMP_kernel.Object_swigregister
934 Object_swigregister(Object)
936 def Object_get_number_of_live_objects():
937 """Object_get_number_of_live_objects() -> unsigned int"""
938 return _IMP_kernel.Object_get_number_of_live_objects()
940 class SetLogState(_RAII):
941 """Proxy of C++ IMP::SetLogState class."""
943 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
946 """reset(SetLogState self)"""
947 return _IMP_kernel.SetLogState_reset(self)
949 __swig_destroy__ = _IMP_kernel.delete_SetLogState
950 __del__ =
lambda self:
None
952 def show(self, *args):
954 show(SetLogState self, _ostream out)
955 show(SetLogState self)
957 return _IMP_kernel.SetLogState_show(self, *args)
960 def __init__(self, *args):
962 __init__(IMP::SetLogState self) -> SetLogState
963 __init__(IMP::SetLogState self, Object o, IMP::LogLevel l) -> SetLogState
964 __init__(IMP::SetLogState self, IMP::LogLevel l) -> SetLogState
966 this = _IMP_kernel.new_SetLogState(*args)
968 self.this.append(this)
969 except __builtin__.Exception:
972 def set(self, *args):
974 set(SetLogState self, Object o, IMP::LogLevel l)
975 set(SetLogState self, IMP::LogLevel l)
977 return _IMP_kernel.SetLogState_set(self, *args)
982 def __exit__(self, exc_type, exc_val, exc_tb):
988 """__str__(SetLogState self) -> std::string"""
989 return _IMP_kernel.SetLogState___str__(self)
993 """__repr__(SetLogState self) -> std::string"""
994 return _IMP_kernel.SetLogState___repr__(self)
996 SetLogState_swigregister = _IMP_kernel.SetLogState_swigregister
997 SetLogState_swigregister(SetLogState)
999 class WarningContext(object):
1000 """Proxy of C++ IMP::WarningContext class."""
1002 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
1003 data_ = _swig_property(_IMP_kernel.WarningContext_data__get, _IMP_kernel.WarningContext_data__set)
1005 def add_warning(self, key, warning):
1006 """add_warning(WarningContext self, std::string key, std::string warning)"""
1007 return _IMP_kernel.WarningContext_add_warning(self, key, warning)
1010 def clear_warnings(self):
1011 """clear_warnings(WarningContext self)"""
1012 return _IMP_kernel.WarningContext_clear_warnings(self)
1015 def dump_warnings(self):
1016 """dump_warnings(WarningContext self)"""
1017 return _IMP_kernel.WarningContext_dump_warnings(self)
1019 __swig_destroy__ = _IMP_kernel.delete_WarningContext
1020 __del__ =
lambda self:
None
1022 def show(self, *args):
1024 show(WarningContext self, _ostream out)
1025 show(WarningContext self)
1027 return _IMP_kernel.WarningContext_show(self, *args)
1030 def __enter__(self):
1032 def __exit__(self, exc_type, exc_val, exc_tb):
1038 """__str__(WarningContext self) -> std::string"""
1039 return _IMP_kernel.WarningContext___str__(self)
1043 """__repr__(WarningContext self) -> std::string"""
1044 return _IMP_kernel.WarningContext___repr__(self)
1048 """__init__(IMP::WarningContext self) -> WarningContext"""
1049 this = _IMP_kernel.new_WarningContext()
1051 self.this.append(this)
1052 except __builtin__.Exception:
1054 WarningContext_swigregister = _IMP_kernel.WarningContext_swigregister
1055 WarningContext_swigregister(WarningContext)
1057 class CreateLogContext(_RAII):
1058 """Proxy of C++ IMP::CreateLogContext class."""
1060 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
1062 def __init__(self, *args):
1064 __init__(IMP::CreateLogContext self, std::string fname, Object object=None) -> CreateLogContext
1065 __init__(IMP::CreateLogContext self, std::string fname) -> CreateLogContext
1066 __init__(IMP::CreateLogContext self) -> CreateLogContext
1067 __init__(IMP::CreateLogContext self, char const * fname, Object object=None) -> CreateLogContext
1068 __init__(IMP::CreateLogContext self, char const * fname) -> CreateLogContext
1070 this = _IMP_kernel.new_CreateLogContext(*args)
1072 self.this.append(this)
1073 except __builtin__.Exception:
1076 def set(self, fname, object=None):
1078 set(CreateLogContext self, char const * fname, Object object=None)
1079 set(CreateLogContext self, char const * fname)
1081 return _IMP_kernel.CreateLogContext_set(self, fname, object)
1085 """reset(CreateLogContext self)"""
1086 return _IMP_kernel.CreateLogContext_reset(self)
1088 __swig_destroy__ = _IMP_kernel.delete_CreateLogContext
1089 __del__ =
lambda self:
None
1091 def show(self, *args):
1093 show(CreateLogContext self, _ostream out)
1094 show(CreateLogContext self)
1096 return _IMP_kernel.CreateLogContext_show(self, *args)
1099 def __enter__(self):
1101 def __exit__(self, exc_type, exc_val, exc_tb):
1107 """__str__(CreateLogContext self) -> std::string"""
1108 return _IMP_kernel.CreateLogContext___str__(self)
1112 """__repr__(CreateLogContext self) -> std::string"""
1113 return _IMP_kernel.CreateLogContext___repr__(self)
1115 CreateLogContext_swigregister = _IMP_kernel.CreateLogContext_swigregister
1116 CreateLogContext_swigregister(CreateLogContext)
1118 class SetCheckState(_RAII):
1119 """Proxy of C++ IMP::SetCheckState class."""
1121 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
1124 """reset(SetCheckState self)"""
1125 return _IMP_kernel.SetCheckState_reset(self)
1127 __swig_destroy__ = _IMP_kernel.delete_SetCheckState
1128 __del__ =
lambda self:
None
1130 def show(self, *args):
1132 show(SetCheckState self, _ostream out)
1133 show(SetCheckState self)
1135 return _IMP_kernel.SetCheckState_show(self, *args)
1138 def __init__(self, *args):
1140 __init__(IMP::SetCheckState self) -> SetCheckState
1141 __init__(IMP::SetCheckState self, Object o, IMP::CheckLevel l) -> SetCheckState
1142 __init__(IMP::SetCheckState self, IMP::CheckLevel l) -> SetCheckState
1144 this = _IMP_kernel.new_SetCheckState(*args)
1146 self.this.append(this)
1147 except __builtin__.Exception:
1150 def set(self, *args):
1152 set(SetCheckState self, Object o, IMP::CheckLevel l)
1153 set(SetCheckState self, IMP::CheckLevel l)
1155 return _IMP_kernel.SetCheckState_set(self, *args)
1158 def __enter__(self):
1160 def __exit__(self, exc_type, exc_val, exc_tb):
1166 """__str__(SetCheckState self) -> std::string"""
1167 return _IMP_kernel.SetCheckState___str__(self)
1171 """__repr__(SetCheckState self) -> std::string"""
1172 return _IMP_kernel.SetCheckState___repr__(self)
1174 SetCheckState_swigregister = _IMP_kernel.SetCheckState_swigregister
1175 SetCheckState_swigregister(SetCheckState)
1179 """get_unique_name(std::string templ) -> std::string"""
1180 return _IMP_kernel.get_unique_name(templ)
1181 class _Protection(object):
1182 """Proxy of C++ IMP::internal::_Protection class."""
1184 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
1186 def __init__(self, *args, **kwargs):
1187 raise AttributeError(
"No constructor defined")
1189 def show(self, *args):
1191 show(_Protection self, _ostream out)
1192 show(_Protection self)
1194 return _IMP_kernel._Protection_show(self, *args)
1198 """__str__(_Protection self) -> std::string"""
1199 return _IMP_kernel._Protection___str__(self)
1203 """__repr__(_Protection self) -> std::string"""
1204 return _IMP_kernel._Protection___repr__(self)
1206 __swig_destroy__ = _IMP_kernel.delete__Protection
1207 __del__ =
lambda self:
None
1208 _Protection_swigregister = _IMP_kernel._Protection_swigregister
1209 _Protection_swigregister(_Protection)
1214 return _IMP_kernel._test_log()
1216 def _test_intranges(ips):
1217 """_test_intranges(IMP::IntRanges const & ips) -> int"""
1218 return _IMP_kernel._test_intranges(ips)
1220 def _test_intrange(*args):
1222 _test_intrange(IMP::IntRange const & ips) -> IMP::IntRange
1223 _test_intrange() -> IMP::IntRange
1225 return _IMP_kernel._test_intrange(*args)
1228 """_test_ifile(TextInput a) -> std::string"""
1229 return _IMP_kernel._test_ifile(a)
1232 """_test_ofile(TextOutput a) -> std::string"""
1233 return _IMP_kernel._test_ofile(a)
1235 def _test_ifile_overloaded(*args):
1237 _test_ifile_overloaded(TextInput a, int i) -> std::string
1238 _test_ifile_overloaded(TextInput a, std::string st) -> std::string
1240 return _IMP_kernel._test_ifile_overloaded(*args)
1242 def _test_ofile_overloaded(*args):
1244 _test_ofile_overloaded(TextOutput a, int i) -> std::string
1245 _test_ofile_overloaded(TextOutput a, std::string st) -> std::string
1247 return _IMP_kernel._test_ofile_overloaded(*args)
1248 class _TestValue(object):
1249 """Proxy of C++ IMP::internal::_TestValue class."""
1251 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
1253 def __init__(self, i):
1254 """__init__(IMP::internal::_TestValue self, int i) -> _TestValue"""
1255 this = _IMP_kernel.new__TestValue(i)
1257 self.this.append(this)
1258 except __builtin__.Exception:
1261 def show(self, *args):
1263 show(_TestValue self, _ostream out)
1264 show(_TestValue self)
1266 return _IMP_kernel._TestValue_show(self, *args)
1269 def __cmp__(self, o):
1270 """__cmp__(_TestValue self, _TestValue o) -> int"""
1271 return _IMP_kernel._TestValue___cmp__(self, o)
1274 def __eq__(self, o):
1275 """__eq__(_TestValue self, _TestValue o) -> bool"""
1276 return _IMP_kernel._TestValue___eq__(self, o)
1279 def __ne__(self, o):
1280 """__ne__(_TestValue self, _TestValue o) -> bool"""
1281 return _IMP_kernel._TestValue___ne__(self, o)
1284 def __lt__(self, o):
1285 """__lt__(_TestValue self, _TestValue o) -> bool"""
1286 return _IMP_kernel._TestValue___lt__(self, o)
1289 def __gt__(self, o):
1290 """__gt__(_TestValue self, _TestValue o) -> bool"""
1291 return _IMP_kernel._TestValue___gt__(self, o)
1294 def __ge__(self, o):
1295 """__ge__(_TestValue self, _TestValue o) -> bool"""
1296 return _IMP_kernel._TestValue___ge__(self, o)
1299 def __le__(self, o):
1300 """__le__(_TestValue self, _TestValue o) -> bool"""
1301 return _IMP_kernel._TestValue___le__(self, o)
1305 """get(_TestValue self) -> int"""
1306 return _IMP_kernel._TestValue_get(self)
1309 def get_float(self):
1310 """get_float(_TestValue self) -> float const &"""
1311 return _IMP_kernel._TestValue_get_float(self)
1314 def get_double(self):
1315 """get_double(_TestValue self) -> double const &"""
1316 return _IMP_kernel._TestValue_get_double(self)
1319 def get_Float(self):
1320 """get_Float(_TestValue self) -> IMP::Float const &"""
1321 return _IMP_kernel._TestValue_get_Float(self)
1325 """get_int(_TestValue self) -> int const &"""
1326 return _IMP_kernel._TestValue_get_int(self)
1330 """get_Int(_TestValue self) -> IMP::Int const &"""
1331 return _IMP_kernel._TestValue_get_Int(self)
1334 def get_string(self):
1335 """get_string(_TestValue self) -> std::string const &"""
1336 return _IMP_kernel._TestValue_get_string(self)
1339 def get_String(self):
1340 """get_String(_TestValue self) -> IMP::String const &"""
1341 return _IMP_kernel._TestValue_get_String(self)
1345 """__str__(_TestValue self) -> std::string"""
1346 return _IMP_kernel._TestValue___str__(self)
1350 """__repr__(_TestValue self) -> std::string"""
1351 return _IMP_kernel._TestValue___repr__(self)
1353 __swig_destroy__ = _IMP_kernel.delete__TestValue
1354 __del__ =
lambda self:
None
1355 _TestValue_swigregister = _IMP_kernel._TestValue_swigregister
1356 _TestValue_swigregister(_TestValue)
1359 def _pass_plain_pair(p):
1360 """_pass_plain_pair(IMP::FloatPair p) -> IMP::FloatPair"""
1361 return _IMP_kernel._pass_plain_pair(p)
1363 def _pass_overloaded_strings(*args):
1365 _pass_overloaded_strings(IMP::Strings const & a, int arg2) -> IMP::Strings
1366 _pass_overloaded_strings(IMP::Strings const & a) -> IMP::Strings
1368 return _IMP_kernel._pass_overloaded_strings(*args)
1371 """_pass_pair(IMP::DerivativePair const & p) -> IMP::DerivativePair"""
1372 return _IMP_kernel._pass_pair(p)
1374 def _pass_floats(input):
1375 """_pass_floats(IMP::Floats const & input) -> IMP::Floats"""
1376 return _IMP_kernel._pass_floats(input)
1378 def _pass_ints(input):
1379 """_pass_ints(IMP::Ints input) -> IMP::Ints"""
1380 return _IMP_kernel._pass_ints(input)
1382 def _pass_ints_list(input):
1383 """_pass_ints_list(IMP::IntsList const & input) -> IMP::IntsList"""
1384 return _IMP_kernel._pass_ints_list(input)
1386 def _pass_ints_lists(input):
1387 """_pass_ints_lists(IMP::IntsLists const & input) -> IMP::IntsLists"""
1388 return _IMP_kernel._pass_ints_lists(input)
1390 def _pass_strings(input):
1391 """_pass_strings(IMP::Strings const & input) -> IMP::Strings const &"""
1392 return _IMP_kernel._pass_strings(input)
1393 class _TestObject(Object):
1394 """Proxy of C++ IMP::internal::_TestObject class."""
1396 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
1399 """__init__(IMP::internal::_TestObject self) -> _TestObject"""
1400 this = _IMP_kernel.new__TestObject()
1402 self.this.append(this)
1403 except __builtin__.Exception:
1406 def get_version_info(self):
1407 """get_version_info(_TestObject self) -> VersionInfo"""
1408 return _IMP_kernel._TestObject_get_version_info(self)
1412 """__str__(_TestObject self) -> std::string"""
1413 return _IMP_kernel._TestObject___str__(self)
1417 """__repr__(_TestObject self) -> std::string"""
1418 return _IMP_kernel._TestObject___repr__(self)
1423 return _object_cast_to__TestObject(o)
1425 _TestObject_swigregister = _IMP_kernel._TestObject_swigregister
1426 _TestObject_swigregister(_TestObject)
1430 """get_live_object_names() -> IMP::Strings"""
1431 return _IMP_kernel.get_live_object_names()
1434 """get_live_objects() -> IMP::Objects"""
1435 return _IMP_kernel.get_live_objects()
1438 """set_show_leaked_objects(bool tf)"""
1439 return _IMP_kernel.set_show_leaked_objects(tf)
1442 """set_deprecation_warnings(bool tf)"""
1443 return _IMP_kernel.set_deprecation_warnings(tf)
1446 """set_deprecation_exceptions(bool tf)"""
1447 return _IMP_kernel.set_deprecation_exceptions(tf)
1450 """get_deprecation_exceptions() -> bool"""
1451 return _IMP_kernel.get_deprecation_exceptions()
1454 """handle_use_deprecated(std::string message)"""
1455 return _IMP_kernel.handle_use_deprecated(message)
1458 """get_number_of_threads() -> unsigned int"""
1459 return _IMP_kernel.get_number_of_threads()
1462 """set_number_of_threads(unsigned int n)"""
1463 return _IMP_kernel.set_number_of_threads(n)
1464 class SetNumberOfThreads(_RAII):
1465 """Proxy of C++ IMP::SetNumberOfThreads class."""
1467 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
1469 def __init__(self, *args):
1471 __init__(IMP::SetNumberOfThreads self) -> SetNumberOfThreads
1472 __init__(IMP::SetNumberOfThreads self, unsigned int n) -> SetNumberOfThreads
1474 this = _IMP_kernel.new_SetNumberOfThreads(*args)
1476 self.this.append(this)
1477 except __builtin__.Exception:
1481 """set(SetNumberOfThreads self, unsigned int n)"""
1482 return _IMP_kernel.SetNumberOfThreads_set(self, n)
1486 """reset(SetNumberOfThreads self)"""
1487 return _IMP_kernel.SetNumberOfThreads_reset(self)
1489 __swig_destroy__ = _IMP_kernel.delete_SetNumberOfThreads
1490 __del__ =
lambda self:
None
1492 def show(self, *args):
1494 show(SetNumberOfThreads self, _ostream out)
1495 show(SetNumberOfThreads self)
1497 return _IMP_kernel.SetNumberOfThreads_show(self, *args)
1500 def __enter__(self):
1502 def __exit__(self, exc_type, exc_val, exc_tb):
1508 """__str__(SetNumberOfThreads self) -> std::string"""
1509 return _IMP_kernel.SetNumberOfThreads___str__(self)
1513 """__repr__(SetNumberOfThreads self) -> std::string"""
1514 return _IMP_kernel.SetNumberOfThreads___repr__(self)
1516 SetNumberOfThreads_swigregister = _IMP_kernel.SetNumberOfThreads_swigregister
1517 SetNumberOfThreads_swigregister(SetNumberOfThreads)
1520 def clear_statistics():
1521 """clear_statistics()"""
1522 return _IMP_kernel.clear_statistics()
1524 def show_timings(out):
1525 """show_timings(TextOutput out)"""
1526 return _IMP_kernel.show_timings(out)
1528 """Proxy of C++ IMP::Timer class."""
1530 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
1531 __repr__ = _swig_repr
1533 def __init__(self, *args):
1535 __init__(IMP::Timer self, Object object, std::string const & operation) -> Timer
1536 __init__(IMP::Timer self, Object object, char const * operation) -> Timer
1537 __init__(IMP::Timer self, std::string operation) -> Timer
1539 this = _IMP_kernel.new_Timer(*args)
1541 self.this.append(this)
1542 except __builtin__.Exception:
1544 __swig_destroy__ = _IMP_kernel.delete_Timer
1545 __del__ =
lambda self:
None
1546 Timer_swigregister = _IMP_kernel.Timer_swigregister
1547 Timer_swigregister(Timer)
1550 def set_statistics_level(l):
1551 """set_statistics_level(IMP::StatisticsLevel l)"""
1552 return _IMP_kernel.set_statistics_level(l)
1555 i_m_p=
"IMP_MODULE_PATH"
1556 if i_m_p
in os.environ.keys():
1557 __path__.insert(0, os.environ[i_m_p])
1559 def _forward_add_attribute(self, name, value, opt=None):
1561 self.get_particle().add_attribute(name, value, opt)
1563 self.get_particle().add_attribute(name, value)
1564 def _forward_get_value(self, name):
1565 self.get_particle().get_value(name)
1566 def _forward_set_value(self, name, value):
1567 self.get_particle().set_value(name, value)
1573 _object_types.append(
"Constraint")
1576 def _object_cast_to_Constraint(o):
1577 """_object_cast_to_Constraint(Object o) -> Constraint"""
1578 return _IMP_kernel._object_cast_to_Constraint(o)
1580 _object_types.append(
"Undecorator")
1583 def _object_cast_to_Undecorator(o):
1584 """_object_cast_to_Undecorator(Object o) -> Undecorator"""
1585 return _IMP_kernel._object_cast_to_Undecorator(o)
1587 _object_types.append(
"Container")
1590 def _object_cast_to_Container(o):
1591 """_object_cast_to_Container(Object o) -> Container"""
1592 return _IMP_kernel._object_cast_to_Container(o)
1594 _object_types.append(
"Optimizer")
1597 def _object_cast_to_Optimizer(o):
1598 """_object_cast_to_Optimizer(Object o) -> Optimizer"""
1599 return _IMP_kernel._object_cast_to_Optimizer(o)
1601 _object_types.append(
"AttributeOptimizer")
1604 def _object_cast_to_AttributeOptimizer(o):
1605 """_object_cast_to_AttributeOptimizer(Object o) -> AttributeOptimizer"""
1606 return _IMP_kernel._object_cast_to_AttributeOptimizer(o)
1608 _object_types.append(
"OptimizerState")
1611 def _object_cast_to_OptimizerState(o):
1612 """_object_cast_to_OptimizerState(Object o) -> OptimizerState"""
1613 return _IMP_kernel._object_cast_to_OptimizerState(o)
1615 _object_types.append(
"PairContainer")
1618 def _object_cast_to_PairContainer(o):
1619 """_object_cast_to_PairContainer(Object o) -> PairContainer"""
1620 return _IMP_kernel._object_cast_to_PairContainer(o)
1622 _object_types.append(
"PairModifier")
1625 def _object_cast_to_PairModifier(o):
1626 """_object_cast_to_PairModifier(Object o) -> PairModifier"""
1627 return _IMP_kernel._object_cast_to_PairModifier(o)
1629 _object_types.append(
"PairScore")
1632 def _object_cast_to_PairScore(o):
1633 """_object_cast_to_PairScore(Object o) -> PairScore"""
1634 return _IMP_kernel._object_cast_to_PairScore(o)
1636 _object_types.append(
"QuadContainer")
1639 def _object_cast_to_QuadContainer(o):
1640 """_object_cast_to_QuadContainer(Object o) -> QuadContainer"""
1641 return _IMP_kernel._object_cast_to_QuadContainer(o)
1643 _object_types.append(
"QuadModifier")
1646 def _object_cast_to_QuadModifier(o):
1647 """_object_cast_to_QuadModifier(Object o) -> QuadModifier"""
1648 return _IMP_kernel._object_cast_to_QuadModifier(o)
1650 _object_types.append(
"QuadScore")
1653 def _object_cast_to_QuadScore(o):
1654 """_object_cast_to_QuadScore(Object o) -> QuadScore"""
1655 return _IMP_kernel._object_cast_to_QuadScore(o)
1657 _object_types.append(
"Refiner")
1660 def _object_cast_to_Refiner(o):
1661 """_object_cast_to_Refiner(Object o) -> Refiner"""
1662 return _IMP_kernel._object_cast_to_Refiner(o)
1664 _object_types.append(
"Restraint")
1667 def _object_cast_to_Restraint(o):
1668 """_object_cast_to_Restraint(Object o) -> Restraint"""
1669 return _IMP_kernel._object_cast_to_Restraint(o)
1671 _object_types.append(
"Sampler")
1674 def _object_cast_to_Sampler(o):
1675 """_object_cast_to_Sampler(Object o) -> Sampler"""
1676 return _IMP_kernel._object_cast_to_Sampler(o)
1678 _object_types.append(
"ScoreState")
1681 def _object_cast_to_ScoreState(o):
1682 """_object_cast_to_ScoreState(Object o) -> ScoreState"""
1683 return _IMP_kernel._object_cast_to_ScoreState(o)
1685 _object_types.append(
"SingletonContainer")
1688 def _object_cast_to_SingletonContainer(o):
1689 """_object_cast_to_SingletonContainer(Object o) -> SingletonContainer"""
1690 return _IMP_kernel._object_cast_to_SingletonContainer(o)
1692 _object_types.append(
"SingletonModifier")
1695 def _object_cast_to_SingletonModifier(o):
1696 """_object_cast_to_SingletonModifier(Object o) -> SingletonModifier"""
1697 return _IMP_kernel._object_cast_to_SingletonModifier(o)
1699 _object_types.append(
"SingletonScore")
1702 def _object_cast_to_SingletonScore(o):
1703 """_object_cast_to_SingletonScore(Object o) -> SingletonScore"""
1704 return _IMP_kernel._object_cast_to_SingletonScore(o)
1706 _object_types.append(
"TripletContainer")
1709 def _object_cast_to_TripletContainer(o):
1710 """_object_cast_to_TripletContainer(Object o) -> TripletContainer"""
1711 return _IMP_kernel._object_cast_to_TripletContainer(o)
1713 _object_types.append(
"TripletModifier")
1716 def _object_cast_to_TripletModifier(o):
1717 """_object_cast_to_TripletModifier(Object o) -> TripletModifier"""
1718 return _IMP_kernel._object_cast_to_TripletModifier(o)
1720 _object_types.append(
"TripletScore")
1723 def _object_cast_to_TripletScore(o):
1724 """_object_cast_to_TripletScore(Object o) -> TripletScore"""
1725 return _IMP_kernel._object_cast_to_TripletScore(o)
1727 _object_types.append(
"UnaryFunction")
1730 def _object_cast_to_UnaryFunction(o):
1731 """_object_cast_to_UnaryFunction(Object o) -> UnaryFunction"""
1732 return _IMP_kernel._object_cast_to_UnaryFunction(o)
1734 _object_types.append(
"ConfigurationSet")
1737 def _object_cast_to_ConfigurationSet(o):
1738 """_object_cast_to_ConfigurationSet(Object o) -> ConfigurationSet"""
1739 return _IMP_kernel._object_cast_to_ConfigurationSet(o)
1741 _object_types.append(
"Configuration")
1744 def _object_cast_to_Configuration(o):
1745 """_object_cast_to_Configuration(Object o) -> Configuration"""
1746 return _IMP_kernel._object_cast_to_Configuration(o)
1748 _object_types.append(
"Model")
1751 def _object_cast_to_Model(o):
1752 """_object_cast_to_Model(Object o) -> Model"""
1753 return _IMP_kernel._object_cast_to_Model(o)
1755 _object_types.append(
"Particle")
1758 def _object_cast_to_Particle(o):
1759 """_object_cast_to_Particle(Object o) -> Particle"""
1760 return _IMP_kernel._object_cast_to_Particle(o)
1762 _object_types.append(
"RestraintSet")
1765 def _object_cast_to_RestraintSet(o):
1766 """_object_cast_to_RestraintSet(Object o) -> RestraintSet"""
1767 return _IMP_kernel._object_cast_to_RestraintSet(o)
1769 ParticlePairsTemp=list
1770 _plural_types.append(
"ParticlePairsTemp")
1771 _value_types.append(
"ParticlePair")
1774 ParticleTripletsTemp=list
1775 _plural_types.append(
"ParticleTripletsTemp")
1776 _value_types.append(
"ParticleTriplet")
1779 ParticleQuadsTemp=list
1780 _plural_types.append(
"ParticleQuadsTemp")
1781 _value_types.append(
"ParticleQuad")
1784 ParticleIndexPairs=list
1785 _plural_types.append(
"ParticleIndexPairs")
1786 _value_types.append(
"ParticleIndexPair")
1789 ParticleIndexTriplets=list
1790 _plural_types.append(
"ParticleIndexTriplets")
1791 _value_types.append(
"ParticleIndexTriplet")
1794 ParticleIndexQuads=list
1795 _plural_types.append(
"ParticleIndexQuads")
1796 _value_types.append(
"ParticleIndexQuad")
1799 _object_types.append(
"SingletonPredicate")
1802 def _object_cast_to_SingletonPredicate(o):
1803 """_object_cast_to_SingletonPredicate(Object o) -> SingletonPredicate"""
1804 return _IMP_kernel._object_cast_to_SingletonPredicate(o)
1806 _object_types.append(
"PairPredicate")
1809 def _object_cast_to_PairPredicate(o):
1810 """_object_cast_to_PairPredicate(Object o) -> PairPredicate"""
1811 return _IMP_kernel._object_cast_to_PairPredicate(o)
1813 _object_types.append(
"TripletPredicate")
1816 def _object_cast_to_TripletPredicate(o):
1817 """_object_cast_to_TripletPredicate(Object o) -> TripletPredicate"""
1818 return _IMP_kernel._object_cast_to_TripletPredicate(o)
1820 _object_types.append(
"QuadPredicate")
1823 def _object_cast_to_QuadPredicate(o):
1824 """_object_cast_to_QuadPredicate(Object o) -> QuadPredicate"""
1825 return _IMP_kernel._object_cast_to_QuadPredicate(o)
1827 _object_types.append(
"SaveToConfigurationSetOptimizerState")
1830 def _object_cast_to_SaveToConfigurationSetOptimizerState(o):
1831 """_object_cast_to_SaveToConfigurationSetOptimizerState(Object o) -> SaveToConfigurationSetOptimizerState"""
1832 return _IMP_kernel._object_cast_to_SaveToConfigurationSetOptimizerState(o)
1834 EvaluationStates=list
1835 _plural_types.append(
"EvaluationStates")
1836 _value_types.append(
"EvaluationState")
1839 ScoreAccumulators=list
1840 _plural_types.append(
"ScoreAccumulators")
1841 _value_types.append(
"ScoreAccumulator")
1844 ParticleIndexes=list
1845 _plural_types.append(
"ParticleIndexes")
1846 _value_types.append(
"ParticleIndex")
1850 _plural_types.append(
"FloatIndexes")
1851 _value_types.append(
"FloatIndex")
1855 _plural_types.append(
"FloatKeys")
1856 _value_types.append(
"FloatKey")
1860 _plural_types.append(
"IntKeys")
1861 _value_types.append(
"IntKey")
1865 _plural_types.append(
"StringKeys")
1866 _value_types.append(
"StringKey")
1869 ParticleIndexKeys=list
1870 _plural_types.append(
"ParticleIndexKeys")
1871 _value_types.append(
"ParticleIndexKey")
1874 ParticleIndexesKeys=list
1875 _plural_types.append(
"ParticleIndexesKeys")
1876 _value_types.append(
"ParticleIndexesKey")
1880 _plural_types.append(
"ObjectKeys")
1881 _value_types.append(
"ObjectKey")
1885 _plural_types.append(
"ModelKeys")
1886 _value_types.append(
"ModelKey")
1889 _raii_types.append(
"ScopedSetFloatAttribute")
1892 _object_types.append(
"ScoringFunction")
1895 def _object_cast_to_ScoringFunction(o):
1896 """_object_cast_to_ScoringFunction(Object o) -> ScoringFunction"""
1897 return _IMP_kernel._object_cast_to_ScoringFunction(o)
1899 _object_types.append(
"ModelObject")
1902 def _object_cast_to_ModelObject(o):
1903 """_object_cast_to_ModelObject(Object o) -> ModelObject"""
1904 return _IMP_kernel._object_cast_to_ModelObject(o)
1906 def _TrivialDecorators(l=[]):
1907 return [_TrivialDecorator(x)
for x
in l]
1908 _plural_types.append(
"_TrivialDecorators")
1911 _value_types.append(
"_TrivialDecorator")
1914 def _TrivialDerivedDecorators(l=[]):
1915 return [_TrivialDerivedDecorator(x)
for x
in l]
1916 _plural_types.append(
"_TrivialDerivedDecorators")
1919 _value_types.append(
"_TrivialDerivedDecorator")
1922 def _TrivialTraitsDecorators(l=[]):
1923 return [_TrivialTraitsDecorator(x)
for x
in l]
1924 _plural_types.append(
"_TrivialTraitsDecorators")
1927 _value_types.append(
"_TrivialTraitsDecorator")
1930 _object_types.append(
"_ConstRestraint")
1933 def _object_cast_to__ConstRestraint(o):
1934 """_object_cast_to__ConstRestraint(Object o) -> _ConstRestraint"""
1935 return _IMP_kernel._object_cast_to__ConstRestraint(o)
1937 _object_types.append(
"_ConstOptimizer")
1940 def _object_cast_to__ConstOptimizer(o):
1941 """_object_cast_to__ConstOptimizer(Object o) -> _ConstOptimizer"""
1942 return _IMP_kernel._object_cast_to__ConstOptimizer(o)
1944 """Proxy of C++ IMP::internal::BoostDigraph<(IMP::DependencyGraph,p.IMP::ModelObject,IMP::ShowDependencyGraphVertex)> class."""
1946 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
1947 __repr__ = _swig_repr
1950 """__init__(IMP::internal::BoostDigraph<(IMP::DependencyGraph,p.IMP::ModelObject,IMP::ShowDependencyGraphVertex)> self) -> DependencyGraph"""
1951 this = _IMP_kernel.new_DependencyGraph()
1953 self.this.append(this)
1954 except __builtin__.Exception:
1957 def get_graph(self):
1958 """get_graph(DependencyGraph self) -> IMP::DependencyGraph const &"""
1959 return _IMP_kernel.DependencyGraph_get_graph(self)
1963 """get_vertices(DependencyGraph self) -> IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptors"""
1964 return _IMP_kernel.DependencyGraph_get_vertices(self)
1967 def get_vertex_name(self, i):
1968 """get_vertex_name(DependencyGraph self, IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptor i) -> ModelObject"""
1969 return _IMP_kernel.DependencyGraph_get_vertex_name(self, i)
1972 def get_in_neighbors(self, v):
1973 """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"""
1974 return _IMP_kernel.DependencyGraph_get_in_neighbors(self, v)
1977 def get_out_neighbors(self, v):
1978 """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"""
1979 return _IMP_kernel.DependencyGraph_get_out_neighbors(self, v)
1984 show_graphviz(DependencyGraph self, _ostream out)
1985 show_graphviz(DependencyGraph self)
1987 return _IMP_kernel.DependencyGraph_show_graphviz(self, *args)
1990 def get_graphviz_string(self):
1991 """get_graphviz_string(DependencyGraph self) -> std::string"""
1992 return _IMP_kernel.DependencyGraph_get_graphviz_string(self)
1995 def add_edge(self, v0, v1):
1996 """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)"""
1997 return _IMP_kernel.DependencyGraph_add_edge(self, v0, v1)
2000 def add_vertex(self, l):
2001 """add_vertex(DependencyGraph self, ModelObject l) -> IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptor"""
2002 return _IMP_kernel.DependencyGraph_add_vertex(self, l)
2005 def remove_vertex(self, l):
2006 """remove_vertex(DependencyGraph self, IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptor l)"""
2007 return _IMP_kernel.DependencyGraph_remove_vertex(self, l)
2009 __swig_destroy__ = _IMP_kernel.delete_DependencyGraph
2010 __del__ =
lambda self:
None
2011 DependencyGraph_swigregister = _IMP_kernel.DependencyGraph_swigregister
2012 DependencyGraph_swigregister(DependencyGraph)
2015 _value_types.append(
"DependencyGraph")
2018 """Proxy of C++ IMP::Key<(0)> class."""
2020 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
2022 def __init__(self, *args):
2024 __init__(IMP::Key<(0)> self) -> FloatKey
2025 __init__(IMP::Key<(0)> self, std::string const & c, bool is_implicit_add_permitted=True) -> FloatKey
2026 __init__(IMP::Key<(0)> self, std::string const & c) -> FloatKey
2027 __init__(IMP::Key<(0)> self, unsigned int i) -> FloatKey
2029 this = _IMP_kernel.new_FloatKey(*args)
2031 self.this.append(this)
2032 except __builtin__.Exception:
2036 """add_key(std::string sc) -> unsigned int"""
2037 return _IMP_kernel.FloatKey_add_key(sc)
2039 add_key = staticmethod(add_key)
2041 def get_key_exists(sc):
2042 """get_key_exists(std::string sc) -> bool"""
2043 return _IMP_kernel.FloatKey_get_key_exists(sc)
2045 get_key_exists = staticmethod(get_key_exists)
2047 def get_string(self):
2048 """get_string(FloatKey self) -> std::string const"""
2049 return _IMP_kernel.FloatKey_get_string(self)
2052 def __cmp__(self, o):
2053 """__cmp__(FloatKey self, FloatKey o) -> int"""
2054 return _IMP_kernel.FloatKey___cmp__(self, o)
2057 def __eq__(self, o):
2058 """__eq__(FloatKey self, FloatKey o) -> bool"""
2059 return _IMP_kernel.FloatKey___eq__(self, o)
2062 def __ne__(self, o):
2063 """__ne__(FloatKey self, FloatKey o) -> bool"""
2064 return _IMP_kernel.FloatKey___ne__(self, o)
2067 def __lt__(self, o):
2068 """__lt__(FloatKey self, FloatKey o) -> bool"""
2069 return _IMP_kernel.FloatKey___lt__(self, o)
2072 def __gt__(self, o):
2073 """__gt__(FloatKey self, FloatKey o) -> bool"""
2074 return _IMP_kernel.FloatKey___gt__(self, o)
2077 def __ge__(self, o):
2078 """__ge__(FloatKey self, FloatKey o) -> bool"""
2079 return _IMP_kernel.FloatKey___ge__(self, o)
2082 def __le__(self, o):
2083 """__le__(FloatKey self, FloatKey o) -> bool"""
2084 return _IMP_kernel.FloatKey___le__(self, o)
2088 """__hash__(FloatKey self) -> std::size_t"""
2089 return _IMP_kernel.FloatKey___hash__(self)
2092 def show(self, *args):
2094 show(FloatKey self, _ostream out)
2097 return _IMP_kernel.FloatKey_show(self, *args)
2100 def add_alias(old_key, new_name):
2101 """add_alias(FloatKey old_key, std::string new_name) -> FloatKey"""
2102 return _IMP_kernel.FloatKey_add_alias(old_key, new_name)
2104 add_alias = staticmethod(add_alias)
2106 def get_number_of_keys():
2107 """get_number_of_keys() -> unsigned int"""
2108 return _IMP_kernel.FloatKey_get_number_of_keys()
2110 get_number_of_keys = staticmethod(get_number_of_keys)
2113 """get_index(FloatKey self) -> unsigned int"""
2114 return _IMP_kernel.FloatKey_get_index(self)
2118 """show_all(_ostream out)"""
2119 return _IMP_kernel.FloatKey_show_all(out)
2121 show_all = staticmethod(show_all)
2123 def get_all_strings():
2124 """get_all_strings() -> IMP::Vector< std::string >"""
2125 return _IMP_kernel.FloatKey_get_all_strings()
2127 get_all_strings = staticmethod(get_all_strings)
2129 def get_number_unique():
2130 """get_number_unique() -> unsigned int"""
2131 return _IMP_kernel.FloatKey_get_number_unique()
2133 get_number_unique = staticmethod(get_number_unique)
2136 """__str__(FloatKey self) -> std::string"""
2137 return _IMP_kernel.FloatKey___str__(self)
2141 """__repr__(FloatKey self) -> std::string"""
2142 return _IMP_kernel.FloatKey___repr__(self)
2144 __swig_destroy__ = _IMP_kernel.delete_FloatKey
2145 __del__ =
lambda self:
None
2146 FloatKey_swigregister = _IMP_kernel.FloatKey_swigregister
2147 FloatKey_swigregister(FloatKey)
2149 def FloatKey_add_key(sc):
2150 """FloatKey_add_key(std::string sc) -> unsigned int"""
2151 return _IMP_kernel.FloatKey_add_key(sc)
2153 def FloatKey_get_key_exists(sc):
2154 """FloatKey_get_key_exists(std::string sc) -> bool"""
2155 return _IMP_kernel.FloatKey_get_key_exists(sc)
2157 def FloatKey_add_alias(old_key, new_name):
2158 """FloatKey_add_alias(FloatKey old_key, std::string new_name) -> FloatKey"""
2159 return _IMP_kernel.FloatKey_add_alias(old_key, new_name)
2161 def FloatKey_get_number_of_keys():
2162 """FloatKey_get_number_of_keys() -> unsigned int"""
2163 return _IMP_kernel.FloatKey_get_number_of_keys()
2165 def FloatKey_show_all(out):
2166 """FloatKey_show_all(_ostream out)"""
2167 return _IMP_kernel.FloatKey_show_all(out)
2169 def FloatKey_get_all_strings():
2170 """FloatKey_get_all_strings() -> IMP::Vector< std::string >"""
2171 return _IMP_kernel.FloatKey_get_all_strings()
2173 def FloatKey_get_number_unique():
2174 """FloatKey_get_number_unique() -> unsigned int"""
2175 return _IMP_kernel.FloatKey_get_number_unique()
2178 """Proxy of C++ IMP::Key<(1)> class."""
2180 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
2182 def __init__(self, *args):
2184 __init__(IMP::Key<(1)> self) -> IntKey
2185 __init__(IMP::Key<(1)> self, std::string const & c, bool is_implicit_add_permitted=True) -> IntKey
2186 __init__(IMP::Key<(1)> self, std::string const & c) -> IntKey
2187 __init__(IMP::Key<(1)> self, unsigned int i) -> IntKey
2189 this = _IMP_kernel.new_IntKey(*args)
2191 self.this.append(this)
2192 except __builtin__.Exception:
2196 """add_key(std::string sc) -> unsigned int"""
2197 return _IMP_kernel.IntKey_add_key(sc)
2199 add_key = staticmethod(add_key)
2201 def get_key_exists(sc):
2202 """get_key_exists(std::string sc) -> bool"""
2203 return _IMP_kernel.IntKey_get_key_exists(sc)
2205 get_key_exists = staticmethod(get_key_exists)
2207 def get_string(self):
2208 """get_string(IntKey self) -> std::string const"""
2209 return _IMP_kernel.IntKey_get_string(self)
2212 def __cmp__(self, o):
2213 """__cmp__(IntKey self, IntKey o) -> int"""
2214 return _IMP_kernel.IntKey___cmp__(self, o)
2217 def __eq__(self, o):
2218 """__eq__(IntKey self, IntKey o) -> bool"""
2219 return _IMP_kernel.IntKey___eq__(self, o)
2222 def __ne__(self, o):
2223 """__ne__(IntKey self, IntKey o) -> bool"""
2224 return _IMP_kernel.IntKey___ne__(self, o)
2227 def __lt__(self, o):
2228 """__lt__(IntKey self, IntKey o) -> bool"""
2229 return _IMP_kernel.IntKey___lt__(self, o)
2232 def __gt__(self, o):
2233 """__gt__(IntKey self, IntKey o) -> bool"""
2234 return _IMP_kernel.IntKey___gt__(self, o)
2237 def __ge__(self, o):
2238 """__ge__(IntKey self, IntKey o) -> bool"""
2239 return _IMP_kernel.IntKey___ge__(self, o)
2242 def __le__(self, o):
2243 """__le__(IntKey self, IntKey o) -> bool"""
2244 return _IMP_kernel.IntKey___le__(self, o)
2248 """__hash__(IntKey self) -> std::size_t"""
2249 return _IMP_kernel.IntKey___hash__(self)
2252 def show(self, *args):
2254 show(IntKey self, _ostream out)
2257 return _IMP_kernel.IntKey_show(self, *args)
2260 def add_alias(old_key, new_name):
2261 """add_alias(IntKey old_key, std::string new_name) -> IntKey"""
2262 return _IMP_kernel.IntKey_add_alias(old_key, new_name)
2264 add_alias = staticmethod(add_alias)
2266 def get_number_of_keys():
2267 """get_number_of_keys() -> unsigned int"""
2268 return _IMP_kernel.IntKey_get_number_of_keys()
2270 get_number_of_keys = staticmethod(get_number_of_keys)
2273 """get_index(IntKey self) -> unsigned int"""
2274 return _IMP_kernel.IntKey_get_index(self)
2278 """show_all(_ostream out)"""
2279 return _IMP_kernel.IntKey_show_all(out)
2281 show_all = staticmethod(show_all)
2283 def get_all_strings():
2284 """get_all_strings() -> IMP::Vector< std::string >"""
2285 return _IMP_kernel.IntKey_get_all_strings()
2287 get_all_strings = staticmethod(get_all_strings)
2289 def get_number_unique():
2290 """get_number_unique() -> unsigned int"""
2291 return _IMP_kernel.IntKey_get_number_unique()
2293 get_number_unique = staticmethod(get_number_unique)
2296 """__str__(IntKey self) -> std::string"""
2297 return _IMP_kernel.IntKey___str__(self)
2301 """__repr__(IntKey self) -> std::string"""
2302 return _IMP_kernel.IntKey___repr__(self)
2304 __swig_destroy__ = _IMP_kernel.delete_IntKey
2305 __del__ =
lambda self:
None
2306 IntKey_swigregister = _IMP_kernel.IntKey_swigregister
2307 IntKey_swigregister(IntKey)
2309 def IntKey_add_key(sc):
2310 """IntKey_add_key(std::string sc) -> unsigned int"""
2311 return _IMP_kernel.IntKey_add_key(sc)
2313 def IntKey_get_key_exists(sc):
2314 """IntKey_get_key_exists(std::string sc) -> bool"""
2315 return _IMP_kernel.IntKey_get_key_exists(sc)
2317 def IntKey_add_alias(old_key, new_name):
2318 """IntKey_add_alias(IntKey old_key, std::string new_name) -> IntKey"""
2319 return _IMP_kernel.IntKey_add_alias(old_key, new_name)
2321 def IntKey_get_number_of_keys():
2322 """IntKey_get_number_of_keys() -> unsigned int"""
2323 return _IMP_kernel.IntKey_get_number_of_keys()
2325 def IntKey_show_all(out):
2326 """IntKey_show_all(_ostream out)"""
2327 return _IMP_kernel.IntKey_show_all(out)
2329 def IntKey_get_all_strings():
2330 """IntKey_get_all_strings() -> IMP::Vector< std::string >"""
2331 return _IMP_kernel.IntKey_get_all_strings()
2333 def IntKey_get_number_unique():
2334 """IntKey_get_number_unique() -> unsigned int"""
2335 return _IMP_kernel.IntKey_get_number_unique()
2338 """Proxy of C++ IMP::Key<(2)> class."""
2340 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
2342 def __init__(self, *args):
2344 __init__(IMP::Key<(2)> self) -> StringKey
2345 __init__(IMP::Key<(2)> self, std::string const & c, bool is_implicit_add_permitted=True) -> StringKey
2346 __init__(IMP::Key<(2)> self, std::string const & c) -> StringKey
2347 __init__(IMP::Key<(2)> self, unsigned int i) -> StringKey
2349 this = _IMP_kernel.new_StringKey(*args)
2351 self.this.append(this)
2352 except __builtin__.Exception:
2356 """add_key(std::string sc) -> unsigned int"""
2357 return _IMP_kernel.StringKey_add_key(sc)
2359 add_key = staticmethod(add_key)
2361 def get_key_exists(sc):
2362 """get_key_exists(std::string sc) -> bool"""
2363 return _IMP_kernel.StringKey_get_key_exists(sc)
2365 get_key_exists = staticmethod(get_key_exists)
2367 def get_string(self):
2368 """get_string(StringKey self) -> std::string const"""
2369 return _IMP_kernel.StringKey_get_string(self)
2372 def __cmp__(self, o):
2373 """__cmp__(StringKey self, StringKey o) -> int"""
2374 return _IMP_kernel.StringKey___cmp__(self, o)
2377 def __eq__(self, o):
2378 """__eq__(StringKey self, StringKey o) -> bool"""
2379 return _IMP_kernel.StringKey___eq__(self, o)
2382 def __ne__(self, o):
2383 """__ne__(StringKey self, StringKey o) -> bool"""
2384 return _IMP_kernel.StringKey___ne__(self, o)
2387 def __lt__(self, o):
2388 """__lt__(StringKey self, StringKey o) -> bool"""
2389 return _IMP_kernel.StringKey___lt__(self, o)
2392 def __gt__(self, o):
2393 """__gt__(StringKey self, StringKey o) -> bool"""
2394 return _IMP_kernel.StringKey___gt__(self, o)
2397 def __ge__(self, o):
2398 """__ge__(StringKey self, StringKey o) -> bool"""
2399 return _IMP_kernel.StringKey___ge__(self, o)
2402 def __le__(self, o):
2403 """__le__(StringKey self, StringKey o) -> bool"""
2404 return _IMP_kernel.StringKey___le__(self, o)
2408 """__hash__(StringKey self) -> std::size_t"""
2409 return _IMP_kernel.StringKey___hash__(self)
2412 def show(self, *args):
2414 show(StringKey self, _ostream out)
2415 show(StringKey self)
2417 return _IMP_kernel.StringKey_show(self, *args)
2420 def add_alias(old_key, new_name):
2421 """add_alias(StringKey old_key, std::string new_name) -> StringKey"""
2422 return _IMP_kernel.StringKey_add_alias(old_key, new_name)
2424 add_alias = staticmethod(add_alias)
2426 def get_number_of_keys():
2427 """get_number_of_keys() -> unsigned int"""
2428 return _IMP_kernel.StringKey_get_number_of_keys()
2430 get_number_of_keys = staticmethod(get_number_of_keys)
2433 """get_index(StringKey self) -> unsigned int"""
2434 return _IMP_kernel.StringKey_get_index(self)
2438 """show_all(_ostream out)"""
2439 return _IMP_kernel.StringKey_show_all(out)
2441 show_all = staticmethod(show_all)
2443 def get_all_strings():
2444 """get_all_strings() -> IMP::Vector< std::string >"""
2445 return _IMP_kernel.StringKey_get_all_strings()
2447 get_all_strings = staticmethod(get_all_strings)
2449 def get_number_unique():
2450 """get_number_unique() -> unsigned int"""
2451 return _IMP_kernel.StringKey_get_number_unique()
2453 get_number_unique = staticmethod(get_number_unique)
2456 """__str__(StringKey self) -> std::string"""
2457 return _IMP_kernel.StringKey___str__(self)
2461 """__repr__(StringKey self) -> std::string"""
2462 return _IMP_kernel.StringKey___repr__(self)
2464 __swig_destroy__ = _IMP_kernel.delete_StringKey
2465 __del__ =
lambda self:
None
2466 StringKey_swigregister = _IMP_kernel.StringKey_swigregister
2467 StringKey_swigregister(StringKey)
2469 def StringKey_add_key(sc):
2470 """StringKey_add_key(std::string sc) -> unsigned int"""
2471 return _IMP_kernel.StringKey_add_key(sc)
2473 def StringKey_get_key_exists(sc):
2474 """StringKey_get_key_exists(std::string sc) -> bool"""
2475 return _IMP_kernel.StringKey_get_key_exists(sc)
2477 def StringKey_add_alias(old_key, new_name):
2478 """StringKey_add_alias(StringKey old_key, std::string new_name) -> StringKey"""
2479 return _IMP_kernel.StringKey_add_alias(old_key, new_name)
2481 def StringKey_get_number_of_keys():
2482 """StringKey_get_number_of_keys() -> unsigned int"""
2483 return _IMP_kernel.StringKey_get_number_of_keys()
2485 def StringKey_show_all(out):
2486 """StringKey_show_all(_ostream out)"""
2487 return _IMP_kernel.StringKey_show_all(out)
2489 def StringKey_get_all_strings():
2490 """StringKey_get_all_strings() -> IMP::Vector< std::string >"""
2491 return _IMP_kernel.StringKey_get_all_strings()
2493 def StringKey_get_number_unique():
2494 """StringKey_get_number_unique() -> unsigned int"""
2495 return _IMP_kernel.StringKey_get_number_unique()
2498 """Proxy of C++ IMP::Key<(3)> class."""
2500 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
2502 def __init__(self, *args):
2504 __init__(IMP::Key<(3)> self) -> ParticleIndexKey
2505 __init__(IMP::Key<(3)> self, std::string const & c, bool is_implicit_add_permitted=True) -> ParticleIndexKey
2506 __init__(IMP::Key<(3)> self, std::string const & c) -> ParticleIndexKey
2507 __init__(IMP::Key<(3)> self, unsigned int i) -> ParticleIndexKey
2509 this = _IMP_kernel.new_ParticleIndexKey(*args)
2511 self.this.append(this)
2512 except __builtin__.Exception:
2516 """add_key(std::string sc) -> unsigned int"""
2517 return _IMP_kernel.ParticleIndexKey_add_key(sc)
2519 add_key = staticmethod(add_key)
2521 def get_key_exists(sc):
2522 """get_key_exists(std::string sc) -> bool"""
2523 return _IMP_kernel.ParticleIndexKey_get_key_exists(sc)
2525 get_key_exists = staticmethod(get_key_exists)
2527 def get_string(self):
2528 """get_string(ParticleIndexKey self) -> std::string const"""
2529 return _IMP_kernel.ParticleIndexKey_get_string(self)
2532 def __cmp__(self, o):
2533 """__cmp__(ParticleIndexKey self, ParticleIndexKey o) -> int"""
2534 return _IMP_kernel.ParticleIndexKey___cmp__(self, o)
2537 def __eq__(self, o):
2538 """__eq__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2539 return _IMP_kernel.ParticleIndexKey___eq__(self, o)
2542 def __ne__(self, o):
2543 """__ne__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2544 return _IMP_kernel.ParticleIndexKey___ne__(self, o)
2547 def __lt__(self, o):
2548 """__lt__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2549 return _IMP_kernel.ParticleIndexKey___lt__(self, o)
2552 def __gt__(self, o):
2553 """__gt__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2554 return _IMP_kernel.ParticleIndexKey___gt__(self, o)
2557 def __ge__(self, o):
2558 """__ge__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2559 return _IMP_kernel.ParticleIndexKey___ge__(self, o)
2562 def __le__(self, o):
2563 """__le__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2564 return _IMP_kernel.ParticleIndexKey___le__(self, o)
2568 """__hash__(ParticleIndexKey self) -> std::size_t"""
2569 return _IMP_kernel.ParticleIndexKey___hash__(self)
2572 def show(self, *args):
2574 show(ParticleIndexKey self, _ostream out)
2575 show(ParticleIndexKey self)
2577 return _IMP_kernel.ParticleIndexKey_show(self, *args)
2580 def add_alias(old_key, new_name):
2581 """add_alias(ParticleIndexKey old_key, std::string new_name) -> ParticleIndexKey"""
2582 return _IMP_kernel.ParticleIndexKey_add_alias(old_key, new_name)
2584 add_alias = staticmethod(add_alias)
2586 def get_number_of_keys():
2587 """get_number_of_keys() -> unsigned int"""
2588 return _IMP_kernel.ParticleIndexKey_get_number_of_keys()
2590 get_number_of_keys = staticmethod(get_number_of_keys)
2593 """get_index(ParticleIndexKey self) -> unsigned int"""
2594 return _IMP_kernel.ParticleIndexKey_get_index(self)
2598 """show_all(_ostream out)"""
2599 return _IMP_kernel.ParticleIndexKey_show_all(out)
2601 show_all = staticmethod(show_all)
2603 def get_all_strings():
2604 """get_all_strings() -> IMP::Vector< std::string >"""
2605 return _IMP_kernel.ParticleIndexKey_get_all_strings()
2607 get_all_strings = staticmethod(get_all_strings)
2609 def get_number_unique():
2610 """get_number_unique() -> unsigned int"""
2611 return _IMP_kernel.ParticleIndexKey_get_number_unique()
2613 get_number_unique = staticmethod(get_number_unique)
2616 """__str__(ParticleIndexKey self) -> std::string"""
2617 return _IMP_kernel.ParticleIndexKey___str__(self)
2621 """__repr__(ParticleIndexKey self) -> std::string"""
2622 return _IMP_kernel.ParticleIndexKey___repr__(self)
2624 __swig_destroy__ = _IMP_kernel.delete_ParticleIndexKey
2625 __del__ =
lambda self:
None
2626 ParticleIndexKey_swigregister = _IMP_kernel.ParticleIndexKey_swigregister
2627 ParticleIndexKey_swigregister(ParticleIndexKey)
2629 def ParticleIndexKey_add_key(sc):
2630 """ParticleIndexKey_add_key(std::string sc) -> unsigned int"""
2631 return _IMP_kernel.ParticleIndexKey_add_key(sc)
2633 def ParticleIndexKey_get_key_exists(sc):
2634 """ParticleIndexKey_get_key_exists(std::string sc) -> bool"""
2635 return _IMP_kernel.ParticleIndexKey_get_key_exists(sc)
2637 def ParticleIndexKey_add_alias(old_key, new_name):
2638 """ParticleIndexKey_add_alias(ParticleIndexKey old_key, std::string new_name) -> ParticleIndexKey"""
2639 return _IMP_kernel.ParticleIndexKey_add_alias(old_key, new_name)
2641 def ParticleIndexKey_get_number_of_keys():
2642 """ParticleIndexKey_get_number_of_keys() -> unsigned int"""
2643 return _IMP_kernel.ParticleIndexKey_get_number_of_keys()
2645 def ParticleIndexKey_show_all(out):
2646 """ParticleIndexKey_show_all(_ostream out)"""
2647 return _IMP_kernel.ParticleIndexKey_show_all(out)
2649 def ParticleIndexKey_get_all_strings():
2650 """ParticleIndexKey_get_all_strings() -> IMP::Vector< std::string >"""
2651 return _IMP_kernel.ParticleIndexKey_get_all_strings()
2653 def ParticleIndexKey_get_number_unique():
2654 """ParticleIndexKey_get_number_unique() -> unsigned int"""
2655 return _IMP_kernel.ParticleIndexKey_get_number_unique()
2658 """Proxy of C++ IMP::Key<(4)> class."""
2660 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
2662 def __init__(self, *args):
2664 __init__(IMP::Key<(4)> self) -> ObjectKey
2665 __init__(IMP::Key<(4)> self, std::string const & c, bool is_implicit_add_permitted=True) -> ObjectKey
2666 __init__(IMP::Key<(4)> self, std::string const & c) -> ObjectKey
2667 __init__(IMP::Key<(4)> self, unsigned int i) -> ObjectKey
2669 this = _IMP_kernel.new_ObjectKey(*args)
2671 self.this.append(this)
2672 except __builtin__.Exception:
2676 """add_key(std::string sc) -> unsigned int"""
2677 return _IMP_kernel.ObjectKey_add_key(sc)
2679 add_key = staticmethod(add_key)
2681 def get_key_exists(sc):
2682 """get_key_exists(std::string sc) -> bool"""
2683 return _IMP_kernel.ObjectKey_get_key_exists(sc)
2685 get_key_exists = staticmethod(get_key_exists)
2687 def get_string(self):
2688 """get_string(ObjectKey self) -> std::string const"""
2689 return _IMP_kernel.ObjectKey_get_string(self)
2692 def __cmp__(self, o):
2693 """__cmp__(ObjectKey self, ObjectKey o) -> int"""
2694 return _IMP_kernel.ObjectKey___cmp__(self, o)
2697 def __eq__(self, o):
2698 """__eq__(ObjectKey self, ObjectKey o) -> bool"""
2699 return _IMP_kernel.ObjectKey___eq__(self, o)
2702 def __ne__(self, o):
2703 """__ne__(ObjectKey self, ObjectKey o) -> bool"""
2704 return _IMP_kernel.ObjectKey___ne__(self, o)
2707 def __lt__(self, o):
2708 """__lt__(ObjectKey self, ObjectKey o) -> bool"""
2709 return _IMP_kernel.ObjectKey___lt__(self, o)
2712 def __gt__(self, o):
2713 """__gt__(ObjectKey self, ObjectKey o) -> bool"""
2714 return _IMP_kernel.ObjectKey___gt__(self, o)
2717 def __ge__(self, o):
2718 """__ge__(ObjectKey self, ObjectKey o) -> bool"""
2719 return _IMP_kernel.ObjectKey___ge__(self, o)
2722 def __le__(self, o):
2723 """__le__(ObjectKey self, ObjectKey o) -> bool"""
2724 return _IMP_kernel.ObjectKey___le__(self, o)
2728 """__hash__(ObjectKey self) -> std::size_t"""
2729 return _IMP_kernel.ObjectKey___hash__(self)
2732 def show(self, *args):
2734 show(ObjectKey self, _ostream out)
2735 show(ObjectKey self)
2737 return _IMP_kernel.ObjectKey_show(self, *args)
2740 def add_alias(old_key, new_name):
2741 """add_alias(ObjectKey old_key, std::string new_name) -> ObjectKey"""
2742 return _IMP_kernel.ObjectKey_add_alias(old_key, new_name)
2744 add_alias = staticmethod(add_alias)
2746 def get_number_of_keys():
2747 """get_number_of_keys() -> unsigned int"""
2748 return _IMP_kernel.ObjectKey_get_number_of_keys()
2750 get_number_of_keys = staticmethod(get_number_of_keys)
2753 """get_index(ObjectKey self) -> unsigned int"""
2754 return _IMP_kernel.ObjectKey_get_index(self)
2758 """show_all(_ostream out)"""
2759 return _IMP_kernel.ObjectKey_show_all(out)
2761 show_all = staticmethod(show_all)
2763 def get_all_strings():
2764 """get_all_strings() -> IMP::Vector< std::string >"""
2765 return _IMP_kernel.ObjectKey_get_all_strings()
2767 get_all_strings = staticmethod(get_all_strings)
2769 def get_number_unique():
2770 """get_number_unique() -> unsigned int"""
2771 return _IMP_kernel.ObjectKey_get_number_unique()
2773 get_number_unique = staticmethod(get_number_unique)
2776 """__str__(ObjectKey self) -> std::string"""
2777 return _IMP_kernel.ObjectKey___str__(self)
2781 """__repr__(ObjectKey self) -> std::string"""
2782 return _IMP_kernel.ObjectKey___repr__(self)
2784 __swig_destroy__ = _IMP_kernel.delete_ObjectKey
2785 __del__ =
lambda self:
None
2786 ObjectKey_swigregister = _IMP_kernel.ObjectKey_swigregister
2787 ObjectKey_swigregister(ObjectKey)
2789 def ObjectKey_add_key(sc):
2790 """ObjectKey_add_key(std::string sc) -> unsigned int"""
2791 return _IMP_kernel.ObjectKey_add_key(sc)
2793 def ObjectKey_get_key_exists(sc):
2794 """ObjectKey_get_key_exists(std::string sc) -> bool"""
2795 return _IMP_kernel.ObjectKey_get_key_exists(sc)
2797 def ObjectKey_add_alias(old_key, new_name):
2798 """ObjectKey_add_alias(ObjectKey old_key, std::string new_name) -> ObjectKey"""
2799 return _IMP_kernel.ObjectKey_add_alias(old_key, new_name)
2801 def ObjectKey_get_number_of_keys():
2802 """ObjectKey_get_number_of_keys() -> unsigned int"""
2803 return _IMP_kernel.ObjectKey_get_number_of_keys()
2805 def ObjectKey_show_all(out):
2806 """ObjectKey_show_all(_ostream out)"""
2807 return _IMP_kernel.ObjectKey_show_all(out)
2809 def ObjectKey_get_all_strings():
2810 """ObjectKey_get_all_strings() -> IMP::Vector< std::string >"""
2811 return _IMP_kernel.ObjectKey_get_all_strings()
2813 def ObjectKey_get_number_unique():
2814 """ObjectKey_get_number_unique() -> unsigned int"""
2815 return _IMP_kernel.ObjectKey_get_number_unique()
2818 """Proxy of C++ IMP::Key<(6)> class."""
2820 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
2822 def __init__(self, *args):
2824 __init__(IMP::Key<(6)> self) -> ParticleIndexesKey
2825 __init__(IMP::Key<(6)> self, std::string const & c, bool is_implicit_add_permitted=True) -> ParticleIndexesKey
2826 __init__(IMP::Key<(6)> self, std::string const & c) -> ParticleIndexesKey
2827 __init__(IMP::Key<(6)> self, unsigned int i) -> ParticleIndexesKey
2829 this = _IMP_kernel.new_ParticleIndexesKey(*args)
2831 self.this.append(this)
2832 except __builtin__.Exception:
2836 """add_key(std::string sc) -> unsigned int"""
2837 return _IMP_kernel.ParticleIndexesKey_add_key(sc)
2839 add_key = staticmethod(add_key)
2841 def get_key_exists(sc):
2842 """get_key_exists(std::string sc) -> bool"""
2843 return _IMP_kernel.ParticleIndexesKey_get_key_exists(sc)
2845 get_key_exists = staticmethod(get_key_exists)
2847 def get_string(self):
2848 """get_string(ParticleIndexesKey self) -> std::string const"""
2849 return _IMP_kernel.ParticleIndexesKey_get_string(self)
2852 def __cmp__(self, o):
2853 """__cmp__(ParticleIndexesKey self, ParticleIndexesKey o) -> int"""
2854 return _IMP_kernel.ParticleIndexesKey___cmp__(self, o)
2857 def __eq__(self, o):
2858 """__eq__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
2859 return _IMP_kernel.ParticleIndexesKey___eq__(self, o)
2862 def __ne__(self, o):
2863 """__ne__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
2864 return _IMP_kernel.ParticleIndexesKey___ne__(self, o)
2867 def __lt__(self, o):
2868 """__lt__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
2869 return _IMP_kernel.ParticleIndexesKey___lt__(self, o)
2872 def __gt__(self, o):
2873 """__gt__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
2874 return _IMP_kernel.ParticleIndexesKey___gt__(self, o)
2877 def __ge__(self, o):
2878 """__ge__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
2879 return _IMP_kernel.ParticleIndexesKey___ge__(self, o)
2882 def __le__(self, o):
2883 """__le__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
2884 return _IMP_kernel.ParticleIndexesKey___le__(self, o)
2888 """__hash__(ParticleIndexesKey self) -> std::size_t"""
2889 return _IMP_kernel.ParticleIndexesKey___hash__(self)
2892 def show(self, *args):
2894 show(ParticleIndexesKey self, _ostream out)
2895 show(ParticleIndexesKey self)
2897 return _IMP_kernel.ParticleIndexesKey_show(self, *args)
2900 def add_alias(old_key, new_name):
2901 """add_alias(ParticleIndexesKey old_key, std::string new_name) -> ParticleIndexesKey"""
2902 return _IMP_kernel.ParticleIndexesKey_add_alias(old_key, new_name)
2904 add_alias = staticmethod(add_alias)
2906 def get_number_of_keys():
2907 """get_number_of_keys() -> unsigned int"""
2908 return _IMP_kernel.ParticleIndexesKey_get_number_of_keys()
2910 get_number_of_keys = staticmethod(get_number_of_keys)
2913 """get_index(ParticleIndexesKey self) -> unsigned int"""
2914 return _IMP_kernel.ParticleIndexesKey_get_index(self)
2918 """show_all(_ostream out)"""
2919 return _IMP_kernel.ParticleIndexesKey_show_all(out)
2921 show_all = staticmethod(show_all)
2923 def get_all_strings():
2924 """get_all_strings() -> IMP::Vector< std::string >"""
2925 return _IMP_kernel.ParticleIndexesKey_get_all_strings()
2927 get_all_strings = staticmethod(get_all_strings)
2929 def get_number_unique():
2930 """get_number_unique() -> unsigned int"""
2931 return _IMP_kernel.ParticleIndexesKey_get_number_unique()
2933 get_number_unique = staticmethod(get_number_unique)
2936 """__str__(ParticleIndexesKey self) -> std::string"""
2937 return _IMP_kernel.ParticleIndexesKey___str__(self)
2941 """__repr__(ParticleIndexesKey self) -> std::string"""
2942 return _IMP_kernel.ParticleIndexesKey___repr__(self)
2944 __swig_destroy__ = _IMP_kernel.delete_ParticleIndexesKey
2945 __del__ =
lambda self:
None
2946 ParticleIndexesKey_swigregister = _IMP_kernel.ParticleIndexesKey_swigregister
2947 ParticleIndexesKey_swigregister(ParticleIndexesKey)
2949 def ParticleIndexesKey_add_key(sc):
2950 """ParticleIndexesKey_add_key(std::string sc) -> unsigned int"""
2951 return _IMP_kernel.ParticleIndexesKey_add_key(sc)
2953 def ParticleIndexesKey_get_key_exists(sc):
2954 """ParticleIndexesKey_get_key_exists(std::string sc) -> bool"""
2955 return _IMP_kernel.ParticleIndexesKey_get_key_exists(sc)
2957 def ParticleIndexesKey_add_alias(old_key, new_name):
2958 """ParticleIndexesKey_add_alias(ParticleIndexesKey old_key, std::string new_name) -> ParticleIndexesKey"""
2959 return _IMP_kernel.ParticleIndexesKey_add_alias(old_key, new_name)
2961 def ParticleIndexesKey_get_number_of_keys():
2962 """ParticleIndexesKey_get_number_of_keys() -> unsigned int"""
2963 return _IMP_kernel.ParticleIndexesKey_get_number_of_keys()
2965 def ParticleIndexesKey_show_all(out):
2966 """ParticleIndexesKey_show_all(_ostream out)"""
2967 return _IMP_kernel.ParticleIndexesKey_show_all(out)
2969 def ParticleIndexesKey_get_all_strings():
2970 """ParticleIndexesKey_get_all_strings() -> IMP::Vector< std::string >"""
2971 return _IMP_kernel.ParticleIndexesKey_get_all_strings()
2973 def ParticleIndexesKey_get_number_unique():
2974 """ParticleIndexesKey_get_number_unique() -> unsigned int"""
2975 return _IMP_kernel.ParticleIndexesKey_get_number_unique()
2978 """Proxy of C++ IMP::Key<(8)> class."""
2980 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
2982 def __init__(self, *args):
2984 __init__(IMP::Key<(8)> self) -> ModelKey
2985 __init__(IMP::Key<(8)> self, std::string const & c, bool is_implicit_add_permitted=True) -> ModelKey
2986 __init__(IMP::Key<(8)> self, std::string const & c) -> ModelKey
2987 __init__(IMP::Key<(8)> self, unsigned int i) -> ModelKey
2989 this = _IMP_kernel.new_ModelKey(*args)
2991 self.this.append(this)
2992 except __builtin__.Exception:
2996 """add_key(std::string sc) -> unsigned int"""
2997 return _IMP_kernel.ModelKey_add_key(sc)
2999 add_key = staticmethod(add_key)
3001 def get_key_exists(sc):
3002 """get_key_exists(std::string sc) -> bool"""
3003 return _IMP_kernel.ModelKey_get_key_exists(sc)
3005 get_key_exists = staticmethod(get_key_exists)
3007 def get_string(self):
3008 """get_string(ModelKey self) -> std::string const"""
3009 return _IMP_kernel.ModelKey_get_string(self)
3012 def __cmp__(self, o):
3013 """__cmp__(ModelKey self, ModelKey o) -> int"""
3014 return _IMP_kernel.ModelKey___cmp__(self, o)
3017 def __eq__(self, o):
3018 """__eq__(ModelKey self, ModelKey o) -> bool"""
3019 return _IMP_kernel.ModelKey___eq__(self, o)
3022 def __ne__(self, o):
3023 """__ne__(ModelKey self, ModelKey o) -> bool"""
3024 return _IMP_kernel.ModelKey___ne__(self, o)
3027 def __lt__(self, o):
3028 """__lt__(ModelKey self, ModelKey o) -> bool"""
3029 return _IMP_kernel.ModelKey___lt__(self, o)
3032 def __gt__(self, o):
3033 """__gt__(ModelKey self, ModelKey o) -> bool"""
3034 return _IMP_kernel.ModelKey___gt__(self, o)
3037 def __ge__(self, o):
3038 """__ge__(ModelKey self, ModelKey o) -> bool"""
3039 return _IMP_kernel.ModelKey___ge__(self, o)
3042 def __le__(self, o):
3043 """__le__(ModelKey self, ModelKey o) -> bool"""
3044 return _IMP_kernel.ModelKey___le__(self, o)
3048 """__hash__(ModelKey self) -> std::size_t"""
3049 return _IMP_kernel.ModelKey___hash__(self)
3052 def show(self, *args):
3054 show(ModelKey self, _ostream out)
3057 return _IMP_kernel.ModelKey_show(self, *args)
3060 def add_alias(old_key, new_name):
3061 """add_alias(ModelKey old_key, std::string new_name) -> ModelKey"""
3062 return _IMP_kernel.ModelKey_add_alias(old_key, new_name)
3064 add_alias = staticmethod(add_alias)
3066 def get_number_of_keys():
3067 """get_number_of_keys() -> unsigned int"""
3068 return _IMP_kernel.ModelKey_get_number_of_keys()
3070 get_number_of_keys = staticmethod(get_number_of_keys)
3073 """get_index(ModelKey self) -> unsigned int"""
3074 return _IMP_kernel.ModelKey_get_index(self)
3078 """show_all(_ostream out)"""
3079 return _IMP_kernel.ModelKey_show_all(out)
3081 show_all = staticmethod(show_all)
3083 def get_all_strings():
3084 """get_all_strings() -> IMP::Vector< std::string >"""
3085 return _IMP_kernel.ModelKey_get_all_strings()
3087 get_all_strings = staticmethod(get_all_strings)
3089 def get_number_unique():
3090 """get_number_unique() -> unsigned int"""
3091 return _IMP_kernel.ModelKey_get_number_unique()
3093 get_number_unique = staticmethod(get_number_unique)
3096 """__str__(ModelKey self) -> std::string"""
3097 return _IMP_kernel.ModelKey___str__(self)
3101 """__repr__(ModelKey self) -> std::string"""
3102 return _IMP_kernel.ModelKey___repr__(self)
3104 __swig_destroy__ = _IMP_kernel.delete_ModelKey
3105 __del__ =
lambda self:
None
3106 ModelKey_swigregister = _IMP_kernel.ModelKey_swigregister
3107 ModelKey_swigregister(ModelKey)
3109 def ModelKey_add_key(sc):
3110 """ModelKey_add_key(std::string sc) -> unsigned int"""
3111 return _IMP_kernel.ModelKey_add_key(sc)
3113 def ModelKey_get_key_exists(sc):
3114 """ModelKey_get_key_exists(std::string sc) -> bool"""
3115 return _IMP_kernel.ModelKey_get_key_exists(sc)
3117 def ModelKey_add_alias(old_key, new_name):
3118 """ModelKey_add_alias(ModelKey old_key, std::string new_name) -> ModelKey"""
3119 return _IMP_kernel.ModelKey_add_alias(old_key, new_name)
3121 def ModelKey_get_number_of_keys():
3122 """ModelKey_get_number_of_keys() -> unsigned int"""
3123 return _IMP_kernel.ModelKey_get_number_of_keys()
3125 def ModelKey_show_all(out):
3126 """ModelKey_show_all(_ostream out)"""
3127 return _IMP_kernel.ModelKey_show_all(out)
3129 def ModelKey_get_all_strings():
3130 """ModelKey_get_all_strings() -> IMP::Vector< std::string >"""
3131 return _IMP_kernel.ModelKey_get_all_strings()
3133 def ModelKey_get_number_unique():
3134 """ModelKey_get_number_unique() -> unsigned int"""
3135 return _IMP_kernel.ModelKey_get_number_unique()
3138 """Proxy of C++ IMP::Index<(IMP::ParticleIndexTag)> class."""
3140 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3142 def __init__(self, *args):
3144 __init__(IMP::Index<(IMP::ParticleIndexTag)> self, int i) -> ParticleIndex
3145 __init__(IMP::Index<(IMP::ParticleIndexTag)> self) -> ParticleIndex
3147 this = _IMP_kernel.new_ParticleIndex(*args)
3149 self.this.append(this)
3150 except __builtin__.Exception:
3154 """get_index(ParticleIndex self) -> int"""
3155 return _IMP_kernel.ParticleIndex_get_index(self)
3158 def __cmp__(self, o):
3159 """__cmp__(ParticleIndex self, ParticleIndex o) -> int"""
3160 return _IMP_kernel.ParticleIndex___cmp__(self, o)
3163 def __eq__(self, o):
3164 """__eq__(ParticleIndex self, ParticleIndex o) -> bool"""
3165 return _IMP_kernel.ParticleIndex___eq__(self, o)
3168 def __ne__(self, o):
3169 """__ne__(ParticleIndex self, ParticleIndex o) -> bool"""
3170 return _IMP_kernel.ParticleIndex___ne__(self, o)
3173 def __lt__(self, o):
3174 """__lt__(ParticleIndex self, ParticleIndex o) -> bool"""
3175 return _IMP_kernel.ParticleIndex___lt__(self, o)
3178 def __gt__(self, o):
3179 """__gt__(ParticleIndex self, ParticleIndex o) -> bool"""
3180 return _IMP_kernel.ParticleIndex___gt__(self, o)
3183 def __ge__(self, o):
3184 """__ge__(ParticleIndex self, ParticleIndex o) -> bool"""
3185 return _IMP_kernel.ParticleIndex___ge__(self, o)
3188 def __le__(self, o):
3189 """__le__(ParticleIndex self, ParticleIndex o) -> bool"""
3190 return _IMP_kernel.ParticleIndex___le__(self, o)
3193 def show(self, *args):
3195 show(ParticleIndex self, _ostream out)
3196 show(ParticleIndex self)
3198 return _IMP_kernel.ParticleIndex_show(self, *args)
3202 """__hash__(ParticleIndex self) -> std::size_t"""
3203 return _IMP_kernel.ParticleIndex___hash__(self)
3207 """__str__(ParticleIndex self) -> std::string"""
3208 return _IMP_kernel.ParticleIndex___str__(self)
3212 """__repr__(ParticleIndex self) -> std::string"""
3213 return _IMP_kernel.ParticleIndex___repr__(self)
3215 __swig_destroy__ = _IMP_kernel.delete_ParticleIndex
3216 __del__ =
lambda self:
None
3217 ParticleIndex_swigregister = _IMP_kernel.ParticleIndex_swigregister
3218 ParticleIndex_swigregister(ParticleIndex)
3228 class FloatIndex(_Value):
3229 """Proxy of C++ IMP::FloatIndex class."""
3231 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3233 def __init__(self, *args):
3235 __init__(IMP::FloatIndex self, ParticleIndex i0, FloatKey i1) -> FloatIndex
3236 __init__(IMP::FloatIndex self, ParticleIndex i0) -> FloatIndex
3237 __init__(IMP::FloatIndex self) -> FloatIndex
3239 this = _IMP_kernel.new_FloatIndex(*args)
3241 self.this.append(this)
3242 except __builtin__.Exception:
3246 """__hash__(FloatIndex self) -> std::size_t"""
3247 return _IMP_kernel.FloatIndex___hash__(self)
3250 def show(self, *args):
3252 show(FloatIndex self, _ostream out)
3253 show(FloatIndex self)
3255 return _IMP_kernel.FloatIndex_show(self, *args)
3258 def __cmp__(self, o):
3259 """__cmp__(FloatIndex self, FloatIndex o) -> int"""
3260 return _IMP_kernel.FloatIndex___cmp__(self, o)
3263 def __eq__(self, o):
3264 """__eq__(FloatIndex self, FloatIndex o) -> bool"""
3265 return _IMP_kernel.FloatIndex___eq__(self, o)
3268 def __ne__(self, o):
3269 """__ne__(FloatIndex self, FloatIndex o) -> bool"""
3270 return _IMP_kernel.FloatIndex___ne__(self, o)
3273 def __lt__(self, o):
3274 """__lt__(FloatIndex self, FloatIndex o) -> bool"""
3275 return _IMP_kernel.FloatIndex___lt__(self, o)
3278 def __gt__(self, o):
3279 """__gt__(FloatIndex self, FloatIndex o) -> bool"""
3280 return _IMP_kernel.FloatIndex___gt__(self, o)
3283 def __ge__(self, o):
3284 """__ge__(FloatIndex self, FloatIndex o) -> bool"""
3285 return _IMP_kernel.FloatIndex___ge__(self, o)
3288 def __le__(self, o):
3289 """__le__(FloatIndex self, FloatIndex o) -> bool"""
3290 return _IMP_kernel.FloatIndex___le__(self, o)
3293 def get_particle(self):
3294 """get_particle(FloatIndex self) -> ParticleIndex const &"""
3295 return _IMP_kernel.FloatIndex_get_particle(self)
3298 def set_particle(self, v):
3299 """set_particle(FloatIndex self, ParticleIndex const & v)"""
3300 return _IMP_kernel.FloatIndex_set_particle(self, v)
3304 """get_key(FloatIndex self) -> FloatKey const &"""
3305 return _IMP_kernel.FloatIndex_get_key(self)
3308 def set_key(self, v):
3309 """set_key(FloatIndex self, FloatKey const & v)"""
3310 return _IMP_kernel.FloatIndex_set_key(self, v)
3314 """__str__(FloatIndex self) -> std::string"""
3315 return _IMP_kernel.FloatIndex___str__(self)
3319 """__repr__(FloatIndex self) -> std::string"""
3320 return _IMP_kernel.FloatIndex___repr__(self)
3322 __swig_destroy__ = _IMP_kernel.delete_FloatIndex
3323 __del__ =
lambda self:
None
3324 FloatIndex_swigregister = _IMP_kernel.FloatIndex_swigregister
3325 FloatIndex_swigregister(FloatIndex)
3327 class _ParticleIndexTag(object):
3328 """Proxy of C++ IMP::ParticleIndexTag class."""
3330 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3331 __repr__ = _swig_repr
3334 """__init__(IMP::ParticleIndexTag self) -> _ParticleIndexTag"""
3335 this = _IMP_kernel.new__ParticleIndexTag()
3337 self.this.append(this)
3338 except __builtin__.Exception:
3340 __swig_destroy__ = _IMP_kernel.delete__ParticleIndexTag
3341 __del__ =
lambda self:
None
3342 _ParticleIndexTag_swigregister = _IMP_kernel._ParticleIndexTag_swigregister
3343 _ParticleIndexTag_swigregister(_ParticleIndexTag)
3345 class ModelObject(Object):
3346 """Proxy of C++ IMP::ModelObject class."""
3348 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3350 def __init__(self, m, name):
3351 """__init__(IMP::ModelObject self, Model m, std::string name) -> ModelObject"""
3352 if self.__class__ == ModelObject:
3356 this = _IMP_kernel.new_ModelObject(_self, m, name)
3358 self.this.append(this)
3359 except __builtin__.Exception:
3362 if self.__class__ != ModelObject:
3363 _director_objects.register(self)
3367 __swig_destroy__ = _IMP_kernel.delete_ModelObject
3368 __del__ =
lambda self:
None
3370 def get_model(self):
3371 """get_model(ModelObject self) -> Model"""
3372 return _IMP_kernel.ModelObject_get_model(self)
3375 def get_inputs(self):
3376 """get_inputs(ModelObject self) -> IMP::ModelObjectsTemp"""
3377 return _IMP_kernel.ModelObject_get_inputs(self)
3380 def get_outputs(self):
3381 """get_outputs(ModelObject self) -> IMP::ModelObjectsTemp"""
3382 return _IMP_kernel.ModelObject_get_outputs(self)
3385 def get_interactions(self):
3386 """get_interactions(ModelObject self) -> IMP::ModelObjectsTemps"""
3387 return _IMP_kernel.ModelObject_get_interactions(self)
3390 def get_has_dependencies(self):
3391 """get_has_dependencies(ModelObject self) -> bool"""
3392 return _IMP_kernel.ModelObject_get_has_dependencies(self)
3395 def set_has_dependencies(self, tf):
3396 """set_has_dependencies(ModelObject self, bool tf)"""
3397 return _IMP_kernel.ModelObject_set_has_dependencies(self, tf)
3400 def set_has_required_score_states(self, tf):
3401 """set_has_required_score_states(ModelObject self, bool tf)"""
3402 return _IMP_kernel.ModelObject_set_has_required_score_states(self, tf)
3405 def get_has_required_score_states(self):
3406 """get_has_required_score_states(ModelObject self) -> bool"""
3407 return _IMP_kernel.ModelObject_get_has_required_score_states(self)
3411 """get_required_score_states(ModelObject self) -> IMP::ScoreStatesTemp const &"""
3412 return _IMP_kernel.ModelObject_get_required_score_states(self)
3415 def handle_set_has_required_score_states(self, arg0):
3416 """handle_set_has_required_score_states(ModelObject self, bool arg0)"""
3417 return _IMP_kernel.ModelObject_handle_set_has_required_score_states(self, arg0)
3420 def do_get_inputs(self):
3421 """do_get_inputs(ModelObject self) -> IMP::ModelObjectsTemp"""
3422 return _IMP_kernel.ModelObject_do_get_inputs(self)
3425 def do_get_outputs(self):
3426 """do_get_outputs(ModelObject self) -> IMP::ModelObjectsTemp"""
3427 return _IMP_kernel.ModelObject_do_get_outputs(self)
3430 def do_get_interactions(self):
3431 """do_get_interactions(ModelObject self) -> IMP::ModelObjectsTemps"""
3432 return _IMP_kernel.ModelObject_do_get_interactions(self)
3436 """__str__(ModelObject self) -> std::string"""
3437 return _IMP_kernel.ModelObject___str__(self)
3441 """__repr__(ModelObject self) -> std::string"""
3442 return _IMP_kernel.ModelObject___repr__(self)
3447 return _object_cast_to_ModelObject(o)
3450 def get_type_name(self):
3451 return self.__class__.__name__
3452 def do_show(self, out):
3454 def get_version_info(self):
3456 return VersionInfo(self.__module__,
3457 __import__(self.__module__).get_module_version())
3460 __import__(self.__module__).get_module_version())
3463 return _object_cast_to_ModelObject(o)
3465 def __disown__(self):
3467 _IMP_kernel.disown_ModelObject(self)
3468 return weakref_proxy(self)
3470 def do_destroy(self):
3471 """do_destroy(ModelObject self)"""
3472 return _IMP_kernel.ModelObject_do_destroy(self)
3474 ModelObject_swigregister = _IMP_kernel.ModelObject_swigregister
3475 ModelObject_swigregister(ModelObject)
3476 cvar = _IMP_kernel.cvar
3477 NO_MAX = cvar.NO_MAX
3478 BAD_SCORE = cvar.BAD_SCORE
3480 class _ParticleInputs(object):
3481 """Proxy of C++ IMP::ParticleInputs class."""
3483 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3485 def __init__(self, *args, **kwargs):
3486 raise AttributeError(
"No constructor defined - class is abstract")
3487 __repr__ = _swig_repr
3489 def get_inputs(self, m, pis):
3490 """get_inputs(_ParticleInputs self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
3491 return _IMP_kernel._ParticleInputs_get_inputs(self, m, pis)
3493 _ParticleInputs_swigregister = _IMP_kernel._ParticleInputs_swigregister
3494 _ParticleInputs_swigregister(_ParticleInputs)
3496 class _ParticleOutputs(object):
3497 """Proxy of C++ IMP::ParticleOutputs class."""
3499 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3501 def __init__(self, *args, **kwargs):
3502 raise AttributeError(
"No constructor defined - class is abstract")
3503 __repr__ = _swig_repr
3505 def get_outputs(self, m, pis):
3506 """get_outputs(_ParticleOutputs self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
3507 return _IMP_kernel._ParticleOutputs_get_outputs(self, m, pis)
3509 _ParticleOutputs_swigregister = _IMP_kernel._ParticleOutputs_swigregister
3510 _ParticleOutputs_swigregister(_ParticleOutputs)
3514 """get_input_particles(IMP::ModelObjectsTemp const & mos) -> IMP::ParticlesTemp"""
3515 return _IMP_kernel.get_input_particles(mos)
3518 """get_input_containers(IMP::ModelObjectsTemp const & mos) -> IMP::ContainersTemp"""
3519 return _IMP_kernel.get_input_containers(mos)
3522 """get_output_particles(IMP::ModelObjectsTemp const & mos) -> IMP::ParticlesTemp"""
3523 return _IMP_kernel.get_output_particles(mos)
3526 """get_output_containers(IMP::ModelObjectsTemp const & mos) -> IMP::ContainersTemp"""
3527 return _IMP_kernel.get_output_containers(mos)
3528 class DerivativeAccumulator(object):
3529 """Proxy of C++ IMP::DerivativeAccumulator class."""
3531 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3532 __repr__ = _swig_repr
3534 def __init__(self, *args):
3536 __init__(IMP::DerivativeAccumulator self, double weight=1.0) -> DerivativeAccumulator
3537 __init__(IMP::DerivativeAccumulator self) -> DerivativeAccumulator
3538 __init__(IMP::DerivativeAccumulator self, DerivativeAccumulator copy, double weight) -> DerivativeAccumulator
3540 this = _IMP_kernel.new_DerivativeAccumulator(*args)
3542 self.this.append(this)
3543 except __builtin__.Exception:
3546 def __call__(self, value):
3547 """__call__(DerivativeAccumulator self, double const value) -> double"""
3548 return _IMP_kernel.DerivativeAccumulator___call__(self, value)
3551 def get_weight(self):
3552 """get_weight(DerivativeAccumulator self) -> double"""
3553 return _IMP_kernel.DerivativeAccumulator_get_weight(self)
3556 def show(self, *args):
3558 show(DerivativeAccumulator self, _ostream out)
3559 show(DerivativeAccumulator self)
3561 return _IMP_kernel.DerivativeAccumulator_show(self, *args)
3563 __swig_destroy__ = _IMP_kernel.delete_DerivativeAccumulator
3564 __del__ =
lambda self:
None
3565 DerivativeAccumulator_swigregister = _IMP_kernel.DerivativeAccumulator_swigregister
3566 DerivativeAccumulator_swigregister(DerivativeAccumulator)
3568 class EvaluationState(object):
3569 """Proxy of C++ IMP::EvaluationState class."""
3571 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3572 score = _swig_property(_IMP_kernel.EvaluationState_score_get, _IMP_kernel.EvaluationState_score_set)
3573 good = _swig_property(_IMP_kernel.EvaluationState_good_get, _IMP_kernel.EvaluationState_good_set)
3575 def __init__(self, *args):
3577 __init__(IMP::EvaluationState self, double oscore, bool ogood) -> EvaluationState
3578 __init__(IMP::EvaluationState self) -> EvaluationState
3580 this = _IMP_kernel.new_EvaluationState(*args)
3582 self.this.append(this)
3583 except __builtin__.Exception:
3586 def show(self, *args):
3588 show(EvaluationState self, _ostream out)
3589 show(EvaluationState self)
3591 return _IMP_kernel.EvaluationState_show(self, *args)
3595 """__str__(EvaluationState self) -> std::string"""
3596 return _IMP_kernel.EvaluationState___str__(self)
3600 """__repr__(EvaluationState self) -> std::string"""
3601 return _IMP_kernel.EvaluationState___repr__(self)
3603 __swig_destroy__ = _IMP_kernel.delete_EvaluationState
3604 __del__ =
lambda self:
None
3605 EvaluationState_swigregister = _IMP_kernel.EvaluationState_swigregister
3606 EvaluationState_swigregister(EvaluationState)
3608 class ScoreAccumulator(_Value):
3609 """Proxy of C++ IMP::ScoreAccumulator class."""
3611 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3613 def __init__(self, *args):
3615 __init__(IMP::ScoreAccumulator self) -> ScoreAccumulator
3616 __init__(IMP::ScoreAccumulator self, ScoreAccumulator o, Restraint r) -> ScoreAccumulator
3617 __init__(IMP::ScoreAccumulator self, ScoreAccumulator o, double weight, double local_max) -> ScoreAccumulator
3619 this = _IMP_kernel.new_ScoreAccumulator(*args)
3621 self.this.append(this)
3622 except __builtin__.Exception:
3625 def add_score(self, score):
3626 """add_score(ScoreAccumulator self, double score)"""
3627 return _IMP_kernel.ScoreAccumulator_add_score(self, score)
3630 def get_abort_evaluation(self):
3631 """get_abort_evaluation(ScoreAccumulator self) -> bool"""
3632 return _IMP_kernel.ScoreAccumulator_get_abort_evaluation(self)
3635 def get_is_evaluate_if_below(self):
3636 """get_is_evaluate_if_below(ScoreAccumulator self) -> bool"""
3637 return _IMP_kernel.ScoreAccumulator_get_is_evaluate_if_below(self)
3640 def get_is_evaluate_if_good(self):
3641 """get_is_evaluate_if_good(ScoreAccumulator self) -> bool"""
3642 return _IMP_kernel.ScoreAccumulator_get_is_evaluate_if_good(self)
3645 def get_maximum(self):
3646 """get_maximum(ScoreAccumulator self) -> double"""
3647 return _IMP_kernel.ScoreAccumulator_get_maximum(self)
3650 def get_derivative_accumulator(self):
3651 """get_derivative_accumulator(ScoreAccumulator self) -> DerivativeAccumulator"""
3652 return _IMP_kernel.ScoreAccumulator_get_derivative_accumulator(self)
3655 def show(self, *args):
3657 show(ScoreAccumulator self, _ostream out)
3658 show(ScoreAccumulator self)
3660 return _IMP_kernel.ScoreAccumulator_show(self, *args)
3664 """__str__(ScoreAccumulator self) -> std::string"""
3665 return _IMP_kernel.ScoreAccumulator___str__(self)
3669 """__repr__(ScoreAccumulator self) -> std::string"""
3670 return _IMP_kernel.ScoreAccumulator___repr__(self)
3672 __swig_destroy__ = _IMP_kernel.delete_ScoreAccumulator
3673 __del__ =
lambda self:
None
3674 ScoreAccumulator_swigregister = _IMP_kernel.ScoreAccumulator_swigregister
3675 ScoreAccumulator_swigregister(ScoreAccumulator)
3677 class ScoreState(ModelObject):
3678 """Proxy of C++ IMP::ScoreState class."""
3680 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3682 def __init__(self, m, name):
3683 """__init__(IMP::ScoreState self, Model m, std::string name) -> ScoreState"""
3684 if self.__class__ == ScoreState:
3688 this = _IMP_kernel.new_ScoreState(_self, m, name)
3690 self.this.append(this)
3691 except __builtin__.Exception:
3694 if self.__class__ != ScoreState:
3695 _director_objects.register(self)
3700 def before_evaluate(self):
3701 """before_evaluate(ScoreState self)"""
3702 return _IMP_kernel.ScoreState_before_evaluate(self)
3705 def after_evaluate(self, accpt):
3706 """after_evaluate(ScoreState self, DerivativeAccumulator accpt)"""
3707 return _IMP_kernel.ScoreState_after_evaluate(self, accpt)
3710 def get_has_update_order(self):
3711 """get_has_update_order(ScoreState self) -> bool"""
3712 return _IMP_kernel.ScoreState_get_has_update_order(self)
3716 """get_update_order(ScoreState self) -> unsigned int"""
3717 return _IMP_kernel.ScoreState_get_update_order(self)
3720 def handle_set_has_required_score_states(self, tf):
3721 """handle_set_has_required_score_states(ScoreState self, bool tf)"""
3722 return _IMP_kernel.ScoreState_handle_set_has_required_score_states(self, tf)
3725 def do_before_evaluate(self):
3726 """do_before_evaluate(ScoreState self)"""
3727 return _IMP_kernel.ScoreState_do_before_evaluate(self)
3730 def do_after_evaluate(self, accpt):
3731 """do_after_evaluate(ScoreState self, DerivativeAccumulator accpt)"""
3732 return _IMP_kernel.ScoreState_do_after_evaluate(self, accpt)
3734 __swig_destroy__ = _IMP_kernel.delete_ScoreState
3735 __del__ =
lambda self:
None
3738 """__str__(ScoreState self) -> std::string"""
3739 return _IMP_kernel.ScoreState___str__(self)
3743 """__repr__(ScoreState self) -> std::string"""
3744 return _IMP_kernel.ScoreState___repr__(self)
3749 return _object_cast_to_ScoreState(o)
3752 def get_type_name(self):
3753 return self.__class__.__name__
3754 def do_show(self, out):
3756 def get_version_info(self):
3758 return VersionInfo(self.__module__,
3759 __import__(self.__module__).get_module_version())
3762 __import__(self.__module__).get_module_version())
3765 return _object_cast_to_ScoreState(o)
3767 def __disown__(self):
3769 _IMP_kernel.disown_ScoreState(self)
3770 return weakref_proxy(self)
3772 def do_destroy(self):
3773 """do_destroy(ScoreState self)"""
3774 return _IMP_kernel.ScoreState_do_destroy(self)
3777 def do_get_inputs(self):
3778 """do_get_inputs(ScoreState self) -> IMP::ModelObjectsTemp"""
3779 return _IMP_kernel.ScoreState_do_get_inputs(self)
3782 def do_get_outputs(self):
3783 """do_get_outputs(ScoreState self) -> IMP::ModelObjectsTemp"""
3784 return _IMP_kernel.ScoreState_do_get_outputs(self)
3787 def do_get_interactions(self):
3788 """do_get_interactions(ScoreState self) -> IMP::ModelObjectsTemps"""
3789 return _IMP_kernel.ScoreState_do_get_interactions(self)
3791 ScoreState_swigregister = _IMP_kernel.ScoreState_swigregister
3792 ScoreState_swigregister(ScoreState)
3796 """get_update_order(IMP::ScoreStatesTemp input) -> IMP::ScoreStatesTemp"""
3797 return _IMP_kernel.get_update_order(input)
3798 class Constraint(ScoreState):
3799 """Proxy of C++ IMP::Constraint class."""
3801 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3803 def __init__(self, *args):
3805 __init__(IMP::Constraint self, Model m, std::string name) -> Constraint
3806 __init__(IMP::Constraint self, Model m) -> Constraint
3808 if self.__class__ == Constraint:
3812 this = _IMP_kernel.new_Constraint(_self, *args)
3814 self.this.append(this)
3815 except __builtin__.Exception:
3818 if self.__class__ != Constraint:
3819 _director_objects.register(self)
3824 def do_update_attributes(self):
3825 """do_update_attributes(Constraint self)"""
3826 return _IMP_kernel.Constraint_do_update_attributes(self)
3829 def do_update_derivatives(self, da):
3830 """do_update_derivatives(Constraint self, DerivativeAccumulator da)"""
3831 return _IMP_kernel.Constraint_do_update_derivatives(self, da)
3834 def do_before_evaluate(self):
3835 """do_before_evaluate(Constraint self)"""
3836 return _IMP_kernel.Constraint_do_before_evaluate(self)
3839 def do_after_evaluate(self, da):
3840 """do_after_evaluate(Constraint self, DerivativeAccumulator da)"""
3841 return _IMP_kernel.Constraint_do_after_evaluate(self, da)
3843 __swig_destroy__ = _IMP_kernel.delete_Constraint
3844 __del__ =
lambda self:
None
3847 """__str__(Constraint self) -> std::string"""
3848 return _IMP_kernel.Constraint___str__(self)
3852 """__repr__(Constraint self) -> std::string"""
3853 return _IMP_kernel.Constraint___repr__(self)
3858 return _object_cast_to_Constraint(o)
3861 def get_type_name(self):
3862 return self.__class__.__name__
3863 def do_show(self, out):
3865 def get_version_info(self):
3867 return VersionInfo(self.__module__,
3868 __import__(self.__module__).get_module_version())
3871 __import__(self.__module__).get_module_version())
3874 return _object_cast_to_Constraint(o)
3876 def __disown__(self):
3878 _IMP_kernel.disown_Constraint(self)
3879 return weakref_proxy(self)
3881 def do_destroy(self):
3882 """do_destroy(Constraint self)"""
3883 return _IMP_kernel.Constraint_do_destroy(self)
3886 def do_get_inputs(self):
3887 """do_get_inputs(Constraint self) -> IMP::ModelObjectsTemp"""
3888 return _IMP_kernel.Constraint_do_get_inputs(self)
3891 def do_get_outputs(self):
3892 """do_get_outputs(Constraint self) -> IMP::ModelObjectsTemp"""
3893 return _IMP_kernel.Constraint_do_get_outputs(self)
3896 def do_get_interactions(self):
3897 """do_get_interactions(Constraint self) -> IMP::ModelObjectsTemps"""
3898 return _IMP_kernel.Constraint_do_get_interactions(self)
3900 Constraint_swigregister = _IMP_kernel.Constraint_swigregister
3901 Constraint_swigregister(Constraint)
3903 class Container(ModelObject):
3904 """Proxy of C++ IMP::Container class."""
3906 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3908 def __init__(self, *args):
3910 __init__(IMP::Container self, Model m, std::string name) -> Container
3911 __init__(IMP::Container self, Model m) -> Container
3913 if self.__class__ == Container:
3917 this = _IMP_kernel.new_Container(_self, *args)
3919 self.this.append(this)
3920 except __builtin__.Exception:
3923 if self.__class__ != Container:
3924 _director_objects.register(self)
3929 def do_get_contents_hash(self):
3930 """do_get_contents_hash(Container self) -> std::size_t"""
3931 return _IMP_kernel.Container_do_get_contents_hash(self)
3934 def get_all_possible_indexes(self):
3935 """get_all_possible_indexes(Container self) -> IMP::ParticleIndexes"""
3936 return _IMP_kernel.Container_get_all_possible_indexes(self)
3939 def get_contents_hash(self):
3940 """get_contents_hash(Container self) -> std::size_t"""
3941 return _IMP_kernel.Container_get_contents_hash(self)
3944 def do_get_outputs(self):
3945 """do_get_outputs(Container self) -> IMP::ModelObjectsTemp"""
3946 return _IMP_kernel.Container_do_get_outputs(self)
3949 def get_is_decomposable(self):
3950 """get_is_decomposable(Container self) -> bool"""
3951 return _IMP_kernel.Container_get_is_decomposable(self)
3954 def validate_readable(self):
3955 """validate_readable(Container self)"""
3956 return _IMP_kernel.Container_validate_readable(self)
3959 def validate_writable(self):
3960 """validate_writable(Container self)"""
3961 return _IMP_kernel.Container_validate_writable(self)
3964 def set_is_readable(self, tf):
3965 """set_is_readable(Container self, bool tf)"""
3966 return _IMP_kernel.Container_set_is_readable(self, tf)
3969 def set_is_writable(self, tf):
3970 """set_is_writable(Container self, bool tf)"""
3971 return _IMP_kernel.Container_set_is_writable(self, tf)
3973 __swig_destroy__ = _IMP_kernel.delete_Container
3974 __del__ =
lambda self:
None
3977 """__str__(Container self) -> std::string"""
3978 return _IMP_kernel.Container___str__(self)
3982 """__repr__(Container self) -> std::string"""
3983 return _IMP_kernel.Container___repr__(self)
3988 return _object_cast_to_Container(o)
3991 def get_type_name(self):
3992 return self.__class__.__name__
3993 def do_show(self, out):
3995 def get_version_info(self):
3997 return VersionInfo(self.__module__,
3998 __import__(self.__module__).get_module_version())
4001 __import__(self.__module__).get_module_version())
4004 return _object_cast_to_Container(o)
4006 def __disown__(self):
4008 _IMP_kernel.disown_Container(self)
4009 return weakref_proxy(self)
4011 def do_destroy(self):
4012 """do_destroy(Container self)"""
4013 return _IMP_kernel.Container_do_destroy(self)
4016 def handle_set_has_required_score_states(self, arg0):
4017 """handle_set_has_required_score_states(Container self, bool arg0)"""
4018 return _IMP_kernel.Container_handle_set_has_required_score_states(self, arg0)
4021 def do_get_inputs(self):
4022 """do_get_inputs(Container self) -> IMP::ModelObjectsTemp"""
4023 return _IMP_kernel.Container_do_get_inputs(self)
4026 def do_get_interactions(self):
4027 """do_get_interactions(Container self) -> IMP::ModelObjectsTemps"""
4028 return _IMP_kernel.Container_do_get_interactions(self)
4030 Container_swigregister = _IMP_kernel.Container_swigregister
4031 Container_swigregister(Container)
4033 class Restraint(ModelObject):
4034 """Proxy of C++ IMP::Restraint class."""
4036 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
4038 def __init__(self, m, name):
4039 """__init__(IMP::Restraint self, Model m, std::string name) -> Restraint"""
4040 if self.__class__ == Restraint:
4044 this = _IMP_kernel.new_Restraint(_self, m, name)
4046 self.this.append(this)
4047 except __builtin__.Exception:
4050 if self.__class__ != Restraint:
4051 _director_objects.register(self)
4056 def get_score(self):
4057 """get_score(Restraint self) -> double"""
4058 return _IMP_kernel.Restraint_get_score(self)
4061 def evaluate(self, calc_derivs):
4062 """evaluate(Restraint self, bool calc_derivs) -> double"""
4063 return _IMP_kernel.Restraint_evaluate(self, calc_derivs)
4066 def evaluate_if_good(self, calc_derivatives):
4067 """evaluate_if_good(Restraint self, bool calc_derivatives) -> double"""
4068 return _IMP_kernel.Restraint_evaluate_if_good(self, calc_derivatives)
4071 def evaluate_if_below(self, calc_derivatives, max):
4072 """evaluate_if_below(Restraint self, bool calc_derivatives, double max) -> double"""
4073 return _IMP_kernel.Restraint_evaluate_if_below(self, calc_derivatives, max)
4076 def unprotected_evaluate(self, da):
4077 """unprotected_evaluate(Restraint self, DerivativeAccumulator da) -> double"""
4078 return _IMP_kernel.Restraint_unprotected_evaluate(self, da)
4081 def unprotected_evaluate_if_good(self, da, max):
4082 """unprotected_evaluate_if_good(Restraint self, DerivativeAccumulator da, double max) -> double"""
4083 return _IMP_kernel.Restraint_unprotected_evaluate_if_good(self, da, max)
4086 def unprotected_evaluate_if_below(self, da, max):
4087 """unprotected_evaluate_if_below(Restraint self, DerivativeAccumulator da, double max) -> double"""
4088 return _IMP_kernel.Restraint_unprotected_evaluate_if_below(self, da, max)
4091 def add_score_and_derivatives(self, sa):
4092 """add_score_and_derivatives(Restraint self, ScoreAccumulator sa)"""
4093 return _IMP_kernel.Restraint_add_score_and_derivatives(self, sa)
4097 """create_decomposition(Restraint self) -> Restraint"""
4098 return _IMP_kernel.Restraint_create_decomposition(self)
4101 def create_current_decomposition(self):
4102 """create_current_decomposition(Restraint self) -> Restraint"""
4103 return _IMP_kernel.Restraint_create_current_decomposition(self)
4106 def set_weight(self, weight):
4107 """set_weight(Restraint self, IMP::Float weight)"""
4108 return _IMP_kernel.Restraint_set_weight(self, weight)
4111 def get_weight(self):
4112 """get_weight(Restraint self) -> IMP::Float"""
4113 return _IMP_kernel.Restraint_get_weight(self)
4116 def get_maximum_score(self):
4117 """get_maximum_score(Restraint self) -> double"""
4118 return _IMP_kernel.Restraint_get_maximum_score(self)
4121 def set_maximum_score(self, s):
4122 """set_maximum_score(Restraint self, double s)"""
4123 return _IMP_kernel.Restraint_set_maximum_score(self, s)
4128 create_scoring_function(Restraint self, double weight=1.0, double max) -> ScoringFunction
4129 create_scoring_function(Restraint self, double weight=1.0) -> ScoringFunction
4130 create_scoring_function(Restraint self) -> ScoringFunction
4132 return _IMP_kernel.Restraint_create_scoring_function(self, *args)
4135 def set_last_score(self, s):
4136 """set_last_score(Restraint self, double s)"""
4137 return _IMP_kernel.Restraint_set_last_score(self, s)
4140 def get_last_score(self):
4141 """get_last_score(Restraint self) -> double"""
4142 return _IMP_kernel.Restraint_get_last_score(self)
4145 def get_was_good(self):
4146 """get_was_good(Restraint self) -> bool"""
4147 return _IMP_kernel.Restraint_get_was_good(self)
4149 __swig_destroy__ = _IMP_kernel.delete_Restraint
4150 __del__ =
lambda self:
None
4152 def do_create_decomposition(self):
4153 """do_create_decomposition(Restraint self) -> IMP::Restraints"""
4154 return _IMP_kernel.Restraint_do_create_decomposition(self)
4157 def do_create_current_decomposition(self):
4158 """do_create_current_decomposition(Restraint self) -> IMP::Restraints"""
4159 return _IMP_kernel.Restraint_do_create_current_decomposition(self)
4162 def do_add_score_and_derivatives(self, sa):
4163 """do_add_score_and_derivatives(Restraint self, ScoreAccumulator sa)"""
4164 return _IMP_kernel.Restraint_do_add_score_and_derivatives(self, sa)
4167 def do_get_outputs(self):
4168 """do_get_outputs(Restraint self) -> IMP::ModelObjectsTemp"""
4169 return _IMP_kernel.Restraint_do_get_outputs(self)
4173 """__str__(Restraint self) -> std::string"""
4174 return _IMP_kernel.Restraint___str__(self)
4178 """__repr__(Restraint self) -> std::string"""
4179 return _IMP_kernel.Restraint___repr__(self)
4184 return _object_cast_to_Restraint(o)
4187 def get_type_name(self):
4188 return self.__class__.__name__
4189 def do_show(self, out):
4191 def get_version_info(self):
4193 return VersionInfo(self.__module__,
4194 __import__(self.__module__).get_module_version())
4197 __import__(self.__module__).get_module_version())
4200 return _object_cast_to_Restraint(o)
4202 def __disown__(self):
4204 _IMP_kernel.disown_Restraint(self)
4205 return weakref_proxy(self)
4207 def do_destroy(self):
4208 """do_destroy(Restraint self)"""
4209 return _IMP_kernel.Restraint_do_destroy(self)
4212 def handle_set_has_required_score_states(self, arg0):
4213 """handle_set_has_required_score_states(Restraint self, bool arg0)"""
4214 return _IMP_kernel.Restraint_handle_set_has_required_score_states(self, arg0)
4217 def do_get_inputs(self):
4218 """do_get_inputs(Restraint self) -> IMP::ModelObjectsTemp"""
4219 return _IMP_kernel.Restraint_do_get_inputs(self)
4222 def do_get_interactions(self):
4223 """do_get_interactions(Restraint self) -> IMP::ModelObjectsTemps"""
4224 return _IMP_kernel.Restraint_do_get_interactions(self)
4226 Restraint_swigregister = _IMP_kernel.Restraint_swigregister
4227 Restraint_swigregister(Restraint)
4229 class _RestraintsAdaptor(_InputAdaptor):
4230 """Proxy of C++ IMP::RestraintsAdaptor class."""
4232 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
4233 __repr__ = _swig_repr
4235 def __init__(self, *args):
4237 __init__(IMP::RestraintsAdaptor self) -> _RestraintsAdaptor
4238 __init__(IMP::RestraintsAdaptor self, IMP::Restraints const & sf) -> _RestraintsAdaptor
4239 __init__(IMP::RestraintsAdaptor self, IMP::RestraintsTemp const & sf) -> _RestraintsAdaptor
4240 __init__(IMP::RestraintsAdaptor self, Restraint sf) -> _RestraintsAdaptor
4242 this = _IMP_kernel.new__RestraintsAdaptor(*args)
4244 self.this.append(this)
4245 except __builtin__.Exception:
4247 __swig_destroy__ = _IMP_kernel.delete__RestraintsAdaptor
4248 __del__ =
lambda self:
None
4249 _RestraintsAdaptor_swigregister = _IMP_kernel._RestraintsAdaptor_swigregister
4250 _RestraintsAdaptor_swigregister(_RestraintsAdaptor)
4252 class RestraintSet(Restraint):
4253 """Proxy of C++ IMP::RestraintSet class."""
4255 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
4257 def __init__(self, *args):
4259 __init__(IMP::RestraintSet self, Model m, double weight, std::string const & name) -> RestraintSet
4260 __init__(IMP::RestraintSet self, Model m, double weight) -> RestraintSet
4261 __init__(IMP::RestraintSet self, Model m, std::string const & name) -> RestraintSet
4262 __init__(IMP::RestraintSet self, Model m) -> RestraintSet
4263 __init__(IMP::RestraintSet self, IMP::RestraintsTemp const & rs, double weight, std::string const & name) -> RestraintSet
4264 __init__(IMP::RestraintSet self, IMP::RestraintsTemp const & rs, double weight) -> RestraintSet
4266 this = _IMP_kernel.new_RestraintSet(*args)
4268 self.this.append(this)
4269 except __builtin__.Exception:
4272 def get_version_info(self):
4273 """get_version_info(RestraintSet self) -> VersionInfo"""
4274 return _IMP_kernel.RestraintSet_get_version_info(self)
4277 def remove_restraint(self, d):
4278 """remove_restraint(RestraintSet self, Restraint d)"""
4279 return _IMP_kernel.RestraintSet_remove_restraint(self, d)
4282 def remove_restraints(self, d):
4283 """remove_restraints(RestraintSet self, IMP::Restraints const & d)"""
4284 return _IMP_kernel.RestraintSet_remove_restraints(self, d)
4287 def set_restraints(self, ps):
4288 """set_restraints(RestraintSet self, IMP::Restraints const & ps)"""
4289 return _IMP_kernel.RestraintSet_set_restraints(self, ps)
4292 def set_restraints_order(self, objs):
4293 """set_restraints_order(RestraintSet self, IMP::Restraints const & objs)"""
4294 return _IMP_kernel.RestraintSet_set_restraints_order(self, objs)
4298 """add_restraint(RestraintSet self, Restraint obj) -> unsigned int"""
4299 return _IMP_kernel.RestraintSet_add_restraint(self, obj)
4303 """add_restraints(RestraintSet self, IMP::Restraints const & objs)"""
4304 return _IMP_kernel.RestraintSet_add_restraints(self, objs)
4307 def clear_restraints(self):
4308 """clear_restraints(RestraintSet self)"""
4309 return _IMP_kernel.RestraintSet_clear_restraints(self)
4312 def get_number_of_restraints(self):
4313 """get_number_of_restraints(RestraintSet self) -> unsigned int"""
4314 return _IMP_kernel.RestraintSet_get_number_of_restraints(self)
4317 def get_has_restraints(self):
4318 """get_has_restraints(RestraintSet self) -> bool"""
4319 return _IMP_kernel.RestraintSet_get_has_restraints(self)
4322 def get_restraint(self, i):
4323 """get_restraint(RestraintSet self, unsigned int i) -> Restraint"""
4324 return _IMP_kernel.RestraintSet_get_restraint(self, i)
4327 def get_restraints(self):
4328 """get_restraints(RestraintSet self) -> IMP::Restraints"""
4329 return _IMP_kernel.RestraintSet_get_restraints(self)
4332 def reserve_restraints(self, sz):
4333 """reserve_restraints(RestraintSet self, unsigned int sz)"""
4334 return _IMP_kernel.RestraintSet_reserve_restraints(self, sz)
4337 def get_non_sets_and_sets(self):
4338 """get_non_sets_and_sets(RestraintSet self) -> std::pair< IMP::RestraintsTemp,IMP::RestraintSetsTemp >"""
4339 return _IMP_kernel.RestraintSet_get_non_sets_and_sets(self)
4342 def do_get_inputs(self):
4343 """do_get_inputs(RestraintSet self) -> IMP::ModelObjectsTemp"""
4344 return _IMP_kernel.RestraintSet_do_get_inputs(self)
4349 create_scoring_function(RestraintSet self, double weight=1.0, double max) -> ScoringFunction
4350 create_scoring_function(RestraintSet self, double weight=1.0) -> ScoringFunction
4351 create_scoring_function(RestraintSet self) -> ScoringFunction
4353 return _IMP_kernel.RestraintSet_create_scoring_function(self, *args)
4357 """__str__(RestraintSet self) -> std::string"""
4358 return _IMP_kernel.RestraintSet___str__(self)
4362 """__repr__(RestraintSet self) -> std::string"""
4363 return _IMP_kernel.RestraintSet___repr__(self)
4368 return _object_cast_to_RestraintSet(o)
4370 RestraintSet_swigregister = _IMP_kernel.RestraintSet_swigregister
4371 RestraintSet_swigregister(RestraintSet)
4374 def get_restraints(rs):
4375 """get_restraints(IMP::RestraintsTemp const & rs) -> IMP::RestraintsTemp"""
4376 return _IMP_kernel.get_restraints(rs)
4378 def _check_particle(p, a):
4379 if (
not p.get_is_active()):
4380 raise ValueError(
"Inactive Particle")
4381 if (type(a)() == a):
4382 raise IndexError(
"Cannot use default Index")
4383 if (
not p.has_attribute(a)):
4384 raise IndexError(
"Particle does not have attribute")
4386 class Particle(ModelObject):
4387 """Proxy of C++ IMP::Particle class."""
4389 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
4391 def get_version_info(self):
4392 """get_version_info(Particle self) -> VersionInfo"""
4393 return _IMP_kernel.Particle_get_version_info(self)
4396 def __init__(self, *args):
4398 __init__(IMP::Particle self, Model m, std::string name) -> Particle
4399 __init__(IMP::Particle self, Model m) -> Particle
4401 this = _IMP_kernel.new_Particle(*args)
4403 self.this.append(this)
4404 except __builtin__.Exception:
4407 def get_float_keys(self):
4408 """get_float_keys(Particle self) -> IMP::FloatKeys"""
4409 return _IMP_kernel.Particle_get_float_keys(self)
4412 def get_int_keys(self):
4413 """get_int_keys(Particle self) -> IMP::IntKeys"""
4414 return _IMP_kernel.Particle_get_int_keys(self)
4417 def get_string_keys(self):
4418 """get_string_keys(Particle self) -> IMP::StringKeys"""
4419 return _IMP_kernel.Particle_get_string_keys(self)
4422 def get_object_keys(self):
4423 """get_object_keys(Particle self) -> IMP::ObjectKeys"""
4424 return _IMP_kernel.Particle_get_object_keys(self)
4427 def add_cache_attribute(self, *args):
4429 add_cache_attribute(Particle self, FloatKey name, IMP::Float value)
4430 add_cache_attribute(Particle self, IntKey name, IMP::Int value)
4431 add_cache_attribute(Particle self, StringKey name, IMP::String value)
4432 add_cache_attribute(Particle self, ObjectKey name, Object value)
4433 add_cache_attribute(Particle self, IMP::WeakObjectKey name, Object value)
4435 return _IMP_kernel.Particle_add_cache_attribute(self, *args)
4438 def get_weak_object_keys(self):
4439 """get_weak_object_keys(Particle self) -> IMP::WeakObjectKeys"""
4440 return _IMP_kernel.Particle_get_weak_object_keys(self)
4443 def add_to_derivative(self, key, value, da):
4444 """add_to_derivative(Particle self, FloatKey key, IMP::Float value, DerivativeAccumulator da)"""
4445 return _IMP_kernel.Particle_add_to_derivative(self, key, value, da)
4448 def set_is_optimized(self, k, tf):
4449 """set_is_optimized(Particle self, FloatKey k, bool tf)"""
4450 return _IMP_kernel.Particle_set_is_optimized(self, k, tf)
4453 def get_is_optimized(self, k):
4454 """get_is_optimized(Particle self, FloatKey k) -> bool"""
4455 return _IMP_kernel.Particle_get_is_optimized(self, k)
4458 def get_derivative(self, k):
4459 """get_derivative(Particle self, FloatKey k) -> IMP::Float"""
4460 return _IMP_kernel.Particle_get_derivative(self, k)
4463 def add_attribute(self, *args):
4465 add_attribute(Particle self, FloatKey name, IMP::Float initial_value)
4466 add_attribute(Particle self, IntKey name, IMP::Int initial_value)
4467 add_attribute(Particle self, StringKey name, IMP::String initial_value)
4468 add_attribute(Particle self, ObjectKey name, Object initial_value)
4469 add_attribute(Particle self, IMP::WeakObjectKey name, Object initial_value)
4470 add_attribute(Particle self, FloatKey name, IMP::Float const initial_value, bool optimized)
4471 add_attribute(Particle self, ParticleIndexKey k, Particle v)
4473 return _IMP_kernel.Particle_add_attribute(self, *args)
4476 def has_attribute(self, *args):
4478 has_attribute(Particle self, FloatKey name) -> bool
4479 has_attribute(Particle self, IntKey name) -> bool
4480 has_attribute(Particle self, StringKey name) -> bool
4481 has_attribute(Particle self, ObjectKey name) -> bool
4482 has_attribute(Particle self, IMP::WeakObjectKey name) -> bool
4483 has_attribute(Particle self, ParticleIndexKey k) -> bool
4485 return _IMP_kernel.Particle_has_attribute(self, *args)
4488 def set_value(self, *args):
4490 set_value(Particle self, FloatKey name, IMP::Float value)
4491 set_value(Particle self, IntKey name, IMP::Int value)
4492 set_value(Particle self, StringKey name, IMP::String value)
4493 set_value(Particle self, ObjectKey name, Object value)
4494 set_value(Particle self, IMP::WeakObjectKey name, Object value)
4495 set_value(Particle self, ParticleIndexKey k, Particle v)
4497 return _IMP_kernel.Particle_set_value(self, *args)
4500 def get_value(self, *args):
4502 get_value(Particle self, FloatKey name) -> IMP::Float
4503 get_value(Particle self, IntKey name) -> IMP::Int
4504 get_value(Particle self, StringKey name) -> IMP::String
4505 get_value(Particle self, ObjectKey name) -> Object
4506 get_value(Particle self, IMP::WeakObjectKey name) -> Object
4507 get_value(Particle self, ParticleIndexKey k) -> Particle
4509 return _IMP_kernel.Particle_get_value(self, *args)
4512 def remove_attribute(self, *args):
4514 remove_attribute(Particle self, FloatKey name)
4515 remove_attribute(Particle self, IntKey name)
4516 remove_attribute(Particle self, StringKey name)
4517 remove_attribute(Particle self, ObjectKey name)
4518 remove_attribute(Particle self, IMP::WeakObjectKey name)
4519 remove_attribute(Particle self, ParticleIndexKey k)
4521 return _IMP_kernel.Particle_remove_attribute(self, *args)
4524 def get_particle_keys(self):
4525 """get_particle_keys(Particle self) -> IMP::ParticleIndexKeys"""
4526 return _IMP_kernel.Particle_get_particle_keys(self)
4529 def show(self, *args):
4531 show(Particle self, _ostream out)
4534 return _IMP_kernel.Particle_show(self, *args)
4537 def get_is_active(self):
4538 """get_is_active(Particle self) -> bool"""
4539 return _IMP_kernel.Particle_get_is_active(self)
4543 """get_index(Particle self) -> ParticleIndex"""
4544 return _IMP_kernel.Particle_get_index(self)
4547 def __eq__(self, *args):
4549 __eq__(Particle self, Particle o) -> bool
4550 __eq__(Particle self, Decorator d) -> bool
4552 return _IMP_kernel.Particle___eq__(self, *args)
4555 def __ne__(self, *args):
4557 __ne__(Particle self, Particle o) -> bool
4558 __ne__(Particle self, Decorator d) -> bool
4560 return _IMP_kernel.Particle___ne__(self, *args)
4563 def __le__(self, *args):
4565 __le__(Particle self, Particle o) -> bool
4566 __le__(Particle self, Decorator d) -> bool
4568 return _IMP_kernel.Particle___le__(self, *args)
4571 def __lt__(self, *args):
4573 __lt__(Particle self, Particle o) -> bool
4574 __lt__(Particle self, Decorator d) -> bool
4576 return _IMP_kernel.Particle___lt__(self, *args)
4579 def __ge__(self, *args):
4581 __ge__(Particle self, Particle o) -> bool
4582 __ge__(Particle self, Decorator d) -> bool
4584 return _IMP_kernel.Particle___ge__(self, *args)
4587 def __gt__(self, *args):
4589 __gt__(Particle self, Particle o) -> bool
4590 __gt__(Particle self, Decorator d) -> bool
4592 return _IMP_kernel.Particle___gt__(self, *args)
4595 __hash__ = ModelObject.__hash__
4599 """__str__(Particle self) -> std::string"""
4600 return _IMP_kernel.Particle___str__(self)
4604 """__repr__(Particle self) -> std::string"""
4605 return _IMP_kernel.Particle___repr__(self)
4610 return _object_cast_to_Particle(o)
4612 Particle_swigregister = _IMP_kernel.Particle_swigregister
4613 Particle_swigregister(Particle)
4615 class _ParticleAdaptor(_InputAdaptor):
4616 """Proxy of C++ IMP::ParticleAdaptor class."""
4618 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
4619 __repr__ = _swig_repr
4621 def __init__(self, *args):
4623 __init__(IMP::ParticleAdaptor self) -> _ParticleAdaptor
4624 __init__(IMP::ParticleAdaptor self, Particle p) -> _ParticleAdaptor
4625 __init__(IMP::ParticleAdaptor self, Decorator d) -> _ParticleAdaptor
4627 this = _IMP_kernel.new__ParticleAdaptor(*args)
4629 self.this.append(this)
4630 except __builtin__.Exception:
4633 def get_model(self):
4634 """get_model(_ParticleAdaptor self) -> Model"""
4635 return _IMP_kernel._ParticleAdaptor_get_model(self)
4638 def get_particle_index(self):
4639 """get_particle_index(_ParticleAdaptor self) -> ParticleIndex"""
4640 return _IMP_kernel._ParticleAdaptor_get_particle_index(self)
4642 __swig_destroy__ = _IMP_kernel.delete__ParticleAdaptor
4643 __del__ =
lambda self:
None
4644 _ParticleAdaptor_swigregister = _IMP_kernel._ParticleAdaptor_swigregister
4645 _ParticleAdaptor_swigregister(_ParticleAdaptor)
4647 class _DependencyGraphVertexIndex(object):
4648 """Proxy of C++ IMP::DependencyGraphVertexIndex class."""
4650 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
4651 __repr__ = _swig_repr
4654 """__init__(IMP::DependencyGraphVertexIndex self) -> _DependencyGraphVertexIndex"""
4655 this = _IMP_kernel.new__DependencyGraphVertexIndex()
4657 self.this.append(this)
4658 except __builtin__.Exception:
4660 __swig_destroy__ = _IMP_kernel.delete__DependencyGraphVertexIndex
4661 __del__ =
lambda self:
None
4662 _DependencyGraphVertexIndex_swigregister = _IMP_kernel._DependencyGraphVertexIndex_swigregister
4663 _DependencyGraphVertexIndex_swigregister(_DependencyGraphVertexIndex)
4666 def show_as_graphviz(name, out):
4667 """show_as_graphviz(IMP::DependencyGraph const & name, TextOutput out)"""
4668 return _IMP_kernel.show_as_graphviz(name, out)
4670 def get_vertex_index(g):
4671 """get_vertex_index(IMP::DependencyGraph const & g) -> _DependencyGraphVertexIndex"""
4672 return _IMP_kernel.get_vertex_index(g)
4675 """get_dependency_graph(Model m) -> IMP::DependencyGraph"""
4676 return _IMP_kernel.get_dependency_graph(m)
4679 """get_pruned_dependency_graph(Model m) -> IMP::DependencyGraph"""
4680 return _IMP_kernel.get_pruned_dependency_graph(m)
4684 get_required_score_states(IMP::ModelObjectsTemp const & mos, IMP::ScoreStatesTemp exclude) -> IMP::ScoreStatesTemp
4685 get_required_score_states(IMP::ModelObjectsTemp const & mos) -> IMP::ScoreStatesTemp
4686 get_required_score_states(ModelObject p, IMP::ModelObjectsTemp const & all, IMP::DependencyGraph const & dg, _DependencyGraphVertexIndex index) -> IMP::ScoreStatesTemp
4688 return _IMP_kernel.get_required_score_states(*args)
4691 """get_dependent_particles(ModelObject p, IMP::ModelObjectsTemp const & all, IMP::DependencyGraph const & dg, _DependencyGraphVertexIndex index) -> IMP::ParticlesTemp"""
4692 return _IMP_kernel.get_dependent_particles(p, all, dg, index)
4694 def get_dependent_restraints(m, pi):
4695 """get_dependent_restraints(Model m, ParticleIndex pi) -> IMP::RestraintsTemp"""
4696 return _IMP_kernel.get_dependent_restraints(m, pi)
4697 class ScoringFunction(ModelObject):
4698 """Proxy of C++ IMP::ScoringFunction class."""
4700 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
4702 def do_add_score_and_derivatives(self, sa, ss):
4703 """do_add_score_and_derivatives(ScoringFunction self, ScoreAccumulator sa, IMP::ScoreStatesTemp const & ss)"""
4704 return _IMP_kernel.ScoringFunction_do_add_score_and_derivatives(self, sa, ss)
4707 def get_score_accumulator_if_below(self, deriv, max):
4708 """get_score_accumulator_if_below(ScoringFunction self, bool deriv, double max) -> ScoreAccumulator"""
4709 return _IMP_kernel.ScoringFunction_get_score_accumulator_if_below(self, deriv, max)
4712 def get_score_accumulator_if_good(self, deriv):
4713 """get_score_accumulator_if_good(ScoringFunction self, bool deriv) -> ScoreAccumulator"""
4714 return _IMP_kernel.ScoringFunction_get_score_accumulator_if_good(self, deriv)
4717 def get_score_accumulator(self, deriv):
4718 """get_score_accumulator(ScoringFunction self, bool deriv) -> ScoreAccumulator"""
4719 return _IMP_kernel.ScoringFunction_get_score_accumulator(self, deriv)
4722 def __init__(self, m, name):
4723 """__init__(IMP::ScoringFunction self, Model m, std::string name) -> ScoringFunction"""
4724 if self.__class__ == ScoringFunction:
4728 this = _IMP_kernel.new_ScoringFunction(_self, m, name)
4730 self.this.append(this)
4731 except __builtin__.Exception:
4734 if self.__class__ != ScoringFunction:
4735 _director_objects.register(self)
4740 def do_get_outputs(self):
4741 """do_get_outputs(ScoringFunction self) -> IMP::ModelObjectsTemp"""
4742 return _IMP_kernel.ScoringFunction_do_get_outputs(self)
4745 def evaluate_if_good(self, derivatives):
4746 """evaluate_if_good(ScoringFunction self, bool derivatives) -> double"""
4747 return _IMP_kernel.ScoringFunction_evaluate_if_good(self, derivatives)
4750 def evaluate(self, derivatives):
4751 """evaluate(ScoringFunction self, bool derivatives) -> double"""
4752 return _IMP_kernel.ScoringFunction_evaluate(self, derivatives)
4755 def evaluate_if_below(self, derivatives, max):
4756 """evaluate_if_below(ScoringFunction self, bool derivatives, double max) -> double"""
4757 return _IMP_kernel.ScoringFunction_evaluate_if_below(self, derivatives, max)
4760 def get_had_good_score(self):
4761 """get_had_good_score(ScoringFunction self) -> bool"""
4762 return _IMP_kernel.ScoringFunction_get_had_good_score(self)
4765 def get_last_score(self):
4766 """get_last_score(ScoringFunction self) -> double"""
4767 return _IMP_kernel.ScoringFunction_get_last_score(self)
4771 """create_restraints(ScoringFunction self) -> IMP::Restraints"""
4772 return _IMP_kernel.ScoringFunction_create_restraints(self)
4776 """__str__(ScoringFunction self) -> std::string"""
4777 return _IMP_kernel.ScoringFunction___str__(self)
4781 """__repr__(ScoringFunction self) -> std::string"""
4782 return _IMP_kernel.ScoringFunction___repr__(self)
4787 return _object_cast_to_ScoringFunction(o)
4790 def get_type_name(self):
4791 return self.__class__.__name__
4792 def do_show(self, out):
4794 def get_version_info(self):
4796 return VersionInfo(self.__module__,
4797 __import__(self.__module__).get_module_version())
4800 __import__(self.__module__).get_module_version())
4803 return _object_cast_to_ScoringFunction(o)
4805 __swig_destroy__ = _IMP_kernel.delete_ScoringFunction
4806 __del__ =
lambda self:
None
4807 def __disown__(self):
4809 _IMP_kernel.disown_ScoringFunction(self)
4810 return weakref_proxy(self)
4812 def do_destroy(self):
4813 """do_destroy(ScoringFunction self)"""
4814 return _IMP_kernel.ScoringFunction_do_destroy(self)
4817 def handle_set_has_required_score_states(self, arg0):
4818 """handle_set_has_required_score_states(ScoringFunction self, bool arg0)"""
4819 return _IMP_kernel.ScoringFunction_handle_set_has_required_score_states(self, arg0)
4822 def do_get_inputs(self):
4823 """do_get_inputs(ScoringFunction self) -> IMP::ModelObjectsTemp"""
4824 return _IMP_kernel.ScoringFunction_do_get_inputs(self)
4827 def do_get_interactions(self):
4828 """do_get_interactions(ScoringFunction self) -> IMP::ModelObjectsTemps"""
4829 return _IMP_kernel.ScoringFunction_do_get_interactions(self)
4831 ScoringFunction_swigregister = _IMP_kernel.ScoringFunction_swigregister
4832 ScoringFunction_swigregister(ScoringFunction)
4837 create_decomposition(IMP::RestraintsTemp const & rs) -> IMP::Restraints
4838 create_decomposition(ScoringFunction sf) -> IMP::ScoringFunctions
4840 return _IMP_kernel.create_decomposition(*args)
4841 class _ScoringFunctionAdaptor(_InputAdaptor):
4842 """Proxy of C++ IMP::ScoringFunctionAdaptor class."""
4844 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
4845 __repr__ = _swig_repr
4847 def __init__(self, *args):
4849 __init__(IMP::ScoringFunctionAdaptor self) -> _ScoringFunctionAdaptor
4850 __init__(IMP::ScoringFunctionAdaptor self, ScoringFunction sf) -> _ScoringFunctionAdaptor
4851 __init__(IMP::ScoringFunctionAdaptor self, IMP::RestraintsTemp const & sf) -> _ScoringFunctionAdaptor
4852 __init__(IMP::ScoringFunctionAdaptor self, IMP::Restraints const & sf) -> _ScoringFunctionAdaptor
4853 __init__(IMP::ScoringFunctionAdaptor self, Restraint sf) -> _ScoringFunctionAdaptor
4855 this = _IMP_kernel.new__ScoringFunctionAdaptor(*args)
4857 self.this.append(this)
4858 except __builtin__.Exception:
4860 __swig_destroy__ = _IMP_kernel.delete__ScoringFunctionAdaptor
4861 __del__ =
lambda self:
None
4862 _ScoringFunctionAdaptor_swigregister = _IMP_kernel._ScoringFunctionAdaptor_swigregister
4863 _ScoringFunctionAdaptor_swigregister(_ScoringFunctionAdaptor)
4868 show_restraint_hierarchy(_ScoringFunctionAdaptor rs, _ostream out)
4869 show_restraint_hierarchy(_ScoringFunctionAdaptor rs)
4871 return _IMP_kernel.show_restraint_hierarchy(*args)
4872 class Undecorator(Object):
4873 """Proxy of C++ IMP::Undecorator class."""
4875 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
4877 def __init__(self, m, name):
4878 """__init__(IMP::Undecorator self, Model m, std::string name) -> Undecorator"""
4879 if self.__class__ == Undecorator:
4883 this = _IMP_kernel.new_Undecorator(_self, m, name)
4885 self.this.append(this)
4886 except __builtin__.Exception:
4889 if self.__class__ != Undecorator:
4890 _director_objects.register(self)
4895 def teardown(self, pi):
4896 """teardown(Undecorator self, ParticleIndex pi)"""
4897 return _IMP_kernel.Undecorator_teardown(self, pi)
4901 """__str__(Undecorator self) -> std::string"""
4902 return _IMP_kernel.Undecorator___str__(self)
4906 """__repr__(Undecorator self) -> std::string"""
4907 return _IMP_kernel.Undecorator___repr__(self)
4912 return _object_cast_to_Undecorator(o)
4915 def get_type_name(self):
4916 return self.__class__.__name__
4917 def do_show(self, out):
4919 def get_version_info(self):
4921 return VersionInfo(self.__module__,
4922 __import__(self.__module__).get_module_version())
4925 __import__(self.__module__).get_module_version())
4928 return _object_cast_to_Undecorator(o)
4930 __swig_destroy__ = _IMP_kernel.delete_Undecorator
4931 __del__ =
lambda self:
None
4932 def __disown__(self):
4934 _IMP_kernel.disown_Undecorator(self)
4935 return weakref_proxy(self)
4937 def do_destroy(self):
4938 """do_destroy(Undecorator self)"""
4939 return _IMP_kernel.Undecorator_do_destroy(self)
4941 Undecorator_swigregister = _IMP_kernel.Undecorator_swigregister
4942 Undecorator_swigregister(Undecorator)
4944 class Model(Object):
4945 """Proxy of C++ IMP::Model class."""
4947 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
4949 def __init__(self, *args):
4951 __init__(IMP::Model self, std::string name) -> Model
4952 __init__(IMP::Model self) -> Model
4954 this = _IMP_kernel.new_Model(*args)
4956 self.this.append(this)
4957 except __builtin__.Exception:
4960 def clear_particle_caches(self, pi):
4961 """clear_particle_caches(Model self, ParticleIndex pi)"""
4962 return _IMP_kernel.Model_clear_particle_caches(self, pi)
4966 """add_particle(Model self, std::string name) -> ParticleIndex"""
4967 return _IMP_kernel.Model_add_particle(self, name)
4970 def get_particle_name(self, pi):
4971 """get_particle_name(Model self, ParticleIndex pi) -> std::string"""
4972 return _IMP_kernel.Model_get_particle_name(self, pi)
4975 def add_undecorator(self, pi, d):
4976 """add_undecorator(Model self, ParticleIndex pi, Undecorator d)"""
4977 return _IMP_kernel.Model_add_undecorator(self, pi, d)
4980 def remove_score_state(self, d):
4981 """remove_score_state(Model self, ScoreState d)"""
4982 return _IMP_kernel.Model_remove_score_state(self, d)
4985 def remove_score_states(self, d):
4986 """remove_score_states(Model self, IMP::ScoreStates const & d)"""
4987 return _IMP_kernel.Model_remove_score_states(self, d)
4990 def set_score_states(self, ps):
4991 """set_score_states(Model self, IMP::ScoreStates const & ps)"""
4992 return _IMP_kernel.Model_set_score_states(self, ps)
4995 def set_score_states_order(self, objs):
4996 """set_score_states_order(Model self, IMP::ScoreStates const & objs)"""
4997 return _IMP_kernel.Model_set_score_states_order(self, objs)
5000 def add_score_state(self, obj):
5001 """add_score_state(Model self, ScoreState obj) -> unsigned int"""
5002 return _IMP_kernel.Model_add_score_state(self, obj)
5005 def add_score_states(self, objs):
5006 """add_score_states(Model self, IMP::ScoreStates const & objs)"""
5007 return _IMP_kernel.Model_add_score_states(self, objs)
5010 def clear_score_states(self):
5011 """clear_score_states(Model self)"""
5012 return _IMP_kernel.Model_clear_score_states(self)
5015 def get_number_of_score_states(self):
5016 """get_number_of_score_states(Model self) -> unsigned int"""
5017 return _IMP_kernel.Model_get_number_of_score_states(self)
5020 def get_has_score_states(self):
5021 """get_has_score_states(Model self) -> bool"""
5022 return _IMP_kernel.Model_get_has_score_states(self)
5025 def get_score_state(self, i):
5026 """get_score_state(Model self, unsigned int i) -> ScoreState"""
5027 return _IMP_kernel.Model_get_score_state(self, i)
5030 def get_score_states(self):
5031 """get_score_states(Model self) -> IMP::ScoreStates"""
5032 return _IMP_kernel.Model_get_score_states(self)
5035 def reserve_score_states(self, sz):
5036 """reserve_score_states(Model self, unsigned int sz)"""
5037 return _IMP_kernel.Model_reserve_score_states(self, sz)
5041 """update(Model self)"""
5042 return _IMP_kernel.Model_update(self)
5045 def add_attribute(self, *args):
5047 add_attribute(Model self, FloatKey attribute_key, ParticleIndex particle, IMP::Float value)
5048 add_attribute(Model self, IntKey attribute_key, ParticleIndex particle, IMP::Int value)
5049 add_attribute(Model self, IMP::IntsKey attribute_key, ParticleIndex particle, IMP::Ints value)
5050 add_attribute(Model self, StringKey attribute_key, ParticleIndex particle, IMP::String value)
5051 add_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle, IMP::ParticleIndexes value)
5052 add_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle, ParticleIndex value)
5053 add_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle, Object value)
5054 add_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle, Object value)
5056 return _IMP_kernel.Model_add_attribute(self, *args)
5059 def remove_attribute(self, *args):
5061 remove_attribute(Model self, FloatKey attribute_key, ParticleIndex particle)
5062 remove_attribute(Model self, IntKey attribute_key, ParticleIndex particle)
5063 remove_attribute(Model self, IMP::IntsKey attribute_key, ParticleIndex particle)
5064 remove_attribute(Model self, StringKey attribute_key, ParticleIndex particle)
5065 remove_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle)
5066 remove_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle)
5067 remove_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle)
5068 remove_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle)
5070 return _IMP_kernel.Model_remove_attribute(self, *args)
5073 def get_has_attribute(self, *args):
5075 get_has_attribute(Model self, FloatKey attribute_key, ParticleIndex particle) -> bool
5076 get_has_attribute(Model self, IntKey attribute_key, ParticleIndex particle) -> bool
5077 get_has_attribute(Model self, IMP::IntsKey attribute_key, ParticleIndex particle) -> bool
5078 get_has_attribute(Model self, StringKey attribute_key, ParticleIndex particle) -> bool
5079 get_has_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle) -> bool
5080 get_has_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle) -> bool
5081 get_has_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle) -> bool
5082 get_has_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle) -> bool
5084 return _IMP_kernel.Model_get_has_attribute(self, *args)
5087 def set_attribute(self, *args):
5089 set_attribute(Model self, FloatKey attribute_key, ParticleIndex particle, IMP::Float value)
5090 set_attribute(Model self, IntKey attribute_key, ParticleIndex particle, IMP::Int value)
5091 set_attribute(Model self, IMP::IntsKey attribute_key, ParticleIndex particle, IMP::Ints value)
5092 set_attribute(Model self, StringKey attribute_key, ParticleIndex particle, IMP::String value)
5093 set_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle, IMP::ParticleIndexes value)
5094 set_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle, ParticleIndex value)
5095 set_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle, Object value)
5096 set_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle, Object value)
5098 return _IMP_kernel.Model_set_attribute(self, *args)
5101 def get_attribute(self, *args):
5103 get_attribute(Model self, FloatKey attribute_key, ParticleIndex particle) -> IMP::Float
5104 get_attribute(Model self, IntKey attribute_key, ParticleIndex particle) -> IMP::Int
5105 get_attribute(Model self, IMP::IntsKey attribute_key, ParticleIndex particle) -> IMP::Ints
5106 get_attribute(Model self, StringKey attribute_key, ParticleIndex particle) -> IMP::String
5107 get_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle) -> IMP::ParticleIndexes
5108 get_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle) -> ParticleIndex
5109 get_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle) -> Object
5110 get_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle) -> Object
5112 return _IMP_kernel.Model_get_attribute(self, *args)
5115 def add_cache_attribute(self, *args):
5117 add_cache_attribute(Model self, FloatKey attribute_key, ParticleIndex particle, IMP::Float value)
5118 add_cache_attribute(Model self, IntKey attribute_key, ParticleIndex particle, IMP::Int value)
5119 add_cache_attribute(Model self, IMP::IntsKey attribute_key, ParticleIndex particle, IMP::Ints value)
5120 add_cache_attribute(Model self, StringKey attribute_key, ParticleIndex particle, IMP::String value)
5121 add_cache_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle, IMP::ParticleIndexes value)
5122 add_cache_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle, ParticleIndex value)
5123 add_cache_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle, Object value)
5124 add_cache_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle, Object value)
5126 return _IMP_kernel.Model_add_cache_attribute(self, *args)
5129 def set_is_optimized(self, arg2, arg3, arg4):
5130 """set_is_optimized(Model self, FloatKey arg2, ParticleIndex arg3, bool arg4)"""
5131 return _IMP_kernel.Model_set_is_optimized(self, arg2, arg3, arg4)
5134 def add_to_derivative(self, k, particle, v, da):
5135 """add_to_derivative(Model self, FloatKey k, ParticleIndex particle, double v, DerivativeAccumulator da)"""
5136 return _IMP_kernel.Model_add_to_derivative(self, k, particle, v, da)
5139 def get_particle(self, p):
5140 """get_particle(Model self, ParticleIndex p) -> Particle"""
5141 return _IMP_kernel.Model_get_particle(self, p)
5144 def get_has_particle(self, p):
5145 """get_has_particle(Model self, ParticleIndex p) -> bool"""
5146 return _IMP_kernel.Model_get_has_particle(self, p)
5149 def get_particle_indexes(self):
5150 """get_particle_indexes(Model self) -> IMP::ParticleIndexes"""
5151 return _IMP_kernel.Model_get_particle_indexes(self)
5154 def get_model_objects(self):
5155 """get_model_objects(Model self) -> IMP::ModelObjectsTemp"""
5156 return _IMP_kernel.Model_get_model_objects(self)
5159 def remove_particle(self, pi):
5160 """remove_particle(Model self, ParticleIndex pi)"""
5161 return _IMP_kernel.Model_remove_particle(self, pi)
5164 def add_data(self, mk, o):
5165 """add_data(Model self, ModelKey mk, Object o)"""
5166 return _IMP_kernel.Model_add_data(self, mk, o)
5169 def get_data(self, mk):
5170 """get_data(Model self, ModelKey mk) -> Object"""
5171 return _IMP_kernel.Model_get_data(self, mk)
5174 def remove_data(self, mk):
5175 """remove_data(Model self, ModelKey mk)"""
5176 return _IMP_kernel.Model_remove_data(self, mk)
5179 def get_has_data(self, mk):
5180 """get_has_data(Model self, ModelKey mk) -> bool"""
5181 return _IMP_kernel.Model_get_has_data(self, mk)
5184 def get_version_info(self):
5185 """get_version_info(Model self) -> VersionInfo"""
5186 return _IMP_kernel.Model_get_version_info(self)
5189 def do_destroy(self):
5190 """do_destroy(Model self)"""
5191 return _IMP_kernel.Model_do_destroy(self)
5195 """__str__(Model self) -> std::string"""
5196 return _IMP_kernel.Model___str__(self)
5200 """__repr__(Model self) -> std::string"""
5201 return _IMP_kernel.Model___repr__(self)
5206 return _object_cast_to_Model(o)
5208 Model_swigregister = _IMP_kernel.Model_swigregister
5209 Model_swigregister(Model)
5211 class Decorator(_Value):
5212 """Proxy of C++ IMP::Decorator class."""
5214 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
5215 __repr__ = _swig_repr
5217 def __init__(self, p):
5218 """__init__(IMP::Decorator self, _ParticleAdaptor p) -> Decorator"""
5219 this = _IMP_kernel.new_Decorator(p)
5221 self.this.append(this)
5222 except __builtin__.Exception:
5225 def __ne__(self, o):
5226 """__ne__(Decorator self, Object o) -> bool"""
5227 return _IMP_kernel.Decorator___ne__(self, o)
5230 def __lt__(self, o):
5231 """__lt__(Decorator self, Object o) -> bool"""
5232 return _IMP_kernel.Decorator___lt__(self, o)
5235 def __gt__(self, o):
5236 """__gt__(Decorator self, Object o) -> bool"""
5237 return _IMP_kernel.Decorator___gt__(self, o)
5240 def __ge__(self, o):
5241 """__ge__(Decorator self, Object o) -> bool"""
5242 return _IMP_kernel.Decorator___ge__(self, o)
5245 def __le__(self, o):
5246 """__le__(Decorator self, Object o) -> bool"""
5247 return _IMP_kernel.Decorator___le__(self, o)
5250 def get_particle(self):
5251 """get_particle(Decorator self) -> Particle"""
5252 return _IMP_kernel.Decorator_get_particle(self)
5255 def get_particle_index(self):
5256 """get_particle_index(Decorator self) -> ParticleIndex"""
5257 return _IMP_kernel.Decorator_get_particle_index(self)
5260 def get_model(self):
5261 """get_model(Decorator self) -> Model"""
5262 return _IMP_kernel.Decorator_get_model(self)
5265 def get_is_valid(self):
5266 """get_is_valid(Decorator self) -> bool"""
5267 return _IMP_kernel.Decorator_get_is_valid(self)
5271 """__hash__(Decorator self) -> std::size_t"""
5272 return _IMP_kernel.Decorator___hash__(self)
5275 def __eq__(self, *args):
5277 __eq__(Decorator self, Object o) -> bool
5278 __eq__(Decorator self, Decorator o) -> bool
5279 __eq__(Decorator self, Particle o) -> bool
5281 return _IMP_kernel.Decorator___eq__(self, *args)
5285 """__bool__(Decorator self) -> bool"""
5286 return _IMP_kernel.Decorator___bool__(self)
5289 __nonzero__ = __bool__
5291 __swig_destroy__ = _IMP_kernel.delete_Decorator
5292 __del__ =
lambda self:
None
5293 Decorator_swigregister = _IMP_kernel.Decorator_swigregister
5294 Decorator_swigregister(Decorator)
5297 def check_particle(m, pi):
5298 """check_particle(Model m, ParticleIndex pi)"""
5299 return _IMP_kernel.check_particle(m, pi)
5300 class UnaryFunction(Object):
5301 """Proxy of C++ IMP::UnaryFunction class."""
5303 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
5305 def __init__(self, *args):
5307 __init__(IMP::UnaryFunction self, std::string name) -> UnaryFunction
5308 __init__(IMP::UnaryFunction self) -> UnaryFunction
5310 if self.__class__ == UnaryFunction:
5314 this = _IMP_kernel.new_UnaryFunction(_self, *args)
5316 self.this.append(this)
5317 except __builtin__.Exception:
5320 if self.__class__ != UnaryFunction:
5321 _director_objects.register(self)
5326 def evaluate(self, feature):
5327 """evaluate(UnaryFunction self, double feature) -> double"""
5328 return _IMP_kernel.UnaryFunction_evaluate(self, feature)
5331 def evaluate_with_derivative(self, feature):
5332 """evaluate_with_derivative(UnaryFunction self, double feature) -> IMP::DerivativePair"""
5333 return _IMP_kernel.UnaryFunction_evaluate_with_derivative(self, feature)
5335 __swig_destroy__ = _IMP_kernel.delete_UnaryFunction
5336 __del__ =
lambda self:
None
5339 """__str__(UnaryFunction self) -> std::string"""
5340 return _IMP_kernel.UnaryFunction___str__(self)
5344 """__repr__(UnaryFunction self) -> std::string"""
5345 return _IMP_kernel.UnaryFunction___repr__(self)
5350 return _object_cast_to_UnaryFunction(o)
5353 def get_type_name(self):
5354 return self.__class__.__name__
5355 def do_show(self, out):
5357 def get_version_info(self):
5359 return VersionInfo(self.__module__,
5360 __import__(self.__module__).get_module_version())
5363 __import__(self.__module__).get_module_version())
5366 return _object_cast_to_UnaryFunction(o)
5368 def __disown__(self):
5370 _IMP_kernel.disown_UnaryFunction(self)
5371 return weakref_proxy(self)
5373 def do_destroy(self):
5374 """do_destroy(UnaryFunction self)"""
5375 return _IMP_kernel.UnaryFunction_do_destroy(self)
5377 UnaryFunction_swigregister = _IMP_kernel.UnaryFunction_swigregister
5378 UnaryFunction_swigregister(UnaryFunction)
5380 class OptimizerState(ModelObject):
5381 """Proxy of C++ IMP::OptimizerState class."""
5383 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
5385 def __init__(self, m, name):
5386 """__init__(IMP::OptimizerState self, Model m, std::string name) -> OptimizerState"""
5387 if self.__class__ == OptimizerState:
5391 this = _IMP_kernel.new_OptimizerState(_self, m, name)
5393 self.this.append(this)
5394 except __builtin__.Exception:
5397 if self.__class__ != OptimizerState:
5398 _director_objects.register(self)
5404 """update(OptimizerState self)"""
5405 return _IMP_kernel.OptimizerState_update(self)
5408 def set_is_optimizing(self, arg0):
5409 """set_is_optimizing(OptimizerState self, bool arg0)"""
5410 return _IMP_kernel.OptimizerState_set_is_optimizing(self, arg0)
5413 def get_optimizer(self):
5414 """get_optimizer(OptimizerState self) -> Optimizer"""
5415 return _IMP_kernel.OptimizerState_get_optimizer(self)
5418 def set_period(self, p):
5419 """set_period(OptimizerState self, unsigned int p)"""
5420 return _IMP_kernel.OptimizerState_set_period(self, p)
5423 def get_period(self):
5424 """get_period(OptimizerState self) -> unsigned int"""
5425 return _IMP_kernel.OptimizerState_get_period(self)
5429 """reset(OptimizerState self)"""
5430 return _IMP_kernel.OptimizerState_reset(self)
5433 def update_always(self):
5434 """update_always(OptimizerState self)"""
5435 return _IMP_kernel.OptimizerState_update_always(self)
5438 def get_number_of_updates(self):
5439 """get_number_of_updates(OptimizerState self) -> unsigned int"""
5440 return _IMP_kernel.OptimizerState_get_number_of_updates(self)
5443 def set_number_of_updates(self, n):
5444 """set_number_of_updates(OptimizerState self, unsigned int n)"""
5445 return _IMP_kernel.OptimizerState_set_number_of_updates(self, n)
5447 __swig_destroy__ = _IMP_kernel.delete_OptimizerState
5448 __del__ =
lambda self:
None
5450 def do_update(self, arg0):
5451 """do_update(OptimizerState self, unsigned int arg0)"""
5452 return _IMP_kernel.OptimizerState_do_update(self, arg0)
5455 def do_set_is_optimizing(self, arg0):
5456 """do_set_is_optimizing(OptimizerState self, bool arg0)"""
5457 return _IMP_kernel.OptimizerState_do_set_is_optimizing(self, arg0)
5460 def do_get_inputs(self):
5461 """do_get_inputs(OptimizerState self) -> IMP::ModelObjectsTemp"""
5462 return _IMP_kernel.OptimizerState_do_get_inputs(self)
5465 def do_get_outputs(self):
5466 """do_get_outputs(OptimizerState self) -> IMP::ModelObjectsTemp"""
5467 return _IMP_kernel.OptimizerState_do_get_outputs(self)
5471 """__str__(OptimizerState self) -> std::string"""
5472 return _IMP_kernel.OptimizerState___str__(self)
5476 """__repr__(OptimizerState self) -> std::string"""
5477 return _IMP_kernel.OptimizerState___repr__(self)
5482 return _object_cast_to_OptimizerState(o)
5485 def get_type_name(self):
5486 return self.__class__.__name__
5487 def do_show(self, out):
5489 def get_version_info(self):
5491 return VersionInfo(self.__module__,
5492 __import__(self.__module__).get_module_version())
5495 __import__(self.__module__).get_module_version())
5498 return _object_cast_to_OptimizerState(o)
5500 def __disown__(self):
5502 _IMP_kernel.disown_OptimizerState(self)
5503 return weakref_proxy(self)
5505 def do_destroy(self):
5506 """do_destroy(OptimizerState self)"""
5507 return _IMP_kernel.OptimizerState_do_destroy(self)
5510 def handle_set_has_required_score_states(self, arg0):
5511 """handle_set_has_required_score_states(OptimizerState self, bool arg0)"""
5512 return _IMP_kernel.OptimizerState_handle_set_has_required_score_states(self, arg0)
5515 def do_get_interactions(self):
5516 """do_get_interactions(OptimizerState self) -> IMP::ModelObjectsTemps"""
5517 return _IMP_kernel.OptimizerState_do_get_interactions(self)
5519 OptimizerState_swigregister = _IMP_kernel.OptimizerState_swigregister
5520 OptimizerState_swigregister(OptimizerState)
5522 class Refiner(_ParticleInputs, Object):
5523 """Proxy of C++ IMP::Refiner class."""
5525 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
5527 def __init__(self, *args):
5529 __init__(IMP::Refiner self, std::string name, bool is_by_ref=False) -> Refiner
5530 __init__(IMP::Refiner self, std::string name) -> Refiner
5531 __init__(IMP::Refiner self) -> Refiner
5533 if self.__class__ == Refiner:
5537 this = _IMP_kernel.new_Refiner(_self, *args)
5539 self.this.append(this)
5540 except __builtin__.Exception:
5543 if self.__class__ != Refiner:
5544 _director_objects.register(self)
5549 def get_can_refine(self, arg0):
5550 """get_can_refine(Refiner self, Particle arg0) -> bool"""
5551 return _IMP_kernel.Refiner_get_can_refine(self, arg0)
5554 def get_refined_indexes(self, m, pi):
5555 """get_refined_indexes(Refiner self, Model m, ParticleIndex pi) -> IMP::ParticleIndexes"""
5556 return _IMP_kernel.Refiner_get_refined_indexes(self, m, pi)
5559 def get_refined_indexes_by_ref(self, m, pi):
5560 """get_refined_indexes_by_ref(Refiner self, Model m, ParticleIndex pi) -> IMP::ParticleIndexes const &"""
5561 return _IMP_kernel.Refiner_get_refined_indexes_by_ref(self, m, pi)
5564 def get_is_by_ref_supported(self):
5565 """get_is_by_ref_supported(Refiner self) -> bool"""
5566 return _IMP_kernel.Refiner_get_is_by_ref_supported(self)
5569 def get_refined(self, *args):
5571 get_refined(Refiner self, Particle a) -> IMP::ParticlesTemp const
5572 get_refined(Refiner self, Particle a, unsigned int i) -> Particle
5574 return _IMP_kernel.Refiner_get_refined(self, *args)
5577 def get_number_of_refined(self, a):
5578 """get_number_of_refined(Refiner self, Particle a) -> unsigned int"""
5579 return _IMP_kernel.Refiner_get_number_of_refined(self, a)
5583 """__str__(Refiner self) -> std::string"""
5584 return _IMP_kernel.Refiner___str__(self)
5588 """__repr__(Refiner self) -> std::string"""
5589 return _IMP_kernel.Refiner___repr__(self)
5594 return _object_cast_to_Refiner(o)
5597 def get_type_name(self):
5598 return self.__class__.__name__
5599 def do_show(self, out):
5601 def get_version_info(self):
5603 return VersionInfo(self.__module__,
5604 __import__(self.__module__).get_module_version())
5607 __import__(self.__module__).get_module_version())
5610 return _object_cast_to_Refiner(o)
5612 __swig_destroy__ = _IMP_kernel.delete_Refiner
5613 __del__ =
lambda self:
None
5614 def __disown__(self):
5616 _IMP_kernel.disown_Refiner(self)
5617 return weakref_proxy(self)
5619 def do_get_inputs(self, m, pis):
5620 """do_get_inputs(Refiner self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
5621 return _IMP_kernel.Refiner_do_get_inputs(self, m, pis)
5624 def do_destroy(self):
5625 """do_destroy(Refiner self)"""
5626 return _IMP_kernel.Refiner_do_destroy(self)
5628 Refiner_swigregister = _IMP_kernel.Refiner_swigregister
5629 Refiner_swigregister(Refiner)
5631 class Optimizer(ModelObject):
5632 """Proxy of C++ IMP::Optimizer class."""
5634 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
5636 def set_is_optimizing_states(self, tf):
5637 """set_is_optimizing_states(Optimizer self, bool tf)"""
5638 return _IMP_kernel.Optimizer_set_is_optimizing_states(self, tf)
5641 def get_optimizer_state_inputs(self):
5642 """get_optimizer_state_inputs(Optimizer self) -> IMP::ModelObjectsTemp"""
5643 return _IMP_kernel.Optimizer_get_optimizer_state_inputs(self)
5646 def do_get_inputs(self):
5647 """do_get_inputs(Optimizer self) -> IMP::ModelObjectsTemp"""
5648 return _IMP_kernel.Optimizer_do_get_inputs(self)
5651 def do_get_outputs(self):
5652 """do_get_outputs(Optimizer self) -> IMP::ModelObjectsTemp"""
5653 return _IMP_kernel.Optimizer_do_get_outputs(self)
5656 def __init__(self, *args):
5658 __init__(IMP::Optimizer self, Model m, std::string name) -> Optimizer
5659 __init__(IMP::Optimizer self, Model m) -> Optimizer
5661 if self.__class__ == Optimizer:
5665 this = _IMP_kernel.new_Optimizer(_self, *args)
5667 self.this.append(this)
5668 except __builtin__.Exception:
5671 if self.__class__ != Optimizer:
5672 _director_objects.register(self)
5677 def optimize(self, max_steps):
5678 """optimize(Optimizer self, unsigned int max_steps) -> double"""
5679 return _IMP_kernel.Optimizer_optimize(self, max_steps)
5682 def set_stop_on_good_score(self, tf):
5683 """set_stop_on_good_score(Optimizer self, bool tf)"""
5684 return _IMP_kernel.Optimizer_set_stop_on_good_score(self, tf)
5687 def get_stop_on_good_score(self):
5688 """get_stop_on_good_score(Optimizer self) -> bool"""
5689 return _IMP_kernel.Optimizer_get_stop_on_good_score(self)
5692 def get_last_score(self):
5693 """get_last_score(Optimizer self) -> double"""
5694 return _IMP_kernel.Optimizer_get_last_score(self)
5697 def get_scoring_function(self):
5698 """get_scoring_function(Optimizer self) -> ScoringFunction"""
5699 return _IMP_kernel.Optimizer_get_scoring_function(self)
5702 def remove_optimizer_state(self, d):
5703 """remove_optimizer_state(Optimizer self, OptimizerState d)"""
5704 return _IMP_kernel.Optimizer_remove_optimizer_state(self, d)
5707 def remove_optimizer_states(self, d):
5708 """remove_optimizer_states(Optimizer self, IMP::OptimizerStates const & d)"""
5709 return _IMP_kernel.Optimizer_remove_optimizer_states(self, d)
5712 def set_optimizer_states(self, ps):
5713 """set_optimizer_states(Optimizer self, IMP::OptimizerStates const & ps)"""
5714 return _IMP_kernel.Optimizer_set_optimizer_states(self, ps)
5717 def set_optimizer_states_order(self, objs):
5718 """set_optimizer_states_order(Optimizer self, IMP::OptimizerStates const & objs)"""
5719 return _IMP_kernel.Optimizer_set_optimizer_states_order(self, objs)
5722 def add_optimizer_state(self, obj):
5723 """add_optimizer_state(Optimizer self, OptimizerState obj) -> unsigned int"""
5724 return _IMP_kernel.Optimizer_add_optimizer_state(self, obj)
5727 def add_optimizer_states(self, objs):
5728 """add_optimizer_states(Optimizer self, IMP::OptimizerStates const & objs)"""
5729 return _IMP_kernel.Optimizer_add_optimizer_states(self, objs)
5732 def clear_optimizer_states(self):
5733 """clear_optimizer_states(Optimizer self)"""
5734 return _IMP_kernel.Optimizer_clear_optimizer_states(self)
5737 def get_number_of_optimizer_states(self):
5738 """get_number_of_optimizer_states(Optimizer self) -> unsigned int"""
5739 return _IMP_kernel.Optimizer_get_number_of_optimizer_states(self)
5742 def get_has_optimizer_states(self):
5743 """get_has_optimizer_states(Optimizer self) -> bool"""
5744 return _IMP_kernel.Optimizer_get_has_optimizer_states(self)
5747 def get_optimizer_state(self, i):
5748 """get_optimizer_state(Optimizer self, unsigned int i) -> OptimizerState"""
5749 return _IMP_kernel.Optimizer_get_optimizer_state(self, i)
5752 def get_optimizer_states(self):
5753 """get_optimizer_states(Optimizer self) -> IMP::OptimizerStates"""
5754 return _IMP_kernel.Optimizer_get_optimizer_states(self)
5757 def reserve_optimizer_states(self, sz):
5758 """reserve_optimizer_states(Optimizer self, unsigned int sz)"""
5759 return _IMP_kernel.Optimizer_reserve_optimizer_states(self, sz)
5762 def set_scoring_function(self, sf):
5763 """set_scoring_function(Optimizer self, _ScoringFunctionAdaptor sf)"""
5764 return _IMP_kernel.Optimizer_set_scoring_function(self, sf)
5766 __swig_destroy__ = _IMP_kernel.delete_Optimizer
5768 """__del__(IMP::Optimizer self)"""
5770 _director_objects.cleanup()
5776 def do_optimize(self, ns):
5777 """do_optimize(Optimizer self, unsigned int ns) -> double"""
5778 return _IMP_kernel.Optimizer_do_optimize(self, ns)
5781 def update_states(self):
5782 """update_states(Optimizer self)"""
5783 return _IMP_kernel.Optimizer_update_states(self)
5787 """__str__(Optimizer self) -> std::string"""
5788 return _IMP_kernel.Optimizer___str__(self)
5792 """__repr__(Optimizer self) -> std::string"""
5793 return _IMP_kernel.Optimizer___repr__(self)
5798 return _object_cast_to_Optimizer(o)
5801 def get_type_name(self):
5802 return self.__class__.__name__
5803 def do_show(self, out):
5805 def get_version_info(self):
5807 return VersionInfo(self.__module__,
5808 __import__(self.__module__).get_module_version())
5811 __import__(self.__module__).get_module_version())
5814 return _object_cast_to_Optimizer(o)
5816 def __disown__(self):
5818 _IMP_kernel.disown_Optimizer(self)
5819 return weakref_proxy(self)
5821 def do_destroy(self):
5822 """do_destroy(Optimizer self)"""
5823 return _IMP_kernel.Optimizer_do_destroy(self)
5826 def handle_set_has_required_score_states(self, arg0):
5827 """handle_set_has_required_score_states(Optimizer self, bool arg0)"""
5828 return _IMP_kernel.Optimizer_handle_set_has_required_score_states(self, arg0)
5831 def do_get_interactions(self):
5832 """do_get_interactions(Optimizer self) -> IMP::ModelObjectsTemps"""
5833 return _IMP_kernel.Optimizer_do_get_interactions(self)
5835 Optimizer_swigregister = _IMP_kernel.Optimizer_swigregister
5836 Optimizer_swigregister(Optimizer)
5838 class AttributeOptimizer(Optimizer):
5839 """Proxy of C++ IMP::AttributeOptimizer class."""
5841 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
5843 def __init__(self, *args):
5845 __init__(IMP::AttributeOptimizer self, Model m, std::string name) -> AttributeOptimizer
5846 __init__(IMP::AttributeOptimizer self, Model m) -> AttributeOptimizer
5848 if self.__class__ == AttributeOptimizer:
5852 this = _IMP_kernel.new_AttributeOptimizer(_self, *args)
5854 self.this.append(this)
5855 except __builtin__.Exception:
5858 if self.__class__ != AttributeOptimizer:
5859 _director_objects.register(self)
5864 def get_optimized_attributes(self):
5865 """get_optimized_attributes(AttributeOptimizer self) -> IMP::FloatIndexes"""
5866 return _IMP_kernel.AttributeOptimizer_get_optimized_attributes(self)
5869 def set_value(self, fi, v):
5870 """set_value(AttributeOptimizer self, FloatIndex fi, double v)"""
5871 return _IMP_kernel.AttributeOptimizer_set_value(self, fi, v)
5874 def get_value(self, fi):
5875 """get_value(AttributeOptimizer self, FloatIndex fi) -> IMP::Float"""
5876 return _IMP_kernel.AttributeOptimizer_get_value(self, fi)
5879 def get_derivative(self, fi):
5880 """get_derivative(AttributeOptimizer self, FloatIndex fi) -> IMP::Float"""
5881 return _IMP_kernel.AttributeOptimizer_get_derivative(self, fi)
5884 def get_width(self, k):
5885 """get_width(AttributeOptimizer self, FloatKey k) -> double"""
5886 return _IMP_kernel.AttributeOptimizer_get_width(self, k)
5889 def set_scaled_value(self, fi, v):
5890 """set_scaled_value(AttributeOptimizer self, FloatIndex fi, IMP::Float v)"""
5891 return _IMP_kernel.AttributeOptimizer_set_scaled_value(self, fi, v)
5894 def get_scaled_value(self, fi):
5895 """get_scaled_value(AttributeOptimizer self, FloatIndex fi) -> double"""
5896 return _IMP_kernel.AttributeOptimizer_get_scaled_value(self, fi)
5899 def get_scaled_derivative(self, fi):
5900 """get_scaled_derivative(AttributeOptimizer self, FloatIndex fi) -> double"""
5901 return _IMP_kernel.AttributeOptimizer_get_scaled_derivative(self, fi)
5904 def clear_range_cache(self):
5905 """clear_range_cache(AttributeOptimizer self)"""
5906 return _IMP_kernel.AttributeOptimizer_clear_range_cache(self)
5910 """__str__(AttributeOptimizer self) -> std::string"""
5911 return _IMP_kernel.AttributeOptimizer___str__(self)
5915 """__repr__(AttributeOptimizer self) -> std::string"""
5916 return _IMP_kernel.AttributeOptimizer___repr__(self)
5921 return _object_cast_to_AttributeOptimizer(o)
5924 def get_type_name(self):
5925 return self.__class__.__name__
5926 def do_show(self, out):
5928 def get_version_info(self):
5930 return VersionInfo(self.__module__,
5931 __import__(self.__module__).get_module_version())
5934 __import__(self.__module__).get_module_version())
5937 return _object_cast_to_AttributeOptimizer(o)
5939 __swig_destroy__ = _IMP_kernel.delete_AttributeOptimizer
5940 __del__ =
lambda self:
None
5941 def __disown__(self):
5943 _IMP_kernel.disown_AttributeOptimizer(self)
5944 return weakref_proxy(self)
5946 def do_destroy(self):
5947 """do_destroy(AttributeOptimizer self)"""
5948 return _IMP_kernel.AttributeOptimizer_do_destroy(self)
5951 def handle_set_has_required_score_states(self, arg0):
5952 """handle_set_has_required_score_states(AttributeOptimizer self, bool arg0)"""
5953 return _IMP_kernel.AttributeOptimizer_handle_set_has_required_score_states(self, arg0)
5956 def do_get_inputs(self):
5957 """do_get_inputs(AttributeOptimizer self) -> IMP::ModelObjectsTemp"""
5958 return _IMP_kernel.AttributeOptimizer_do_get_inputs(self)
5961 def do_get_outputs(self):
5962 """do_get_outputs(AttributeOptimizer self) -> IMP::ModelObjectsTemp"""
5963 return _IMP_kernel.AttributeOptimizer_do_get_outputs(self)
5966 def do_get_interactions(self):
5967 """do_get_interactions(AttributeOptimizer self) -> IMP::ModelObjectsTemps"""
5968 return _IMP_kernel.AttributeOptimizer_do_get_interactions(self)
5971 def do_optimize(self, ns):
5972 """do_optimize(AttributeOptimizer self, unsigned int ns) -> double"""
5973 return _IMP_kernel.AttributeOptimizer_do_optimize(self, ns)
5975 AttributeOptimizer_swigregister = _IMP_kernel.AttributeOptimizer_swigregister
5976 AttributeOptimizer_swigregister(AttributeOptimizer)
5978 class ConfigurationSet(Object):
5979 """Proxy of C++ IMP::ConfigurationSet class."""
5981 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
5983 def __init__(self, *args):
5985 __init__(IMP::ConfigurationSet self, Model m, std::string name) -> ConfigurationSet
5986 __init__(IMP::ConfigurationSet self, Model m) -> ConfigurationSet
5988 this = _IMP_kernel.new_ConfigurationSet(*args)
5990 self.this.append(this)
5991 except __builtin__.Exception:
5994 def save_configuration(self):
5995 """save_configuration(ConfigurationSet self)"""
5996 return _IMP_kernel.ConfigurationSet_save_configuration(self)
5999 def get_number_of_configurations(self):
6000 """get_number_of_configurations(ConfigurationSet self) -> unsigned int"""
6001 return _IMP_kernel.ConfigurationSet_get_number_of_configurations(self)
6004 def load_configuration(self, i):
6005 """load_configuration(ConfigurationSet self, int i)"""
6006 return _IMP_kernel.ConfigurationSet_load_configuration(self, i)
6009 def remove_configuration(self, i):
6010 """remove_configuration(ConfigurationSet self, unsigned int i)"""
6011 return _IMP_kernel.ConfigurationSet_remove_configuration(self, i)
6014 def get_model(self):
6015 """get_model(ConfigurationSet self) -> Model"""
6016 return _IMP_kernel.ConfigurationSet_get_model(self)
6019 def get_version_info(self):
6020 """get_version_info(ConfigurationSet self) -> VersionInfo"""
6021 return _IMP_kernel.ConfigurationSet_get_version_info(self)
6025 """__str__(ConfigurationSet self) -> std::string"""
6026 return _IMP_kernel.ConfigurationSet___str__(self)
6030 """__repr__(ConfigurationSet self) -> std::string"""
6031 return _IMP_kernel.ConfigurationSet___repr__(self)
6036 return _object_cast_to_ConfigurationSet(o)
6038 ConfigurationSet_swigregister = _IMP_kernel.ConfigurationSet_swigregister
6039 ConfigurationSet_swigregister(ConfigurationSet)
6041 class SaveToConfigurationSetOptimizerState(OptimizerState):
6042 """Proxy of C++ IMP::SaveToConfigurationSetOptimizerState class."""
6044 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6046 def __init__(self, cs):
6047 """__init__(IMP::SaveToConfigurationSetOptimizerState self, ConfigurationSet cs) -> SaveToConfigurationSetOptimizerState"""
6048 this = _IMP_kernel.new_SaveToConfigurationSetOptimizerState(cs)
6050 self.this.append(this)
6051 except __builtin__.Exception:
6054 def get_version_info(self):
6055 """get_version_info(SaveToConfigurationSetOptimizerState self) -> VersionInfo"""
6056 return _IMP_kernel.SaveToConfigurationSetOptimizerState_get_version_info(self)
6060 """__str__(SaveToConfigurationSetOptimizerState self) -> std::string"""
6061 return _IMP_kernel.SaveToConfigurationSetOptimizerState___str__(self)
6065 """__repr__(SaveToConfigurationSetOptimizerState self) -> std::string"""
6066 return _IMP_kernel.SaveToConfigurationSetOptimizerState___repr__(self)
6071 return _object_cast_to_SaveToConfigurationSetOptimizerState(o)
6073 SaveToConfigurationSetOptimizerState_swigregister = _IMP_kernel.SaveToConfigurationSetOptimizerState_swigregister
6074 SaveToConfigurationSetOptimizerState_swigregister(SaveToConfigurationSetOptimizerState)
6076 class Configuration(Object):
6077 """Proxy of C++ IMP::Configuration class."""
6079 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6081 def __init__(self, *args):
6083 __init__(IMP::Configuration self, Model m, std::string name) -> Configuration
6084 __init__(IMP::Configuration self, Model m) -> Configuration
6085 __init__(IMP::Configuration self, Model m, Configuration base, std::string name) -> Configuration
6086 __init__(IMP::Configuration self, Model m, Configuration base) -> Configuration
6088 this = _IMP_kernel.new_Configuration(*args)
6090 self.this.append(this)
6091 except __builtin__.Exception:
6094 def load_configuration(self):
6095 """load_configuration(Configuration self)"""
6096 return _IMP_kernel.Configuration_load_configuration(self)
6099 def swap_configuration(self):
6100 """swap_configuration(Configuration self)"""
6101 return _IMP_kernel.Configuration_swap_configuration(self)
6104 def get_version_info(self):
6105 """get_version_info(Configuration self) -> VersionInfo"""
6106 return _IMP_kernel.Configuration_get_version_info(self)
6110 """__str__(Configuration self) -> std::string"""
6111 return _IMP_kernel.Configuration___str__(self)
6115 """__repr__(Configuration self) -> std::string"""
6116 return _IMP_kernel.Configuration___repr__(self)
6121 return _object_cast_to_Configuration(o)
6123 Configuration_swigregister = _IMP_kernel.Configuration_swigregister
6124 Configuration_swigregister(Configuration)
6126 class Sampler(Object):
6127 """Proxy of C++ IMP::Sampler class."""
6129 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6131 def __init__(self, *args):
6133 __init__(IMP::Sampler self, Model m, std::string name) -> Sampler
6134 __init__(IMP::Sampler self, Model m) -> Sampler
6136 if self.__class__ == Sampler:
6140 this = _IMP_kernel.new_Sampler(_self, *args)
6142 self.this.append(this)
6143 except __builtin__.Exception:
6146 if self.__class__ != Sampler:
6147 _director_objects.register(self)
6152 def create_sample(self):
6153 """create_sample(Sampler self) -> ConfigurationSet"""
6154 return _IMP_kernel.Sampler_create_sample(self)
6157 def get_scoring_function(self):
6158 """get_scoring_function(Sampler self) -> ScoringFunction"""
6159 return _IMP_kernel.Sampler_get_scoring_function(self)
6162 def set_scoring_function(self, sf):
6163 """set_scoring_function(Sampler self, _ScoringFunctionAdaptor sf)"""
6164 return _IMP_kernel.Sampler_set_scoring_function(self, sf)
6167 def get_model(self):
6168 """get_model(Sampler self) -> Model"""
6169 return _IMP_kernel.Sampler_get_model(self)
6172 def do_sample(self):
6173 """do_sample(Sampler self) -> ConfigurationSet"""
6174 return _IMP_kernel.Sampler_do_sample(self)
6176 __swig_destroy__ = _IMP_kernel.delete_Sampler
6177 __del__ =
lambda self:
None
6180 """__str__(Sampler self) -> std::string"""
6181 return _IMP_kernel.Sampler___str__(self)
6185 """__repr__(Sampler self) -> std::string"""
6186 return _IMP_kernel.Sampler___repr__(self)
6191 return _object_cast_to_Sampler(o)
6194 def get_type_name(self):
6195 return self.__class__.__name__
6196 def do_show(self, out):
6198 def get_version_info(self):
6200 return VersionInfo(self.__module__,
6201 __import__(self.__module__).get_module_version())
6204 __import__(self.__module__).get_module_version())
6207 return _object_cast_to_Sampler(o)
6209 def __disown__(self):
6211 _IMP_kernel.disown_Sampler(self)
6212 return weakref_proxy(self)
6214 def do_destroy(self):
6215 """do_destroy(Sampler self)"""
6216 return _IMP_kernel.Sampler_do_destroy(self)
6218 Sampler_swigregister = _IMP_kernel.Sampler_swigregister
6219 Sampler_swigregister(Sampler)
6221 class PairModifier(_ParticleInputs, _ParticleOutputs, Object):
6222 """Proxy of C++ IMP::PairModifier class."""
6224 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6226 def __init__(self, *args):
6228 __init__(IMP::PairModifier self, std::string name) -> PairModifier
6229 __init__(IMP::PairModifier self) -> PairModifier
6231 if self.__class__ == PairModifier:
6235 this = _IMP_kernel.new_PairModifier(_self, *args)
6237 self.this.append(this)
6238 except __builtin__.Exception:
6241 if self.__class__ != PairModifier:
6242 _director_objects.register(self)
6247 def apply_index(self, m, v):
6248 """apply_index(PairModifier self, Model m, IMP::ParticleIndexPair const & v)"""
6249 return _IMP_kernel.PairModifier_apply_index(self, m, v)
6252 def apply_indexes(self, m, o, lower_bound, upper_bound):
6253 """apply_indexes(PairModifier self, Model m, IMP::ParticleIndexPairs const & o, unsigned int lower_bound, unsigned int upper_bound)"""
6254 return _IMP_kernel.PairModifier_apply_indexes(self, m, o, lower_bound, upper_bound)
6258 """__str__(PairModifier self) -> std::string"""
6259 return _IMP_kernel.PairModifier___str__(self)
6263 """__repr__(PairModifier self) -> std::string"""
6264 return _IMP_kernel.PairModifier___repr__(self)
6269 return _object_cast_to_PairModifier(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__,
6279 __import__(self.__module__).get_module_version())
6282 __import__(self.__module__).get_module_version())
6285 return _object_cast_to_PairModifier(o)
6287 __swig_destroy__ = _IMP_kernel.delete_PairModifier
6288 __del__ =
lambda self:
None
6289 def __disown__(self):
6291 _IMP_kernel.disown_PairModifier(self)
6292 return weakref_proxy(self)
6294 def do_get_inputs(self, m, pis):
6295 """do_get_inputs(PairModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6296 return _IMP_kernel.PairModifier_do_get_inputs(self, m, pis)
6299 def do_get_outputs(self, m, pis):
6300 """do_get_outputs(PairModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6301 return _IMP_kernel.PairModifier_do_get_outputs(self, m, pis)
6304 def do_destroy(self):
6305 """do_destroy(PairModifier self)"""
6306 return _IMP_kernel.PairModifier_do_destroy(self)
6308 PairModifier_swigregister = _IMP_kernel.PairModifier_swigregister
6309 PairModifier_swigregister(PairModifier)
6311 class PairScore(_ParticleInputs, Object):
6312 """Proxy of C++ IMP::PairScore class."""
6314 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6316 def __init__(self, *args):
6318 __init__(IMP::PairScore self, std::string name) -> PairScore
6319 __init__(IMP::PairScore self) -> PairScore
6321 if self.__class__ == PairScore:
6325 this = _IMP_kernel.new_PairScore(_self, *args)
6327 self.this.append(this)
6328 except __builtin__.Exception:
6331 if self.__class__ != PairScore:
6332 _director_objects.register(self)
6337 def evaluate_index(self, m, vt, da):
6338 """evaluate_index(PairScore self, Model m, IMP::ParticleIndexPair const & vt, DerivativeAccumulator da) -> double"""
6339 return _IMP_kernel.PairScore_evaluate_index(self, m, vt, da)
6342 def evaluate_indexes(self, m, o, da, lower_bound, upper_bound):
6343 """evaluate_indexes(PairScore self, Model m, IMP::ParticleIndexPairs const & o, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound) -> double"""
6344 return _IMP_kernel.PairScore_evaluate_indexes(self, m, o, da, lower_bound, upper_bound)
6347 def evaluate_if_good_index(self, m, vt, da, max):
6348 """evaluate_if_good_index(PairScore self, Model m, IMP::ParticleIndexPair const & vt, DerivativeAccumulator da, double max) -> double"""
6349 return _IMP_kernel.PairScore_evaluate_if_good_index(self, m, vt, da, max)
6352 def evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound):
6353 """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"""
6354 return _IMP_kernel.PairScore_evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound)
6357 def create_current_decomposition(self, m, vt):
6358 """create_current_decomposition(PairScore self, Model m, IMP::ParticleIndexPair const & vt) -> IMP::Restraints"""
6359 return _IMP_kernel.PairScore_create_current_decomposition(self, m, vt)
6362 def do_create_current_decomposition(self, m, vt):
6363 """do_create_current_decomposition(PairScore self, Model m, IMP::ParticleIndexPair const & vt) -> IMP::Restraints"""
6364 return _IMP_kernel.PairScore_do_create_current_decomposition(self, m, vt)
6366 __swig_destroy__ = _IMP_kernel.delete_PairScore
6367 __del__ =
lambda self:
None
6370 """__str__(PairScore self) -> std::string"""
6371 return _IMP_kernel.PairScore___str__(self)
6375 """__repr__(PairScore self) -> std::string"""
6376 return _IMP_kernel.PairScore___repr__(self)
6381 return _object_cast_to_PairScore(o)
6384 def get_type_name(self):
6385 return self.__class__.__name__
6386 def do_show(self, out):
6388 def get_version_info(self):
6390 return VersionInfo(self.__module__,
6391 __import__(self.__module__).get_module_version())
6394 __import__(self.__module__).get_module_version())
6397 return _object_cast_to_PairScore(o)
6399 def __disown__(self):
6401 _IMP_kernel.disown_PairScore(self)
6402 return weakref_proxy(self)
6404 def do_get_inputs(self, m, pis):
6405 """do_get_inputs(PairScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6406 return _IMP_kernel.PairScore_do_get_inputs(self, m, pis)
6409 def do_destroy(self):
6410 """do_destroy(PairScore self)"""
6411 return _IMP_kernel.PairScore_do_destroy(self)
6413 PairScore_swigregister = _IMP_kernel.PairScore_swigregister
6414 PairScore_swigregister(PairScore)
6416 class PairPredicate(_ParticleInputs, Object):
6417 """Proxy of C++ IMP::PairPredicate class."""
6419 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6421 def __init__(self, *args):
6423 __init__(IMP::PairPredicate self, std::string name) -> PairPredicate
6424 __init__(IMP::PairPredicate self) -> PairPredicate
6426 if self.__class__ == PairPredicate:
6430 this = _IMP_kernel.new_PairPredicate(_self, *args)
6432 self.this.append(this)
6433 except __builtin__.Exception:
6436 if self.__class__ != PairPredicate:
6437 _director_objects.register(self)
6442 def get_value(self, *args):
6444 get_value(PairPredicate self, IMP::ParticlePair const & vt) -> int
6445 get_value(PairPredicate self, IMP::ParticlePairsTemp const & o) -> IMP::Ints
6447 return _IMP_kernel.PairPredicate_get_value(self, *args)
6450 def __call__(self, m, vt):
6451 """__call__(PairPredicate self, Model m, IMP::ParticleIndexPair const & vt) -> int"""
6452 return _IMP_kernel.PairPredicate___call__(self, m, vt)
6455 def get_value_index(self, *args):
6457 get_value_index(PairPredicate self, Model m, IMP::ParticleIndexPair const & vt) -> int
6458 get_value_index(PairPredicate self, Model m, IMP::ParticleIndexPairs const & o) -> IMP::Ints
6460 return _IMP_kernel.PairPredicate_get_value_index(self, *args)
6462 __swig_destroy__ = _IMP_kernel.delete_PairPredicate
6463 __del__ =
lambda self:
None
6466 """__str__(PairPredicate self) -> std::string"""
6467 return _IMP_kernel.PairPredicate___str__(self)
6471 """__repr__(PairPredicate self) -> std::string"""
6472 return _IMP_kernel.PairPredicate___repr__(self)
6477 return _object_cast_to_PairPredicate(o)
6480 def get_type_name(self):
6481 return self.__class__.__name__
6482 def do_show(self, out):
6484 def get_version_info(self):
6486 return VersionInfo(self.__module__,
6487 __import__(self.__module__).get_module_version())
6490 __import__(self.__module__).get_module_version())
6493 return _object_cast_to_PairPredicate(o)
6495 def __disown__(self):
6497 _IMP_kernel.disown_PairPredicate(self)
6498 return weakref_proxy(self)
6500 def do_get_inputs(self, m, pis):
6501 """do_get_inputs(PairPredicate self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6502 return _IMP_kernel.PairPredicate_do_get_inputs(self, m, pis)
6505 def do_destroy(self):
6506 """do_destroy(PairPredicate self)"""
6507 return _IMP_kernel.PairPredicate_do_destroy(self)
6509 PairPredicate_swigregister = _IMP_kernel.PairPredicate_swigregister
6510 PairPredicate_swigregister(PairPredicate)
6512 class PairContainer(Container):
6513 """Proxy of C++ IMP::PairContainer class."""
6515 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6517 def apply_generic(self, m):
6518 """apply_generic(PairContainer self, PairModifier m)"""
6519 return _IMP_kernel.PairContainer_apply_generic(self, m)
6522 def apply(self, sm):
6523 """apply(PairContainer self, PairModifier sm)"""
6524 return _IMP_kernel.PairContainer_apply(self, sm)
6527 def get_range_indexes(self):
6528 """get_range_indexes(PairContainer self) -> IMP::ParticleIndexPairs"""
6529 return _IMP_kernel.PairContainer_get_range_indexes(self)
6532 def get_contents(self):
6533 """get_contents(PairContainer self) -> IMP::ParticleIndexPairs const &"""
6534 return _IMP_kernel.PairContainer_get_contents(self)
6538 """get_indexes(PairContainer self) -> IMP::ParticleIndexPairs"""
6539 return _IMP_kernel.PairContainer_get_indexes(self)
6542 def get(self, *args):
6544 get(PairContainer self) -> IMP::ParticlePairsTemp
6545 get(PairContainer self, unsigned int i) -> IMP::ParticlePair
6547 return _IMP_kernel.PairContainer_get(self, *args)
6550 def get_number(self):
6551 """get_number(PairContainer self) -> unsigned int"""
6552 return _IMP_kernel.PairContainer_get_number(self)
6555 def get_particle_pairs(self):
6556 """get_particle_pairs(PairContainer self) -> IMP::ParticlePairsTemp"""
6557 return _IMP_kernel.PairContainer_get_particle_pairs(self)
6560 def get_particle_pair(self, i):
6561 """get_particle_pair(PairContainer self, unsigned int i) -> IMP::ParticlePair"""
6562 return _IMP_kernel.PairContainer_get_particle_pair(self, i)
6565 def __init__(self, *args):
6567 __init__(IMP::PairContainer self, Model m, std::string name) -> PairContainer
6568 __init__(IMP::PairContainer self, Model m) -> PairContainer
6570 if self.__class__ == PairContainer:
6574 this = _IMP_kernel.new_PairContainer(_self, *args)
6576 self.this.append(this)
6577 except __builtin__.Exception:
6580 if self.__class__ != PairContainer:
6581 _director_objects.register(self)
6586 def do_apply(self, sm):
6587 """do_apply(PairContainer self, PairModifier sm)"""
6588 return _IMP_kernel.PairContainer_do_apply(self, sm)
6591 def do_get_provides_access(self):
6592 """do_get_provides_access(PairContainer self) -> bool"""
6593 return _IMP_kernel.PairContainer_do_get_provides_access(self)
6595 __swig_destroy__ = _IMP_kernel.delete_PairContainer
6596 __del__ =
lambda self:
None
6599 """__str__(PairContainer self) -> std::string"""
6600 return _IMP_kernel.PairContainer___str__(self)
6604 """__repr__(PairContainer self) -> std::string"""
6605 return _IMP_kernel.PairContainer___repr__(self)
6610 return _object_cast_to_PairContainer(o)
6613 def get_type_name(self):
6614 return self.__class__.__name__
6615 def do_show(self, out):
6617 def get_version_info(self):
6619 return VersionInfo(self.__module__,
6620 __import__(self.__module__).get_module_version())
6623 __import__(self.__module__).get_module_version())
6626 return _object_cast_to_PairContainer(o)
6628 def __disown__(self):
6630 _IMP_kernel.disown_PairContainer(self)
6631 return weakref_proxy(self)
6633 def do_destroy(self):
6634 """do_destroy(PairContainer self)"""
6635 return _IMP_kernel.PairContainer_do_destroy(self)
6638 def handle_set_has_required_score_states(self, arg0):
6639 """handle_set_has_required_score_states(PairContainer self, bool arg0)"""
6640 return _IMP_kernel.PairContainer_handle_set_has_required_score_states(self, arg0)
6643 def do_get_inputs(self):
6644 """do_get_inputs(PairContainer self) -> IMP::ModelObjectsTemp"""
6645 return _IMP_kernel.PairContainer_do_get_inputs(self)
6648 def do_get_interactions(self):
6649 """do_get_interactions(PairContainer self) -> IMP::ModelObjectsTemps"""
6650 return _IMP_kernel.PairContainer_do_get_interactions(self)
6653 def do_get_contents_hash(self):
6654 """do_get_contents_hash(PairContainer self) -> std::size_t"""
6655 return _IMP_kernel.PairContainer_do_get_contents_hash(self)
6657 PairContainer_swigregister = _IMP_kernel.PairContainer_swigregister
6658 PairContainer_swigregister(PairContainer)
6660 class _PairContainerAdaptor(_InputAdaptor):
6661 """Proxy of C++ IMP::PairContainerAdaptor class."""
6663 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6664 __repr__ = _swig_repr
6666 def __init__(self, *args):
6668 __init__(IMP::PairContainerAdaptor self) -> _PairContainerAdaptor
6669 __init__(IMP::PairContainerAdaptor self, PairContainer c) -> _PairContainerAdaptor
6670 __init__(IMP::PairContainerAdaptor self, IMP::ParticlePairsTemp const & t) -> _PairContainerAdaptor
6672 this = _IMP_kernel.new__PairContainerAdaptor(*args)
6674 self.this.append(this)
6675 except __builtin__.Exception:
6678 def set_name_if_default(self, name):
6679 """set_name_if_default(_PairContainerAdaptor self, std::string name)"""
6680 return _IMP_kernel._PairContainerAdaptor_set_name_if_default(self, name)
6682 __swig_destroy__ = _IMP_kernel.delete__PairContainerAdaptor
6683 __del__ =
lambda self:
None
6684 _PairContainerAdaptor_swigregister = _IMP_kernel._PairContainerAdaptor_swigregister
6685 _PairContainerAdaptor_swigregister(_PairContainerAdaptor)
6687 class QuadModifier(_ParticleInputs, _ParticleOutputs, Object):
6688 """Proxy of C++ IMP::QuadModifier class."""
6690 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6692 def __init__(self, *args):
6694 __init__(IMP::QuadModifier self, std::string name) -> QuadModifier
6695 __init__(IMP::QuadModifier self) -> QuadModifier
6697 if self.__class__ == QuadModifier:
6701 this = _IMP_kernel.new_QuadModifier(_self, *args)
6703 self.this.append(this)
6704 except __builtin__.Exception:
6707 if self.__class__ != QuadModifier:
6708 _director_objects.register(self)
6713 def apply_index(self, m, v):
6714 """apply_index(QuadModifier self, Model m, IMP::ParticleIndexQuad const & v)"""
6715 return _IMP_kernel.QuadModifier_apply_index(self, m, v)
6718 def apply_indexes(self, m, o, lower_bound, upper_bound):
6719 """apply_indexes(QuadModifier self, Model m, IMP::ParticleIndexQuads const & o, unsigned int lower_bound, unsigned int upper_bound)"""
6720 return _IMP_kernel.QuadModifier_apply_indexes(self, m, o, lower_bound, upper_bound)
6724 """__str__(QuadModifier self) -> std::string"""
6725 return _IMP_kernel.QuadModifier___str__(self)
6729 """__repr__(QuadModifier self) -> std::string"""
6730 return _IMP_kernel.QuadModifier___repr__(self)
6735 return _object_cast_to_QuadModifier(o)
6738 def get_type_name(self):
6739 return self.__class__.__name__
6740 def do_show(self, out):
6742 def get_version_info(self):
6744 return VersionInfo(self.__module__,
6745 __import__(self.__module__).get_module_version())
6748 __import__(self.__module__).get_module_version())
6751 return _object_cast_to_QuadModifier(o)
6753 __swig_destroy__ = _IMP_kernel.delete_QuadModifier
6754 __del__ =
lambda self:
None
6755 def __disown__(self):
6757 _IMP_kernel.disown_QuadModifier(self)
6758 return weakref_proxy(self)
6760 def do_get_inputs(self, m, pis):
6761 """do_get_inputs(QuadModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6762 return _IMP_kernel.QuadModifier_do_get_inputs(self, m, pis)
6765 def do_get_outputs(self, m, pis):
6766 """do_get_outputs(QuadModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6767 return _IMP_kernel.QuadModifier_do_get_outputs(self, m, pis)
6770 def do_destroy(self):
6771 """do_destroy(QuadModifier self)"""
6772 return _IMP_kernel.QuadModifier_do_destroy(self)
6774 QuadModifier_swigregister = _IMP_kernel.QuadModifier_swigregister
6775 QuadModifier_swigregister(QuadModifier)
6777 class QuadScore(_ParticleInputs, Object):
6778 """Proxy of C++ IMP::QuadScore class."""
6780 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6782 def __init__(self, *args):
6784 __init__(IMP::QuadScore self, std::string name) -> QuadScore
6785 __init__(IMP::QuadScore self) -> QuadScore
6787 if self.__class__ == QuadScore:
6791 this = _IMP_kernel.new_QuadScore(_self, *args)
6793 self.this.append(this)
6794 except __builtin__.Exception:
6797 if self.__class__ != QuadScore:
6798 _director_objects.register(self)
6803 def evaluate_index(self, m, vt, da):
6804 """evaluate_index(QuadScore self, Model m, IMP::ParticleIndexQuad const & vt, DerivativeAccumulator da) -> double"""
6805 return _IMP_kernel.QuadScore_evaluate_index(self, m, vt, da)
6808 def evaluate_indexes(self, m, o, da, lower_bound, upper_bound):
6809 """evaluate_indexes(QuadScore self, Model m, IMP::ParticleIndexQuads const & o, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound) -> double"""
6810 return _IMP_kernel.QuadScore_evaluate_indexes(self, m, o, da, lower_bound, upper_bound)
6813 def evaluate_if_good_index(self, m, vt, da, max):
6814 """evaluate_if_good_index(QuadScore self, Model m, IMP::ParticleIndexQuad const & vt, DerivativeAccumulator da, double max) -> double"""
6815 return _IMP_kernel.QuadScore_evaluate_if_good_index(self, m, vt, da, max)
6818 def evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound):
6819 """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"""
6820 return _IMP_kernel.QuadScore_evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound)
6823 def create_current_decomposition(self, m, vt):
6824 """create_current_decomposition(QuadScore self, Model m, IMP::ParticleIndexQuad const & vt) -> IMP::Restraints"""
6825 return _IMP_kernel.QuadScore_create_current_decomposition(self, m, vt)
6828 def do_create_current_decomposition(self, m, vt):
6829 """do_create_current_decomposition(QuadScore self, Model m, IMP::ParticleIndexQuad const & vt) -> IMP::Restraints"""
6830 return _IMP_kernel.QuadScore_do_create_current_decomposition(self, m, vt)
6832 __swig_destroy__ = _IMP_kernel.delete_QuadScore
6833 __del__ =
lambda self:
None
6836 """__str__(QuadScore self) -> std::string"""
6837 return _IMP_kernel.QuadScore___str__(self)
6841 """__repr__(QuadScore self) -> std::string"""
6842 return _IMP_kernel.QuadScore___repr__(self)
6847 return _object_cast_to_QuadScore(o)
6850 def get_type_name(self):
6851 return self.__class__.__name__
6852 def do_show(self, out):
6854 def get_version_info(self):
6856 return VersionInfo(self.__module__,
6857 __import__(self.__module__).get_module_version())
6860 __import__(self.__module__).get_module_version())
6863 return _object_cast_to_QuadScore(o)
6865 def __disown__(self):
6867 _IMP_kernel.disown_QuadScore(self)
6868 return weakref_proxy(self)
6870 def do_get_inputs(self, m, pis):
6871 """do_get_inputs(QuadScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6872 return _IMP_kernel.QuadScore_do_get_inputs(self, m, pis)
6875 def do_destroy(self):
6876 """do_destroy(QuadScore self)"""
6877 return _IMP_kernel.QuadScore_do_destroy(self)
6879 QuadScore_swigregister = _IMP_kernel.QuadScore_swigregister
6880 QuadScore_swigregister(QuadScore)
6882 class QuadPredicate(_ParticleInputs, Object):
6883 """Proxy of C++ IMP::QuadPredicate class."""
6885 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6887 def __init__(self, *args):
6889 __init__(IMP::QuadPredicate self, std::string name) -> QuadPredicate
6890 __init__(IMP::QuadPredicate self) -> QuadPredicate
6892 if self.__class__ == QuadPredicate:
6896 this = _IMP_kernel.new_QuadPredicate(_self, *args)
6898 self.this.append(this)
6899 except __builtin__.Exception:
6902 if self.__class__ != QuadPredicate:
6903 _director_objects.register(self)
6908 def get_value(self, *args):
6910 get_value(QuadPredicate self, IMP::ParticleQuad const & vt) -> int
6911 get_value(QuadPredicate self, IMP::ParticleQuadsTemp const & o) -> IMP::Ints
6913 return _IMP_kernel.QuadPredicate_get_value(self, *args)
6916 def __call__(self, m, vt):
6917 """__call__(QuadPredicate self, Model m, IMP::ParticleIndexQuad const & vt) -> int"""
6918 return _IMP_kernel.QuadPredicate___call__(self, m, vt)
6921 def get_value_index(self, *args):
6923 get_value_index(QuadPredicate self, Model m, IMP::ParticleIndexQuad const & vt) -> int
6924 get_value_index(QuadPredicate self, Model m, IMP::ParticleIndexQuads const & o) -> IMP::Ints
6926 return _IMP_kernel.QuadPredicate_get_value_index(self, *args)
6928 __swig_destroy__ = _IMP_kernel.delete_QuadPredicate
6929 __del__ =
lambda self:
None
6932 """__str__(QuadPredicate self) -> std::string"""
6933 return _IMP_kernel.QuadPredicate___str__(self)
6937 """__repr__(QuadPredicate self) -> std::string"""
6938 return _IMP_kernel.QuadPredicate___repr__(self)
6943 return _object_cast_to_QuadPredicate(o)
6946 def get_type_name(self):
6947 return self.__class__.__name__
6948 def do_show(self, out):
6950 def get_version_info(self):
6952 return VersionInfo(self.__module__,
6953 __import__(self.__module__).get_module_version())
6956 __import__(self.__module__).get_module_version())
6959 return _object_cast_to_QuadPredicate(o)
6961 def __disown__(self):
6963 _IMP_kernel.disown_QuadPredicate(self)
6964 return weakref_proxy(self)
6966 def do_get_inputs(self, m, pis):
6967 """do_get_inputs(QuadPredicate self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6968 return _IMP_kernel.QuadPredicate_do_get_inputs(self, m, pis)
6971 def do_destroy(self):
6972 """do_destroy(QuadPredicate self)"""
6973 return _IMP_kernel.QuadPredicate_do_destroy(self)
6975 QuadPredicate_swigregister = _IMP_kernel.QuadPredicate_swigregister
6976 QuadPredicate_swigregister(QuadPredicate)
6978 class QuadContainer(Container):
6979 """Proxy of C++ IMP::QuadContainer class."""
6981 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6983 def apply_generic(self, m):
6984 """apply_generic(QuadContainer self, QuadModifier m)"""
6985 return _IMP_kernel.QuadContainer_apply_generic(self, m)
6988 def apply(self, sm):
6989 """apply(QuadContainer self, QuadModifier sm)"""
6990 return _IMP_kernel.QuadContainer_apply(self, sm)
6993 def get_range_indexes(self):
6994 """get_range_indexes(QuadContainer self) -> IMP::ParticleIndexQuads"""
6995 return _IMP_kernel.QuadContainer_get_range_indexes(self)
6998 def get_contents(self):
6999 """get_contents(QuadContainer self) -> IMP::ParticleIndexQuads const &"""
7000 return _IMP_kernel.QuadContainer_get_contents(self)
7004 """get_indexes(QuadContainer self) -> IMP::ParticleIndexQuads"""
7005 return _IMP_kernel.QuadContainer_get_indexes(self)
7008 def get(self, *args):
7010 get(QuadContainer self) -> IMP::ParticleQuadsTemp
7011 get(QuadContainer self, unsigned int i) -> IMP::ParticleQuad
7013 return _IMP_kernel.QuadContainer_get(self, *args)
7016 def get_number(self):
7017 """get_number(QuadContainer self) -> unsigned int"""
7018 return _IMP_kernel.QuadContainer_get_number(self)
7021 def get_particle_quads(self):
7022 """get_particle_quads(QuadContainer self) -> IMP::ParticleQuadsTemp"""
7023 return _IMP_kernel.QuadContainer_get_particle_quads(self)
7026 def get_particle_quad(self, i):
7027 """get_particle_quad(QuadContainer self, unsigned int i) -> IMP::ParticleQuad"""
7028 return _IMP_kernel.QuadContainer_get_particle_quad(self, i)
7031 def __init__(self, *args):
7033 __init__(IMP::QuadContainer self, Model m, std::string name) -> QuadContainer
7034 __init__(IMP::QuadContainer self, Model m) -> QuadContainer
7036 if self.__class__ == QuadContainer:
7040 this = _IMP_kernel.new_QuadContainer(_self, *args)
7042 self.this.append(this)
7043 except __builtin__.Exception:
7046 if self.__class__ != QuadContainer:
7047 _director_objects.register(self)
7052 def do_apply(self, sm):
7053 """do_apply(QuadContainer self, QuadModifier sm)"""
7054 return _IMP_kernel.QuadContainer_do_apply(self, sm)
7057 def do_get_provides_access(self):
7058 """do_get_provides_access(QuadContainer self) -> bool"""
7059 return _IMP_kernel.QuadContainer_do_get_provides_access(self)
7061 __swig_destroy__ = _IMP_kernel.delete_QuadContainer
7062 __del__ =
lambda self:
None
7065 """__str__(QuadContainer self) -> std::string"""
7066 return _IMP_kernel.QuadContainer___str__(self)
7070 """__repr__(QuadContainer self) -> std::string"""
7071 return _IMP_kernel.QuadContainer___repr__(self)
7076 return _object_cast_to_QuadContainer(o)
7079 def get_type_name(self):
7080 return self.__class__.__name__
7081 def do_show(self, out):
7083 def get_version_info(self):
7085 return VersionInfo(self.__module__,
7086 __import__(self.__module__).get_module_version())
7089 __import__(self.__module__).get_module_version())
7092 return _object_cast_to_QuadContainer(o)
7094 def __disown__(self):
7096 _IMP_kernel.disown_QuadContainer(self)
7097 return weakref_proxy(self)
7099 def do_destroy(self):
7100 """do_destroy(QuadContainer self)"""
7101 return _IMP_kernel.QuadContainer_do_destroy(self)
7104 def handle_set_has_required_score_states(self, arg0):
7105 """handle_set_has_required_score_states(QuadContainer self, bool arg0)"""
7106 return _IMP_kernel.QuadContainer_handle_set_has_required_score_states(self, arg0)
7109 def do_get_inputs(self):
7110 """do_get_inputs(QuadContainer self) -> IMP::ModelObjectsTemp"""
7111 return _IMP_kernel.QuadContainer_do_get_inputs(self)
7114 def do_get_interactions(self):
7115 """do_get_interactions(QuadContainer self) -> IMP::ModelObjectsTemps"""
7116 return _IMP_kernel.QuadContainer_do_get_interactions(self)
7119 def do_get_contents_hash(self):
7120 """do_get_contents_hash(QuadContainer self) -> std::size_t"""
7121 return _IMP_kernel.QuadContainer_do_get_contents_hash(self)
7123 QuadContainer_swigregister = _IMP_kernel.QuadContainer_swigregister
7124 QuadContainer_swigregister(QuadContainer)
7126 class _QuadContainerAdaptor(_InputAdaptor):
7127 """Proxy of C++ IMP::QuadContainerAdaptor class."""
7129 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
7130 __repr__ = _swig_repr
7132 def __init__(self, *args):
7134 __init__(IMP::QuadContainerAdaptor self) -> _QuadContainerAdaptor
7135 __init__(IMP::QuadContainerAdaptor self, QuadContainer c) -> _QuadContainerAdaptor
7136 __init__(IMP::QuadContainerAdaptor self, IMP::ParticleQuadsTemp const & t) -> _QuadContainerAdaptor
7138 this = _IMP_kernel.new__QuadContainerAdaptor(*args)
7140 self.this.append(this)
7141 except __builtin__.Exception:
7144 def set_name_if_default(self, name):
7145 """set_name_if_default(_QuadContainerAdaptor self, std::string name)"""
7146 return _IMP_kernel._QuadContainerAdaptor_set_name_if_default(self, name)
7148 __swig_destroy__ = _IMP_kernel.delete__QuadContainerAdaptor
7149 __del__ =
lambda self:
None
7150 _QuadContainerAdaptor_swigregister = _IMP_kernel._QuadContainerAdaptor_swigregister
7151 _QuadContainerAdaptor_swigregister(_QuadContainerAdaptor)
7153 class SingletonModifier(_ParticleInputs, _ParticleOutputs, Object):
7154 """Proxy of C++ IMP::SingletonModifier class."""
7156 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
7158 def __init__(self, *args):
7160 __init__(IMP::SingletonModifier self, std::string name) -> SingletonModifier
7161 __init__(IMP::SingletonModifier self) -> SingletonModifier
7163 if self.__class__ == SingletonModifier:
7167 this = _IMP_kernel.new_SingletonModifier(_self, *args)
7169 self.this.append(this)
7170 except __builtin__.Exception:
7173 if self.__class__ != SingletonModifier:
7174 _director_objects.register(self)
7179 def apply_index(self, m, v):
7180 """apply_index(SingletonModifier self, Model m, ParticleIndex v)"""
7181 return _IMP_kernel.SingletonModifier_apply_index(self, m, v)
7184 def apply_indexes(self, m, o, lower_bound, upper_bound):
7185 """apply_indexes(SingletonModifier self, Model m, IMP::ParticleIndexes const & o, unsigned int lower_bound, unsigned int upper_bound)"""
7186 return _IMP_kernel.SingletonModifier_apply_indexes(self, m, o, lower_bound, upper_bound)
7190 """__str__(SingletonModifier self) -> std::string"""
7191 return _IMP_kernel.SingletonModifier___str__(self)
7195 """__repr__(SingletonModifier self) -> std::string"""
7196 return _IMP_kernel.SingletonModifier___repr__(self)
7201 return _object_cast_to_SingletonModifier(o)
7204 def get_type_name(self):
7205 return self.__class__.__name__
7206 def do_show(self, out):
7208 def get_version_info(self):
7210 return VersionInfo(self.__module__,
7211 __import__(self.__module__).get_module_version())
7214 __import__(self.__module__).get_module_version())
7217 return _object_cast_to_SingletonModifier(o)
7219 __swig_destroy__ = _IMP_kernel.delete_SingletonModifier
7220 __del__ =
lambda self:
None
7221 def __disown__(self):
7223 _IMP_kernel.disown_SingletonModifier(self)
7224 return weakref_proxy(self)
7226 def do_get_inputs(self, m, pis):
7227 """do_get_inputs(SingletonModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7228 return _IMP_kernel.SingletonModifier_do_get_inputs(self, m, pis)