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 class VersionInfo(_Value):
482 """Proxy of C++ IMP::VersionInfo class."""
484 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
486 def __init__(self, *args):
488 __init__(IMP::VersionInfo self, std::string module, std::string version) -> VersionInfo
489 __init__(IMP::VersionInfo self) -> VersionInfo
491 this = _IMP_kernel.new_VersionInfo(*args)
493 self.this.append(this)
494 except __builtin__.Exception:
497 def get_module(self):
498 """get_module(VersionInfo self) -> std::string"""
499 return _IMP_kernel.VersionInfo_get_module(self)
502 def get_version(self):
503 """get_version(VersionInfo self) -> std::string"""
504 return _IMP_kernel.VersionInfo_get_version(self)
507 def show(self, *args):
509 show(VersionInfo self, _ostream out)
510 show(VersionInfo self)
512 return _IMP_kernel.VersionInfo_show(self, *args)
515 def __cmp__(self, o):
516 """__cmp__(VersionInfo self, VersionInfo o) -> int"""
517 return _IMP_kernel.VersionInfo___cmp__(self, o)
521 """__eq__(VersionInfo self, VersionInfo o) -> bool"""
522 return _IMP_kernel.VersionInfo___eq__(self, o)
526 """__ne__(VersionInfo self, VersionInfo o) -> bool"""
527 return _IMP_kernel.VersionInfo___ne__(self, o)
531 """__lt__(VersionInfo self, VersionInfo o) -> bool"""
532 return _IMP_kernel.VersionInfo___lt__(self, o)
536 """__gt__(VersionInfo self, VersionInfo o) -> bool"""
537 return _IMP_kernel.VersionInfo___gt__(self, o)
541 """__ge__(VersionInfo self, VersionInfo o) -> bool"""
542 return _IMP_kernel.VersionInfo___ge__(self, o)
546 """__le__(VersionInfo self, VersionInfo o) -> bool"""
547 return _IMP_kernel.VersionInfo___le__(self, o)
551 """__str__(VersionInfo self) -> std::string"""
552 return _IMP_kernel.VersionInfo___str__(self)
556 """__repr__(VersionInfo self) -> std::string"""
557 return _IMP_kernel.VersionInfo___repr__(self)
559 __swig_destroy__ = _IMP_kernel.delete_VersionInfo
560 __del__ =
lambda self:
None
561 VersionInfo_swigregister = _IMP_kernel.VersionInfo_swigregister
562 VersionInfo_swigregister(VersionInfo)
564 class TextOutput(_InputAdaptor):
565 """Proxy of C++ IMP::TextOutput class."""
567 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
568 __repr__ = _swig_repr
570 def __init__(self, *args):
572 __init__(IMP::TextOutput self, int arg2) -> TextOutput
573 __init__(IMP::TextOutput self, double arg2) -> TextOutput
574 __init__(IMP::TextOutput self, char const * c, bool append=False) -> TextOutput
575 __init__(IMP::TextOutput self, char const * c) -> TextOutput
576 __init__(IMP::TextOutput self, IMP::TextProxy< std::ostream > p) -> TextOutput
577 __init__(IMP::TextOutput self) -> TextOutput
578 __init__(IMP::TextOutput self, std::string file_name, bool append=False) -> TextOutput
579 __init__(IMP::TextOutput self, std::string file_name) -> TextOutput
581 this = _IMP_kernel.new_TextOutput(*args)
583 self.this.append(this)
584 except __builtin__.Exception:
587 def show(self, *args):
589 show(TextOutput self, _ostream out)
590 show(TextOutput self)
592 return _IMP_kernel.TextOutput_show(self, *args)
596 """get_name(TextOutput self) -> std::string"""
597 return _IMP_kernel.TextOutput_get_name(self)
599 __swig_destroy__ = _IMP_kernel.delete_TextOutput
600 __del__ =
lambda self:
None
601 TextOutput_swigregister = _IMP_kernel.TextOutput_swigregister
602 TextOutput_swigregister(TextOutput)
604 class TextInput(_InputAdaptor):
605 """Proxy of C++ IMP::TextInput class."""
607 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
608 __repr__ = _swig_repr
610 def __init__(self, *args):
612 __init__(IMP::TextInput self, int arg2) -> TextInput
613 __init__(IMP::TextInput self, double arg2) -> TextInput
614 __init__(IMP::TextInput self, char const * c) -> TextInput
615 __init__(IMP::TextInput self, IMP::TextProxy< std::istream > p) -> TextInput
616 __init__(IMP::TextInput self) -> TextInput
617 __init__(IMP::TextInput self, std::string file_name) -> TextInput
619 this = _IMP_kernel.new_TextInput(*args)
621 self.this.append(this)
622 except __builtin__.Exception:
625 def show(self, *args):
627 show(TextInput self, _ostream out)
630 return _IMP_kernel.TextInput_show(self, *args)
634 """get_name(TextInput self) -> std::string"""
635 return _IMP_kernel.TextInput_get_name(self)
637 __swig_destroy__ = _IMP_kernel.delete_TextInput
638 __del__ =
lambda self:
None
639 TextInput_swigregister = _IMP_kernel.TextInput_swigregister
640 TextInput_swigregister(TextInput)
642 class SetLogTarget(_RAII):
643 """Proxy of C++ IMP::SetLogTarget class."""
645 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
647 def __init__(self, *args):
649 __init__(IMP::SetLogTarget self) -> SetLogTarget
650 __init__(IMP::SetLogTarget self, TextOutput to) -> SetLogTarget
652 this = _IMP_kernel.new_SetLogTarget(*args)
654 self.this.append(this)
655 except __builtin__.Exception:
659 """set(SetLogTarget self, TextOutput to)"""
660 return _IMP_kernel.SetLogTarget_set(self, to)
664 """reset(SetLogTarget self)"""
665 return _IMP_kernel.SetLogTarget_reset(self)
667 __swig_destroy__ = _IMP_kernel.delete_SetLogTarget
668 __del__ =
lambda self:
None
670 def show(self, *args):
672 show(SetLogTarget self, _ostream out)
673 show(SetLogTarget self)
675 return _IMP_kernel.SetLogTarget_show(self, *args)
680 def __exit__(self, exc_type, exc_val, exc_tb):
686 """__str__(SetLogTarget self) -> std::string"""
687 return _IMP_kernel.SetLogTarget___str__(self)
691 """__repr__(SetLogTarget self) -> std::string"""
692 return _IMP_kernel.SetLogTarget___repr__(self)
694 SetLogTarget_swigregister = _IMP_kernel.SetLogTarget_swigregister
695 SetLogTarget_swigregister(SetLogTarget)
700 create_temporary_file(std::string prefix, std::string suffix) -> TextOutput
701 create_temporary_file(std::string prefix) -> TextOutput
702 create_temporary_file() -> TextOutput
704 return _IMP_kernel.create_temporary_file(*args)
708 create_temporary_file_name(std::string prefix, std::string suffix) -> std::string
709 create_temporary_file_name(std::string prefix) -> std::string
710 create_temporary_file_name() -> std::string
712 return _IMP_kernel.create_temporary_file_name(*args)
715 """get_relative_path(std::string base, std::string relative) -> std::string"""
716 return _IMP_kernel.get_relative_path(base, relative)
718 def push_log_context(functionname, object):
719 """push_log_context(char const * functionname, void const * object)"""
720 return _IMP_kernel.push_log_context(functionname, object)
722 def pop_log_context():
723 """pop_log_context()"""
724 return _IMP_kernel.pop_log_context()
728 add_to_log(std::string to_write)
729 add_to_log(IMP::LogLevel level, std::string to_write)
731 return _IMP_kernel.add_to_log(*args)
734 """set_log_level(IMP::LogLevel l)"""
735 return _IMP_kernel.set_log_level(l)
738 """set_log_timer(bool tb)"""
739 return _IMP_kernel.set_log_timer(tb)
742 """reset_log_timer()"""
743 return _IMP_kernel.reset_log_timer()
746 """get_log_level() -> IMP::LogLevel"""
747 return _IMP_kernel.get_log_level()
750 """set_progress_display(std::string description, unsigned int steps)"""
751 return _IMP_kernel.set_progress_display(description, steps)
755 add_to_progress_display(unsigned int step=1)
756 add_to_progress_display()
758 return _IMP_kernel.add_to_progress_display(step)
759 class Object(_NonCopyable):
760 """Proxy of C++ IMP::Object class."""
762 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
764 def __init__(self, name):
765 """__init__(IMP::Object self, std::string name) -> Object"""
766 if self.__class__ == Object:
770 this = _IMP_kernel.new_Object(_self, name)
772 self.this.append(this)
773 except __builtin__.Exception:
776 if self.__class__ != Object:
777 _director_objects.register(self)
781 __swig_destroy__ = _IMP_kernel.delete_Object
782 __del__ =
lambda self:
None
785 """__hash__(Object self) -> std::size_t"""
786 return _IMP_kernel.Object___hash__(self)
790 """set_log_level(Object self, IMP::LogLevel l)"""
791 return _IMP_kernel.Object_set_log_level(self, l)
795 """set_check_level(Object self, IMP::CheckLevel l)"""
796 return _IMP_kernel.Object_set_check_level(self, l)
800 """get_log_level(Object self) -> IMP::LogLevel"""
801 return _IMP_kernel.Object_get_log_level(self)
805 """get_check_level(Object self) -> IMP::CheckLevel"""
806 return _IMP_kernel.Object_get_check_level(self)
809 def get_version_info(self):
810 """get_version_info(Object self) -> VersionInfo"""
811 return _IMP_kernel.Object_get_version_info(self)
815 """get_name(Object self) -> std::string const &"""
816 return _IMP_kernel.Object_get_name(self)
819 def set_name(self, name):
820 """set_name(Object self, std::string name)"""
821 return _IMP_kernel.Object_set_name(self, name)
824 def get_type_name(self):
825 """get_type_name(Object self) -> std::string"""
826 return _IMP_kernel.Object_get_type_name(self)
829 def set_was_used(self, tf):
830 """set_was_used(Object self, bool tf)"""
831 return _IMP_kernel.Object_set_was_used(self, tf)
834 def show(self, *args):
836 show(Object self, _ostream out)
839 return _IMP_kernel.Object_show(self, *args)
842 def get_string(self):
843 """get_string(Object self) -> std::string"""
844 return _IMP_kernel.Object_get_string(self)
847 def _on_destruction(self):
848 """_on_destruction(Object self)"""
849 return _IMP_kernel.Object__on_destruction(self)
852 def get_is_valid(self):
853 """get_is_valid(Object self) -> bool"""
854 return _IMP_kernel.Object_get_is_valid(self)
857 def get_ref_count(self):
858 """get_ref_count(Object self) -> unsigned int"""
859 return _IMP_kernel.Object_get_ref_count(self)
862 def get_number_of_live_objects():
863 """get_number_of_live_objects() -> unsigned int"""
864 return _IMP_kernel.Object_get_number_of_live_objects()
866 get_number_of_live_objects = staticmethod(get_number_of_live_objects)
868 def get_is_shared(self):
869 """get_is_shared(Object self) -> bool"""
870 return _IMP_kernel.Object_get_is_shared(self)
873 def clear_caches(self):
874 """clear_caches(Object self)"""
875 return _IMP_kernel.Object_clear_caches(self)
878 def do_destroy(self):
879 """do_destroy(Object self)"""
880 return _IMP_kernel.Object_do_destroy(self)
884 """__eq__(Object self, Object o) -> bool"""
885 return _IMP_kernel.Object___eq__(self, o)
889 """__ne__(Object self, Object o) -> bool"""
890 return _IMP_kernel.Object___ne__(self, o)
894 """__le__(Object self, Object o) -> bool"""
895 return _IMP_kernel.Object___le__(self, o)
899 """__lt__(Object self, Object o) -> bool"""
900 return _IMP_kernel.Object___lt__(self, o)
904 """__ge__(Object self, Object o) -> bool"""
905 return _IMP_kernel.Object___ge__(self, o)
909 """__gt__(Object self, Object o) -> bool"""
910 return _IMP_kernel.Object___gt__(self, o)
914 """__str__(Object self) -> std::string"""
915 return _IMP_kernel.Object___str__(self)
919 """__repr__(Object self) -> std::string"""
920 return _IMP_kernel.Object___repr__(self)
925 return _object_cast_to_Object(o)
927 def __disown__(self):
929 _IMP_kernel.disown_Object(self)
930 return weakref_proxy(self)
931 Object_swigregister = _IMP_kernel.Object_swigregister
932 Object_swigregister(Object)
934 def Object_get_number_of_live_objects():
935 """Object_get_number_of_live_objects() -> unsigned int"""
936 return _IMP_kernel.Object_get_number_of_live_objects()
938 class SetLogState(_RAII):
939 """Proxy of C++ IMP::SetLogState class."""
941 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
944 """reset(SetLogState self)"""
945 return _IMP_kernel.SetLogState_reset(self)
947 __swig_destroy__ = _IMP_kernel.delete_SetLogState
948 __del__ =
lambda self:
None
950 def show(self, *args):
952 show(SetLogState self, _ostream out)
953 show(SetLogState self)
955 return _IMP_kernel.SetLogState_show(self, *args)
958 def __init__(self, *args):
960 __init__(IMP::SetLogState self) -> SetLogState
961 __init__(IMP::SetLogState self, Object o, IMP::LogLevel l) -> SetLogState
962 __init__(IMP::SetLogState self, IMP::LogLevel l) -> SetLogState
964 this = _IMP_kernel.new_SetLogState(*args)
966 self.this.append(this)
967 except __builtin__.Exception:
970 def set(self, *args):
972 set(SetLogState self, Object o, IMP::LogLevel l)
973 set(SetLogState self, IMP::LogLevel l)
975 return _IMP_kernel.SetLogState_set(self, *args)
980 def __exit__(self, exc_type, exc_val, exc_tb):
986 """__str__(SetLogState self) -> std::string"""
987 return _IMP_kernel.SetLogState___str__(self)
991 """__repr__(SetLogState self) -> std::string"""
992 return _IMP_kernel.SetLogState___repr__(self)
994 SetLogState_swigregister = _IMP_kernel.SetLogState_swigregister
995 SetLogState_swigregister(SetLogState)
997 class WarningContext(object):
998 """Proxy of C++ IMP::WarningContext class."""
1000 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
1001 data_ = _swig_property(_IMP_kernel.WarningContext_data__get, _IMP_kernel.WarningContext_data__set)
1003 def add_warning(self, key, warning):
1004 """add_warning(WarningContext self, std::string key, std::string warning)"""
1005 return _IMP_kernel.WarningContext_add_warning(self, key, warning)
1008 def clear_warnings(self):
1009 """clear_warnings(WarningContext self)"""
1010 return _IMP_kernel.WarningContext_clear_warnings(self)
1013 def dump_warnings(self):
1014 """dump_warnings(WarningContext self)"""
1015 return _IMP_kernel.WarningContext_dump_warnings(self)
1017 __swig_destroy__ = _IMP_kernel.delete_WarningContext
1018 __del__ =
lambda self:
None
1020 def show(self, *args):
1022 show(WarningContext self, _ostream out)
1023 show(WarningContext self)
1025 return _IMP_kernel.WarningContext_show(self, *args)
1028 def __enter__(self):
1030 def __exit__(self, exc_type, exc_val, exc_tb):
1036 """__str__(WarningContext self) -> std::string"""
1037 return _IMP_kernel.WarningContext___str__(self)
1041 """__repr__(WarningContext self) -> std::string"""
1042 return _IMP_kernel.WarningContext___repr__(self)
1046 """__init__(IMP::WarningContext self) -> WarningContext"""
1047 this = _IMP_kernel.new_WarningContext()
1049 self.this.append(this)
1050 except __builtin__.Exception:
1052 WarningContext_swigregister = _IMP_kernel.WarningContext_swigregister
1053 WarningContext_swigregister(WarningContext)
1055 class CreateLogContext(_RAII):
1056 """Proxy of C++ IMP::CreateLogContext class."""
1058 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
1060 def __init__(self, *args):
1062 __init__(IMP::CreateLogContext self, std::string fname, Object object=None) -> CreateLogContext
1063 __init__(IMP::CreateLogContext self, std::string fname) -> CreateLogContext
1064 __init__(IMP::CreateLogContext self) -> CreateLogContext
1065 __init__(IMP::CreateLogContext self, char const * fname, Object object=None) -> CreateLogContext
1066 __init__(IMP::CreateLogContext self, char const * fname) -> CreateLogContext
1068 this = _IMP_kernel.new_CreateLogContext(*args)
1070 self.this.append(this)
1071 except __builtin__.Exception:
1074 def set(self, fname, object=None):
1076 set(CreateLogContext self, char const * fname, Object object=None)
1077 set(CreateLogContext self, char const * fname)
1079 return _IMP_kernel.CreateLogContext_set(self, fname, object)
1083 """reset(CreateLogContext self)"""
1084 return _IMP_kernel.CreateLogContext_reset(self)
1086 __swig_destroy__ = _IMP_kernel.delete_CreateLogContext
1087 __del__ =
lambda self:
None
1089 def show(self, *args):
1091 show(CreateLogContext self, _ostream out)
1092 show(CreateLogContext self)
1094 return _IMP_kernel.CreateLogContext_show(self, *args)
1097 def __enter__(self):
1099 def __exit__(self, exc_type, exc_val, exc_tb):
1105 """__str__(CreateLogContext self) -> std::string"""
1106 return _IMP_kernel.CreateLogContext___str__(self)
1110 """__repr__(CreateLogContext self) -> std::string"""
1111 return _IMP_kernel.CreateLogContext___repr__(self)
1113 CreateLogContext_swigregister = _IMP_kernel.CreateLogContext_swigregister
1114 CreateLogContext_swigregister(CreateLogContext)
1116 class SetCheckState(_RAII):
1117 """Proxy of C++ IMP::SetCheckState class."""
1119 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
1122 """reset(SetCheckState self)"""
1123 return _IMP_kernel.SetCheckState_reset(self)
1125 __swig_destroy__ = _IMP_kernel.delete_SetCheckState
1126 __del__ =
lambda self:
None
1128 def show(self, *args):
1130 show(SetCheckState self, _ostream out)
1131 show(SetCheckState self)
1133 return _IMP_kernel.SetCheckState_show(self, *args)
1136 def __init__(self, *args):
1138 __init__(IMP::SetCheckState self) -> SetCheckState
1139 __init__(IMP::SetCheckState self, Object o, IMP::CheckLevel l) -> SetCheckState
1140 __init__(IMP::SetCheckState self, IMP::CheckLevel l) -> SetCheckState
1142 this = _IMP_kernel.new_SetCheckState(*args)
1144 self.this.append(this)
1145 except __builtin__.Exception:
1148 def set(self, *args):
1150 set(SetCheckState self, Object o, IMP::CheckLevel l)
1151 set(SetCheckState self, IMP::CheckLevel l)
1153 return _IMP_kernel.SetCheckState_set(self, *args)
1156 def __enter__(self):
1158 def __exit__(self, exc_type, exc_val, exc_tb):
1164 """__str__(SetCheckState self) -> std::string"""
1165 return _IMP_kernel.SetCheckState___str__(self)
1169 """__repr__(SetCheckState self) -> std::string"""
1170 return _IMP_kernel.SetCheckState___repr__(self)
1172 SetCheckState_swigregister = _IMP_kernel.SetCheckState_swigregister
1173 SetCheckState_swigregister(SetCheckState)
1177 """get_unique_name(std::string templ) -> std::string"""
1178 return _IMP_kernel.get_unique_name(templ)
1179 class _Protection(object):
1180 """Proxy of C++ IMP::internal::_Protection class."""
1182 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
1184 def __init__(self, *args, **kwargs):
1185 raise AttributeError(
"No constructor defined")
1187 def show(self, *args):
1189 show(_Protection self, _ostream out)
1190 show(_Protection self)
1192 return _IMP_kernel._Protection_show(self, *args)
1196 """__str__(_Protection self) -> std::string"""
1197 return _IMP_kernel._Protection___str__(self)
1201 """__repr__(_Protection self) -> std::string"""
1202 return _IMP_kernel._Protection___repr__(self)
1204 __swig_destroy__ = _IMP_kernel.delete__Protection
1205 __del__ =
lambda self:
None
1206 _Protection_swigregister = _IMP_kernel._Protection_swigregister
1207 _Protection_swigregister(_Protection)
1212 return _IMP_kernel._test_log()
1214 def _test_intranges(ips):
1215 """_test_intranges(IMP::IntRanges const & ips) -> int"""
1216 return _IMP_kernel._test_intranges(ips)
1218 def _test_intrange(*args):
1220 _test_intrange(IMP::IntRange const & ips) -> IMP::IntRange
1221 _test_intrange() -> IMP::IntRange
1223 return _IMP_kernel._test_intrange(*args)
1226 """_test_ifile(TextInput a) -> std::string"""
1227 return _IMP_kernel._test_ifile(a)
1230 """_test_ofile(TextOutput a) -> std::string"""
1231 return _IMP_kernel._test_ofile(a)
1233 def _test_ifile_overloaded(*args):
1235 _test_ifile_overloaded(TextInput a, int i) -> std::string
1236 _test_ifile_overloaded(TextInput a, std::string st) -> std::string
1238 return _IMP_kernel._test_ifile_overloaded(*args)
1240 def _test_ofile_overloaded(*args):
1242 _test_ofile_overloaded(TextOutput a, int i) -> std::string
1243 _test_ofile_overloaded(TextOutput a, std::string st) -> std::string
1245 return _IMP_kernel._test_ofile_overloaded(*args)
1246 class _TestValue(object):
1247 """Proxy of C++ IMP::internal::_TestValue class."""
1249 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
1251 def __init__(self, i):
1252 """__init__(IMP::internal::_TestValue self, int i) -> _TestValue"""
1253 this = _IMP_kernel.new__TestValue(i)
1255 self.this.append(this)
1256 except __builtin__.Exception:
1259 def show(self, *args):
1261 show(_TestValue self, _ostream out)
1262 show(_TestValue self)
1264 return _IMP_kernel._TestValue_show(self, *args)
1267 def __cmp__(self, o):
1268 """__cmp__(_TestValue self, _TestValue o) -> int"""
1269 return _IMP_kernel._TestValue___cmp__(self, o)
1272 def __eq__(self, o):
1273 """__eq__(_TestValue self, _TestValue o) -> bool"""
1274 return _IMP_kernel._TestValue___eq__(self, o)
1277 def __ne__(self, o):
1278 """__ne__(_TestValue self, _TestValue o) -> bool"""
1279 return _IMP_kernel._TestValue___ne__(self, o)
1282 def __lt__(self, o):
1283 """__lt__(_TestValue self, _TestValue o) -> bool"""
1284 return _IMP_kernel._TestValue___lt__(self, o)
1287 def __gt__(self, o):
1288 """__gt__(_TestValue self, _TestValue o) -> bool"""
1289 return _IMP_kernel._TestValue___gt__(self, o)
1292 def __ge__(self, o):
1293 """__ge__(_TestValue self, _TestValue o) -> bool"""
1294 return _IMP_kernel._TestValue___ge__(self, o)
1297 def __le__(self, o):
1298 """__le__(_TestValue self, _TestValue o) -> bool"""
1299 return _IMP_kernel._TestValue___le__(self, o)
1303 """get(_TestValue self) -> int"""
1304 return _IMP_kernel._TestValue_get(self)
1307 def get_float(self):
1308 """get_float(_TestValue self) -> float const &"""
1309 return _IMP_kernel._TestValue_get_float(self)
1312 def get_double(self):
1313 """get_double(_TestValue self) -> double const &"""
1314 return _IMP_kernel._TestValue_get_double(self)
1317 def get_Float(self):
1318 """get_Float(_TestValue self) -> IMP::Float const &"""
1319 return _IMP_kernel._TestValue_get_Float(self)
1323 """get_int(_TestValue self) -> int const &"""
1324 return _IMP_kernel._TestValue_get_int(self)
1328 """get_Int(_TestValue self) -> IMP::Int const &"""
1329 return _IMP_kernel._TestValue_get_Int(self)
1332 def get_string(self):
1333 """get_string(_TestValue self) -> std::string const &"""
1334 return _IMP_kernel._TestValue_get_string(self)
1337 def get_String(self):
1338 """get_String(_TestValue self) -> IMP::String const &"""
1339 return _IMP_kernel._TestValue_get_String(self)
1343 """__str__(_TestValue self) -> std::string"""
1344 return _IMP_kernel._TestValue___str__(self)
1348 """__repr__(_TestValue self) -> std::string"""
1349 return _IMP_kernel._TestValue___repr__(self)
1351 __swig_destroy__ = _IMP_kernel.delete__TestValue
1352 __del__ =
lambda self:
None
1353 _TestValue_swigregister = _IMP_kernel._TestValue_swigregister
1354 _TestValue_swigregister(_TestValue)
1357 def _pass_plain_pair(p):
1358 """_pass_plain_pair(IMP::FloatPair p) -> IMP::FloatPair"""
1359 return _IMP_kernel._pass_plain_pair(p)
1361 def _pass_overloaded_strings(*args):
1363 _pass_overloaded_strings(IMP::Strings const & a, int arg2) -> IMP::Strings
1364 _pass_overloaded_strings(IMP::Strings const & a) -> IMP::Strings
1366 return _IMP_kernel._pass_overloaded_strings(*args)
1369 """_pass_pair(IMP::DerivativePair const & p) -> IMP::DerivativePair"""
1370 return _IMP_kernel._pass_pair(p)
1372 def _pass_floats(input):
1373 """_pass_floats(IMP::Floats const & input) -> IMP::Floats"""
1374 return _IMP_kernel._pass_floats(input)
1376 def _pass_ints(input):
1377 """_pass_ints(IMP::Ints input) -> IMP::Ints"""
1378 return _IMP_kernel._pass_ints(input)
1380 def _pass_ints_list(input):
1381 """_pass_ints_list(IMP::IntsList const & input) -> IMP::IntsList"""
1382 return _IMP_kernel._pass_ints_list(input)
1384 def _pass_ints_lists(input):
1385 """_pass_ints_lists(IMP::IntsLists const & input) -> IMP::IntsLists"""
1386 return _IMP_kernel._pass_ints_lists(input)
1388 def _pass_strings(input):
1389 """_pass_strings(IMP::Strings const & input) -> IMP::Strings const &"""
1390 return _IMP_kernel._pass_strings(input)
1391 class _TestObject(Object):
1392 """Proxy of C++ IMP::internal::_TestObject class."""
1394 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
1397 """__init__(IMP::internal::_TestObject self) -> _TestObject"""
1398 this = _IMP_kernel.new__TestObject()
1400 self.this.append(this)
1401 except __builtin__.Exception:
1404 def get_version_info(self):
1405 """get_version_info(_TestObject self) -> VersionInfo"""
1406 return _IMP_kernel._TestObject_get_version_info(self)
1410 """__str__(_TestObject self) -> std::string"""
1411 return _IMP_kernel._TestObject___str__(self)
1415 """__repr__(_TestObject self) -> std::string"""
1416 return _IMP_kernel._TestObject___repr__(self)
1421 return _object_cast_to__TestObject(o)
1423 _TestObject_swigregister = _IMP_kernel._TestObject_swigregister
1424 _TestObject_swigregister(_TestObject)
1428 """get_live_object_names() -> IMP::Strings"""
1429 return _IMP_kernel.get_live_object_names()
1432 """get_live_objects() -> IMP::Objects"""
1433 return _IMP_kernel.get_live_objects()
1436 """set_show_leaked_objects(bool tf)"""
1437 return _IMP_kernel.set_show_leaked_objects(tf)
1440 """set_deprecation_warnings(bool tf)"""
1441 return _IMP_kernel.set_deprecation_warnings(tf)
1444 """set_deprecation_exceptions(bool tf)"""
1445 return _IMP_kernel.set_deprecation_exceptions(tf)
1448 """get_deprecation_exceptions() -> bool"""
1449 return _IMP_kernel.get_deprecation_exceptions()
1452 """handle_use_deprecated(std::string message)"""
1453 return _IMP_kernel.handle_use_deprecated(message)
1456 """get_number_of_threads() -> unsigned int"""
1457 return _IMP_kernel.get_number_of_threads()
1460 """set_number_of_threads(unsigned int n)"""
1461 return _IMP_kernel.set_number_of_threads(n)
1462 class SetNumberOfThreads(_RAII):
1463 """Proxy of C++ IMP::SetNumberOfThreads class."""
1465 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
1467 def __init__(self, *args):
1469 __init__(IMP::SetNumberOfThreads self) -> SetNumberOfThreads
1470 __init__(IMP::SetNumberOfThreads self, unsigned int n) -> SetNumberOfThreads
1472 this = _IMP_kernel.new_SetNumberOfThreads(*args)
1474 self.this.append(this)
1475 except __builtin__.Exception:
1479 """set(SetNumberOfThreads self, unsigned int n)"""
1480 return _IMP_kernel.SetNumberOfThreads_set(self, n)
1484 """reset(SetNumberOfThreads self)"""
1485 return _IMP_kernel.SetNumberOfThreads_reset(self)
1487 __swig_destroy__ = _IMP_kernel.delete_SetNumberOfThreads
1488 __del__ =
lambda self:
None
1490 def show(self, *args):
1492 show(SetNumberOfThreads self, _ostream out)
1493 show(SetNumberOfThreads self)
1495 return _IMP_kernel.SetNumberOfThreads_show(self, *args)
1498 def __enter__(self):
1500 def __exit__(self, exc_type, exc_val, exc_tb):
1506 """__str__(SetNumberOfThreads self) -> std::string"""
1507 return _IMP_kernel.SetNumberOfThreads___str__(self)
1511 """__repr__(SetNumberOfThreads self) -> std::string"""
1512 return _IMP_kernel.SetNumberOfThreads___repr__(self)
1514 SetNumberOfThreads_swigregister = _IMP_kernel.SetNumberOfThreads_swigregister
1515 SetNumberOfThreads_swigregister(SetNumberOfThreads)
1519 i_m_p=
"IMP_MODULE_PATH"
1520 if i_m_p
in os.environ.keys():
1521 __path__.insert(0, os.environ[i_m_p])
1523 def _forward_add_attribute(self, name, value, opt=None):
1525 self.get_particle().add_attribute(name, value, opt)
1527 self.get_particle().add_attribute(name, value)
1528 def _forward_get_value(self, name):
1529 self.get_particle().get_value(name)
1530 def _forward_set_value(self, name, value):
1531 self.get_particle().set_value(name, value)
1537 _object_types.append(
"Constraint")
1540 def _object_cast_to_Constraint(o):
1541 """_object_cast_to_Constraint(Object o) -> Constraint"""
1542 return _IMP_kernel._object_cast_to_Constraint(o)
1544 _object_types.append(
"Undecorator")
1547 def _object_cast_to_Undecorator(o):
1548 """_object_cast_to_Undecorator(Object o) -> Undecorator"""
1549 return _IMP_kernel._object_cast_to_Undecorator(o)
1551 _object_types.append(
"Container")
1554 def _object_cast_to_Container(o):
1555 """_object_cast_to_Container(Object o) -> Container"""
1556 return _IMP_kernel._object_cast_to_Container(o)
1558 _object_types.append(
"Optimizer")
1561 def _object_cast_to_Optimizer(o):
1562 """_object_cast_to_Optimizer(Object o) -> Optimizer"""
1563 return _IMP_kernel._object_cast_to_Optimizer(o)
1565 _object_types.append(
"AttributeOptimizer")
1568 def _object_cast_to_AttributeOptimizer(o):
1569 """_object_cast_to_AttributeOptimizer(Object o) -> AttributeOptimizer"""
1570 return _IMP_kernel._object_cast_to_AttributeOptimizer(o)
1572 _object_types.append(
"OptimizerState")
1575 def _object_cast_to_OptimizerState(o):
1576 """_object_cast_to_OptimizerState(Object o) -> OptimizerState"""
1577 return _IMP_kernel._object_cast_to_OptimizerState(o)
1579 _object_types.append(
"PairContainer")
1582 def _object_cast_to_PairContainer(o):
1583 """_object_cast_to_PairContainer(Object o) -> PairContainer"""
1584 return _IMP_kernel._object_cast_to_PairContainer(o)
1586 _object_types.append(
"PairModifier")
1589 def _object_cast_to_PairModifier(o):
1590 """_object_cast_to_PairModifier(Object o) -> PairModifier"""
1591 return _IMP_kernel._object_cast_to_PairModifier(o)
1593 _object_types.append(
"PairScore")
1596 def _object_cast_to_PairScore(o):
1597 """_object_cast_to_PairScore(Object o) -> PairScore"""
1598 return _IMP_kernel._object_cast_to_PairScore(o)
1600 _object_types.append(
"QuadContainer")
1603 def _object_cast_to_QuadContainer(o):
1604 """_object_cast_to_QuadContainer(Object o) -> QuadContainer"""
1605 return _IMP_kernel._object_cast_to_QuadContainer(o)
1607 _object_types.append(
"QuadModifier")
1610 def _object_cast_to_QuadModifier(o):
1611 """_object_cast_to_QuadModifier(Object o) -> QuadModifier"""
1612 return _IMP_kernel._object_cast_to_QuadModifier(o)
1614 _object_types.append(
"QuadScore")
1617 def _object_cast_to_QuadScore(o):
1618 """_object_cast_to_QuadScore(Object o) -> QuadScore"""
1619 return _IMP_kernel._object_cast_to_QuadScore(o)
1621 _object_types.append(
"Refiner")
1624 def _object_cast_to_Refiner(o):
1625 """_object_cast_to_Refiner(Object o) -> Refiner"""
1626 return _IMP_kernel._object_cast_to_Refiner(o)
1628 _object_types.append(
"Restraint")
1631 def _object_cast_to_Restraint(o):
1632 """_object_cast_to_Restraint(Object o) -> Restraint"""
1633 return _IMP_kernel._object_cast_to_Restraint(o)
1635 _object_types.append(
"Sampler")
1638 def _object_cast_to_Sampler(o):
1639 """_object_cast_to_Sampler(Object o) -> Sampler"""
1640 return _IMP_kernel._object_cast_to_Sampler(o)
1642 _object_types.append(
"ScoreState")
1645 def _object_cast_to_ScoreState(o):
1646 """_object_cast_to_ScoreState(Object o) -> ScoreState"""
1647 return _IMP_kernel._object_cast_to_ScoreState(o)
1649 _object_types.append(
"SingletonContainer")
1652 def _object_cast_to_SingletonContainer(o):
1653 """_object_cast_to_SingletonContainer(Object o) -> SingletonContainer"""
1654 return _IMP_kernel._object_cast_to_SingletonContainer(o)
1656 _object_types.append(
"SingletonModifier")
1659 def _object_cast_to_SingletonModifier(o):
1660 """_object_cast_to_SingletonModifier(Object o) -> SingletonModifier"""
1661 return _IMP_kernel._object_cast_to_SingletonModifier(o)
1663 _object_types.append(
"SingletonScore")
1666 def _object_cast_to_SingletonScore(o):
1667 """_object_cast_to_SingletonScore(Object o) -> SingletonScore"""
1668 return _IMP_kernel._object_cast_to_SingletonScore(o)
1670 _object_types.append(
"TripletContainer")
1673 def _object_cast_to_TripletContainer(o):
1674 """_object_cast_to_TripletContainer(Object o) -> TripletContainer"""
1675 return _IMP_kernel._object_cast_to_TripletContainer(o)
1677 _object_types.append(
"TripletModifier")
1680 def _object_cast_to_TripletModifier(o):
1681 """_object_cast_to_TripletModifier(Object o) -> TripletModifier"""
1682 return _IMP_kernel._object_cast_to_TripletModifier(o)
1684 _object_types.append(
"TripletScore")
1687 def _object_cast_to_TripletScore(o):
1688 """_object_cast_to_TripletScore(Object o) -> TripletScore"""
1689 return _IMP_kernel._object_cast_to_TripletScore(o)
1691 _object_types.append(
"UnaryFunction")
1694 def _object_cast_to_UnaryFunction(o):
1695 """_object_cast_to_UnaryFunction(Object o) -> UnaryFunction"""
1696 return _IMP_kernel._object_cast_to_UnaryFunction(o)
1698 _object_types.append(
"ConfigurationSet")
1701 def _object_cast_to_ConfigurationSet(o):
1702 """_object_cast_to_ConfigurationSet(Object o) -> ConfigurationSet"""
1703 return _IMP_kernel._object_cast_to_ConfigurationSet(o)
1705 _object_types.append(
"Configuration")
1708 def _object_cast_to_Configuration(o):
1709 """_object_cast_to_Configuration(Object o) -> Configuration"""
1710 return _IMP_kernel._object_cast_to_Configuration(o)
1712 _object_types.append(
"Model")
1715 def _object_cast_to_Model(o):
1716 """_object_cast_to_Model(Object o) -> Model"""
1717 return _IMP_kernel._object_cast_to_Model(o)
1719 _object_types.append(
"Particle")
1722 def _object_cast_to_Particle(o):
1723 """_object_cast_to_Particle(Object o) -> Particle"""
1724 return _IMP_kernel._object_cast_to_Particle(o)
1726 _object_types.append(
"RestraintSet")
1729 def _object_cast_to_RestraintSet(o):
1730 """_object_cast_to_RestraintSet(Object o) -> RestraintSet"""
1731 return _IMP_kernel._object_cast_to_RestraintSet(o)
1733 ParticlePairsTemp=list
1734 _plural_types.append(
"ParticlePairsTemp")
1735 _value_types.append(
"ParticlePair")
1738 ParticleTripletsTemp=list
1739 _plural_types.append(
"ParticleTripletsTemp")
1740 _value_types.append(
"ParticleTriplet")
1743 ParticleQuadsTemp=list
1744 _plural_types.append(
"ParticleQuadsTemp")
1745 _value_types.append(
"ParticleQuad")
1748 ParticleIndexPairs=list
1749 _plural_types.append(
"ParticleIndexPairs")
1750 _value_types.append(
"ParticleIndexPair")
1753 ParticleIndexTriplets=list
1754 _plural_types.append(
"ParticleIndexTriplets")
1755 _value_types.append(
"ParticleIndexTriplet")
1758 ParticleIndexQuads=list
1759 _plural_types.append(
"ParticleIndexQuads")
1760 _value_types.append(
"ParticleIndexQuad")
1763 _object_types.append(
"SingletonPredicate")
1766 def _object_cast_to_SingletonPredicate(o):
1767 """_object_cast_to_SingletonPredicate(Object o) -> SingletonPredicate"""
1768 return _IMP_kernel._object_cast_to_SingletonPredicate(o)
1770 _object_types.append(
"PairPredicate")
1773 def _object_cast_to_PairPredicate(o):
1774 """_object_cast_to_PairPredicate(Object o) -> PairPredicate"""
1775 return _IMP_kernel._object_cast_to_PairPredicate(o)
1777 _object_types.append(
"TripletPredicate")
1780 def _object_cast_to_TripletPredicate(o):
1781 """_object_cast_to_TripletPredicate(Object o) -> TripletPredicate"""
1782 return _IMP_kernel._object_cast_to_TripletPredicate(o)
1784 _object_types.append(
"QuadPredicate")
1787 def _object_cast_to_QuadPredicate(o):
1788 """_object_cast_to_QuadPredicate(Object o) -> QuadPredicate"""
1789 return _IMP_kernel._object_cast_to_QuadPredicate(o)
1791 _object_types.append(
"SaveToConfigurationSetOptimizerState")
1794 def _object_cast_to_SaveToConfigurationSetOptimizerState(o):
1795 """_object_cast_to_SaveToConfigurationSetOptimizerState(Object o) -> SaveToConfigurationSetOptimizerState"""
1796 return _IMP_kernel._object_cast_to_SaveToConfigurationSetOptimizerState(o)
1798 EvaluationStates=list
1799 _plural_types.append(
"EvaluationStates")
1800 _value_types.append(
"EvaluationState")
1803 ScoreAccumulators=list
1804 _plural_types.append(
"ScoreAccumulators")
1805 _value_types.append(
"ScoreAccumulator")
1808 ParticleIndexes=list
1809 _plural_types.append(
"ParticleIndexes")
1810 _value_types.append(
"ParticleIndex")
1814 _plural_types.append(
"FloatIndexes")
1815 _value_types.append(
"FloatIndex")
1819 _plural_types.append(
"FloatKeys")
1820 _value_types.append(
"FloatKey")
1824 _plural_types.append(
"IntKeys")
1825 _value_types.append(
"IntKey")
1829 _plural_types.append(
"StringKeys")
1830 _value_types.append(
"StringKey")
1833 ParticleIndexKeys=list
1834 _plural_types.append(
"ParticleIndexKeys")
1835 _value_types.append(
"ParticleIndexKey")
1838 ParticleIndexesKeys=list
1839 _plural_types.append(
"ParticleIndexesKeys")
1840 _value_types.append(
"ParticleIndexesKey")
1844 _plural_types.append(
"ObjectKeys")
1845 _value_types.append(
"ObjectKey")
1849 _plural_types.append(
"ModelKeys")
1850 _value_types.append(
"ModelKey")
1853 _raii_types.append(
"ScopedSetFloatAttribute")
1856 _object_types.append(
"ScoringFunction")
1859 def _object_cast_to_ScoringFunction(o):
1860 """_object_cast_to_ScoringFunction(Object o) -> ScoringFunction"""
1861 return _IMP_kernel._object_cast_to_ScoringFunction(o)
1863 _object_types.append(
"ModelObject")
1866 def _object_cast_to_ModelObject(o):
1867 """_object_cast_to_ModelObject(Object o) -> ModelObject"""
1868 return _IMP_kernel._object_cast_to_ModelObject(o)
1870 def _TrivialDecorators(l=[]):
1871 return [_TrivialDecorator(x)
for x
in l]
1872 _plural_types.append(
"_TrivialDecorators")
1875 _value_types.append(
"_TrivialDecorator")
1878 def _TrivialDerivedDecorators(l=[]):
1879 return [_TrivialDerivedDecorator(x)
for x
in l]
1880 _plural_types.append(
"_TrivialDerivedDecorators")
1883 _value_types.append(
"_TrivialDerivedDecorator")
1886 def _TrivialTraitsDecorators(l=[]):
1887 return [_TrivialTraitsDecorator(x)
for x
in l]
1888 _plural_types.append(
"_TrivialTraitsDecorators")
1891 _value_types.append(
"_TrivialTraitsDecorator")
1894 _object_types.append(
"_ConstRestraint")
1897 def _object_cast_to__ConstRestraint(o):
1898 """_object_cast_to__ConstRestraint(Object o) -> _ConstRestraint"""
1899 return _IMP_kernel._object_cast_to__ConstRestraint(o)
1901 _object_types.append(
"_ConstOptimizer")
1904 def _object_cast_to__ConstOptimizer(o):
1905 """_object_cast_to__ConstOptimizer(Object o) -> _ConstOptimizer"""
1906 return _IMP_kernel._object_cast_to__ConstOptimizer(o)
1908 """Proxy of C++ IMP::internal::BoostDigraph<(IMP::DependencyGraph,p.IMP::ModelObject,IMP::ShowDependencyGraphVertex)> class."""
1910 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
1911 __repr__ = _swig_repr
1914 """__init__(IMP::internal::BoostDigraph<(IMP::DependencyGraph,p.IMP::ModelObject,IMP::ShowDependencyGraphVertex)> self) -> DependencyGraph"""
1915 this = _IMP_kernel.new_DependencyGraph()
1917 self.this.append(this)
1918 except __builtin__.Exception:
1921 def get_graph(self):
1922 """get_graph(DependencyGraph self) -> IMP::DependencyGraph const &"""
1923 return _IMP_kernel.DependencyGraph_get_graph(self)
1927 """get_vertices(DependencyGraph self) -> IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptors"""
1928 return _IMP_kernel.DependencyGraph_get_vertices(self)
1931 def get_vertex_name(self, i):
1932 """get_vertex_name(DependencyGraph self, IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptor i) -> ModelObject"""
1933 return _IMP_kernel.DependencyGraph_get_vertex_name(self, i)
1936 def get_in_neighbors(self, v):
1937 """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"""
1938 return _IMP_kernel.DependencyGraph_get_in_neighbors(self, v)
1941 def get_out_neighbors(self, v):
1942 """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"""
1943 return _IMP_kernel.DependencyGraph_get_out_neighbors(self, v)
1948 show_graphviz(DependencyGraph self, _ostream out)
1949 show_graphviz(DependencyGraph self)
1951 return _IMP_kernel.DependencyGraph_show_graphviz(self, *args)
1954 def get_graphviz_string(self):
1955 """get_graphviz_string(DependencyGraph self) -> std::string"""
1956 return _IMP_kernel.DependencyGraph_get_graphviz_string(self)
1959 def add_edge(self, v0, v1):
1960 """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)"""
1961 return _IMP_kernel.DependencyGraph_add_edge(self, v0, v1)
1964 def add_vertex(self, l):
1965 """add_vertex(DependencyGraph self, ModelObject l) -> IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptor"""
1966 return _IMP_kernel.DependencyGraph_add_vertex(self, l)
1969 def remove_vertex(self, l):
1970 """remove_vertex(DependencyGraph self, IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptor l)"""
1971 return _IMP_kernel.DependencyGraph_remove_vertex(self, l)
1973 __swig_destroy__ = _IMP_kernel.delete_DependencyGraph
1974 __del__ =
lambda self:
None
1975 DependencyGraph_swigregister = _IMP_kernel.DependencyGraph_swigregister
1976 DependencyGraph_swigregister(DependencyGraph)
1979 _value_types.append(
"DependencyGraph")
1982 """Proxy of C++ IMP::Key<(0)> class."""
1984 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
1986 def __init__(self, *args):
1988 __init__(IMP::Key<(0)> self) -> FloatKey
1989 __init__(IMP::Key<(0)> self, std::string const & c, bool is_implicit_add_permitted=True) -> FloatKey
1990 __init__(IMP::Key<(0)> self, std::string const & c) -> FloatKey
1991 __init__(IMP::Key<(0)> self, unsigned int i) -> FloatKey
1993 this = _IMP_kernel.new_FloatKey(*args)
1995 self.this.append(this)
1996 except __builtin__.Exception:
2000 """add_key(std::string sc) -> unsigned int"""
2001 return _IMP_kernel.FloatKey_add_key(sc)
2003 add_key = staticmethod(add_key)
2005 def get_key_exists(sc):
2006 """get_key_exists(std::string sc) -> bool"""
2007 return _IMP_kernel.FloatKey_get_key_exists(sc)
2009 get_key_exists = staticmethod(get_key_exists)
2011 def get_string(self):
2012 """get_string(FloatKey self) -> std::string const"""
2013 return _IMP_kernel.FloatKey_get_string(self)
2016 def __cmp__(self, o):
2017 """__cmp__(FloatKey self, FloatKey o) -> int"""
2018 return _IMP_kernel.FloatKey___cmp__(self, o)
2021 def __eq__(self, o):
2022 """__eq__(FloatKey self, FloatKey o) -> bool"""
2023 return _IMP_kernel.FloatKey___eq__(self, o)
2026 def __ne__(self, o):
2027 """__ne__(FloatKey self, FloatKey o) -> bool"""
2028 return _IMP_kernel.FloatKey___ne__(self, o)
2031 def __lt__(self, o):
2032 """__lt__(FloatKey self, FloatKey o) -> bool"""
2033 return _IMP_kernel.FloatKey___lt__(self, o)
2036 def __gt__(self, o):
2037 """__gt__(FloatKey self, FloatKey o) -> bool"""
2038 return _IMP_kernel.FloatKey___gt__(self, o)
2041 def __ge__(self, o):
2042 """__ge__(FloatKey self, FloatKey o) -> bool"""
2043 return _IMP_kernel.FloatKey___ge__(self, o)
2046 def __le__(self, o):
2047 """__le__(FloatKey self, FloatKey o) -> bool"""
2048 return _IMP_kernel.FloatKey___le__(self, o)
2052 """__hash__(FloatKey self) -> std::size_t"""
2053 return _IMP_kernel.FloatKey___hash__(self)
2056 def show(self, *args):
2058 show(FloatKey self, _ostream out)
2061 return _IMP_kernel.FloatKey_show(self, *args)
2064 def add_alias(old_key, new_name):
2065 """add_alias(FloatKey old_key, std::string new_name) -> FloatKey"""
2066 return _IMP_kernel.FloatKey_add_alias(old_key, new_name)
2068 add_alias = staticmethod(add_alias)
2070 def get_number_of_keys():
2071 """get_number_of_keys() -> unsigned int"""
2072 return _IMP_kernel.FloatKey_get_number_of_keys()
2074 get_number_of_keys = staticmethod(get_number_of_keys)
2077 """get_index(FloatKey self) -> unsigned int"""
2078 return _IMP_kernel.FloatKey_get_index(self)
2082 """show_all(_ostream out)"""
2083 return _IMP_kernel.FloatKey_show_all(out)
2085 show_all = staticmethod(show_all)
2087 def get_all_strings():
2088 """get_all_strings() -> IMP::Vector< std::string >"""
2089 return _IMP_kernel.FloatKey_get_all_strings()
2091 get_all_strings = staticmethod(get_all_strings)
2093 def get_number_unique():
2094 """get_number_unique() -> unsigned int"""
2095 return _IMP_kernel.FloatKey_get_number_unique()
2097 get_number_unique = staticmethod(get_number_unique)
2100 """__str__(FloatKey self) -> std::string"""
2101 return _IMP_kernel.FloatKey___str__(self)
2105 """__repr__(FloatKey self) -> std::string"""
2106 return _IMP_kernel.FloatKey___repr__(self)
2108 __swig_destroy__ = _IMP_kernel.delete_FloatKey
2109 __del__ =
lambda self:
None
2110 FloatKey_swigregister = _IMP_kernel.FloatKey_swigregister
2111 FloatKey_swigregister(FloatKey)
2113 def FloatKey_add_key(sc):
2114 """FloatKey_add_key(std::string sc) -> unsigned int"""
2115 return _IMP_kernel.FloatKey_add_key(sc)
2117 def FloatKey_get_key_exists(sc):
2118 """FloatKey_get_key_exists(std::string sc) -> bool"""
2119 return _IMP_kernel.FloatKey_get_key_exists(sc)
2121 def FloatKey_add_alias(old_key, new_name):
2122 """FloatKey_add_alias(FloatKey old_key, std::string new_name) -> FloatKey"""
2123 return _IMP_kernel.FloatKey_add_alias(old_key, new_name)
2125 def FloatKey_get_number_of_keys():
2126 """FloatKey_get_number_of_keys() -> unsigned int"""
2127 return _IMP_kernel.FloatKey_get_number_of_keys()
2129 def FloatKey_show_all(out):
2130 """FloatKey_show_all(_ostream out)"""
2131 return _IMP_kernel.FloatKey_show_all(out)
2133 def FloatKey_get_all_strings():
2134 """FloatKey_get_all_strings() -> IMP::Vector< std::string >"""
2135 return _IMP_kernel.FloatKey_get_all_strings()
2137 def FloatKey_get_number_unique():
2138 """FloatKey_get_number_unique() -> unsigned int"""
2139 return _IMP_kernel.FloatKey_get_number_unique()
2142 """Proxy of C++ IMP::Key<(1)> class."""
2144 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
2146 def __init__(self, *args):
2148 __init__(IMP::Key<(1)> self) -> IntKey
2149 __init__(IMP::Key<(1)> self, std::string const & c, bool is_implicit_add_permitted=True) -> IntKey
2150 __init__(IMP::Key<(1)> self, std::string const & c) -> IntKey
2151 __init__(IMP::Key<(1)> self, unsigned int i) -> IntKey
2153 this = _IMP_kernel.new_IntKey(*args)
2155 self.this.append(this)
2156 except __builtin__.Exception:
2160 """add_key(std::string sc) -> unsigned int"""
2161 return _IMP_kernel.IntKey_add_key(sc)
2163 add_key = staticmethod(add_key)
2165 def get_key_exists(sc):
2166 """get_key_exists(std::string sc) -> bool"""
2167 return _IMP_kernel.IntKey_get_key_exists(sc)
2169 get_key_exists = staticmethod(get_key_exists)
2171 def get_string(self):
2172 """get_string(IntKey self) -> std::string const"""
2173 return _IMP_kernel.IntKey_get_string(self)
2176 def __cmp__(self, o):
2177 """__cmp__(IntKey self, IntKey o) -> int"""
2178 return _IMP_kernel.IntKey___cmp__(self, o)
2181 def __eq__(self, o):
2182 """__eq__(IntKey self, IntKey o) -> bool"""
2183 return _IMP_kernel.IntKey___eq__(self, o)
2186 def __ne__(self, o):
2187 """__ne__(IntKey self, IntKey o) -> bool"""
2188 return _IMP_kernel.IntKey___ne__(self, o)
2191 def __lt__(self, o):
2192 """__lt__(IntKey self, IntKey o) -> bool"""
2193 return _IMP_kernel.IntKey___lt__(self, o)
2196 def __gt__(self, o):
2197 """__gt__(IntKey self, IntKey o) -> bool"""
2198 return _IMP_kernel.IntKey___gt__(self, o)
2201 def __ge__(self, o):
2202 """__ge__(IntKey self, IntKey o) -> bool"""
2203 return _IMP_kernel.IntKey___ge__(self, o)
2206 def __le__(self, o):
2207 """__le__(IntKey self, IntKey o) -> bool"""
2208 return _IMP_kernel.IntKey___le__(self, o)
2212 """__hash__(IntKey self) -> std::size_t"""
2213 return _IMP_kernel.IntKey___hash__(self)
2216 def show(self, *args):
2218 show(IntKey self, _ostream out)
2221 return _IMP_kernel.IntKey_show(self, *args)
2224 def add_alias(old_key, new_name):
2225 """add_alias(IntKey old_key, std::string new_name) -> IntKey"""
2226 return _IMP_kernel.IntKey_add_alias(old_key, new_name)
2228 add_alias = staticmethod(add_alias)
2230 def get_number_of_keys():
2231 """get_number_of_keys() -> unsigned int"""
2232 return _IMP_kernel.IntKey_get_number_of_keys()
2234 get_number_of_keys = staticmethod(get_number_of_keys)
2237 """get_index(IntKey self) -> unsigned int"""
2238 return _IMP_kernel.IntKey_get_index(self)
2242 """show_all(_ostream out)"""
2243 return _IMP_kernel.IntKey_show_all(out)
2245 show_all = staticmethod(show_all)
2247 def get_all_strings():
2248 """get_all_strings() -> IMP::Vector< std::string >"""
2249 return _IMP_kernel.IntKey_get_all_strings()
2251 get_all_strings = staticmethod(get_all_strings)
2253 def get_number_unique():
2254 """get_number_unique() -> unsigned int"""
2255 return _IMP_kernel.IntKey_get_number_unique()
2257 get_number_unique = staticmethod(get_number_unique)
2260 """__str__(IntKey self) -> std::string"""
2261 return _IMP_kernel.IntKey___str__(self)
2265 """__repr__(IntKey self) -> std::string"""
2266 return _IMP_kernel.IntKey___repr__(self)
2268 __swig_destroy__ = _IMP_kernel.delete_IntKey
2269 __del__ =
lambda self:
None
2270 IntKey_swigregister = _IMP_kernel.IntKey_swigregister
2271 IntKey_swigregister(IntKey)
2273 def IntKey_add_key(sc):
2274 """IntKey_add_key(std::string sc) -> unsigned int"""
2275 return _IMP_kernel.IntKey_add_key(sc)
2277 def IntKey_get_key_exists(sc):
2278 """IntKey_get_key_exists(std::string sc) -> bool"""
2279 return _IMP_kernel.IntKey_get_key_exists(sc)
2281 def IntKey_add_alias(old_key, new_name):
2282 """IntKey_add_alias(IntKey old_key, std::string new_name) -> IntKey"""
2283 return _IMP_kernel.IntKey_add_alias(old_key, new_name)
2285 def IntKey_get_number_of_keys():
2286 """IntKey_get_number_of_keys() -> unsigned int"""
2287 return _IMP_kernel.IntKey_get_number_of_keys()
2289 def IntKey_show_all(out):
2290 """IntKey_show_all(_ostream out)"""
2291 return _IMP_kernel.IntKey_show_all(out)
2293 def IntKey_get_all_strings():
2294 """IntKey_get_all_strings() -> IMP::Vector< std::string >"""
2295 return _IMP_kernel.IntKey_get_all_strings()
2297 def IntKey_get_number_unique():
2298 """IntKey_get_number_unique() -> unsigned int"""
2299 return _IMP_kernel.IntKey_get_number_unique()
2302 """Proxy of C++ IMP::Key<(2)> class."""
2304 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
2306 def __init__(self, *args):
2308 __init__(IMP::Key<(2)> self) -> StringKey
2309 __init__(IMP::Key<(2)> self, std::string const & c, bool is_implicit_add_permitted=True) -> StringKey
2310 __init__(IMP::Key<(2)> self, std::string const & c) -> StringKey
2311 __init__(IMP::Key<(2)> self, unsigned int i) -> StringKey
2313 this = _IMP_kernel.new_StringKey(*args)
2315 self.this.append(this)
2316 except __builtin__.Exception:
2320 """add_key(std::string sc) -> unsigned int"""
2321 return _IMP_kernel.StringKey_add_key(sc)
2323 add_key = staticmethod(add_key)
2325 def get_key_exists(sc):
2326 """get_key_exists(std::string sc) -> bool"""
2327 return _IMP_kernel.StringKey_get_key_exists(sc)
2329 get_key_exists = staticmethod(get_key_exists)
2331 def get_string(self):
2332 """get_string(StringKey self) -> std::string const"""
2333 return _IMP_kernel.StringKey_get_string(self)
2336 def __cmp__(self, o):
2337 """__cmp__(StringKey self, StringKey o) -> int"""
2338 return _IMP_kernel.StringKey___cmp__(self, o)
2341 def __eq__(self, o):
2342 """__eq__(StringKey self, StringKey o) -> bool"""
2343 return _IMP_kernel.StringKey___eq__(self, o)
2346 def __ne__(self, o):
2347 """__ne__(StringKey self, StringKey o) -> bool"""
2348 return _IMP_kernel.StringKey___ne__(self, o)
2351 def __lt__(self, o):
2352 """__lt__(StringKey self, StringKey o) -> bool"""
2353 return _IMP_kernel.StringKey___lt__(self, o)
2356 def __gt__(self, o):
2357 """__gt__(StringKey self, StringKey o) -> bool"""
2358 return _IMP_kernel.StringKey___gt__(self, o)
2361 def __ge__(self, o):
2362 """__ge__(StringKey self, StringKey o) -> bool"""
2363 return _IMP_kernel.StringKey___ge__(self, o)
2366 def __le__(self, o):
2367 """__le__(StringKey self, StringKey o) -> bool"""
2368 return _IMP_kernel.StringKey___le__(self, o)
2372 """__hash__(StringKey self) -> std::size_t"""
2373 return _IMP_kernel.StringKey___hash__(self)
2376 def show(self, *args):
2378 show(StringKey self, _ostream out)
2379 show(StringKey self)
2381 return _IMP_kernel.StringKey_show(self, *args)
2384 def add_alias(old_key, new_name):
2385 """add_alias(StringKey old_key, std::string new_name) -> StringKey"""
2386 return _IMP_kernel.StringKey_add_alias(old_key, new_name)
2388 add_alias = staticmethod(add_alias)
2390 def get_number_of_keys():
2391 """get_number_of_keys() -> unsigned int"""
2392 return _IMP_kernel.StringKey_get_number_of_keys()
2394 get_number_of_keys = staticmethod(get_number_of_keys)
2397 """get_index(StringKey self) -> unsigned int"""
2398 return _IMP_kernel.StringKey_get_index(self)
2402 """show_all(_ostream out)"""
2403 return _IMP_kernel.StringKey_show_all(out)
2405 show_all = staticmethod(show_all)
2407 def get_all_strings():
2408 """get_all_strings() -> IMP::Vector< std::string >"""
2409 return _IMP_kernel.StringKey_get_all_strings()
2411 get_all_strings = staticmethod(get_all_strings)
2413 def get_number_unique():
2414 """get_number_unique() -> unsigned int"""
2415 return _IMP_kernel.StringKey_get_number_unique()
2417 get_number_unique = staticmethod(get_number_unique)
2420 """__str__(StringKey self) -> std::string"""
2421 return _IMP_kernel.StringKey___str__(self)
2425 """__repr__(StringKey self) -> std::string"""
2426 return _IMP_kernel.StringKey___repr__(self)
2428 __swig_destroy__ = _IMP_kernel.delete_StringKey
2429 __del__ =
lambda self:
None
2430 StringKey_swigregister = _IMP_kernel.StringKey_swigregister
2431 StringKey_swigregister(StringKey)
2433 def StringKey_add_key(sc):
2434 """StringKey_add_key(std::string sc) -> unsigned int"""
2435 return _IMP_kernel.StringKey_add_key(sc)
2437 def StringKey_get_key_exists(sc):
2438 """StringKey_get_key_exists(std::string sc) -> bool"""
2439 return _IMP_kernel.StringKey_get_key_exists(sc)
2441 def StringKey_add_alias(old_key, new_name):
2442 """StringKey_add_alias(StringKey old_key, std::string new_name) -> StringKey"""
2443 return _IMP_kernel.StringKey_add_alias(old_key, new_name)
2445 def StringKey_get_number_of_keys():
2446 """StringKey_get_number_of_keys() -> unsigned int"""
2447 return _IMP_kernel.StringKey_get_number_of_keys()
2449 def StringKey_show_all(out):
2450 """StringKey_show_all(_ostream out)"""
2451 return _IMP_kernel.StringKey_show_all(out)
2453 def StringKey_get_all_strings():
2454 """StringKey_get_all_strings() -> IMP::Vector< std::string >"""
2455 return _IMP_kernel.StringKey_get_all_strings()
2457 def StringKey_get_number_unique():
2458 """StringKey_get_number_unique() -> unsigned int"""
2459 return _IMP_kernel.StringKey_get_number_unique()
2462 """Proxy of C++ IMP::Key<(3)> class."""
2464 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
2466 def __init__(self, *args):
2468 __init__(IMP::Key<(3)> self) -> ParticleIndexKey
2469 __init__(IMP::Key<(3)> self, std::string const & c, bool is_implicit_add_permitted=True) -> ParticleIndexKey
2470 __init__(IMP::Key<(3)> self, std::string const & c) -> ParticleIndexKey
2471 __init__(IMP::Key<(3)> self, unsigned int i) -> ParticleIndexKey
2473 this = _IMP_kernel.new_ParticleIndexKey(*args)
2475 self.this.append(this)
2476 except __builtin__.Exception:
2480 """add_key(std::string sc) -> unsigned int"""
2481 return _IMP_kernel.ParticleIndexKey_add_key(sc)
2483 add_key = staticmethod(add_key)
2485 def get_key_exists(sc):
2486 """get_key_exists(std::string sc) -> bool"""
2487 return _IMP_kernel.ParticleIndexKey_get_key_exists(sc)
2489 get_key_exists = staticmethod(get_key_exists)
2491 def get_string(self):
2492 """get_string(ParticleIndexKey self) -> std::string const"""
2493 return _IMP_kernel.ParticleIndexKey_get_string(self)
2496 def __cmp__(self, o):
2497 """__cmp__(ParticleIndexKey self, ParticleIndexKey o) -> int"""
2498 return _IMP_kernel.ParticleIndexKey___cmp__(self, o)
2501 def __eq__(self, o):
2502 """__eq__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2503 return _IMP_kernel.ParticleIndexKey___eq__(self, o)
2506 def __ne__(self, o):
2507 """__ne__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2508 return _IMP_kernel.ParticleIndexKey___ne__(self, o)
2511 def __lt__(self, o):
2512 """__lt__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2513 return _IMP_kernel.ParticleIndexKey___lt__(self, o)
2516 def __gt__(self, o):
2517 """__gt__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2518 return _IMP_kernel.ParticleIndexKey___gt__(self, o)
2521 def __ge__(self, o):
2522 """__ge__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2523 return _IMP_kernel.ParticleIndexKey___ge__(self, o)
2526 def __le__(self, o):
2527 """__le__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2528 return _IMP_kernel.ParticleIndexKey___le__(self, o)
2532 """__hash__(ParticleIndexKey self) -> std::size_t"""
2533 return _IMP_kernel.ParticleIndexKey___hash__(self)
2536 def show(self, *args):
2538 show(ParticleIndexKey self, _ostream out)
2539 show(ParticleIndexKey self)
2541 return _IMP_kernel.ParticleIndexKey_show(self, *args)
2544 def add_alias(old_key, new_name):
2545 """add_alias(ParticleIndexKey old_key, std::string new_name) -> ParticleIndexKey"""
2546 return _IMP_kernel.ParticleIndexKey_add_alias(old_key, new_name)
2548 add_alias = staticmethod(add_alias)
2550 def get_number_of_keys():
2551 """get_number_of_keys() -> unsigned int"""
2552 return _IMP_kernel.ParticleIndexKey_get_number_of_keys()
2554 get_number_of_keys = staticmethod(get_number_of_keys)
2557 """get_index(ParticleIndexKey self) -> unsigned int"""
2558 return _IMP_kernel.ParticleIndexKey_get_index(self)
2562 """show_all(_ostream out)"""
2563 return _IMP_kernel.ParticleIndexKey_show_all(out)
2565 show_all = staticmethod(show_all)
2567 def get_all_strings():
2568 """get_all_strings() -> IMP::Vector< std::string >"""
2569 return _IMP_kernel.ParticleIndexKey_get_all_strings()
2571 get_all_strings = staticmethod(get_all_strings)
2573 def get_number_unique():
2574 """get_number_unique() -> unsigned int"""
2575 return _IMP_kernel.ParticleIndexKey_get_number_unique()
2577 get_number_unique = staticmethod(get_number_unique)
2580 """__str__(ParticleIndexKey self) -> std::string"""
2581 return _IMP_kernel.ParticleIndexKey___str__(self)
2585 """__repr__(ParticleIndexKey self) -> std::string"""
2586 return _IMP_kernel.ParticleIndexKey___repr__(self)
2588 __swig_destroy__ = _IMP_kernel.delete_ParticleIndexKey
2589 __del__ =
lambda self:
None
2590 ParticleIndexKey_swigregister = _IMP_kernel.ParticleIndexKey_swigregister
2591 ParticleIndexKey_swigregister(ParticleIndexKey)
2593 def ParticleIndexKey_add_key(sc):
2594 """ParticleIndexKey_add_key(std::string sc) -> unsigned int"""
2595 return _IMP_kernel.ParticleIndexKey_add_key(sc)
2597 def ParticleIndexKey_get_key_exists(sc):
2598 """ParticleIndexKey_get_key_exists(std::string sc) -> bool"""
2599 return _IMP_kernel.ParticleIndexKey_get_key_exists(sc)
2601 def ParticleIndexKey_add_alias(old_key, new_name):
2602 """ParticleIndexKey_add_alias(ParticleIndexKey old_key, std::string new_name) -> ParticleIndexKey"""
2603 return _IMP_kernel.ParticleIndexKey_add_alias(old_key, new_name)
2605 def ParticleIndexKey_get_number_of_keys():
2606 """ParticleIndexKey_get_number_of_keys() -> unsigned int"""
2607 return _IMP_kernel.ParticleIndexKey_get_number_of_keys()
2609 def ParticleIndexKey_show_all(out):
2610 """ParticleIndexKey_show_all(_ostream out)"""
2611 return _IMP_kernel.ParticleIndexKey_show_all(out)
2613 def ParticleIndexKey_get_all_strings():
2614 """ParticleIndexKey_get_all_strings() -> IMP::Vector< std::string >"""
2615 return _IMP_kernel.ParticleIndexKey_get_all_strings()
2617 def ParticleIndexKey_get_number_unique():
2618 """ParticleIndexKey_get_number_unique() -> unsigned int"""
2619 return _IMP_kernel.ParticleIndexKey_get_number_unique()
2622 """Proxy of C++ IMP::Key<(4)> class."""
2624 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
2626 def __init__(self, *args):
2628 __init__(IMP::Key<(4)> self) -> ObjectKey
2629 __init__(IMP::Key<(4)> self, std::string const & c, bool is_implicit_add_permitted=True) -> ObjectKey
2630 __init__(IMP::Key<(4)> self, std::string const & c) -> ObjectKey
2631 __init__(IMP::Key<(4)> self, unsigned int i) -> ObjectKey
2633 this = _IMP_kernel.new_ObjectKey(*args)
2635 self.this.append(this)
2636 except __builtin__.Exception:
2640 """add_key(std::string sc) -> unsigned int"""
2641 return _IMP_kernel.ObjectKey_add_key(sc)
2643 add_key = staticmethod(add_key)
2645 def get_key_exists(sc):
2646 """get_key_exists(std::string sc) -> bool"""
2647 return _IMP_kernel.ObjectKey_get_key_exists(sc)
2649 get_key_exists = staticmethod(get_key_exists)
2651 def get_string(self):
2652 """get_string(ObjectKey self) -> std::string const"""
2653 return _IMP_kernel.ObjectKey_get_string(self)
2656 def __cmp__(self, o):
2657 """__cmp__(ObjectKey self, ObjectKey o) -> int"""
2658 return _IMP_kernel.ObjectKey___cmp__(self, o)
2661 def __eq__(self, o):
2662 """__eq__(ObjectKey self, ObjectKey o) -> bool"""
2663 return _IMP_kernel.ObjectKey___eq__(self, o)
2666 def __ne__(self, o):
2667 """__ne__(ObjectKey self, ObjectKey o) -> bool"""
2668 return _IMP_kernel.ObjectKey___ne__(self, o)
2671 def __lt__(self, o):
2672 """__lt__(ObjectKey self, ObjectKey o) -> bool"""
2673 return _IMP_kernel.ObjectKey___lt__(self, o)
2676 def __gt__(self, o):
2677 """__gt__(ObjectKey self, ObjectKey o) -> bool"""
2678 return _IMP_kernel.ObjectKey___gt__(self, o)
2681 def __ge__(self, o):
2682 """__ge__(ObjectKey self, ObjectKey o) -> bool"""
2683 return _IMP_kernel.ObjectKey___ge__(self, o)
2686 def __le__(self, o):
2687 """__le__(ObjectKey self, ObjectKey o) -> bool"""
2688 return _IMP_kernel.ObjectKey___le__(self, o)
2692 """__hash__(ObjectKey self) -> std::size_t"""
2693 return _IMP_kernel.ObjectKey___hash__(self)
2696 def show(self, *args):
2698 show(ObjectKey self, _ostream out)
2699 show(ObjectKey self)
2701 return _IMP_kernel.ObjectKey_show(self, *args)
2704 def add_alias(old_key, new_name):
2705 """add_alias(ObjectKey old_key, std::string new_name) -> ObjectKey"""
2706 return _IMP_kernel.ObjectKey_add_alias(old_key, new_name)
2708 add_alias = staticmethod(add_alias)
2710 def get_number_of_keys():
2711 """get_number_of_keys() -> unsigned int"""
2712 return _IMP_kernel.ObjectKey_get_number_of_keys()
2714 get_number_of_keys = staticmethod(get_number_of_keys)
2717 """get_index(ObjectKey self) -> unsigned int"""
2718 return _IMP_kernel.ObjectKey_get_index(self)
2722 """show_all(_ostream out)"""
2723 return _IMP_kernel.ObjectKey_show_all(out)
2725 show_all = staticmethod(show_all)
2727 def get_all_strings():
2728 """get_all_strings() -> IMP::Vector< std::string >"""
2729 return _IMP_kernel.ObjectKey_get_all_strings()
2731 get_all_strings = staticmethod(get_all_strings)
2733 def get_number_unique():
2734 """get_number_unique() -> unsigned int"""
2735 return _IMP_kernel.ObjectKey_get_number_unique()
2737 get_number_unique = staticmethod(get_number_unique)
2740 """__str__(ObjectKey self) -> std::string"""
2741 return _IMP_kernel.ObjectKey___str__(self)
2745 """__repr__(ObjectKey self) -> std::string"""
2746 return _IMP_kernel.ObjectKey___repr__(self)
2748 __swig_destroy__ = _IMP_kernel.delete_ObjectKey
2749 __del__ =
lambda self:
None
2750 ObjectKey_swigregister = _IMP_kernel.ObjectKey_swigregister
2751 ObjectKey_swigregister(ObjectKey)
2753 def ObjectKey_add_key(sc):
2754 """ObjectKey_add_key(std::string sc) -> unsigned int"""
2755 return _IMP_kernel.ObjectKey_add_key(sc)
2757 def ObjectKey_get_key_exists(sc):
2758 """ObjectKey_get_key_exists(std::string sc) -> bool"""
2759 return _IMP_kernel.ObjectKey_get_key_exists(sc)
2761 def ObjectKey_add_alias(old_key, new_name):
2762 """ObjectKey_add_alias(ObjectKey old_key, std::string new_name) -> ObjectKey"""
2763 return _IMP_kernel.ObjectKey_add_alias(old_key, new_name)
2765 def ObjectKey_get_number_of_keys():
2766 """ObjectKey_get_number_of_keys() -> unsigned int"""
2767 return _IMP_kernel.ObjectKey_get_number_of_keys()
2769 def ObjectKey_show_all(out):
2770 """ObjectKey_show_all(_ostream out)"""
2771 return _IMP_kernel.ObjectKey_show_all(out)
2773 def ObjectKey_get_all_strings():
2774 """ObjectKey_get_all_strings() -> IMP::Vector< std::string >"""
2775 return _IMP_kernel.ObjectKey_get_all_strings()
2777 def ObjectKey_get_number_unique():
2778 """ObjectKey_get_number_unique() -> unsigned int"""
2779 return _IMP_kernel.ObjectKey_get_number_unique()
2782 """Proxy of C++ IMP::Key<(6)> class."""
2784 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
2786 def __init__(self, *args):
2788 __init__(IMP::Key<(6)> self) -> ParticleIndexesKey
2789 __init__(IMP::Key<(6)> self, std::string const & c, bool is_implicit_add_permitted=True) -> ParticleIndexesKey
2790 __init__(IMP::Key<(6)> self, std::string const & c) -> ParticleIndexesKey
2791 __init__(IMP::Key<(6)> self, unsigned int i) -> ParticleIndexesKey
2793 this = _IMP_kernel.new_ParticleIndexesKey(*args)
2795 self.this.append(this)
2796 except __builtin__.Exception:
2800 """add_key(std::string sc) -> unsigned int"""
2801 return _IMP_kernel.ParticleIndexesKey_add_key(sc)
2803 add_key = staticmethod(add_key)
2805 def get_key_exists(sc):
2806 """get_key_exists(std::string sc) -> bool"""
2807 return _IMP_kernel.ParticleIndexesKey_get_key_exists(sc)
2809 get_key_exists = staticmethod(get_key_exists)
2811 def get_string(self):
2812 """get_string(ParticleIndexesKey self) -> std::string const"""
2813 return _IMP_kernel.ParticleIndexesKey_get_string(self)
2816 def __cmp__(self, o):
2817 """__cmp__(ParticleIndexesKey self, ParticleIndexesKey o) -> int"""
2818 return _IMP_kernel.ParticleIndexesKey___cmp__(self, o)
2821 def __eq__(self, o):
2822 """__eq__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
2823 return _IMP_kernel.ParticleIndexesKey___eq__(self, o)
2826 def __ne__(self, o):
2827 """__ne__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
2828 return _IMP_kernel.ParticleIndexesKey___ne__(self, o)
2831 def __lt__(self, o):
2832 """__lt__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
2833 return _IMP_kernel.ParticleIndexesKey___lt__(self, o)
2836 def __gt__(self, o):
2837 """__gt__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
2838 return _IMP_kernel.ParticleIndexesKey___gt__(self, o)
2841 def __ge__(self, o):
2842 """__ge__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
2843 return _IMP_kernel.ParticleIndexesKey___ge__(self, o)
2846 def __le__(self, o):
2847 """__le__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
2848 return _IMP_kernel.ParticleIndexesKey___le__(self, o)
2852 """__hash__(ParticleIndexesKey self) -> std::size_t"""
2853 return _IMP_kernel.ParticleIndexesKey___hash__(self)
2856 def show(self, *args):
2858 show(ParticleIndexesKey self, _ostream out)
2859 show(ParticleIndexesKey self)
2861 return _IMP_kernel.ParticleIndexesKey_show(self, *args)
2864 def add_alias(old_key, new_name):
2865 """add_alias(ParticleIndexesKey old_key, std::string new_name) -> ParticleIndexesKey"""
2866 return _IMP_kernel.ParticleIndexesKey_add_alias(old_key, new_name)
2868 add_alias = staticmethod(add_alias)
2870 def get_number_of_keys():
2871 """get_number_of_keys() -> unsigned int"""
2872 return _IMP_kernel.ParticleIndexesKey_get_number_of_keys()
2874 get_number_of_keys = staticmethod(get_number_of_keys)
2877 """get_index(ParticleIndexesKey self) -> unsigned int"""
2878 return _IMP_kernel.ParticleIndexesKey_get_index(self)
2882 """show_all(_ostream out)"""
2883 return _IMP_kernel.ParticleIndexesKey_show_all(out)
2885 show_all = staticmethod(show_all)
2887 def get_all_strings():
2888 """get_all_strings() -> IMP::Vector< std::string >"""
2889 return _IMP_kernel.ParticleIndexesKey_get_all_strings()
2891 get_all_strings = staticmethod(get_all_strings)
2893 def get_number_unique():
2894 """get_number_unique() -> unsigned int"""
2895 return _IMP_kernel.ParticleIndexesKey_get_number_unique()
2897 get_number_unique = staticmethod(get_number_unique)
2900 """__str__(ParticleIndexesKey self) -> std::string"""
2901 return _IMP_kernel.ParticleIndexesKey___str__(self)
2905 """__repr__(ParticleIndexesKey self) -> std::string"""
2906 return _IMP_kernel.ParticleIndexesKey___repr__(self)
2908 __swig_destroy__ = _IMP_kernel.delete_ParticleIndexesKey
2909 __del__ =
lambda self:
None
2910 ParticleIndexesKey_swigregister = _IMP_kernel.ParticleIndexesKey_swigregister
2911 ParticleIndexesKey_swigregister(ParticleIndexesKey)
2913 def ParticleIndexesKey_add_key(sc):
2914 """ParticleIndexesKey_add_key(std::string sc) -> unsigned int"""
2915 return _IMP_kernel.ParticleIndexesKey_add_key(sc)
2917 def ParticleIndexesKey_get_key_exists(sc):
2918 """ParticleIndexesKey_get_key_exists(std::string sc) -> bool"""
2919 return _IMP_kernel.ParticleIndexesKey_get_key_exists(sc)
2921 def ParticleIndexesKey_add_alias(old_key, new_name):
2922 """ParticleIndexesKey_add_alias(ParticleIndexesKey old_key, std::string new_name) -> ParticleIndexesKey"""
2923 return _IMP_kernel.ParticleIndexesKey_add_alias(old_key, new_name)
2925 def ParticleIndexesKey_get_number_of_keys():
2926 """ParticleIndexesKey_get_number_of_keys() -> unsigned int"""
2927 return _IMP_kernel.ParticleIndexesKey_get_number_of_keys()
2929 def ParticleIndexesKey_show_all(out):
2930 """ParticleIndexesKey_show_all(_ostream out)"""
2931 return _IMP_kernel.ParticleIndexesKey_show_all(out)
2933 def ParticleIndexesKey_get_all_strings():
2934 """ParticleIndexesKey_get_all_strings() -> IMP::Vector< std::string >"""
2935 return _IMP_kernel.ParticleIndexesKey_get_all_strings()
2937 def ParticleIndexesKey_get_number_unique():
2938 """ParticleIndexesKey_get_number_unique() -> unsigned int"""
2939 return _IMP_kernel.ParticleIndexesKey_get_number_unique()
2942 """Proxy of C++ IMP::Key<(8)> class."""
2944 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
2946 def __init__(self, *args):
2948 __init__(IMP::Key<(8)> self) -> ModelKey
2949 __init__(IMP::Key<(8)> self, std::string const & c, bool is_implicit_add_permitted=True) -> ModelKey
2950 __init__(IMP::Key<(8)> self, std::string const & c) -> ModelKey
2951 __init__(IMP::Key<(8)> self, unsigned int i) -> ModelKey
2953 this = _IMP_kernel.new_ModelKey(*args)
2955 self.this.append(this)
2956 except __builtin__.Exception:
2960 """add_key(std::string sc) -> unsigned int"""
2961 return _IMP_kernel.ModelKey_add_key(sc)
2963 add_key = staticmethod(add_key)
2965 def get_key_exists(sc):
2966 """get_key_exists(std::string sc) -> bool"""
2967 return _IMP_kernel.ModelKey_get_key_exists(sc)
2969 get_key_exists = staticmethod(get_key_exists)
2971 def get_string(self):
2972 """get_string(ModelKey self) -> std::string const"""
2973 return _IMP_kernel.ModelKey_get_string(self)
2976 def __cmp__(self, o):
2977 """__cmp__(ModelKey self, ModelKey o) -> int"""
2978 return _IMP_kernel.ModelKey___cmp__(self, o)
2981 def __eq__(self, o):
2982 """__eq__(ModelKey self, ModelKey o) -> bool"""
2983 return _IMP_kernel.ModelKey___eq__(self, o)
2986 def __ne__(self, o):
2987 """__ne__(ModelKey self, ModelKey o) -> bool"""
2988 return _IMP_kernel.ModelKey___ne__(self, o)
2991 def __lt__(self, o):
2992 """__lt__(ModelKey self, ModelKey o) -> bool"""
2993 return _IMP_kernel.ModelKey___lt__(self, o)
2996 def __gt__(self, o):
2997 """__gt__(ModelKey self, ModelKey o) -> bool"""
2998 return _IMP_kernel.ModelKey___gt__(self, o)
3001 def __ge__(self, o):
3002 """__ge__(ModelKey self, ModelKey o) -> bool"""
3003 return _IMP_kernel.ModelKey___ge__(self, o)
3006 def __le__(self, o):
3007 """__le__(ModelKey self, ModelKey o) -> bool"""
3008 return _IMP_kernel.ModelKey___le__(self, o)
3012 """__hash__(ModelKey self) -> std::size_t"""
3013 return _IMP_kernel.ModelKey___hash__(self)
3016 def show(self, *args):
3018 show(ModelKey self, _ostream out)
3021 return _IMP_kernel.ModelKey_show(self, *args)
3024 def add_alias(old_key, new_name):
3025 """add_alias(ModelKey old_key, std::string new_name) -> ModelKey"""
3026 return _IMP_kernel.ModelKey_add_alias(old_key, new_name)
3028 add_alias = staticmethod(add_alias)
3030 def get_number_of_keys():
3031 """get_number_of_keys() -> unsigned int"""
3032 return _IMP_kernel.ModelKey_get_number_of_keys()
3034 get_number_of_keys = staticmethod(get_number_of_keys)
3037 """get_index(ModelKey self) -> unsigned int"""
3038 return _IMP_kernel.ModelKey_get_index(self)
3042 """show_all(_ostream out)"""
3043 return _IMP_kernel.ModelKey_show_all(out)
3045 show_all = staticmethod(show_all)
3047 def get_all_strings():
3048 """get_all_strings() -> IMP::Vector< std::string >"""
3049 return _IMP_kernel.ModelKey_get_all_strings()
3051 get_all_strings = staticmethod(get_all_strings)
3053 def get_number_unique():
3054 """get_number_unique() -> unsigned int"""
3055 return _IMP_kernel.ModelKey_get_number_unique()
3057 get_number_unique = staticmethod(get_number_unique)
3060 """__str__(ModelKey self) -> std::string"""
3061 return _IMP_kernel.ModelKey___str__(self)
3065 """__repr__(ModelKey self) -> std::string"""
3066 return _IMP_kernel.ModelKey___repr__(self)
3068 __swig_destroy__ = _IMP_kernel.delete_ModelKey
3069 __del__ =
lambda self:
None
3070 ModelKey_swigregister = _IMP_kernel.ModelKey_swigregister
3071 ModelKey_swigregister(ModelKey)
3073 def ModelKey_add_key(sc):
3074 """ModelKey_add_key(std::string sc) -> unsigned int"""
3075 return _IMP_kernel.ModelKey_add_key(sc)
3077 def ModelKey_get_key_exists(sc):
3078 """ModelKey_get_key_exists(std::string sc) -> bool"""
3079 return _IMP_kernel.ModelKey_get_key_exists(sc)
3081 def ModelKey_add_alias(old_key, new_name):
3082 """ModelKey_add_alias(ModelKey old_key, std::string new_name) -> ModelKey"""
3083 return _IMP_kernel.ModelKey_add_alias(old_key, new_name)
3085 def ModelKey_get_number_of_keys():
3086 """ModelKey_get_number_of_keys() -> unsigned int"""
3087 return _IMP_kernel.ModelKey_get_number_of_keys()
3089 def ModelKey_show_all(out):
3090 """ModelKey_show_all(_ostream out)"""
3091 return _IMP_kernel.ModelKey_show_all(out)
3093 def ModelKey_get_all_strings():
3094 """ModelKey_get_all_strings() -> IMP::Vector< std::string >"""
3095 return _IMP_kernel.ModelKey_get_all_strings()
3097 def ModelKey_get_number_unique():
3098 """ModelKey_get_number_unique() -> unsigned int"""
3099 return _IMP_kernel.ModelKey_get_number_unique()
3102 """Proxy of C++ IMP::Index<(IMP::ParticleIndexTag)> class."""
3104 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3106 def __init__(self, *args):
3108 __init__(IMP::Index<(IMP::ParticleIndexTag)> self, int i) -> ParticleIndex
3109 __init__(IMP::Index<(IMP::ParticleIndexTag)> self) -> ParticleIndex
3111 this = _IMP_kernel.new_ParticleIndex(*args)
3113 self.this.append(this)
3114 except __builtin__.Exception:
3118 """get_index(ParticleIndex self) -> int"""
3119 return _IMP_kernel.ParticleIndex_get_index(self)
3122 def __cmp__(self, o):
3123 """__cmp__(ParticleIndex self, ParticleIndex o) -> int"""
3124 return _IMP_kernel.ParticleIndex___cmp__(self, o)
3127 def __eq__(self, o):
3128 """__eq__(ParticleIndex self, ParticleIndex o) -> bool"""
3129 return _IMP_kernel.ParticleIndex___eq__(self, o)
3132 def __ne__(self, o):
3133 """__ne__(ParticleIndex self, ParticleIndex o) -> bool"""
3134 return _IMP_kernel.ParticleIndex___ne__(self, o)
3137 def __lt__(self, o):
3138 """__lt__(ParticleIndex self, ParticleIndex o) -> bool"""
3139 return _IMP_kernel.ParticleIndex___lt__(self, o)
3142 def __gt__(self, o):
3143 """__gt__(ParticleIndex self, ParticleIndex o) -> bool"""
3144 return _IMP_kernel.ParticleIndex___gt__(self, o)
3147 def __ge__(self, o):
3148 """__ge__(ParticleIndex self, ParticleIndex o) -> bool"""
3149 return _IMP_kernel.ParticleIndex___ge__(self, o)
3152 def __le__(self, o):
3153 """__le__(ParticleIndex self, ParticleIndex o) -> bool"""
3154 return _IMP_kernel.ParticleIndex___le__(self, o)
3157 def show(self, *args):
3159 show(ParticleIndex self, _ostream out)
3160 show(ParticleIndex self)
3162 return _IMP_kernel.ParticleIndex_show(self, *args)
3166 """__hash__(ParticleIndex self) -> std::size_t"""
3167 return _IMP_kernel.ParticleIndex___hash__(self)
3171 """__str__(ParticleIndex self) -> std::string"""
3172 return _IMP_kernel.ParticleIndex___str__(self)
3176 """__repr__(ParticleIndex self) -> std::string"""
3177 return _IMP_kernel.ParticleIndex___repr__(self)
3179 __swig_destroy__ = _IMP_kernel.delete_ParticleIndex
3180 __del__ =
lambda self:
None
3181 ParticleIndex_swigregister = _IMP_kernel.ParticleIndex_swigregister
3182 ParticleIndex_swigregister(ParticleIndex)
3192 class FloatIndex(_Value):
3193 """Proxy of C++ IMP::FloatIndex class."""
3195 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3197 def __init__(self, *args):
3199 __init__(IMP::FloatIndex self, ParticleIndex i0, FloatKey i1) -> FloatIndex
3200 __init__(IMP::FloatIndex self, ParticleIndex i0) -> FloatIndex
3201 __init__(IMP::FloatIndex self) -> FloatIndex
3203 this = _IMP_kernel.new_FloatIndex(*args)
3205 self.this.append(this)
3206 except __builtin__.Exception:
3210 """__hash__(FloatIndex self) -> std::size_t"""
3211 return _IMP_kernel.FloatIndex___hash__(self)
3214 def show(self, *args):
3216 show(FloatIndex self, _ostream out)
3217 show(FloatIndex self)
3219 return _IMP_kernel.FloatIndex_show(self, *args)
3222 def __cmp__(self, o):
3223 """__cmp__(FloatIndex self, FloatIndex o) -> int"""
3224 return _IMP_kernel.FloatIndex___cmp__(self, o)
3227 def __eq__(self, o):
3228 """__eq__(FloatIndex self, FloatIndex o) -> bool"""
3229 return _IMP_kernel.FloatIndex___eq__(self, o)
3232 def __ne__(self, o):
3233 """__ne__(FloatIndex self, FloatIndex o) -> bool"""
3234 return _IMP_kernel.FloatIndex___ne__(self, o)
3237 def __lt__(self, o):
3238 """__lt__(FloatIndex self, FloatIndex o) -> bool"""
3239 return _IMP_kernel.FloatIndex___lt__(self, o)
3242 def __gt__(self, o):
3243 """__gt__(FloatIndex self, FloatIndex o) -> bool"""
3244 return _IMP_kernel.FloatIndex___gt__(self, o)
3247 def __ge__(self, o):
3248 """__ge__(FloatIndex self, FloatIndex o) -> bool"""
3249 return _IMP_kernel.FloatIndex___ge__(self, o)
3252 def __le__(self, o):
3253 """__le__(FloatIndex self, FloatIndex o) -> bool"""
3254 return _IMP_kernel.FloatIndex___le__(self, o)
3257 def get_particle(self):
3258 """get_particle(FloatIndex self) -> ParticleIndex const &"""
3259 return _IMP_kernel.FloatIndex_get_particle(self)
3262 def set_particle(self, v):
3263 """set_particle(FloatIndex self, ParticleIndex const & v)"""
3264 return _IMP_kernel.FloatIndex_set_particle(self, v)
3268 """get_key(FloatIndex self) -> FloatKey const &"""
3269 return _IMP_kernel.FloatIndex_get_key(self)
3272 def set_key(self, v):
3273 """set_key(FloatIndex self, FloatKey const & v)"""
3274 return _IMP_kernel.FloatIndex_set_key(self, v)
3278 """__str__(FloatIndex self) -> std::string"""
3279 return _IMP_kernel.FloatIndex___str__(self)
3283 """__repr__(FloatIndex self) -> std::string"""
3284 return _IMP_kernel.FloatIndex___repr__(self)
3286 __swig_destroy__ = _IMP_kernel.delete_FloatIndex
3287 __del__ =
lambda self:
None
3288 FloatIndex_swigregister = _IMP_kernel.FloatIndex_swigregister
3289 FloatIndex_swigregister(FloatIndex)
3291 class _ParticleIndexTag(object):
3292 """Proxy of C++ IMP::ParticleIndexTag class."""
3294 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3295 __repr__ = _swig_repr
3298 """__init__(IMP::ParticleIndexTag self) -> _ParticleIndexTag"""
3299 this = _IMP_kernel.new__ParticleIndexTag()
3301 self.this.append(this)
3302 except __builtin__.Exception:
3304 __swig_destroy__ = _IMP_kernel.delete__ParticleIndexTag
3305 __del__ =
lambda self:
None
3306 _ParticleIndexTag_swigregister = _IMP_kernel._ParticleIndexTag_swigregister
3307 _ParticleIndexTag_swigregister(_ParticleIndexTag)
3309 class ModelObject(Object):
3310 """Proxy of C++ IMP::ModelObject class."""
3312 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3314 def __init__(self, m, name):
3315 """__init__(IMP::ModelObject self, Model m, std::string name) -> ModelObject"""
3316 if self.__class__ == ModelObject:
3320 this = _IMP_kernel.new_ModelObject(_self, m, name)
3322 self.this.append(this)
3323 except __builtin__.Exception:
3326 if self.__class__ != ModelObject:
3327 _director_objects.register(self)
3331 __swig_destroy__ = _IMP_kernel.delete_ModelObject
3332 __del__ =
lambda self:
None
3334 def get_model(self):
3335 """get_model(ModelObject self) -> Model"""
3336 return _IMP_kernel.ModelObject_get_model(self)
3339 def get_inputs(self):
3340 """get_inputs(ModelObject self) -> IMP::ModelObjectsTemp"""
3341 return _IMP_kernel.ModelObject_get_inputs(self)
3344 def get_outputs(self):
3345 """get_outputs(ModelObject self) -> IMP::ModelObjectsTemp"""
3346 return _IMP_kernel.ModelObject_get_outputs(self)
3349 def get_interactions(self):
3350 """get_interactions(ModelObject self) -> IMP::ModelObjectsTemps"""
3351 return _IMP_kernel.ModelObject_get_interactions(self)
3354 def get_has_dependencies(self):
3355 """get_has_dependencies(ModelObject self) -> bool"""
3356 return _IMP_kernel.ModelObject_get_has_dependencies(self)
3359 def set_has_dependencies(self, tf):
3360 """set_has_dependencies(ModelObject self, bool tf)"""
3361 return _IMP_kernel.ModelObject_set_has_dependencies(self, tf)
3364 def set_has_required_score_states(self, tf):
3365 """set_has_required_score_states(ModelObject self, bool tf)"""
3366 return _IMP_kernel.ModelObject_set_has_required_score_states(self, tf)
3369 def get_has_required_score_states(self):
3370 """get_has_required_score_states(ModelObject self) -> bool"""
3371 return _IMP_kernel.ModelObject_get_has_required_score_states(self)
3375 """get_required_score_states(ModelObject self) -> IMP::ScoreStatesTemp const &"""
3376 return _IMP_kernel.ModelObject_get_required_score_states(self)
3379 def handle_set_has_required_score_states(self, arg0):
3380 """handle_set_has_required_score_states(ModelObject self, bool arg0)"""
3381 return _IMP_kernel.ModelObject_handle_set_has_required_score_states(self, arg0)
3384 def do_get_inputs(self):
3385 """do_get_inputs(ModelObject self) -> IMP::ModelObjectsTemp"""
3386 return _IMP_kernel.ModelObject_do_get_inputs(self)
3389 def do_get_outputs(self):
3390 """do_get_outputs(ModelObject self) -> IMP::ModelObjectsTemp"""
3391 return _IMP_kernel.ModelObject_do_get_outputs(self)
3394 def do_get_interactions(self):
3395 """do_get_interactions(ModelObject self) -> IMP::ModelObjectsTemps"""
3396 return _IMP_kernel.ModelObject_do_get_interactions(self)
3400 """__str__(ModelObject self) -> std::string"""
3401 return _IMP_kernel.ModelObject___str__(self)
3405 """__repr__(ModelObject self) -> std::string"""
3406 return _IMP_kernel.ModelObject___repr__(self)
3411 return _object_cast_to_ModelObject(o)
3414 def get_type_name(self):
3415 return self.__class__.__name__
3416 def do_show(self, out):
3418 def get_version_info(self):
3420 return VersionInfo(self.__module__,
3421 __import__(self.__module__).get_module_version())
3424 __import__(self.__module__).get_module_version())
3427 return _object_cast_to_ModelObject(o)
3429 def __disown__(self):
3431 _IMP_kernel.disown_ModelObject(self)
3432 return weakref_proxy(self)
3434 def do_destroy(self):
3435 """do_destroy(ModelObject self)"""
3436 return _IMP_kernel.ModelObject_do_destroy(self)
3438 ModelObject_swigregister = _IMP_kernel.ModelObject_swigregister
3439 ModelObject_swigregister(ModelObject)
3440 cvar = _IMP_kernel.cvar
3441 NO_MAX = cvar.NO_MAX
3442 BAD_SCORE = cvar.BAD_SCORE
3444 class _ParticleInputs(object):
3445 """Proxy of C++ IMP::ParticleInputs class."""
3447 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3449 def __init__(self, *args, **kwargs):
3450 raise AttributeError(
"No constructor defined - class is abstract")
3451 __repr__ = _swig_repr
3453 def get_inputs(self, m, pis):
3454 """get_inputs(_ParticleInputs self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
3455 return _IMP_kernel._ParticleInputs_get_inputs(self, m, pis)
3457 _ParticleInputs_swigregister = _IMP_kernel._ParticleInputs_swigregister
3458 _ParticleInputs_swigregister(_ParticleInputs)
3460 class _ParticleOutputs(object):
3461 """Proxy of C++ IMP::ParticleOutputs class."""
3463 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3465 def __init__(self, *args, **kwargs):
3466 raise AttributeError(
"No constructor defined - class is abstract")
3467 __repr__ = _swig_repr
3469 def get_outputs(self, m, pis):
3470 """get_outputs(_ParticleOutputs self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
3471 return _IMP_kernel._ParticleOutputs_get_outputs(self, m, pis)
3473 _ParticleOutputs_swigregister = _IMP_kernel._ParticleOutputs_swigregister
3474 _ParticleOutputs_swigregister(_ParticleOutputs)
3478 """get_input_particles(IMP::ModelObjectsTemp const & mos) -> IMP::ParticlesTemp"""
3479 return _IMP_kernel.get_input_particles(mos)
3482 """get_input_containers(IMP::ModelObjectsTemp const & mos) -> IMP::ContainersTemp"""
3483 return _IMP_kernel.get_input_containers(mos)
3486 """get_output_particles(IMP::ModelObjectsTemp const & mos) -> IMP::ParticlesTemp"""
3487 return _IMP_kernel.get_output_particles(mos)
3490 """get_output_containers(IMP::ModelObjectsTemp const & mos) -> IMP::ContainersTemp"""
3491 return _IMP_kernel.get_output_containers(mos)
3492 class DerivativeAccumulator(object):
3493 """Proxy of C++ IMP::DerivativeAccumulator class."""
3495 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3496 __repr__ = _swig_repr
3498 def __init__(self, *args):
3500 __init__(IMP::DerivativeAccumulator self, double weight=1.0) -> DerivativeAccumulator
3501 __init__(IMP::DerivativeAccumulator self) -> DerivativeAccumulator
3502 __init__(IMP::DerivativeAccumulator self, DerivativeAccumulator copy, double weight) -> DerivativeAccumulator
3504 this = _IMP_kernel.new_DerivativeAccumulator(*args)
3506 self.this.append(this)
3507 except __builtin__.Exception:
3510 def __call__(self, value):
3511 """__call__(DerivativeAccumulator self, double const value) -> double"""
3512 return _IMP_kernel.DerivativeAccumulator___call__(self, value)
3515 def get_weight(self):
3516 """get_weight(DerivativeAccumulator self) -> double"""
3517 return _IMP_kernel.DerivativeAccumulator_get_weight(self)
3520 def show(self, *args):
3522 show(DerivativeAccumulator self, _ostream out)
3523 show(DerivativeAccumulator self)
3525 return _IMP_kernel.DerivativeAccumulator_show(self, *args)
3527 __swig_destroy__ = _IMP_kernel.delete_DerivativeAccumulator
3528 __del__ =
lambda self:
None
3529 DerivativeAccumulator_swigregister = _IMP_kernel.DerivativeAccumulator_swigregister
3530 DerivativeAccumulator_swigregister(DerivativeAccumulator)
3532 class EvaluationState(object):
3533 """Proxy of C++ IMP::EvaluationState class."""
3535 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3536 score = _swig_property(_IMP_kernel.EvaluationState_score_get, _IMP_kernel.EvaluationState_score_set)
3537 good = _swig_property(_IMP_kernel.EvaluationState_good_get, _IMP_kernel.EvaluationState_good_set)
3539 def __init__(self, *args):
3541 __init__(IMP::EvaluationState self, double oscore, bool ogood) -> EvaluationState
3542 __init__(IMP::EvaluationState self) -> EvaluationState
3544 this = _IMP_kernel.new_EvaluationState(*args)
3546 self.this.append(this)
3547 except __builtin__.Exception:
3550 def show(self, *args):
3552 show(EvaluationState self, _ostream out)
3553 show(EvaluationState self)
3555 return _IMP_kernel.EvaluationState_show(self, *args)
3559 """__str__(EvaluationState self) -> std::string"""
3560 return _IMP_kernel.EvaluationState___str__(self)
3564 """__repr__(EvaluationState self) -> std::string"""
3565 return _IMP_kernel.EvaluationState___repr__(self)
3567 __swig_destroy__ = _IMP_kernel.delete_EvaluationState
3568 __del__ =
lambda self:
None
3569 EvaluationState_swigregister = _IMP_kernel.EvaluationState_swigregister
3570 EvaluationState_swigregister(EvaluationState)
3572 class ScoreAccumulator(_Value):
3573 """Proxy of C++ IMP::ScoreAccumulator class."""
3575 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3577 def __init__(self, *args):
3579 __init__(IMP::ScoreAccumulator self) -> ScoreAccumulator
3580 __init__(IMP::ScoreAccumulator self, ScoreAccumulator o, Restraint r) -> ScoreAccumulator
3581 __init__(IMP::ScoreAccumulator self, ScoreAccumulator o, double weight, double local_max) -> ScoreAccumulator
3583 this = _IMP_kernel.new_ScoreAccumulator(*args)
3585 self.this.append(this)
3586 except __builtin__.Exception:
3589 def add_score(self, score):
3590 """add_score(ScoreAccumulator self, double score)"""
3591 return _IMP_kernel.ScoreAccumulator_add_score(self, score)
3594 def get_abort_evaluation(self):
3595 """get_abort_evaluation(ScoreAccumulator self) -> bool"""
3596 return _IMP_kernel.ScoreAccumulator_get_abort_evaluation(self)
3599 def get_is_evaluate_if_below(self):
3600 """get_is_evaluate_if_below(ScoreAccumulator self) -> bool"""
3601 return _IMP_kernel.ScoreAccumulator_get_is_evaluate_if_below(self)
3604 def get_is_evaluate_if_good(self):
3605 """get_is_evaluate_if_good(ScoreAccumulator self) -> bool"""
3606 return _IMP_kernel.ScoreAccumulator_get_is_evaluate_if_good(self)
3609 def get_maximum(self):
3610 """get_maximum(ScoreAccumulator self) -> double"""
3611 return _IMP_kernel.ScoreAccumulator_get_maximum(self)
3614 def get_derivative_accumulator(self):
3615 """get_derivative_accumulator(ScoreAccumulator self) -> DerivativeAccumulator"""
3616 return _IMP_kernel.ScoreAccumulator_get_derivative_accumulator(self)
3619 def show(self, *args):
3621 show(ScoreAccumulator self, _ostream out)
3622 show(ScoreAccumulator self)
3624 return _IMP_kernel.ScoreAccumulator_show(self, *args)
3628 """__str__(ScoreAccumulator self) -> std::string"""
3629 return _IMP_kernel.ScoreAccumulator___str__(self)
3633 """__repr__(ScoreAccumulator self) -> std::string"""
3634 return _IMP_kernel.ScoreAccumulator___repr__(self)
3636 __swig_destroy__ = _IMP_kernel.delete_ScoreAccumulator
3637 __del__ =
lambda self:
None
3638 ScoreAccumulator_swigregister = _IMP_kernel.ScoreAccumulator_swigregister
3639 ScoreAccumulator_swigregister(ScoreAccumulator)
3641 class ScoreState(ModelObject):
3642 """Proxy of C++ IMP::ScoreState class."""
3644 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3646 def __init__(self, m, name):
3647 """__init__(IMP::ScoreState self, Model m, std::string name) -> ScoreState"""
3648 if self.__class__ == ScoreState:
3652 this = _IMP_kernel.new_ScoreState(_self, m, name)
3654 self.this.append(this)
3655 except __builtin__.Exception:
3658 if self.__class__ != ScoreState:
3659 _director_objects.register(self)
3664 def before_evaluate(self):
3665 """before_evaluate(ScoreState self)"""
3666 return _IMP_kernel.ScoreState_before_evaluate(self)
3669 def after_evaluate(self, accpt):
3670 """after_evaluate(ScoreState self, DerivativeAccumulator accpt)"""
3671 return _IMP_kernel.ScoreState_after_evaluate(self, accpt)
3674 def get_has_update_order(self):
3675 """get_has_update_order(ScoreState self) -> bool"""
3676 return _IMP_kernel.ScoreState_get_has_update_order(self)
3680 """get_update_order(ScoreState self) -> unsigned int"""
3681 return _IMP_kernel.ScoreState_get_update_order(self)
3684 def handle_set_has_required_score_states(self, tf):
3685 """handle_set_has_required_score_states(ScoreState self, bool tf)"""
3686 return _IMP_kernel.ScoreState_handle_set_has_required_score_states(self, tf)
3689 def do_before_evaluate(self):
3690 """do_before_evaluate(ScoreState self)"""
3691 return _IMP_kernel.ScoreState_do_before_evaluate(self)
3694 def do_after_evaluate(self, accpt):
3695 """do_after_evaluate(ScoreState self, DerivativeAccumulator accpt)"""
3696 return _IMP_kernel.ScoreState_do_after_evaluate(self, accpt)
3698 __swig_destroy__ = _IMP_kernel.delete_ScoreState
3699 __del__ =
lambda self:
None
3702 """__str__(ScoreState self) -> std::string"""
3703 return _IMP_kernel.ScoreState___str__(self)
3707 """__repr__(ScoreState self) -> std::string"""
3708 return _IMP_kernel.ScoreState___repr__(self)
3713 return _object_cast_to_ScoreState(o)
3716 def get_type_name(self):
3717 return self.__class__.__name__
3718 def do_show(self, out):
3720 def get_version_info(self):
3722 return VersionInfo(self.__module__,
3723 __import__(self.__module__).get_module_version())
3726 __import__(self.__module__).get_module_version())
3729 return _object_cast_to_ScoreState(o)
3731 def __disown__(self):
3733 _IMP_kernel.disown_ScoreState(self)
3734 return weakref_proxy(self)
3736 def do_destroy(self):
3737 """do_destroy(ScoreState self)"""
3738 return _IMP_kernel.ScoreState_do_destroy(self)
3741 def do_get_inputs(self):
3742 """do_get_inputs(ScoreState self) -> IMP::ModelObjectsTemp"""
3743 return _IMP_kernel.ScoreState_do_get_inputs(self)
3746 def do_get_outputs(self):
3747 """do_get_outputs(ScoreState self) -> IMP::ModelObjectsTemp"""
3748 return _IMP_kernel.ScoreState_do_get_outputs(self)
3751 def do_get_interactions(self):
3752 """do_get_interactions(ScoreState self) -> IMP::ModelObjectsTemps"""
3753 return _IMP_kernel.ScoreState_do_get_interactions(self)
3755 ScoreState_swigregister = _IMP_kernel.ScoreState_swigregister
3756 ScoreState_swigregister(ScoreState)
3760 """get_update_order(IMP::ScoreStatesTemp input) -> IMP::ScoreStatesTemp"""
3761 return _IMP_kernel.get_update_order(input)
3762 class Constraint(ScoreState):
3763 """Proxy of C++ IMP::Constraint class."""
3765 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3767 def __init__(self, *args):
3769 __init__(IMP::Constraint self, Model m, std::string name) -> Constraint
3770 __init__(IMP::Constraint self, Model m) -> Constraint
3772 if self.__class__ == Constraint:
3776 this = _IMP_kernel.new_Constraint(_self, *args)
3778 self.this.append(this)
3779 except __builtin__.Exception:
3782 if self.__class__ != Constraint:
3783 _director_objects.register(self)
3788 def do_update_attributes(self):
3789 """do_update_attributes(Constraint self)"""
3790 return _IMP_kernel.Constraint_do_update_attributes(self)
3793 def do_update_derivatives(self, da):
3794 """do_update_derivatives(Constraint self, DerivativeAccumulator da)"""
3795 return _IMP_kernel.Constraint_do_update_derivatives(self, da)
3798 def do_before_evaluate(self):
3799 """do_before_evaluate(Constraint self)"""
3800 return _IMP_kernel.Constraint_do_before_evaluate(self)
3803 def do_after_evaluate(self, da):
3804 """do_after_evaluate(Constraint self, DerivativeAccumulator da)"""
3805 return _IMP_kernel.Constraint_do_after_evaluate(self, da)
3807 __swig_destroy__ = _IMP_kernel.delete_Constraint
3808 __del__ =
lambda self:
None
3811 """__str__(Constraint self) -> std::string"""
3812 return _IMP_kernel.Constraint___str__(self)
3816 """__repr__(Constraint self) -> std::string"""
3817 return _IMP_kernel.Constraint___repr__(self)
3822 return _object_cast_to_Constraint(o)
3825 def get_type_name(self):
3826 return self.__class__.__name__
3827 def do_show(self, out):
3829 def get_version_info(self):
3831 return VersionInfo(self.__module__,
3832 __import__(self.__module__).get_module_version())
3835 __import__(self.__module__).get_module_version())
3838 return _object_cast_to_Constraint(o)
3840 def __disown__(self):
3842 _IMP_kernel.disown_Constraint(self)
3843 return weakref_proxy(self)
3845 def do_destroy(self):
3846 """do_destroy(Constraint self)"""
3847 return _IMP_kernel.Constraint_do_destroy(self)
3850 def do_get_inputs(self):
3851 """do_get_inputs(Constraint self) -> IMP::ModelObjectsTemp"""
3852 return _IMP_kernel.Constraint_do_get_inputs(self)
3855 def do_get_outputs(self):
3856 """do_get_outputs(Constraint self) -> IMP::ModelObjectsTemp"""
3857 return _IMP_kernel.Constraint_do_get_outputs(self)
3860 def do_get_interactions(self):
3861 """do_get_interactions(Constraint self) -> IMP::ModelObjectsTemps"""
3862 return _IMP_kernel.Constraint_do_get_interactions(self)
3864 Constraint_swigregister = _IMP_kernel.Constraint_swigregister
3865 Constraint_swigregister(Constraint)
3867 class Container(ModelObject):
3868 """Proxy of C++ IMP::Container class."""
3870 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
3872 def __init__(self, *args):
3874 __init__(IMP::Container self, Model m, std::string name) -> Container
3875 __init__(IMP::Container self, Model m) -> Container
3877 if self.__class__ == Container:
3881 this = _IMP_kernel.new_Container(_self, *args)
3883 self.this.append(this)
3884 except __builtin__.Exception:
3887 if self.__class__ != Container:
3888 _director_objects.register(self)
3893 def do_get_contents_hash(self):
3894 """do_get_contents_hash(Container self) -> std::size_t"""
3895 return _IMP_kernel.Container_do_get_contents_hash(self)
3898 def get_all_possible_indexes(self):
3899 """get_all_possible_indexes(Container self) -> IMP::ParticleIndexes"""
3900 return _IMP_kernel.Container_get_all_possible_indexes(self)
3903 def get_contents_hash(self):
3904 """get_contents_hash(Container self) -> std::size_t"""
3905 return _IMP_kernel.Container_get_contents_hash(self)
3908 def do_get_outputs(self):
3909 """do_get_outputs(Container self) -> IMP::ModelObjectsTemp"""
3910 return _IMP_kernel.Container_do_get_outputs(self)
3913 def get_is_decomposable(self):
3914 """get_is_decomposable(Container self) -> bool"""
3915 return _IMP_kernel.Container_get_is_decomposable(self)
3918 def validate_readable(self):
3919 """validate_readable(Container self)"""
3920 return _IMP_kernel.Container_validate_readable(self)
3923 def validate_writable(self):
3924 """validate_writable(Container self)"""
3925 return _IMP_kernel.Container_validate_writable(self)
3928 def set_is_readable(self, tf):
3929 """set_is_readable(Container self, bool tf)"""
3930 return _IMP_kernel.Container_set_is_readable(self, tf)
3933 def set_is_writable(self, tf):
3934 """set_is_writable(Container self, bool tf)"""
3935 return _IMP_kernel.Container_set_is_writable(self, tf)
3937 __swig_destroy__ = _IMP_kernel.delete_Container
3938 __del__ =
lambda self:
None
3941 """__str__(Container self) -> std::string"""
3942 return _IMP_kernel.Container___str__(self)
3946 """__repr__(Container self) -> std::string"""
3947 return _IMP_kernel.Container___repr__(self)
3952 return _object_cast_to_Container(o)
3955 def get_type_name(self):
3956 return self.__class__.__name__
3957 def do_show(self, out):
3959 def get_version_info(self):
3961 return VersionInfo(self.__module__,
3962 __import__(self.__module__).get_module_version())
3965 __import__(self.__module__).get_module_version())
3968 return _object_cast_to_Container(o)
3970 def __disown__(self):
3972 _IMP_kernel.disown_Container(self)
3973 return weakref_proxy(self)
3975 def do_destroy(self):
3976 """do_destroy(Container self)"""
3977 return _IMP_kernel.Container_do_destroy(self)
3980 def handle_set_has_required_score_states(self, arg0):
3981 """handle_set_has_required_score_states(Container self, bool arg0)"""
3982 return _IMP_kernel.Container_handle_set_has_required_score_states(self, arg0)
3985 def do_get_inputs(self):
3986 """do_get_inputs(Container self) -> IMP::ModelObjectsTemp"""
3987 return _IMP_kernel.Container_do_get_inputs(self)
3990 def do_get_interactions(self):
3991 """do_get_interactions(Container self) -> IMP::ModelObjectsTemps"""
3992 return _IMP_kernel.Container_do_get_interactions(self)
3994 Container_swigregister = _IMP_kernel.Container_swigregister
3995 Container_swigregister(Container)
3997 class Restraint(ModelObject):
3998 """Proxy of C++ IMP::Restraint class."""
4000 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
4002 def __init__(self, m, name):
4003 """__init__(IMP::Restraint self, Model m, std::string name) -> Restraint"""
4004 if self.__class__ == Restraint:
4008 this = _IMP_kernel.new_Restraint(_self, m, name)
4010 self.this.append(this)
4011 except __builtin__.Exception:
4014 if self.__class__ != Restraint:
4015 _director_objects.register(self)
4020 def get_score(self):
4021 """get_score(Restraint self) -> double"""
4022 return _IMP_kernel.Restraint_get_score(self)
4025 def evaluate(self, calc_derivs):
4026 """evaluate(Restraint self, bool calc_derivs) -> double"""
4027 return _IMP_kernel.Restraint_evaluate(self, calc_derivs)
4030 def evaluate_if_good(self, calc_derivatives):
4031 """evaluate_if_good(Restraint self, bool calc_derivatives) -> double"""
4032 return _IMP_kernel.Restraint_evaluate_if_good(self, calc_derivatives)
4035 def evaluate_if_below(self, calc_derivatives, max):
4036 """evaluate_if_below(Restraint self, bool calc_derivatives, double max) -> double"""
4037 return _IMP_kernel.Restraint_evaluate_if_below(self, calc_derivatives, max)
4040 def unprotected_evaluate(self, da):
4041 """unprotected_evaluate(Restraint self, DerivativeAccumulator da) -> double"""
4042 return _IMP_kernel.Restraint_unprotected_evaluate(self, da)
4045 def unprotected_evaluate_if_good(self, da, max):
4046 """unprotected_evaluate_if_good(Restraint self, DerivativeAccumulator da, double max) -> double"""
4047 return _IMP_kernel.Restraint_unprotected_evaluate_if_good(self, da, max)
4050 def unprotected_evaluate_if_below(self, da, max):
4051 """unprotected_evaluate_if_below(Restraint self, DerivativeAccumulator da, double max) -> double"""
4052 return _IMP_kernel.Restraint_unprotected_evaluate_if_below(self, da, max)
4055 def add_score_and_derivatives(self, sa):
4056 """add_score_and_derivatives(Restraint self, ScoreAccumulator sa)"""
4057 return _IMP_kernel.Restraint_add_score_and_derivatives(self, sa)
4061 """create_decomposition(Restraint self) -> Restraint"""
4062 return _IMP_kernel.Restraint_create_decomposition(self)
4065 def create_current_decomposition(self):
4066 """create_current_decomposition(Restraint self) -> Restraint"""
4067 return _IMP_kernel.Restraint_create_current_decomposition(self)
4070 def set_weight(self, weight):
4071 """set_weight(Restraint self, IMP::Float weight)"""
4072 return _IMP_kernel.Restraint_set_weight(self, weight)
4075 def get_weight(self):
4076 """get_weight(Restraint self) -> IMP::Float"""
4077 return _IMP_kernel.Restraint_get_weight(self)
4080 def get_maximum_score(self):
4081 """get_maximum_score(Restraint self) -> double"""
4082 return _IMP_kernel.Restraint_get_maximum_score(self)
4085 def set_maximum_score(self, s):
4086 """set_maximum_score(Restraint self, double s)"""
4087 return _IMP_kernel.Restraint_set_maximum_score(self, s)
4092 create_scoring_function(Restraint self, double weight=1.0, double max) -> ScoringFunction
4093 create_scoring_function(Restraint self, double weight=1.0) -> ScoringFunction
4094 create_scoring_function(Restraint self) -> ScoringFunction
4096 return _IMP_kernel.Restraint_create_scoring_function(self, *args)
4099 def set_last_score(self, s):
4100 """set_last_score(Restraint self, double s)"""
4101 return _IMP_kernel.Restraint_set_last_score(self, s)
4104 def get_last_score(self):
4105 """get_last_score(Restraint self) -> double"""
4106 return _IMP_kernel.Restraint_get_last_score(self)
4109 def get_was_good(self):
4110 """get_was_good(Restraint self) -> bool"""
4111 return _IMP_kernel.Restraint_get_was_good(self)
4113 __swig_destroy__ = _IMP_kernel.delete_Restraint
4114 __del__ =
lambda self:
None
4116 def do_create_decomposition(self):
4117 """do_create_decomposition(Restraint self) -> IMP::Restraints"""
4118 return _IMP_kernel.Restraint_do_create_decomposition(self)
4121 def do_create_current_decomposition(self):
4122 """do_create_current_decomposition(Restraint self) -> IMP::Restraints"""
4123 return _IMP_kernel.Restraint_do_create_current_decomposition(self)
4126 def do_add_score_and_derivatives(self, sa):
4127 """do_add_score_and_derivatives(Restraint self, ScoreAccumulator sa)"""
4128 return _IMP_kernel.Restraint_do_add_score_and_derivatives(self, sa)
4131 def do_get_outputs(self):
4132 """do_get_outputs(Restraint self) -> IMP::ModelObjectsTemp"""
4133 return _IMP_kernel.Restraint_do_get_outputs(self)
4137 """__str__(Restraint self) -> std::string"""
4138 return _IMP_kernel.Restraint___str__(self)
4142 """__repr__(Restraint self) -> std::string"""
4143 return _IMP_kernel.Restraint___repr__(self)
4148 return _object_cast_to_Restraint(o)
4151 def get_type_name(self):
4152 return self.__class__.__name__
4153 def do_show(self, out):
4155 def get_version_info(self):
4157 return VersionInfo(self.__module__,
4158 __import__(self.__module__).get_module_version())
4161 __import__(self.__module__).get_module_version())
4164 return _object_cast_to_Restraint(o)
4166 def __disown__(self):
4168 _IMP_kernel.disown_Restraint(self)
4169 return weakref_proxy(self)
4171 def do_destroy(self):
4172 """do_destroy(Restraint self)"""
4173 return _IMP_kernel.Restraint_do_destroy(self)
4176 def handle_set_has_required_score_states(self, arg0):
4177 """handle_set_has_required_score_states(Restraint self, bool arg0)"""
4178 return _IMP_kernel.Restraint_handle_set_has_required_score_states(self, arg0)
4181 def do_get_inputs(self):
4182 """do_get_inputs(Restraint self) -> IMP::ModelObjectsTemp"""
4183 return _IMP_kernel.Restraint_do_get_inputs(self)
4186 def do_get_interactions(self):
4187 """do_get_interactions(Restraint self) -> IMP::ModelObjectsTemps"""
4188 return _IMP_kernel.Restraint_do_get_interactions(self)
4190 Restraint_swigregister = _IMP_kernel.Restraint_swigregister
4191 Restraint_swigregister(Restraint)
4193 class _RestraintsAdaptor(_InputAdaptor):
4194 """Proxy of C++ IMP::RestraintsAdaptor class."""
4196 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
4197 __repr__ = _swig_repr
4199 def __init__(self, *args):
4201 __init__(IMP::RestraintsAdaptor self) -> _RestraintsAdaptor
4202 __init__(IMP::RestraintsAdaptor self, IMP::Restraints const & sf) -> _RestraintsAdaptor
4203 __init__(IMP::RestraintsAdaptor self, IMP::RestraintsTemp const & sf) -> _RestraintsAdaptor
4204 __init__(IMP::RestraintsAdaptor self, Restraint sf) -> _RestraintsAdaptor
4206 this = _IMP_kernel.new__RestraintsAdaptor(*args)
4208 self.this.append(this)
4209 except __builtin__.Exception:
4211 __swig_destroy__ = _IMP_kernel.delete__RestraintsAdaptor
4212 __del__ =
lambda self:
None
4213 _RestraintsAdaptor_swigregister = _IMP_kernel._RestraintsAdaptor_swigregister
4214 _RestraintsAdaptor_swigregister(_RestraintsAdaptor)
4216 class RestraintSet(Restraint):
4217 """Proxy of C++ IMP::RestraintSet class."""
4219 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
4221 def __init__(self, *args):
4223 __init__(IMP::RestraintSet self, Model m, double weight, std::string const & name) -> RestraintSet
4224 __init__(IMP::RestraintSet self, Model m, double weight) -> RestraintSet
4225 __init__(IMP::RestraintSet self, Model m, std::string const & name) -> RestraintSet
4226 __init__(IMP::RestraintSet self, Model m) -> RestraintSet
4227 __init__(IMP::RestraintSet self, IMP::RestraintsTemp const & rs, double weight, std::string const & name) -> RestraintSet
4228 __init__(IMP::RestraintSet self, IMP::RestraintsTemp const & rs, double weight) -> RestraintSet
4230 this = _IMP_kernel.new_RestraintSet(*args)
4232 self.this.append(this)
4233 except __builtin__.Exception:
4236 def get_version_info(self):
4237 """get_version_info(RestraintSet self) -> VersionInfo"""
4238 return _IMP_kernel.RestraintSet_get_version_info(self)
4241 def remove_restraint(self, d):
4242 """remove_restraint(RestraintSet self, Restraint d)"""
4243 return _IMP_kernel.RestraintSet_remove_restraint(self, d)
4246 def remove_restraints(self, d):
4247 """remove_restraints(RestraintSet self, IMP::Restraints const & d)"""
4248 return _IMP_kernel.RestraintSet_remove_restraints(self, d)
4251 def set_restraints(self, ps):
4252 """set_restraints(RestraintSet self, IMP::Restraints const & ps)"""
4253 return _IMP_kernel.RestraintSet_set_restraints(self, ps)
4256 def set_restraints_order(self, objs):
4257 """set_restraints_order(RestraintSet self, IMP::Restraints const & objs)"""
4258 return _IMP_kernel.RestraintSet_set_restraints_order(self, objs)
4262 """add_restraint(RestraintSet self, Restraint obj) -> unsigned int"""
4263 return _IMP_kernel.RestraintSet_add_restraint(self, obj)
4267 """add_restraints(RestraintSet self, IMP::Restraints const & objs)"""
4268 return _IMP_kernel.RestraintSet_add_restraints(self, objs)
4271 def clear_restraints(self):
4272 """clear_restraints(RestraintSet self)"""
4273 return _IMP_kernel.RestraintSet_clear_restraints(self)
4276 def get_number_of_restraints(self):
4277 """get_number_of_restraints(RestraintSet self) -> unsigned int"""
4278 return _IMP_kernel.RestraintSet_get_number_of_restraints(self)
4281 def get_has_restraints(self):
4282 """get_has_restraints(RestraintSet self) -> bool"""
4283 return _IMP_kernel.RestraintSet_get_has_restraints(self)
4286 def get_restraint(self, i):
4287 """get_restraint(RestraintSet self, unsigned int i) -> Restraint"""
4288 return _IMP_kernel.RestraintSet_get_restraint(self, i)
4291 def get_restraints(self):
4292 """get_restraints(RestraintSet self) -> IMP::Restraints"""
4293 return _IMP_kernel.RestraintSet_get_restraints(self)
4296 def reserve_restraints(self, sz):
4297 """reserve_restraints(RestraintSet self, unsigned int sz)"""
4298 return _IMP_kernel.RestraintSet_reserve_restraints(self, sz)
4301 def get_non_sets_and_sets(self):
4302 """get_non_sets_and_sets(RestraintSet self) -> std::pair< IMP::RestraintsTemp,IMP::RestraintSetsTemp >"""
4303 return _IMP_kernel.RestraintSet_get_non_sets_and_sets(self)
4306 def do_get_inputs(self):
4307 """do_get_inputs(RestraintSet self) -> IMP::ModelObjectsTemp"""
4308 return _IMP_kernel.RestraintSet_do_get_inputs(self)
4313 create_scoring_function(RestraintSet self, double weight=1.0, double max) -> ScoringFunction
4314 create_scoring_function(RestraintSet self, double weight=1.0) -> ScoringFunction
4315 create_scoring_function(RestraintSet self) -> ScoringFunction
4317 return _IMP_kernel.RestraintSet_create_scoring_function(self, *args)
4321 """__str__(RestraintSet self) -> std::string"""
4322 return _IMP_kernel.RestraintSet___str__(self)
4326 """__repr__(RestraintSet self) -> std::string"""
4327 return _IMP_kernel.RestraintSet___repr__(self)
4332 return _object_cast_to_RestraintSet(o)
4334 RestraintSet_swigregister = _IMP_kernel.RestraintSet_swigregister
4335 RestraintSet_swigregister(RestraintSet)
4338 def get_restraints(rs):
4339 """get_restraints(IMP::RestraintsTemp const & rs) -> IMP::RestraintsTemp"""
4340 return _IMP_kernel.get_restraints(rs)
4342 def _check_particle(p, a):
4343 if (
not p.get_is_active()):
4344 raise ValueError(
"Inactive Particle")
4345 if (type(a)() == a):
4346 raise IndexError(
"Cannot use default Index")
4347 if (
not p.has_attribute(a)):
4348 raise IndexError(
"Particle does not have attribute")
4350 class Particle(ModelObject):
4351 """Proxy of C++ IMP::Particle class."""
4353 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
4355 def get_version_info(self):
4356 """get_version_info(Particle self) -> VersionInfo"""
4357 return _IMP_kernel.Particle_get_version_info(self)
4360 def __init__(self, *args):
4362 __init__(IMP::Particle self, Model m, std::string name) -> Particle
4363 __init__(IMP::Particle self, Model m) -> Particle
4365 this = _IMP_kernel.new_Particle(*args)
4367 self.this.append(this)
4368 except __builtin__.Exception:
4371 def get_float_keys(self):
4372 """get_float_keys(Particle self) -> IMP::FloatKeys"""
4373 return _IMP_kernel.Particle_get_float_keys(self)
4376 def get_int_keys(self):
4377 """get_int_keys(Particle self) -> IMP::IntKeys"""
4378 return _IMP_kernel.Particle_get_int_keys(self)
4381 def get_string_keys(self):
4382 """get_string_keys(Particle self) -> IMP::StringKeys"""
4383 return _IMP_kernel.Particle_get_string_keys(self)
4386 def get_object_keys(self):
4387 """get_object_keys(Particle self) -> IMP::ObjectKeys"""
4388 return _IMP_kernel.Particle_get_object_keys(self)
4391 def add_cache_attribute(self, *args):
4393 add_cache_attribute(Particle self, FloatKey name, IMP::Float value)
4394 add_cache_attribute(Particle self, IntKey name, IMP::Int value)
4395 add_cache_attribute(Particle self, StringKey name, IMP::String value)
4396 add_cache_attribute(Particle self, ObjectKey name, Object value)
4397 add_cache_attribute(Particle self, IMP::WeakObjectKey name, Object value)
4399 return _IMP_kernel.Particle_add_cache_attribute(self, *args)
4402 def get_weak_object_keys(self):
4403 """get_weak_object_keys(Particle self) -> IMP::WeakObjectKeys"""
4404 return _IMP_kernel.Particle_get_weak_object_keys(self)
4407 def add_to_derivative(self, key, value, da):
4408 """add_to_derivative(Particle self, FloatKey key, IMP::Float value, DerivativeAccumulator da)"""
4409 return _IMP_kernel.Particle_add_to_derivative(self, key, value, da)
4412 def set_is_optimized(self, k, tf):
4413 """set_is_optimized(Particle self, FloatKey k, bool tf)"""
4414 return _IMP_kernel.Particle_set_is_optimized(self, k, tf)
4417 def get_is_optimized(self, k):
4418 """get_is_optimized(Particle self, FloatKey k) -> bool"""
4419 return _IMP_kernel.Particle_get_is_optimized(self, k)
4422 def get_derivative(self, k):
4423 """get_derivative(Particle self, FloatKey k) -> IMP::Float"""
4424 return _IMP_kernel.Particle_get_derivative(self, k)
4427 def add_attribute(self, *args):
4429 add_attribute(Particle self, FloatKey name, IMP::Float initial_value)
4430 add_attribute(Particle self, IntKey name, IMP::Int initial_value)
4431 add_attribute(Particle self, StringKey name, IMP::String initial_value)
4432 add_attribute(Particle self, ObjectKey name, Object initial_value)
4433 add_attribute(Particle self, IMP::WeakObjectKey name, Object initial_value)
4434 add_attribute(Particle self, FloatKey name, IMP::Float const initial_value, bool optimized)
4435 add_attribute(Particle self, ParticleIndexKey k, Particle v)
4437 return _IMP_kernel.Particle_add_attribute(self, *args)
4440 def has_attribute(self, *args):
4442 has_attribute(Particle self, FloatKey name) -> bool
4443 has_attribute(Particle self, IntKey name) -> bool
4444 has_attribute(Particle self, StringKey name) -> bool
4445 has_attribute(Particle self, ObjectKey name) -> bool
4446 has_attribute(Particle self, IMP::WeakObjectKey name) -> bool
4447 has_attribute(Particle self, ParticleIndexKey k) -> bool
4449 return _IMP_kernel.Particle_has_attribute(self, *args)
4452 def set_value(self, *args):
4454 set_value(Particle self, FloatKey name, IMP::Float value)
4455 set_value(Particle self, IntKey name, IMP::Int value)
4456 set_value(Particle self, StringKey name, IMP::String value)
4457 set_value(Particle self, ObjectKey name, Object value)
4458 set_value(Particle self, IMP::WeakObjectKey name, Object value)
4459 set_value(Particle self, ParticleIndexKey k, Particle v)
4461 return _IMP_kernel.Particle_set_value(self, *args)
4464 def get_value(self, *args):
4466 get_value(Particle self, FloatKey name) -> IMP::Float
4467 get_value(Particle self, IntKey name) -> IMP::Int
4468 get_value(Particle self, StringKey name) -> IMP::String
4469 get_value(Particle self, ObjectKey name) -> Object
4470 get_value(Particle self, IMP::WeakObjectKey name) -> Object
4471 get_value(Particle self, ParticleIndexKey k) -> Particle
4473 return _IMP_kernel.Particle_get_value(self, *args)
4476 def remove_attribute(self, *args):
4478 remove_attribute(Particle self, FloatKey name)
4479 remove_attribute(Particle self, IntKey name)
4480 remove_attribute(Particle self, StringKey name)
4481 remove_attribute(Particle self, ObjectKey name)
4482 remove_attribute(Particle self, IMP::WeakObjectKey name)
4483 remove_attribute(Particle self, ParticleIndexKey k)
4485 return _IMP_kernel.Particle_remove_attribute(self, *args)
4488 def get_particle_keys(self):
4489 """get_particle_keys(Particle self) -> IMP::ParticleIndexKeys"""
4490 return _IMP_kernel.Particle_get_particle_keys(self)
4493 def show(self, *args):
4495 show(Particle self, _ostream out)
4498 return _IMP_kernel.Particle_show(self, *args)
4501 def get_is_active(self):
4502 """get_is_active(Particle self) -> bool"""
4503 return _IMP_kernel.Particle_get_is_active(self)
4507 """get_index(Particle self) -> ParticleIndex"""
4508 return _IMP_kernel.Particle_get_index(self)
4511 def __eq__(self, *args):
4513 __eq__(Particle self, Particle o) -> bool
4514 __eq__(Particle self, Decorator d) -> bool
4516 return _IMP_kernel.Particle___eq__(self, *args)
4519 def __ne__(self, *args):
4521 __ne__(Particle self, Particle o) -> bool
4522 __ne__(Particle self, Decorator d) -> bool
4524 return _IMP_kernel.Particle___ne__(self, *args)
4527 def __le__(self, *args):
4529 __le__(Particle self, Particle o) -> bool
4530 __le__(Particle self, Decorator d) -> bool
4532 return _IMP_kernel.Particle___le__(self, *args)
4535 def __lt__(self, *args):
4537 __lt__(Particle self, Particle o) -> bool
4538 __lt__(Particle self, Decorator d) -> bool
4540 return _IMP_kernel.Particle___lt__(self, *args)
4543 def __ge__(self, *args):
4545 __ge__(Particle self, Particle o) -> bool
4546 __ge__(Particle self, Decorator d) -> bool
4548 return _IMP_kernel.Particle___ge__(self, *args)
4551 def __gt__(self, *args):
4553 __gt__(Particle self, Particle o) -> bool
4554 __gt__(Particle self, Decorator d) -> bool
4556 return _IMP_kernel.Particle___gt__(self, *args)
4559 __hash__ = ModelObject.__hash__
4563 """__str__(Particle self) -> std::string"""
4564 return _IMP_kernel.Particle___str__(self)
4568 """__repr__(Particle self) -> std::string"""
4569 return _IMP_kernel.Particle___repr__(self)
4574 return _object_cast_to_Particle(o)
4576 Particle_swigregister = _IMP_kernel.Particle_swigregister
4577 Particle_swigregister(Particle)
4579 class _ParticleAdaptor(_InputAdaptor):
4580 """Proxy of C++ IMP::ParticleAdaptor class."""
4582 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
4583 __repr__ = _swig_repr
4585 def __init__(self, *args):
4587 __init__(IMP::ParticleAdaptor self) -> _ParticleAdaptor
4588 __init__(IMP::ParticleAdaptor self, Particle p) -> _ParticleAdaptor
4589 __init__(IMP::ParticleAdaptor self, Decorator d) -> _ParticleAdaptor
4591 this = _IMP_kernel.new__ParticleAdaptor(*args)
4593 self.this.append(this)
4594 except __builtin__.Exception:
4597 def get_model(self):
4598 """get_model(_ParticleAdaptor self) -> Model"""
4599 return _IMP_kernel._ParticleAdaptor_get_model(self)
4602 def get_particle_index(self):
4603 """get_particle_index(_ParticleAdaptor self) -> ParticleIndex"""
4604 return _IMP_kernel._ParticleAdaptor_get_particle_index(self)
4606 __swig_destroy__ = _IMP_kernel.delete__ParticleAdaptor
4607 __del__ =
lambda self:
None
4608 _ParticleAdaptor_swigregister = _IMP_kernel._ParticleAdaptor_swigregister
4609 _ParticleAdaptor_swigregister(_ParticleAdaptor)
4611 class _DependencyGraphVertexIndex(object):
4612 """Proxy of C++ IMP::DependencyGraphVertexIndex class."""
4614 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
4615 __repr__ = _swig_repr
4618 """__init__(IMP::DependencyGraphVertexIndex self) -> _DependencyGraphVertexIndex"""
4619 this = _IMP_kernel.new__DependencyGraphVertexIndex()
4621 self.this.append(this)
4622 except __builtin__.Exception:
4624 __swig_destroy__ = _IMP_kernel.delete__DependencyGraphVertexIndex
4625 __del__ =
lambda self:
None
4626 _DependencyGraphVertexIndex_swigregister = _IMP_kernel._DependencyGraphVertexIndex_swigregister
4627 _DependencyGraphVertexIndex_swigregister(_DependencyGraphVertexIndex)
4630 def show_as_graphviz(name, out):
4631 """show_as_graphviz(IMP::DependencyGraph const & name, TextOutput out)"""
4632 return _IMP_kernel.show_as_graphviz(name, out)
4634 def get_vertex_index(g):
4635 """get_vertex_index(IMP::DependencyGraph const & g) -> _DependencyGraphVertexIndex"""
4636 return _IMP_kernel.get_vertex_index(g)
4639 """get_dependency_graph(Model m) -> IMP::DependencyGraph"""
4640 return _IMP_kernel.get_dependency_graph(m)
4643 """get_pruned_dependency_graph(Model m) -> IMP::DependencyGraph"""
4644 return _IMP_kernel.get_pruned_dependency_graph(m)
4648 get_required_score_states(IMP::ModelObjectsTemp const & mos, IMP::ScoreStatesTemp exclude) -> IMP::ScoreStatesTemp
4649 get_required_score_states(IMP::ModelObjectsTemp const & mos) -> IMP::ScoreStatesTemp
4650 get_required_score_states(ModelObject p, IMP::ModelObjectsTemp const & all, IMP::DependencyGraph const & dg, _DependencyGraphVertexIndex index) -> IMP::ScoreStatesTemp
4652 return _IMP_kernel.get_required_score_states(*args)
4655 """get_dependent_particles(ModelObject p, IMP::ModelObjectsTemp const & all, IMP::DependencyGraph const & dg, _DependencyGraphVertexIndex index) -> IMP::ParticlesTemp"""
4656 return _IMP_kernel.get_dependent_particles(p, all, dg, index)
4658 def get_dependent_restraints(m, pi):
4659 """get_dependent_restraints(Model m, ParticleIndex pi) -> IMP::RestraintsTemp"""
4660 return _IMP_kernel.get_dependent_restraints(m, pi)
4661 class ScoringFunction(ModelObject):
4662 """Proxy of C++ IMP::ScoringFunction class."""
4664 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
4666 def do_add_score_and_derivatives(self, sa, ss):
4667 """do_add_score_and_derivatives(ScoringFunction self, ScoreAccumulator sa, IMP::ScoreStatesTemp const & ss)"""
4668 return _IMP_kernel.ScoringFunction_do_add_score_and_derivatives(self, sa, ss)
4671 def get_score_accumulator_if_below(self, deriv, max):
4672 """get_score_accumulator_if_below(ScoringFunction self, bool deriv, double max) -> ScoreAccumulator"""
4673 return _IMP_kernel.ScoringFunction_get_score_accumulator_if_below(self, deriv, max)
4676 def get_score_accumulator_if_good(self, deriv):
4677 """get_score_accumulator_if_good(ScoringFunction self, bool deriv) -> ScoreAccumulator"""
4678 return _IMP_kernel.ScoringFunction_get_score_accumulator_if_good(self, deriv)
4681 def get_score_accumulator(self, deriv):
4682 """get_score_accumulator(ScoringFunction self, bool deriv) -> ScoreAccumulator"""
4683 return _IMP_kernel.ScoringFunction_get_score_accumulator(self, deriv)
4686 def __init__(self, m, name):
4687 """__init__(IMP::ScoringFunction self, Model m, std::string name) -> ScoringFunction"""
4688 if self.__class__ == ScoringFunction:
4692 this = _IMP_kernel.new_ScoringFunction(_self, m, name)
4694 self.this.append(this)
4695 except __builtin__.Exception:
4698 if self.__class__ != ScoringFunction:
4699 _director_objects.register(self)
4704 def do_get_outputs(self):
4705 """do_get_outputs(ScoringFunction self) -> IMP::ModelObjectsTemp"""
4706 return _IMP_kernel.ScoringFunction_do_get_outputs(self)
4709 def evaluate_if_good(self, derivatives):
4710 """evaluate_if_good(ScoringFunction self, bool derivatives) -> double"""
4711 return _IMP_kernel.ScoringFunction_evaluate_if_good(self, derivatives)
4714 def evaluate(self, derivatives):
4715 """evaluate(ScoringFunction self, bool derivatives) -> double"""
4716 return _IMP_kernel.ScoringFunction_evaluate(self, derivatives)
4719 def evaluate_if_below(self, derivatives, max):
4720 """evaluate_if_below(ScoringFunction self, bool derivatives, double max) -> double"""
4721 return _IMP_kernel.ScoringFunction_evaluate_if_below(self, derivatives, max)
4724 def get_had_good_score(self):
4725 """get_had_good_score(ScoringFunction self) -> bool"""
4726 return _IMP_kernel.ScoringFunction_get_had_good_score(self)
4729 def get_last_score(self):
4730 """get_last_score(ScoringFunction self) -> double"""
4731 return _IMP_kernel.ScoringFunction_get_last_score(self)
4735 """create_restraints(ScoringFunction self) -> IMP::Restraints"""
4736 return _IMP_kernel.ScoringFunction_create_restraints(self)
4740 """__str__(ScoringFunction self) -> std::string"""
4741 return _IMP_kernel.ScoringFunction___str__(self)
4745 """__repr__(ScoringFunction self) -> std::string"""
4746 return _IMP_kernel.ScoringFunction___repr__(self)
4751 return _object_cast_to_ScoringFunction(o)
4754 def get_type_name(self):
4755 return self.__class__.__name__
4756 def do_show(self, out):
4758 def get_version_info(self):
4760 return VersionInfo(self.__module__,
4761 __import__(self.__module__).get_module_version())
4764 __import__(self.__module__).get_module_version())
4767 return _object_cast_to_ScoringFunction(o)
4769 __swig_destroy__ = _IMP_kernel.delete_ScoringFunction
4770 __del__ =
lambda self:
None
4771 def __disown__(self):
4773 _IMP_kernel.disown_ScoringFunction(self)
4774 return weakref_proxy(self)
4776 def do_destroy(self):
4777 """do_destroy(ScoringFunction self)"""
4778 return _IMP_kernel.ScoringFunction_do_destroy(self)
4781 def handle_set_has_required_score_states(self, arg0):
4782 """handle_set_has_required_score_states(ScoringFunction self, bool arg0)"""
4783 return _IMP_kernel.ScoringFunction_handle_set_has_required_score_states(self, arg0)
4786 def do_get_inputs(self):
4787 """do_get_inputs(ScoringFunction self) -> IMP::ModelObjectsTemp"""
4788 return _IMP_kernel.ScoringFunction_do_get_inputs(self)
4791 def do_get_interactions(self):
4792 """do_get_interactions(ScoringFunction self) -> IMP::ModelObjectsTemps"""
4793 return _IMP_kernel.ScoringFunction_do_get_interactions(self)
4795 ScoringFunction_swigregister = _IMP_kernel.ScoringFunction_swigregister
4796 ScoringFunction_swigregister(ScoringFunction)
4801 create_decomposition(IMP::RestraintsTemp const & rs) -> IMP::Restraints
4802 create_decomposition(ScoringFunction sf) -> IMP::ScoringFunctions
4804 return _IMP_kernel.create_decomposition(*args)
4805 class _ScoringFunctionAdaptor(_InputAdaptor):
4806 """Proxy of C++ IMP::ScoringFunctionAdaptor class."""
4808 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
4809 __repr__ = _swig_repr
4811 def __init__(self, *args):
4813 __init__(IMP::ScoringFunctionAdaptor self) -> _ScoringFunctionAdaptor
4814 __init__(IMP::ScoringFunctionAdaptor self, ScoringFunction sf) -> _ScoringFunctionAdaptor
4815 __init__(IMP::ScoringFunctionAdaptor self, IMP::RestraintsTemp const & sf) -> _ScoringFunctionAdaptor
4816 __init__(IMP::ScoringFunctionAdaptor self, IMP::Restraints const & sf) -> _ScoringFunctionAdaptor
4817 __init__(IMP::ScoringFunctionAdaptor self, Restraint sf) -> _ScoringFunctionAdaptor
4819 this = _IMP_kernel.new__ScoringFunctionAdaptor(*args)
4821 self.this.append(this)
4822 except __builtin__.Exception:
4824 __swig_destroy__ = _IMP_kernel.delete__ScoringFunctionAdaptor
4825 __del__ =
lambda self:
None
4826 _ScoringFunctionAdaptor_swigregister = _IMP_kernel._ScoringFunctionAdaptor_swigregister
4827 _ScoringFunctionAdaptor_swigregister(_ScoringFunctionAdaptor)
4832 show_restraint_hierarchy(_ScoringFunctionAdaptor rs, _ostream out)
4833 show_restraint_hierarchy(_ScoringFunctionAdaptor rs)
4835 return _IMP_kernel.show_restraint_hierarchy(*args)
4836 class Undecorator(Object):
4837 """Proxy of C++ IMP::Undecorator class."""
4839 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
4841 def __init__(self, m, name):
4842 """__init__(IMP::Undecorator self, Model m, std::string name) -> Undecorator"""
4843 if self.__class__ == Undecorator:
4847 this = _IMP_kernel.new_Undecorator(_self, m, name)
4849 self.this.append(this)
4850 except __builtin__.Exception:
4853 if self.__class__ != Undecorator:
4854 _director_objects.register(self)
4859 def teardown(self, pi):
4860 """teardown(Undecorator self, ParticleIndex pi)"""
4861 return _IMP_kernel.Undecorator_teardown(self, pi)
4865 """__str__(Undecorator self) -> std::string"""
4866 return _IMP_kernel.Undecorator___str__(self)
4870 """__repr__(Undecorator self) -> std::string"""
4871 return _IMP_kernel.Undecorator___repr__(self)
4876 return _object_cast_to_Undecorator(o)
4879 def get_type_name(self):
4880 return self.__class__.__name__
4881 def do_show(self, out):
4883 def get_version_info(self):
4885 return VersionInfo(self.__module__,
4886 __import__(self.__module__).get_module_version())
4889 __import__(self.__module__).get_module_version())
4892 return _object_cast_to_Undecorator(o)
4894 __swig_destroy__ = _IMP_kernel.delete_Undecorator
4895 __del__ =
lambda self:
None
4896 def __disown__(self):
4898 _IMP_kernel.disown_Undecorator(self)
4899 return weakref_proxy(self)
4901 def do_destroy(self):
4902 """do_destroy(Undecorator self)"""
4903 return _IMP_kernel.Undecorator_do_destroy(self)
4905 Undecorator_swigregister = _IMP_kernel.Undecorator_swigregister
4906 Undecorator_swigregister(Undecorator)
4908 class Model(Object):
4909 """Proxy of C++ IMP::Model class."""
4911 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
4913 def __init__(self, *args):
4915 __init__(IMP::Model self, std::string name) -> Model
4916 __init__(IMP::Model self) -> Model
4918 this = _IMP_kernel.new_Model(*args)
4920 self.this.append(this)
4921 except __builtin__.Exception:
4924 def clear_particle_caches(self, pi):
4925 """clear_particle_caches(Model self, ParticleIndex pi)"""
4926 return _IMP_kernel.Model_clear_particle_caches(self, pi)
4930 """add_particle(Model self, std::string name) -> ParticleIndex"""
4931 return _IMP_kernel.Model_add_particle(self, name)
4934 def get_particle_name(self, pi):
4935 """get_particle_name(Model self, ParticleIndex pi) -> std::string"""
4936 return _IMP_kernel.Model_get_particle_name(self, pi)
4939 def add_undecorator(self, pi, d):
4940 """add_undecorator(Model self, ParticleIndex pi, Undecorator d)"""
4941 return _IMP_kernel.Model_add_undecorator(self, pi, d)
4944 def remove_score_state(self, d):
4945 """remove_score_state(Model self, ScoreState d)"""
4946 return _IMP_kernel.Model_remove_score_state(self, d)
4949 def remove_score_states(self, d):
4950 """remove_score_states(Model self, IMP::ScoreStates const & d)"""
4951 return _IMP_kernel.Model_remove_score_states(self, d)
4954 def set_score_states(self, ps):
4955 """set_score_states(Model self, IMP::ScoreStates const & ps)"""
4956 return _IMP_kernel.Model_set_score_states(self, ps)
4959 def set_score_states_order(self, objs):
4960 """set_score_states_order(Model self, IMP::ScoreStates const & objs)"""
4961 return _IMP_kernel.Model_set_score_states_order(self, objs)
4964 def add_score_state(self, obj):
4965 """add_score_state(Model self, ScoreState obj) -> unsigned int"""
4966 return _IMP_kernel.Model_add_score_state(self, obj)
4969 def add_score_states(self, objs):
4970 """add_score_states(Model self, IMP::ScoreStates const & objs)"""
4971 return _IMP_kernel.Model_add_score_states(self, objs)
4974 def clear_score_states(self):
4975 """clear_score_states(Model self)"""
4976 return _IMP_kernel.Model_clear_score_states(self)
4979 def get_number_of_score_states(self):
4980 """get_number_of_score_states(Model self) -> unsigned int"""
4981 return _IMP_kernel.Model_get_number_of_score_states(self)
4984 def get_has_score_states(self):
4985 """get_has_score_states(Model self) -> bool"""
4986 return _IMP_kernel.Model_get_has_score_states(self)
4989 def get_score_state(self, i):
4990 """get_score_state(Model self, unsigned int i) -> ScoreState"""
4991 return _IMP_kernel.Model_get_score_state(self, i)
4994 def get_score_states(self):
4995 """get_score_states(Model self) -> IMP::ScoreStates"""
4996 return _IMP_kernel.Model_get_score_states(self)
4999 def reserve_score_states(self, sz):
5000 """reserve_score_states(Model self, unsigned int sz)"""
5001 return _IMP_kernel.Model_reserve_score_states(self, sz)
5005 """update(Model self)"""
5006 return _IMP_kernel.Model_update(self)
5009 def add_attribute(self, *args):
5011 add_attribute(Model self, FloatKey attribute_key, ParticleIndex particle, IMP::Float value)
5012 add_attribute(Model self, IntKey attribute_key, ParticleIndex particle, IMP::Int value)
5013 add_attribute(Model self, IMP::IntsKey attribute_key, ParticleIndex particle, IMP::Ints value)
5014 add_attribute(Model self, StringKey attribute_key, ParticleIndex particle, IMP::String value)
5015 add_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle, IMP::ParticleIndexes value)
5016 add_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle, ParticleIndex value)
5017 add_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle, Object value)
5018 add_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle, Object value)
5020 return _IMP_kernel.Model_add_attribute(self, *args)
5023 def remove_attribute(self, *args):
5025 remove_attribute(Model self, FloatKey attribute_key, ParticleIndex particle)
5026 remove_attribute(Model self, IntKey attribute_key, ParticleIndex particle)
5027 remove_attribute(Model self, IMP::IntsKey attribute_key, ParticleIndex particle)
5028 remove_attribute(Model self, StringKey attribute_key, ParticleIndex particle)
5029 remove_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle)
5030 remove_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle)
5031 remove_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle)
5032 remove_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle)
5034 return _IMP_kernel.Model_remove_attribute(self, *args)
5037 def get_has_attribute(self, *args):
5039 get_has_attribute(Model self, FloatKey attribute_key, ParticleIndex particle) -> bool
5040 get_has_attribute(Model self, IntKey attribute_key, ParticleIndex particle) -> bool
5041 get_has_attribute(Model self, IMP::IntsKey attribute_key, ParticleIndex particle) -> bool
5042 get_has_attribute(Model self, StringKey attribute_key, ParticleIndex particle) -> bool
5043 get_has_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle) -> bool
5044 get_has_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle) -> bool
5045 get_has_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle) -> bool
5046 get_has_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle) -> bool
5048 return _IMP_kernel.Model_get_has_attribute(self, *args)
5051 def set_attribute(self, *args):
5053 set_attribute(Model self, FloatKey attribute_key, ParticleIndex particle, IMP::Float value)
5054 set_attribute(Model self, IntKey attribute_key, ParticleIndex particle, IMP::Int value)
5055 set_attribute(Model self, IMP::IntsKey attribute_key, ParticleIndex particle, IMP::Ints value)
5056 set_attribute(Model self, StringKey attribute_key, ParticleIndex particle, IMP::String value)
5057 set_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle, IMP::ParticleIndexes value)
5058 set_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle, ParticleIndex value)
5059 set_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle, Object value)
5060 set_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle, Object value)
5062 return _IMP_kernel.Model_set_attribute(self, *args)
5065 def get_attribute(self, *args):
5067 get_attribute(Model self, FloatKey attribute_key, ParticleIndex particle) -> IMP::Float
5068 get_attribute(Model self, IntKey attribute_key, ParticleIndex particle) -> IMP::Int
5069 get_attribute(Model self, IMP::IntsKey attribute_key, ParticleIndex particle) -> IMP::Ints
5070 get_attribute(Model self, StringKey attribute_key, ParticleIndex particle) -> IMP::String
5071 get_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle) -> IMP::ParticleIndexes
5072 get_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle) -> ParticleIndex
5073 get_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle) -> Object
5074 get_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle) -> Object
5076 return _IMP_kernel.Model_get_attribute(self, *args)
5079 def add_cache_attribute(self, *args):
5081 add_cache_attribute(Model self, FloatKey attribute_key, ParticleIndex particle, IMP::Float value)
5082 add_cache_attribute(Model self, IntKey attribute_key, ParticleIndex particle, IMP::Int value)
5083 add_cache_attribute(Model self, IMP::IntsKey attribute_key, ParticleIndex particle, IMP::Ints value)
5084 add_cache_attribute(Model self, StringKey attribute_key, ParticleIndex particle, IMP::String value)
5085 add_cache_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle, IMP::ParticleIndexes value)
5086 add_cache_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle, ParticleIndex value)
5087 add_cache_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle, Object value)
5088 add_cache_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle, Object value)
5090 return _IMP_kernel.Model_add_cache_attribute(self, *args)
5093 def set_is_optimized(self, arg2, arg3, arg4):
5094 """set_is_optimized(Model self, FloatKey arg2, ParticleIndex arg3, bool arg4)"""
5095 return _IMP_kernel.Model_set_is_optimized(self, arg2, arg3, arg4)
5098 def add_to_derivative(self, k, particle, v, da):
5099 """add_to_derivative(Model self, FloatKey k, ParticleIndex particle, double v, DerivativeAccumulator da)"""
5100 return _IMP_kernel.Model_add_to_derivative(self, k, particle, v, da)
5103 def get_particle(self, p):
5104 """get_particle(Model self, ParticleIndex p) -> Particle"""
5105 return _IMP_kernel.Model_get_particle(self, p)
5108 def get_has_particle(self, p):
5109 """get_has_particle(Model self, ParticleIndex p) -> bool"""
5110 return _IMP_kernel.Model_get_has_particle(self, p)
5113 def get_particle_indexes(self):
5114 """get_particle_indexes(Model self) -> IMP::ParticleIndexes"""
5115 return _IMP_kernel.Model_get_particle_indexes(self)
5118 def get_model_objects(self):
5119 """get_model_objects(Model self) -> IMP::ModelObjectsTemp"""
5120 return _IMP_kernel.Model_get_model_objects(self)
5123 def remove_particle(self, pi):
5124 """remove_particle(Model self, ParticleIndex pi)"""
5125 return _IMP_kernel.Model_remove_particle(self, pi)
5128 def add_data(self, mk, o):
5129 """add_data(Model self, ModelKey mk, Object o)"""
5130 return _IMP_kernel.Model_add_data(self, mk, o)
5133 def get_data(self, mk):
5134 """get_data(Model self, ModelKey mk) -> Object"""
5135 return _IMP_kernel.Model_get_data(self, mk)
5138 def remove_data(self, mk):
5139 """remove_data(Model self, ModelKey mk)"""
5140 return _IMP_kernel.Model_remove_data(self, mk)
5143 def get_has_data(self, mk):
5144 """get_has_data(Model self, ModelKey mk) -> bool"""
5145 return _IMP_kernel.Model_get_has_data(self, mk)
5148 def get_version_info(self):
5149 """get_version_info(Model self) -> VersionInfo"""
5150 return _IMP_kernel.Model_get_version_info(self)
5153 def do_destroy(self):
5154 """do_destroy(Model self)"""
5155 return _IMP_kernel.Model_do_destroy(self)
5159 """__str__(Model self) -> std::string"""
5160 return _IMP_kernel.Model___str__(self)
5164 """__repr__(Model self) -> std::string"""
5165 return _IMP_kernel.Model___repr__(self)
5170 return _object_cast_to_Model(o)
5172 Model_swigregister = _IMP_kernel.Model_swigregister
5173 Model_swigregister(Model)
5175 class Decorator(_Value):
5176 """Proxy of C++ IMP::Decorator class."""
5178 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
5179 __repr__ = _swig_repr
5181 def __init__(self, p):
5182 """__init__(IMP::Decorator self, _ParticleAdaptor p) -> Decorator"""
5183 this = _IMP_kernel.new_Decorator(p)
5185 self.this.append(this)
5186 except __builtin__.Exception:
5189 def __ne__(self, o):
5190 """__ne__(Decorator self, Object o) -> bool"""
5191 return _IMP_kernel.Decorator___ne__(self, o)
5194 def __lt__(self, o):
5195 """__lt__(Decorator self, Object o) -> bool"""
5196 return _IMP_kernel.Decorator___lt__(self, o)
5199 def __gt__(self, o):
5200 """__gt__(Decorator self, Object o) -> bool"""
5201 return _IMP_kernel.Decorator___gt__(self, o)
5204 def __ge__(self, o):
5205 """__ge__(Decorator self, Object o) -> bool"""
5206 return _IMP_kernel.Decorator___ge__(self, o)
5209 def __le__(self, o):
5210 """__le__(Decorator self, Object o) -> bool"""
5211 return _IMP_kernel.Decorator___le__(self, o)
5214 def get_particle(self):
5215 """get_particle(Decorator self) -> Particle"""
5216 return _IMP_kernel.Decorator_get_particle(self)
5219 def get_particle_index(self):
5220 """get_particle_index(Decorator self) -> ParticleIndex"""
5221 return _IMP_kernel.Decorator_get_particle_index(self)
5224 def get_model(self):
5225 """get_model(Decorator self) -> Model"""
5226 return _IMP_kernel.Decorator_get_model(self)
5229 def get_is_valid(self):
5230 """get_is_valid(Decorator self) -> bool"""
5231 return _IMP_kernel.Decorator_get_is_valid(self)
5235 """__hash__(Decorator self) -> std::size_t"""
5236 return _IMP_kernel.Decorator___hash__(self)
5239 def __eq__(self, *args):
5241 __eq__(Decorator self, Object o) -> bool
5242 __eq__(Decorator self, Decorator o) -> bool
5243 __eq__(Decorator self, Particle o) -> bool
5245 return _IMP_kernel.Decorator___eq__(self, *args)
5249 """__bool__(Decorator self) -> bool"""
5250 return _IMP_kernel.Decorator___bool__(self)
5253 __nonzero__ = __bool__
5255 __swig_destroy__ = _IMP_kernel.delete_Decorator
5256 __del__ =
lambda self:
None
5257 Decorator_swigregister = _IMP_kernel.Decorator_swigregister
5258 Decorator_swigregister(Decorator)
5261 def check_particle(m, pi):
5262 """check_particle(Model m, ParticleIndex pi)"""
5263 return _IMP_kernel.check_particle(m, pi)
5264 class UnaryFunction(Object):
5265 """Proxy of C++ IMP::UnaryFunction class."""
5267 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
5269 def __init__(self, *args):
5271 __init__(IMP::UnaryFunction self, std::string name) -> UnaryFunction
5272 __init__(IMP::UnaryFunction self) -> UnaryFunction
5274 if self.__class__ == UnaryFunction:
5278 this = _IMP_kernel.new_UnaryFunction(_self, *args)
5280 self.this.append(this)
5281 except __builtin__.Exception:
5284 if self.__class__ != UnaryFunction:
5285 _director_objects.register(self)
5290 def evaluate(self, feature):
5291 """evaluate(UnaryFunction self, double feature) -> double"""
5292 return _IMP_kernel.UnaryFunction_evaluate(self, feature)
5295 def evaluate_with_derivative(self, feature):
5296 """evaluate_with_derivative(UnaryFunction self, double feature) -> IMP::DerivativePair"""
5297 return _IMP_kernel.UnaryFunction_evaluate_with_derivative(self, feature)
5299 __swig_destroy__ = _IMP_kernel.delete_UnaryFunction
5300 __del__ =
lambda self:
None
5303 """__str__(UnaryFunction self) -> std::string"""
5304 return _IMP_kernel.UnaryFunction___str__(self)
5308 """__repr__(UnaryFunction self) -> std::string"""
5309 return _IMP_kernel.UnaryFunction___repr__(self)
5314 return _object_cast_to_UnaryFunction(o)
5317 def get_type_name(self):
5318 return self.__class__.__name__
5319 def do_show(self, out):
5321 def get_version_info(self):
5323 return VersionInfo(self.__module__,
5324 __import__(self.__module__).get_module_version())
5327 __import__(self.__module__).get_module_version())
5330 return _object_cast_to_UnaryFunction(o)
5332 def __disown__(self):
5334 _IMP_kernel.disown_UnaryFunction(self)
5335 return weakref_proxy(self)
5337 def do_destroy(self):
5338 """do_destroy(UnaryFunction self)"""
5339 return _IMP_kernel.UnaryFunction_do_destroy(self)
5341 UnaryFunction_swigregister = _IMP_kernel.UnaryFunction_swigregister
5342 UnaryFunction_swigregister(UnaryFunction)
5344 class OptimizerState(ModelObject):
5345 """Proxy of C++ IMP::OptimizerState class."""
5347 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
5349 def __init__(self, m, name):
5350 """__init__(IMP::OptimizerState self, Model m, std::string name) -> OptimizerState"""
5351 if self.__class__ == OptimizerState:
5355 this = _IMP_kernel.new_OptimizerState(_self, m, name)
5357 self.this.append(this)
5358 except __builtin__.Exception:
5361 if self.__class__ != OptimizerState:
5362 _director_objects.register(self)
5368 """update(OptimizerState self)"""
5369 return _IMP_kernel.OptimizerState_update(self)
5372 def set_is_optimizing(self, arg0):
5373 """set_is_optimizing(OptimizerState self, bool arg0)"""
5374 return _IMP_kernel.OptimizerState_set_is_optimizing(self, arg0)
5377 def get_optimizer(self):
5378 """get_optimizer(OptimizerState self) -> Optimizer"""
5379 return _IMP_kernel.OptimizerState_get_optimizer(self)
5382 def set_period(self, p):
5383 """set_period(OptimizerState self, unsigned int p)"""
5384 return _IMP_kernel.OptimizerState_set_period(self, p)
5387 def get_period(self):
5388 """get_period(OptimizerState self) -> unsigned int"""
5389 return _IMP_kernel.OptimizerState_get_period(self)
5393 """reset(OptimizerState self)"""
5394 return _IMP_kernel.OptimizerState_reset(self)
5397 def update_always(self):
5398 """update_always(OptimizerState self)"""
5399 return _IMP_kernel.OptimizerState_update_always(self)
5402 def get_number_of_updates(self):
5403 """get_number_of_updates(OptimizerState self) -> unsigned int"""
5404 return _IMP_kernel.OptimizerState_get_number_of_updates(self)
5407 def set_number_of_updates(self, n):
5408 """set_number_of_updates(OptimizerState self, unsigned int n)"""
5409 return _IMP_kernel.OptimizerState_set_number_of_updates(self, n)
5411 __swig_destroy__ = _IMP_kernel.delete_OptimizerState
5412 __del__ =
lambda self:
None
5414 def do_update(self, arg0):
5415 """do_update(OptimizerState self, unsigned int arg0)"""
5416 return _IMP_kernel.OptimizerState_do_update(self, arg0)
5419 def do_set_is_optimizing(self, arg0):
5420 """do_set_is_optimizing(OptimizerState self, bool arg0)"""
5421 return _IMP_kernel.OptimizerState_do_set_is_optimizing(self, arg0)
5424 def do_get_inputs(self):
5425 """do_get_inputs(OptimizerState self) -> IMP::ModelObjectsTemp"""
5426 return _IMP_kernel.OptimizerState_do_get_inputs(self)
5429 def do_get_outputs(self):
5430 """do_get_outputs(OptimizerState self) -> IMP::ModelObjectsTemp"""
5431 return _IMP_kernel.OptimizerState_do_get_outputs(self)
5435 """__str__(OptimizerState self) -> std::string"""
5436 return _IMP_kernel.OptimizerState___str__(self)
5440 """__repr__(OptimizerState self) -> std::string"""
5441 return _IMP_kernel.OptimizerState___repr__(self)
5446 return _object_cast_to_OptimizerState(o)
5449 def get_type_name(self):
5450 return self.__class__.__name__
5451 def do_show(self, out):
5453 def get_version_info(self):
5455 return VersionInfo(self.__module__,
5456 __import__(self.__module__).get_module_version())
5459 __import__(self.__module__).get_module_version())
5462 return _object_cast_to_OptimizerState(o)
5464 def __disown__(self):
5466 _IMP_kernel.disown_OptimizerState(self)
5467 return weakref_proxy(self)
5469 def do_destroy(self):
5470 """do_destroy(OptimizerState self)"""
5471 return _IMP_kernel.OptimizerState_do_destroy(self)
5474 def handle_set_has_required_score_states(self, arg0):
5475 """handle_set_has_required_score_states(OptimizerState self, bool arg0)"""
5476 return _IMP_kernel.OptimizerState_handle_set_has_required_score_states(self, arg0)
5479 def do_get_interactions(self):
5480 """do_get_interactions(OptimizerState self) -> IMP::ModelObjectsTemps"""
5481 return _IMP_kernel.OptimizerState_do_get_interactions(self)
5483 OptimizerState_swigregister = _IMP_kernel.OptimizerState_swigregister
5484 OptimizerState_swigregister(OptimizerState)
5486 class Refiner(_ParticleInputs, Object):
5487 """Proxy of C++ IMP::Refiner class."""
5489 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
5491 def __init__(self, *args):
5493 __init__(IMP::Refiner self, std::string name, bool is_by_ref=False) -> Refiner
5494 __init__(IMP::Refiner self, std::string name) -> Refiner
5495 __init__(IMP::Refiner self) -> Refiner
5497 if self.__class__ == Refiner:
5501 this = _IMP_kernel.new_Refiner(_self, *args)
5503 self.this.append(this)
5504 except __builtin__.Exception:
5507 if self.__class__ != Refiner:
5508 _director_objects.register(self)
5513 def get_can_refine(self, arg0):
5514 """get_can_refine(Refiner self, Particle arg0) -> bool"""
5515 return _IMP_kernel.Refiner_get_can_refine(self, arg0)
5518 def get_refined_indexes(self, m, pi):
5519 """get_refined_indexes(Refiner self, Model m, ParticleIndex pi) -> IMP::ParticleIndexes"""
5520 return _IMP_kernel.Refiner_get_refined_indexes(self, m, pi)
5523 def get_refined_indexes_by_ref(self, m, pi):
5524 """get_refined_indexes_by_ref(Refiner self, Model m, ParticleIndex pi) -> IMP::ParticleIndexes const &"""
5525 return _IMP_kernel.Refiner_get_refined_indexes_by_ref(self, m, pi)
5528 def get_is_by_ref_supported(self):
5529 """get_is_by_ref_supported(Refiner self) -> bool"""
5530 return _IMP_kernel.Refiner_get_is_by_ref_supported(self)
5533 def get_refined(self, *args):
5535 get_refined(Refiner self, Particle a) -> IMP::ParticlesTemp const
5536 get_refined(Refiner self, Particle a, unsigned int i) -> Particle
5538 return _IMP_kernel.Refiner_get_refined(self, *args)
5541 def get_number_of_refined(self, a):
5542 """get_number_of_refined(Refiner self, Particle a) -> unsigned int"""
5543 return _IMP_kernel.Refiner_get_number_of_refined(self, a)
5547 """__str__(Refiner self) -> std::string"""
5548 return _IMP_kernel.Refiner___str__(self)
5552 """__repr__(Refiner self) -> std::string"""
5553 return _IMP_kernel.Refiner___repr__(self)
5558 return _object_cast_to_Refiner(o)
5561 def get_type_name(self):
5562 return self.__class__.__name__
5563 def do_show(self, out):
5565 def get_version_info(self):
5567 return VersionInfo(self.__module__,
5568 __import__(self.__module__).get_module_version())
5571 __import__(self.__module__).get_module_version())
5574 return _object_cast_to_Refiner(o)
5576 __swig_destroy__ = _IMP_kernel.delete_Refiner
5577 __del__ =
lambda self:
None
5578 def __disown__(self):
5580 _IMP_kernel.disown_Refiner(self)
5581 return weakref_proxy(self)
5583 def do_get_inputs(self, m, pis):
5584 """do_get_inputs(Refiner self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
5585 return _IMP_kernel.Refiner_do_get_inputs(self, m, pis)
5588 def do_destroy(self):
5589 """do_destroy(Refiner self)"""
5590 return _IMP_kernel.Refiner_do_destroy(self)
5592 Refiner_swigregister = _IMP_kernel.Refiner_swigregister
5593 Refiner_swigregister(Refiner)
5595 class Optimizer(ModelObject):
5596 """Proxy of C++ IMP::Optimizer class."""
5598 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
5600 def set_is_optimizing_states(self, tf):
5601 """set_is_optimizing_states(Optimizer self, bool tf)"""
5602 return _IMP_kernel.Optimizer_set_is_optimizing_states(self, tf)
5605 def get_optimizer_state_inputs(self):
5606 """get_optimizer_state_inputs(Optimizer self) -> IMP::ModelObjectsTemp"""
5607 return _IMP_kernel.Optimizer_get_optimizer_state_inputs(self)
5610 def do_get_inputs(self):
5611 """do_get_inputs(Optimizer self) -> IMP::ModelObjectsTemp"""
5612 return _IMP_kernel.Optimizer_do_get_inputs(self)
5615 def do_get_outputs(self):
5616 """do_get_outputs(Optimizer self) -> IMP::ModelObjectsTemp"""
5617 return _IMP_kernel.Optimizer_do_get_outputs(self)
5620 def __init__(self, *args):
5622 __init__(IMP::Optimizer self, Model m, std::string name) -> Optimizer
5623 __init__(IMP::Optimizer self, Model m) -> Optimizer
5625 if self.__class__ == Optimizer:
5629 this = _IMP_kernel.new_Optimizer(_self, *args)
5631 self.this.append(this)
5632 except __builtin__.Exception:
5635 if self.__class__ != Optimizer:
5636 _director_objects.register(self)
5641 def optimize(self, max_steps):
5642 """optimize(Optimizer self, unsigned int max_steps) -> double"""
5643 return _IMP_kernel.Optimizer_optimize(self, max_steps)
5646 def set_stop_on_good_score(self, tf):
5647 """set_stop_on_good_score(Optimizer self, bool tf)"""
5648 return _IMP_kernel.Optimizer_set_stop_on_good_score(self, tf)
5651 def get_stop_on_good_score(self):
5652 """get_stop_on_good_score(Optimizer self) -> bool"""
5653 return _IMP_kernel.Optimizer_get_stop_on_good_score(self)
5656 def get_last_score(self):
5657 """get_last_score(Optimizer self) -> double"""
5658 return _IMP_kernel.Optimizer_get_last_score(self)
5661 def get_scoring_function(self):
5662 """get_scoring_function(Optimizer self) -> ScoringFunction"""
5663 return _IMP_kernel.Optimizer_get_scoring_function(self)
5666 def remove_optimizer_state(self, d):
5667 """remove_optimizer_state(Optimizer self, OptimizerState d)"""
5668 return _IMP_kernel.Optimizer_remove_optimizer_state(self, d)
5671 def remove_optimizer_states(self, d):
5672 """remove_optimizer_states(Optimizer self, IMP::OptimizerStates const & d)"""
5673 return _IMP_kernel.Optimizer_remove_optimizer_states(self, d)
5676 def set_optimizer_states(self, ps):
5677 """set_optimizer_states(Optimizer self, IMP::OptimizerStates const & ps)"""
5678 return _IMP_kernel.Optimizer_set_optimizer_states(self, ps)
5681 def set_optimizer_states_order(self, objs):
5682 """set_optimizer_states_order(Optimizer self, IMP::OptimizerStates const & objs)"""
5683 return _IMP_kernel.Optimizer_set_optimizer_states_order(self, objs)
5686 def add_optimizer_state(self, obj):
5687 """add_optimizer_state(Optimizer self, OptimizerState obj) -> unsigned int"""
5688 return _IMP_kernel.Optimizer_add_optimizer_state(self, obj)
5691 def add_optimizer_states(self, objs):
5692 """add_optimizer_states(Optimizer self, IMP::OptimizerStates const & objs)"""
5693 return _IMP_kernel.Optimizer_add_optimizer_states(self, objs)
5696 def clear_optimizer_states(self):
5697 """clear_optimizer_states(Optimizer self)"""
5698 return _IMP_kernel.Optimizer_clear_optimizer_states(self)
5701 def get_number_of_optimizer_states(self):
5702 """get_number_of_optimizer_states(Optimizer self) -> unsigned int"""
5703 return _IMP_kernel.Optimizer_get_number_of_optimizer_states(self)
5706 def get_has_optimizer_states(self):
5707 """get_has_optimizer_states(Optimizer self) -> bool"""
5708 return _IMP_kernel.Optimizer_get_has_optimizer_states(self)
5711 def get_optimizer_state(self, i):
5712 """get_optimizer_state(Optimizer self, unsigned int i) -> OptimizerState"""
5713 return _IMP_kernel.Optimizer_get_optimizer_state(self, i)
5716 def get_optimizer_states(self):
5717 """get_optimizer_states(Optimizer self) -> IMP::OptimizerStates"""
5718 return _IMP_kernel.Optimizer_get_optimizer_states(self)
5721 def reserve_optimizer_states(self, sz):
5722 """reserve_optimizer_states(Optimizer self, unsigned int sz)"""
5723 return _IMP_kernel.Optimizer_reserve_optimizer_states(self, sz)
5726 def set_scoring_function(self, sf):
5727 """set_scoring_function(Optimizer self, _ScoringFunctionAdaptor sf)"""
5728 return _IMP_kernel.Optimizer_set_scoring_function(self, sf)
5730 __swig_destroy__ = _IMP_kernel.delete_Optimizer
5732 """__del__(IMP::Optimizer self)"""
5734 _director_objects.cleanup()
5740 def do_optimize(self, ns):
5741 """do_optimize(Optimizer self, unsigned int ns) -> double"""
5742 return _IMP_kernel.Optimizer_do_optimize(self, ns)
5745 def update_states(self):
5746 """update_states(Optimizer self)"""
5747 return _IMP_kernel.Optimizer_update_states(self)
5751 """__str__(Optimizer self) -> std::string"""
5752 return _IMP_kernel.Optimizer___str__(self)
5756 """__repr__(Optimizer self) -> std::string"""
5757 return _IMP_kernel.Optimizer___repr__(self)
5762 return _object_cast_to_Optimizer(o)
5765 def get_type_name(self):
5766 return self.__class__.__name__
5767 def do_show(self, out):
5769 def get_version_info(self):
5771 return VersionInfo(self.__module__,
5772 __import__(self.__module__).get_module_version())
5775 __import__(self.__module__).get_module_version())
5778 return _object_cast_to_Optimizer(o)
5780 def __disown__(self):
5782 _IMP_kernel.disown_Optimizer(self)
5783 return weakref_proxy(self)
5785 def do_destroy(self):
5786 """do_destroy(Optimizer self)"""
5787 return _IMP_kernel.Optimizer_do_destroy(self)
5790 def handle_set_has_required_score_states(self, arg0):
5791 """handle_set_has_required_score_states(Optimizer self, bool arg0)"""
5792 return _IMP_kernel.Optimizer_handle_set_has_required_score_states(self, arg0)
5795 def do_get_interactions(self):
5796 """do_get_interactions(Optimizer self) -> IMP::ModelObjectsTemps"""
5797 return _IMP_kernel.Optimizer_do_get_interactions(self)
5799 Optimizer_swigregister = _IMP_kernel.Optimizer_swigregister
5800 Optimizer_swigregister(Optimizer)
5802 class AttributeOptimizer(Optimizer):
5803 """Proxy of C++ IMP::AttributeOptimizer class."""
5805 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
5807 def __init__(self, *args):
5809 __init__(IMP::AttributeOptimizer self, Model m, std::string name) -> AttributeOptimizer
5810 __init__(IMP::AttributeOptimizer self, Model m) -> AttributeOptimizer
5812 if self.__class__ == AttributeOptimizer:
5816 this = _IMP_kernel.new_AttributeOptimizer(_self, *args)
5818 self.this.append(this)
5819 except __builtin__.Exception:
5822 if self.__class__ != AttributeOptimizer:
5823 _director_objects.register(self)
5828 def get_optimized_attributes(self):
5829 """get_optimized_attributes(AttributeOptimizer self) -> IMP::FloatIndexes"""
5830 return _IMP_kernel.AttributeOptimizer_get_optimized_attributes(self)
5833 def set_value(self, fi, v):
5834 """set_value(AttributeOptimizer self, FloatIndex fi, double v)"""
5835 return _IMP_kernel.AttributeOptimizer_set_value(self, fi, v)
5838 def get_value(self, fi):
5839 """get_value(AttributeOptimizer self, FloatIndex fi) -> IMP::Float"""
5840 return _IMP_kernel.AttributeOptimizer_get_value(self, fi)
5843 def get_derivative(self, fi):
5844 """get_derivative(AttributeOptimizer self, FloatIndex fi) -> IMP::Float"""
5845 return _IMP_kernel.AttributeOptimizer_get_derivative(self, fi)
5848 def get_width(self, k):
5849 """get_width(AttributeOptimizer self, FloatKey k) -> double"""
5850 return _IMP_kernel.AttributeOptimizer_get_width(self, k)
5853 def set_scaled_value(self, fi, v):
5854 """set_scaled_value(AttributeOptimizer self, FloatIndex fi, IMP::Float v)"""
5855 return _IMP_kernel.AttributeOptimizer_set_scaled_value(self, fi, v)
5858 def get_scaled_value(self, fi):
5859 """get_scaled_value(AttributeOptimizer self, FloatIndex fi) -> double"""
5860 return _IMP_kernel.AttributeOptimizer_get_scaled_value(self, fi)
5863 def get_scaled_derivative(self, fi):
5864 """get_scaled_derivative(AttributeOptimizer self, FloatIndex fi) -> double"""
5865 return _IMP_kernel.AttributeOptimizer_get_scaled_derivative(self, fi)
5868 def clear_range_cache(self):
5869 """clear_range_cache(AttributeOptimizer self)"""
5870 return _IMP_kernel.AttributeOptimizer_clear_range_cache(self)
5874 """__str__(AttributeOptimizer self) -> std::string"""
5875 return _IMP_kernel.AttributeOptimizer___str__(self)
5879 """__repr__(AttributeOptimizer self) -> std::string"""
5880 return _IMP_kernel.AttributeOptimizer___repr__(self)
5885 return _object_cast_to_AttributeOptimizer(o)
5888 def get_type_name(self):
5889 return self.__class__.__name__
5890 def do_show(self, out):
5892 def get_version_info(self):
5894 return VersionInfo(self.__module__,
5895 __import__(self.__module__).get_module_version())
5898 __import__(self.__module__).get_module_version())
5901 return _object_cast_to_AttributeOptimizer(o)
5903 __swig_destroy__ = _IMP_kernel.delete_AttributeOptimizer
5904 __del__ =
lambda self:
None
5905 def __disown__(self):
5907 _IMP_kernel.disown_AttributeOptimizer(self)
5908 return weakref_proxy(self)
5910 def do_destroy(self):
5911 """do_destroy(AttributeOptimizer self)"""
5912 return _IMP_kernel.AttributeOptimizer_do_destroy(self)
5915 def handle_set_has_required_score_states(self, arg0):
5916 """handle_set_has_required_score_states(AttributeOptimizer self, bool arg0)"""
5917 return _IMP_kernel.AttributeOptimizer_handle_set_has_required_score_states(self, arg0)
5920 def do_get_inputs(self):
5921 """do_get_inputs(AttributeOptimizer self) -> IMP::ModelObjectsTemp"""
5922 return _IMP_kernel.AttributeOptimizer_do_get_inputs(self)
5925 def do_get_outputs(self):
5926 """do_get_outputs(AttributeOptimizer self) -> IMP::ModelObjectsTemp"""
5927 return _IMP_kernel.AttributeOptimizer_do_get_outputs(self)
5930 def do_get_interactions(self):
5931 """do_get_interactions(AttributeOptimizer self) -> IMP::ModelObjectsTemps"""
5932 return _IMP_kernel.AttributeOptimizer_do_get_interactions(self)
5935 def do_optimize(self, ns):
5936 """do_optimize(AttributeOptimizer self, unsigned int ns) -> double"""
5937 return _IMP_kernel.AttributeOptimizer_do_optimize(self, ns)
5939 AttributeOptimizer_swigregister = _IMP_kernel.AttributeOptimizer_swigregister
5940 AttributeOptimizer_swigregister(AttributeOptimizer)
5942 class ConfigurationSet(Object):
5943 """Proxy of C++ IMP::ConfigurationSet class."""
5945 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
5947 def __init__(self, *args):
5949 __init__(IMP::ConfigurationSet self, Model m, std::string name) -> ConfigurationSet
5950 __init__(IMP::ConfigurationSet self, Model m) -> ConfigurationSet
5952 this = _IMP_kernel.new_ConfigurationSet(*args)
5954 self.this.append(this)
5955 except __builtin__.Exception:
5958 def save_configuration(self):
5959 """save_configuration(ConfigurationSet self)"""
5960 return _IMP_kernel.ConfigurationSet_save_configuration(self)
5963 def get_number_of_configurations(self):
5964 """get_number_of_configurations(ConfigurationSet self) -> unsigned int"""
5965 return _IMP_kernel.ConfigurationSet_get_number_of_configurations(self)
5968 def load_configuration(self, i):
5969 """load_configuration(ConfigurationSet self, int i)"""
5970 return _IMP_kernel.ConfigurationSet_load_configuration(self, i)
5973 def remove_configuration(self, i):
5974 """remove_configuration(ConfigurationSet self, unsigned int i)"""
5975 return _IMP_kernel.ConfigurationSet_remove_configuration(self, i)
5978 def get_model(self):
5979 """get_model(ConfigurationSet self) -> Model"""
5980 return _IMP_kernel.ConfigurationSet_get_model(self)
5983 def get_version_info(self):
5984 """get_version_info(ConfigurationSet self) -> VersionInfo"""
5985 return _IMP_kernel.ConfigurationSet_get_version_info(self)
5989 """__str__(ConfigurationSet self) -> std::string"""
5990 return _IMP_kernel.ConfigurationSet___str__(self)
5994 """__repr__(ConfigurationSet self) -> std::string"""
5995 return _IMP_kernel.ConfigurationSet___repr__(self)
6000 return _object_cast_to_ConfigurationSet(o)
6002 ConfigurationSet_swigregister = _IMP_kernel.ConfigurationSet_swigregister
6003 ConfigurationSet_swigregister(ConfigurationSet)
6005 class SaveToConfigurationSetOptimizerState(OptimizerState):
6006 """Proxy of C++ IMP::SaveToConfigurationSetOptimizerState class."""
6008 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6010 def __init__(self, cs):
6011 """__init__(IMP::SaveToConfigurationSetOptimizerState self, ConfigurationSet cs) -> SaveToConfigurationSetOptimizerState"""
6012 this = _IMP_kernel.new_SaveToConfigurationSetOptimizerState(cs)
6014 self.this.append(this)
6015 except __builtin__.Exception:
6018 def get_version_info(self):
6019 """get_version_info(SaveToConfigurationSetOptimizerState self) -> VersionInfo"""
6020 return _IMP_kernel.SaveToConfigurationSetOptimizerState_get_version_info(self)
6024 """__str__(SaveToConfigurationSetOptimizerState self) -> std::string"""
6025 return _IMP_kernel.SaveToConfigurationSetOptimizerState___str__(self)
6029 """__repr__(SaveToConfigurationSetOptimizerState self) -> std::string"""
6030 return _IMP_kernel.SaveToConfigurationSetOptimizerState___repr__(self)
6035 return _object_cast_to_SaveToConfigurationSetOptimizerState(o)
6037 SaveToConfigurationSetOptimizerState_swigregister = _IMP_kernel.SaveToConfigurationSetOptimizerState_swigregister
6038 SaveToConfigurationSetOptimizerState_swigregister(SaveToConfigurationSetOptimizerState)
6040 class Configuration(Object):
6041 """Proxy of C++ IMP::Configuration class."""
6043 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6045 def __init__(self, *args):
6047 __init__(IMP::Configuration self, Model m, std::string name) -> Configuration
6048 __init__(IMP::Configuration self, Model m) -> Configuration
6049 __init__(IMP::Configuration self, Model m, Configuration base, std::string name) -> Configuration
6050 __init__(IMP::Configuration self, Model m, Configuration base) -> Configuration
6052 this = _IMP_kernel.new_Configuration(*args)
6054 self.this.append(this)
6055 except __builtin__.Exception:
6058 def load_configuration(self):
6059 """load_configuration(Configuration self)"""
6060 return _IMP_kernel.Configuration_load_configuration(self)
6063 def swap_configuration(self):
6064 """swap_configuration(Configuration self)"""
6065 return _IMP_kernel.Configuration_swap_configuration(self)
6068 def get_version_info(self):
6069 """get_version_info(Configuration self) -> VersionInfo"""
6070 return _IMP_kernel.Configuration_get_version_info(self)
6074 """__str__(Configuration self) -> std::string"""
6075 return _IMP_kernel.Configuration___str__(self)
6079 """__repr__(Configuration self) -> std::string"""
6080 return _IMP_kernel.Configuration___repr__(self)
6085 return _object_cast_to_Configuration(o)
6087 Configuration_swigregister = _IMP_kernel.Configuration_swigregister
6088 Configuration_swigregister(Configuration)
6090 class Sampler(Object):
6091 """Proxy of C++ IMP::Sampler class."""
6093 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6095 def __init__(self, *args):
6097 __init__(IMP::Sampler self, Model m, std::string name) -> Sampler
6098 __init__(IMP::Sampler self, Model m) -> Sampler
6100 if self.__class__ == Sampler:
6104 this = _IMP_kernel.new_Sampler(_self, *args)
6106 self.this.append(this)
6107 except __builtin__.Exception:
6110 if self.__class__ != Sampler:
6111 _director_objects.register(self)
6116 def create_sample(self):
6117 """create_sample(Sampler self) -> ConfigurationSet"""
6118 return _IMP_kernel.Sampler_create_sample(self)
6121 def get_scoring_function(self):
6122 """get_scoring_function(Sampler self) -> ScoringFunction"""
6123 return _IMP_kernel.Sampler_get_scoring_function(self)
6126 def set_scoring_function(self, sf):
6127 """set_scoring_function(Sampler self, _ScoringFunctionAdaptor sf)"""
6128 return _IMP_kernel.Sampler_set_scoring_function(self, sf)
6131 def get_model(self):
6132 """get_model(Sampler self) -> Model"""
6133 return _IMP_kernel.Sampler_get_model(self)
6136 def do_sample(self):
6137 """do_sample(Sampler self) -> ConfigurationSet"""
6138 return _IMP_kernel.Sampler_do_sample(self)
6140 __swig_destroy__ = _IMP_kernel.delete_Sampler
6141 __del__ =
lambda self:
None
6144 """__str__(Sampler self) -> std::string"""
6145 return _IMP_kernel.Sampler___str__(self)
6149 """__repr__(Sampler self) -> std::string"""
6150 return _IMP_kernel.Sampler___repr__(self)
6155 return _object_cast_to_Sampler(o)
6158 def get_type_name(self):
6159 return self.__class__.__name__
6160 def do_show(self, out):
6162 def get_version_info(self):
6164 return VersionInfo(self.__module__,
6165 __import__(self.__module__).get_module_version())
6168 __import__(self.__module__).get_module_version())
6171 return _object_cast_to_Sampler(o)
6173 def __disown__(self):
6175 _IMP_kernel.disown_Sampler(self)
6176 return weakref_proxy(self)
6178 def do_destroy(self):
6179 """do_destroy(Sampler self)"""
6180 return _IMP_kernel.Sampler_do_destroy(self)
6182 Sampler_swigregister = _IMP_kernel.Sampler_swigregister
6183 Sampler_swigregister(Sampler)
6185 class PairModifier(_ParticleInputs, _ParticleOutputs, Object):
6186 """Proxy of C++ IMP::PairModifier class."""
6188 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6190 def __init__(self, *args):
6192 __init__(IMP::PairModifier self, std::string name) -> PairModifier
6193 __init__(IMP::PairModifier self) -> PairModifier
6195 if self.__class__ == PairModifier:
6199 this = _IMP_kernel.new_PairModifier(_self, *args)
6201 self.this.append(this)
6202 except __builtin__.Exception:
6205 if self.__class__ != PairModifier:
6206 _director_objects.register(self)
6211 def apply_index(self, m, v):
6212 """apply_index(PairModifier self, Model m, IMP::ParticleIndexPair const & v)"""
6213 return _IMP_kernel.PairModifier_apply_index(self, m, v)
6216 def apply_indexes(self, m, o, lower_bound, upper_bound):
6217 """apply_indexes(PairModifier self, Model m, IMP::ParticleIndexPairs const & o, unsigned int lower_bound, unsigned int upper_bound)"""
6218 return _IMP_kernel.PairModifier_apply_indexes(self, m, o, lower_bound, upper_bound)
6222 """__str__(PairModifier self) -> std::string"""
6223 return _IMP_kernel.PairModifier___str__(self)
6227 """__repr__(PairModifier self) -> std::string"""
6228 return _IMP_kernel.PairModifier___repr__(self)
6233 return _object_cast_to_PairModifier(o)
6236 def get_type_name(self):
6237 return self.__class__.__name__
6238 def do_show(self, out):
6240 def get_version_info(self):
6242 return VersionInfo(self.__module__,
6243 __import__(self.__module__).get_module_version())
6246 __import__(self.__module__).get_module_version())
6249 return _object_cast_to_PairModifier(o)
6251 __swig_destroy__ = _IMP_kernel.delete_PairModifier
6252 __del__ =
lambda self:
None
6253 def __disown__(self):
6255 _IMP_kernel.disown_PairModifier(self)
6256 return weakref_proxy(self)
6258 def do_get_inputs(self, m, pis):
6259 """do_get_inputs(PairModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6260 return _IMP_kernel.PairModifier_do_get_inputs(self, m, pis)
6263 def do_get_outputs(self, m, pis):
6264 """do_get_outputs(PairModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6265 return _IMP_kernel.PairModifier_do_get_outputs(self, m, pis)
6268 def do_destroy(self):
6269 """do_destroy(PairModifier self)"""
6270 return _IMP_kernel.PairModifier_do_destroy(self)
6272 PairModifier_swigregister = _IMP_kernel.PairModifier_swigregister
6273 PairModifier_swigregister(PairModifier)
6275 class PairScore(_ParticleInputs, Object):
6276 """Proxy of C++ IMP::PairScore class."""
6278 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6280 def __init__(self, *args):
6282 __init__(IMP::PairScore self, std::string name) -> PairScore
6283 __init__(IMP::PairScore self) -> PairScore
6285 if self.__class__ == PairScore:
6289 this = _IMP_kernel.new_PairScore(_self, *args)
6291 self.this.append(this)
6292 except __builtin__.Exception:
6295 if self.__class__ != PairScore:
6296 _director_objects.register(self)
6301 def evaluate_index(self, m, vt, da):
6302 """evaluate_index(PairScore self, Model m, IMP::ParticleIndexPair const & vt, DerivativeAccumulator da) -> double"""
6303 return _IMP_kernel.PairScore_evaluate_index(self, m, vt, da)
6306 def evaluate_indexes(self, m, o, da, lower_bound, upper_bound):
6307 """evaluate_indexes(PairScore self, Model m, IMP::ParticleIndexPairs const & o, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound) -> double"""
6308 return _IMP_kernel.PairScore_evaluate_indexes(self, m, o, da, lower_bound, upper_bound)
6311 def evaluate_if_good_index(self, m, vt, da, max):
6312 """evaluate_if_good_index(PairScore self, Model m, IMP::ParticleIndexPair const & vt, DerivativeAccumulator da, double max) -> double"""
6313 return _IMP_kernel.PairScore_evaluate_if_good_index(self, m, vt, da, max)
6316 def evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound):
6317 """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"""
6318 return _IMP_kernel.PairScore_evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound)
6321 def create_current_decomposition(self, m, vt):
6322 """create_current_decomposition(PairScore self, Model m, IMP::ParticleIndexPair const & vt) -> IMP::Restraints"""
6323 return _IMP_kernel.PairScore_create_current_decomposition(self, m, vt)
6326 def do_create_current_decomposition(self, m, vt):
6327 """do_create_current_decomposition(PairScore self, Model m, IMP::ParticleIndexPair const & vt) -> IMP::Restraints"""
6328 return _IMP_kernel.PairScore_do_create_current_decomposition(self, m, vt)
6330 __swig_destroy__ = _IMP_kernel.delete_PairScore
6331 __del__ =
lambda self:
None
6334 """__str__(PairScore self) -> std::string"""
6335 return _IMP_kernel.PairScore___str__(self)
6339 """__repr__(PairScore self) -> std::string"""
6340 return _IMP_kernel.PairScore___repr__(self)
6345 return _object_cast_to_PairScore(o)
6348 def get_type_name(self):
6349 return self.__class__.__name__
6350 def do_show(self, out):
6352 def get_version_info(self):
6354 return VersionInfo(self.__module__,
6355 __import__(self.__module__).get_module_version())
6358 __import__(self.__module__).get_module_version())
6361 return _object_cast_to_PairScore(o)
6363 def __disown__(self):
6365 _IMP_kernel.disown_PairScore(self)
6366 return weakref_proxy(self)
6368 def do_get_inputs(self, m, pis):
6369 """do_get_inputs(PairScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6370 return _IMP_kernel.PairScore_do_get_inputs(self, m, pis)
6373 def do_destroy(self):
6374 """do_destroy(PairScore self)"""
6375 return _IMP_kernel.PairScore_do_destroy(self)
6377 PairScore_swigregister = _IMP_kernel.PairScore_swigregister
6378 PairScore_swigregister(PairScore)
6380 class PairPredicate(_ParticleInputs, Object):
6381 """Proxy of C++ IMP::PairPredicate class."""
6383 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6385 def __init__(self, *args):
6387 __init__(IMP::PairPredicate self, std::string name) -> PairPredicate
6388 __init__(IMP::PairPredicate self) -> PairPredicate
6390 if self.__class__ == PairPredicate:
6394 this = _IMP_kernel.new_PairPredicate(_self, *args)
6396 self.this.append(this)
6397 except __builtin__.Exception:
6400 if self.__class__ != PairPredicate:
6401 _director_objects.register(self)
6406 def get_value(self, *args):
6408 get_value(PairPredicate self, IMP::ParticlePair const & vt) -> int
6409 get_value(PairPredicate self, IMP::ParticlePairsTemp const & o) -> IMP::Ints
6411 return _IMP_kernel.PairPredicate_get_value(self, *args)
6414 def __call__(self, m, vt):
6415 """__call__(PairPredicate self, Model m, IMP::ParticleIndexPair const & vt) -> int"""
6416 return _IMP_kernel.PairPredicate___call__(self, m, vt)
6419 def get_value_index(self, *args):
6421 get_value_index(PairPredicate self, Model m, IMP::ParticleIndexPair const & vt) -> int
6422 get_value_index(PairPredicate self, Model m, IMP::ParticleIndexPairs const & o) -> IMP::Ints
6424 return _IMP_kernel.PairPredicate_get_value_index(self, *args)
6426 __swig_destroy__ = _IMP_kernel.delete_PairPredicate
6427 __del__ =
lambda self:
None
6430 """__str__(PairPredicate self) -> std::string"""
6431 return _IMP_kernel.PairPredicate___str__(self)
6435 """__repr__(PairPredicate self) -> std::string"""
6436 return _IMP_kernel.PairPredicate___repr__(self)
6441 return _object_cast_to_PairPredicate(o)
6444 def get_type_name(self):
6445 return self.__class__.__name__
6446 def do_show(self, out):
6448 def get_version_info(self):
6450 return VersionInfo(self.__module__,
6451 __import__(self.__module__).get_module_version())
6454 __import__(self.__module__).get_module_version())
6457 return _object_cast_to_PairPredicate(o)
6459 def __disown__(self):
6461 _IMP_kernel.disown_PairPredicate(self)
6462 return weakref_proxy(self)
6464 def do_get_inputs(self, m, pis):
6465 """do_get_inputs(PairPredicate self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6466 return _IMP_kernel.PairPredicate_do_get_inputs(self, m, pis)
6469 def do_destroy(self):
6470 """do_destroy(PairPredicate self)"""
6471 return _IMP_kernel.PairPredicate_do_destroy(self)
6473 PairPredicate_swigregister = _IMP_kernel.PairPredicate_swigregister
6474 PairPredicate_swigregister(PairPredicate)
6476 class PairContainer(Container):
6477 """Proxy of C++ IMP::PairContainer class."""
6479 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6481 def apply_generic(self, m):
6482 """apply_generic(PairContainer self, PairModifier m)"""
6483 return _IMP_kernel.PairContainer_apply_generic(self, m)
6486 def apply(self, sm):
6487 """apply(PairContainer self, PairModifier sm)"""
6488 return _IMP_kernel.PairContainer_apply(self, sm)
6491 def get_range_indexes(self):
6492 """get_range_indexes(PairContainer self) -> IMP::ParticleIndexPairs"""
6493 return _IMP_kernel.PairContainer_get_range_indexes(self)
6496 def get_contents(self):
6497 """get_contents(PairContainer self) -> IMP::ParticleIndexPairs const &"""
6498 return _IMP_kernel.PairContainer_get_contents(self)
6502 """get_indexes(PairContainer self) -> IMP::ParticleIndexPairs"""
6503 return _IMP_kernel.PairContainer_get_indexes(self)
6506 def get(self, *args):
6508 get(PairContainer self) -> IMP::ParticlePairsTemp
6509 get(PairContainer self, unsigned int i) -> IMP::ParticlePair
6511 return _IMP_kernel.PairContainer_get(self, *args)
6514 def get_number(self):
6515 """get_number(PairContainer self) -> unsigned int"""
6516 return _IMP_kernel.PairContainer_get_number(self)
6519 def get_particle_pairs(self):
6520 """get_particle_pairs(PairContainer self) -> IMP::ParticlePairsTemp"""
6521 return _IMP_kernel.PairContainer_get_particle_pairs(self)
6524 def get_particle_pair(self, i):
6525 """get_particle_pair(PairContainer self, unsigned int i) -> IMP::ParticlePair"""
6526 return _IMP_kernel.PairContainer_get_particle_pair(self, i)
6529 def __init__(self, *args):
6531 __init__(IMP::PairContainer self, Model m, std::string name) -> PairContainer
6532 __init__(IMP::PairContainer self, Model m) -> PairContainer
6534 if self.__class__ == PairContainer:
6538 this = _IMP_kernel.new_PairContainer(_self, *args)
6540 self.this.append(this)
6541 except __builtin__.Exception:
6544 if self.__class__ != PairContainer:
6545 _director_objects.register(self)
6550 def do_apply(self, sm):
6551 """do_apply(PairContainer self, PairModifier sm)"""
6552 return _IMP_kernel.PairContainer_do_apply(self, sm)
6555 def do_get_provides_access(self):
6556 """do_get_provides_access(PairContainer self) -> bool"""
6557 return _IMP_kernel.PairContainer_do_get_provides_access(self)
6559 __swig_destroy__ = _IMP_kernel.delete_PairContainer
6560 __del__ =
lambda self:
None
6563 """__str__(PairContainer self) -> std::string"""
6564 return _IMP_kernel.PairContainer___str__(self)
6568 """__repr__(PairContainer self) -> std::string"""
6569 return _IMP_kernel.PairContainer___repr__(self)
6574 return _object_cast_to_PairContainer(o)
6577 def get_type_name(self):
6578 return self.__class__.__name__
6579 def do_show(self, out):
6581 def get_version_info(self):
6583 return VersionInfo(self.__module__,
6584 __import__(self.__module__).get_module_version())
6587 __import__(self.__module__).get_module_version())
6590 return _object_cast_to_PairContainer(o)
6592 def __disown__(self):
6594 _IMP_kernel.disown_PairContainer(self)
6595 return weakref_proxy(self)
6597 def do_destroy(self):
6598 """do_destroy(PairContainer self)"""
6599 return _IMP_kernel.PairContainer_do_destroy(self)
6602 def handle_set_has_required_score_states(self, arg0):
6603 """handle_set_has_required_score_states(PairContainer self, bool arg0)"""
6604 return _IMP_kernel.PairContainer_handle_set_has_required_score_states(self, arg0)
6607 def do_get_inputs(self):
6608 """do_get_inputs(PairContainer self) -> IMP::ModelObjectsTemp"""
6609 return _IMP_kernel.PairContainer_do_get_inputs(self)
6612 def do_get_interactions(self):
6613 """do_get_interactions(PairContainer self) -> IMP::ModelObjectsTemps"""
6614 return _IMP_kernel.PairContainer_do_get_interactions(self)
6617 def do_get_contents_hash(self):
6618 """do_get_contents_hash(PairContainer self) -> std::size_t"""
6619 return _IMP_kernel.PairContainer_do_get_contents_hash(self)
6621 PairContainer_swigregister = _IMP_kernel.PairContainer_swigregister
6622 PairContainer_swigregister(PairContainer)
6624 class _PairContainerAdaptor(_InputAdaptor):
6625 """Proxy of C++ IMP::PairContainerAdaptor class."""
6627 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6628 __repr__ = _swig_repr
6630 def __init__(self, *args):
6632 __init__(IMP::PairContainerAdaptor self) -> _PairContainerAdaptor
6633 __init__(IMP::PairContainerAdaptor self, PairContainer c) -> _PairContainerAdaptor
6634 __init__(IMP::PairContainerAdaptor self, IMP::ParticlePairsTemp const & t) -> _PairContainerAdaptor
6636 this = _IMP_kernel.new__PairContainerAdaptor(*args)
6638 self.this.append(this)
6639 except __builtin__.Exception:
6642 def set_name_if_default(self, name):
6643 """set_name_if_default(_PairContainerAdaptor self, std::string name)"""
6644 return _IMP_kernel._PairContainerAdaptor_set_name_if_default(self, name)
6646 __swig_destroy__ = _IMP_kernel.delete__PairContainerAdaptor
6647 __del__ =
lambda self:
None
6648 _PairContainerAdaptor_swigregister = _IMP_kernel._PairContainerAdaptor_swigregister
6649 _PairContainerAdaptor_swigregister(_PairContainerAdaptor)
6651 class QuadModifier(_ParticleInputs, _ParticleOutputs, Object):
6652 """Proxy of C++ IMP::QuadModifier class."""
6654 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6656 def __init__(self, *args):
6658 __init__(IMP::QuadModifier self, std::string name) -> QuadModifier
6659 __init__(IMP::QuadModifier self) -> QuadModifier
6661 if self.__class__ == QuadModifier:
6665 this = _IMP_kernel.new_QuadModifier(_self, *args)
6667 self.this.append(this)
6668 except __builtin__.Exception:
6671 if self.__class__ != QuadModifier:
6672 _director_objects.register(self)
6677 def apply_index(self, m, v):
6678 """apply_index(QuadModifier self, Model m, IMP::ParticleIndexQuad const & v)"""
6679 return _IMP_kernel.QuadModifier_apply_index(self, m, v)
6682 def apply_indexes(self, m, o, lower_bound, upper_bound):
6683 """apply_indexes(QuadModifier self, Model m, IMP::ParticleIndexQuads const & o, unsigned int lower_bound, unsigned int upper_bound)"""
6684 return _IMP_kernel.QuadModifier_apply_indexes(self, m, o, lower_bound, upper_bound)
6688 """__str__(QuadModifier self) -> std::string"""
6689 return _IMP_kernel.QuadModifier___str__(self)
6693 """__repr__(QuadModifier self) -> std::string"""
6694 return _IMP_kernel.QuadModifier___repr__(self)
6699 return _object_cast_to_QuadModifier(o)
6702 def get_type_name(self):
6703 return self.__class__.__name__
6704 def do_show(self, out):
6706 def get_version_info(self):
6708 return VersionInfo(self.__module__,
6709 __import__(self.__module__).get_module_version())
6712 __import__(self.__module__).get_module_version())
6715 return _object_cast_to_QuadModifier(o)
6717 __swig_destroy__ = _IMP_kernel.delete_QuadModifier
6718 __del__ =
lambda self:
None
6719 def __disown__(self):
6721 _IMP_kernel.disown_QuadModifier(self)
6722 return weakref_proxy(self)
6724 def do_get_inputs(self, m, pis):
6725 """do_get_inputs(QuadModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6726 return _IMP_kernel.QuadModifier_do_get_inputs(self, m, pis)
6729 def do_get_outputs(self, m, pis):
6730 """do_get_outputs(QuadModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6731 return _IMP_kernel.QuadModifier_do_get_outputs(self, m, pis)
6734 def do_destroy(self):
6735 """do_destroy(QuadModifier self)"""
6736 return _IMP_kernel.QuadModifier_do_destroy(self)
6738 QuadModifier_swigregister = _IMP_kernel.QuadModifier_swigregister
6739 QuadModifier_swigregister(QuadModifier)
6741 class QuadScore(_ParticleInputs, Object):
6742 """Proxy of C++ IMP::QuadScore class."""
6744 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6746 def __init__(self, *args):
6748 __init__(IMP::QuadScore self, std::string name) -> QuadScore
6749 __init__(IMP::QuadScore self) -> QuadScore
6751 if self.__class__ == QuadScore:
6755 this = _IMP_kernel.new_QuadScore(_self, *args)
6757 self.this.append(this)
6758 except __builtin__.Exception:
6761 if self.__class__ != QuadScore:
6762 _director_objects.register(self)
6767 def evaluate_index(self, m, vt, da):
6768 """evaluate_index(QuadScore self, Model m, IMP::ParticleIndexQuad const & vt, DerivativeAccumulator da) -> double"""
6769 return _IMP_kernel.QuadScore_evaluate_index(self, m, vt, da)
6772 def evaluate_indexes(self, m, o, da, lower_bound, upper_bound):
6773 """evaluate_indexes(QuadScore self, Model m, IMP::ParticleIndexQuads const & o, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound) -> double"""
6774 return _IMP_kernel.QuadScore_evaluate_indexes(self, m, o, da, lower_bound, upper_bound)
6777 def evaluate_if_good_index(self, m, vt, da, max):
6778 """evaluate_if_good_index(QuadScore self, Model m, IMP::ParticleIndexQuad const & vt, DerivativeAccumulator da, double max) -> double"""
6779 return _IMP_kernel.QuadScore_evaluate_if_good_index(self, m, vt, da, max)
6782 def evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound):
6783 """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"""
6784 return _IMP_kernel.QuadScore_evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound)
6787 def create_current_decomposition(self, m, vt):
6788 """create_current_decomposition(QuadScore self, Model m, IMP::ParticleIndexQuad const & vt) -> IMP::Restraints"""
6789 return _IMP_kernel.QuadScore_create_current_decomposition(self, m, vt)
6792 def do_create_current_decomposition(self, m, vt):
6793 """do_create_current_decomposition(QuadScore self, Model m, IMP::ParticleIndexQuad const & vt) -> IMP::Restraints"""
6794 return _IMP_kernel.QuadScore_do_create_current_decomposition(self, m, vt)
6796 __swig_destroy__ = _IMP_kernel.delete_QuadScore
6797 __del__ =
lambda self:
None
6800 """__str__(QuadScore self) -> std::string"""
6801 return _IMP_kernel.QuadScore___str__(self)
6805 """__repr__(QuadScore self) -> std::string"""
6806 return _IMP_kernel.QuadScore___repr__(self)
6811 return _object_cast_to_QuadScore(o)
6814 def get_type_name(self):
6815 return self.__class__.__name__
6816 def do_show(self, out):
6818 def get_version_info(self):
6820 return VersionInfo(self.__module__,
6821 __import__(self.__module__).get_module_version())
6824 __import__(self.__module__).get_module_version())
6827 return _object_cast_to_QuadScore(o)
6829 def __disown__(self):
6831 _IMP_kernel.disown_QuadScore(self)
6832 return weakref_proxy(self)
6834 def do_get_inputs(self, m, pis):
6835 """do_get_inputs(QuadScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6836 return _IMP_kernel.QuadScore_do_get_inputs(self, m, pis)
6839 def do_destroy(self):
6840 """do_destroy(QuadScore self)"""
6841 return _IMP_kernel.QuadScore_do_destroy(self)
6843 QuadScore_swigregister = _IMP_kernel.QuadScore_swigregister
6844 QuadScore_swigregister(QuadScore)
6846 class QuadPredicate(_ParticleInputs, Object):
6847 """Proxy of C++ IMP::QuadPredicate class."""
6849 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6851 def __init__(self, *args):
6853 __init__(IMP::QuadPredicate self, std::string name) -> QuadPredicate
6854 __init__(IMP::QuadPredicate self) -> QuadPredicate
6856 if self.__class__ == QuadPredicate:
6860 this = _IMP_kernel.new_QuadPredicate(_self, *args)
6862 self.this.append(this)
6863 except __builtin__.Exception:
6866 if self.__class__ != QuadPredicate:
6867 _director_objects.register(self)
6872 def get_value(self, *args):
6874 get_value(QuadPredicate self, IMP::ParticleQuad const & vt) -> int
6875 get_value(QuadPredicate self, IMP::ParticleQuadsTemp const & o) -> IMP::Ints
6877 return _IMP_kernel.QuadPredicate_get_value(self, *args)
6880 def __call__(self, m, vt):
6881 """__call__(QuadPredicate self, Model m, IMP::ParticleIndexQuad const & vt) -> int"""
6882 return _IMP_kernel.QuadPredicate___call__(self, m, vt)
6885 def get_value_index(self, *args):
6887 get_value_index(QuadPredicate self, Model m, IMP::ParticleIndexQuad const & vt) -> int
6888 get_value_index(QuadPredicate self, Model m, IMP::ParticleIndexQuads const & o) -> IMP::Ints
6890 return _IMP_kernel.QuadPredicate_get_value_index(self, *args)
6892 __swig_destroy__ = _IMP_kernel.delete_QuadPredicate
6893 __del__ =
lambda self:
None
6896 """__str__(QuadPredicate self) -> std::string"""
6897 return _IMP_kernel.QuadPredicate___str__(self)
6901 """__repr__(QuadPredicate self) -> std::string"""
6902 return _IMP_kernel.QuadPredicate___repr__(self)
6907 return _object_cast_to_QuadPredicate(o)
6910 def get_type_name(self):
6911 return self.__class__.__name__
6912 def do_show(self, out):
6914 def get_version_info(self):
6916 return VersionInfo(self.__module__,
6917 __import__(self.__module__).get_module_version())
6920 __import__(self.__module__).get_module_version())
6923 return _object_cast_to_QuadPredicate(o)
6925 def __disown__(self):
6927 _IMP_kernel.disown_QuadPredicate(self)
6928 return weakref_proxy(self)
6930 def do_get_inputs(self, m, pis):
6931 """do_get_inputs(QuadPredicate self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6932 return _IMP_kernel.QuadPredicate_do_get_inputs(self, m, pis)
6935 def do_destroy(self):
6936 """do_destroy(QuadPredicate self)"""
6937 return _IMP_kernel.QuadPredicate_do_destroy(self)
6939 QuadPredicate_swigregister = _IMP_kernel.QuadPredicate_swigregister
6940 QuadPredicate_swigregister(QuadPredicate)
6942 class QuadContainer(Container):
6943 """Proxy of C++ IMP::QuadContainer class."""
6945 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
6947 def apply_generic(self, m):
6948 """apply_generic(QuadContainer self, QuadModifier m)"""
6949 return _IMP_kernel.QuadContainer_apply_generic(self, m)
6952 def apply(self, sm):
6953 """apply(QuadContainer self, QuadModifier sm)"""
6954 return _IMP_kernel.QuadContainer_apply(self, sm)
6957 def get_range_indexes(self):
6958 """get_range_indexes(QuadContainer self) -> IMP::ParticleIndexQuads"""
6959 return _IMP_kernel.QuadContainer_get_range_indexes(self)
6962 def get_contents(self):
6963 """get_contents(QuadContainer self) -> IMP::ParticleIndexQuads const &"""
6964 return _IMP_kernel.QuadContainer_get_contents(self)
6968 """get_indexes(QuadContainer self) -> IMP::ParticleIndexQuads"""
6969 return _IMP_kernel.QuadContainer_get_indexes(self)
6972 def get(self, *args):
6974 get(QuadContainer self) -> IMP::ParticleQuadsTemp
6975 get(QuadContainer self, unsigned int i) -> IMP::ParticleQuad
6977 return _IMP_kernel.QuadContainer_get(self, *args)
6980 def get_number(self):
6981 """get_number(QuadContainer self) -> unsigned int"""
6982 return _IMP_kernel.QuadContainer_get_number(self)
6985 def get_particle_quads(self):
6986 """get_particle_quads(QuadContainer self) -> IMP::ParticleQuadsTemp"""
6987 return _IMP_kernel.QuadContainer_get_particle_quads(self)
6990 def get_particle_quad(self, i):
6991 """get_particle_quad(QuadContainer self, unsigned int i) -> IMP::ParticleQuad"""
6992 return _IMP_kernel.QuadContainer_get_particle_quad(self, i)
6995 def __init__(self, *args):
6997 __init__(IMP::QuadContainer self, Model m, std::string name) -> QuadContainer
6998 __init__(IMP::QuadContainer self, Model m) -> QuadContainer
7000 if self.__class__ == QuadContainer:
7004 this = _IMP_kernel.new_QuadContainer(_self, *args)
7006 self.this.append(this)
7007 except __builtin__.Exception:
7010 if self.__class__ != QuadContainer:
7011 _director_objects.register(self)
7016 def do_apply(self, sm):
7017 """do_apply(QuadContainer self, QuadModifier sm)"""
7018 return _IMP_kernel.QuadContainer_do_apply(self, sm)
7021 def do_get_provides_access(self):
7022 """do_get_provides_access(QuadContainer self) -> bool"""
7023 return _IMP_kernel.QuadContainer_do_get_provides_access(self)
7025 __swig_destroy__ = _IMP_kernel.delete_QuadContainer
7026 __del__ =
lambda self:
None
7029 """__str__(QuadContainer self) -> std::string"""
7030 return _IMP_kernel.QuadContainer___str__(self)
7034 """__repr__(QuadContainer self) -> std::string"""
7035 return _IMP_kernel.QuadContainer___repr__(self)
7040 return _object_cast_to_QuadContainer(o)
7043 def get_type_name(self):
7044 return self.__class__.__name__
7045 def do_show(self, out):
7047 def get_version_info(self):
7049 return VersionInfo(self.__module__,
7050 __import__(self.__module__).get_module_version())
7053 __import__(self.__module__).get_module_version())
7056 return _object_cast_to_QuadContainer(o)
7058 def __disown__(self):
7060 _IMP_kernel.disown_QuadContainer(self)
7061 return weakref_proxy(self)
7063 def do_destroy(self):
7064 """do_destroy(QuadContainer self)"""
7065 return _IMP_kernel.QuadContainer_do_destroy(self)
7068 def handle_set_has_required_score_states(self, arg0):
7069 """handle_set_has_required_score_states(QuadContainer self, bool arg0)"""
7070 return _IMP_kernel.QuadContainer_handle_set_has_required_score_states(self, arg0)
7073 def do_get_inputs(self):
7074 """do_get_inputs(QuadContainer self) -> IMP::ModelObjectsTemp"""
7075 return _IMP_kernel.QuadContainer_do_get_inputs(self)
7078 def do_get_interactions(self):
7079 """do_get_interactions(QuadContainer self) -> IMP::ModelObjectsTemps"""
7080 return _IMP_kernel.QuadContainer_do_get_interactions(self)
7083 def do_get_contents_hash(self):
7084 """do_get_contents_hash(QuadContainer self) -> std::size_t"""
7085 return _IMP_kernel.QuadContainer_do_get_contents_hash(self)
7087 QuadContainer_swigregister = _IMP_kernel.QuadContainer_swigregister
7088 QuadContainer_swigregister(QuadContainer)
7090 class _QuadContainerAdaptor(_InputAdaptor):
7091 """Proxy of C++ IMP::QuadContainerAdaptor class."""
7093 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
7094 __repr__ = _swig_repr
7096 def __init__(self, *args):
7098 __init__(IMP::QuadContainerAdaptor self) -> _QuadContainerAdaptor
7099 __init__(IMP::QuadContainerAdaptor self, QuadContainer c) -> _QuadContainerAdaptor
7100 __init__(IMP::QuadContainerAdaptor self, IMP::ParticleQuadsTemp const & t) -> _QuadContainerAdaptor
7102 this = _IMP_kernel.new__QuadContainerAdaptor(*args)
7104 self.this.append(this)
7105 except __builtin__.Exception:
7108 def set_name_if_default(self, name):
7109 """set_name_if_default(_QuadContainerAdaptor self, std::string name)"""
7110 return _IMP_kernel._QuadContainerAdaptor_set_name_if_default(self, name)
7112 __swig_destroy__ = _IMP_kernel.delete__QuadContainerAdaptor
7113 __del__ =
lambda self:
None
7114 _QuadContainerAdaptor_swigregister = _IMP_kernel._QuadContainerAdaptor_swigregister
7115 _QuadContainerAdaptor_swigregister(_QuadContainerAdaptor)
7117 class SingletonModifier(_ParticleInputs, _ParticleOutputs, Object):
7118 """Proxy of C++ IMP::SingletonModifier class."""
7120 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
7122 def __init__(self, *args):
7124 __init__(IMP::SingletonModifier self, std::string name) -> SingletonModifier
7125 __init__(IMP::SingletonModifier self) -> SingletonModifier
7127 if self.__class__ == SingletonModifier:
7131 this = _IMP_kernel.new_SingletonModifier(_self, *args)
7133 self.this.append(this)
7134 except __builtin__.Exception:
7137 if self.__class__ != SingletonModifier:
7138 _director_objects.register(self)
7143 def apply_index(self, m, v):
7144 """apply_index(SingletonModifier self, Model m, ParticleIndex v)"""
7145 return _IMP_kernel.SingletonModifier_apply_index(self, m, v)
7148 def apply_indexes(self, m, o, lower_bound, upper_bound):
7149 """apply_indexes(SingletonModifier self, Model m, IMP::ParticleIndexes const & o, unsigned int lower_bound, unsigned int upper_bound)"""
7150 return _IMP_kernel.SingletonModifier_apply_indexes(self, m, o, lower_bound, upper_bound)
7154 """__str__(SingletonModifier self) -> std::string"""
7155 return _IMP_kernel.SingletonModifier___str__(self)
7159 """__repr__(SingletonModifier self) -> std::string"""
7160 return _IMP_kernel.SingletonModifier___repr__(self)
7165 return _object_cast_to_SingletonModifier(o)
7168 def get_type_name(self):
7169 return self.__class__.__name__
7170 def do_show(self, out):
7172 def get_version_info(self):
7174 return VersionInfo(self.__module__,
7175 __import__(self.__module__).get_module_version())
7178 __import__(self.__module__).get_module_version())
7181 return _object_cast_to_SingletonModifier(o)
7183 __swig_destroy__ = _IMP_kernel.delete_SingletonModifier
7184 __del__ =
lambda self:
None
7185 def __disown__(self):
7187 _IMP_kernel.disown_SingletonModifier(self)
7188 return weakref_proxy(self)
7190 def do_get_inputs(self, m, pis):
7191 """do_get_inputs(SingletonModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7192 return _IMP_kernel.SingletonModifier_do_get_inputs(self, m, pis)
7195 def do_get_outputs(self, m, pis):
7196 """do_get_outputs(SingletonModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7197 return _IMP_kernel.SingletonModifier_do_get_outputs(self, m, pis)
7200 def do_destroy(self):
7201 """do_destroy(SingletonModifier self)"""
7202 return _IMP_kernel.SingletonModifier_do_destroy(self)
7204 SingletonModifier_swigregister = _IMP_kernel.SingletonModifier_swigregister
7205 SingletonModifier_swigregister(SingletonModifier)
7207 class SingletonScore(_ParticleInputs, Object):
7208 """Proxy of C++ IMP::SingletonScore class."""
7210 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
7212 def __init__(self, *args):
7214 __init__(IMP::SingletonScore self, std::string name) -> SingletonScore
7215 __init__(IMP::SingletonScore self) -> SingletonScore
7217 if self.__class__ == SingletonScore:
7221 this = _IMP_kernel.new_SingletonScore(_self, *args)
7223 self.this.append(this)
7224 except __builtin__.Exception:
7227 if self.__class__ != SingletonScore:
7228 _director_objects.register(self)
7233 def evaluate_index(self, m, vt, da):
7234 """evaluate_index(SingletonScore self, Model m, ParticleIndex vt, DerivativeAccumulator da) -> double"""
7235 return _IMP_kernel.SingletonScore_evaluate_index(self, m, vt, da)
7238 def evaluate_indexes(self, m, o, da, lower_bound, upper_bound):
7239 """evaluate_indexes(SingletonScore self, Model m, IMP::ParticleIndexes const & o, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound) -> double"""
7240 return _IMP_kernel.SingletonScore_evaluate_indexes(self, m, o, da, lower_bound, upper_bound)
7243 def evaluate_if_good_index(self, m, vt, da, max):
7244 """evaluate_if_good_index(SingletonScore self, Model m, ParticleIndex vt, DerivativeAccumulator da, double max) -> double"""
7245 return _IMP_kernel.SingletonScore_evaluate_if_good_index(self, m, vt, da, max)
7248 def evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound):
7249 """evaluate_if_good_indexes(SingletonScore self, Model m, IMP::ParticleIndexes const & o, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound) -> double"""
7250 return _IMP_kernel.SingletonScore_evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound)
7253 def create_current_decomposition(self, m, vt):
7254 """create_current_decomposition(SingletonScore self, Model m, ParticleIndex vt) -> IMP::Restraints"""
7255 return _IMP_kernel.SingletonScore_create_current_decomposition(self, m, vt)
7258 def do_create_current_decomposition(self, m, vt):
7259 """do_create_current_decomposition(SingletonScore self, Model m, ParticleIndex vt) -> IMP::Restraints"""
7260 return _IMP_kernel.SingletonScore_do_create_current_decomposition(self, m, vt)
7262 __swig_destroy__ = _IMP_kernel.delete_SingletonScore
7263 __del__ =
lambda self:
None
7266 """__str__(SingletonScore self) -> std::string"""
7267 return _IMP_kernel.SingletonScore___str__(self)
7271 """__repr__(SingletonScore self) -> std::string"""
7272 return _IMP_kernel.SingletonScore___repr__(self)
7277 return _object_cast_to_SingletonScore(o)
7280 def get_type_name(self):
7281 return self.__class__.__name__
7282 def do_show(self, out):
7284 def get_version_info(self):
7286 return VersionInfo(self.__module__,
7287 __import__(self.__module__).get_module_version())
7290 __import__(self.__module__).get_module_version())
7293 return _object_cast_to_SingletonScore(o)
7295 def __disown__(self):
7297 _IMP_kernel.disown_SingletonScore(self)
7298 return weakref_proxy(self)
7300 def do_get_inputs(self, m, pis):
7301 """do_get_inputs(SingletonScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7302 return _IMP_kernel.SingletonScore_do_get_inputs(self, m, pis)
7305 def do_destroy(self):
7306 """do_destroy(SingletonScore self)"""
7307 return _IMP_kernel.SingletonScore_do_destroy(self)
7309 SingletonScore_swigregister = _IMP_kernel.SingletonScore_swigregister
7310 SingletonScore_swigregister(SingletonScore)
7312 class SingletonPredicate(_ParticleInputs, Object):
7313 """Proxy of C++ IMP::SingletonPredicate class."""
7315 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
7317 def __init__(self, *args):
7319 __init__(IMP::SingletonPredicate self, std::string name) -> SingletonPredicate
7320 __init__(IMP::SingletonPredicate self) -> SingletonPredicate
7322 if self.__class__ == SingletonPredicate:
7326 this = _IMP_kernel.new_SingletonPredicate(_self, *args)
7328 self.this.append(this)
7329 except __builtin__.Exception:
7332 if self.__class__ != SingletonPredicate:
7333 _director_objects.register(self)
7338 def get_value(self, *args):
7340 get_value(SingletonPredicate self, Particle vt) -> int
7341 get_value(SingletonPredicate self, IMP::ParticlesTemp const & o) -> IMP::Ints
7343 return _IMP_kernel.SingletonPredicate_get_value(self, *args)
7346 def __call__(self, m, vt):
7347 """__call__(SingletonPredicate self, Model m, ParticleIndex vt) -> int"""
7348 return _IMP_kernel.SingletonPredicate___call__(self, m, vt)
7351 def get_value_index(self, *args):
7353 get_value_index(SingletonPredicate self, Model m, ParticleIndex vt) -> int
7354 get_value_index(SingletonPredicate self, Model m, IMP::ParticleIndexes const & o) -> IMP::Ints
7356 return _IMP_kernel.SingletonPredicate_get_value_index(self, *args)
7358 __swig_destroy__ = _IMP_kernel.delete_SingletonPredicate
7359 __del__ =
lambda self:
None
7362 """__str__(SingletonPredicate self) -> std::string"""
7363 return _IMP_kernel.SingletonPredicate___str__(self)
7367 """__repr__(SingletonPredicate self) -> std::string"""
7368 return _IMP_kernel.SingletonPredicate___repr__(self)
7373 return _object_cast_to_SingletonPredicate(o)
7376 def get_type_name(self):
7377 return self.__class__.__name__
7378 def do_show(self, out):
7380 def get_version_info(self):
7382 return VersionInfo(self.__module__,
7383 __import__(self.__module__).get_module_version())
7386 __import__(self.__module__).get_module_version())
7389 return _object_cast_to_SingletonPredicate(o)
7391 def __disown__(self):
7393 _IMP_kernel.disown_SingletonPredicate(self)
7394 return weakref_proxy(self)
7396 def do_get_inputs(self, m, pis):
7397 """do_get_inputs(SingletonPredicate self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7398 return _IMP_kernel.SingletonPredicate_do_get_inputs(self, m, pis)
7401 def do_destroy(self):
7402 """do_destroy(SingletonPredicate self)"""
7403 return _IMP_kernel.SingletonPredicate_do_destroy(self)
7405 SingletonPredicate_swigregister = _IMP_kernel.SingletonPredicate_swigregister
7406 SingletonPredicate_swigregister(SingletonPredicate)
7408 class SingletonContainer(Container):
7409 """Proxy of C++ IMP::SingletonContainer class."""
7411 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
7413 def apply_generic(self, m):
7414 """apply_generic(SingletonContainer self, SingletonModifier m)"""
7415 return _IMP_kernel.SingletonContainer_apply_generic(self, m)
7418 def apply(self, sm):
7419 """apply(SingletonContainer self, SingletonModifier sm)"""
7420 return _IMP_kernel.SingletonContainer_apply(self, sm)
7423 def get_range_indexes(self):
7424 """get_range_indexes(SingletonContainer self) -> IMP::ParticleIndexes"""
7425 return _IMP_kernel.SingletonContainer_get_range_indexes(self)
7428 def get_contents(self):
7429 """get_contents(SingletonContainer self) -> IMP::ParticleIndexes const &"""
7430 return _IMP_kernel.SingletonContainer_get_contents(self)
7434 """get_indexes(SingletonContainer self) -> IMP::ParticleIndexes"""
7435 return _IMP_kernel.SingletonContainer_get_indexes(self)
7438 def get(self, *args):
7440 get(SingletonContainer self) -> IMP::ParticlesTemp
7441 get(SingletonContainer self, unsigned int i) -> Particle
7443 return _IMP_kernel.SingletonContainer_get(self, *args)
7446 def get_number(self):
7447 """get_number(SingletonContainer self) -> unsigned int"""
7448 return _IMP_kernel.SingletonContainer_get_number(self)
7452 """get_particles(SingletonContainer self) -> IMP::ParticlesTemp"""
7453 return _IMP_kernel.SingletonContainer_get_particles(self)
7456 def get_particle(self, i):
7457 """get_particle(SingletonContainer self, unsigned int i) -> Particle"""
7458 return _IMP_kernel.SingletonContainer_get_particle(self, i)
7461 def __init__(self, *args):
7463 __init__(IMP::SingletonContainer self, Model m, std::string name) -> SingletonContainer
7464 __init__(IMP::SingletonContainer self, Model m) -> SingletonContainer
7466 if self.__class__ == SingletonContainer:
7470 this = _IMP_kernel.new_SingletonContainer(_self, *args)
7472 self.this.append(this)
7473 except __builtin__.Exception:
7476 if self.__class__ != SingletonContainer:
7477 _director_objects.register(self)
7482 def do_apply(self, sm):
7483 """do_apply(SingletonContainer self, SingletonModifier sm)"""
7484 return _IMP_kernel.SingletonContainer_do_apply(self, sm)
7487 def do_get_provides_access(self):
7488 """do_get_provides_access(SingletonContainer self) -> bool"""
7489 return _IMP_kernel.SingletonContainer_do_get_provides_access(self)
7491 __swig_destroy__ = _IMP_kernel.delete_SingletonContainer
7492 __del__ =
lambda self:
None
7495 """__str__(SingletonContainer self) -> std::string"""
7496 return _IMP_kernel.SingletonContainer___str__(self)
7500 """__repr__(SingletonContainer self) -> std::string"""
7501 return _IMP_kernel.SingletonContainer___repr__(self)
7506 return _object_cast_to_SingletonContainer(o)
7509 def get_type_name(self):
7510 return self.__class__.__name__
7511 def do_show(self, out):
7513 def get_version_info(self):
7515 return VersionInfo(self.__module__,
7516 __import__(self.__module__).get_module_version())
7519 __import__(self.__module__).get_module_version())
7522 return _object_cast_to_SingletonContainer(o)
7524 def __disown__(self):
7526 _IMP_kernel.disown_SingletonContainer(self)
7527 return weakref_proxy(self)
7529 def do_destroy(self):
7530 """do_destroy(SingletonContainer self)"""
7531 return _IMP_kernel.SingletonContainer_do_destroy(self)
7534 def handle_set_has_required_score_states(self, arg0):
7535 """handle_set_has_required_score_states(SingletonContainer self, bool arg0)"""
7536 return _IMP_kernel.SingletonContainer_handle_set_has_required_score_states(self, arg0)
7539 def do_get_inputs(self):
7540 """do_get_inputs(SingletonContainer self) -> IMP::ModelObjectsTemp"""
7541 return _IMP_kernel.SingletonContainer_do_get_inputs(self)
7544 def do_get_interactions(self):
7545 """do_get_interactions(SingletonContainer self) -> IMP::ModelObjectsTemps"""
7546 return _IMP_kernel.SingletonContainer_do_get_interactions(self)
7549 def do_get_contents_hash(self):
7550 """do_get_contents_hash(SingletonContainer self) -> std::size_t"""
7551 return _IMP_kernel.SingletonContainer_do_get_contents_hash(self)
7553 SingletonContainer_swigregister = _IMP_kernel.SingletonContainer_swigregister
7554 SingletonContainer_swigregister(SingletonContainer)
7556 class _SingletonContainerAdaptor(_InputAdaptor):
7557 """Proxy of C++ IMP::SingletonContainerAdaptor class."""
7559 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
7560 __repr__ = _swig_repr
7562 def __init__(self, *args):
7564 __init__(IMP::SingletonContainerAdaptor self) -> _SingletonContainerAdaptor
7565 __init__(IMP::SingletonContainerAdaptor self, SingletonContainer c) -> _SingletonContainerAdaptor
7566 __init__(IMP::SingletonContainerAdaptor self, IMP::ParticlesTemp const & t) -> _SingletonContainerAdaptor
7568 this = _IMP_kernel.new__SingletonContainerAdaptor(*args)
7570 self.this.append(this)
7571 except __builtin__.Exception:
7574 def set_name_if_default(self, name):
7575 """set_name_if_default(_SingletonContainerAdaptor self, std::string name)"""
7576 return _IMP_kernel._SingletonContainerAdaptor_set_name_if_default(self, name)
7578 __swig_destroy__ = _IMP_kernel.delete__SingletonContainerAdaptor
7579 __del__ =
lambda self:
None
7580 _SingletonContainerAdaptor_swigregister = _IMP_kernel._SingletonContainerAdaptor_swigregister
7581 _SingletonContainerAdaptor_swigregister(_SingletonContainerAdaptor)
7583 class TripletModifier(_ParticleInputs, _ParticleOutputs, Object):
7584 """Proxy of C++ IMP::TripletModifier class."""
7586 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
7588 def __init__(self, *args):
7590 __init__(IMP::TripletModifier self, std::string name) -> TripletModifier
7591 __init__(IMP::TripletModifier self) -> TripletModifier
7593 if self.__class__ == TripletModifier:
7597 this = _IMP_kernel.new_TripletModifier(_self, *args)
7599 self.this.append(this)
7600 except __builtin__.Exception:
7603 if self.__class__ != TripletModifier:
7604 _director_objects.register(self)
7609 def apply_index(self, m, v):
7610 """apply_index(TripletModifier self, Model m, IMP::ParticleIndexTriplet const & v)"""
7611 return _IMP_kernel.TripletModifier_apply_index(self, m, v)
7614 def apply_indexes(self, m, o, lower_bound, upper_bound):
7615 """apply_indexes(TripletModifier self, Model m, IMP::ParticleIndexTriplets const & o, unsigned int lower_bound, unsigned int upper_bound)"""
7616 return _IMP_kernel.TripletModifier_apply_indexes(self, m, o, lower_bound, upper_bound)
7620 """__str__(TripletModifier self) -> std::string"""
7621 return _IMP_kernel.TripletModifier___str__(self)
7625 """__repr__(TripletModifier self) -> std::string"""
7626 return _IMP_kernel.TripletModifier___repr__(self)
7631 return _object_cast_to_TripletModifier(o)
7634 def get_type_name(self):
7635 return self.__class__.__name__
7636 def do_show(self, out):
7638 def get_version_info(self):
7640 return VersionInfo(self.__module__,
7641 __import__(self.__module__).get_module_version())
7644 __import__(self.__module__).get_module_version())
7647 return _object_cast_to_TripletModifier(o)
7649 __swig_destroy__ = _IMP_kernel.delete_TripletModifier
7650 __del__ =
lambda self:
None
7651 def __disown__(self):
7653 _IMP_kernel.disown_TripletModifier(self)
7654 return weakref_proxy(self)
7656 def do_get_inputs(self, m, pis):
7657 """do_get_inputs(TripletModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7658 return _IMP_kernel.TripletModifier_do_get_inputs(self, m, pis)
7661 def do_get_outputs(self, m, pis):
7662 """do_get_outputs(TripletModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7663 return _IMP_kernel.TripletModifier_do_get_outputs(self, m, pis)
7666 def do_destroy(self):
7667 """do_destroy(TripletModifier self)"""
7668 return _IMP_kernel.TripletModifier_do_destroy(self)
7670 TripletModifier_swigregister = _IMP_kernel.TripletModifier_swigregister
7671 TripletModifier_swigregister(TripletModifier)
7673 class TripletScore(_ParticleInputs, Object):
7674 """Proxy of C++ IMP::TripletScore class."""
7676 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
7678 def __init__(self, *args):
7680 __init__(IMP::TripletScore self, std::string name) -> TripletScore
7681 __init__(IMP::TripletScore self) -> TripletScore
7683 if self.__class__ == TripletScore:
7687 this = _IMP_kernel.new_TripletScore(_self, *args)
7689 self.this.append(this)
7690 except __builtin__.Exception:
7693 if self.__class__ != TripletScore:
7694 _director_objects.register(self)
7699 def evaluate_index(self, m, vt, da):
7700 """evaluate_index(TripletScore self, Model m, IMP::ParticleIndexTriplet const & vt, DerivativeAccumulator da) -> double"""
7701 return _IMP_kernel.TripletScore_evaluate_index(self, m, vt, da)
7704 def evaluate_indexes(self, m, o, da, lower_bound, upper_bound):
7705 """evaluate_indexes(TripletScore self, Model m, IMP::ParticleIndexTriplets const & o, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound) -> double"""
7706 return _IMP_kernel.TripletScore_evaluate_indexes(self, m, o, da, lower_bound, upper_bound)
7709 def evaluate_if_good_index(self, m, vt, da, max):
7710 """evaluate_if_good_index(TripletScore self, Model m, IMP::ParticleIndexTriplet const & vt, DerivativeAccumulator da, double max) -> double"""
7711 return _IMP_kernel.TripletScore_evaluate_if_good_index(self, m, vt, da, max)
7714 def evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound):
7715 """evaluate_if_good_indexes(TripletScore self, Model m, IMP::ParticleIndexTriplets const & o, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound) -> double"""
7716 return _IMP_kernel.TripletScore_evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound)
7719 def create_current_decomposition(self, m, vt):
7720 """create_current_decomposition(TripletScore self, Model m, IMP::ParticleIndexTriplet const & vt) -> IMP::Restraints"""
7721 return _IMP_kernel.TripletScore_create_current_decomposition(self, m, vt)
7724 def do_create_current_decomposition(self, m, vt):
7725 """do_create_current_decomposition(TripletScore self, Model m, IMP::ParticleIndexTriplet const & vt) -> IMP::Restraints"""
7726 return _IMP_kernel.TripletScore_do_create_current_decomposition(self, m, vt)
7728 __swig_destroy__ = _IMP_kernel.delete_TripletScore
7729 __del__ =
lambda self:
None
7732 """__str__(TripletScore self) -> std::string"""
7733 return _IMP_kernel.TripletScore___str__(self)
7737 """__repr__(TripletScore self) -> std::string"""
7738 return _IMP_kernel.TripletScore___repr__(self)
7743 return _object_cast_to_TripletScore(o)
7746 def get_type_name(self):
7747 return self.__class__.__name__
7748 def do_show(self, out):
7750 def get_version_info(self):
7752 return VersionInfo(self.__module__,
7753 __import__(self.__module__).get_module_version())
7756 __import__(self.__module__).get_module_version())
7759 return _object_cast_to_TripletScore(o)
7761 def __disown__(self):
7763 _IMP_kernel.disown_TripletScore(self)
7764 return weakref_proxy(self)
7766 def do_get_inputs(self, m, pis):
7767 """do_get_inputs(TripletScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7768 return _IMP_kernel.TripletScore_do_get_inputs(self, m, pis)
7771 def do_destroy(self):
7772 """do_destroy(TripletScore self)"""
7773 return _IMP_kernel.TripletScore_do_destroy(self)
7775 TripletScore_swigregister = _IMP_kernel.TripletScore_swigregister
7776 TripletScore_swigregister(TripletScore)
7778 class TripletPredicate(_ParticleInputs, Object):
7779 """Proxy of C++ IMP::TripletPredicate class."""
7781 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
7783 def __init__(self, *args):
7785 __init__(IMP::TripletPredicate self, std::string name) -> TripletPredicate
7786 __init__(IMP::TripletPredicate self) -> TripletPredicate
7788 if self.__class__ == TripletPredicate:
7792 this = _IMP_kernel.new_TripletPredicate(_self, *args)
7794 self.this.append(this)
7795 except __builtin__.Exception:
7798 if self.__class__ != TripletPredicate:
7799 _director_objects.register(self)
7804 def get_value(self, *args):
7806 get_value(TripletPredicate self, IMP::ParticleTriplet const & vt) -> int
7807 get_value(TripletPredicate self, IMP::ParticleTripletsTemp const & o) -> IMP::Ints
7809 return _IMP_kernel.TripletPredicate_get_value(self, *args)
7812 def __call__(self, m, vt):
7813 """__call__(TripletPredicate self, Model m, IMP::ParticleIndexTriplet const & vt) -> int"""
7814 return _IMP_kernel.TripletPredicate___call__(self, m, vt)
7817 def get_value_index(self, *args):
7819 get_value_index(TripletPredicate self, Model m, IMP::ParticleIndexTriplet const & vt) -> int
7820 get_value_index(TripletPredicate self, Model m, IMP::ParticleIndexTriplets const & o) -> IMP::Ints
7822 return _IMP_kernel.TripletPredicate_get_value_index(self, *args)
7824 __swig_destroy__ = _IMP_kernel.delete_TripletPredicate
7825 __del__ =
lambda self:
None
7828 """__str__(TripletPredicate self) -> std::string"""
7829 return _IMP_kernel.TripletPredicate___str__(self)
7833 """__repr__(TripletPredicate self) -> std::string"""
7834 return _IMP_kernel.TripletPredicate___repr__(self)
7839 return _object_cast_to_TripletPredicate(o)
7842 def get_type_name(self):
7843 return self.__class__.__name__
7844 def do_show(self, out):
7846 def get_version_info(self):
7848 return VersionInfo(self.__module__,
7849 __import__(self.__module__).get_module_version())
7852 __import__(self.__module__).get_module_version())
7855 return _object_cast_to_TripletPredicate(o)
7857 def __disown__(self):
7859 _IMP_kernel.disown_TripletPredicate(self)
7860 return weakref_proxy(self)
7862 def do_get_inputs(self, m, pis):
7863 """do_get_inputs(TripletPredicate self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7864 return _IMP_kernel.TripletPredicate_do_get_inputs(self, m, pis)
7867 def do_destroy(self):
7868 """do_destroy(TripletPredicate self)"""
7869 return _IMP_kernel.TripletPredicate_do_destroy(self)
7871 TripletPredicate_swigregister = _IMP_kernel.TripletPredicate_swigregister
7872 TripletPredicate_swigregister(TripletPredicate)
7874 class TripletContainer(Container):
7875 """Proxy of C++ IMP::TripletContainer class."""
7877 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
7879 def apply_generic(self, m):
7880 """apply_generic(TripletContainer self, TripletModifier m)"""
7881 return _IMP_kernel.TripletContainer_apply_generic(self, m)
7884 def apply(self, sm):
7885 """apply(TripletContainer self, TripletModifier sm)"""
7886 return _IMP_kernel.TripletContainer_apply(self, sm)
7889 def get_range_indexes(self):
7890 """get_range_indexes(TripletContainer self) -> IMP::ParticleIndexTriplets"""
7891 return _IMP_kernel.TripletContainer_get_range_indexes(self)
7894 def get_contents(self):
7895 """get_contents(TripletContainer self) -> IMP::ParticleIndexTriplets const &"""
7896 return _IMP_kernel.TripletContainer_get_contents(self)
7900 """get_indexes(TripletContainer self) -> IMP::ParticleIndexTriplets"""
7901 return _IMP_kernel.TripletContainer_get_indexes(self)
7904 def get(self, *args):
7906 get(TripletContainer self) -> IMP::ParticleTripletsTemp
7907 get(TripletContainer self, unsigned int i) -> IMP::ParticleTriplet
7909 return _IMP_kernel.TripletContainer_get(self, *args)
7912 def get_number(self):
7913 """get_number(TripletContainer self) -> unsigned int"""
7914 return _IMP_kernel.TripletContainer_get_number(self)
7917 def get_particle_triplets(self):
7918 """get_particle_triplets(TripletContainer self) -> IMP::ParticleTripletsTemp"""
7919 return _IMP_kernel.TripletContainer_get_particle_triplets(self)
7922 def get_particle_triplet(self, i):
7923 """get_particle_triplet(TripletContainer self, unsigned int i) -> IMP::ParticleTriplet"""
7924 return _IMP_kernel.TripletContainer_get_particle_triplet(self, i)
7927 def __init__(self, *args):
7929 __init__(IMP::TripletContainer self, Model m, std::string name) -> TripletContainer
7930 __init__(IMP::TripletContainer self, Model m) -> TripletContainer
7932 if self.__class__ == TripletContainer:
7936 this = _IMP_kernel.new_TripletContainer(_self, *args)
7938 self.this.append(this)
7939 except __builtin__.Exception:
7942 if self.__class__ != TripletContainer:
7943 _director_objects.register(self)
7948 def do_apply(self, sm):
7949 """do_apply(TripletContainer self, TripletModifier sm)"""
7950 return _IMP_kernel.TripletContainer_do_apply(self, sm)
7953 def do_get_provides_access(self):
7954 """do_get_provides_access(TripletContainer self) -> bool"""
7955 return _IMP_kernel.TripletContainer_do_get_provides_access(self)
7957 __swig_destroy__ = _IMP_kernel.delete_TripletContainer
7958 __del__ =
lambda self:
None
7961 """__str__(TripletContainer self) -> std::string"""
7962 return _IMP_kernel.TripletContainer___str__(self)
7966 """__repr__(TripletContainer self) -> std::string"""
7967 return _IMP_kernel.TripletContainer___repr__(self)
7972 return _object_cast_to_TripletContainer(o)
7975 def get_type_name(self):
7976 return self.__class__.__name__
7977 def do_show(self, out):
7979 def get_version_info(self):
7981 return VersionInfo(self.__module__,
7982 __import__(self.__module__).get_module_version())
7985 __import__(self.__module__).get_module_version())
7988 return _object_cast_to_TripletContainer(o)
7990 def __disown__(self):
7992 _IMP_kernel.disown_TripletContainer(self)
7993 return weakref_proxy(self)
7995 def do_destroy(self):
7996 """do_destroy(TripletContainer self)"""
7997 return _IMP_kernel.TripletContainer_do_destroy(self)
8000 def handle_set_has_required_score_states(self, arg0):
8001 """handle_set_has_required_score_states(TripletContainer self, bool arg0)"""
8002 return _IMP_kernel.TripletContainer_handle_set_has_required_score_states(self, arg0)
8005 def do_get_inputs(self):
8006 """do_get_inputs(TripletContainer self) -> IMP::ModelObjectsTemp"""
8007 return _IMP_kernel.TripletContainer_do_get_inputs(self)
8010 def do_get_interactions(self):
8011 """do_get_interactions(TripletContainer self) -> IMP::ModelObjectsTemps"""
8012 return _IMP_kernel.TripletContainer_do_get_interactions(self)
8015 def do_get_contents_hash(self):
8016 """do_get_contents_hash(TripletContainer self) -> std::size_t"""
8017 return _IMP_kernel.TripletContainer_do_get_contents_hash(self)
8019 TripletContainer_swigregister = _IMP_kernel.TripletContainer_swigregister
8020 TripletContainer_swigregister(TripletContainer)
8022 class _TripletContainerAdaptor(_InputAdaptor):
8023 """Proxy of C++ IMP::TripletContainerAdaptor class."""
8025 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
8026 __repr__ = _swig_repr
8028 def __init__(self, *args):
8030 __init__(IMP::TripletContainerAdaptor self) -> _TripletContainerAdaptor
8031 __init__(IMP::TripletContainerAdaptor self, TripletContainer c) -> _TripletContainerAdaptor
8032 __init__(IMP::TripletContainerAdaptor self, IMP::ParticleTripletsTemp const & t) -> _TripletContainerAdaptor
8034 this = _IMP_kernel.new__TripletContainerAdaptor(*args)
8036 self.this.append(this)
8037 except __builtin__.Exception:
8040 def set_name_if_default(self, name):
8041 """set_name_if_default(_TripletContainerAdaptor self, std::string name)"""
8042 return _IMP_kernel._TripletContainerAdaptor_set_name_if_default(self, name)
8044 __swig_destroy__ = _IMP_kernel.delete__TripletContainerAdaptor
8045 __del__ =
lambda self:
None
8046 _TripletContainerAdaptor_swigregister = _IMP_kernel._TripletContainerAdaptor_swigregister
8047 _TripletContainerAdaptor_swigregister(_TripletContainerAdaptor)
8051 """write_particles_to_buffer(IMP::ParticlesTemp const & particles, IMP::FloatKeys const & keys) -> IMP::Vector< char >"""
8052 return _IMP_kernel.write_particles_to_buffer(particles, keys)
8055 """read_particles_from_buffer(IMP::Vector< char > const & buffer, IMP::ParticlesTemp const & particles, IMP::FloatKeys const & keys)"""
8056 return _IMP_kernel.read_particles_from_buffer(buffer, particles, keys)
8059 """get_particles(Model m, IMP::ParticleIndexes const & ps) -> IMP::ParticlesTemp"""
8060 return _IMP_kernel.get_particles(m, ps)
8064 get_indexes(IMP::ParticlesTemp const & ps) -> IMP::ParticleIndexes
8065 get_indexes(IMP::ParticlePairsTemp const & ps) -> IMP::ParticleIndexPairs
8067 return _IMP_kernel.get_indexes(*args)
8068 class _ParticleIndexAdaptor(object):
8069 """Proxy of C++ IMP::ParticleIndexAdaptor class."""
8071 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
8072 __repr__ = _swig_repr
8074 def __init__(self, *args):
8076 __init__(IMP::ParticleIndexAdaptor self, Particle p) -> _ParticleIndexAdaptor
8077 __init__(IMP::ParticleIndexAdaptor self, ParticleIndex pi) -> _ParticleIndexAdaptor
8078 __init__(IMP::ParticleIndexAdaptor self, Decorator d) -> _ParticleIndexAdaptor
8080 this = _IMP_kernel.new__ParticleIndexAdaptor(*args)
8082 self.this.append(this)
8083 except __builtin__.Exception:
8085 __swig_destroy__ = _IMP_kernel.delete__ParticleIndexAdaptor
8086 __del__ =
lambda self:
None
8087 _ParticleIndexAdaptor_swigregister = _IMP_kernel._ParticleIndexAdaptor_swigregister
8088 _ParticleIndexAdaptor_swigregister(_ParticleIndexAdaptor)
8090 class _ParticleIndexesAdaptor(_InputAdaptor):
8091 """Proxy of C++ IMP::ParticleIndexesAdaptor class."""
8093 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
8094 __repr__ = _swig_repr
8096 def __init__(self, *args):
8098 __init__(IMP::ParticleIndexesAdaptor self, IMP::ParticlesTemp const & ps) -> _ParticleIndexesAdaptor
8099 __init__(IMP::ParticleIndexesAdaptor self, IMP::ParticleIndexes const & pi) -> _ParticleIndexesAdaptor
8100 __init__(IMP::ParticleIndexesAdaptor self) -> _ParticleIndexesAdaptor
8102 this = _IMP_kernel.new__ParticleIndexesAdaptor(*args)
8104 self.this.append(this)
8105 except __builtin__.Exception:
8107 __swig_destroy__ = _IMP_kernel.delete__ParticleIndexesAdaptor
8108 __del__ =
lambda self:
None
8109 _ParticleIndexesAdaptor_swigregister = _IMP_kernel._ParticleIndexesAdaptor_swigregister
8110 _ParticleIndexesAdaptor_swigregister(_ParticleIndexesAdaptor)
8112 class _ParticleIndexPairsAdaptor(object):
8113 """Proxy of C++ IMP::ParticleIndexPairsAdaptor class."""
8115 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
8116 __repr__ = _swig_repr
8118 def __init__(self, *args):
8120 __init__(IMP::ParticleIndexPairsAdaptor self, IMP::ParticlePairsTemp const & ps) -> _ParticleIndexPairsAdaptor
8121 __init__(IMP::ParticleIndexPairsAdaptor self, IMP::ParticleIndexPairs const & pi) -> _ParticleIndexPairsAdaptor
8122 __init__(IMP::ParticleIndexPairsAdaptor self) -> _ParticleIndexPairsAdaptor
8124 this = _IMP_kernel.new__ParticleIndexPairsAdaptor(*args)
8126 self.this.append(this)
8127 except __builtin__.Exception:
8129 __swig_destroy__ = _IMP_kernel.delete__ParticleIndexPairsAdaptor
8130 __del__ =
lambda self:
None
8131 _ParticleIndexPairsAdaptor_swigregister = _IMP_kernel._ParticleIndexPairsAdaptor_swigregister
8132 _ParticleIndexPairsAdaptor_swigregister(_ParticleIndexPairsAdaptor)
8134 class _ConstRestraint(Restraint):
8135 """Proxy of C++ IMP::internal::_ConstRestraint class."""
8137 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
8139 def __init__(self, *args):
8141 __init__(IMP::internal::_ConstRestraint self, double v, IMP::ParticlesTemp const ps) -> _ConstRestraint
8142 __init__(IMP::internal::_ConstRestraint self, Model m, IMP::ParticleIndexes const & pis, double v) -> _ConstRestraint
8144 this = _IMP_kernel.new__ConstRestraint(*args)
8146 self.this.append(this)
8147 except __builtin__.Exception:
8150 def get_value(self):
8151 """get_value(_ConstRestraint self) -> double"""
8152 return _IMP_kernel._ConstRestraint_get_value(self)
8155 def do_create_decomposition(self):
8156 """do_create_decomposition(_ConstRestraint self) -> IMP::Restraints"""
8157 return _IMP_kernel._ConstRestraint_do_create_decomposition(self)
8160 def do_get_inputs(self):
8161 """do_get_inputs(_ConstRestraint self) -> IMP::ModelObjectsTemp"""
8162 return _IMP_kernel._ConstRestraint_do_get_inputs(self)
8165 def get_version_info(self):
8166 """get_version_info(_ConstRestraint self) -> VersionInfo"""
8167 return _IMP_kernel._ConstRestraint_get_version_info(self)
8171 """__str__(_ConstRestraint self) -> std::string"""
8172 return _IMP_kernel._ConstRestraint___str__(self)
8176 """__repr__(_ConstRestraint self) -> std::string"""
8177 return _IMP_kernel._ConstRestraint___repr__(self)
8182 return _object_cast_to__ConstRestraint(o)
8184 _ConstRestraint_swigregister = _IMP_kernel._ConstRestraint_swigregister
8185 _ConstRestraint_swigregister(_ConstRestraint)
8187 class _ConstSingletonScore(SingletonScore):
8188 """Proxy of C++ IMP::internal::_ConstSingletonScore class."""
8190 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
8191 __repr__ = _swig_repr
8193 def __init__(self, v):
8194 """__init__(IMP::internal::_ConstSingletonScore self, double v) -> _ConstSingletonScore"""
8195 this = _IMP_kernel.new__ConstSingletonScore(v)
8197 self.this.append(this)
8198 except __builtin__.Exception:
8201 def do_get_inputs(self, arg2, arg3):
8202 """do_get_inputs(_ConstSingletonScore self, Model arg2, IMP::ParticleIndexes const & arg3) -> IMP::ModelObjectsTemp"""
8203 return _IMP_kernel._ConstSingletonScore_do_get_inputs(self, arg2, arg3)
8206 def get_version_info(self):
8207 """get_version_info(_ConstSingletonScore self) -> VersionInfo"""
8208 return _IMP_kernel._ConstSingletonScore_get_version_info(self)
8210 _ConstSingletonScore_swigregister = _IMP_kernel._ConstSingletonScore_swigregister
8211 _ConstSingletonScore_swigregister(_ConstSingletonScore)
8213 class _ConstPairScore(PairScore):
8214 """Proxy of C++ IMP::internal::_ConstPairScore class."""
8216 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
8217 __repr__ = _swig_repr
8219 def __init__(self, v):
8220 """__init__(IMP::internal::_ConstPairScore self, double v) -> _ConstPairScore"""
8221 this = _IMP_kernel.new__ConstPairScore(v)
8223 self.this.append(this)
8224 except __builtin__.Exception:
8227 def do_get_inputs(self, arg2, arg3):
8228 """do_get_inputs(_ConstPairScore self, Model arg2, IMP::ParticleIndexes const & arg3) -> IMP::ModelObjectsTemp"""
8229 return _IMP_kernel._ConstPairScore_do_get_inputs(self, arg2, arg3)
8232 def get_version_info(self):
8233 """get_version_info(_ConstPairScore self) -> VersionInfo"""
8234 return _IMP_kernel._ConstPairScore_get_version_info(self)
8236 _ConstPairScore_swigregister = _IMP_kernel._ConstPairScore_swigregister
8237 _ConstPairScore_swigregister(_ConstPairScore)
8239 class _TrivialDecorator(Decorator):
8240 """Proxy of C++ IMP::internal::_TrivialDecorator class."""
8242 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
8244 def __init__(self, *args):
8246 __init__(IMP::internal::_TrivialDecorator self) -> _TrivialDecorator
8247 __init__(IMP::internal::_TrivialDecorator self, Model m, ParticleIndex id) -> _TrivialDecorator
8248 __init__(IMP::internal::_TrivialDecorator self, _ParticleAdaptor d) -> _TrivialDecorator
8250 this = _IMP_kernel.new__TrivialDecorator(*args)
8252 self.this.append(this)
8253 except __builtin__.Exception:
8256 def show(self, *args):
8258 show(_TrivialDecorator self, _ostream out)
8259 show(_TrivialDecorator self)
8261 return _IMP_kernel._TrivialDecorator_show(self, *args)
8264 def setup_particle(*args):
8266 setup_particle(Model m, ParticleIndex pi) -> _TrivialDecorator
8267 setup_particle(_ParticleAdaptor decorator) -> _TrivialDecorator
8269 return _IMP_kernel._TrivialDecorator_setup_particle(*args)
8271 setup_particle = staticmethod(setup_particle)
8273 def get_is_setup(*args):
8275 get_is_setup(_ParticleAdaptor p) -> bool
8276 get_is_setup(Model m, ParticleIndex pi) -> bool
8278 return _IMP_kernel._TrivialDecorator_get_is_setup(*args)
8280 get_is_setup = staticmethod(get_is_setup)
8282 def add_attribute(self, *args):
8284 add_attribute(_TrivialDecorator self, FloatKey k, IMP::Float v, bool opt)
8285 add_attribute(_TrivialDecorator self, FloatKey a0, IMP::Float a1)
8286 add_attribute(_TrivialDecorator self, IntKey a0, IMP::Int a1)
8287 add_attribute(_TrivialDecorator self, StringKey a0, IMP::String a1)
8288 add_attribute(_TrivialDecorator self, ParticleIndexKey a0, Particle a1)
8289 add_attribute(_TrivialDecorator self, ObjectKey a0, Object a1)
8291 return _IMP_kernel._TrivialDecorator_add_attribute(self, *args)
8294 def get_value(self, *args):
8296 get_value(_TrivialDecorator self, FloatKey a0) -> IMP::Float
8297 get_value(_TrivialDecorator self, IntKey a0) -> IMP::Int
8298 get_value(_TrivialDecorator self, StringKey a0) -> IMP::String
8299 get_value(_TrivialDecorator self, ParticleIndexKey a0) -> Particle
8300 get_value(_TrivialDecorator self, ObjectKey a0) -> Object
8302 return _IMP_kernel._TrivialDecorator_get_value(self, *args)
8305 def set_value(self, *args):
8307 set_value(_TrivialDecorator self, FloatKey a0, IMP::Float a1)
8308 set_value(_TrivialDecorator self, IntKey a0, IMP::Int a1)
8309 set_value(_TrivialDecorator self, StringKey a0, IMP::String a1)
8310 set_value(_TrivialDecorator self, ParticleIndexKey a0, Particle a1)
8311 set_value(_TrivialDecorator self, ObjectKey a0, Object a1)
8313 return _IMP_kernel._TrivialDecorator_set_value(self, *args)
8316 def remove_attribute(self, *args):
8318 remove_attribute(_TrivialDecorator self, FloatKey a0)
8319 remove_attribute(_TrivialDecorator self, IntKey a0)
8320 remove_attribute(_TrivialDecorator self, StringKey a0)
8321 remove_attribute(_TrivialDecorator self, ParticleIndexKey a0)
8322 remove_attribute(_TrivialDecorator self, ObjectKey a0)
8324 return _IMP_kernel._TrivialDecorator_remove_attribute(self, *args)
8327 def has_attribute(self, *args):
8329 has_attribute(_TrivialDecorator self, FloatKey a0) -> bool
8330 has_attribute(_TrivialDecorator self, IntKey a0) -> bool
8331 has_attribute(_TrivialDecorator self, StringKey a0) -> bool
8332 has_attribute(_TrivialDecorator self, ParticleIndexKey a0) -> bool
8333 has_attribute(_TrivialDecorator self, ObjectKey a0) -> bool
8335 return _IMP_kernel._TrivialDecorator_has_attribute(self, *args)
8338 def get_derivative(self, a0):
8339 """get_derivative(_TrivialDecorator self, FloatKey a0) -> double"""
8340 return _IMP_kernel._TrivialDecorator_get_derivative(self, a0)
8344 """get_name(_TrivialDecorator self) -> std::string"""
8345 return _IMP_kernel._TrivialDecorator_get_name(self)
8348 def clear_caches(self):
8349 """clear_caches(_TrivialDecorator self)"""
8350 return _IMP_kernel._TrivialDecorator_clear_caches(self)
8353 def set_name(self, a0):
8354 """set_name(_TrivialDecorator self, std::string a0)"""
8355 return _IMP_kernel._TrivialDecorator_set_name(self, a0)
8359 """set_check_level(_TrivialDecorator self, IMP::CheckLevel a0)"""
8360 return _IMP_kernel._TrivialDecorator_set_check_level(self, a0)
8363 def add_to_derivative(self, a0, a1, a2):
8364 """add_to_derivative(_TrivialDecorator self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
8365 return _IMP_kernel._TrivialDecorator_add_to_derivative(self, a0, a1, a2)
8368 def set_is_optimized(self, a0, a1):
8369 """set_is_optimized(_TrivialDecorator self, FloatKey a0, bool a1)"""
8370 return _IMP_kernel._TrivialDecorator_set_is_optimized(self, a0, a1)
8373 def get_is_optimized(self, a0):
8374 """get_is_optimized(_TrivialDecorator self, FloatKey a0) -> bool"""
8375 return _IMP_kernel._TrivialDecorator_get_is_optimized(self, a0)
8379 """get_check_level(_TrivialDecorator self) -> IMP::CheckLevel"""
8380 return _IMP_kernel._TrivialDecorator_get_check_level(self)
8383 def __eq__(self, *args):
8385 __eq__(_TrivialDecorator self, _TrivialDecorator o) -> bool
8386 __eq__(_TrivialDecorator self, Particle d) -> bool
8388 return _IMP_kernel._TrivialDecorator___eq__(self, *args)
8391 def __ne__(self, *args):
8393 __ne__(_TrivialDecorator self, _TrivialDecorator o) -> bool
8394 __ne__(_TrivialDecorator self, Particle d) -> bool
8396 return _IMP_kernel._TrivialDecorator___ne__(self, *args)
8399 def __le__(self, *args):
8401 __le__(_TrivialDecorator self, _TrivialDecorator o) -> bool
8402 __le__(_TrivialDecorator self, Particle d) -> bool
8404 return _IMP_kernel._TrivialDecorator___le__(self, *args)
8407 def __lt__(self, *args):
8409 __lt__(_TrivialDecorator self, _TrivialDecorator o) -> bool
8410 __lt__(_TrivialDecorator self, Particle d) -> bool
8412 return _IMP_kernel._TrivialDecorator___lt__(self, *args)
8415 def __ge__(self, *args):
8417 __ge__(_TrivialDecorator self, _TrivialDecorator o) -> bool
8418 __ge__(_TrivialDecorator self, Particle d) -> bool
8420 return _IMP_kernel._TrivialDecorator___ge__(self, *args)
8423 def __gt__(self, *args):
8425 __gt__(_TrivialDecorator self, _TrivialDecorator o) -> bool
8426 __gt__(_TrivialDecorator self, Particle d) -> bool
8428 return _IMP_kernel._TrivialDecorator___gt__(self, *args)
8432 """__hash__(_TrivialDecorator self) -> std::size_t"""
8433 return _IMP_kernel._TrivialDecorator___hash__(self)
8437 """__str__(_TrivialDecorator self) -> std::string"""
8438 return _IMP_kernel._TrivialDecorator___str__(self)
8442 """__repr__(_TrivialDecorator self) -> std::string"""
8443 return _IMP_kernel._TrivialDecorator___repr__(self)
8445 __swig_destroy__ = _IMP_kernel.delete__TrivialDecorator
8446 __del__ =
lambda self:
None
8447 _TrivialDecorator_swigregister = _IMP_kernel._TrivialDecorator_swigregister
8448 _TrivialDecorator_swigregister(_TrivialDecorator)
8450 def _TrivialDecorator_setup_particle(*args):
8452 setup_particle(Model m, ParticleIndex pi) -> _TrivialDecorator
8453 _TrivialDecorator_setup_particle(_ParticleAdaptor decorator) -> _TrivialDecorator
8455 return _IMP_kernel._TrivialDecorator_setup_particle(*args)
8457 def _TrivialDecorator_get_is_setup(*args):
8459 get_is_setup(_ParticleAdaptor p) -> bool
8460 _TrivialDecorator_get_is_setup(Model m, ParticleIndex pi) -> bool
8462 return _IMP_kernel._TrivialDecorator_get_is_setup(*args)
8464 class _TrivialDerivedDecorator(_TrivialDecorator):
8465 """Proxy of C++ IMP::internal::_TrivialDerivedDecorator class."""
8467 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
8469 def __init__(self, *args):
8471 __init__(IMP::internal::_TrivialDerivedDecorator self) -> _TrivialDerivedDecorator
8472 __init__(IMP::internal::_TrivialDerivedDecorator self, Model m, ParticleIndex id) -> _TrivialDerivedDecorator
8473 __init__(IMP::internal::_TrivialDerivedDecorator self, _ParticleAdaptor d) -> _TrivialDerivedDecorator
8475 this = _IMP_kernel.new__TrivialDerivedDecorator(*args)
8477 self.this.append(this)
8478 except __builtin__.Exception:
8481 def show(self, *args):
8483 show(_TrivialDerivedDecorator self, _ostream out)
8484 show(_TrivialDerivedDecorator self)
8486 return _IMP_kernel._TrivialDerivedDecorator_show(self, *args)
8489 def setup_particle(*args):
8491 setup_particle(Model m, ParticleIndex pi) -> _TrivialDerivedDecorator
8492 setup_particle(_ParticleAdaptor decorator) -> _TrivialDerivedDecorator
8494 return _IMP_kernel._TrivialDerivedDecorator_setup_particle(*args)
8496 setup_particle = staticmethod(setup_particle)
8498 def get_is_setup(*args):
8500 get_is_setup(_ParticleAdaptor p) -> bool
8501 get_is_setup(Model m, ParticleIndex pi) -> bool
8503 return _IMP_kernel._TrivialDerivedDecorator_get_is_setup(*args)
8505 get_is_setup = staticmethod(get_is_setup)
8507 def add_attribute(self, *args):
8509 add_attribute(_TrivialDerivedDecorator self, FloatKey k, IMP::Float v, bool opt)
8510 add_attribute(_TrivialDerivedDecorator self, FloatKey a0, IMP::Float a1)
8511 add_attribute(_TrivialDerivedDecorator self, IntKey a0, IMP::Int a1)
8512 add_attribute(_TrivialDerivedDecorator self, StringKey a0, IMP::String a1)
8513 add_attribute(_TrivialDerivedDecorator self, ParticleIndexKey a0, Particle a1)
8514 add_attribute(_TrivialDerivedDecorator self, ObjectKey a0, Object a1)
8516 return _IMP_kernel._TrivialDerivedDecorator_add_attribute(self, *args)
8519 def get_value(self, *args):
8521 get_value(_TrivialDerivedDecorator self, FloatKey a0) -> IMP::Float
8522 get_value(_TrivialDerivedDecorator self, IntKey a0) -> IMP::Int
8523 get_value(_TrivialDerivedDecorator self, StringKey a0) -> IMP::String
8524 get_value(_TrivialDerivedDecorator self, ParticleIndexKey a0) -> Particle
8525 get_value(_TrivialDerivedDecorator self, ObjectKey a0) -> Object
8527 return _IMP_kernel._TrivialDerivedDecorator_get_value(self, *args)
8530 def set_value(self, *args):
8532 set_value(_TrivialDerivedDecorator self, FloatKey a0, IMP::Float a1)
8533 set_value(_TrivialDerivedDecorator self, IntKey a0, IMP::Int a1)
8534 set_value(_TrivialDerivedDecorator self, StringKey a0, IMP::String a1)
8535 set_value(_TrivialDerivedDecorator self, ParticleIndexKey a0, Particle a1)
8536 set_value(_TrivialDerivedDecorator self, ObjectKey a0, Object a1)
8538 return _IMP_kernel._TrivialDerivedDecorator_set_value(self, *args)
8541 def remove_attribute(self, *args):
8543 remove_attribute(_TrivialDerivedDecorator self, FloatKey a0)
8544 remove_attribute(_TrivialDerivedDecorator self, IntKey a0)
8545 remove_attribute(_TrivialDerivedDecorator self, StringKey a0)
8546 remove_attribute(_TrivialDerivedDecorator self, ParticleIndexKey a0)
8547 remove_attribute(_TrivialDerivedDecorator self, ObjectKey a0)
8549 return _IMP_kernel._TrivialDerivedDecorator_remove_attribute(self, *args)
8552 def has_attribute(self, *args):
8554 has_attribute(_TrivialDerivedDecorator self, FloatKey a0) -> bool
8555 has_attribute(_TrivialDerivedDecorator self, IntKey a0) -> bool
8556 has_attribute(_TrivialDerivedDecorator self, StringKey a0) -> bool
8557 has_attribute(_TrivialDerivedDecorator self, ParticleIndexKey a0) -> bool
8558 has_attribute(_TrivialDerivedDecorator self, ObjectKey a0) -> bool
8560 return _IMP_kernel._TrivialDerivedDecorator_has_attribute(self, *args)
8563 def get_derivative(self, a0):
8564 """get_derivative(_TrivialDerivedDecorator self, FloatKey a0) -> double"""
8565 return _IMP_kernel._TrivialDerivedDecorator_get_derivative(self, a0)
8569 """get_name(_TrivialDerivedDecorator self) -> std::string"""
8570 return _IMP_kernel._TrivialDerivedDecorator_get_name(self)
8573 def clear_caches(self):
8574 """clear_caches(_TrivialDerivedDecorator self)"""
8575 return _IMP_kernel._TrivialDerivedDecorator_clear_caches(self)
8578 def set_name(self, a0):
8579 """set_name(_TrivialDerivedDecorator self, std::string a0)"""
8580 return _IMP_kernel._TrivialDerivedDecorator_set_name(self, a0)
8584 """set_check_level(_TrivialDerivedDecorator self, IMP::CheckLevel a0)"""
8585 return _IMP_kernel._TrivialDerivedDecorator_set_check_level(self, a0)
8588 def add_to_derivative(self, a0, a1, a2):
8589 """add_to_derivative(_TrivialDerivedDecorator self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
8590 return _IMP_kernel._TrivialDerivedDecorator_add_to_derivative(self, a0, a1, a2)
8593 def set_is_optimized(self, a0, a1):
8594 """set_is_optimized(_TrivialDerivedDecorator self, FloatKey a0, bool a1)"""
8595 return _IMP_kernel._TrivialDerivedDecorator_set_is_optimized(self, a0, a1)
8598 def get_is_optimized(self, a0):
8599 """get_is_optimized(_TrivialDerivedDecorator self, FloatKey a0) -> bool"""
8600 return _IMP_kernel._TrivialDerivedDecorator_get_is_optimized(self, a0)
8604 """get_check_level(_TrivialDerivedDecorator self) -> IMP::CheckLevel"""
8605 return _IMP_kernel._TrivialDerivedDecorator_get_check_level(self)
8608 def __eq__(self, *args):
8610 __eq__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
8611 __eq__(_TrivialDerivedDecorator self, Particle d) -> bool
8613 return _IMP_kernel._TrivialDerivedDecorator___eq__(self, *args)
8616 def __ne__(self, *args):
8618 __ne__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
8619 __ne__(_TrivialDerivedDecorator self, Particle d) -> bool
8621 return _IMP_kernel._TrivialDerivedDecorator___ne__(self, *args)
8624 def __le__(self, *args):
8626 __le__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
8627 __le__(_TrivialDerivedDecorator self, Particle d) -> bool
8629 return _IMP_kernel._TrivialDerivedDecorator___le__(self, *args)
8632 def __lt__(self, *args):
8634 __lt__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
8635 __lt__(_TrivialDerivedDecorator self, Particle d) -> bool
8637 return _IMP_kernel._TrivialDerivedDecorator___lt__(self, *args)
8640 def __ge__(self, *args):
8642 __ge__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
8643 __ge__(_TrivialDerivedDecorator self, Particle d) -> bool
8645 return _IMP_kernel._TrivialDerivedDecorator___ge__(self, *args)
8648 def __gt__(self, *args):
8650 __gt__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
8651 __gt__(_TrivialDerivedDecorator self, Particle d) -> bool
8653 return _IMP_kernel._TrivialDerivedDecorator___gt__(self, *args)
8657 """__hash__(_TrivialDerivedDecorator self) -> std::size_t"""
8658 return _IMP_kernel._TrivialDerivedDecorator___hash__(self)
8662 """__str__(_TrivialDerivedDecorator self) -> std::string"""
8663 return _IMP_kernel._TrivialDerivedDecorator___str__(self)
8667 """__repr__(_TrivialDerivedDecorator self) -> std::string"""
8668 return _IMP_kernel._TrivialDerivedDecorator___repr__(self)
8670 __swig_destroy__ = _IMP_kernel.delete__TrivialDerivedDecorator
8671 __del__ =
lambda self:
None
8672 _TrivialDerivedDecorator_swigregister = _IMP_kernel._TrivialDerivedDecorator_swigregister
8673 _TrivialDerivedDecorator_swigregister(_TrivialDerivedDecorator)
8675 def _TrivialDerivedDecorator_setup_particle(*args):
8677 setup_particle(Model m, ParticleIndex pi) -> _TrivialDerivedDecorator
8678 _TrivialDerivedDecorator_setup_particle(_ParticleAdaptor decorator) -> _TrivialDerivedDecorator
8680 return _IMP_kernel._TrivialDerivedDecorator_setup_particle(*args)
8682 def _TrivialDerivedDecorator_get_is_setup(*args):
8684 get_is_setup(_ParticleAdaptor p) -> bool
8685 _TrivialDerivedDecorator_get_is_setup(Model m, ParticleIndex pi) -> bool
8687 return _IMP_kernel._TrivialDerivedDecorator_get_is_setup(*args)
8689 class _TrivialTraitsDecorator(Decorator):
8690 """Proxy of C++ IMP::internal::_TrivialTraitsDecorator class."""
8692 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
8694 def get_decorator_traits(self):
8695 """get_decorator_traits(_TrivialTraitsDecorator self) -> StringKey"""
8696 return _IMP_kernel._TrivialTraitsDecorator_get_decorator_traits(self)
8699 def get_default_decorator_traits():
8700 """get_default_decorator_traits() -> StringKey"""
8701 return _IMP_kernel._TrivialTraitsDecorator_get_default_decorator_traits()
8703 get_default_decorator_traits = staticmethod(get_default_decorator_traits)
8705 def __init__(self, *args):
8707 __init__(IMP::internal::_TrivialTraitsDecorator self) -> _TrivialTraitsDecorator
8708 __init__(IMP::internal::_TrivialTraitsDecorator self, Model m, ParticleIndex id, StringKey tr) -> _TrivialTraitsDecorator
8709 __init__(IMP::internal::_TrivialTraitsDecorator self, Model m, ParticleIndex id) -> _TrivialTraitsDecorator
8710 __init__(IMP::internal::_TrivialTraitsDecorator self, _ParticleAdaptor d, StringKey tr) -> _TrivialTraitsDecorator
8711 __init__(IMP::internal::_TrivialTraitsDecorator self, _ParticleAdaptor d) -> _TrivialTraitsDecorator
8713 this = _IMP_kernel.new__TrivialTraitsDecorator(*args)
8715 self.this.append(this)
8716 except __builtin__.Exception:
8719 def show(self, *args):
8721 show(_TrivialTraitsDecorator self, _ostream out)
8722 show(_TrivialTraitsDecorator self)
8724 return _IMP_kernel._TrivialTraitsDecorator_show(self, *args)
8727 def setup_particle(*args):
8729 setup_particle(Model m, ParticleIndex pi, StringKey tr) -> _TrivialTraitsDecorator
8730 setup_particle(Model m, ParticleIndex pi) -> _TrivialTraitsDecorator
8731 setup_particle(_ParticleAdaptor d, StringKey tr) -> _TrivialTraitsDecorator
8732 setup_particle(_ParticleAdaptor d) -> _TrivialTraitsDecorator
8734 return _IMP_kernel._TrivialTraitsDecorator_setup_particle(*args)
8736 setup_particle = staticmethod(setup_particle)
8738 def get_is_setup(*args):
8740 get_is_setup(_ParticleAdaptor p, StringKey tr) -> bool
8741 get_is_setup(_ParticleAdaptor p) -> bool
8742 get_is_setup(Model m, ParticleIndex pi, StringKey k) -> bool
8743 get_is_setup(Model m, ParticleIndex pi) -> bool
8745 return _IMP_kernel._TrivialTraitsDecorator_get_is_setup(*args)
8747 get_is_setup = staticmethod(get_is_setup)
8749 def get_default_key():
8750 """get_default_key() -> StringKey"""
8751 return _IMP_kernel._TrivialTraitsDecorator_get_default_key()
8753 get_default_key = staticmethod(get_default_key)
8755 def add_attribute(self, *args):
8757 add_attribute(_TrivialTraitsDecorator self, FloatKey k, IMP::Float v, bool opt)
8758 add_attribute(_TrivialTraitsDecorator self, FloatKey a0, IMP::Float a1)
8759 add_attribute(_TrivialTraitsDecorator self, IntKey a0, IMP::Int a1)
8760 add_attribute(_TrivialTraitsDecorator self, StringKey a0, IMP::String a1)
8761 add_attribute(_TrivialTraitsDecorator self, ParticleIndexKey a0, Particle a1)
8762 add_attribute(_TrivialTraitsDecorator self, ObjectKey a0, Object a1)
8764 return _IMP_kernel._TrivialTraitsDecorator_add_attribute(self, *args)
8767 def get_value(self, *args):
8769 get_value(_TrivialTraitsDecorator self, FloatKey a0) -> IMP::Float
8770 get_value(_TrivialTraitsDecorator self, IntKey a0) -> IMP::Int
8771 get_value(_TrivialTraitsDecorator self, StringKey a0) -> IMP::String
8772 get_value(_TrivialTraitsDecorator self, ParticleIndexKey a0) -> Particle
8773 get_value(_TrivialTraitsDecorator self, ObjectKey a0) -> Object
8775 return _IMP_kernel._TrivialTraitsDecorator_get_value(self, *args)
8778 def set_value(self, *args):
8780 set_value(_TrivialTraitsDecorator self, FloatKey a0, IMP::Float a1)
8781 set_value(_TrivialTraitsDecorator self, IntKey a0, IMP::Int a1)
8782 set_value(_TrivialTraitsDecorator self, StringKey a0, IMP::String a1)
8783 set_value(_TrivialTraitsDecorator self, ParticleIndexKey a0, Particle a1)
8784 set_value(_TrivialTraitsDecorator self, ObjectKey a0, Object a1)
8786 return _IMP_kernel._TrivialTraitsDecorator_set_value(self, *args)
8789 def remove_attribute(self, *args):
8791 remove_attribute(_TrivialTraitsDecorator self, FloatKey a0)
8792 remove_attribute(_TrivialTraitsDecorator self, IntKey a0)
8793 remove_attribute(_TrivialTraitsDecorator self, StringKey a0)
8794 remove_attribute(_TrivialTraitsDecorator self, ParticleIndexKey a0)
8795 remove_attribute(_TrivialTraitsDecorator self, ObjectKey a0)
8797 return _IMP_kernel._TrivialTraitsDecorator_remove_attribute(self, *args)
8800 def has_attribute(self, *args):
8802 has_attribute(_TrivialTraitsDecorator self, FloatKey a0) -> bool
8803 has_attribute(_TrivialTraitsDecorator self, IntKey a0) -> bool
8804 has_attribute(_TrivialTraitsDecorator self, StringKey a0) -> bool
8805 has_attribute(_TrivialTraitsDecorator self, ParticleIndexKey a0) -> bool
8806 has_attribute(_TrivialTraitsDecorator self, ObjectKey a0) -> bool
8808 return _IMP_kernel._TrivialTraitsDecorator_has_attribute(self, *args)
8811 def get_derivative(self, a0):
8812 """get_derivative(_TrivialTraitsDecorator self, FloatKey a0) -> double"""
8813 return _IMP_kernel._TrivialTraitsDecorator_get_derivative(self, a0)
8817 """get_name(_TrivialTraitsDecorator self) -> std::string"""
8818 return _IMP_kernel._TrivialTraitsDecorator_get_name(self)
8821 def clear_caches(self):
8822 """clear_caches(_TrivialTraitsDecorator self)"""
8823 return _IMP_kernel._TrivialTraitsDecorator_clear_caches(self)
8826 def set_name(self, a0):
8827 """set_name(_TrivialTraitsDecorator self, std::string a0)"""
8828 return _IMP_kernel._TrivialTraitsDecorator_set_name(self, a0)
8832 """set_check_level(_TrivialTraitsDecorator self, IMP::CheckLevel a0)"""
8833 return _IMP_kernel._TrivialTraitsDecorator_set_check_level(self, a0)
8836 def add_to_derivative(self, a0, a1, a2):
8837 """add_to_derivative(_TrivialTraitsDecorator self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
8838 return _IMP_kernel._TrivialTraitsDecorator_add_to_derivative(self, a0, a1, a2)
8841 def set_is_optimized(self, a0, a1):
8842 """set_is_optimized(_TrivialTraitsDecorator self, FloatKey a0, bool a1)"""
8843 return _IMP_kernel._TrivialTraitsDecorator_set_is_optimized(self, a0, a1)
8846 def get_is_optimized(self, a0):
8847 """get_is_optimized(_TrivialTraitsDecorator self, FloatKey a0) -> bool"""
8848 return _IMP_kernel._TrivialTraitsDecorator_get_is_optimized(self, a0)
8852 """get_check_level(_TrivialTraitsDecorator self) -> IMP::CheckLevel"""
8853 return _IMP_kernel._TrivialTraitsDecorator_get_check_level(self)
8856 def __eq__(self, *args):
8858 __eq__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
8859 __eq__(_TrivialTraitsDecorator self, Particle d) -> bool
8861 return _IMP_kernel._TrivialTraitsDecorator___eq__(self, *args)
8864 def __ne__(self, *args):
8866 __ne__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
8867 __ne__(_TrivialTraitsDecorator self, Particle d) -> bool
8869 return _IMP_kernel._TrivialTraitsDecorator___ne__(self, *args)
8872 def __le__(self, *args):
8874 __le__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
8875 __le__(_TrivialTraitsDecorator self, Particle d) -> bool
8877 return _IMP_kernel._TrivialTraitsDecorator___le__(self, *args)
8880 def __lt__(self, *args):
8882 __lt__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
8883 __lt__(_TrivialTraitsDecorator self, Particle d) -> bool
8885 return _IMP_kernel._TrivialTraitsDecorator___lt__(self, *args)
8888 def __ge__(self, *args):
8890 __ge__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
8891 __ge__(_TrivialTraitsDecorator self, Particle d) -> bool
8893 return _IMP_kernel._TrivialTraitsDecorator___ge__(self, *args)
8896 def __gt__(self, *args):
8898 __gt__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
8899 __gt__(_TrivialTraitsDecorator self, Particle d) -> bool
8901 return _IMP_kernel._TrivialTraitsDecorator___gt__(self, *args)
8905 """__hash__(_TrivialTraitsDecorator self) -> std::size_t"""
8906 return _IMP_kernel._TrivialTraitsDecorator___hash__(self)
8910 """__str__(_TrivialTraitsDecorator self) -> std::string"""
8911 return _IMP_kernel._TrivialTraitsDecorator___str__(self)
8915 """__repr__(_TrivialTraitsDecorator self) -> std::string"""
8916 return _IMP_kernel._TrivialTraitsDecorator___repr__(self)
8918 __swig_destroy__ = _IMP_kernel.delete__TrivialTraitsDecorator
8919 __del__ =
lambda self:
None
8920 _TrivialTraitsDecorator_swigregister = _IMP_kernel._TrivialTraitsDecorator_swigregister
8921 _TrivialTraitsDecorator_swigregister(_TrivialTraitsDecorator)
8923 def _TrivialTraitsDecorator_get_default_decorator_traits():
8924 """_TrivialTraitsDecorator_get_default_decorator_traits() -> StringKey"""
8925 return _IMP_kernel._TrivialTraitsDecorator_get_default_decorator_traits()
8927 def _TrivialTraitsDecorator_setup_particle(*args):
8929 setup_particle(Model m, ParticleIndex pi, StringKey tr) -> _TrivialTraitsDecorator
8930 setup_particle(Model m, ParticleIndex pi) -> _TrivialTraitsDecorator
8931 setup_particle(_ParticleAdaptor d, StringKey tr) -> _TrivialTraitsDecorator
8932 _TrivialTraitsDecorator_setup_particle(_ParticleAdaptor d) -> _TrivialTraitsDecorator
8934 return _IMP_kernel._TrivialTraitsDecorator_setup_particle(*args)
8936 def _TrivialTraitsDecorator_get_is_setup(*args):
8938 get_is_setup(_ParticleAdaptor p, StringKey tr) -> bool
8939 get_is_setup(_ParticleAdaptor p) -> bool
8940 get_is_setup(Model m, ParticleIndex pi, StringKey k) -> bool
8941 _TrivialTraitsDecorator_get_is_setup(Model m, ParticleIndex pi) -> bool
8943 return _IMP_kernel._TrivialTraitsDecorator_get_is_setup(*args)
8945 def _TrivialTraitsDecorator_get_default_key():
8946 """_TrivialTraitsDecorator_get_default_key() -> StringKey"""
8947 return _IMP_kernel._TrivialTraitsDecorator_get_default_key()
8950 def __lshift__(*args):
8952 __lshift__(_ostream out, _TrivialDecorator n) -> _ostream
8953 __lshift__(_ostream out, _TrivialDerivedDecorator n) -> _ostream
8954 __lshift__(_ostream out, _TrivialTraitsDecorator n) -> _ostream
8956 return _IMP_kernel.__lshift__(*args)
8957 class _ConstOptimizer(Optimizer):
8958 """Proxy of C++ IMP::internal::_ConstOptimizer class."""
8960 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
8962 def __init__(self, m):
8963 """__init__(IMP::internal::_ConstOptimizer self, Model m) -> _ConstOptimizer"""
8964 this = _IMP_kernel.new__ConstOptimizer(m)
8966 self.this.append(this)
8967 except __builtin__.Exception:
8970 def do_optimize(self, max_steps):
8971 """do_optimize(_ConstOptimizer self, unsigned int max_steps) -> IMP::Float"""
8972 return _IMP_kernel._ConstOptimizer_do_optimize(self, max_steps)
8975 def get_version_info(self):
8976 """get_version_info(_ConstOptimizer self) -> VersionInfo"""
8977 return _IMP_kernel._ConstOptimizer_get_version_info(self)
8981 """__str__(_ConstOptimizer self) -> std::string"""
8982 return _IMP_kernel._ConstOptimizer___str__(self)
8986 """__repr__(_ConstOptimizer self) -> std::string"""
8987 return _IMP_kernel._ConstOptimizer___repr__(self)
8992 return _object_cast_to__ConstOptimizer(o)
8994 _ConstOptimizer_swigregister = _IMP_kernel._ConstOptimizer_swigregister
8995 _ConstOptimizer_swigregister(_ConstOptimizer)
8998 def get_particle(p):
8999 """get_particle(Particle p) -> Particle"""
9000 return _IMP_kernel.get_particle(p)
9002 def _decorator_test(p):
9003 """_decorator_test(Particle p)"""
9004 return _IMP_kernel._decorator_test(p)
9006 def _overloaded_decorator(*args):
9008 _overloaded_decorator(_TrivialDecorator a) -> int
9009 _overloaded_decorator(_TrivialDerivedDecorator a) -> int
9011 return _IMP_kernel._overloaded_decorator(*args)
9013 def _take_particles(*args):
9015 _take_particles(IMP::Particles const & ps) -> unsigned int
9016 _take_particles(Model m, IMP::Particles const & ps) -> unsigned int
9017 _take_particles(Model m, IMP::Particles const & ps, TextOutput out) -> unsigned int
9019 return _IMP_kernel._take_particles(*args)
9021 def _give_particles(m):
9022 """_give_particles(Model m) -> IMP::Particles const &"""
9023 return _IMP_kernel._give_particles(m)
9025 def _pass_particles(ps):
9026 """_pass_particles(IMP::Particles const & ps) -> IMP::Particles const &"""
9027 return _IMP_kernel._pass_particles(ps)
9029 def _pass_particle(ps):
9030 """_pass_particle(Particle ps) -> Particle"""
9031 return _IMP_kernel._pass_particle(ps)
9033 def _pass_particle_pair(pp):
9034 """_pass_particle_pair(IMP::ParticlePair const & pp) -> IMP::ParticlePair const &"""
9035 return _IMP_kernel._pass_particle_pair(pp)
9037 def _give_particles_copy(m):
9038 """_give_particles_copy(Model m) -> IMP::Particles"""
9039 return _IMP_kernel._give_particles_copy(m)
9041 def _pass_float_keys(input):
9042 """_pass_float_keys(IMP::FloatKeys const & input) -> IMP::FloatKeys"""
9043 return _IMP_kernel._pass_float_keys(input)
9047 _pass(IMP::Particles const & p) -> IMP::Particles const
9048 _pass(IMP::Restraints const & p) -> IMP::Restraints const &
9050 return _IMP_kernel._pass(*args)
9052 def _pass_decorators(p):
9053 """_pass_decorators(IMP::internal::_TrivialDecorators const & p) -> IMP::internal::_TrivialDecorators const &"""
9054 return _IMP_kernel._pass_decorators(p)
9056 def _pass_decorator_traits(p):
9057 """_pass_decorator_traits(IMP::internal::_TrivialTraitsDecorators const & p) -> IMP::internal::_TrivialTraitsDecorators const &"""
9058 return _IMP_kernel._pass_decorator_traits(p)
9060 def _pass_particle_pairs(p):
9061 """_pass_particle_pairs(IMP::ParticlePairsTemp const & p) -> IMP::ParticlePairsTemp"""
9062 return _IMP_kernel._pass_particle_pairs(p)
9064 def _pass_particle_index_pairs(p):
9065 """_pass_particle_index_pairs(IMP::ParticleIndexPairs const & p) -> IMP::ParticleIndexPairs"""
9066 return _IMP_kernel._pass_particle_index_pairs(p)
9068 def _pass_model_objects(p):
9069 """_pass_model_objects(IMP::ModelObjectsTemp const & p) -> IMP::ModelObjectsTemp"""
9070 return _IMP_kernel._pass_model_objects(p)
9072 def _pass_particles_temps(ps):
9073 """_pass_particles_temps(IMP::ParticlesTemps const & ps) -> IMP::ParticlesTemps"""
9074 return _IMP_kernel._pass_particles_temps(ps)
9076 def _test_overload(*args):
9078 _test_overload(IMP::Particles const & ps) -> int
9079 _test_overload(IMP::Restraints const & ps) -> int
9081 return _IMP_kernel._test_overload(*args)
9083 def _get_range(m, k):
9084 """_get_range(Model m, FloatKey k) -> IMP::FloatRange"""
9085 return _IMP_kernel._get_range(m, k)
9087 def _create_particles_from_pdb(name, m):
9088 """_create_particles_from_pdb(std::string name, Model m) -> IMP::ParticleIndexes"""
9089 return _IMP_kernel._create_particles_from_pdb(name, m)
9090 class _LogPairScore(PairScore):
9091 """Proxy of C++ IMP::internal::_LogPairScore class."""
9093 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
9094 __repr__ = _swig_repr
9097 """__init__(IMP::internal::_LogPairScore self) -> _LogPairScore"""
9098 this = _IMP_kernel.new__LogPairScore()
9100 self.this.append(this)
9101 except __builtin__.Exception:
9104 def do_get_inputs(self, arg2, arg3):
9105 """do_get_inputs(_LogPairScore self, Model arg2, IMP::ParticleIndexes const & arg3) -> IMP::ModelObjectsTemp"""
9106 return _IMP_kernel._LogPairScore_do_get_inputs(self, arg2, arg3)
9109 def get_version_info(self):
9110 """get_version_info(_LogPairScore self) -> VersionInfo"""
9111 return _IMP_kernel._LogPairScore_get_version_info(self)
9114 def get_particle_pairs(self):
9115 """get_particle_pairs(_LogPairScore self) -> IMP::ParticlePairsTemp"""
9116 return _IMP_kernel._LogPairScore_get_particle_pairs(self)
9120 """clear(_LogPairScore self)"""
9121 return _IMP_kernel._LogPairScore_clear(self)
9124 def get_contains(self, pp):
9125 """get_contains(_LogPairScore self, IMP::ParticlePair const & pp) -> bool"""
9126 return _IMP_kernel._LogPairScore_get_contains(self, pp)
9128 _LogPairScore_swigregister = _IMP_kernel._LogPairScore_swigregister
9129 _LogPairScore_swigregister(_LogPairScore)
9132 def _overloaded_particles(*args):
9134 _overloaded_particles(Particle arg1)
9135 _overloaded_particles(IMP::Particles const & arg1)
9136 _overloaded_particles(IMP::ParticlesTemp const & arg1)
9137 _overloaded_particles(Model arg1, IMP::ParticleIndexes const & arg2)
9138 _overloaded_particles(IMP::internal::_TrivialDecorators const & arg1)
9139 _overloaded_particles(_TrivialDecorator arg1)
9141 return _IMP_kernel._overloaded_particles(*args)
9142 class _ImplicitParticles(object):
9143 """Proxy of C++ IMP::internal::_ImplicitParticles class."""
9145 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
9146 __repr__ = _swig_repr
9148 def __init__(self, *args):
9150 __init__(IMP::internal::_ImplicitParticles self, Particle arg2) -> _ImplicitParticles
9151 __init__(IMP::internal::_ImplicitParticles self, IMP::Particles const & arg2) -> _ImplicitParticles
9152 __init__(IMP::internal::_ImplicitParticles self, IMP::ParticlesTemp const & arg2) -> _ImplicitParticles
9153 __init__(IMP::internal::_ImplicitParticles self, Model arg2, IMP::ParticleIndexes const & arg3) -> _ImplicitParticles
9154 __init__(IMP::internal::_ImplicitParticles self, IMP::internal::_TrivialDecorators const & arg2) -> _ImplicitParticles
9155 __init__(IMP::internal::_ImplicitParticles self, _TrivialDecorator arg2) -> _ImplicitParticles
9157 this = _IMP_kernel.new__ImplicitParticles(*args)
9159 self.this.append(this)
9160 except __builtin__.Exception:
9162 __swig_destroy__ = _IMP_kernel.delete__ImplicitParticles
9163 __del__ =
lambda self:
None
9164 _ImplicitParticles_swigregister = _IMP_kernel._ImplicitParticles_swigregister
9165 _ImplicitParticles_swigregister(_ImplicitParticles)
9168 def _implicit_particles(arg1):
9169 """_implicit_particles(_ImplicitParticles arg1)"""
9170 return _IMP_kernel._implicit_particles(arg1)
9172 def _take_particle_adaptor(pa):
9173 """_take_particle_adaptor(_ParticleAdaptor pa) -> ParticleIndex"""
9174 return _IMP_kernel._take_particle_adaptor(pa)
9176 def _take_particle_indexes_adaptor(pa):
9177 """_take_particle_indexes_adaptor(_ParticleIndexesAdaptor pa) -> IMP::ParticleIndexes"""
9178 return _IMP_kernel._take_particle_indexes_adaptor(pa)
9179 class ScopedSetFloatAttribute(_RAII):
9180 """Proxy of C++ IMP::ScopedSetAttribute<(FloatKey,IMP::Float)> class."""
9182 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
9184 def __init__(self, *args):
9186 __init__(IMP::ScopedSetAttribute<(FloatKey,IMP::Float)> self) -> ScopedSetFloatAttribute
9187 __init__(IMP::ScopedSetAttribute<(FloatKey,IMP::Float)> self, Particle p, FloatKey key, double const & value) -> ScopedSetFloatAttribute
9189 this = _IMP_kernel.new_ScopedSetFloatAttribute(*args)
9191 self.this.append(this)
9192 except __builtin__.Exception:
9195 def set(self, p, key, value):
9196 """set(ScopedSetFloatAttribute self, Particle p, FloatKey key, double const & value)"""
9197 return _IMP_kernel.ScopedSetFloatAttribute_set(self, p, key, value)
9201 """reset(ScopedSetFloatAttribute self)"""
9202 return _IMP_kernel.ScopedSetFloatAttribute_reset(self)
9204 __swig_destroy__ = _IMP_kernel.delete_ScopedSetFloatAttribute
9205 __del__ =
lambda self:
None
9207 def show(self, *args):
9209 show(ScopedSetFloatAttribute self, _ostream out)
9210 show(ScopedSetFloatAttribute self)
9212 return _IMP_kernel.ScopedSetFloatAttribute_show(self, *args)
9216 """__str__(ScopedSetFloatAttribute self) -> std::string"""
9217 return _IMP_kernel.ScopedSetFloatAttribute___str__(self)
9221 """__repr__(ScopedSetFloatAttribute self) -> std::string"""
9222 return _IMP_kernel.ScopedSetFloatAttribute___repr__(self)
9224 ScopedSetFloatAttribute_swigregister = _IMP_kernel.ScopedSetFloatAttribute_swigregister
9225 ScopedSetFloatAttribute_swigregister(ScopedSetFloatAttribute)
9235 if sys.platform ==
'win32' and 'IMP_LD_PATH' in os.environ:
9236 dirs = os.environ[
'IMP_LD_PATH'].split(
":")
9237 pathcomps = os.environ[
'PATH'].split(
";")
9239 if d
not in pathcomps:
9240 os.environ[
'PATH'] = d +
';' + os.environ[
'PATH']
9248 """Allow command line tools to easily implement multiple commands.
9249 Typically, an IMP command line tool will use an instance of this class
9250 to provide a consistent interface to multiple distinct commands
9251 from a single binary, rather than providing a potentially large
9252 number of binaries. This is similar to the way a number of common
9253 command line tools outside of IMP function (e.g. Git provides a single
9254 `git` tool which implements multiple commands - `git add`, `git commit`,
9255 `git push` and so on).
9257 Each command is implemented with a Python module of the same name
9258 that can be imported from the module (for example, if `module_name`
9259 is `IMP.foo`, the `bar` command is provided by the `IMP.foo.bar` Python
9260 module, which would usually be found as `modules/foo/pyext/src/bar.py`).
9261 Each such module should have a docstring and a `%main()` method
9262 that takes no arguments (the module should also call its `%main()` method
9263 if it is run directly, i.e. with something like
9264 `if __name__=="__main__": %main()`). The encompassing module
9265 (`IMP.foo` in the example) should define `_all_commands` as a Python
9266 list of all valid commands.
9268 See the `multifit` and `cnmultifit` command line tools for example
9272 def __init__(self, short_help, long_help, module_name):
9274 @param short_help A few words that describe the command line tool.
9275 @param long_help Longer text, used in the `help` command.
9276 @param module_name Name of the module (e.g. `IMP.foo`) that
9277 implements the commands.
9279 self.short_help = short_help
9280 self.long_help = long_help
9281 self.module_name = module_name
9282 self._all_commands = self.import_module()._all_commands
9283 self._progname = os.path.basename(sys.argv[0])
9286 """Call this method to act upon the user-provided command line"""
9287 if len(sys.argv) <= 1:
9288 print(self.short_help +
" Use '%s help' for help." % self._progname)
9290 command = sys.argv[1]
9291 if command
in (
'help',
'--help',
'-h'):
9292 if len(sys.argv) == 3:
9293 self.show_command_help(sys.argv[2])
9296 elif command ==
'--version':
9298 elif command
in self._all_commands:
9299 self.do_command(command)
9301 self.unknown_command(command)
9303 def import_module(self, mod=None):
9304 modname = self.module_name
9306 modname +=
"." + mod
9307 return __import__(modname, {}, {}, [
''])
9309 def unknown_command(self, command):
9310 print(
"Unknown command: '%s'" % command)
9311 print(
"Use '%s help' for help." % self._progname)
9314 def _get_version(self):
9315 return self.import_module().get_module_version()
9317 def show_version(self):
9318 print(self._progname +
' ' + self._get_version())
9320 def show_help(self):
9321 ver = self._get_version()
9322 print(
"%s, version %s." % (self._progname, ver))
9323 print(self.long_help +
"""
9325 This program is part of IMP, the Integrative Modeling Platform,
9326 which is Copyright 2007-2017 IMP Inventors.
9327 For additional information about IMP, see <https://integrativemodeling.org>.
9329 Usage: %s <command> [options] [args]
9331 Commands:""" % self._progname)
9332 commands = self._all_commands[:] + [
'help']
9334 cmdlen = max([len(c)
for c
in commands])
9337 doc =
'Get help on using %s.' % self._progname
9339 doc = self.import_module(c).__doc__
or "<no help>"
9340 c +=
' ' * (cmdlen - len(c))
9341 print(
' ' + c +
' ' + doc)
9343 Use "%s help <command>" for detailed help on any command
9344 or "%s --version" to see the version number.""" % (self._progname,
9347 def do_command(self, command):
9348 mod = self.import_module(command)
9349 sys.argv[0] = self._progname +
' ' + command
9353 def show_command_help(self, command):
9354 if command ==
'help':
9356 elif command
in self._all_commands
or command ==
'help':
9357 mod = self.import_module(command)
9358 sys.argv = [self._progname +
' ' + command,
'--help']
9361 self.unknown_command(command)
9370 """IMP-specific subclass of optparse.OptionParser.
9371 This adds options common to all IMP applications
9372 (see IMP::setup_from_argv()).
9375 _use_boost_parser =
True
9377 def __init__(self, *args, **kwargs):
9380 kwargs[
'add_help_option'] =
False
9381 kwargs[
'version'] =
None
9383 if 'imp_module' in kwargs:
9384 del kwargs[
'imp_module']
9386 optparse.OptionParser.__init__(self, *args, **kwargs)
9388 if 'epilog' in kwargs:
9390 del kwargs[
'epilog']
9391 optparse.OptionParser.__init__(self, *args, **kwargs)
9397 def _process_long_opt(self, rargs, values):
9398 if self._use_boost_parser:
9400 optparse.OptionParser._process_long_opt(self, rargs, values)
9401 except optparse.BadOptionError
as err:
9402 if not hasattr(err,
'opt_str') \
9403 and err.msg.startswith(
'no such option:'):
9404 self.largs.append(err.msg[16:])
9406 self.largs.append(err.opt_str)
9408 optparse.OptionParser._process_long_opt(self, rargs, values)
9409 def _process_short_opts(self, rargs, values):
9410 if self._use_boost_parser:
9412 optparse.OptionParser._process_short_opts(self, rargs, values)
9413 except optparse.BadOptionError
as err:
9414 self.largs.append(err.opt_str)
9416 optparse.OptionParser._process_short_opts(self, rargs, values)
9418 def _process_args(self, largs, rargs, values):
9419 if self._use_boost_parser:
9424 dashdash = rargs.index(
'--')
9426 dashdash = len(rargs)
9427 saved_args = rargs[dashdash:]
9428 del rargs[dashdash:]
9429 optparse.OptionParser._process_args(self, largs, rargs, values)
9430 rargs.extend(saved_args)
9432 optparse.OptionParser._process_args(self, largs, rargs, values)
9435 """Parse the command line and return options and positional arguments.
9436 This functions in the same way as the method in the base class
9437 optparse.OptionParser, except that it also processes options common
9438 to all IMP applications (these are not returned in opts, but can be
9439 obtained in the usual way, e.g. by calling
9440 IMP::get_string_flag()).
9441 @param[in] num_positional If a positive integer, exactly that
9442 many positional arguments must be specified on the
9443 command line; if a negative integer, that many or
9444 more must be given; if None, any number of positional
9445 arguments can be given.
9449 opts, args = optparse.OptionParser.parse_args(self)
9450 if not self._use_boost_parser:
9452 orig_desc = self.description
9453 orig_usage = self.usage
9455 usage = self.usage.replace(
'%prog ',
'')
9458 if num_positional
is None:
9462 args.append(
'dummy')
9464 numpos = num_positional
9466 self.usage = self.description =
None
9470 self.format_help() \
9471 +
"\nOptions common to all IMP applications:",
9474 self.description = orig_desc
9475 self.usage = orig_usage
9476 if num_positional
is None:
9484 g = networkx.DiGraph()
9485 if len(ig.get_vertices()) == 0:
9490 def __init__(self, p):
9494 return self.p.get_name()
9496 def __call__(self, name):
9497 return self.p.__call__(name)
9499 for vi
in ig.get_vertices():
9500 n = ig.get_vertex_name(vi)
9501 g.add_node(NodeWrapper(n))
9502 for vi
in ig.get_vertices():
9503 n = ig.get_vertex_name(vi)
9504 for ni
in ig.get_out_neighbors(vi):
9505 nn = ig.get_vertex_name(ni)
9506 g.add_edge(NodeWrapper(n), NodeWrapper(nn))
9513 n0 = name.get_name()
9516 n1 = str(n0).replace(
'"',
'')
9517 n2 = n1.replace(
"\n",
'')
9520 from altgraph
import Graph, Dot
9521 graph = Graph.Graph()
9522 for i, v
in enumerate(g.get_vertices()):
9524 for i, v
in enumerate(g.get_vertices()):
9525 for n
in g.get_out_neighbors(v):
9526 graph.add_edge(v, n)
9527 dot = Dot.Dot(graph)
9528 for i, v
in enumerate(g.get_vertices()):
9529 dot.node_style(i, label=clean(g.get_vertex_name(v)))
9536 st = g.get_graphviz_string()
9537 open(tfn,
"w").write(st)
9542 sys.stderr.write(
"Cannot run dot on Python 2.3 systems.\n")
9545 print(
"running dot")
9546 sp = subprocess.Popen([
"dot",
"-Tpdf", tfn,
"-o" + tfon])
9550 sys.stderr.write(
"The dot command from the graphviz package was not found. Please make sure it is in the PATH passed to IMP.\n")
9553 if platform.system() ==
"Darwin":
9556 cmd = [
"gv",
"acroread",
"xpdf"]
9559 print(
"launching viewer " + c)
9561 subprocess.check_call([c, tfon])
9567 print(
"Could not display file. It is saved at " + tfon)
9577 """Mark a Python module as deprecated.
9578 @note The `module` argument would normally be `__name__`.
9579 @see [deprecation support](@ref deprecation)."""
9581 "Module %s is deprecated. %s\n" % (module, help_message))
9584 """Python decorator to mark a class as deprecated.
9585 @see [deprecation support](@ref deprecation)."""
9587 orig_init = obj.__init__
9590 @functools.wraps(orig_init, (
'__name__',
'__doc__'))
9591 def __init__(obj, *args, **keys):
9593 % (type(obj), help_message))
9594 orig_init(obj, *args, **keys)
9595 obj.__init__ = __init__
9600 """Python decorator to mark a method as deprecated.
9601 @see [deprecation support](@ref deprecation)."""
9602 def out_wrapper(obj):
9603 @functools.wraps(obj)
9604 def wrapper(cls, *args, **keys):
9606 % (obj.__name__, type(cls), help_message))
9607 return obj(cls, *args, **keys)
9612 """Python decorator to mark a function as deprecated.
9613 @see [deprecation support](@ref deprecation)."""
9614 def out_wrapper(obj):
9615 @functools.wraps(obj)
9616 def wrapper(*args, **keys):
9618 % (obj.__name__, help_message))
9619 return obj(*args, **keys)
9623 @contextlib.contextmanager
9625 """Context manager to temporarily allow (or disallow) deprecated code.
9626 @see [deprecation support](@ref deprecation)."""
9632 class RandomNumberGenerator(object):
9633 """Proxy of C++ IMP::RandomNumberGenerator class."""
9635 thisown = _swig_property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
'The membership flag')
9636 __repr__ = _swig_repr
9639 """seed(RandomNumberGenerator self, ::boost::int32_t x)"""
9640 return _IMP_kernel.RandomNumberGenerator_seed(self, x)
9644 """__call__(RandomNumberGenerator self) -> int"""
9645 return _IMP_kernel.RandomNumberGenerator___call__(self)
9649 """__init__(IMP::RandomNumberGenerator self) -> RandomNumberGenerator"""
9650 this = _IMP_kernel.new_RandomNumberGenerator()
9652 self.this.append(this)
9653 except __builtin__.Exception:
9655 __swig_destroy__ = _IMP_kernel.delete_RandomNumberGenerator
9656 __del__ =
lambda self:
None
9657 RandomNumberGenerator_swigregister = _IMP_kernel.RandomNumberGenerator_swigregister
9658 RandomNumberGenerator_swigregister(RandomNumberGenerator)
9663 get_random_float_uniform() -> float
9664 get_random_float_uniform(float min, float max) -> float
9666 return _IMP_kernel.get_random_float_uniform(*args)
9670 get_random_double_uniform() -> double
9671 get_random_double_uniform(double min, double max) -> double
9673 return _IMP_kernel.get_random_double_uniform(*args)
9675 def get_random_floats_normal(n, mean=0.0, stddev=1.0):
9677 get_random_floats_normal(unsigned int n, float mean=0.0, float stddev=1.0) -> IMP::Vector< float >
9678 get_random_floats_normal(unsigned int n, float mean=0.0) -> IMP::Vector< float >
9679 get_random_floats_normal(unsigned int n) -> IMP::Vector< float >
9681 return _IMP_kernel.get_random_floats_normal(n, mean, stddev)
9683 def get_random_doubles_normal(n, mean=0.0, stddev=1.0):
9685 get_random_doubles_normal(unsigned int n, double mean=0.0, double stddev=1.0) -> IMP::Vector< double >
9686 get_random_doubles_normal(unsigned int n, double mean=0.0) -> IMP::Vector< double >
9687 get_random_doubles_normal(unsigned int n) -> IMP::Vector< double >
9689 return _IMP_kernel.get_random_doubles_normal(n, mean, stddev)
9691 def get_random_floats_uniform(n):
9692 """get_random_floats_uniform(unsigned int n) -> IMP::Vector< float >"""
9693 return _IMP_kernel.get_random_floats_uniform(n)
9695 def get_random_doubles_uniform(n):
9696 """get_random_doubles_uniform(unsigned int n) -> IMP::Vector< double >"""
9697 return _IMP_kernel.get_random_doubles_uniform(n)
9700 """get_random_seed() -> boost::uint64_t"""
9701 return _IMP_kernel.get_random_seed()
9703 def get_module_version():
9704 """get_module_version() -> std::string const"""
9705 return _IMP_kernel.get_module_version()
9708 """get_example_path(std::string fname) -> std::string"""
9709 return _IMP_kernel.get_example_path(fname)
9712 """get_data_path(std::string fname) -> std::string"""
9713 return _IMP_kernel.get_data_path(fname)
9715 from .
import _version_check
9716 _version_check.check_version(get_module_version())
9717 __version__ = get_module_version()
9720 random_number_generator = cvar.random_number_generator
void add_int_flag(std::string name, size_t default_value, std::string description)
Allow command line tools to easily implement multiple commands.
CheckLevel get_check_level()
Get the current audit mode.
Key< 0 > FloatKey
The type used to identify float attributes in the Particles.
def allow_deprecated
Context manager to temporarily allow (or disallow) deprecated code.
std::string get_unique_name(std::string templ)
Return a unique name produced from the string.
DependencyGraph get_dependency_graph(Model *m)
Objects get_live_objects()
Return pointers to all live objects.
Vector< char > write_particles_to_buffer(const ParticlesTemp &particles, const FloatKeys &keys)
return a binary buffer with the data
def main
Call this method to act upon the user-provided command line.
boost::graph DependencyGraph
A directed graph on the interactions between the various objects in the model.
ContainersTemp get_input_containers(const ModelObjectsTemp &mos)
Return all the input particles for a given ModelObject.
ParticlesTemp get_dependent_particles(ModelObject *p, const ModelObjectsTemp &all, const DependencyGraph &dg, const DependencyGraphVertexIndex &index)
def deprecated_module
Mark a Python module as deprecated.
Vector< VectorD< D > > get_vertices(const BoundingBoxD< D > &bb)
Return a list of the 2^D bounding points for the bounding box.
Array< 4, WeakPointer< Particle >, Particle * > ParticleQuad
bool get_bool_flag(std::string name)
void handle_use_deprecated(std::string message)
void set_progress_display(std::string description, unsigned int steps)
Set up the progress bar with the passed description.
def deprecated_function
Python decorator to mark a function as deprecated.
def parse_args
Parse the command line and return options and positional arguments.
Index< ParticleIndexTag > ParticleIndex
ParticlesTemp get_particles(Model *m, const ParticleIndexes &ps)
Key< 6 > ParticleIndexesKey
The type used to identify a particle attribute in the Particles.
Array< 3, WeakPointer< Particle >, Particle * > ParticleTriplet
ContainersTemp get_output_containers(const ModelObjectsTemp &mos)
Return all the output particles for a given ModelObject.
void add_particle(RMF::FileHandle fh, Particle *hs)
std::string get_data_path(std::string file_name)
Return the full path to one of this module's data files.
void add_string_flag(std::string name, std::string default_value, std::string description)
LogLevel get_log_level()
Get the currently active global log level.
void set_deprecation_warnings(bool tf)
Toggle printing of warnings on using deprecated classes.
TextOutput create_temporary_file(std::string prefix="imp_temp", std::string suffix="")
ParticlesTemp get_output_particles(const ModelObjectsTemp &mos)
Return all the output particles for a given ModelObject.
IMP-specific subclass of optparse.OptionParser.
ScoringFunction * create_scoring_function(RestraintType *rs, double weight=1.0, double max=NO_MAX, std::string name=std::string())
void write_help(std::ostream &out=std::cerr)
Key< 2 > StringKey
The type used to identify string attributes in the Particles.
size_t get_int_flag(std::string name)
void add_restraint(RMF::FileHandle fh, Restraint *hs)
ScoreStatesTemp get_required_score_states(ModelObject *p, const ModelObjectsTemp &all, const DependencyGraph &dg, const DependencyGraphVertexIndex &index)
boost::uint64_t get_random_seed()
Return the initial random seed.
Key< 3 > ParticleIndexKey
The type used to identify a particle attribute in the Particles.
Strings get_live_object_names()
Return the names of all live objects.
void add_to_progress_display(unsigned int step=1)
Set the current progress.
void add_float_flag(std::string name, double default_value, std::string description)
Ints get_index(const ParticlesTemp &particles, const Subset &subset, const Subsets &excluded)
def deprecated_method
Python decorator to mark a method as deprecated.
void reset_log_timer()
Reset the log timer.
void add_restraints(RMF::FileHandle fh, const Restraints &hs)
void add_to_log(LogLevel level, std::string to_write)
Write a string to the log, for Python.
Key< 1 > IntKey
The type used to identify int attributes in the Particles.
Version and module information for Objects.
Restraints create_decomposition(const RestraintsTemp &rs)
Return the decomposition of a list of restraints.
std::string get_relative_path(std::string base, std::string relative)
Return a path to a file relative to another file.
void set_deprecation_exceptions(bool tf)
Toggle whether an exception is thrown when a deprecated method is used.
Key< 4 > ObjectKey
The type used to identify an Object attribute.
std::ostream & show(Hierarchy h, std::ostream &out=std::cout)
Print the hierarchy using a given decorator to display each node.
std::string get_executable_name()
Return the name of the current executable.
void set_log_level(LogLevel l)
Set the current global log level.
unsigned int get_number_of_threads()
float get_random_float_uniform()
Return a uniformly distributed float number in range [0..1)
def deprecated_object
Python decorator to mark a class as deprecated.
ParticlesTemp get_input_particles(const ModelObjectsTemp &mos)
Return all the input particles for a given ModelObject.
void set_show_leaked_objects(bool tf)
Set whether to complain about objects not being properly cleaned up.
bool get_deprecation_exceptions()
Get whether an exception is thrown when a deprecated method is used.
void set_log_timer(bool tb)
Set whether log messages are tagged with the current log time.
void show_restraint_hierarchy(ScoringFunctionAdaptor rs, std::ostream &out=std::cout)
Print the hierarchy of restraints.
DependencyGraph get_pruned_dependency_graph(Model *m)
std::string get_example_path(std::string file_name)
Return the full path to one of this module's example files.
Array< 2, WeakPointer< Particle >, Particle * > ParticlePair
Restraints create_restraints(RMF::FileConstHandle fh, Model *m)
std::string show_graphviz(Graph g)
std::string get_string_flag(std::string name)
networkx::DiGraph get_networkx_graph(Graph g)
double get_random_double_uniform()
Return a uniformly distributed double number in range [0..1)
Key< 8 > ModelKey
The type used to identify data stored directly in the model.
void show_altgraph(Graph g)
void setup_from_argv(int argc, char **argv, std::string description)
Parse the command line flags and return the positional arguments.
void add_bool_flag(std::string name, std::string description)
ParticleIndexes get_indexes(const ParticlesTemp &ps)
void read_particles_from_buffer(const Vector< char > &buffer, const ParticlesTemp &particles, const FloatKeys &keys)
load found attributes into the particles
void set_number_of_threads(unsigned int n)
double get_float_flag(std::string name)
void set_check_level(CheckLevel tf)
Control runtime checks in the code.
ScoreStatesTemp get_update_order(ScoreStatesTemp input)
std::string create_temporary_file_name(std::string prefix="imp_temp", std::string suffix="")
Create a temporary file.