IMP logo
IMP Reference Guide  develop.18ca3ba1ae,2021/02/28
The Integrative Modeling Platform
__init__.py
1 # This file was automatically generated by SWIG (http://www.swig.org).
2 # Version 3.0.7
3 #
4 # Do not make changes to this file unless you know what you are doing--modify
5 # the SWIG interface file instead.
6 
7 # This wrapper is part of IMP,
8 # Copyright 2007-2021 IMP Inventors. All rights reserved.
9 
10 from __future__ import print_function, division, absolute_import
11 
12 
13 
14 
15 from sys import version_info
16 if version_info >= (2, 6, 0):
17  def swig_import_helper():
18  from os.path import dirname
19  import imp
20  fp = None
21  try:
22  fp, pathname, description = imp.find_module('_IMP_kernel', [dirname(__file__)])
23  except ImportError:
24  import _IMP_kernel
25  return _IMP_kernel
26  if fp is not None:
27  try:
28  _mod = imp.load_module('_IMP_kernel', fp, pathname, description)
29  finally:
30  fp.close()
31  return _mod
32  _IMP_kernel = swig_import_helper()
33  del swig_import_helper
34 else:
35  import _IMP_kernel
36 del version_info
37 try:
38  _swig_property = property
39 except NameError:
40  pass # Python < 2.2 doesn't have 'property'.
41 
42 
43 def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
44  if (name == "thisown"):
45  return self.this.own(value)
46  if (name == "this"):
47  if type(value).__name__ == 'SwigPyObject':
48  self.__dict__[name] = value
49  return
50  method = class_type.__swig_setmethods__.get(name, None)
51  if method:
52  return method(self, value)
53  if (not static):
54  object.__setattr__(self, name, value)
55  else:
56  raise AttributeError("You cannot add attributes to %s" % self)
57 
58 
59 def _swig_setattr(self, class_type, name, value):
60  return _swig_setattr_nondynamic(self, class_type, name, value, 0)
61 
62 
63 def _swig_getattr_nondynamic(self, class_type, name, static=1):
64  if (name == "thisown"):
65  return self.this.own()
66  method = class_type.__swig_getmethods__.get(name, None)
67  if method:
68  return method(self)
69  if (not static):
70  return object.__getattr__(self, name)
71  else:
72  raise AttributeError(name)
73 
74 def _swig_getattr(self, class_type, name):
75  return _swig_getattr_nondynamic(self, class_type, name, 0)
76 
77 
78 def _swig_repr(self):
79  try:
80  strthis = "proxy of " + self.this.__repr__()
81  except:
82  strthis = ""
83  return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
84 
85 try:
86  _object = object
87  _newclass = 1
88 except AttributeError:
89  class _object:
90  pass
91  _newclass = 0
92 
93 
94 
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)
101  else:
102  raise AttributeError("You cannot add attributes to %s" % self)
103  return set_attr
104 
105 
106 try:
107  import weakref
108  weakref_proxy = weakref.proxy
109 except:
110  weakref_proxy = lambda x: x
111 
112 
113 class IMP_KERNEL_SwigPyIterator(object):
114  """Proxy of C++ swig::IMP_KERNEL_SwigPyIterator class"""
115  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
116 
117  def __init__(self, *args, **kwargs):
118  raise AttributeError("No constructor defined - class is abstract")
119  __repr__ = _swig_repr
120  __swig_destroy__ = _IMP_kernel.delete_IMP_KERNEL_SwigPyIterator
121  __del__ = lambda self: None
122 
123  def value(self):
124  """value(IMP_KERNEL_SwigPyIterator self) -> PyObject *"""
125  return _IMP_kernel.IMP_KERNEL_SwigPyIterator_value(self)
126 
127 
128  def incr(self, n=1):
129  """
130  incr(IMP_KERNEL_SwigPyIterator self, size_t n=1) -> IMP_KERNEL_SwigPyIterator
131  incr(IMP_KERNEL_SwigPyIterator self) -> IMP_KERNEL_SwigPyIterator
132  """
133  return _IMP_kernel.IMP_KERNEL_SwigPyIterator_incr(self, n)
134 
135 
136  def decr(self, n=1):
137  """
138  decr(IMP_KERNEL_SwigPyIterator self, size_t n=1) -> IMP_KERNEL_SwigPyIterator
139  decr(IMP_KERNEL_SwigPyIterator self) -> IMP_KERNEL_SwigPyIterator
140  """
141  return _IMP_kernel.IMP_KERNEL_SwigPyIterator_decr(self, n)
142 
143 
144  def distance(self, x):
145  """distance(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> ptrdiff_t"""
146  return _IMP_kernel.IMP_KERNEL_SwigPyIterator_distance(self, x)
147 
148 
149  def equal(self, x):
150  """equal(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> bool"""
151  return _IMP_kernel.IMP_KERNEL_SwigPyIterator_equal(self, x)
152 
153 
154  def copy(self):
155  """copy(IMP_KERNEL_SwigPyIterator self) -> IMP_KERNEL_SwigPyIterator"""
156  return _IMP_kernel.IMP_KERNEL_SwigPyIterator_copy(self)
157 
158 
159  def next(self):
160  """next(IMP_KERNEL_SwigPyIterator self) -> PyObject *"""
161  return _IMP_kernel.IMP_KERNEL_SwigPyIterator_next(self)
162 
163 
164  def __next__(self):
165  """__next__(IMP_KERNEL_SwigPyIterator self) -> PyObject *"""
166  return _IMP_kernel.IMP_KERNEL_SwigPyIterator___next__(self)
167 
168 
169  def previous(self):
170  """previous(IMP_KERNEL_SwigPyIterator self) -> PyObject *"""
171  return _IMP_kernel.IMP_KERNEL_SwigPyIterator_previous(self)
172 
173 
174  def advance(self, n):
175  """advance(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator"""
176  return _IMP_kernel.IMP_KERNEL_SwigPyIterator_advance(self, n)
177 
178 
179  def __eq__(self, x):
180  """__eq__(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> bool"""
181  return _IMP_kernel.IMP_KERNEL_SwigPyIterator___eq__(self, x)
182 
183 
184  def __ne__(self, x):
185  """__ne__(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> bool"""
186  return _IMP_kernel.IMP_KERNEL_SwigPyIterator___ne__(self, x)
187 
188 
189  def __iadd__(self, n):
190  """__iadd__(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator"""
191  return _IMP_kernel.IMP_KERNEL_SwigPyIterator___iadd__(self, n)
192 
193 
194  def __isub__(self, n):
195  """__isub__(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator"""
196  return _IMP_kernel.IMP_KERNEL_SwigPyIterator___isub__(self, n)
197 
198 
199  def __add__(self, n):
200  """__add__(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator"""
201  return _IMP_kernel.IMP_KERNEL_SwigPyIterator___add__(self, n)
202 
203 
204  def __sub__(self, *args):
205  """
206  __sub__(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator
207  __sub__(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> ptrdiff_t
208  """
209  return _IMP_kernel.IMP_KERNEL_SwigPyIterator___sub__(self, *args)
210 
211  def __iter__(self):
212  return self
213 IMP_KERNEL_SwigPyIterator_swigregister = _IMP_kernel.IMP_KERNEL_SwigPyIterator_swigregister
214 IMP_KERNEL_SwigPyIterator_swigregister(IMP_KERNEL_SwigPyIterator)
215 
216 
217 _value_types=[]
218 _object_types=[]
219 _raii_types=[]
220 _plural_types=[]
221 
222 
223 _IMP_kernel.IMP_DEBUG_swigconstant(_IMP_kernel)
224 IMP_DEBUG = _IMP_kernel.IMP_DEBUG
225 
226 _IMP_kernel.IMP_RELEASE_swigconstant(_IMP_kernel)
227 IMP_RELEASE = _IMP_kernel.IMP_RELEASE
228 
229 _IMP_kernel.IMP_SILENT_swigconstant(_IMP_kernel)
230 IMP_SILENT = _IMP_kernel.IMP_SILENT
231 
232 _IMP_kernel.IMP_PROGRESS_swigconstant(_IMP_kernel)
233 IMP_PROGRESS = _IMP_kernel.IMP_PROGRESS
234 
235 _IMP_kernel.IMP_TERSE_swigconstant(_IMP_kernel)
236 IMP_TERSE = _IMP_kernel.IMP_TERSE
237 
238 _IMP_kernel.IMP_VERBOSE_swigconstant(_IMP_kernel)
239 IMP_VERBOSE = _IMP_kernel.IMP_VERBOSE
240 
241 _IMP_kernel.IMP_MEMORY_swigconstant(_IMP_kernel)
242 IMP_MEMORY = _IMP_kernel.IMP_MEMORY
243 
244 _IMP_kernel.IMP_NONE_swigconstant(_IMP_kernel)
245 IMP_NONE = _IMP_kernel.IMP_NONE
246 
247 _IMP_kernel.IMP_USAGE_swigconstant(_IMP_kernel)
248 IMP_USAGE = _IMP_kernel.IMP_USAGE
249 
250 _IMP_kernel.IMP_INTERNAL_swigconstant(_IMP_kernel)
251 IMP_INTERNAL = _IMP_kernel.IMP_INTERNAL
252 
253 _IMP_kernel.IMP_KERNEL_HAS_LOG4CXX_swigconstant(_IMP_kernel)
254 IMP_KERNEL_HAS_LOG4CXX = _IMP_kernel.IMP_KERNEL_HAS_LOG4CXX
255 
256 _IMP_kernel.IMP_COMPILER_HAS_AUTO_swigconstant(_IMP_kernel)
257 IMP_COMPILER_HAS_AUTO = _IMP_kernel.IMP_COMPILER_HAS_AUTO
258 
259 _IMP_kernel.IMP_COMPILER_HAS_DEBUG_VECTOR_swigconstant(_IMP_kernel)
260 IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_kernel.IMP_COMPILER_HAS_DEBUG_VECTOR
261 
262 _IMP_kernel.IMP_COMPILER_HAS_UNIQUE_PTR_swigconstant(_IMP_kernel)
263 IMP_COMPILER_HAS_UNIQUE_PTR = _IMP_kernel.IMP_COMPILER_HAS_UNIQUE_PTR
264 
265 _IMP_kernel.IMP_KERNEL_HAS_BOOST_RANDOM_swigconstant(_IMP_kernel)
266 IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_kernel.IMP_KERNEL_HAS_BOOST_RANDOM
267 
268 _IMP_kernel.IMP_KERNEL_HAS_NUMPY_swigconstant(_IMP_kernel)
269 IMP_KERNEL_HAS_NUMPY = _IMP_kernel.IMP_KERNEL_HAS_NUMPY
270 
271 _IMP_kernel.IMP_KERNEL_HAS_GPERFTOOLS_swigconstant(_IMP_kernel)
272 IMP_KERNEL_HAS_GPERFTOOLS = _IMP_kernel.IMP_KERNEL_HAS_GPERFTOOLS
273 
274 _IMP_kernel.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER_swigconstant(_IMP_kernel)
275 IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER = _IMP_kernel.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER
276 
277 _IMP_kernel.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER_swigconstant(_IMP_kernel)
278 IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER = _IMP_kernel.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER
279 
280 _IMP_kernel.IMPKERNEL_SHOW_WARNINGS_swigconstant(_IMP_kernel)
281 IMPKERNEL_SHOW_WARNINGS = _IMP_kernel.IMPKERNEL_SHOW_WARNINGS
282 
283 import sys
284 class _DirectorObjects(object):
285  """@internal Simple class to keep references to director objects
286  to prevent premature deletion."""
287  def __init__(self):
288  self._objects = []
289  def register(self, obj):
290  """Take a reference to a director object; will only work for
291  refcounted C++ classes"""
292  if hasattr(obj, 'get_ref_count'):
293  self._objects.append(obj)
294  def cleanup(self):
295  """Only drop our reference and allow cleanup by Python if no other
296  Python references exist (we hold 3 references: one in self._objects,
297  one in x, and one in the argument list for getrefcount) *and* no
298  other C++ references exist (the Python object always holds one)"""
299  objs = [x for x in self._objects if sys.getrefcount(x) > 3 \
300  or x.get_ref_count() > 1]
301 # Do in two steps so the references are kept until the end of the
302 # function (deleting references may trigger a fresh call to this method)
303  self._objects = objs
304  def get_object_count(self):
305  """Get number of director objects (useful for testing only)"""
306  return len(self._objects)
307 _director_objects = _DirectorObjects()
308 
309 
310 _IMP_kernel.DEFAULT_CHECK_swigconstant(_IMP_kernel)
311 DEFAULT_CHECK = _IMP_kernel.DEFAULT_CHECK
312 
313 _IMP_kernel.NONE_swigconstant(_IMP_kernel)
314 NONE = _IMP_kernel.NONE
315 
316 _IMP_kernel.USAGE_swigconstant(_IMP_kernel)
317 USAGE = _IMP_kernel.USAGE
318 
319 _IMP_kernel.USAGE_AND_INTERNAL_swigconstant(_IMP_kernel)
320 USAGE_AND_INTERNAL = _IMP_kernel.USAGE_AND_INTERNAL
321 
322 def set_check_level(tf):
323  """set_check_level(IMP::CheckLevel tf)"""
324  return _IMP_kernel.set_check_level(tf)
325 
326 def get_check_level():
327  """get_check_level() -> IMP::CheckLevel"""
328  return _IMP_kernel.get_check_level()
329 
330 from _IMP_kernel import Exception, InternalException, ModelException, EventException
331 from _IMP_kernel import UsageException, IndexException, IOException, ValueException
332 from _IMP_kernel import TypeException
333 
334 class _ostream(object):
335  """Proxy of C++ std::ostream class"""
336  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
337 
338  def __init__(self, *args, **kwargs):
339  raise AttributeError("No constructor defined")
340  __repr__ = _swig_repr
341 
342  def write(self, osa_buf):
343  """write(_ostream self, char const * osa_buf)"""
344  return _IMP_kernel._ostream_write(self, osa_buf)
345 
346 _ostream_swigregister = _IMP_kernel._ostream_swigregister
347 _ostream_swigregister(_ostream)
348 
349 
350 _IMP_kernel.IMP_COMPILER_HAS_OVERRIDE_swigconstant(_IMP_kernel)
351 IMP_COMPILER_HAS_OVERRIDE = _IMP_kernel.IMP_COMPILER_HAS_OVERRIDE
352 
353 _IMP_kernel.IMP_COMPILER_HAS_FINAL_swigconstant(_IMP_kernel)
354 IMP_COMPILER_HAS_FINAL = _IMP_kernel.IMP_COMPILER_HAS_FINAL
355 
356 _IMP_kernel.IMP_HAS_NOEXCEPT_swigconstant(_IMP_kernel)
357 IMP_HAS_NOEXCEPT = _IMP_kernel.IMP_HAS_NOEXCEPT
358 
359 _IMP_kernel.IMP_C_OPEN_BINARY_swigconstant(_IMP_kernel)
360 IMP_C_OPEN_BINARY = _IMP_kernel.IMP_C_OPEN_BINARY
361 
362 _raii_types.append("SetLogState")
363 
364 
365 _raii_types.append("SetNumberOfThreads")
366 
367 
368 _raii_types.append("SetCheckState")
369 
370 
371 _object_types.append("Object")
372 
373 
374 def _object_cast_to_Object(o):
375  """_object_cast_to_Object(Object * o) -> Object"""
376  return _IMP_kernel._object_cast_to_Object(o)
377 
378 _object_types.append("_TestObject")
379 
380 
381 def _object_cast_to__TestObject(o):
382  """_object_cast_to__TestObject(Object * o) -> _TestObject"""
383  return _IMP_kernel._object_cast_to__TestObject(o)
384 
385 VersionInfos=list
386 _plural_types.append("VersionInfos")
387 _value_types.append("VersionInfo")
388 
389 
390 _raii_types.append("CreateLogContext")
391 
392 
393 _raii_types.append("WarningContext")
394 
395 
396 _raii_types.append("SetLogTarget")
397 
398 
399 _TestValues=list
400 _plural_types.append("_TestValues")
401 _value_types.append("_TestValue")
402 
403 
404 Floats=list
405 _plural_types.append("Floats")
406 _value_types.append("Float")
407 
408 
409 Ints=list
410 _plural_types.append("Ints")
411 _value_types.append("Int")
412 
413 
414 Strings=list
415 _plural_types.append("Strings")
416 _value_types.append("String")
417 
418 
419 _Protections=list
420 _plural_types.append("_Protections")
421 _value_types.append("_Protection")
422 
423 class _InputAdaptor(object):
424  """Proxy of C++ IMP::InputAdaptor class"""
425  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
426 
427  def __init__(self, *args, **kwargs):
428  raise AttributeError("No constructor defined")
429  __repr__ = _swig_repr
430  __swig_destroy__ = _IMP_kernel.delete__InputAdaptor
431  __del__ = lambda self: None
432 _InputAdaptor_swigregister = _IMP_kernel._InputAdaptor_swigregister
433 _InputAdaptor_swigregister(_InputAdaptor)
434 
435 class _NonCopyable(object):
436  """Proxy of C++ IMP::NonCopyable class"""
437  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
438 
439  def __init__(self, *args, **kwargs):
440  raise AttributeError("No constructor defined")
441  __repr__ = _swig_repr
442  __swig_destroy__ = _IMP_kernel.delete__NonCopyable
443  __del__ = lambda self: None
444 _NonCopyable_swigregister = _IMP_kernel._NonCopyable_swigregister
445 _NonCopyable_swigregister(_NonCopyable)
446 
447 class _RAII(_NonCopyable):
448  """Proxy of C++ IMP::RAII class"""
449  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
450 
451  def __init__(self, *args, **kwargs):
452  raise AttributeError("No constructor defined")
453  __repr__ = _swig_repr
454  __swig_destroy__ = _IMP_kernel.delete__RAII
455  __del__ = lambda self: None
456 _RAII_swigregister = _IMP_kernel._RAII_swigregister
457 _RAII_swigregister(_RAII)
458 
459 class _Value(object):
460  """Proxy of C++ IMP::Value class"""
461  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
462 
463  def __init__(self, *args, **kwargs):
464  raise AttributeError("No constructor defined")
465  __repr__ = _swig_repr
466  __swig_destroy__ = _IMP_kernel.delete__Value
467  __del__ = lambda self: None
468 _Value_swigregister = _IMP_kernel._Value_swigregister
469 _Value_swigregister(_Value)
470 
471 
472 def get_executable_name():
473  """get_executable_name() -> std::string"""
474  return _IMP_kernel.get_executable_name()
475 
476 def setup_from_argv(*args):
477  """
478  setup_from_argv(IMP::Strings const & argv, std::string description)
479  setup_from_argv(IMP::Strings const & argv, std::string description, std::string positional_description, int num_positional) -> IMP::Strings
480  """
481  return _IMP_kernel.setup_from_argv(*args)
482 
483 def add_string_flag(name, default_value, description):
484  """add_string_flag(std::string name, std::string default_value, std::string description)"""
485  return _IMP_kernel.add_string_flag(name, default_value, description)
486 
487 def get_string_flag(name):
488  """get_string_flag(std::string name) -> std::string"""
489  return _IMP_kernel.get_string_flag(name)
490 
491 def add_int_flag(name, default_value, description):
492  """add_int_flag(std::string name, size_t default_value, std::string description)"""
493  return _IMP_kernel.add_int_flag(name, default_value, description)
494 
495 def get_int_flag(name):
496  """get_int_flag(std::string name) -> size_t"""
497  return _IMP_kernel.get_int_flag(name)
498 
499 def add_bool_flag(name, description):
500  """add_bool_flag(std::string name, std::string description)"""
501  return _IMP_kernel.add_bool_flag(name, description)
502 
503 def get_bool_flag(name):
504  """get_bool_flag(std::string name) -> bool"""
505  return _IMP_kernel.get_bool_flag(name)
506 
507 def add_float_flag(name, default_value, description):
508  """add_float_flag(std::string name, double default_value, std::string description)"""
509  return _IMP_kernel.add_float_flag(name, default_value, description)
510 
511 def get_float_flag(name):
512  """get_float_flag(std::string name) -> double"""
513  return _IMP_kernel.get_float_flag(name)
514 
515 def write_help(*args):
516  """
517  write_help(_ostream out)
518  write_help()
519  """
520  return _IMP_kernel.write_help(*args)
521 
522 def get_is_quick_test():
523  """get_is_quick_test() -> bool"""
524  return _IMP_kernel.get_is_quick_test()
525 
526 _IMP_kernel.DEFAULT_swigconstant(_IMP_kernel)
527 DEFAULT = _IMP_kernel.DEFAULT
528 
529 _IMP_kernel.SILENT_swigconstant(_IMP_kernel)
530 SILENT = _IMP_kernel.SILENT
531 
532 _IMP_kernel.WARNING_swigconstant(_IMP_kernel)
533 WARNING = _IMP_kernel.WARNING
534 
535 _IMP_kernel.PROGRESS_swigconstant(_IMP_kernel)
536 PROGRESS = _IMP_kernel.PROGRESS
537 
538 _IMP_kernel.TERSE_swigconstant(_IMP_kernel)
539 TERSE = _IMP_kernel.TERSE
540 
541 _IMP_kernel.VERBOSE_swigconstant(_IMP_kernel)
542 VERBOSE = _IMP_kernel.VERBOSE
543 
544 _IMP_kernel.MEMORY_swigconstant(_IMP_kernel)
545 MEMORY = _IMP_kernel.MEMORY
546 
547 _IMP_kernel.ALL_LOG_swigconstant(_IMP_kernel)
548 ALL_LOG = _IMP_kernel.ALL_LOG
549 class VersionInfo(_Value):
550  """Proxy of C++ IMP::VersionInfo class"""
551  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
552 
553  def __init__(self, *args):
554  """
555  __init__(IMP::VersionInfo self, std::string module, std::string version) -> VersionInfo
556  __init__(IMP::VersionInfo self) -> VersionInfo
557  """
558  this = _IMP_kernel.new_VersionInfo(*args)
559  try:
560  self.this.append(this)
561  except:
562  self.this = this
563 
564  def get_module(self):
565  """get_module(VersionInfo self) -> std::string"""
566  return _IMP_kernel.VersionInfo_get_module(self)
567 
568 
569  def get_version(self):
570  """get_version(VersionInfo self) -> std::string"""
571  return _IMP_kernel.VersionInfo_get_version(self)
572 
573 
574  def show(self, *args):
575  """
576  show(VersionInfo self, _ostream out)
577  show(VersionInfo self)
578  """
579  return _IMP_kernel.VersionInfo_show(self, *args)
580 
581 
582  def __cmp__(self, o):
583  """__cmp__(VersionInfo self, VersionInfo o) -> int"""
584  return _IMP_kernel.VersionInfo___cmp__(self, o)
585 
586 
587  def __eq__(self, o):
588  """__eq__(VersionInfo self, VersionInfo o) -> bool"""
589  return _IMP_kernel.VersionInfo___eq__(self, o)
590 
591 
592  def __ne__(self, o):
593  """__ne__(VersionInfo self, VersionInfo o) -> bool"""
594  return _IMP_kernel.VersionInfo___ne__(self, o)
595 
596 
597  def __lt__(self, o):
598  """__lt__(VersionInfo self, VersionInfo o) -> bool"""
599  return _IMP_kernel.VersionInfo___lt__(self, o)
600 
601 
602  def __gt__(self, o):
603  """__gt__(VersionInfo self, VersionInfo o) -> bool"""
604  return _IMP_kernel.VersionInfo___gt__(self, o)
605 
606 
607  def __ge__(self, o):
608  """__ge__(VersionInfo self, VersionInfo o) -> bool"""
609  return _IMP_kernel.VersionInfo___ge__(self, o)
610 
611 
612  def __le__(self, o):
613  """__le__(VersionInfo self, VersionInfo o) -> bool"""
614  return _IMP_kernel.VersionInfo___le__(self, o)
615 
616 
617  def __str__(self):
618  """__str__(VersionInfo self) -> std::string"""
619  return _IMP_kernel.VersionInfo___str__(self)
620 
621 
622  def __repr__(self):
623  """__repr__(VersionInfo self) -> std::string"""
624  return _IMP_kernel.VersionInfo___repr__(self)
625 
626  __swig_destroy__ = _IMP_kernel.delete_VersionInfo
627  __del__ = lambda self: None
628 VersionInfo_swigregister = _IMP_kernel.VersionInfo_swigregister
629 VersionInfo_swigregister(VersionInfo)
630 
631 class TextOutput(_InputAdaptor):
632  """Proxy of C++ IMP::TextOutput class"""
633  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
634  __repr__ = _swig_repr
635 
636  def __init__(self, *args):
637  """
638  __init__(IMP::TextOutput self, int arg2) -> TextOutput
639  __init__(IMP::TextOutput self, double arg2) -> TextOutput
640  __init__(IMP::TextOutput self, char const * c, bool append=False) -> TextOutput
641  __init__(IMP::TextOutput self, char const * c) -> TextOutput
642  __init__(IMP::TextOutput self, IMP::TextProxy< std::ostream > p) -> TextOutput
643  __init__(IMP::TextOutput self) -> TextOutput
644  __init__(IMP::TextOutput self, std::string file_name, bool append=False) -> TextOutput
645  __init__(IMP::TextOutput self, std::string file_name) -> TextOutput
646  """
647  this = _IMP_kernel.new_TextOutput(*args)
648  try:
649  self.this.append(this)
650  except:
651  self.this = this
652 
653  def show(self, *args):
654  """
655  show(TextOutput self, _ostream out)
656  show(TextOutput self)
657  """
658  return _IMP_kernel.TextOutput_show(self, *args)
659 
660 
661  def get_name(self):
662  """get_name(TextOutput self) -> std::string"""
663  return _IMP_kernel.TextOutput_get_name(self)
664 
665  __swig_destroy__ = _IMP_kernel.delete_TextOutput
666  __del__ = lambda self: None
667 TextOutput_swigregister = _IMP_kernel.TextOutput_swigregister
668 TextOutput_swigregister(TextOutput)
669 
670 class TextInput(_InputAdaptor):
671  """Proxy of C++ IMP::TextInput class"""
672  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
673  __repr__ = _swig_repr
674 
675  def __init__(self, *args):
676  """
677  __init__(IMP::TextInput self, int arg2) -> TextInput
678  __init__(IMP::TextInput self, double arg2) -> TextInput
679  __init__(IMP::TextInput self, char const * c) -> TextInput
680  __init__(IMP::TextInput self, IMP::TextProxy< std::istream > p) -> TextInput
681  __init__(IMP::TextInput self) -> TextInput
682  __init__(IMP::TextInput self, std::string file_name) -> TextInput
683  """
684  this = _IMP_kernel.new_TextInput(*args)
685  try:
686  self.this.append(this)
687  except:
688  self.this = this
689 
690  def show(self, *args):
691  """
692  show(TextInput self, _ostream out)
693  show(TextInput self)
694  """
695  return _IMP_kernel.TextInput_show(self, *args)
696 
697 
698  def get_name(self):
699  """get_name(TextInput self) -> std::string"""
700  return _IMP_kernel.TextInput_get_name(self)
701 
702  __swig_destroy__ = _IMP_kernel.delete_TextInput
703  __del__ = lambda self: None
704 TextInput_swigregister = _IMP_kernel.TextInput_swigregister
705 TextInput_swigregister(TextInput)
706 
707 class SetLogTarget(_RAII):
708  """Proxy of C++ IMP::SetLogTarget class"""
709  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
710 
711  def __init__(self, *args):
712  """
713  __init__(IMP::SetLogTarget self) -> SetLogTarget
714  __init__(IMP::SetLogTarget self, TextOutput to) -> SetLogTarget
715  """
716  this = _IMP_kernel.new_SetLogTarget(*args)
717  try:
718  self.this.append(this)
719  except:
720  self.this = this
721 
722  def set(self, to):
723  """set(SetLogTarget self, TextOutput to)"""
724  return _IMP_kernel.SetLogTarget_set(self, to)
725 
726 
727  def reset(self):
728  """reset(SetLogTarget self)"""
729  return _IMP_kernel.SetLogTarget_reset(self)
730 
731  __swig_destroy__ = _IMP_kernel.delete_SetLogTarget
732  __del__ = lambda self: None
733 
734  def show(self, *args):
735  """
736  show(SetLogTarget self, _ostream out)
737  show(SetLogTarget self)
738  """
739  return _IMP_kernel.SetLogTarget_show(self, *args)
740 
741 
742  def __enter__(self):
743  return self
744  def __exit__(self, exc_type, exc_val, exc_tb):
745  self.reset()
746  return False
747 
748 
749  def __str__(self):
750  """__str__(SetLogTarget self) -> std::string"""
751  return _IMP_kernel.SetLogTarget___str__(self)
752 
753 
754  def __repr__(self):
755  """__repr__(SetLogTarget self) -> std::string"""
756  return _IMP_kernel.SetLogTarget___repr__(self)
757 
758 SetLogTarget_swigregister = _IMP_kernel.SetLogTarget_swigregister
759 SetLogTarget_swigregister(SetLogTarget)
760 
761 
762 def create_temporary_file(*args):
763  """
764  create_temporary_file(std::string prefix, std::string suffix) -> TextOutput
765  create_temporary_file(std::string prefix) -> TextOutput
766  create_temporary_file() -> TextOutput
767  """
768  return _IMP_kernel.create_temporary_file(*args)
769 
770 def create_temporary_file_name(*args):
771  """
772  create_temporary_file_name(std::string prefix, std::string suffix) -> std::string
773  create_temporary_file_name(std::string prefix) -> std::string
774  create_temporary_file_name() -> std::string
775  """
776  return _IMP_kernel.create_temporary_file_name(*args)
777 
778 def get_relative_path(base, relative):
779  """get_relative_path(std::string base, std::string relative) -> std::string"""
780  return _IMP_kernel.get_relative_path(base, relative)
781 
782 def get_absolute_path(file):
783  """get_absolute_path(std::string file) -> std::string"""
784  return _IMP_kernel.get_absolute_path(file)
785 
786 def push_log_context(functionname, object):
787  """push_log_context(char const * functionname, void const * object)"""
788  return _IMP_kernel.push_log_context(functionname, object)
789 
790 def pop_log_context():
791  """pop_log_context()"""
792  return _IMP_kernel.pop_log_context()
793 
794 def add_to_log(*args):
795  """
796  add_to_log(std::string to_write)
797  add_to_log(IMP::LogLevel level, std::string to_write)
798  """
799  return _IMP_kernel.add_to_log(*args)
800 
801 def set_log_level(l):
802  """set_log_level(IMP::LogLevel l)"""
803  return _IMP_kernel.set_log_level(l)
804 
805 def set_log_timer(tb):
806  """set_log_timer(bool tb)"""
807  return _IMP_kernel.set_log_timer(tb)
808 
809 def reset_log_timer():
810  """reset_log_timer()"""
811  return _IMP_kernel.reset_log_timer()
812 
813 def get_log_level():
814  """get_log_level() -> IMP::LogLevel"""
815  return _IMP_kernel.get_log_level()
816 
817 def set_progress_display(description, steps):
818  """set_progress_display(std::string description, unsigned int steps)"""
819  return _IMP_kernel.set_progress_display(description, steps)
820 
821 def add_to_progress_display(step=1):
822  """
823  add_to_progress_display(unsigned int step=1)
824  add_to_progress_display()
825  """
826  return _IMP_kernel.add_to_progress_display(step)
827 class Object(_NonCopyable):
828  """Proxy of C++ IMP::Object class"""
829  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
830 
831  def __init__(self, name):
832  """__init__(IMP::Object self, std::string name) -> Object"""
833  if self.__class__ == Object:
834  _self = None
835  else:
836  _self = self
837  this = _IMP_kernel.new_Object(_self, name)
838  try:
839  self.this.append(this)
840  except:
841  self.this = this
842 
843  if self.__class__ != Object:
844  _director_objects.register(self)
845 
846 
847 
848  __swig_destroy__ = _IMP_kernel.delete_Object
849  __del__ = lambda self: None
850 
851  def __hash__(self):
852  """__hash__(Object self) -> std::size_t"""
853  return _IMP_kernel.Object___hash__(self)
854 
855 
856  def set_log_level(self, l):
857  """set_log_level(Object self, IMP::LogLevel l)"""
858  return _IMP_kernel.Object_set_log_level(self, l)
859 
860 
861  def set_check_level(self, l):
862  """set_check_level(Object self, IMP::CheckLevel l)"""
863  return _IMP_kernel.Object_set_check_level(self, l)
864 
865 
866  def get_log_level(self):
867  """get_log_level(Object self) -> IMP::LogLevel"""
868  return _IMP_kernel.Object_get_log_level(self)
869 
870 
871  def get_check_level(self):
872  """get_check_level(Object self) -> IMP::CheckLevel"""
873  return _IMP_kernel.Object_get_check_level(self)
874 
875 
876  def get_version_info(self):
877  """get_version_info(Object self) -> VersionInfo"""
878  return _IMP_kernel.Object_get_version_info(self)
879 
880 
881  def get_name(self):
882  """get_name(Object self) -> std::string const &"""
883  return _IMP_kernel.Object_get_name(self)
884 
885 
886  def set_name(self, name):
887  """set_name(Object self, std::string name)"""
888  return _IMP_kernel.Object_set_name(self, name)
889 
890 
891  def get_type_name(self):
892  """get_type_name(Object self) -> std::string"""
893  return _IMP_kernel.Object_get_type_name(self)
894 
895 
896  def set_was_used(self, tf):
897  """set_was_used(Object self, bool tf)"""
898  return _IMP_kernel.Object_set_was_used(self, tf)
899 
900 
901  def show(self, *args):
902  """
903  show(Object self, _ostream out)
904  show(Object self)
905  """
906  return _IMP_kernel.Object_show(self, *args)
907 
908 
909  def get_string(self):
910  """get_string(Object self) -> std::string"""
911  return _IMP_kernel.Object_get_string(self)
912 
913 
914  def _on_destruction(self):
915  """_on_destruction(Object self)"""
916  return _IMP_kernel.Object__on_destruction(self)
917 
918 
919  def get_is_valid(self):
920  """get_is_valid(Object self) -> bool"""
921  return _IMP_kernel.Object_get_is_valid(self)
922 
923 
924  def get_ref_count(self):
925  """get_ref_count(Object self) -> unsigned int"""
926  return _IMP_kernel.Object_get_ref_count(self)
927 
928 
929  def get_number_of_live_objects():
930  """get_number_of_live_objects() -> unsigned int"""
931  return _IMP_kernel.Object_get_number_of_live_objects()
932 
933  get_number_of_live_objects = staticmethod(get_number_of_live_objects)
934 
935  def get_is_shared(self):
936  """get_is_shared(Object self) -> bool"""
937  return _IMP_kernel.Object_get_is_shared(self)
938 
939 
940  def clear_caches(self):
941  """clear_caches(Object self)"""
942  return _IMP_kernel.Object_clear_caches(self)
943 
944 
945  def do_destroy(self):
946  """do_destroy(Object self)"""
947  return _IMP_kernel.Object_do_destroy(self)
948 
949 
950  def __eq__(self, o):
951  """__eq__(Object self, Object o) -> bool"""
952  return _IMP_kernel.Object___eq__(self, o)
953 
954 
955  def __ne__(self, o):
956  """__ne__(Object self, Object o) -> bool"""
957  return _IMP_kernel.Object___ne__(self, o)
958 
959 
960  def __le__(self, o):
961  """__le__(Object self, Object o) -> bool"""
962  return _IMP_kernel.Object___le__(self, o)
963 
964 
965  def __lt__(self, o):
966  """__lt__(Object self, Object o) -> bool"""
967  return _IMP_kernel.Object___lt__(self, o)
968 
969 
970  def __ge__(self, o):
971  """__ge__(Object self, Object o) -> bool"""
972  return _IMP_kernel.Object___ge__(self, o)
973 
974 
975  def __gt__(self, o):
976  """__gt__(Object self, Object o) -> bool"""
977  return _IMP_kernel.Object___gt__(self, o)
978 
979 
980  def __str__(self):
981  """__str__(Object self) -> std::string"""
982  return _IMP_kernel.Object___str__(self)
983 
984 
985  def __repr__(self):
986  """__repr__(Object self) -> std::string"""
987  return _IMP_kernel.Object___repr__(self)
988 
989 
990  @staticmethod
991  def get_from(o):
992  return _object_cast_to_Object(o)
993 
994  def __disown__(self):
995  self.this.disown()
996  _IMP_kernel.disown_Object(self)
997  return weakref_proxy(self)
998 Object_swigregister = _IMP_kernel.Object_swigregister
999 Object_swigregister(Object)
1000 
1001 def Object_get_number_of_live_objects():
1002  """Object_get_number_of_live_objects() -> unsigned int"""
1003  return _IMP_kernel.Object_get_number_of_live_objects()
1004 
1005 class SetLogState(_RAII):
1006  """Proxy of C++ IMP::SetLogState class"""
1007  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1008 
1009  def reset(self):
1010  """reset(SetLogState self)"""
1011  return _IMP_kernel.SetLogState_reset(self)
1012 
1013  __swig_destroy__ = _IMP_kernel.delete_SetLogState
1014  __del__ = lambda self: None
1015 
1016  def show(self, *args):
1017  """
1018  show(SetLogState self, _ostream out)
1019  show(SetLogState self)
1020  """
1021  return _IMP_kernel.SetLogState_show(self, *args)
1022 
1023 
1024  def __init__(self, *args):
1025  """
1026  __init__(IMP::SetLogState self) -> SetLogState
1027  __init__(IMP::SetLogState self, Object o, IMP::LogLevel l) -> SetLogState
1028  __init__(IMP::SetLogState self, IMP::LogLevel l) -> SetLogState
1029  """
1030  this = _IMP_kernel.new_SetLogState(*args)
1031  try:
1032  self.this.append(this)
1033  except:
1034  self.this = this
1035 
1036  def set(self, *args):
1037  """
1038  set(SetLogState self, Object o, IMP::LogLevel l)
1039  set(SetLogState self, IMP::LogLevel l)
1040  """
1041  return _IMP_kernel.SetLogState_set(self, *args)
1042 
1043 
1044  def __enter__(self):
1045  return self
1046  def __exit__(self, exc_type, exc_val, exc_tb):
1047  self.reset()
1048  return False
1049 
1050 
1051  def __str__(self):
1052  """__str__(SetLogState self) -> std::string"""
1053  return _IMP_kernel.SetLogState___str__(self)
1054 
1055 
1056  def __repr__(self):
1057  """__repr__(SetLogState self) -> std::string"""
1058  return _IMP_kernel.SetLogState___repr__(self)
1059 
1060 SetLogState_swigregister = _IMP_kernel.SetLogState_swigregister
1061 SetLogState_swigregister(SetLogState)
1062 
1063 class WarningContext(object):
1064  """Proxy of C++ IMP::WarningContext class"""
1065  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1066  data_ = _swig_property(_IMP_kernel.WarningContext_data__get, _IMP_kernel.WarningContext_data__set)
1067 
1068  def add_warning(self, key, warning):
1069  """add_warning(WarningContext self, std::string key, std::string warning)"""
1070  return _IMP_kernel.WarningContext_add_warning(self, key, warning)
1071 
1072 
1073  def clear_warnings(self):
1074  """clear_warnings(WarningContext self)"""
1075  return _IMP_kernel.WarningContext_clear_warnings(self)
1076 
1077 
1078  def dump_warnings(self):
1079  """dump_warnings(WarningContext self)"""
1080  return _IMP_kernel.WarningContext_dump_warnings(self)
1081 
1082  __swig_destroy__ = _IMP_kernel.delete_WarningContext
1083  __del__ = lambda self: None
1084 
1085  def show(self, *args):
1086  """
1087  show(WarningContext self, _ostream out)
1088  show(WarningContext self)
1089  """
1090  return _IMP_kernel.WarningContext_show(self, *args)
1091 
1092 
1093  def __enter__(self):
1094  return self
1095  def __exit__(self, exc_type, exc_val, exc_tb):
1096  self.reset()
1097  return False
1098 
1099 
1100  def __str__(self):
1101  """__str__(WarningContext self) -> std::string"""
1102  return _IMP_kernel.WarningContext___str__(self)
1103 
1104 
1105  def __repr__(self):
1106  """__repr__(WarningContext self) -> std::string"""
1107  return _IMP_kernel.WarningContext___repr__(self)
1108 
1109 
1110  def __init__(self):
1111  """__init__(IMP::WarningContext self) -> WarningContext"""
1112  this = _IMP_kernel.new_WarningContext()
1113  try:
1114  self.this.append(this)
1115  except:
1116  self.this = this
1117 WarningContext_swigregister = _IMP_kernel.WarningContext_swigregister
1118 WarningContext_swigregister(WarningContext)
1119 
1120 class CreateLogContext(_RAII):
1121  """Proxy of C++ IMP::CreateLogContext class"""
1122  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1123 
1124  def __init__(self, *args):
1125  """
1126  __init__(IMP::CreateLogContext self, std::string fname, Object object=None) -> CreateLogContext
1127  __init__(IMP::CreateLogContext self, std::string fname) -> CreateLogContext
1128  __init__(IMP::CreateLogContext self) -> CreateLogContext
1129  __init__(IMP::CreateLogContext self, char const * fname, Object object=None) -> CreateLogContext
1130  __init__(IMP::CreateLogContext self, char const * fname) -> CreateLogContext
1131  """
1132  this = _IMP_kernel.new_CreateLogContext(*args)
1133  try:
1134  self.this.append(this)
1135  except:
1136  self.this = this
1137 
1138  def set(self, fname, object=None):
1139  """
1140  set(CreateLogContext self, char const * fname, Object object=None)
1141  set(CreateLogContext self, char const * fname)
1142  """
1143  return _IMP_kernel.CreateLogContext_set(self, fname, object)
1144 
1145 
1146  def reset(self):
1147  """reset(CreateLogContext self)"""
1148  return _IMP_kernel.CreateLogContext_reset(self)
1149 
1150  __swig_destroy__ = _IMP_kernel.delete_CreateLogContext
1151  __del__ = lambda self: None
1152 
1153  def show(self, *args):
1154  """
1155  show(CreateLogContext self, _ostream out)
1156  show(CreateLogContext self)
1157  """
1158  return _IMP_kernel.CreateLogContext_show(self, *args)
1159 
1160 
1161  def __enter__(self):
1162  return self
1163  def __exit__(self, exc_type, exc_val, exc_tb):
1164  self.reset()
1165  return False
1166 
1167 
1168  def __str__(self):
1169  """__str__(CreateLogContext self) -> std::string"""
1170  return _IMP_kernel.CreateLogContext___str__(self)
1171 
1172 
1173  def __repr__(self):
1174  """__repr__(CreateLogContext self) -> std::string"""
1175  return _IMP_kernel.CreateLogContext___repr__(self)
1176 
1177 CreateLogContext_swigregister = _IMP_kernel.CreateLogContext_swigregister
1178 CreateLogContext_swigregister(CreateLogContext)
1179 
1180 class SetCheckState(_RAII):
1181  """Proxy of C++ IMP::SetCheckState class"""
1182  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1183 
1184  def reset(self):
1185  """reset(SetCheckState self)"""
1186  return _IMP_kernel.SetCheckState_reset(self)
1187 
1188  __swig_destroy__ = _IMP_kernel.delete_SetCheckState
1189  __del__ = lambda self: None
1190 
1191  def show(self, *args):
1192  """
1193  show(SetCheckState self, _ostream out)
1194  show(SetCheckState self)
1195  """
1196  return _IMP_kernel.SetCheckState_show(self, *args)
1197 
1198 
1199  def __init__(self, *args):
1200  """
1201  __init__(IMP::SetCheckState self) -> SetCheckState
1202  __init__(IMP::SetCheckState self, Object o, IMP::CheckLevel l) -> SetCheckState
1203  __init__(IMP::SetCheckState self, IMP::CheckLevel l) -> SetCheckState
1204  """
1205  this = _IMP_kernel.new_SetCheckState(*args)
1206  try:
1207  self.this.append(this)
1208  except:
1209  self.this = this
1210 
1211  def set(self, *args):
1212  """
1213  set(SetCheckState self, Object o, IMP::CheckLevel l)
1214  set(SetCheckState self, IMP::CheckLevel l)
1215  """
1216  return _IMP_kernel.SetCheckState_set(self, *args)
1217 
1218 
1219  def __enter__(self):
1220  return self
1221  def __exit__(self, exc_type, exc_val, exc_tb):
1222  self.reset()
1223  return False
1224 
1225 
1226  def __str__(self):
1227  """__str__(SetCheckState self) -> std::string"""
1228  return _IMP_kernel.SetCheckState___str__(self)
1229 
1230 
1231  def __repr__(self):
1232  """__repr__(SetCheckState self) -> std::string"""
1233  return _IMP_kernel.SetCheckState___repr__(self)
1234 
1235 SetCheckState_swigregister = _IMP_kernel.SetCheckState_swigregister
1236 SetCheckState_swigregister(SetCheckState)
1237 
1238 
1239 def get_unique_name(templ):
1240  """get_unique_name(std::string templ) -> std::string"""
1241  return _IMP_kernel.get_unique_name(templ)
1242 class _Protection(object):
1243  """Proxy of C++ IMP::internal::_Protection class"""
1244  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1245 
1246  def __init__(self, *args, **kwargs):
1247  raise AttributeError("No constructor defined")
1248 
1249  def show(self, *args):
1250  """
1251  show(_Protection self, _ostream out)
1252  show(_Protection self)
1253  """
1254  return _IMP_kernel._Protection_show(self, *args)
1255 
1256 
1257  def __str__(self):
1258  """__str__(_Protection self) -> std::string"""
1259  return _IMP_kernel._Protection___str__(self)
1260 
1261 
1262  def __repr__(self):
1263  """__repr__(_Protection self) -> std::string"""
1264  return _IMP_kernel._Protection___repr__(self)
1265 
1266  __swig_destroy__ = _IMP_kernel.delete__Protection
1267  __del__ = lambda self: None
1268 _Protection_swigregister = _IMP_kernel._Protection_swigregister
1269 _Protection_swigregister(_Protection)
1270 
1271 
1272 def _test_log():
1273  """_test_log()"""
1274  return _IMP_kernel._test_log()
1275 
1276 def _test_intranges(ips):
1277  """_test_intranges(IMP::IntRanges const & ips) -> int"""
1278  return _IMP_kernel._test_intranges(ips)
1279 
1280 def _test_intrange(*args):
1281  """
1282  _test_intrange(IMP::IntRange const & ips) -> IMP::IntRange
1283  _test_intrange() -> IMP::IntRange
1284  """
1285  return _IMP_kernel._test_intrange(*args)
1286 
1287 def _test_ifile(a):
1288  """_test_ifile(TextInput a) -> std::string"""
1289  return _IMP_kernel._test_ifile(a)
1290 
1291 def _test_ofile(a):
1292  """_test_ofile(TextOutput a) -> std::string"""
1293  return _IMP_kernel._test_ofile(a)
1294 
1295 def _test_ifile_overloaded(*args):
1296  """
1297  _test_ifile_overloaded(TextInput a, int i) -> std::string
1298  _test_ifile_overloaded(TextInput a, std::string st) -> std::string
1299  """
1300  return _IMP_kernel._test_ifile_overloaded(*args)
1301 
1302 def _test_ofile_overloaded(*args):
1303  """
1304  _test_ofile_overloaded(TextOutput a, int i) -> std::string
1305  _test_ofile_overloaded(TextOutput a, std::string st) -> std::string
1306  """
1307  return _IMP_kernel._test_ofile_overloaded(*args)
1308 class _TestValue(object):
1309  """Proxy of C++ IMP::internal::_TestValue class"""
1310  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1311 
1312  def __init__(self, i):
1313  """__init__(IMP::internal::_TestValue self, int i) -> _TestValue"""
1314  this = _IMP_kernel.new__TestValue(i)
1315  try:
1316  self.this.append(this)
1317  except:
1318  self.this = this
1319 
1320  def show(self, *args):
1321  """
1322  show(_TestValue self, _ostream out)
1323  show(_TestValue self)
1324  """
1325  return _IMP_kernel._TestValue_show(self, *args)
1326 
1327 
1328  def __cmp__(self, o):
1329  """__cmp__(_TestValue self, _TestValue o) -> int"""
1330  return _IMP_kernel._TestValue___cmp__(self, o)
1331 
1332 
1333  def __eq__(self, o):
1334  """__eq__(_TestValue self, _TestValue o) -> bool"""
1335  return _IMP_kernel._TestValue___eq__(self, o)
1336 
1337 
1338  def __ne__(self, o):
1339  """__ne__(_TestValue self, _TestValue o) -> bool"""
1340  return _IMP_kernel._TestValue___ne__(self, o)
1341 
1342 
1343  def __lt__(self, o):
1344  """__lt__(_TestValue self, _TestValue o) -> bool"""
1345  return _IMP_kernel._TestValue___lt__(self, o)
1346 
1347 
1348  def __gt__(self, o):
1349  """__gt__(_TestValue self, _TestValue o) -> bool"""
1350  return _IMP_kernel._TestValue___gt__(self, o)
1351 
1352 
1353  def __ge__(self, o):
1354  """__ge__(_TestValue self, _TestValue o) -> bool"""
1355  return _IMP_kernel._TestValue___ge__(self, o)
1356 
1357 
1358  def __le__(self, o):
1359  """__le__(_TestValue self, _TestValue o) -> bool"""
1360  return _IMP_kernel._TestValue___le__(self, o)
1361 
1362 
1363  def get(self):
1364  """get(_TestValue self) -> int"""
1365  return _IMP_kernel._TestValue_get(self)
1366 
1367 
1368  def get_float(self):
1369  """get_float(_TestValue self) -> float const &"""
1370  return _IMP_kernel._TestValue_get_float(self)
1371 
1372 
1373  def get_double(self):
1374  """get_double(_TestValue self) -> double const &"""
1375  return _IMP_kernel._TestValue_get_double(self)
1376 
1377 
1378  def get_Float(self):
1379  """get_Float(_TestValue self) -> IMP::Float const &"""
1380  return _IMP_kernel._TestValue_get_Float(self)
1381 
1382 
1383  def get_int(self):
1384  """get_int(_TestValue self) -> int const &"""
1385  return _IMP_kernel._TestValue_get_int(self)
1386 
1387 
1388  def get_Int(self):
1389  """get_Int(_TestValue self) -> IMP::Int const &"""
1390  return _IMP_kernel._TestValue_get_Int(self)
1391 
1392 
1393  def get_string(self):
1394  """get_string(_TestValue self) -> std::string const &"""
1395  return _IMP_kernel._TestValue_get_string(self)
1396 
1397 
1398  def get_String(self):
1399  """get_String(_TestValue self) -> IMP::String const &"""
1400  return _IMP_kernel._TestValue_get_String(self)
1401 
1402 
1403  def __str__(self):
1404  """__str__(_TestValue self) -> std::string"""
1405  return _IMP_kernel._TestValue___str__(self)
1406 
1407 
1408  def __repr__(self):
1409  """__repr__(_TestValue self) -> std::string"""
1410  return _IMP_kernel._TestValue___repr__(self)
1411 
1412  __swig_destroy__ = _IMP_kernel.delete__TestValue
1413  __del__ = lambda self: None
1414 _TestValue_swigregister = _IMP_kernel._TestValue_swigregister
1415 _TestValue_swigregister(_TestValue)
1416 
1417 
1418 def _pass_plain_pair(p):
1419  """_pass_plain_pair(IMP::FloatPair p) -> IMP::FloatPair"""
1420  return _IMP_kernel._pass_plain_pair(p)
1421 
1422 def _pass_overloaded_strings(*args):
1423  """
1424  _pass_overloaded_strings(IMP::Strings const & a, int arg2) -> IMP::Strings
1425  _pass_overloaded_strings(IMP::Strings const & a) -> IMP::Strings
1426  """
1427  return _IMP_kernel._pass_overloaded_strings(*args)
1428 
1429 def _pass_pair(p):
1430  """_pass_pair(IMP::DerivativePair const & p) -> IMP::DerivativePair"""
1431  return _IMP_kernel._pass_pair(p)
1432 
1433 def _pass_floats(input):
1434  """_pass_floats(IMP::Floats const & input) -> IMP::Floats"""
1435  return _IMP_kernel._pass_floats(input)
1436 
1437 def _pass_ints(input):
1438  """_pass_ints(IMP::Ints input) -> IMP::Ints"""
1439  return _IMP_kernel._pass_ints(input)
1440 
1441 def _pass_ints_list(input):
1442  """_pass_ints_list(IMP::IntsList const & input) -> IMP::IntsList"""
1443  return _IMP_kernel._pass_ints_list(input)
1444 
1445 def _pass_ints_lists(input):
1446  """_pass_ints_lists(IMP::IntsLists const & input) -> IMP::IntsLists"""
1447  return _IMP_kernel._pass_ints_lists(input)
1448 
1449 def _pass_strings(input):
1450  """_pass_strings(IMP::Strings const & input) -> IMP::Strings const &"""
1451  return _IMP_kernel._pass_strings(input)
1452 class _TestObject(Object):
1453  """Proxy of C++ IMP::internal::_TestObject class"""
1454  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1455 
1456  def __init__(self):
1457  """__init__(IMP::internal::_TestObject self) -> _TestObject"""
1458  this = _IMP_kernel.new__TestObject()
1459  try:
1460  self.this.append(this)
1461  except:
1462  self.this = this
1463 
1464  def get_version_info(self):
1465  """get_version_info(_TestObject self) -> VersionInfo"""
1466  return _IMP_kernel._TestObject_get_version_info(self)
1467 
1468 
1469  def __str__(self):
1470  """__str__(_TestObject self) -> std::string"""
1471  return _IMP_kernel._TestObject___str__(self)
1472 
1473 
1474  def __repr__(self):
1475  """__repr__(_TestObject self) -> std::string"""
1476  return _IMP_kernel._TestObject___repr__(self)
1477 
1478 
1479  @staticmethod
1480  def get_from(o):
1481  return _object_cast_to__TestObject(o)
1482 
1483 _TestObject_swigregister = _IMP_kernel._TestObject_swigregister
1484 _TestObject_swigregister(_TestObject)
1485 
1486 
1487 def get_live_object_names():
1488  """get_live_object_names() -> IMP::Strings"""
1489  return _IMP_kernel.get_live_object_names()
1490 
1491 def get_live_objects():
1492  """get_live_objects() -> IMP::Objects"""
1493  return _IMP_kernel.get_live_objects()
1494 
1495 def set_show_leaked_objects(tf):
1496  """set_show_leaked_objects(bool tf)"""
1497  return _IMP_kernel.set_show_leaked_objects(tf)
1498 
1499 def set_deprecation_warnings(tf):
1500  """set_deprecation_warnings(bool tf)"""
1501  return _IMP_kernel.set_deprecation_warnings(tf)
1502 
1504  """set_deprecation_exceptions(bool tf)"""
1505  return _IMP_kernel.set_deprecation_exceptions(tf)
1506 
1508  """get_deprecation_exceptions() -> bool"""
1509  return _IMP_kernel.get_deprecation_exceptions()
1510 
1511 def handle_use_deprecated(message):
1512  """handle_use_deprecated(std::string message)"""
1513  return _IMP_kernel.handle_use_deprecated(message)
1514 
1515 def get_number_of_threads():
1516  """get_number_of_threads() -> unsigned int"""
1517  return _IMP_kernel.get_number_of_threads()
1518 
1519 def set_number_of_threads(n):
1520  """set_number_of_threads(unsigned int n)"""
1521  return _IMP_kernel.set_number_of_threads(n)
1522 class SetNumberOfThreads(_RAII):
1523  """Proxy of C++ IMP::SetNumberOfThreads class"""
1524  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1525 
1526  def __init__(self, *args):
1527  """
1528  __init__(IMP::SetNumberOfThreads self) -> SetNumberOfThreads
1529  __init__(IMP::SetNumberOfThreads self, unsigned int n) -> SetNumberOfThreads
1530  """
1531  this = _IMP_kernel.new_SetNumberOfThreads(*args)
1532  try:
1533  self.this.append(this)
1534  except:
1535  self.this = this
1536 
1537  def set(self, n):
1538  """set(SetNumberOfThreads self, unsigned int n)"""
1539  return _IMP_kernel.SetNumberOfThreads_set(self, n)
1540 
1541 
1542  def reset(self):
1543  """reset(SetNumberOfThreads self)"""
1544  return _IMP_kernel.SetNumberOfThreads_reset(self)
1545 
1546  __swig_destroy__ = _IMP_kernel.delete_SetNumberOfThreads
1547  __del__ = lambda self: None
1548 
1549  def show(self, *args):
1550  """
1551  show(SetNumberOfThreads self, _ostream out)
1552  show(SetNumberOfThreads self)
1553  """
1554  return _IMP_kernel.SetNumberOfThreads_show(self, *args)
1555 
1556 
1557  def __enter__(self):
1558  return self
1559  def __exit__(self, exc_type, exc_val, exc_tb):
1560  self.reset()
1561  return False
1562 
1563 
1564  def __str__(self):
1565  """__str__(SetNumberOfThreads self) -> std::string"""
1566  return _IMP_kernel.SetNumberOfThreads___str__(self)
1567 
1568 
1569  def __repr__(self):
1570  """__repr__(SetNumberOfThreads self) -> std::string"""
1571  return _IMP_kernel.SetNumberOfThreads___repr__(self)
1572 
1573 SetNumberOfThreads_swigregister = _IMP_kernel.SetNumberOfThreads_swigregister
1574 SetNumberOfThreads_swigregister(SetNumberOfThreads)
1575 
1576 
1577 import os
1578 i_m_p="IMP_MODULE_PATH"
1579 if i_m_p in os.environ.keys():
1580  __path__.insert(0, os.environ[i_m_p])
1581 
1582 def _forward_add_attribute(self, name, value, opt=None):
1583  if opt is not None:
1584  self.get_particle().add_attribute(name, value, opt)
1585  else:
1586  self.get_particle().add_attribute(name, value)
1587 def _forward_get_value(self, name):
1588  self.get_particle().get_value(name)
1589 def _forward_set_value(self, name, value):
1590  self.get_particle().set_value(name, value)
1591 
1592 
1593 build="release"
1594 
1595 
1596 _object_types.append("Constraint")
1597 
1598 
1599 def _object_cast_to_Constraint(o):
1600  """_object_cast_to_Constraint(Object o) -> Constraint"""
1601  return _IMP_kernel._object_cast_to_Constraint(o)
1602 
1603 _object_types.append("Undecorator")
1604 
1605 
1606 def _object_cast_to_Undecorator(o):
1607  """_object_cast_to_Undecorator(Object o) -> Undecorator"""
1608  return _IMP_kernel._object_cast_to_Undecorator(o)
1609 
1610 _object_types.append("Container")
1611 
1612 
1613 def _object_cast_to_Container(o):
1614  """_object_cast_to_Container(Object o) -> Container"""
1615  return _IMP_kernel._object_cast_to_Container(o)
1616 
1617 _object_types.append("Optimizer")
1618 
1619 
1620 def _object_cast_to_Optimizer(o):
1621  """_object_cast_to_Optimizer(Object o) -> Optimizer"""
1622  return _IMP_kernel._object_cast_to_Optimizer(o)
1623 
1624 _object_types.append("AttributeOptimizer")
1625 
1626 
1627 def _object_cast_to_AttributeOptimizer(o):
1628  """_object_cast_to_AttributeOptimizer(Object o) -> AttributeOptimizer"""
1629  return _IMP_kernel._object_cast_to_AttributeOptimizer(o)
1630 
1631 _object_types.append("OptimizerState")
1632 
1633 
1634 def _object_cast_to_OptimizerState(o):
1635  """_object_cast_to_OptimizerState(Object o) -> OptimizerState"""
1636  return _IMP_kernel._object_cast_to_OptimizerState(o)
1637 
1638 _object_types.append("PairContainer")
1639 
1640 
1641 def _object_cast_to_PairContainer(o):
1642  """_object_cast_to_PairContainer(Object o) -> PairContainer"""
1643  return _IMP_kernel._object_cast_to_PairContainer(o)
1644 
1645 _object_types.append("PairModifier")
1646 
1647 
1648 def _object_cast_to_PairModifier(o):
1649  """_object_cast_to_PairModifier(Object o) -> PairModifier"""
1650  return _IMP_kernel._object_cast_to_PairModifier(o)
1651 
1652 _object_types.append("PairScore")
1653 
1654 
1655 def _object_cast_to_PairScore(o):
1656  """_object_cast_to_PairScore(Object o) -> PairScore"""
1657  return _IMP_kernel._object_cast_to_PairScore(o)
1658 
1659 _object_types.append("QuadContainer")
1660 
1661 
1662 def _object_cast_to_QuadContainer(o):
1663  """_object_cast_to_QuadContainer(Object o) -> QuadContainer"""
1664  return _IMP_kernel._object_cast_to_QuadContainer(o)
1665 
1666 _object_types.append("QuadModifier")
1667 
1668 
1669 def _object_cast_to_QuadModifier(o):
1670  """_object_cast_to_QuadModifier(Object o) -> QuadModifier"""
1671  return _IMP_kernel._object_cast_to_QuadModifier(o)
1672 
1673 _object_types.append("QuadScore")
1674 
1675 
1676 def _object_cast_to_QuadScore(o):
1677  """_object_cast_to_QuadScore(Object o) -> QuadScore"""
1678  return _IMP_kernel._object_cast_to_QuadScore(o)
1679 
1680 _object_types.append("Refiner")
1681 
1682 
1683 def _object_cast_to_Refiner(o):
1684  """_object_cast_to_Refiner(Object o) -> Refiner"""
1685  return _IMP_kernel._object_cast_to_Refiner(o)
1686 
1687 _object_types.append("Restraint")
1688 
1689 
1690 def _object_cast_to_Restraint(o):
1691  """_object_cast_to_Restraint(Object o) -> Restraint"""
1692  return _IMP_kernel._object_cast_to_Restraint(o)
1693 
1694 _object_types.append("Sampler")
1695 
1696 
1697 def _object_cast_to_Sampler(o):
1698  """_object_cast_to_Sampler(Object o) -> Sampler"""
1699  return _IMP_kernel._object_cast_to_Sampler(o)
1700 
1701 _object_types.append("ScoreState")
1702 
1703 
1704 def _object_cast_to_ScoreState(o):
1705  """_object_cast_to_ScoreState(Object o) -> ScoreState"""
1706  return _IMP_kernel._object_cast_to_ScoreState(o)
1707 
1708 _object_types.append("SingletonContainer")
1709 
1710 
1711 def _object_cast_to_SingletonContainer(o):
1712  """_object_cast_to_SingletonContainer(Object o) -> SingletonContainer"""
1713  return _IMP_kernel._object_cast_to_SingletonContainer(o)
1714 
1715 _object_types.append("SingletonModifier")
1716 
1717 
1718 def _object_cast_to_SingletonModifier(o):
1719  """_object_cast_to_SingletonModifier(Object o) -> SingletonModifier"""
1720  return _IMP_kernel._object_cast_to_SingletonModifier(o)
1721 
1722 _object_types.append("SingletonScore")
1723 
1724 
1725 def _object_cast_to_SingletonScore(o):
1726  """_object_cast_to_SingletonScore(Object o) -> SingletonScore"""
1727  return _IMP_kernel._object_cast_to_SingletonScore(o)
1728 
1729 _object_types.append("TripletContainer")
1730 
1731 
1732 def _object_cast_to_TripletContainer(o):
1733  """_object_cast_to_TripletContainer(Object o) -> TripletContainer"""
1734  return _IMP_kernel._object_cast_to_TripletContainer(o)
1735 
1736 _object_types.append("TripletModifier")
1737 
1738 
1739 def _object_cast_to_TripletModifier(o):
1740  """_object_cast_to_TripletModifier(Object o) -> TripletModifier"""
1741  return _IMP_kernel._object_cast_to_TripletModifier(o)
1742 
1743 _object_types.append("TripletScore")
1744 
1745 
1746 def _object_cast_to_TripletScore(o):
1747  """_object_cast_to_TripletScore(Object o) -> TripletScore"""
1748  return _IMP_kernel._object_cast_to_TripletScore(o)
1749 
1750 _object_types.append("UnaryFunction")
1751 
1752 
1753 def _object_cast_to_UnaryFunction(o):
1754  """_object_cast_to_UnaryFunction(Object o) -> UnaryFunction"""
1755  return _IMP_kernel._object_cast_to_UnaryFunction(o)
1756 
1757 _object_types.append("RestraintInfo")
1758 
1759 
1760 def _object_cast_to_RestraintInfo(o):
1761  """_object_cast_to_RestraintInfo(Object o) -> RestraintInfo"""
1762  return _IMP_kernel._object_cast_to_RestraintInfo(o)
1763 
1764 _object_types.append("ConfigurationSet")
1765 
1766 
1767 def _object_cast_to_ConfigurationSet(o):
1768  """_object_cast_to_ConfigurationSet(Object o) -> ConfigurationSet"""
1769  return _IMP_kernel._object_cast_to_ConfigurationSet(o)
1770 
1771 _object_types.append("Configuration")
1772 
1773 
1774 def _object_cast_to_Configuration(o):
1775  """_object_cast_to_Configuration(Object o) -> Configuration"""
1776  return _IMP_kernel._object_cast_to_Configuration(o)
1777 
1778 _object_types.append("Model")
1779 
1780 
1781 def _object_cast_to_Model(o):
1782  """_object_cast_to_Model(Object o) -> Model"""
1783  return _IMP_kernel._object_cast_to_Model(o)
1784 
1785 _object_types.append("Particle")
1786 
1787 
1788 def _object_cast_to_Particle(o):
1789  """_object_cast_to_Particle(Object o) -> Particle"""
1790  return _IMP_kernel._object_cast_to_Particle(o)
1791 
1792 _object_types.append("RestraintSet")
1793 
1794 
1795 def _object_cast_to_RestraintSet(o):
1796  """_object_cast_to_RestraintSet(Object o) -> RestraintSet"""
1797  return _IMP_kernel._object_cast_to_RestraintSet(o)
1798 
1799 ParticlePairsTemp=list
1800 _plural_types.append("ParticlePairsTemp")
1801 _value_types.append("ParticlePair")
1802 
1803 
1804 ParticleTripletsTemp=list
1805 _plural_types.append("ParticleTripletsTemp")
1806 _value_types.append("ParticleTriplet")
1807 
1808 
1809 ParticleQuadsTemp=list
1810 _plural_types.append("ParticleQuadsTemp")
1811 _value_types.append("ParticleQuad")
1812 
1813 
1814 ParticleIndexPairs=list
1815 _plural_types.append("ParticleIndexPairs")
1816 _value_types.append("ParticleIndexPair")
1817 
1818 
1819 ParticleIndexTriplets=list
1820 _plural_types.append("ParticleIndexTriplets")
1821 _value_types.append("ParticleIndexTriplet")
1822 
1823 
1824 ParticleIndexQuads=list
1825 _plural_types.append("ParticleIndexQuads")
1826 _value_types.append("ParticleIndexQuad")
1827 
1828 
1829 _object_types.append("SingletonPredicate")
1830 
1831 
1832 def _object_cast_to_SingletonPredicate(o):
1833  """_object_cast_to_SingletonPredicate(Object o) -> SingletonPredicate"""
1834  return _IMP_kernel._object_cast_to_SingletonPredicate(o)
1835 
1836 _object_types.append("PairPredicate")
1837 
1838 
1839 def _object_cast_to_PairPredicate(o):
1840  """_object_cast_to_PairPredicate(Object o) -> PairPredicate"""
1841  return _IMP_kernel._object_cast_to_PairPredicate(o)
1842 
1843 _object_types.append("TripletPredicate")
1844 
1845 
1846 def _object_cast_to_TripletPredicate(o):
1847  """_object_cast_to_TripletPredicate(Object o) -> TripletPredicate"""
1848  return _IMP_kernel._object_cast_to_TripletPredicate(o)
1849 
1850 _object_types.append("QuadPredicate")
1851 
1852 
1853 def _object_cast_to_QuadPredicate(o):
1854  """_object_cast_to_QuadPredicate(Object o) -> QuadPredicate"""
1855  return _IMP_kernel._object_cast_to_QuadPredicate(o)
1856 
1857 _object_types.append("SaveToConfigurationSetOptimizerState")
1858 
1859 
1860 def _object_cast_to_SaveToConfigurationSetOptimizerState(o):
1861  """_object_cast_to_SaveToConfigurationSetOptimizerState(Object o) -> SaveToConfigurationSetOptimizerState"""
1862  return _IMP_kernel._object_cast_to_SaveToConfigurationSetOptimizerState(o)
1863 
1864 EvaluationStates=list
1865 _plural_types.append("EvaluationStates")
1866 _value_types.append("EvaluationState")
1867 
1868 
1869 ScoreAccumulators=list
1870 _plural_types.append("ScoreAccumulators")
1871 _value_types.append("ScoreAccumulator")
1872 
1873 
1874 ParticleIndexes=list
1875 _plural_types.append("ParticleIndexes")
1876 _value_types.append("ParticleIndex")
1877 
1878 
1879 FloatIndexes=list
1880 _plural_types.append("FloatIndexes")
1881 _value_types.append("FloatIndex")
1882 
1883 
1884 FloatKeys=list
1885 _plural_types.append("FloatKeys")
1886 _value_types.append("FloatKey")
1887 
1888 
1889 FloatsKeys=list
1890 _plural_types.append("FloatsKeys")
1891 _value_types.append("FloatsKey")
1892 
1893 
1894 IntKeys=list
1895 _plural_types.append("IntKeys")
1896 _value_types.append("IntKey")
1897 
1898 
1899 IntsKeys=list
1900 _plural_types.append("IntsKeys")
1901 _value_types.append("IntsKey")
1902 
1903 
1904 StringKeys=list
1905 _plural_types.append("StringKeys")
1906 _value_types.append("StringKey")
1907 
1908 
1909 ParticleIndexKeys=list
1910 _plural_types.append("ParticleIndexKeys")
1911 _value_types.append("ParticleIndexKey")
1912 
1913 
1914 ParticleIndexesKeys=list
1915 _plural_types.append("ParticleIndexesKeys")
1916 _value_types.append("ParticleIndexesKey")
1917 
1918 
1919 ObjectKeys=list
1920 _plural_types.append("ObjectKeys")
1921 _value_types.append("ObjectKey")
1922 
1923 
1924 ModelKeys=list
1925 _plural_types.append("ModelKeys")
1926 _value_types.append("ModelKey")
1927 
1928 
1929 _raii_types.append("ScopedSetFloatAttribute")
1930 
1931 
1932 _object_types.append("ScoringFunction")
1933 
1934 
1935 def _object_cast_to_ScoringFunction(o):
1936  """_object_cast_to_ScoringFunction(Object o) -> ScoringFunction"""
1937  return _IMP_kernel._object_cast_to_ScoringFunction(o)
1938 
1939 _object_types.append("ModelObject")
1940 
1941 
1942 def _object_cast_to_ModelObject(o):
1943  """_object_cast_to_ModelObject(Object o) -> ModelObject"""
1944  return _IMP_kernel._object_cast_to_ModelObject(o)
1945 
1946 def _TrivialDecorators(l=[]):
1947  return [_TrivialDecorator(x) for x in l]
1948 _plural_types.append("_TrivialDecorators")
1949 
1950 
1951 _value_types.append("_TrivialDecorator")
1952 
1953 
1954 def _TrivialDerivedDecorators(l=[]):
1955  return [_TrivialDerivedDecorator(x) for x in l]
1956 _plural_types.append("_TrivialDerivedDecorators")
1957 
1958 
1959 _value_types.append("_TrivialDerivedDecorator")
1960 
1961 
1962 def _TrivialTraitsDecorators(l=[]):
1963  return [_TrivialTraitsDecorator(x) for x in l]
1964 _plural_types.append("_TrivialTraitsDecorators")
1965 
1966 
1967 _value_types.append("_TrivialTraitsDecorator")
1968 
1969 
1970 _object_types.append("_ConstRestraint")
1971 
1972 
1973 def _object_cast_to__ConstRestraint(o):
1974  """_object_cast_to__ConstRestraint(Object o) -> _ConstRestraint"""
1975  return _IMP_kernel._object_cast_to__ConstRestraint(o)
1976 
1977 _object_types.append("_ConstOptimizer")
1978 
1979 
1980 def _object_cast_to__ConstOptimizer(o):
1981  """_object_cast_to__ConstOptimizer(Object o) -> _ConstOptimizer"""
1982  return _IMP_kernel._object_cast_to__ConstOptimizer(o)
1983 class DependencyGraph(Object):
1984  """Proxy of C++ IMP::internal::BoostDigraph<(IMP::DependencyGraph,p.IMP::ModelObject,IMP::ShowDependencyGraphVertex)> class"""
1985  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1986  __repr__ = _swig_repr
1987 
1988  def __init__(self):
1989  """__init__(IMP::internal::BoostDigraph<(IMP::DependencyGraph,p.IMP::ModelObject,IMP::ShowDependencyGraphVertex)> self) -> DependencyGraph"""
1990  this = _IMP_kernel.new_DependencyGraph()
1991  try:
1992  self.this.append(this)
1993  except:
1994  self.this = this
1995 
1996  def get_graph(self):
1997  """get_graph(DependencyGraph self) -> IMP::DependencyGraph const &"""
1998  return _IMP_kernel.DependencyGraph_get_graph(self)
1999 
2000 
2001  def get_vertices(self):
2002  """get_vertices(DependencyGraph self) -> IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptors"""
2003  return _IMP_kernel.DependencyGraph_get_vertices(self)
2004 
2005 
2006  def get_vertex_name(self, i):
2007  """get_vertex_name(DependencyGraph self, IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptor i) -> ModelObject"""
2008  return _IMP_kernel.DependencyGraph_get_vertex_name(self, i)
2009 
2010 
2011  def get_in_neighbors(self, v):
2012  """get_in_neighbors(DependencyGraph self, IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptor v) -> IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptors"""
2013  return _IMP_kernel.DependencyGraph_get_in_neighbors(self, v)
2014 
2015 
2016  def get_out_neighbors(self, v):
2017  """get_out_neighbors(DependencyGraph self, IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptor v) -> IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptors"""
2018  return _IMP_kernel.DependencyGraph_get_out_neighbors(self, v)
2019 
2020 
2021  def show_graphviz(self, *args):
2022  """
2023  show_graphviz(DependencyGraph self, _ostream out)
2024  show_graphviz(DependencyGraph self)
2025  """
2026  return _IMP_kernel.DependencyGraph_show_graphviz(self, *args)
2027 
2028 
2029  def get_graphviz_string(self):
2030  """get_graphviz_string(DependencyGraph self) -> std::string"""
2031  return _IMP_kernel.DependencyGraph_get_graphviz_string(self)
2032 
2033 
2034  def add_edge(self, v0, v1):
2035  """add_edge(DependencyGraph self, IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptor v0, IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptor v1)"""
2036  return _IMP_kernel.DependencyGraph_add_edge(self, v0, v1)
2037 
2038 
2039  def add_vertex(self, l):
2040  """add_vertex(DependencyGraph self, ModelObject l) -> IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptor"""
2041  return _IMP_kernel.DependencyGraph_add_vertex(self, l)
2042 
2043 
2044  def remove_vertex(self, l):
2045  """remove_vertex(DependencyGraph self, IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptor l)"""
2046  return _IMP_kernel.DependencyGraph_remove_vertex(self, l)
2047 
2048  __swig_destroy__ = _IMP_kernel.delete_DependencyGraph
2049  __del__ = lambda self: None
2050 DependencyGraph_swigregister = _IMP_kernel.DependencyGraph_swigregister
2051 DependencyGraph_swigregister(DependencyGraph)
2052 
2053 
2054 _value_types.append("DependencyGraph")
2055 
2056 class FloatKey(_Value):
2057  """Proxy of C++ IMP::Key<(0)> class"""
2058  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2059 
2060  def __init__(self, *args):
2061  """
2062  __init__(IMP::Key<(0)> self) -> FloatKey
2063  __init__(IMP::Key<(0)> self, std::string const & c, bool is_implicit_add_permitted=True) -> FloatKey
2064  __init__(IMP::Key<(0)> self, std::string const & c) -> FloatKey
2065  __init__(IMP::Key<(0)> self, unsigned int i) -> FloatKey
2066  """
2067  this = _IMP_kernel.new_FloatKey(*args)
2068  try:
2069  self.this.append(this)
2070  except:
2071  self.this = this
2072 
2073  def add_key(sc):
2074  """add_key(std::string sc) -> unsigned int"""
2075  return _IMP_kernel.FloatKey_add_key(sc)
2076 
2077  add_key = staticmethod(add_key)
2078 
2079  def get_key_exists(sc):
2080  """get_key_exists(std::string sc) -> bool"""
2081  return _IMP_kernel.FloatKey_get_key_exists(sc)
2082 
2083  get_key_exists = staticmethod(get_key_exists)
2084 
2085  def get_string(self):
2086  """get_string(FloatKey self) -> std::string const"""
2087  return _IMP_kernel.FloatKey_get_string(self)
2088 
2089 
2090  def __cmp__(self, o):
2091  """__cmp__(FloatKey self, FloatKey o) -> int"""
2092  return _IMP_kernel.FloatKey___cmp__(self, o)
2093 
2094 
2095  def __eq__(self, o):
2096  """__eq__(FloatKey self, FloatKey o) -> bool"""
2097  return _IMP_kernel.FloatKey___eq__(self, o)
2098 
2099 
2100  def __ne__(self, o):
2101  """__ne__(FloatKey self, FloatKey o) -> bool"""
2102  return _IMP_kernel.FloatKey___ne__(self, o)
2103 
2104 
2105  def __lt__(self, o):
2106  """__lt__(FloatKey self, FloatKey o) -> bool"""
2107  return _IMP_kernel.FloatKey___lt__(self, o)
2108 
2109 
2110  def __gt__(self, o):
2111  """__gt__(FloatKey self, FloatKey o) -> bool"""
2112  return _IMP_kernel.FloatKey___gt__(self, o)
2113 
2114 
2115  def __ge__(self, o):
2116  """__ge__(FloatKey self, FloatKey o) -> bool"""
2117  return _IMP_kernel.FloatKey___ge__(self, o)
2118 
2119 
2120  def __le__(self, o):
2121  """__le__(FloatKey self, FloatKey o) -> bool"""
2122  return _IMP_kernel.FloatKey___le__(self, o)
2123 
2124 
2125  def __hash__(self):
2126  """__hash__(FloatKey self) -> std::size_t"""
2127  return _IMP_kernel.FloatKey___hash__(self)
2128 
2129 
2130  def show(self, *args):
2131  """
2132  show(FloatKey self, _ostream out)
2133  show(FloatKey self)
2134  """
2135  return _IMP_kernel.FloatKey_show(self, *args)
2136 
2137 
2138  def add_alias(old_key, new_name):
2139  """add_alias(FloatKey old_key, std::string new_name) -> FloatKey"""
2140  return _IMP_kernel.FloatKey_add_alias(old_key, new_name)
2141 
2142  add_alias = staticmethod(add_alias)
2143 
2144  def get_number_of_keys():
2145  """get_number_of_keys() -> unsigned int"""
2146  return _IMP_kernel.FloatKey_get_number_of_keys()
2147 
2148  get_number_of_keys = staticmethod(get_number_of_keys)
2149 
2150  def get_index(self):
2151  """get_index(FloatKey self) -> unsigned int"""
2152  return _IMP_kernel.FloatKey_get_index(self)
2153 
2154 
2155  def show_all(out):
2156  """show_all(_ostream out)"""
2157  return _IMP_kernel.FloatKey_show_all(out)
2158 
2159  show_all = staticmethod(show_all)
2160 
2161  def get_all_strings():
2162  """get_all_strings() -> IMP::Vector< std::string >"""
2163  return _IMP_kernel.FloatKey_get_all_strings()
2164 
2165  get_all_strings = staticmethod(get_all_strings)
2166 
2167  def get_number_unique():
2168  """get_number_unique() -> unsigned int"""
2169  return _IMP_kernel.FloatKey_get_number_unique()
2170 
2171  get_number_unique = staticmethod(get_number_unique)
2172 
2173  def __str__(self):
2174  """__str__(FloatKey self) -> std::string"""
2175  return _IMP_kernel.FloatKey___str__(self)
2176 
2177 
2178  def __repr__(self):
2179  """__repr__(FloatKey self) -> std::string"""
2180  return _IMP_kernel.FloatKey___repr__(self)
2181 
2182  __swig_destroy__ = _IMP_kernel.delete_FloatKey
2183  __del__ = lambda self: None
2184 FloatKey_swigregister = _IMP_kernel.FloatKey_swigregister
2185 FloatKey_swigregister(FloatKey)
2186 
2187 def FloatKey_add_key(sc):
2188  """FloatKey_add_key(std::string sc) -> unsigned int"""
2189  return _IMP_kernel.FloatKey_add_key(sc)
2190 
2191 def FloatKey_get_key_exists(sc):
2192  """FloatKey_get_key_exists(std::string sc) -> bool"""
2193  return _IMP_kernel.FloatKey_get_key_exists(sc)
2194 
2195 def FloatKey_add_alias(old_key, new_name):
2196  """FloatKey_add_alias(FloatKey old_key, std::string new_name) -> FloatKey"""
2197  return _IMP_kernel.FloatKey_add_alias(old_key, new_name)
2198 
2199 def FloatKey_get_number_of_keys():
2200  """FloatKey_get_number_of_keys() -> unsigned int"""
2201  return _IMP_kernel.FloatKey_get_number_of_keys()
2202 
2203 def FloatKey_show_all(out):
2204  """FloatKey_show_all(_ostream out)"""
2205  return _IMP_kernel.FloatKey_show_all(out)
2206 
2207 def FloatKey_get_all_strings():
2208  """FloatKey_get_all_strings() -> IMP::Vector< std::string >"""
2209  return _IMP_kernel.FloatKey_get_all_strings()
2210 
2211 def FloatKey_get_number_unique():
2212  """FloatKey_get_number_unique() -> unsigned int"""
2213  return _IMP_kernel.FloatKey_get_number_unique()
2214 
2215 class IntKey(_Value):
2216  """Proxy of C++ IMP::Key<(1)> class"""
2217  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2218 
2219  def __init__(self, *args):
2220  """
2221  __init__(IMP::Key<(1)> self) -> IntKey
2222  __init__(IMP::Key<(1)> self, std::string const & c, bool is_implicit_add_permitted=True) -> IntKey
2223  __init__(IMP::Key<(1)> self, std::string const & c) -> IntKey
2224  __init__(IMP::Key<(1)> self, unsigned int i) -> IntKey
2225  """
2226  this = _IMP_kernel.new_IntKey(*args)
2227  try:
2228  self.this.append(this)
2229  except:
2230  self.this = this
2231 
2232  def add_key(sc):
2233  """add_key(std::string sc) -> unsigned int"""
2234  return _IMP_kernel.IntKey_add_key(sc)
2235 
2236  add_key = staticmethod(add_key)
2237 
2238  def get_key_exists(sc):
2239  """get_key_exists(std::string sc) -> bool"""
2240  return _IMP_kernel.IntKey_get_key_exists(sc)
2241 
2242  get_key_exists = staticmethod(get_key_exists)
2243 
2244  def get_string(self):
2245  """get_string(IntKey self) -> std::string const"""
2246  return _IMP_kernel.IntKey_get_string(self)
2247 
2248 
2249  def __cmp__(self, o):
2250  """__cmp__(IntKey self, IntKey o) -> int"""
2251  return _IMP_kernel.IntKey___cmp__(self, o)
2252 
2253 
2254  def __eq__(self, o):
2255  """__eq__(IntKey self, IntKey o) -> bool"""
2256  return _IMP_kernel.IntKey___eq__(self, o)
2257 
2258 
2259  def __ne__(self, o):
2260  """__ne__(IntKey self, IntKey o) -> bool"""
2261  return _IMP_kernel.IntKey___ne__(self, o)
2262 
2263 
2264  def __lt__(self, o):
2265  """__lt__(IntKey self, IntKey o) -> bool"""
2266  return _IMP_kernel.IntKey___lt__(self, o)
2267 
2268 
2269  def __gt__(self, o):
2270  """__gt__(IntKey self, IntKey o) -> bool"""
2271  return _IMP_kernel.IntKey___gt__(self, o)
2272 
2273 
2274  def __ge__(self, o):
2275  """__ge__(IntKey self, IntKey o) -> bool"""
2276  return _IMP_kernel.IntKey___ge__(self, o)
2277 
2278 
2279  def __le__(self, o):
2280  """__le__(IntKey self, IntKey o) -> bool"""
2281  return _IMP_kernel.IntKey___le__(self, o)
2282 
2283 
2284  def __hash__(self):
2285  """__hash__(IntKey self) -> std::size_t"""
2286  return _IMP_kernel.IntKey___hash__(self)
2287 
2288 
2289  def show(self, *args):
2290  """
2291  show(IntKey self, _ostream out)
2292  show(IntKey self)
2293  """
2294  return _IMP_kernel.IntKey_show(self, *args)
2295 
2296 
2297  def add_alias(old_key, new_name):
2298  """add_alias(IntKey old_key, std::string new_name) -> IntKey"""
2299  return _IMP_kernel.IntKey_add_alias(old_key, new_name)
2300 
2301  add_alias = staticmethod(add_alias)
2302 
2303  def get_number_of_keys():
2304  """get_number_of_keys() -> unsigned int"""
2305  return _IMP_kernel.IntKey_get_number_of_keys()
2306 
2307  get_number_of_keys = staticmethod(get_number_of_keys)
2308 
2309  def get_index(self):
2310  """get_index(IntKey self) -> unsigned int"""
2311  return _IMP_kernel.IntKey_get_index(self)
2312 
2313 
2314  def show_all(out):
2315  """show_all(_ostream out)"""
2316  return _IMP_kernel.IntKey_show_all(out)
2317 
2318  show_all = staticmethod(show_all)
2319 
2320  def get_all_strings():
2321  """get_all_strings() -> IMP::Vector< std::string >"""
2322  return _IMP_kernel.IntKey_get_all_strings()
2323 
2324  get_all_strings = staticmethod(get_all_strings)
2325 
2326  def get_number_unique():
2327  """get_number_unique() -> unsigned int"""
2328  return _IMP_kernel.IntKey_get_number_unique()
2329 
2330  get_number_unique = staticmethod(get_number_unique)
2331 
2332  def __str__(self):
2333  """__str__(IntKey self) -> std::string"""
2334  return _IMP_kernel.IntKey___str__(self)
2335 
2336 
2337  def __repr__(self):
2338  """__repr__(IntKey self) -> std::string"""
2339  return _IMP_kernel.IntKey___repr__(self)
2340 
2341  __swig_destroy__ = _IMP_kernel.delete_IntKey
2342  __del__ = lambda self: None
2343 IntKey_swigregister = _IMP_kernel.IntKey_swigregister
2344 IntKey_swigregister(IntKey)
2345 
2346 def IntKey_add_key(sc):
2347  """IntKey_add_key(std::string sc) -> unsigned int"""
2348  return _IMP_kernel.IntKey_add_key(sc)
2349 
2350 def IntKey_get_key_exists(sc):
2351  """IntKey_get_key_exists(std::string sc) -> bool"""
2352  return _IMP_kernel.IntKey_get_key_exists(sc)
2353 
2354 def IntKey_add_alias(old_key, new_name):
2355  """IntKey_add_alias(IntKey old_key, std::string new_name) -> IntKey"""
2356  return _IMP_kernel.IntKey_add_alias(old_key, new_name)
2357 
2358 def IntKey_get_number_of_keys():
2359  """IntKey_get_number_of_keys() -> unsigned int"""
2360  return _IMP_kernel.IntKey_get_number_of_keys()
2361 
2362 def IntKey_show_all(out):
2363  """IntKey_show_all(_ostream out)"""
2364  return _IMP_kernel.IntKey_show_all(out)
2365 
2366 def IntKey_get_all_strings():
2367  """IntKey_get_all_strings() -> IMP::Vector< std::string >"""
2368  return _IMP_kernel.IntKey_get_all_strings()
2369 
2370 def IntKey_get_number_unique():
2371  """IntKey_get_number_unique() -> unsigned int"""
2372  return _IMP_kernel.IntKey_get_number_unique()
2373 
2374 class StringKey(_Value):
2375  """Proxy of C++ IMP::Key<(2)> class"""
2376  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2377 
2378  def __init__(self, *args):
2379  """
2380  __init__(IMP::Key<(2)> self) -> StringKey
2381  __init__(IMP::Key<(2)> self, std::string const & c, bool is_implicit_add_permitted=True) -> StringKey
2382  __init__(IMP::Key<(2)> self, std::string const & c) -> StringKey
2383  __init__(IMP::Key<(2)> self, unsigned int i) -> StringKey
2384  """
2385  this = _IMP_kernel.new_StringKey(*args)
2386  try:
2387  self.this.append(this)
2388  except:
2389  self.this = this
2390 
2391  def add_key(sc):
2392  """add_key(std::string sc) -> unsigned int"""
2393  return _IMP_kernel.StringKey_add_key(sc)
2394 
2395  add_key = staticmethod(add_key)
2396 
2397  def get_key_exists(sc):
2398  """get_key_exists(std::string sc) -> bool"""
2399  return _IMP_kernel.StringKey_get_key_exists(sc)
2400 
2401  get_key_exists = staticmethod(get_key_exists)
2402 
2403  def get_string(self):
2404  """get_string(StringKey self) -> std::string const"""
2405  return _IMP_kernel.StringKey_get_string(self)
2406 
2407 
2408  def __cmp__(self, o):
2409  """__cmp__(StringKey self, StringKey o) -> int"""
2410  return _IMP_kernel.StringKey___cmp__(self, o)
2411 
2412 
2413  def __eq__(self, o):
2414  """__eq__(StringKey self, StringKey o) -> bool"""
2415  return _IMP_kernel.StringKey___eq__(self, o)
2416 
2417 
2418  def __ne__(self, o):
2419  """__ne__(StringKey self, StringKey o) -> bool"""
2420  return _IMP_kernel.StringKey___ne__(self, o)
2421 
2422 
2423  def __lt__(self, o):
2424  """__lt__(StringKey self, StringKey o) -> bool"""
2425  return _IMP_kernel.StringKey___lt__(self, o)
2426 
2427 
2428  def __gt__(self, o):
2429  """__gt__(StringKey self, StringKey o) -> bool"""
2430  return _IMP_kernel.StringKey___gt__(self, o)
2431 
2432 
2433  def __ge__(self, o):
2434  """__ge__(StringKey self, StringKey o) -> bool"""
2435  return _IMP_kernel.StringKey___ge__(self, o)
2436 
2437 
2438  def __le__(self, o):
2439  """__le__(StringKey self, StringKey o) -> bool"""
2440  return _IMP_kernel.StringKey___le__(self, o)
2441 
2442 
2443  def __hash__(self):
2444  """__hash__(StringKey self) -> std::size_t"""
2445  return _IMP_kernel.StringKey___hash__(self)
2446 
2447 
2448  def show(self, *args):
2449  """
2450  show(StringKey self, _ostream out)
2451  show(StringKey self)
2452  """
2453  return _IMP_kernel.StringKey_show(self, *args)
2454 
2455 
2456  def add_alias(old_key, new_name):
2457  """add_alias(StringKey old_key, std::string new_name) -> StringKey"""
2458  return _IMP_kernel.StringKey_add_alias(old_key, new_name)
2459 
2460  add_alias = staticmethod(add_alias)
2461 
2462  def get_number_of_keys():
2463  """get_number_of_keys() -> unsigned int"""
2464  return _IMP_kernel.StringKey_get_number_of_keys()
2465 
2466  get_number_of_keys = staticmethod(get_number_of_keys)
2467 
2468  def get_index(self):
2469  """get_index(StringKey self) -> unsigned int"""
2470  return _IMP_kernel.StringKey_get_index(self)
2471 
2472 
2473  def show_all(out):
2474  """show_all(_ostream out)"""
2475  return _IMP_kernel.StringKey_show_all(out)
2476 
2477  show_all = staticmethod(show_all)
2478 
2479  def get_all_strings():
2480  """get_all_strings() -> IMP::Vector< std::string >"""
2481  return _IMP_kernel.StringKey_get_all_strings()
2482 
2483  get_all_strings = staticmethod(get_all_strings)
2484 
2485  def get_number_unique():
2486  """get_number_unique() -> unsigned int"""
2487  return _IMP_kernel.StringKey_get_number_unique()
2488 
2489  get_number_unique = staticmethod(get_number_unique)
2490 
2491  def __str__(self):
2492  """__str__(StringKey self) -> std::string"""
2493  return _IMP_kernel.StringKey___str__(self)
2494 
2495 
2496  def __repr__(self):
2497  """__repr__(StringKey self) -> std::string"""
2498  return _IMP_kernel.StringKey___repr__(self)
2499 
2500  __swig_destroy__ = _IMP_kernel.delete_StringKey
2501  __del__ = lambda self: None
2502 StringKey_swigregister = _IMP_kernel.StringKey_swigregister
2503 StringKey_swigregister(StringKey)
2504 
2505 def StringKey_add_key(sc):
2506  """StringKey_add_key(std::string sc) -> unsigned int"""
2507  return _IMP_kernel.StringKey_add_key(sc)
2508 
2509 def StringKey_get_key_exists(sc):
2510  """StringKey_get_key_exists(std::string sc) -> bool"""
2511  return _IMP_kernel.StringKey_get_key_exists(sc)
2512 
2513 def StringKey_add_alias(old_key, new_name):
2514  """StringKey_add_alias(StringKey old_key, std::string new_name) -> StringKey"""
2515  return _IMP_kernel.StringKey_add_alias(old_key, new_name)
2516 
2517 def StringKey_get_number_of_keys():
2518  """StringKey_get_number_of_keys() -> unsigned int"""
2519  return _IMP_kernel.StringKey_get_number_of_keys()
2520 
2521 def StringKey_show_all(out):
2522  """StringKey_show_all(_ostream out)"""
2523  return _IMP_kernel.StringKey_show_all(out)
2524 
2525 def StringKey_get_all_strings():
2526  """StringKey_get_all_strings() -> IMP::Vector< std::string >"""
2527  return _IMP_kernel.StringKey_get_all_strings()
2528 
2529 def StringKey_get_number_unique():
2530  """StringKey_get_number_unique() -> unsigned int"""
2531  return _IMP_kernel.StringKey_get_number_unique()
2532 
2533 class ParticleIndexKey(_Value):
2534  """Proxy of C++ IMP::Key<(3)> class"""
2535  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2536 
2537  def __init__(self, *args):
2538  """
2539  __init__(IMP::Key<(3)> self) -> ParticleIndexKey
2540  __init__(IMP::Key<(3)> self, std::string const & c, bool is_implicit_add_permitted=True) -> ParticleIndexKey
2541  __init__(IMP::Key<(3)> self, std::string const & c) -> ParticleIndexKey
2542  __init__(IMP::Key<(3)> self, unsigned int i) -> ParticleIndexKey
2543  """
2544  this = _IMP_kernel.new_ParticleIndexKey(*args)
2545  try:
2546  self.this.append(this)
2547  except:
2548  self.this = this
2549 
2550  def add_key(sc):
2551  """add_key(std::string sc) -> unsigned int"""
2552  return _IMP_kernel.ParticleIndexKey_add_key(sc)
2553 
2554  add_key = staticmethod(add_key)
2555 
2556  def get_key_exists(sc):
2557  """get_key_exists(std::string sc) -> bool"""
2558  return _IMP_kernel.ParticleIndexKey_get_key_exists(sc)
2559 
2560  get_key_exists = staticmethod(get_key_exists)
2561 
2562  def get_string(self):
2563  """get_string(ParticleIndexKey self) -> std::string const"""
2564  return _IMP_kernel.ParticleIndexKey_get_string(self)
2565 
2566 
2567  def __cmp__(self, o):
2568  """__cmp__(ParticleIndexKey self, ParticleIndexKey o) -> int"""
2569  return _IMP_kernel.ParticleIndexKey___cmp__(self, o)
2570 
2571 
2572  def __eq__(self, o):
2573  """__eq__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2574  return _IMP_kernel.ParticleIndexKey___eq__(self, o)
2575 
2576 
2577  def __ne__(self, o):
2578  """__ne__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2579  return _IMP_kernel.ParticleIndexKey___ne__(self, o)
2580 
2581 
2582  def __lt__(self, o):
2583  """__lt__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2584  return _IMP_kernel.ParticleIndexKey___lt__(self, o)
2585 
2586 
2587  def __gt__(self, o):
2588  """__gt__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2589  return _IMP_kernel.ParticleIndexKey___gt__(self, o)
2590 
2591 
2592  def __ge__(self, o):
2593  """__ge__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2594  return _IMP_kernel.ParticleIndexKey___ge__(self, o)
2595 
2596 
2597  def __le__(self, o):
2598  """__le__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2599  return _IMP_kernel.ParticleIndexKey___le__(self, o)
2600 
2601 
2602  def __hash__(self):
2603  """__hash__(ParticleIndexKey self) -> std::size_t"""
2604  return _IMP_kernel.ParticleIndexKey___hash__(self)
2605 
2606 
2607  def show(self, *args):
2608  """
2609  show(ParticleIndexKey self, _ostream out)
2610  show(ParticleIndexKey self)
2611  """
2612  return _IMP_kernel.ParticleIndexKey_show(self, *args)
2613 
2614 
2615  def add_alias(old_key, new_name):
2616  """add_alias(ParticleIndexKey old_key, std::string new_name) -> ParticleIndexKey"""
2617  return _IMP_kernel.ParticleIndexKey_add_alias(old_key, new_name)
2618 
2619  add_alias = staticmethod(add_alias)
2620 
2621  def get_number_of_keys():
2622  """get_number_of_keys() -> unsigned int"""
2623  return _IMP_kernel.ParticleIndexKey_get_number_of_keys()
2624 
2625  get_number_of_keys = staticmethod(get_number_of_keys)
2626 
2627  def get_index(self):
2628  """get_index(ParticleIndexKey self) -> unsigned int"""
2629  return _IMP_kernel.ParticleIndexKey_get_index(self)
2630 
2631 
2632  def show_all(out):
2633  """show_all(_ostream out)"""
2634  return _IMP_kernel.ParticleIndexKey_show_all(out)
2635 
2636  show_all = staticmethod(show_all)
2637 
2638  def get_all_strings():
2639  """get_all_strings() -> IMP::Vector< std::string >"""
2640  return _IMP_kernel.ParticleIndexKey_get_all_strings()
2641 
2642  get_all_strings = staticmethod(get_all_strings)
2643 
2644  def get_number_unique():
2645  """get_number_unique() -> unsigned int"""
2646  return _IMP_kernel.ParticleIndexKey_get_number_unique()
2647 
2648  get_number_unique = staticmethod(get_number_unique)
2649 
2650  def __str__(self):
2651  """__str__(ParticleIndexKey self) -> std::string"""
2652  return _IMP_kernel.ParticleIndexKey___str__(self)
2653 
2654 
2655  def __repr__(self):
2656  """__repr__(ParticleIndexKey self) -> std::string"""
2657  return _IMP_kernel.ParticleIndexKey___repr__(self)
2658 
2659  __swig_destroy__ = _IMP_kernel.delete_ParticleIndexKey
2660  __del__ = lambda self: None
2661 ParticleIndexKey_swigregister = _IMP_kernel.ParticleIndexKey_swigregister
2662 ParticleIndexKey_swigregister(ParticleIndexKey)
2663 
2664 def ParticleIndexKey_add_key(sc):
2665  """ParticleIndexKey_add_key(std::string sc) -> unsigned int"""
2666  return _IMP_kernel.ParticleIndexKey_add_key(sc)
2667 
2668 def ParticleIndexKey_get_key_exists(sc):
2669  """ParticleIndexKey_get_key_exists(std::string sc) -> bool"""
2670  return _IMP_kernel.ParticleIndexKey_get_key_exists(sc)
2671 
2672 def ParticleIndexKey_add_alias(old_key, new_name):
2673  """ParticleIndexKey_add_alias(ParticleIndexKey old_key, std::string new_name) -> ParticleIndexKey"""
2674  return _IMP_kernel.ParticleIndexKey_add_alias(old_key, new_name)
2675 
2676 def ParticleIndexKey_get_number_of_keys():
2677  """ParticleIndexKey_get_number_of_keys() -> unsigned int"""
2678  return _IMP_kernel.ParticleIndexKey_get_number_of_keys()
2679 
2680 def ParticleIndexKey_show_all(out):
2681  """ParticleIndexKey_show_all(_ostream out)"""
2682  return _IMP_kernel.ParticleIndexKey_show_all(out)
2683 
2684 def ParticleIndexKey_get_all_strings():
2685  """ParticleIndexKey_get_all_strings() -> IMP::Vector< std::string >"""
2686  return _IMP_kernel.ParticleIndexKey_get_all_strings()
2687 
2688 def ParticleIndexKey_get_number_unique():
2689  """ParticleIndexKey_get_number_unique() -> unsigned int"""
2690  return _IMP_kernel.ParticleIndexKey_get_number_unique()
2691 
2692 class ObjectKey(_Value):
2693  """Proxy of C++ IMP::Key<(4)> class"""
2694  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2695 
2696  def __init__(self, *args):
2697  """
2698  __init__(IMP::Key<(4)> self) -> ObjectKey
2699  __init__(IMP::Key<(4)> self, std::string const & c, bool is_implicit_add_permitted=True) -> ObjectKey
2700  __init__(IMP::Key<(4)> self, std::string const & c) -> ObjectKey
2701  __init__(IMP::Key<(4)> self, unsigned int i) -> ObjectKey
2702  """
2703  this = _IMP_kernel.new_ObjectKey(*args)
2704  try:
2705  self.this.append(this)
2706  except:
2707  self.this = this
2708 
2709  def add_key(sc):
2710  """add_key(std::string sc) -> unsigned int"""
2711  return _IMP_kernel.ObjectKey_add_key(sc)
2712 
2713  add_key = staticmethod(add_key)
2714 
2715  def get_key_exists(sc):
2716  """get_key_exists(std::string sc) -> bool"""
2717  return _IMP_kernel.ObjectKey_get_key_exists(sc)
2718 
2719  get_key_exists = staticmethod(get_key_exists)
2720 
2721  def get_string(self):
2722  """get_string(ObjectKey self) -> std::string const"""
2723  return _IMP_kernel.ObjectKey_get_string(self)
2724 
2725 
2726  def __cmp__(self, o):
2727  """__cmp__(ObjectKey self, ObjectKey o) -> int"""
2728  return _IMP_kernel.ObjectKey___cmp__(self, o)
2729 
2730 
2731  def __eq__(self, o):
2732  """__eq__(ObjectKey self, ObjectKey o) -> bool"""
2733  return _IMP_kernel.ObjectKey___eq__(self, o)
2734 
2735 
2736  def __ne__(self, o):
2737  """__ne__(ObjectKey self, ObjectKey o) -> bool"""
2738  return _IMP_kernel.ObjectKey___ne__(self, o)
2739 
2740 
2741  def __lt__(self, o):
2742  """__lt__(ObjectKey self, ObjectKey o) -> bool"""
2743  return _IMP_kernel.ObjectKey___lt__(self, o)
2744 
2745 
2746  def __gt__(self, o):
2747  """__gt__(ObjectKey self, ObjectKey o) -> bool"""
2748  return _IMP_kernel.ObjectKey___gt__(self, o)
2749 
2750 
2751  def __ge__(self, o):
2752  """__ge__(ObjectKey self, ObjectKey o) -> bool"""
2753  return _IMP_kernel.ObjectKey___ge__(self, o)
2754 
2755 
2756  def __le__(self, o):
2757  """__le__(ObjectKey self, ObjectKey o) -> bool"""
2758  return _IMP_kernel.ObjectKey___le__(self, o)
2759 
2760 
2761  def __hash__(self):
2762  """__hash__(ObjectKey self) -> std::size_t"""
2763  return _IMP_kernel.ObjectKey___hash__(self)
2764 
2765 
2766  def show(self, *args):
2767  """
2768  show(ObjectKey self, _ostream out)
2769  show(ObjectKey self)
2770  """
2771  return _IMP_kernel.ObjectKey_show(self, *args)
2772 
2773 
2774  def add_alias(old_key, new_name):
2775  """add_alias(ObjectKey old_key, std::string new_name) -> ObjectKey"""
2776  return _IMP_kernel.ObjectKey_add_alias(old_key, new_name)
2777 
2778  add_alias = staticmethod(add_alias)
2779 
2780  def get_number_of_keys():
2781  """get_number_of_keys() -> unsigned int"""
2782  return _IMP_kernel.ObjectKey_get_number_of_keys()
2783 
2784  get_number_of_keys = staticmethod(get_number_of_keys)
2785 
2786  def get_index(self):
2787  """get_index(ObjectKey self) -> unsigned int"""
2788  return _IMP_kernel.ObjectKey_get_index(self)
2789 
2790 
2791  def show_all(out):
2792  """show_all(_ostream out)"""
2793  return _IMP_kernel.ObjectKey_show_all(out)
2794 
2795  show_all = staticmethod(show_all)
2796 
2797  def get_all_strings():
2798  """get_all_strings() -> IMP::Vector< std::string >"""
2799  return _IMP_kernel.ObjectKey_get_all_strings()
2800 
2801  get_all_strings = staticmethod(get_all_strings)
2802 
2803  def get_number_unique():
2804  """get_number_unique() -> unsigned int"""
2805  return _IMP_kernel.ObjectKey_get_number_unique()
2806 
2807  get_number_unique = staticmethod(get_number_unique)
2808 
2809  def __str__(self):
2810  """__str__(ObjectKey self) -> std::string"""
2811  return _IMP_kernel.ObjectKey___str__(self)
2812 
2813 
2814  def __repr__(self):
2815  """__repr__(ObjectKey self) -> std::string"""
2816  return _IMP_kernel.ObjectKey___repr__(self)
2817 
2818  __swig_destroy__ = _IMP_kernel.delete_ObjectKey
2819  __del__ = lambda self: None
2820 ObjectKey_swigregister = _IMP_kernel.ObjectKey_swigregister
2821 ObjectKey_swigregister(ObjectKey)
2822 
2823 def ObjectKey_add_key(sc):
2824  """ObjectKey_add_key(std::string sc) -> unsigned int"""
2825  return _IMP_kernel.ObjectKey_add_key(sc)
2826 
2827 def ObjectKey_get_key_exists(sc):
2828  """ObjectKey_get_key_exists(std::string sc) -> bool"""
2829  return _IMP_kernel.ObjectKey_get_key_exists(sc)
2830 
2831 def ObjectKey_add_alias(old_key, new_name):
2832  """ObjectKey_add_alias(ObjectKey old_key, std::string new_name) -> ObjectKey"""
2833  return _IMP_kernel.ObjectKey_add_alias(old_key, new_name)
2834 
2835 def ObjectKey_get_number_of_keys():
2836  """ObjectKey_get_number_of_keys() -> unsigned int"""
2837  return _IMP_kernel.ObjectKey_get_number_of_keys()
2838 
2839 def ObjectKey_show_all(out):
2840  """ObjectKey_show_all(_ostream out)"""
2841  return _IMP_kernel.ObjectKey_show_all(out)
2842 
2843 def ObjectKey_get_all_strings():
2844  """ObjectKey_get_all_strings() -> IMP::Vector< std::string >"""
2845  return _IMP_kernel.ObjectKey_get_all_strings()
2846 
2847 def ObjectKey_get_number_unique():
2848  """ObjectKey_get_number_unique() -> unsigned int"""
2849  return _IMP_kernel.ObjectKey_get_number_unique()
2850 
2851 class IntsKey(_Value):
2852  """Proxy of C++ IMP::Key<(5)> class"""
2853  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2854 
2855  def __init__(self, *args):
2856  """
2857  __init__(IMP::Key<(5)> self) -> IntsKey
2858  __init__(IMP::Key<(5)> self, std::string const & c, bool is_implicit_add_permitted=True) -> IntsKey
2859  __init__(IMP::Key<(5)> self, std::string const & c) -> IntsKey
2860  __init__(IMP::Key<(5)> self, unsigned int i) -> IntsKey
2861  """
2862  this = _IMP_kernel.new_IntsKey(*args)
2863  try:
2864  self.this.append(this)
2865  except:
2866  self.this = this
2867 
2868  def add_key(sc):
2869  """add_key(std::string sc) -> unsigned int"""
2870  return _IMP_kernel.IntsKey_add_key(sc)
2871 
2872  add_key = staticmethod(add_key)
2873 
2874  def get_key_exists(sc):
2875  """get_key_exists(std::string sc) -> bool"""
2876  return _IMP_kernel.IntsKey_get_key_exists(sc)
2877 
2878  get_key_exists = staticmethod(get_key_exists)
2879 
2880  def get_string(self):
2881  """get_string(IntsKey self) -> std::string const"""
2882  return _IMP_kernel.IntsKey_get_string(self)
2883 
2884 
2885  def __cmp__(self, o):
2886  """__cmp__(IntsKey self, IntsKey o) -> int"""
2887  return _IMP_kernel.IntsKey___cmp__(self, o)
2888 
2889 
2890  def __eq__(self, o):
2891  """__eq__(IntsKey self, IntsKey o) -> bool"""
2892  return _IMP_kernel.IntsKey___eq__(self, o)
2893 
2894 
2895  def __ne__(self, o):
2896  """__ne__(IntsKey self, IntsKey o) -> bool"""
2897  return _IMP_kernel.IntsKey___ne__(self, o)
2898 
2899 
2900  def __lt__(self, o):
2901  """__lt__(IntsKey self, IntsKey o) -> bool"""
2902  return _IMP_kernel.IntsKey___lt__(self, o)
2903 
2904 
2905  def __gt__(self, o):
2906  """__gt__(IntsKey self, IntsKey o) -> bool"""
2907  return _IMP_kernel.IntsKey___gt__(self, o)
2908 
2909 
2910  def __ge__(self, o):
2911  """__ge__(IntsKey self, IntsKey o) -> bool"""
2912  return _IMP_kernel.IntsKey___ge__(self, o)
2913 
2914 
2915  def __le__(self, o):
2916  """__le__(IntsKey self, IntsKey o) -> bool"""
2917  return _IMP_kernel.IntsKey___le__(self, o)
2918 
2919 
2920  def __hash__(self):
2921  """__hash__(IntsKey self) -> std::size_t"""
2922  return _IMP_kernel.IntsKey___hash__(self)
2923 
2924 
2925  def show(self, *args):
2926  """
2927  show(IntsKey self, _ostream out)
2928  show(IntsKey self)
2929  """
2930  return _IMP_kernel.IntsKey_show(self, *args)
2931 
2932 
2933  def add_alias(old_key, new_name):
2934  """add_alias(IntsKey old_key, std::string new_name) -> IntsKey"""
2935  return _IMP_kernel.IntsKey_add_alias(old_key, new_name)
2936 
2937  add_alias = staticmethod(add_alias)
2938 
2939  def get_number_of_keys():
2940  """get_number_of_keys() -> unsigned int"""
2941  return _IMP_kernel.IntsKey_get_number_of_keys()
2942 
2943  get_number_of_keys = staticmethod(get_number_of_keys)
2944 
2945  def get_index(self):
2946  """get_index(IntsKey self) -> unsigned int"""
2947  return _IMP_kernel.IntsKey_get_index(self)
2948 
2949 
2950  def show_all(out):
2951  """show_all(_ostream out)"""
2952  return _IMP_kernel.IntsKey_show_all(out)
2953 
2954  show_all = staticmethod(show_all)
2955 
2956  def get_all_strings():
2957  """get_all_strings() -> IMP::Vector< std::string >"""
2958  return _IMP_kernel.IntsKey_get_all_strings()
2959 
2960  get_all_strings = staticmethod(get_all_strings)
2961 
2962  def get_number_unique():
2963  """get_number_unique() -> unsigned int"""
2964  return _IMP_kernel.IntsKey_get_number_unique()
2965 
2966  get_number_unique = staticmethod(get_number_unique)
2967 
2968  def __str__(self):
2969  """__str__(IntsKey self) -> std::string"""
2970  return _IMP_kernel.IntsKey___str__(self)
2971 
2972 
2973  def __repr__(self):
2974  """__repr__(IntsKey self) -> std::string"""
2975  return _IMP_kernel.IntsKey___repr__(self)
2976 
2977  __swig_destroy__ = _IMP_kernel.delete_IntsKey
2978  __del__ = lambda self: None
2979 IntsKey_swigregister = _IMP_kernel.IntsKey_swigregister
2980 IntsKey_swigregister(IntsKey)
2981 
2982 def IntsKey_add_key(sc):
2983  """IntsKey_add_key(std::string sc) -> unsigned int"""
2984  return _IMP_kernel.IntsKey_add_key(sc)
2985 
2986 def IntsKey_get_key_exists(sc):
2987  """IntsKey_get_key_exists(std::string sc) -> bool"""
2988  return _IMP_kernel.IntsKey_get_key_exists(sc)
2989 
2990 def IntsKey_add_alias(old_key, new_name):
2991  """IntsKey_add_alias(IntsKey old_key, std::string new_name) -> IntsKey"""
2992  return _IMP_kernel.IntsKey_add_alias(old_key, new_name)
2993 
2994 def IntsKey_get_number_of_keys():
2995  """IntsKey_get_number_of_keys() -> unsigned int"""
2996  return _IMP_kernel.IntsKey_get_number_of_keys()
2997 
2998 def IntsKey_show_all(out):
2999  """IntsKey_show_all(_ostream out)"""
3000  return _IMP_kernel.IntsKey_show_all(out)
3001 
3002 def IntsKey_get_all_strings():
3003  """IntsKey_get_all_strings() -> IMP::Vector< std::string >"""
3004  return _IMP_kernel.IntsKey_get_all_strings()
3005 
3006 def IntsKey_get_number_unique():
3007  """IntsKey_get_number_unique() -> unsigned int"""
3008  return _IMP_kernel.IntsKey_get_number_unique()
3009 
3010 class ParticleIndexesKey(_Value):
3011  """Proxy of C++ IMP::Key<(6)> class"""
3012  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3013 
3014  def __init__(self, *args):
3015  """
3016  __init__(IMP::Key<(6)> self) -> ParticleIndexesKey
3017  __init__(IMP::Key<(6)> self, std::string const & c, bool is_implicit_add_permitted=True) -> ParticleIndexesKey
3018  __init__(IMP::Key<(6)> self, std::string const & c) -> ParticleIndexesKey
3019  __init__(IMP::Key<(6)> self, unsigned int i) -> ParticleIndexesKey
3020  """
3021  this = _IMP_kernel.new_ParticleIndexesKey(*args)
3022  try:
3023  self.this.append(this)
3024  except:
3025  self.this = this
3026 
3027  def add_key(sc):
3028  """add_key(std::string sc) -> unsigned int"""
3029  return _IMP_kernel.ParticleIndexesKey_add_key(sc)
3030 
3031  add_key = staticmethod(add_key)
3032 
3033  def get_key_exists(sc):
3034  """get_key_exists(std::string sc) -> bool"""
3035  return _IMP_kernel.ParticleIndexesKey_get_key_exists(sc)
3036 
3037  get_key_exists = staticmethod(get_key_exists)
3038 
3039  def get_string(self):
3040  """get_string(ParticleIndexesKey self) -> std::string const"""
3041  return _IMP_kernel.ParticleIndexesKey_get_string(self)
3042 
3043 
3044  def __cmp__(self, o):
3045  """__cmp__(ParticleIndexesKey self, ParticleIndexesKey o) -> int"""
3046  return _IMP_kernel.ParticleIndexesKey___cmp__(self, o)
3047 
3048 
3049  def __eq__(self, o):
3050  """__eq__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
3051  return _IMP_kernel.ParticleIndexesKey___eq__(self, o)
3052 
3053 
3054  def __ne__(self, o):
3055  """__ne__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
3056  return _IMP_kernel.ParticleIndexesKey___ne__(self, o)
3057 
3058 
3059  def __lt__(self, o):
3060  """__lt__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
3061  return _IMP_kernel.ParticleIndexesKey___lt__(self, o)
3062 
3063 
3064  def __gt__(self, o):
3065  """__gt__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
3066  return _IMP_kernel.ParticleIndexesKey___gt__(self, o)
3067 
3068 
3069  def __ge__(self, o):
3070  """__ge__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
3071  return _IMP_kernel.ParticleIndexesKey___ge__(self, o)
3072 
3073 
3074  def __le__(self, o):
3075  """__le__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
3076  return _IMP_kernel.ParticleIndexesKey___le__(self, o)
3077 
3078 
3079  def __hash__(self):
3080  """__hash__(ParticleIndexesKey self) -> std::size_t"""
3081  return _IMP_kernel.ParticleIndexesKey___hash__(self)
3082 
3083 
3084  def show(self, *args):
3085  """
3086  show(ParticleIndexesKey self, _ostream out)
3087  show(ParticleIndexesKey self)
3088  """
3089  return _IMP_kernel.ParticleIndexesKey_show(self, *args)
3090 
3091 
3092  def add_alias(old_key, new_name):
3093  """add_alias(ParticleIndexesKey old_key, std::string new_name) -> ParticleIndexesKey"""
3094  return _IMP_kernel.ParticleIndexesKey_add_alias(old_key, new_name)
3095 
3096  add_alias = staticmethod(add_alias)
3097 
3098  def get_number_of_keys():
3099  """get_number_of_keys() -> unsigned int"""
3100  return _IMP_kernel.ParticleIndexesKey_get_number_of_keys()
3101 
3102  get_number_of_keys = staticmethod(get_number_of_keys)
3103 
3104  def get_index(self):
3105  """get_index(ParticleIndexesKey self) -> unsigned int"""
3106  return _IMP_kernel.ParticleIndexesKey_get_index(self)
3107 
3108 
3109  def show_all(out):
3110  """show_all(_ostream out)"""
3111  return _IMP_kernel.ParticleIndexesKey_show_all(out)
3112 
3113  show_all = staticmethod(show_all)
3114 
3115  def get_all_strings():
3116  """get_all_strings() -> IMP::Vector< std::string >"""
3117  return _IMP_kernel.ParticleIndexesKey_get_all_strings()
3118 
3119  get_all_strings = staticmethod(get_all_strings)
3120 
3121  def get_number_unique():
3122  """get_number_unique() -> unsigned int"""
3123  return _IMP_kernel.ParticleIndexesKey_get_number_unique()
3124 
3125  get_number_unique = staticmethod(get_number_unique)
3126 
3127  def __str__(self):
3128  """__str__(ParticleIndexesKey self) -> std::string"""
3129  return _IMP_kernel.ParticleIndexesKey___str__(self)
3130 
3131 
3132  def __repr__(self):
3133  """__repr__(ParticleIndexesKey self) -> std::string"""
3134  return _IMP_kernel.ParticleIndexesKey___repr__(self)
3135 
3136  __swig_destroy__ = _IMP_kernel.delete_ParticleIndexesKey
3137  __del__ = lambda self: None
3138 ParticleIndexesKey_swigregister = _IMP_kernel.ParticleIndexesKey_swigregister
3139 ParticleIndexesKey_swigregister(ParticleIndexesKey)
3140 
3141 def ParticleIndexesKey_add_key(sc):
3142  """ParticleIndexesKey_add_key(std::string sc) -> unsigned int"""
3143  return _IMP_kernel.ParticleIndexesKey_add_key(sc)
3144 
3145 def ParticleIndexesKey_get_key_exists(sc):
3146  """ParticleIndexesKey_get_key_exists(std::string sc) -> bool"""
3147  return _IMP_kernel.ParticleIndexesKey_get_key_exists(sc)
3148 
3149 def ParticleIndexesKey_add_alias(old_key, new_name):
3150  """ParticleIndexesKey_add_alias(ParticleIndexesKey old_key, std::string new_name) -> ParticleIndexesKey"""
3151  return _IMP_kernel.ParticleIndexesKey_add_alias(old_key, new_name)
3152 
3153 def ParticleIndexesKey_get_number_of_keys():
3154  """ParticleIndexesKey_get_number_of_keys() -> unsigned int"""
3155  return _IMP_kernel.ParticleIndexesKey_get_number_of_keys()
3156 
3157 def ParticleIndexesKey_show_all(out):
3158  """ParticleIndexesKey_show_all(_ostream out)"""
3159  return _IMP_kernel.ParticleIndexesKey_show_all(out)
3160 
3161 def ParticleIndexesKey_get_all_strings():
3162  """ParticleIndexesKey_get_all_strings() -> IMP::Vector< std::string >"""
3163  return _IMP_kernel.ParticleIndexesKey_get_all_strings()
3164 
3165 def ParticleIndexesKey_get_number_unique():
3166  """ParticleIndexesKey_get_number_unique() -> unsigned int"""
3167  return _IMP_kernel.ParticleIndexesKey_get_number_unique()
3168 
3169 class ModelKey(_Value):
3170  """Proxy of C++ IMP::Key<(8)> class"""
3171  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3172 
3173  def __init__(self, *args):
3174  """
3175  __init__(IMP::Key<(8)> self) -> ModelKey
3176  __init__(IMP::Key<(8)> self, std::string const & c, bool is_implicit_add_permitted=True) -> ModelKey
3177  __init__(IMP::Key<(8)> self, std::string const & c) -> ModelKey
3178  __init__(IMP::Key<(8)> self, unsigned int i) -> ModelKey
3179  """
3180  this = _IMP_kernel.new_ModelKey(*args)
3181  try:
3182  self.this.append(this)
3183  except:
3184  self.this = this
3185 
3186  def add_key(sc):
3187  """add_key(std::string sc) -> unsigned int"""
3188  return _IMP_kernel.ModelKey_add_key(sc)
3189 
3190  add_key = staticmethod(add_key)
3191 
3192  def get_key_exists(sc):
3193  """get_key_exists(std::string sc) -> bool"""
3194  return _IMP_kernel.ModelKey_get_key_exists(sc)
3195 
3196  get_key_exists = staticmethod(get_key_exists)
3197 
3198  def get_string(self):
3199  """get_string(ModelKey self) -> std::string const"""
3200  return _IMP_kernel.ModelKey_get_string(self)
3201 
3202 
3203  def __cmp__(self, o):
3204  """__cmp__(ModelKey self, ModelKey o) -> int"""
3205  return _IMP_kernel.ModelKey___cmp__(self, o)
3206 
3207 
3208  def __eq__(self, o):
3209  """__eq__(ModelKey self, ModelKey o) -> bool"""
3210  return _IMP_kernel.ModelKey___eq__(self, o)
3211 
3212 
3213  def __ne__(self, o):
3214  """__ne__(ModelKey self, ModelKey o) -> bool"""
3215  return _IMP_kernel.ModelKey___ne__(self, o)
3216 
3217 
3218  def __lt__(self, o):
3219  """__lt__(ModelKey self, ModelKey o) -> bool"""
3220  return _IMP_kernel.ModelKey___lt__(self, o)
3221 
3222 
3223  def __gt__(self, o):
3224  """__gt__(ModelKey self, ModelKey o) -> bool"""
3225  return _IMP_kernel.ModelKey___gt__(self, o)
3226 
3227 
3228  def __ge__(self, o):
3229  """__ge__(ModelKey self, ModelKey o) -> bool"""
3230  return _IMP_kernel.ModelKey___ge__(self, o)
3231 
3232 
3233  def __le__(self, o):
3234  """__le__(ModelKey self, ModelKey o) -> bool"""
3235  return _IMP_kernel.ModelKey___le__(self, o)
3236 
3237 
3238  def __hash__(self):
3239  """__hash__(ModelKey self) -> std::size_t"""
3240  return _IMP_kernel.ModelKey___hash__(self)
3241 
3242 
3243  def show(self, *args):
3244  """
3245  show(ModelKey self, _ostream out)
3246  show(ModelKey self)
3247  """
3248  return _IMP_kernel.ModelKey_show(self, *args)
3249 
3250 
3251  def add_alias(old_key, new_name):
3252  """add_alias(ModelKey old_key, std::string new_name) -> ModelKey"""
3253  return _IMP_kernel.ModelKey_add_alias(old_key, new_name)
3254 
3255  add_alias = staticmethod(add_alias)
3256 
3257  def get_number_of_keys():
3258  """get_number_of_keys() -> unsigned int"""
3259  return _IMP_kernel.ModelKey_get_number_of_keys()
3260 
3261  get_number_of_keys = staticmethod(get_number_of_keys)
3262 
3263  def get_index(self):
3264  """get_index(ModelKey self) -> unsigned int"""
3265  return _IMP_kernel.ModelKey_get_index(self)
3266 
3267 
3268  def show_all(out):
3269  """show_all(_ostream out)"""
3270  return _IMP_kernel.ModelKey_show_all(out)
3271 
3272  show_all = staticmethod(show_all)
3273 
3274  def get_all_strings():
3275  """get_all_strings() -> IMP::Vector< std::string >"""
3276  return _IMP_kernel.ModelKey_get_all_strings()
3277 
3278  get_all_strings = staticmethod(get_all_strings)
3279 
3280  def get_number_unique():
3281  """get_number_unique() -> unsigned int"""
3282  return _IMP_kernel.ModelKey_get_number_unique()
3283 
3284  get_number_unique = staticmethod(get_number_unique)
3285 
3286  def __str__(self):
3287  """__str__(ModelKey self) -> std::string"""
3288  return _IMP_kernel.ModelKey___str__(self)
3289 
3290 
3291  def __repr__(self):
3292  """__repr__(ModelKey self) -> std::string"""
3293  return _IMP_kernel.ModelKey___repr__(self)
3294 
3295  __swig_destroy__ = _IMP_kernel.delete_ModelKey
3296  __del__ = lambda self: None
3297 ModelKey_swigregister = _IMP_kernel.ModelKey_swigregister
3298 ModelKey_swigregister(ModelKey)
3299 
3300 def ModelKey_add_key(sc):
3301  """ModelKey_add_key(std::string sc) -> unsigned int"""
3302  return _IMP_kernel.ModelKey_add_key(sc)
3303 
3304 def ModelKey_get_key_exists(sc):
3305  """ModelKey_get_key_exists(std::string sc) -> bool"""
3306  return _IMP_kernel.ModelKey_get_key_exists(sc)
3307 
3308 def ModelKey_add_alias(old_key, new_name):
3309  """ModelKey_add_alias(ModelKey old_key, std::string new_name) -> ModelKey"""
3310  return _IMP_kernel.ModelKey_add_alias(old_key, new_name)
3311 
3312 def ModelKey_get_number_of_keys():
3313  """ModelKey_get_number_of_keys() -> unsigned int"""
3314  return _IMP_kernel.ModelKey_get_number_of_keys()
3315 
3316 def ModelKey_show_all(out):
3317  """ModelKey_show_all(_ostream out)"""
3318  return _IMP_kernel.ModelKey_show_all(out)
3319 
3320 def ModelKey_get_all_strings():
3321  """ModelKey_get_all_strings() -> IMP::Vector< std::string >"""
3322  return _IMP_kernel.ModelKey_get_all_strings()
3323 
3324 def ModelKey_get_number_unique():
3325  """ModelKey_get_number_unique() -> unsigned int"""
3326  return _IMP_kernel.ModelKey_get_number_unique()
3327 
3328 class ParticleIndex(_Value):
3329  """Proxy of C++ IMP::Index<(IMP::ParticleIndexTag)> class"""
3330  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3331 
3332  def __init__(self, *args):
3333  """
3334  __init__(IMP::Index<(IMP::ParticleIndexTag)> self, int i) -> ParticleIndex
3335  __init__(IMP::Index<(IMP::ParticleIndexTag)> self) -> ParticleIndex
3336  """
3337  this = _IMP_kernel.new_ParticleIndex(*args)
3338  try:
3339  self.this.append(this)
3340  except:
3341  self.this = this
3342 
3343  def get_index(self):
3344  """get_index(ParticleIndex self) -> int"""
3345  return _IMP_kernel.ParticleIndex_get_index(self)
3346 
3347 
3348  def __cmp__(self, o):
3349  """__cmp__(ParticleIndex self, ParticleIndex o) -> int"""
3350  return _IMP_kernel.ParticleIndex___cmp__(self, o)
3351 
3352 
3353  def __eq__(self, o):
3354  """__eq__(ParticleIndex self, ParticleIndex o) -> bool"""
3355  return _IMP_kernel.ParticleIndex___eq__(self, o)
3356 
3357 
3358  def __ne__(self, o):
3359  """__ne__(ParticleIndex self, ParticleIndex o) -> bool"""
3360  return _IMP_kernel.ParticleIndex___ne__(self, o)
3361 
3362 
3363  def __lt__(self, o):
3364  """__lt__(ParticleIndex self, ParticleIndex o) -> bool"""
3365  return _IMP_kernel.ParticleIndex___lt__(self, o)
3366 
3367 
3368  def __gt__(self, o):
3369  """__gt__(ParticleIndex self, ParticleIndex o) -> bool"""
3370  return _IMP_kernel.ParticleIndex___gt__(self, o)
3371 
3372 
3373  def __ge__(self, o):
3374  """__ge__(ParticleIndex self, ParticleIndex o) -> bool"""
3375  return _IMP_kernel.ParticleIndex___ge__(self, o)
3376 
3377 
3378  def __le__(self, o):
3379  """__le__(ParticleIndex self, ParticleIndex o) -> bool"""
3380  return _IMP_kernel.ParticleIndex___le__(self, o)
3381 
3382 
3383  def show(self, *args):
3384  """
3385  show(ParticleIndex self, _ostream out)
3386  show(ParticleIndex self)
3387  """
3388  return _IMP_kernel.ParticleIndex_show(self, *args)
3389 
3390 
3391  def __hash__(self):
3392  """__hash__(ParticleIndex self) -> std::size_t"""
3393  return _IMP_kernel.ParticleIndex___hash__(self)
3394 
3395 
3396  def __str__(self):
3397  """__str__(ParticleIndex self) -> std::string"""
3398  return _IMP_kernel.ParticleIndex___str__(self)
3399 
3400 
3401  def __repr__(self):
3402  """__repr__(ParticleIndex self) -> std::string"""
3403  return _IMP_kernel.ParticleIndex___repr__(self)
3404 
3405  __swig_destroy__ = _IMP_kernel.delete_ParticleIndex
3406  __del__ = lambda self: None
3407 ParticleIndex_swigregister = _IMP_kernel.ParticleIndex_swigregister
3408 ParticleIndex_swigregister(ParticleIndex)
3409 
3410 class FloatsKey(_Value):
3411  """Proxy of C++ IMP::Key<(10)> class"""
3412  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3413 
3414  def __init__(self, *args):
3415  """
3416  __init__(IMP::Key<(10)> self) -> FloatsKey
3417  __init__(IMP::Key<(10)> self, std::string const & c, bool is_implicit_add_permitted=True) -> FloatsKey
3418  __init__(IMP::Key<(10)> self, std::string const & c) -> FloatsKey
3419  __init__(IMP::Key<(10)> self, unsigned int i) -> FloatsKey
3420  """
3421  this = _IMP_kernel.new_FloatsKey(*args)
3422  try:
3423  self.this.append(this)
3424  except:
3425  self.this = this
3426 
3427  def add_key(sc):
3428  """add_key(std::string sc) -> unsigned int"""
3429  return _IMP_kernel.FloatsKey_add_key(sc)
3430 
3431  add_key = staticmethod(add_key)
3432 
3433  def get_key_exists(sc):
3434  """get_key_exists(std::string sc) -> bool"""
3435  return _IMP_kernel.FloatsKey_get_key_exists(sc)
3436 
3437  get_key_exists = staticmethod(get_key_exists)
3438 
3439  def get_string(self):
3440  """get_string(FloatsKey self) -> std::string const"""
3441  return _IMP_kernel.FloatsKey_get_string(self)
3442 
3443 
3444  def __cmp__(self, o):
3445  """__cmp__(FloatsKey self, FloatsKey o) -> int"""
3446  return _IMP_kernel.FloatsKey___cmp__(self, o)
3447 
3448 
3449  def __eq__(self, o):
3450  """__eq__(FloatsKey self, FloatsKey o) -> bool"""
3451  return _IMP_kernel.FloatsKey___eq__(self, o)
3452 
3453 
3454  def __ne__(self, o):
3455  """__ne__(FloatsKey self, FloatsKey o) -> bool"""
3456  return _IMP_kernel.FloatsKey___ne__(self, o)
3457 
3458 
3459  def __lt__(self, o):
3460  """__lt__(FloatsKey self, FloatsKey o) -> bool"""
3461  return _IMP_kernel.FloatsKey___lt__(self, o)
3462 
3463 
3464  def __gt__(self, o):
3465  """__gt__(FloatsKey self, FloatsKey o) -> bool"""
3466  return _IMP_kernel.FloatsKey___gt__(self, o)
3467 
3468 
3469  def __ge__(self, o):
3470  """__ge__(FloatsKey self, FloatsKey o) -> bool"""
3471  return _IMP_kernel.FloatsKey___ge__(self, o)
3472 
3473 
3474  def __le__(self, o):
3475  """__le__(FloatsKey self, FloatsKey o) -> bool"""
3476  return _IMP_kernel.FloatsKey___le__(self, o)
3477 
3478 
3479  def __hash__(self):
3480  """__hash__(FloatsKey self) -> std::size_t"""
3481  return _IMP_kernel.FloatsKey___hash__(self)
3482 
3483 
3484  def show(self, *args):
3485  """
3486  show(FloatsKey self, _ostream out)
3487  show(FloatsKey self)
3488  """
3489  return _IMP_kernel.FloatsKey_show(self, *args)
3490 
3491 
3492  def add_alias(old_key, new_name):
3493  """add_alias(FloatsKey old_key, std::string new_name) -> FloatsKey"""
3494  return _IMP_kernel.FloatsKey_add_alias(old_key, new_name)
3495 
3496  add_alias = staticmethod(add_alias)
3497 
3498  def get_number_of_keys():
3499  """get_number_of_keys() -> unsigned int"""
3500  return _IMP_kernel.FloatsKey_get_number_of_keys()
3501 
3502  get_number_of_keys = staticmethod(get_number_of_keys)
3503 
3504  def get_index(self):
3505  """get_index(FloatsKey self) -> unsigned int"""
3506  return _IMP_kernel.FloatsKey_get_index(self)
3507 
3508 
3509  def show_all(out):
3510  """show_all(_ostream out)"""
3511  return _IMP_kernel.FloatsKey_show_all(out)
3512 
3513  show_all = staticmethod(show_all)
3514 
3515  def get_all_strings():
3516  """get_all_strings() -> IMP::Vector< std::string >"""
3517  return _IMP_kernel.FloatsKey_get_all_strings()
3518 
3519  get_all_strings = staticmethod(get_all_strings)
3520 
3521  def get_number_unique():
3522  """get_number_unique() -> unsigned int"""
3523  return _IMP_kernel.FloatsKey_get_number_unique()
3524 
3525  get_number_unique = staticmethod(get_number_unique)
3526 
3527  def __str__(self):
3528  """__str__(FloatsKey self) -> std::string"""
3529  return _IMP_kernel.FloatsKey___str__(self)
3530 
3531 
3532  def __repr__(self):
3533  """__repr__(FloatsKey self) -> std::string"""
3534  return _IMP_kernel.FloatsKey___repr__(self)
3535 
3536  __swig_destroy__ = _IMP_kernel.delete_FloatsKey
3537  __del__ = lambda self: None
3538 FloatsKey_swigregister = _IMP_kernel.FloatsKey_swigregister
3539 FloatsKey_swigregister(FloatsKey)
3540 
3541 def FloatsKey_add_key(sc):
3542  """FloatsKey_add_key(std::string sc) -> unsigned int"""
3543  return _IMP_kernel.FloatsKey_add_key(sc)
3544 
3545 def FloatsKey_get_key_exists(sc):
3546  """FloatsKey_get_key_exists(std::string sc) -> bool"""
3547  return _IMP_kernel.FloatsKey_get_key_exists(sc)
3548 
3549 def FloatsKey_add_alias(old_key, new_name):
3550  """FloatsKey_add_alias(FloatsKey old_key, std::string new_name) -> FloatsKey"""
3551  return _IMP_kernel.FloatsKey_add_alias(old_key, new_name)
3552 
3553 def FloatsKey_get_number_of_keys():
3554  """FloatsKey_get_number_of_keys() -> unsigned int"""
3555  return _IMP_kernel.FloatsKey_get_number_of_keys()
3556 
3557 def FloatsKey_show_all(out):
3558  """FloatsKey_show_all(_ostream out)"""
3559  return _IMP_kernel.FloatsKey_show_all(out)
3560 
3561 def FloatsKey_get_all_strings():
3562  """FloatsKey_get_all_strings() -> IMP::Vector< std::string >"""
3563  return _IMP_kernel.FloatsKey_get_all_strings()
3564 
3565 def FloatsKey_get_number_unique():
3566  """FloatsKey_get_number_unique() -> unsigned int"""
3567  return _IMP_kernel.FloatsKey_get_number_unique()
3568 
3569 
3570 def ParticlePair(a, b):
3571  return (a,b)
3572 def ParticleTriplet(a, b, c):
3573  return (a,b,c)
3574 def ParticleQuad(a, b, c, d):
3575  return (a,b,c,d)
3576 
3577 class FloatIndex(_Value):
3578  """Proxy of C++ IMP::FloatIndex class"""
3579  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3580 
3581  def __init__(self, *args):
3582  """
3583  __init__(IMP::FloatIndex self, ParticleIndex i0, FloatKey i1) -> FloatIndex
3584  __init__(IMP::FloatIndex self, ParticleIndex i0) -> FloatIndex
3585  __init__(IMP::FloatIndex self) -> FloatIndex
3586  """
3587  this = _IMP_kernel.new_FloatIndex(*args)
3588  try:
3589  self.this.append(this)
3590  except:
3591  self.this = this
3592 
3593  def __hash__(self):
3594  """__hash__(FloatIndex self) -> std::size_t"""
3595  return _IMP_kernel.FloatIndex___hash__(self)
3596 
3597 
3598  def show(self, *args):
3599  """
3600  show(FloatIndex self, _ostream out)
3601  show(FloatIndex self)
3602  """
3603  return _IMP_kernel.FloatIndex_show(self, *args)
3604 
3605 
3606  def __cmp__(self, o):
3607  """__cmp__(FloatIndex self, FloatIndex o) -> int"""
3608  return _IMP_kernel.FloatIndex___cmp__(self, o)
3609 
3610 
3611  def __eq__(self, o):
3612  """__eq__(FloatIndex self, FloatIndex o) -> bool"""
3613  return _IMP_kernel.FloatIndex___eq__(self, o)
3614 
3615 
3616  def __ne__(self, o):
3617  """__ne__(FloatIndex self, FloatIndex o) -> bool"""
3618  return _IMP_kernel.FloatIndex___ne__(self, o)
3619 
3620 
3621  def __lt__(self, o):
3622  """__lt__(FloatIndex self, FloatIndex o) -> bool"""
3623  return _IMP_kernel.FloatIndex___lt__(self, o)
3624 
3625 
3626  def __gt__(self, o):
3627  """__gt__(FloatIndex self, FloatIndex o) -> bool"""
3628  return _IMP_kernel.FloatIndex___gt__(self, o)
3629 
3630 
3631  def __ge__(self, o):
3632  """__ge__(FloatIndex self, FloatIndex o) -> bool"""
3633  return _IMP_kernel.FloatIndex___ge__(self, o)
3634 
3635 
3636  def __le__(self, o):
3637  """__le__(FloatIndex self, FloatIndex o) -> bool"""
3638  return _IMP_kernel.FloatIndex___le__(self, o)
3639 
3640 
3641  def get_particle(self):
3642  """get_particle(FloatIndex self) -> ParticleIndex const &"""
3643  return _IMP_kernel.FloatIndex_get_particle(self)
3644 
3645 
3646  def set_particle(self, v):
3647  """set_particle(FloatIndex self, ParticleIndex const & v)"""
3648  return _IMP_kernel.FloatIndex_set_particle(self, v)
3649 
3650 
3651  def get_key(self):
3652  """get_key(FloatIndex self) -> FloatKey const &"""
3653  return _IMP_kernel.FloatIndex_get_key(self)
3654 
3655 
3656  def set_key(self, v):
3657  """set_key(FloatIndex self, FloatKey const & v)"""
3658  return _IMP_kernel.FloatIndex_set_key(self, v)
3659 
3660 
3661  def __str__(self):
3662  """__str__(FloatIndex self) -> std::string"""
3663  return _IMP_kernel.FloatIndex___str__(self)
3664 
3665 
3666  def __repr__(self):
3667  """__repr__(FloatIndex self) -> std::string"""
3668  return _IMP_kernel.FloatIndex___repr__(self)
3669 
3670  __swig_destroy__ = _IMP_kernel.delete_FloatIndex
3671  __del__ = lambda self: None
3672 FloatIndex_swigregister = _IMP_kernel.FloatIndex_swigregister
3673 FloatIndex_swigregister(FloatIndex)
3674 
3675 class _ParticleIndexTag(object):
3676  """Proxy of C++ IMP::ParticleIndexTag class"""
3677  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3678  __repr__ = _swig_repr
3679 
3680  def __init__(self):
3681  """__init__(IMP::ParticleIndexTag self) -> _ParticleIndexTag"""
3682  this = _IMP_kernel.new__ParticleIndexTag()
3683  try:
3684  self.this.append(this)
3685  except:
3686  self.this = this
3687  __swig_destroy__ = _IMP_kernel.delete__ParticleIndexTag
3688  __del__ = lambda self: None
3689 _ParticleIndexTag_swigregister = _IMP_kernel._ParticleIndexTag_swigregister
3690 _ParticleIndexTag_swigregister(_ParticleIndexTag)
3691 
3692 class ModelObject(Object):
3693  """Proxy of C++ IMP::ModelObject class"""
3694  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3695 
3696  def __init__(self, m, name):
3697  """__init__(IMP::ModelObject self, Model m, std::string name) -> ModelObject"""
3698  if self.__class__ == ModelObject:
3699  _self = None
3700  else:
3701  _self = self
3702  this = _IMP_kernel.new_ModelObject(_self, m, name)
3703  try:
3704  self.this.append(this)
3705  except:
3706  self.this = this
3707 
3708  if self.__class__ != ModelObject:
3709  _director_objects.register(self)
3710 
3711 
3712 
3713  __swig_destroy__ = _IMP_kernel.delete_ModelObject
3714  __del__ = lambda self: None
3715 
3716  def get_model(self):
3717  """get_model(ModelObject self) -> Model"""
3718  return _IMP_kernel.ModelObject_get_model(self)
3719 
3720 
3721  def get_inputs(self):
3722  """get_inputs(ModelObject self) -> IMP::ModelObjectsTemp"""
3723  return _IMP_kernel.ModelObject_get_inputs(self)
3724 
3725 
3726  def get_outputs(self):
3727  """get_outputs(ModelObject self) -> IMP::ModelObjectsTemp"""
3728  return _IMP_kernel.ModelObject_get_outputs(self)
3729 
3730 
3731  def get_interactions(self):
3732  """get_interactions(ModelObject self) -> IMP::ModelObjectsTemps"""
3733  return _IMP_kernel.ModelObject_get_interactions(self)
3734 
3735 
3736  def get_has_dependencies(self):
3737  """get_has_dependencies(ModelObject self) -> bool"""
3738  return _IMP_kernel.ModelObject_get_has_dependencies(self)
3739 
3740 
3741  def set_has_dependencies(self, tf):
3742  """set_has_dependencies(ModelObject self, bool tf)"""
3743  return _IMP_kernel.ModelObject_set_has_dependencies(self, tf)
3744 
3745 
3746  def set_has_required_score_states(self, tf):
3747  """set_has_required_score_states(ModelObject self, bool tf)"""
3748  return _IMP_kernel.ModelObject_set_has_required_score_states(self, tf)
3749 
3750 
3751  def get_has_required_score_states(self):
3752  """get_has_required_score_states(ModelObject self) -> bool"""
3753  return _IMP_kernel.ModelObject_get_has_required_score_states(self)
3754 
3755 
3756  def get_required_score_states(self):
3757  """get_required_score_states(ModelObject self) -> IMP::ScoreStatesTemp const &"""
3758  return _IMP_kernel.ModelObject_get_required_score_states(self)
3759 
3760 
3761  def handle_set_has_required_score_states(self, arg0):
3762  """handle_set_has_required_score_states(ModelObject self, bool arg0)"""
3763  return _IMP_kernel.ModelObject_handle_set_has_required_score_states(self, arg0)
3764 
3765 
3766  def do_get_inputs(self):
3767  """do_get_inputs(ModelObject self) -> IMP::ModelObjectsTemp"""
3768  return _IMP_kernel.ModelObject_do_get_inputs(self)
3769 
3770 
3771  def do_get_outputs(self):
3772  """do_get_outputs(ModelObject self) -> IMP::ModelObjectsTemp"""
3773  return _IMP_kernel.ModelObject_do_get_outputs(self)
3774 
3775 
3776  def do_get_interactions(self):
3777  """do_get_interactions(ModelObject self) -> IMP::ModelObjectsTemps"""
3778  return _IMP_kernel.ModelObject_do_get_interactions(self)
3779 
3780 
3781  def __str__(self):
3782  """__str__(ModelObject self) -> std::string"""
3783  return _IMP_kernel.ModelObject___str__(self)
3784 
3785 
3786  def __repr__(self):
3787  """__repr__(ModelObject self) -> std::string"""
3788  return _IMP_kernel.ModelObject___repr__(self)
3789 
3790 
3791  @staticmethod
3792  def get_from(o):
3793  return _object_cast_to_ModelObject(o)
3794 
3795 
3796  def get_type_name(self):
3797  return self.__class__.__name__
3798  def do_show(self, out):
3799  pass
3800  def get_version_info(self):
3801  if"IMP" == "IMP":
3802  return VersionInfo(self.__module__,
3803  __import__(self.__module__).get_module_version())
3804  else:
3805  return IMP.VersionInfo(self.__module__,
3806  __import__(self.__module__).get_module_version())
3807  @staticmethod
3808  def get_from(o):
3809  return _object_cast_to_ModelObject(o)
3810 
3811  def __disown__(self):
3812  self.this.disown()
3813  _IMP_kernel.disown_ModelObject(self)
3814  return weakref_proxy(self)
3815 
3816  def do_destroy(self):
3817  """do_destroy(ModelObject self)"""
3818  return _IMP_kernel.ModelObject_do_destroy(self)
3819 
3820 ModelObject_swigregister = _IMP_kernel.ModelObject_swigregister
3821 ModelObject_swigregister(ModelObject)
3822 cvar = _IMP_kernel.cvar
3823 NO_MAX = cvar.NO_MAX
3824 BAD_SCORE = cvar.BAD_SCORE
3825 
3826 class _ParticleInputs(object):
3827  """Proxy of C++ IMP::ParticleInputs class"""
3828  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3829 
3830  def __init__(self, *args, **kwargs):
3831  raise AttributeError("No constructor defined - class is abstract")
3832  __repr__ = _swig_repr
3833 
3834  def get_inputs(self, m, pis):
3835  """get_inputs(_ParticleInputs self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
3836  return _IMP_kernel._ParticleInputs_get_inputs(self, m, pis)
3837 
3838 _ParticleInputs_swigregister = _IMP_kernel._ParticleInputs_swigregister
3839 _ParticleInputs_swigregister(_ParticleInputs)
3840 
3841 class _ParticleOutputs(object):
3842  """Proxy of C++ IMP::ParticleOutputs class"""
3843  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3844 
3845  def __init__(self, *args, **kwargs):
3846  raise AttributeError("No constructor defined - class is abstract")
3847  __repr__ = _swig_repr
3848 
3849  def get_outputs(self, m, pis):
3850  """get_outputs(_ParticleOutputs self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
3851  return _IMP_kernel._ParticleOutputs_get_outputs(self, m, pis)
3852 
3853 _ParticleOutputs_swigregister = _IMP_kernel._ParticleOutputs_swigregister
3854 _ParticleOutputs_swigregister(_ParticleOutputs)
3855 
3856 
3857 def get_input_particles(mos):
3858  """get_input_particles(IMP::ModelObjectsTemp const & mos) -> IMP::ParticlesTemp"""
3859  return _IMP_kernel.get_input_particles(mos)
3860 
3861 def get_input_containers(mos):
3862  """get_input_containers(IMP::ModelObjectsTemp const & mos) -> IMP::ContainersTemp"""
3863  return _IMP_kernel.get_input_containers(mos)
3864 
3865 def get_output_particles(mos):
3866  """get_output_particles(IMP::ModelObjectsTemp const & mos) -> IMP::ParticlesTemp"""
3867  return _IMP_kernel.get_output_particles(mos)
3868 
3869 def get_output_containers(mos):
3870  """get_output_containers(IMP::ModelObjectsTemp const & mos) -> IMP::ContainersTemp"""
3871  return _IMP_kernel.get_output_containers(mos)
3872 class DerivativeAccumulator(object):
3873  """Proxy of C++ IMP::DerivativeAccumulator class"""
3874  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3875  __repr__ = _swig_repr
3876 
3877  def __init__(self, *args):
3878  """
3879  __init__(IMP::DerivativeAccumulator self, double weight=1.0) -> DerivativeAccumulator
3880  __init__(IMP::DerivativeAccumulator self) -> DerivativeAccumulator
3881  __init__(IMP::DerivativeAccumulator self, DerivativeAccumulator copy, double weight) -> DerivativeAccumulator
3882  """
3883  this = _IMP_kernel.new_DerivativeAccumulator(*args)
3884  try:
3885  self.this.append(this)
3886  except:
3887  self.this = this
3888 
3889  def __call__(self, value):
3890  """__call__(DerivativeAccumulator self, double const value) -> double"""
3891  return _IMP_kernel.DerivativeAccumulator___call__(self, value)
3892 
3893 
3894  def get_weight(self):
3895  """get_weight(DerivativeAccumulator self) -> double"""
3896  return _IMP_kernel.DerivativeAccumulator_get_weight(self)
3897 
3898 
3899  def show(self, *args):
3900  """
3901  show(DerivativeAccumulator self, _ostream out)
3902  show(DerivativeAccumulator self)
3903  """
3904  return _IMP_kernel.DerivativeAccumulator_show(self, *args)
3905 
3906  __swig_destroy__ = _IMP_kernel.delete_DerivativeAccumulator
3907  __del__ = lambda self: None
3908 DerivativeAccumulator_swigregister = _IMP_kernel.DerivativeAccumulator_swigregister
3909 DerivativeAccumulator_swigregister(DerivativeAccumulator)
3910 
3911 class EvaluationState(object):
3912  """Proxy of C++ IMP::EvaluationState class"""
3913  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3914  score = _swig_property(_IMP_kernel.EvaluationState_score_get, _IMP_kernel.EvaluationState_score_set)
3915  good = _swig_property(_IMP_kernel.EvaluationState_good_get, _IMP_kernel.EvaluationState_good_set)
3916 
3917  def __init__(self, *args):
3918  """
3919  __init__(IMP::EvaluationState self, double oscore, bool ogood) -> EvaluationState
3920  __init__(IMP::EvaluationState self) -> EvaluationState
3921  """
3922  this = _IMP_kernel.new_EvaluationState(*args)
3923  try:
3924  self.this.append(this)
3925  except:
3926  self.this = this
3927 
3928  def show(self, *args):
3929  """
3930  show(EvaluationState self, _ostream out)
3931  show(EvaluationState self)
3932  """
3933  return _IMP_kernel.EvaluationState_show(self, *args)
3934 
3935 
3936  def __str__(self):
3937  """__str__(EvaluationState self) -> std::string"""
3938  return _IMP_kernel.EvaluationState___str__(self)
3939 
3940 
3941  def __repr__(self):
3942  """__repr__(EvaluationState self) -> std::string"""
3943  return _IMP_kernel.EvaluationState___repr__(self)
3944 
3945  __swig_destroy__ = _IMP_kernel.delete_EvaluationState
3946  __del__ = lambda self: None
3947 EvaluationState_swigregister = _IMP_kernel.EvaluationState_swigregister
3948 EvaluationState_swigregister(EvaluationState)
3949 
3950 class ScoreAccumulator(_Value):
3951  """Proxy of C++ IMP::ScoreAccumulator class"""
3952  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3953 
3954  def __init__(self, *args):
3955  """
3956  __init__(IMP::ScoreAccumulator self) -> ScoreAccumulator
3957  __init__(IMP::ScoreAccumulator self, ScoreAccumulator o, Restraint r) -> ScoreAccumulator
3958  __init__(IMP::ScoreAccumulator self, ScoreAccumulator o, double weight, double local_max) -> ScoreAccumulator
3959  """
3960  this = _IMP_kernel.new_ScoreAccumulator(*args)
3961  try:
3962  self.this.append(this)
3963  except:
3964  self.this = this
3965 
3966  def add_score(self, score):
3967  """add_score(ScoreAccumulator self, double score)"""
3968  return _IMP_kernel.ScoreAccumulator_add_score(self, score)
3969 
3970 
3971  def get_abort_evaluation(self):
3972  """get_abort_evaluation(ScoreAccumulator self) -> bool"""
3973  return _IMP_kernel.ScoreAccumulator_get_abort_evaluation(self)
3974 
3975 
3976  def get_is_evaluate_if_below(self):
3977  """get_is_evaluate_if_below(ScoreAccumulator self) -> bool"""
3978  return _IMP_kernel.ScoreAccumulator_get_is_evaluate_if_below(self)
3979 
3980 
3981  def get_is_evaluate_if_good(self):
3982  """get_is_evaluate_if_good(ScoreAccumulator self) -> bool"""
3983  return _IMP_kernel.ScoreAccumulator_get_is_evaluate_if_good(self)
3984 
3985 
3986  def get_maximum(self):
3987  """get_maximum(ScoreAccumulator self) -> double"""
3988  return _IMP_kernel.ScoreAccumulator_get_maximum(self)
3989 
3990 
3991  def get_derivative_accumulator(self):
3992  """get_derivative_accumulator(ScoreAccumulator self) -> DerivativeAccumulator"""
3993  return _IMP_kernel.ScoreAccumulator_get_derivative_accumulator(self)
3994 
3995 
3996  def show(self, *args):
3997  """
3998  show(ScoreAccumulator self, _ostream out)
3999  show(ScoreAccumulator self)
4000  """
4001  return _IMP_kernel.ScoreAccumulator_show(self, *args)
4002 
4003 
4004  def __str__(self):
4005  """__str__(ScoreAccumulator self) -> std::string"""
4006  return _IMP_kernel.ScoreAccumulator___str__(self)
4007 
4008 
4009  def __repr__(self):
4010  """__repr__(ScoreAccumulator self) -> std::string"""
4011  return _IMP_kernel.ScoreAccumulator___repr__(self)
4012 
4013  __swig_destroy__ = _IMP_kernel.delete_ScoreAccumulator
4014  __del__ = lambda self: None
4015 ScoreAccumulator_swigregister = _IMP_kernel.ScoreAccumulator_swigregister
4016 ScoreAccumulator_swigregister(ScoreAccumulator)
4017 
4018 class ScoreState(ModelObject):
4019  """Proxy of C++ IMP::ScoreState class"""
4020  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
4021 
4022  def __init__(self, m, name):
4023  """__init__(IMP::ScoreState self, Model m, std::string name) -> ScoreState"""
4024  if self.__class__ == ScoreState:
4025  _self = None
4026  else:
4027  _self = self
4028  this = _IMP_kernel.new_ScoreState(_self, m, name)
4029  try:
4030  self.this.append(this)
4031  except:
4032  self.this = this
4033 
4034  if self.__class__ != ScoreState:
4035  _director_objects.register(self)
4036 
4037 
4038 
4039 
4040  def before_evaluate(self):
4041  """before_evaluate(ScoreState self)"""
4042  return _IMP_kernel.ScoreState_before_evaluate(self)
4043 
4044 
4045  def after_evaluate(self, accpt):
4046  """after_evaluate(ScoreState self, DerivativeAccumulator accpt)"""
4047  return _IMP_kernel.ScoreState_after_evaluate(self, accpt)
4048 
4049 
4050  def get_has_update_order(self):
4051  """get_has_update_order(ScoreState self) -> bool"""
4052  return _IMP_kernel.ScoreState_get_has_update_order(self)
4053 
4054 
4055  def get_update_order(self):
4056  """get_update_order(ScoreState self) -> unsigned int"""
4057  return _IMP_kernel.ScoreState_get_update_order(self)
4058 
4059 
4060  def handle_set_has_required_score_states(self, tf):
4061  """handle_set_has_required_score_states(ScoreState self, bool tf)"""
4062  return _IMP_kernel.ScoreState_handle_set_has_required_score_states(self, tf)
4063 
4064 
4065  def do_before_evaluate(self):
4066  """do_before_evaluate(ScoreState self)"""
4067  return _IMP_kernel.ScoreState_do_before_evaluate(self)
4068 
4069 
4070  def do_after_evaluate(self, accpt):
4071  """do_after_evaluate(ScoreState self, DerivativeAccumulator accpt)"""
4072  return _IMP_kernel.ScoreState_do_after_evaluate(self, accpt)
4073 
4074  __swig_destroy__ = _IMP_kernel.delete_ScoreState
4075  __del__ = lambda self: None
4076 
4077  def __str__(self):
4078  """__str__(ScoreState self) -> std::string"""
4079  return _IMP_kernel.ScoreState___str__(self)
4080 
4081 
4082  def __repr__(self):
4083  """__repr__(ScoreState self) -> std::string"""
4084  return _IMP_kernel.ScoreState___repr__(self)
4085 
4086 
4087  @staticmethod
4088  def get_from(o):
4089  return _object_cast_to_ScoreState(o)
4090 
4091 
4092  def get_type_name(self):
4093  return self.__class__.__name__
4094  def do_show(self, out):
4095  pass
4096  def get_version_info(self):
4097  if"IMP" == "IMP":
4098  return VersionInfo(self.__module__,
4099  __import__(self.__module__).get_module_version())
4100  else:
4101  return IMP.VersionInfo(self.__module__,
4102  __import__(self.__module__).get_module_version())
4103  @staticmethod
4104  def get_from(o):
4105  return _object_cast_to_ScoreState(o)
4106 
4107  def __disown__(self):
4108  self.this.disown()
4109  _IMP_kernel.disown_ScoreState(self)
4110  return weakref_proxy(self)
4111 
4112  def do_destroy(self):
4113  """do_destroy(ScoreState self)"""
4114  return _IMP_kernel.ScoreState_do_destroy(self)
4115 
4116 
4117  def do_get_inputs(self):
4118  """do_get_inputs(ScoreState self) -> IMP::ModelObjectsTemp"""
4119  return _IMP_kernel.ScoreState_do_get_inputs(self)
4120 
4121 
4122  def do_get_outputs(self):
4123  """do_get_outputs(ScoreState self) -> IMP::ModelObjectsTemp"""
4124  return _IMP_kernel.ScoreState_do_get_outputs(self)
4125 
4126 
4127  def do_get_interactions(self):
4128  """do_get_interactions(ScoreState self) -> IMP::ModelObjectsTemps"""
4129  return _IMP_kernel.ScoreState_do_get_interactions(self)
4130 
4131 ScoreState_swigregister = _IMP_kernel.ScoreState_swigregister
4132 ScoreState_swigregister(ScoreState)
4133 
4134 
4135 def get_update_order(input):
4136  """get_update_order(IMP::ScoreStatesTemp input) -> IMP::ScoreStatesTemp"""
4137  return _IMP_kernel.get_update_order(input)
4138 class Constraint(ScoreState):
4139  """Proxy of C++ IMP::Constraint class"""
4140  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
4141 
4142  def __init__(self, *args):
4143  """
4144  __init__(IMP::Constraint self, Model m, std::string name) -> Constraint
4145  __init__(IMP::Constraint self, Model m) -> Constraint
4146  """
4147  if self.__class__ == Constraint:
4148  _self = None
4149  else:
4150  _self = self
4151  this = _IMP_kernel.new_Constraint(_self, *args)
4152  try:
4153  self.this.append(this)
4154  except:
4155  self.this = this
4156 
4157  if self.__class__ != Constraint:
4158  _director_objects.register(self)
4159 
4160 
4161 
4162 
4163  def do_update_attributes(self):
4164  """do_update_attributes(Constraint self)"""
4165  return _IMP_kernel.Constraint_do_update_attributes(self)
4166 
4167 
4168  def do_update_derivatives(self, da):
4169  """do_update_derivatives(Constraint self, DerivativeAccumulator da)"""
4170  return _IMP_kernel.Constraint_do_update_derivatives(self, da)
4171 
4172 
4173  def do_before_evaluate(self):
4174  """do_before_evaluate(Constraint self)"""
4175  return _IMP_kernel.Constraint_do_before_evaluate(self)
4176 
4177 
4178  def do_after_evaluate(self, da):
4179  """do_after_evaluate(Constraint self, DerivativeAccumulator da)"""
4180  return _IMP_kernel.Constraint_do_after_evaluate(self, da)
4181 
4182  __swig_destroy__ = _IMP_kernel.delete_Constraint
4183  __del__ = lambda self: None
4184 
4185  def __str__(self):
4186  """__str__(Constraint self) -> std::string"""
4187  return _IMP_kernel.Constraint___str__(self)
4188 
4189 
4190  def __repr__(self):
4191  """__repr__(Constraint self) -> std::string"""
4192  return _IMP_kernel.Constraint___repr__(self)
4193 
4194 
4195  @staticmethod
4196  def get_from(o):
4197  return _object_cast_to_Constraint(o)
4198 
4199 
4200  def get_type_name(self):
4201  return self.__class__.__name__
4202  def do_show(self, out):
4203  pass
4204  def get_version_info(self):
4205  if"IMP" == "IMP":
4206  return VersionInfo(self.__module__,
4207  __import__(self.__module__).get_module_version())
4208  else:
4209  return IMP.VersionInfo(self.__module__,
4210  __import__(self.__module__).get_module_version())
4211  @staticmethod
4212  def get_from(o):
4213  return _object_cast_to_Constraint(o)
4214 
4215  def __disown__(self):
4216  self.this.disown()
4217  _IMP_kernel.disown_Constraint(self)
4218  return weakref_proxy(self)
4219 
4220  def do_destroy(self):
4221  """do_destroy(Constraint self)"""
4222  return _IMP_kernel.Constraint_do_destroy(self)
4223 
4224 
4225  def do_get_inputs(self):
4226  """do_get_inputs(Constraint self) -> IMP::ModelObjectsTemp"""
4227  return _IMP_kernel.Constraint_do_get_inputs(self)
4228 
4229 
4230  def do_get_outputs(self):
4231  """do_get_outputs(Constraint self) -> IMP::ModelObjectsTemp"""
4232  return _IMP_kernel.Constraint_do_get_outputs(self)
4233 
4234 
4235  def do_get_interactions(self):
4236  """do_get_interactions(Constraint self) -> IMP::ModelObjectsTemps"""
4237  return _IMP_kernel.Constraint_do_get_interactions(self)
4238 
4239 Constraint_swigregister = _IMP_kernel.Constraint_swigregister
4240 Constraint_swigregister(Constraint)
4241 
4242 class Container(ModelObject):
4243  """Proxy of C++ IMP::Container class"""
4244  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
4245 
4246  def __init__(self, *args):
4247  """
4248  __init__(IMP::Container self, Model m, std::string name) -> Container
4249  __init__(IMP::Container self, Model m) -> Container
4250  """
4251  if self.__class__ == Container:
4252  _self = None
4253  else:
4254  _self = self
4255  this = _IMP_kernel.new_Container(_self, *args)
4256  try:
4257  self.this.append(this)
4258  except:
4259  self.this = this
4260 
4261  if self.__class__ != Container:
4262  _director_objects.register(self)
4263 
4264 
4265 
4266 
4267  def do_get_contents_hash(self):
4268  """do_get_contents_hash(Container self) -> std::size_t"""
4269  return _IMP_kernel.Container_do_get_contents_hash(self)
4270 
4271 
4272  def get_all_possible_indexes(self):
4273  """get_all_possible_indexes(Container self) -> IMP::ParticleIndexes"""
4274  return _IMP_kernel.Container_get_all_possible_indexes(self)
4275 
4276 
4277  def get_contents_hash(self):
4278  """get_contents_hash(Container self) -> std::size_t"""
4279  return _IMP_kernel.Container_get_contents_hash(self)
4280 
4281 
4282  def do_get_outputs(self):
4283  """do_get_outputs(Container self) -> IMP::ModelObjectsTemp"""
4284  return _IMP_kernel.Container_do_get_outputs(self)
4285 
4286 
4287  def get_is_decomposable(self):
4288  """get_is_decomposable(Container self) -> bool"""
4289  return _IMP_kernel.Container_get_is_decomposable(self)
4290 
4291 
4292  def validate_readable(self):
4293  """validate_readable(Container self)"""
4294  return _IMP_kernel.Container_validate_readable(self)
4295 
4296 
4297  def validate_writable(self):
4298  """validate_writable(Container self)"""
4299  return _IMP_kernel.Container_validate_writable(self)
4300 
4301 
4302  def set_is_readable(self, tf):
4303  """set_is_readable(Container self, bool tf)"""
4304  return _IMP_kernel.Container_set_is_readable(self, tf)
4305 
4306 
4307  def set_is_writable(self, tf):
4308  """set_is_writable(Container self, bool tf)"""
4309  return _IMP_kernel.Container_set_is_writable(self, tf)
4310 
4311  __swig_destroy__ = _IMP_kernel.delete_Container
4312  __del__ = lambda self: None
4313 
4314  def __str__(self):
4315  """__str__(Container self) -> std::string"""
4316  return _IMP_kernel.Container___str__(self)
4317 
4318 
4319  def __repr__(self):
4320  """__repr__(Container self) -> std::string"""
4321  return _IMP_kernel.Container___repr__(self)
4322 
4323 
4324  @staticmethod
4325  def get_from(o):
4326  return _object_cast_to_Container(o)
4327 
4328 
4329  def get_type_name(self):
4330  return self.__class__.__name__
4331  def do_show(self, out):
4332  pass
4333  def get_version_info(self):
4334  if"IMP" == "IMP":
4335  return VersionInfo(self.__module__,
4336  __import__(self.__module__).get_module_version())
4337  else:
4338  return IMP.VersionInfo(self.__module__,
4339  __import__(self.__module__).get_module_version())
4340  @staticmethod
4341  def get_from(o):
4342  return _object_cast_to_Container(o)
4343 
4344  def __disown__(self):
4345  self.this.disown()
4346  _IMP_kernel.disown_Container(self)
4347  return weakref_proxy(self)
4348 
4349  def do_destroy(self):
4350  """do_destroy(Container self)"""
4351  return _IMP_kernel.Container_do_destroy(self)
4352 
4353 
4354  def handle_set_has_required_score_states(self, arg0):
4355  """handle_set_has_required_score_states(Container self, bool arg0)"""
4356  return _IMP_kernel.Container_handle_set_has_required_score_states(self, arg0)
4357 
4358 
4359  def do_get_inputs(self):
4360  """do_get_inputs(Container self) -> IMP::ModelObjectsTemp"""
4361  return _IMP_kernel.Container_do_get_inputs(self)
4362 
4363 
4364  def do_get_interactions(self):
4365  """do_get_interactions(Container self) -> IMP::ModelObjectsTemps"""
4366  return _IMP_kernel.Container_do_get_interactions(self)
4367 
4368 Container_swigregister = _IMP_kernel.Container_swigregister
4369 Container_swigregister(Container)
4370 
4371 class RestraintInfo(Object):
4372  """Proxy of C++ IMP::RestraintInfo class"""
4373  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
4374 
4375  def __init__(self, *args):
4376  """
4377  __init__(IMP::RestraintInfo self, std::string name) -> RestraintInfo
4378  __init__(IMP::RestraintInfo self) -> RestraintInfo
4379  """
4380  this = _IMP_kernel.new_RestraintInfo(*args)
4381  try:
4382  self.this.append(this)
4383  except:
4384  self.this = this
4385 
4386  def add_int(self, key, value):
4387  """add_int(RestraintInfo self, std::string key, int value)"""
4388  return _IMP_kernel.RestraintInfo_add_int(self, key, value)
4389 
4390 
4391  def get_number_of_int(self):
4392  """get_number_of_int(RestraintInfo self) -> unsigned int"""
4393  return _IMP_kernel.RestraintInfo_get_number_of_int(self)
4394 
4395 
4396  def get_int_key(self, i):
4397  """get_int_key(RestraintInfo self, unsigned int i) -> std::string"""
4398  return _IMP_kernel.RestraintInfo_get_int_key(self, i)
4399 
4400 
4401  def get_int_value(self, i):
4402  """get_int_value(RestraintInfo self, unsigned int i) -> int"""
4403  return _IMP_kernel.RestraintInfo_get_int_value(self, i)
4404 
4405 
4406  def add_float(self, key, value):
4407  """add_float(RestraintInfo self, std::string key, double value)"""
4408  return _IMP_kernel.RestraintInfo_add_float(self, key, value)
4409 
4410 
4411  def get_number_of_float(self):
4412  """get_number_of_float(RestraintInfo self) -> unsigned int"""
4413  return _IMP_kernel.RestraintInfo_get_number_of_float(self)
4414 
4415 
4416  def get_float_key(self, i):
4417  """get_float_key(RestraintInfo self, unsigned int i) -> std::string"""
4418  return _IMP_kernel.RestraintInfo_get_float_key(self, i)
4419 
4420 
4421  def get_float_value(self, i):
4422  """get_float_value(RestraintInfo self, unsigned int i) -> double"""
4423  return _IMP_kernel.RestraintInfo_get_float_value(self, i)
4424 
4425 
4426  def add_string(self, key, value):
4427  """add_string(RestraintInfo self, std::string key, std::string value)"""
4428  return _IMP_kernel.RestraintInfo_add_string(self, key, value)
4429 
4430 
4431  def get_number_of_string(self):
4432  """get_number_of_string(RestraintInfo self) -> unsigned int"""
4433  return _IMP_kernel.RestraintInfo_get_number_of_string(self)
4434 
4435 
4436  def get_string_key(self, i):
4437  """get_string_key(RestraintInfo self, unsigned int i) -> std::string"""
4438  return _IMP_kernel.RestraintInfo_get_string_key(self, i)
4439 
4440 
4441  def get_string_value(self, i):
4442  """get_string_value(RestraintInfo self, unsigned int i) -> std::string"""
4443  return _IMP_kernel.RestraintInfo_get_string_value(self, i)
4444 
4445 
4446  def add_filename(self, key, value):
4447  """add_filename(RestraintInfo self, std::string key, std::string value)"""
4448  return _IMP_kernel.RestraintInfo_add_filename(self, key, value)
4449 
4450 
4451  def get_number_of_filename(self):
4452  """get_number_of_filename(RestraintInfo self) -> unsigned int"""
4453  return _IMP_kernel.RestraintInfo_get_number_of_filename(self)
4454 
4455 
4456  def get_filename_key(self, i):
4457  """get_filename_key(RestraintInfo self, unsigned int i) -> std::string"""
4458  return _IMP_kernel.RestraintInfo_get_filename_key(self, i)
4459 
4460 
4461  def get_filename_value(self, i):
4462  """get_filename_value(RestraintInfo self, unsigned int i) -> std::string"""
4463  return _IMP_kernel.RestraintInfo_get_filename_value(self, i)
4464 
4465 
4466  def add_floats(self, key, value):
4467  """add_floats(RestraintInfo self, std::string key, IMP::Floats value)"""
4468  return _IMP_kernel.RestraintInfo_add_floats(self, key, value)
4469 
4470 
4471  def get_number_of_floats(self):
4472  """get_number_of_floats(RestraintInfo self) -> unsigned int"""
4473  return _IMP_kernel.RestraintInfo_get_number_of_floats(self)
4474 
4475 
4476  def get_floats_key(self, i):
4477  """get_floats_key(RestraintInfo self, unsigned int i) -> std::string"""
4478  return _IMP_kernel.RestraintInfo_get_floats_key(self, i)
4479 
4480 
4481  def get_floats_value(self, i):
4482  """get_floats_value(RestraintInfo self, unsigned int i) -> IMP::Floats"""
4483  return _IMP_kernel.RestraintInfo_get_floats_value(self, i)
4484 
4485 
4486  def add_ints(self, key, value):
4487  """add_ints(RestraintInfo self, std::string key, IMP::Ints value)"""
4488  return _IMP_kernel.RestraintInfo_add_ints(self, key, value)
4489 
4490 
4491  def get_number_of_ints(self):
4492  """get_number_of_ints(RestraintInfo self) -> unsigned int"""
4493  return _IMP_kernel.RestraintInfo_get_number_of_ints(self)
4494 
4495 
4496  def get_ints_key(self, i):
4497  """get_ints_key(RestraintInfo self, unsigned int i) -> std::string"""
4498  return _IMP_kernel.RestraintInfo_get_ints_key(self, i)
4499 
4500 
4501  def get_ints_value(self, i):
4502  """get_ints_value(RestraintInfo self, unsigned int i) -> IMP::Ints"""
4503  return _IMP_kernel.RestraintInfo_get_ints_value(self, i)
4504 
4505 
4506  def add_strings(self, key, value):
4507  """add_strings(RestraintInfo self, std::string key, IMP::Strings value)"""
4508  return _IMP_kernel.RestraintInfo_add_strings(self, key, value)
4509 
4510 
4511  def get_number_of_strings(self):
4512  """get_number_of_strings(RestraintInfo self) -> unsigned int"""
4513  return _IMP_kernel.RestraintInfo_get_number_of_strings(self)
4514 
4515 
4516  def get_strings_key(self, i):
4517  """get_strings_key(RestraintInfo self, unsigned int i) -> std::string"""
4518  return _IMP_kernel.RestraintInfo_get_strings_key(self, i)
4519 
4520 
4521  def get_strings_value(self, i):
4522  """get_strings_value(RestraintInfo self, unsigned int i) -> IMP::Strings"""
4523  return _IMP_kernel.RestraintInfo_get_strings_value(self, i)
4524 
4525 
4526  def add_filenames(self, key, value):
4527  """add_filenames(RestraintInfo self, std::string key, IMP::Strings value)"""
4528  return _IMP_kernel.RestraintInfo_add_filenames(self, key, value)
4529 
4530 
4531  def get_number_of_filenames(self):
4532  """get_number_of_filenames(RestraintInfo self) -> unsigned int"""
4533  return _IMP_kernel.RestraintInfo_get_number_of_filenames(self)
4534 
4535 
4536  def get_filenames_key(self, i):
4537  """get_filenames_key(RestraintInfo self, unsigned int i) -> std::string"""
4538  return _IMP_kernel.RestraintInfo_get_filenames_key(self, i)
4539 
4540 
4541  def get_filenames_value(self, i):
4542  """get_filenames_value(RestraintInfo self, unsigned int i) -> IMP::Strings"""
4543  return _IMP_kernel.RestraintInfo_get_filenames_value(self, i)
4544 
4545 
4546  def add_particle_indexes(self, key, value):
4547  """add_particle_indexes(RestraintInfo self, std::string key, IMP::ParticleIndexes value)"""
4548  return _IMP_kernel.RestraintInfo_add_particle_indexes(self, key, value)
4549 
4550 
4551  def get_number_of_particle_indexes(self):
4552  """get_number_of_particle_indexes(RestraintInfo self) -> unsigned int"""
4553  return _IMP_kernel.RestraintInfo_get_number_of_particle_indexes(self)
4554 
4555 
4556  def get_particle_indexes_key(self, i):
4557  """get_particle_indexes_key(RestraintInfo self, unsigned int i) -> std::string"""
4558  return _IMP_kernel.RestraintInfo_get_particle_indexes_key(self, i)
4559 
4560 
4561  def get_particle_indexes_value(self, i):
4562  """get_particle_indexes_value(RestraintInfo self, unsigned int i) -> IMP::ParticleIndexes"""
4563  return _IMP_kernel.RestraintInfo_get_particle_indexes_value(self, i)
4564 
4565 
4566  def get_version_info(self):
4567  """get_version_info(RestraintInfo self) -> VersionInfo"""
4568  return _IMP_kernel.RestraintInfo_get_version_info(self)
4569 
4570 
4571  def __str__(self):
4572  """__str__(RestraintInfo self) -> std::string"""
4573  return _IMP_kernel.RestraintInfo___str__(self)
4574 
4575 
4576  def __repr__(self):
4577  """__repr__(RestraintInfo self) -> std::string"""
4578  return _IMP_kernel.RestraintInfo___repr__(self)
4579 
4580 
4581  @staticmethod
4582  def get_from(o):
4583  return _object_cast_to_RestraintInfo(o)
4584 
4585 RestraintInfo_swigregister = _IMP_kernel.RestraintInfo_swigregister
4586 RestraintInfo_swigregister(RestraintInfo)
4587 
4588 class Restraint(ModelObject):
4589  """Proxy of C++ IMP::Restraint class"""
4590  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
4591 
4592  def __init__(self, m, name):
4593  """__init__(IMP::Restraint self, Model m, std::string name) -> Restraint"""
4594  if self.__class__ == Restraint:
4595  _self = None
4596  else:
4597  _self = self
4598  this = _IMP_kernel.new_Restraint(_self, m, name)
4599  try:
4600  self.this.append(this)
4601  except:
4602  self.this = this
4603 
4604  if self.__class__ != Restraint:
4605  _director_objects.register(self)
4606 
4607 
4608 
4609 
4610  def get_score(self):
4611  """get_score(Restraint self) -> double"""
4612  return _IMP_kernel.Restraint_get_score(self)
4613 
4614 
4615  def evaluate(self, calc_derivs):
4616  """evaluate(Restraint self, bool calc_derivs) -> double"""
4617  return _IMP_kernel.Restraint_evaluate(self, calc_derivs)
4618 
4619 
4620  def evaluate_if_good(self, calc_derivatives):
4621  """evaluate_if_good(Restraint self, bool calc_derivatives) -> double"""
4622  return _IMP_kernel.Restraint_evaluate_if_good(self, calc_derivatives)
4623 
4624 
4625  def evaluate_if_below(self, calc_derivatives, max):
4626  """evaluate_if_below(Restraint self, bool calc_derivatives, double max) -> double"""
4627  return _IMP_kernel.Restraint_evaluate_if_below(self, calc_derivatives, max)
4628 
4629 
4630  def unprotected_evaluate(self, da):
4631  """unprotected_evaluate(Restraint self, DerivativeAccumulator da) -> double"""
4632  return _IMP_kernel.Restraint_unprotected_evaluate(self, da)
4633 
4634 
4635  def unprotected_evaluate_if_good(self, da, max):
4636  """unprotected_evaluate_if_good(Restraint self, DerivativeAccumulator da, double max) -> double"""
4637  return _IMP_kernel.Restraint_unprotected_evaluate_if_good(self, da, max)
4638 
4639 
4640  def unprotected_evaluate_if_below(self, da, max):
4641  """unprotected_evaluate_if_below(Restraint self, DerivativeAccumulator da, double max) -> double"""
4642  return _IMP_kernel.Restraint_unprotected_evaluate_if_below(self, da, max)
4643 
4644 
4645  def get_static_info(self):
4646  """get_static_info(Restraint self) -> RestraintInfo"""
4647  return _IMP_kernel.Restraint_get_static_info(self)
4648 
4649 
4650  def get_dynamic_info(self):
4651  """get_dynamic_info(Restraint self) -> RestraintInfo"""
4652  return _IMP_kernel.Restraint_get_dynamic_info(self)
4653 
4654 
4655  def add_score_and_derivatives(self, sa):
4656  """add_score_and_derivatives(Restraint self, ScoreAccumulator sa)"""
4657  return _IMP_kernel.Restraint_add_score_and_derivatives(self, sa)
4658 
4659 
4660  def create_decomposition(self):
4661  """create_decomposition(Restraint self) -> Restraint"""
4662  return _IMP_kernel.Restraint_create_decomposition(self)
4663 
4664 
4665  def create_current_decomposition(self):
4666  """create_current_decomposition(Restraint self) -> Restraint"""
4667  return _IMP_kernel.Restraint_create_current_decomposition(self)
4668 
4669 
4670  def set_weight(self, weight):
4671  """set_weight(Restraint self, IMP::Float weight)"""
4672  return _IMP_kernel.Restraint_set_weight(self, weight)
4673 
4674 
4675  def get_weight(self):
4676  """get_weight(Restraint self) -> IMP::Float"""
4677  return _IMP_kernel.Restraint_get_weight(self)
4678 
4679 
4680  def get_maximum_score(self):
4681  """get_maximum_score(Restraint self) -> double"""
4682  return _IMP_kernel.Restraint_get_maximum_score(self)
4683 
4684 
4685  def set_maximum_score(self, s):
4686  """set_maximum_score(Restraint self, double s)"""
4687  return _IMP_kernel.Restraint_set_maximum_score(self, s)
4688 
4689 
4690  def create_scoring_function(self, *args):
4691  """
4692  create_scoring_function(Restraint self, double weight=1.0, double max) -> ScoringFunction
4693  create_scoring_function(Restraint self, double weight=1.0) -> ScoringFunction
4694  create_scoring_function(Restraint self) -> ScoringFunction
4695  """
4696  return _IMP_kernel.Restraint_create_scoring_function(self, *args)
4697 
4698 
4699  def set_last_score(self, s):
4700  """set_last_score(Restraint self, double s)"""
4701  return _IMP_kernel.Restraint_set_last_score(self, s)
4702 
4703 
4704  def get_last_score(self):
4705  """get_last_score(Restraint self) -> double"""
4706  return _IMP_kernel.Restraint_get_last_score(self)
4707 
4708 
4709  def get_was_good(self):
4710  """get_was_good(Restraint self) -> bool"""
4711  return _IMP_kernel.Restraint_get_was_good(self)
4712 
4713  __swig_destroy__ = _IMP_kernel.delete_Restraint
4714  __del__ = lambda self: None
4715 
4716  def do_create_decomposition(self):
4717  """do_create_decomposition(Restraint self) -> IMP::Restraints"""
4718  return _IMP_kernel.Restraint_do_create_decomposition(self)
4719 
4720 
4721  def do_create_current_decomposition(self):
4722  """do_create_current_decomposition(Restraint self) -> IMP::Restraints"""
4723  return _IMP_kernel.Restraint_do_create_current_decomposition(self)
4724 
4725 
4726  def do_add_score_and_derivatives(self, sa):
4727  """do_add_score_and_derivatives(Restraint self, ScoreAccumulator sa)"""
4728  return _IMP_kernel.Restraint_do_add_score_and_derivatives(self, sa)
4729 
4730 
4731  def do_get_outputs(self):
4732  """do_get_outputs(Restraint self) -> IMP::ModelObjectsTemp"""
4733  return _IMP_kernel.Restraint_do_get_outputs(self)
4734 
4735 
4736  def __str__(self):
4737  """__str__(Restraint self) -> std::string"""
4738  return _IMP_kernel.Restraint___str__(self)
4739 
4740 
4741  def __repr__(self):
4742  """__repr__(Restraint self) -> std::string"""
4743  return _IMP_kernel.Restraint___repr__(self)
4744 
4745 
4746  @staticmethod
4747  def get_from(o):
4748  return _object_cast_to_Restraint(o)
4749 
4750 
4751  def get_type_name(self):
4752  return self.__class__.__name__
4753  def do_show(self, out):
4754  pass
4755  def get_version_info(self):
4756  if"IMP" == "IMP":
4757  return VersionInfo(self.__module__,
4758  __import__(self.__module__).get_module_version())
4759  else:
4760  return IMP.VersionInfo(self.__module__,
4761  __import__(self.__module__).get_module_version())
4762  @staticmethod
4763  def get_from(o):
4764  return _object_cast_to_Restraint(o)
4765 
4766  def __disown__(self):
4767  self.this.disown()
4768  _IMP_kernel.disown_Restraint(self)
4769  return weakref_proxy(self)
4770 
4771  def do_destroy(self):
4772  """do_destroy(Restraint self)"""
4773  return _IMP_kernel.Restraint_do_destroy(self)
4774 
4775 
4776  def handle_set_has_required_score_states(self, arg0):
4777  """handle_set_has_required_score_states(Restraint self, bool arg0)"""
4778  return _IMP_kernel.Restraint_handle_set_has_required_score_states(self, arg0)
4779 
4780 
4781  def do_get_inputs(self):
4782  """do_get_inputs(Restraint self) -> IMP::ModelObjectsTemp"""
4783  return _IMP_kernel.Restraint_do_get_inputs(self)
4784 
4785 
4786  def do_get_interactions(self):
4787  """do_get_interactions(Restraint self) -> IMP::ModelObjectsTemps"""
4788  return _IMP_kernel.Restraint_do_get_interactions(self)
4789 
4790 Restraint_swigregister = _IMP_kernel.Restraint_swigregister
4791 Restraint_swigregister(Restraint)
4792 
4793 class _RestraintsAdaptor(_InputAdaptor):
4794  """Proxy of C++ IMP::RestraintsAdaptor class"""
4795  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
4796  __repr__ = _swig_repr
4797 
4798  def __init__(self, *args):
4799  """
4800  __init__(IMP::RestraintsAdaptor self) -> _RestraintsAdaptor
4801  __init__(IMP::RestraintsAdaptor self, IMP::Restraints const & sf) -> _RestraintsAdaptor
4802  __init__(IMP::RestraintsAdaptor self, IMP::RestraintsTemp const & sf) -> _RestraintsAdaptor
4803  __init__(IMP::RestraintsAdaptor self, Restraint sf) -> _RestraintsAdaptor
4804  """
4805  this = _IMP_kernel.new__RestraintsAdaptor(*args)
4806  try:
4807  self.this.append(this)
4808  except:
4809  self.this = this
4810  __swig_destroy__ = _IMP_kernel.delete__RestraintsAdaptor
4811  __del__ = lambda self: None
4812 _RestraintsAdaptor_swigregister = _IMP_kernel._RestraintsAdaptor_swigregister
4813 _RestraintsAdaptor_swigregister(_RestraintsAdaptor)
4814 
4815 class RestraintSet(Restraint):
4816  """Proxy of C++ IMP::RestraintSet class"""
4817  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
4818 
4819  def __init__(self, *args):
4820  """
4821  __init__(IMP::RestraintSet self, Model m, double weight, std::string const & name) -> RestraintSet
4822  __init__(IMP::RestraintSet self, Model m, double weight) -> RestraintSet
4823  __init__(IMP::RestraintSet self, Model m, std::string const & name) -> RestraintSet
4824  __init__(IMP::RestraintSet self, Model m) -> RestraintSet
4825  __init__(IMP::RestraintSet self, IMP::RestraintsTemp const & rs, double weight, std::string const & name) -> RestraintSet
4826  __init__(IMP::RestraintSet self, IMP::RestraintsTemp const & rs, double weight) -> RestraintSet
4827  """
4828  if self.__class__ == RestraintSet:
4829  _self = None
4830  else:
4831  _self = self
4832  this = _IMP_kernel.new_RestraintSet(_self, *args)
4833  try:
4834  self.this.append(this)
4835  except:
4836  self.this = this
4837 
4838  if self.__class__ != RestraintSet:
4839  _director_objects.register(self)
4840 
4841 
4842 
4843 
4844  def unprotected_evaluate(self, da):
4845  """unprotected_evaluate(RestraintSet self, DerivativeAccumulator da) -> double"""
4846  return _IMP_kernel.RestraintSet_unprotected_evaluate(self, da)
4847 
4848 
4849  def get_type_name(self):
4850  """get_type_name(RestraintSet self) -> std::string"""
4851  return _IMP_kernel.RestraintSet_get_type_name(self)
4852 
4853 
4854  def get_version_info(self):
4855  """get_version_info(RestraintSet self) -> VersionInfo"""
4856  return _IMP_kernel.RestraintSet_get_version_info(self)
4857 
4858 
4859  def remove_restraint(self, d):
4860  """remove_restraint(RestraintSet self, Restraint d)"""
4861  return _IMP_kernel.RestraintSet_remove_restraint(self, d)
4862 
4863 
4864  def remove_restraints(self, d):
4865  """remove_restraints(RestraintSet self, IMP::Restraints const & d)"""
4866  return _IMP_kernel.RestraintSet_remove_restraints(self, d)
4867 
4868 
4869  def set_restraints(self, ps):
4870  """set_restraints(RestraintSet self, IMP::Restraints const & ps)"""
4871  return _IMP_kernel.RestraintSet_set_restraints(self, ps)
4872 
4873 
4874  def set_restraints_order(self, objs):
4875  """set_restraints_order(RestraintSet self, IMP::Restraints const & objs)"""
4876  return _IMP_kernel.RestraintSet_set_restraints_order(self, objs)
4877 
4878 
4879  def add_restraint(self, obj):
4880  """add_restraint(RestraintSet self, Restraint obj) -> unsigned int"""
4881  return _IMP_kernel.RestraintSet_add_restraint(self, obj)
4882 
4883 
4884  def add_restraints(self, objs):
4885  """add_restraints(RestraintSet self, IMP::Restraints const & objs)"""
4886  return _IMP_kernel.RestraintSet_add_restraints(self, objs)
4887 
4888 
4889  def clear_restraints(self):
4890  """clear_restraints(RestraintSet self)"""
4891  return _IMP_kernel.RestraintSet_clear_restraints(self)
4892 
4893 
4894  def get_number_of_restraints(self):
4895  """get_number_of_restraints(RestraintSet self) -> unsigned int"""
4896  return _IMP_kernel.RestraintSet_get_number_of_restraints(self)
4897 
4898 
4899  def get_has_restraints(self):
4900  """get_has_restraints(RestraintSet self) -> bool"""
4901  return _IMP_kernel.RestraintSet_get_has_restraints(self)
4902 
4903 
4904  def get_restraint(self, i):
4905  """get_restraint(RestraintSet self, unsigned int i) -> Restraint"""
4906  return _IMP_kernel.RestraintSet_get_restraint(self, i)
4907 
4908 
4909  def get_restraints(self):
4910  """get_restraints(RestraintSet self) -> IMP::Restraints"""
4911  return _IMP_kernel.RestraintSet_get_restraints(self)
4912 
4913 
4914  def reserve_restraints(self, sz):
4915  """reserve_restraints(RestraintSet self, unsigned int sz)"""
4916  return _IMP_kernel.RestraintSet_reserve_restraints(self, sz)
4917 
4918 
4919  def get_non_sets_and_sets(self):
4920  """get_non_sets_and_sets(RestraintSet self) -> std::pair< IMP::RestraintsTemp,IMP::RestraintSetsTemp >"""
4921  return _IMP_kernel.RestraintSet_get_non_sets_and_sets(self)
4922 
4923 
4924  def do_get_inputs(self):
4925  """do_get_inputs(RestraintSet self) -> IMP::ModelObjectsTemp"""
4926  return _IMP_kernel.RestraintSet_do_get_inputs(self)
4927 
4928 
4929  def create_scoring_function(self, *args):
4930  """
4931  create_scoring_function(RestraintSet self, double weight=1.0, double max) -> ScoringFunction
4932  create_scoring_function(RestraintSet self, double weight=1.0) -> ScoringFunction
4933  create_scoring_function(RestraintSet self) -> ScoringFunction
4934  """
4935  return _IMP_kernel.RestraintSet_create_scoring_function(self, *args)
4936 
4937 
4938  def get_last_score(self):
4939  """get_last_score(RestraintSet self) -> double"""
4940  return _IMP_kernel.RestraintSet_get_last_score(self)
4941 
4942 
4943  def __str__(self):
4944  """__str__(RestraintSet self) -> std::string"""
4945  return _IMP_kernel.RestraintSet___str__(self)
4946 
4947 
4948  def __repr__(self):
4949  """__repr__(RestraintSet self) -> std::string"""
4950  return _IMP_kernel.RestraintSet___repr__(self)
4951 
4952 
4953  @staticmethod
4954  def get_from(o):
4955  return _object_cast_to_RestraintSet(o)
4956 
4957 
4958  def get_type_name(self):
4959  return self.__class__.__name__
4960  def do_show(self, out):
4961  pass
4962  def get_version_info(self):
4963  if"IMP" == "IMP":
4964  return VersionInfo(self.__module__,
4965  __import__(self.__module__).get_module_version())
4966  else:
4967  return IMP.VersionInfo(self.__module__,
4968  __import__(self.__module__).get_module_version())
4969  @staticmethod
4970  def get_from(o):
4971  return _object_cast_to_RestraintSet(o)
4972 
4973  def __disown__(self):
4974  self.this.disown()
4975  _IMP_kernel.disown_RestraintSet(self)
4976  return weakref_proxy(self)
4977 
4978  def do_destroy(self):
4979  """do_destroy(RestraintSet self)"""
4980  return _IMP_kernel.RestraintSet_do_destroy(self)
4981 
4982 
4983  def handle_set_has_required_score_states(self, arg0):
4984  """handle_set_has_required_score_states(RestraintSet self, bool arg0)"""
4985  return _IMP_kernel.RestraintSet_handle_set_has_required_score_states(self, arg0)
4986 
4987 
4988  def do_get_outputs(self):
4989  """do_get_outputs(RestraintSet self) -> IMP::ModelObjectsTemp"""
4990  return _IMP_kernel.RestraintSet_do_get_outputs(self)
4991 
4992 
4993  def do_get_interactions(self):
4994  """do_get_interactions(RestraintSet self) -> IMP::ModelObjectsTemps"""
4995  return _IMP_kernel.RestraintSet_do_get_interactions(self)
4996 
4997 
4998  def do_create_decomposition(self):
4999  """do_create_decomposition(RestraintSet self) -> IMP::Restraints"""
5000  return _IMP_kernel.RestraintSet_do_create_decomposition(self)
5001 
5002 
5003  def do_create_current_decomposition(self):
5004  """do_create_current_decomposition(RestraintSet self) -> IMP::Restraints"""
5005  return _IMP_kernel.RestraintSet_do_create_current_decomposition(self)
5006 
5007 
5008  def do_add_score_and_derivatives(self, sa):
5009  """do_add_score_and_derivatives(RestraintSet self, ScoreAccumulator sa)"""
5010  return _IMP_kernel.RestraintSet_do_add_score_and_derivatives(self, sa)
5011 
5012 RestraintSet_swigregister = _IMP_kernel.RestraintSet_swigregister
5013 RestraintSet_swigregister(RestraintSet)
5014 
5015 
5016 def get_restraints(rs):
5017  """get_restraints(IMP::RestraintsTemp const & rs) -> IMP::RestraintsTemp"""
5018  return _IMP_kernel.get_restraints(rs)
5019 
5020 def _check_particle(p, a):
5021  if (not p.get_is_active()):
5022  raise ValueError("Inactive Particle")
5023  if (type(a)() == a):
5024  raise IndexError("Cannot use default Index")
5025  if (not p.has_attribute(a)):
5026  raise IndexError("Particle does not have attribute")
5027 
5028 class Particle(ModelObject):
5029  """Proxy of C++ IMP::Particle class"""
5030  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
5031 
5032  def get_version_info(self):
5033  """get_version_info(Particle self) -> VersionInfo"""
5034  return _IMP_kernel.Particle_get_version_info(self)
5035 
5036 
5037  def __init__(self, *args):
5038  """
5039  __init__(IMP::Particle self, Model m, std::string name) -> Particle
5040  __init__(IMP::Particle self, Model m) -> Particle
5041  """
5042  this = _IMP_kernel.new_Particle(*args)
5043  try:
5044  self.this.append(this)
5045  except:
5046  self.this = this
5047 
5048  def get_float_keys(self):
5049  """get_float_keys(Particle self) -> IMP::FloatKeys"""
5050  return _IMP_kernel.Particle_get_float_keys(self)
5051 
5052 
5053  def get_floats_keys(self):
5054  """get_floats_keys(Particle self) -> IMP::FloatsKeys"""
5055  return _IMP_kernel.Particle_get_floats_keys(self)
5056 
5057 
5058  def get_int_keys(self):
5059  """get_int_keys(Particle self) -> IMP::IntKeys"""
5060  return _IMP_kernel.Particle_get_int_keys(self)
5061 
5062 
5063  def get_ints_keys(self):
5064  """get_ints_keys(Particle self) -> IMP::IntsKeys"""
5065  return _IMP_kernel.Particle_get_ints_keys(self)
5066 
5067 
5068  def get_string_keys(self):
5069  """get_string_keys(Particle self) -> IMP::StringKeys"""
5070  return _IMP_kernel.Particle_get_string_keys(self)
5071 
5072 
5073  def get_object_keys(self):
5074  """get_object_keys(Particle self) -> IMP::ObjectKeys"""
5075  return _IMP_kernel.Particle_get_object_keys(self)
5076 
5077 
5078  def add_cache_attribute(self, *args):
5079  """
5080  add_cache_attribute(Particle self, FloatKey name, IMP::Float value)
5081  add_cache_attribute(Particle self, FloatsKey name, IMP::Floats value)
5082  add_cache_attribute(Particle self, IntKey name, IMP::Int value)
5083  add_cache_attribute(Particle self, IntsKey name, IMP::Ints value)
5084  add_cache_attribute(Particle self, StringKey name, IMP::String value)
5085  add_cache_attribute(Particle self, ObjectKey name, Object value)
5086  add_cache_attribute(Particle self, IMP::WeakObjectKey name, Object value)
5087  """
5088  return _IMP_kernel.Particle_add_cache_attribute(self, *args)
5089 
5090 
5091  def get_weak_object_keys(self):
5092  """get_weak_object_keys(Particle self) -> IMP::WeakObjectKeys"""
5093  return _IMP_kernel.Particle_get_weak_object_keys(self)
5094 
5095 
5096  def add_to_derivative(self, key, value, da):
5097  """add_to_derivative(Particle self, FloatKey key, IMP::Float value, DerivativeAccumulator da)"""
5098  return _IMP_kernel.Particle_add_to_derivative(self, key, value, da)
5099 
5100 
5101  def set_is_optimized(self, k, tf):
5102  """set_is_optimized(Particle self, FloatKey k, bool tf)"""
5103  return _IMP_kernel.Particle_set_is_optimized(self, k, tf)
5104 
5105 
5106  def get_is_optimized(self, k):
5107  """get_is_optimized(Particle self, FloatKey k) -> bool"""
5108  return _IMP_kernel.Particle_get_is_optimized(self, k)
5109 
5110 
5111  def get_derivative(self, k):
5112  """get_derivative(Particle self, FloatKey k) -> IMP::Float"""
5113  return _IMP_kernel.Particle_get_derivative(self, k)
5114 
5115 
5116  def add_attribute(self, *args):
5117  """
5118  add_attribute(Particle self, FloatKey name, IMP::Float initial_value)
5119  add_attribute(Particle self, FloatsKey name, IMP::Floats initial_value)
5120  add_attribute(Particle self, IntKey name, IMP::Int initial_value)
5121  add_attribute(Particle self, IntsKey name, IMP::Ints initial_value)
5122  add_attribute(Particle self, StringKey name, IMP::String initial_value)
5123  add_attribute(Particle self, ObjectKey name, Object initial_value)
5124  add_attribute(Particle self, IMP::WeakObjectKey name, Object initial_value)
5125  add_attribute(Particle self, FloatKey name, IMP::Float const initial_value, bool optimized)
5126  add_attribute(Particle self, ParticleIndexKey k, Particle v)
5127  """
5128  return _IMP_kernel.Particle_add_attribute(self, *args)
5129 
5130 
5131  def has_attribute(self, *args):
5132  """
5133  has_attribute(Particle self, FloatKey name) -> bool
5134  has_attribute(Particle self, FloatsKey name) -> bool
5135  has_attribute(Particle self, IntKey name) -> bool
5136  has_attribute(Particle self, IntsKey name) -> bool
5137  has_attribute(Particle self, StringKey name) -> bool
5138  has_attribute(Particle self, ObjectKey name) -> bool
5139  has_attribute(Particle self, IMP::WeakObjectKey name) -> bool
5140  has_attribute(Particle self, ParticleIndexKey k) -> bool
5141  """
5142  return _IMP_kernel.Particle_has_attribute(self, *args)
5143 
5144 
5145  def set_value(self, *args):
5146  """
5147  set_value(Particle self, FloatKey name, IMP::Float value)
5148  set_value(Particle self, FloatsKey name, IMP::Floats value)
5149  set_value(Particle self, IntKey name, IMP::Int value)
5150  set_value(Particle self, IntsKey name, IMP::Ints value)
5151  set_value(Particle self, StringKey name, IMP::String value)
5152  set_value(Particle self, ObjectKey name, Object value)
5153  set_value(Particle self, IMP::WeakObjectKey name, Object value)
5154  set_value(Particle self, ParticleIndexKey k, Particle v)
5155  """
5156  return _IMP_kernel.Particle_set_value(self, *args)
5157 
5158 
5159  def get_value(self, *args):
5160  """
5161  get_value(Particle self, FloatKey name) -> IMP::Float
5162  get_value(Particle self, FloatsKey name) -> IMP::Floats
5163  get_value(Particle self, IntKey name) -> IMP::Int
5164  get_value(Particle self, IntsKey name) -> IMP::Ints
5165  get_value(Particle self, StringKey name) -> IMP::String
5166  get_value(Particle self, ObjectKey name) -> Object
5167  get_value(Particle self, IMP::WeakObjectKey name) -> Object
5168  get_value(Particle self, ParticleIndexKey k) -> Particle
5169  """
5170  return _IMP_kernel.Particle_get_value(self, *args)
5171 
5172 
5173  def remove_attribute(self, *args):
5174  """
5175  remove_attribute(Particle self, FloatKey name)
5176  remove_attribute(Particle self, FloatsKey name)
5177  remove_attribute(Particle self, IntKey name)
5178  remove_attribute(Particle self, IntsKey name)
5179  remove_attribute(Particle self, StringKey name)
5180  remove_attribute(Particle self, ObjectKey name)
5181  remove_attribute(Particle self, IMP::WeakObjectKey name)
5182  remove_attribute(Particle self, ParticleIndexKey k)
5183  """
5184  return _IMP_kernel.Particle_remove_attribute(self, *args)
5185 
5186 
5187  def get_particle_keys(self):
5188  """get_particle_keys(Particle self) -> IMP::ParticleIndexKeys"""
5189  return _IMP_kernel.Particle_get_particle_keys(self)
5190 
5191 
5192  def show(self, *args):
5193  """
5194  show(Particle self, _ostream out)
5195  show(Particle self)
5196  """
5197  return _IMP_kernel.Particle_show(self, *args)
5198 
5199 
5200  def get_is_active(self):
5201  """get_is_active(Particle self) -> bool"""
5202  return _IMP_kernel.Particle_get_is_active(self)
5203 
5204 
5205  def get_index(self):
5206  """get_index(Particle self) -> ParticleIndex"""
5207  return _IMP_kernel.Particle_get_index(self)
5208 
5209 
5210  def __eq__(self, *args):
5211  """
5212  __eq__(Particle self, Particle o) -> bool
5213  __eq__(Particle self, Decorator d) -> bool
5214  """
5215  return _IMP_kernel.Particle___eq__(self, *args)
5216 
5217 
5218  def __ne__(self, *args):
5219  """
5220  __ne__(Particle self, Particle o) -> bool
5221  __ne__(Particle self, Decorator d) -> bool
5222  """
5223  return _IMP_kernel.Particle___ne__(self, *args)
5224 
5225 
5226  def __le__(self, *args):
5227  """
5228  __le__(Particle self, Particle o) -> bool
5229  __le__(Particle self, Decorator d) -> bool
5230  """
5231  return _IMP_kernel.Particle___le__(self, *args)
5232 
5233 
5234  def __lt__(self, *args):
5235  """
5236  __lt__(Particle self, Particle o) -> bool
5237  __lt__(Particle self, Decorator d) -> bool
5238  """
5239  return _IMP_kernel.Particle___lt__(self, *args)
5240 
5241 
5242  def __ge__(self, *args):
5243  """
5244  __ge__(Particle self, Particle o) -> bool
5245  __ge__(Particle self, Decorator d) -> bool
5246  """
5247  return _IMP_kernel.Particle___ge__(self, *args)
5248 
5249 
5250  def __gt__(self, *args):
5251  """
5252  __gt__(Particle self, Particle o) -> bool
5253  __gt__(Particle self, Decorator d) -> bool
5254  """
5255  return _IMP_kernel.Particle___gt__(self, *args)
5256 
5257 
5258  __hash__ = ModelObject.__hash__
5259 
5260 
5261  def __str__(self):
5262  """__str__(Particle self) -> std::string"""
5263  return _IMP_kernel.Particle___str__(self)
5264 
5265 
5266  def __repr__(self):
5267  """__repr__(Particle self) -> std::string"""
5268  return _IMP_kernel.Particle___repr__(self)
5269 
5270 
5271  @staticmethod
5272  def get_from(o):
5273  return _object_cast_to_Particle(o)
5274 
5275 Particle_swigregister = _IMP_kernel.Particle_swigregister
5276 Particle_swigregister(Particle)
5277 
5278 class _ParticleAdaptor(_InputAdaptor):
5279  """Proxy of C++ IMP::ParticleAdaptor class"""
5280  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
5281  __repr__ = _swig_repr
5282 
5283  def __init__(self, *args):
5284  """
5285  __init__(IMP::ParticleAdaptor self) -> _ParticleAdaptor
5286  __init__(IMP::ParticleAdaptor self, Particle p) -> _ParticleAdaptor
5287  __init__(IMP::ParticleAdaptor self, Decorator d) -> _ParticleAdaptor
5288  """
5289  this = _IMP_kernel.new__ParticleAdaptor(*args)
5290  try:
5291  self.this.append(this)
5292  except:
5293  self.this = this
5294 
5295  def get_model(self):
5296  """get_model(_ParticleAdaptor self) -> Model"""
5297  return _IMP_kernel._ParticleAdaptor_get_model(self)
5298 
5299 
5300  def get_particle_index(self):
5301  """get_particle_index(_ParticleAdaptor self) -> ParticleIndex"""
5302  return _IMP_kernel._ParticleAdaptor_get_particle_index(self)
5303 
5304  __swig_destroy__ = _IMP_kernel.delete__ParticleAdaptor
5305  __del__ = lambda self: None
5306 _ParticleAdaptor_swigregister = _IMP_kernel._ParticleAdaptor_swigregister
5307 _ParticleAdaptor_swigregister(_ParticleAdaptor)
5308 
5309 class _DependencyGraphVertexIndex(object):
5310  """Proxy of C++ IMP::DependencyGraphVertexIndex class"""
5311  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
5312  __repr__ = _swig_repr
5313 
5314  def __init__(self):
5315  """__init__(IMP::DependencyGraphVertexIndex self) -> _DependencyGraphVertexIndex"""
5316  this = _IMP_kernel.new__DependencyGraphVertexIndex()
5317  try:
5318  self.this.append(this)
5319  except:
5320  self.this = this
5321  __swig_destroy__ = _IMP_kernel.delete__DependencyGraphVertexIndex
5322  __del__ = lambda self: None
5323 _DependencyGraphVertexIndex_swigregister = _IMP_kernel._DependencyGraphVertexIndex_swigregister
5324 _DependencyGraphVertexIndex_swigregister(_DependencyGraphVertexIndex)
5325 
5326 
5327 def show_as_graphviz(name, out):
5328  """show_as_graphviz(IMP::DependencyGraph const & name, TextOutput out)"""
5329  return _IMP_kernel.show_as_graphviz(name, out)
5330 
5331 def get_vertex_index(g):
5332  """get_vertex_index(IMP::DependencyGraph const & g) -> _DependencyGraphVertexIndex"""
5333  return _IMP_kernel.get_vertex_index(g)
5334 
5335 def get_dependency_graph(m):
5336  """get_dependency_graph(Model m) -> IMP::DependencyGraph"""
5337  return _IMP_kernel.get_dependency_graph(m)
5338 
5340  """get_pruned_dependency_graph(Model m) -> IMP::DependencyGraph"""
5341  return _IMP_kernel.get_pruned_dependency_graph(m)
5342 
5343 def get_required_score_states(*args):
5344  """
5345  get_required_score_states(IMP::ModelObjectsTemp const & mos, IMP::ScoreStatesTemp exclude) -> IMP::ScoreStatesTemp
5346  get_required_score_states(IMP::ModelObjectsTemp const & mos) -> IMP::ScoreStatesTemp
5347  get_required_score_states(ModelObject p, IMP::ModelObjectsTemp const & all, IMP::DependencyGraph const & dg, _DependencyGraphVertexIndex index) -> IMP::ScoreStatesTemp
5348  """
5349  return _IMP_kernel.get_required_score_states(*args)
5350 
5351 def get_dependent_particles(p, all, dg, index):
5352  """get_dependent_particles(ModelObject p, IMP::ModelObjectsTemp const & all, IMP::DependencyGraph const & dg, _DependencyGraphVertexIndex index) -> IMP::ParticlesTemp"""
5353  return _IMP_kernel.get_dependent_particles(p, all, dg, index)
5354 
5355 def get_dependent_restraints(m, pi):
5356  """get_dependent_restraints(Model m, ParticleIndex pi) -> IMP::RestraintsTemp"""
5357  return _IMP_kernel.get_dependent_restraints(m, pi)
5358 class ScoringFunction(ModelObject):
5359  """Proxy of C++ IMP::ScoringFunction class"""
5360  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
5361 
5362  def do_add_score_and_derivatives(self, sa, ss):
5363  """do_add_score_and_derivatives(ScoringFunction self, ScoreAccumulator sa, IMP::ScoreStatesTemp const & ss)"""
5364  return _IMP_kernel.ScoringFunction_do_add_score_and_derivatives(self, sa, ss)
5365 
5366 
5367  def get_score_accumulator_if_below(self, deriv, max):
5368  """get_score_accumulator_if_below(ScoringFunction self, bool deriv, double max) -> ScoreAccumulator"""
5369  return _IMP_kernel.ScoringFunction_get_score_accumulator_if_below(self, deriv, max)
5370 
5371 
5372  def get_score_accumulator_if_good(self, deriv):
5373  """get_score_accumulator_if_good(ScoringFunction self, bool deriv) -> ScoreAccumulator"""
5374  return _IMP_kernel.ScoringFunction_get_score_accumulator_if_good(self, deriv)
5375 
5376 
5377  def get_score_accumulator(self, deriv):
5378  """get_score_accumulator(ScoringFunction self, bool deriv) -> ScoreAccumulator"""
5379  return _IMP_kernel.ScoringFunction_get_score_accumulator(self, deriv)
5380 
5381 
5382  def __init__(self, m, name):
5383  """__init__(IMP::ScoringFunction self, Model m, std::string name) -> ScoringFunction"""
5384  if self.__class__ == ScoringFunction:
5385  _self = None
5386  else:
5387  _self = self
5388  this = _IMP_kernel.new_ScoringFunction(_self, m, name)
5389  try:
5390  self.this.append(this)
5391  except:
5392  self.this = this
5393 
5394  if self.__class__ != ScoringFunction:
5395  _director_objects.register(self)
5396 
5397 
5398 
5399 
5400  def do_get_outputs(self):
5401  """do_get_outputs(ScoringFunction self) -> IMP::ModelObjectsTemp"""
5402  return _IMP_kernel.ScoringFunction_do_get_outputs(self)
5403 
5404 
5405  def evaluate_if_good(self, derivatives):
5406  """evaluate_if_good(ScoringFunction self, bool derivatives) -> double"""
5407  return _IMP_kernel.ScoringFunction_evaluate_if_good(self, derivatives)
5408 
5409 
5410  def evaluate(self, derivatives):
5411  """evaluate(ScoringFunction self, bool derivatives) -> double"""
5412  return _IMP_kernel.ScoringFunction_evaluate(self, derivatives)
5413 
5414 
5415  def evaluate_if_below(self, derivatives, max):
5416  """evaluate_if_below(ScoringFunction self, bool derivatives, double max) -> double"""
5417  return _IMP_kernel.ScoringFunction_evaluate_if_below(self, derivatives, max)
5418 
5419 
5420  def get_had_good_score(self):
5421  """get_had_good_score(ScoringFunction self) -> bool"""
5422  return _IMP_kernel.ScoringFunction_get_had_good_score(self)
5423 
5424 
5425  def get_last_score(self):
5426  """get_last_score(ScoringFunction self) -> double"""
5427  return _IMP_kernel.ScoringFunction_get_last_score(self)
5428 
5429 
5430  def create_restraints(self):
5431  """create_restraints(ScoringFunction self) -> IMP::Restraints"""
5432  return _IMP_kernel.ScoringFunction_create_restraints(self)
5433 
5434 
5435  def __str__(self):
5436  """__str__(ScoringFunction self) -> std::string"""
5437  return _IMP_kernel.ScoringFunction___str__(self)
5438 
5439 
5440  def __repr__(self):
5441  """__repr__(ScoringFunction self) -> std::string"""
5442  return _IMP_kernel.ScoringFunction___repr__(self)
5443 
5444 
5445  @staticmethod
5446  def get_from(o):
5447  return _object_cast_to_ScoringFunction(o)
5448 
5449 
5450  def get_type_name(self):
5451  return self.__class__.__name__
5452  def do_show(self, out):
5453  pass
5454  def get_version_info(self):
5455  if"IMP" == "IMP":
5456  return VersionInfo(self.__module__,
5457  __import__(self.__module__).get_module_version())
5458  else:
5459  return IMP.VersionInfo(self.__module__,
5460  __import__(self.__module__).get_module_version())
5461  @staticmethod
5462  def get_from(o):
5463  return _object_cast_to_ScoringFunction(o)
5464 
5465  __swig_destroy__ = _IMP_kernel.delete_ScoringFunction
5466  __del__ = lambda self: None
5467  def __disown__(self):
5468  self.this.disown()
5469  _IMP_kernel.disown_ScoringFunction(self)
5470  return weakref_proxy(self)
5471 
5472  def do_destroy(self):
5473  """do_destroy(ScoringFunction self)"""
5474  return _IMP_kernel.ScoringFunction_do_destroy(self)
5475 
5476 
5477  def handle_set_has_required_score_states(self, arg0):
5478  """handle_set_has_required_score_states(ScoringFunction self, bool arg0)"""
5479  return _IMP_kernel.ScoringFunction_handle_set_has_required_score_states(self, arg0)
5480 
5481 
5482  def do_get_inputs(self):
5483  """do_get_inputs(ScoringFunction self) -> IMP::ModelObjectsTemp"""
5484  return _IMP_kernel.ScoringFunction_do_get_inputs(self)
5485 
5486 
5487  def do_get_interactions(self):
5488  """do_get_interactions(ScoringFunction self) -> IMP::ModelObjectsTemps"""
5489  return _IMP_kernel.ScoringFunction_do_get_interactions(self)
5490 
5491 ScoringFunction_swigregister = _IMP_kernel.ScoringFunction_swigregister
5492 ScoringFunction_swigregister(ScoringFunction)
5493 
5494 
5495 def create_decomposition(*args):
5496  """
5497  create_decomposition(IMP::RestraintsTemp const & rs) -> IMP::Restraints
5498  create_decomposition(ScoringFunction sf) -> IMP::ScoringFunctions
5499  """
5500  return _IMP_kernel.create_decomposition(*args)
5501 class _ScoringFunctionAdaptor(_InputAdaptor):
5502  """Proxy of C++ IMP::ScoringFunctionAdaptor class"""
5503  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
5504  __repr__ = _swig_repr
5505 
5506  def __init__(self, *args):
5507  """
5508  __init__(IMP::ScoringFunctionAdaptor self) -> _ScoringFunctionAdaptor
5509  __init__(IMP::ScoringFunctionAdaptor self, ScoringFunction sf) -> _ScoringFunctionAdaptor
5510  __init__(IMP::ScoringFunctionAdaptor self, IMP::RestraintsTemp const & sf) -> _ScoringFunctionAdaptor
5511  __init__(IMP::ScoringFunctionAdaptor self, IMP::Restraints const & sf) -> _ScoringFunctionAdaptor
5512  __init__(IMP::ScoringFunctionAdaptor self, Restraint sf) -> _ScoringFunctionAdaptor
5513  """
5514  this = _IMP_kernel.new__ScoringFunctionAdaptor(*args)
5515  try:
5516  self.this.append(this)
5517  except:
5518  self.this = this
5519  __swig_destroy__ = _IMP_kernel.delete__ScoringFunctionAdaptor
5520  __del__ = lambda self: None
5521 _ScoringFunctionAdaptor_swigregister = _IMP_kernel._ScoringFunctionAdaptor_swigregister
5522 _ScoringFunctionAdaptor_swigregister(_ScoringFunctionAdaptor)
5523 
5524 
5525 def show_restraint_hierarchy(*args):
5526  """
5527  show_restraint_hierarchy(_ScoringFunctionAdaptor rs, _ostream out)
5528  show_restraint_hierarchy(_ScoringFunctionAdaptor rs)
5529  """
5530  return _IMP_kernel.show_restraint_hierarchy(*args)
5531 class Undecorator(Object):
5532  """Proxy of C++ IMP::Undecorator class"""
5533  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
5534 
5535  def __init__(self, m, name):
5536  """__init__(IMP::Undecorator self, Model m, std::string name) -> Undecorator"""
5537  if self.__class__ == Undecorator:
5538  _self = None
5539  else:
5540  _self = self
5541  this = _IMP_kernel.new_Undecorator(_self, m, name)
5542  try:
5543  self.this.append(this)
5544  except:
5545  self.this = this
5546 
5547  if self.__class__ != Undecorator:
5548  _director_objects.register(self)
5549 
5550 
5551 
5552 
5553  def teardown(self, pi):
5554  """teardown(Undecorator self, ParticleIndex pi)"""
5555  return _IMP_kernel.Undecorator_teardown(self, pi)
5556 
5557 
5558  def __str__(self):
5559  """__str__(Undecorator self) -> std::string"""
5560  return _IMP_kernel.Undecorator___str__(self)
5561 
5562 
5563  def __repr__(self):
5564  """__repr__(Undecorator self) -> std::string"""
5565  return _IMP_kernel.Undecorator___repr__(self)
5566 
5567 
5568  @staticmethod
5569  def get_from(o):
5570  return _object_cast_to_Undecorator(o)
5571 
5572 
5573  def get_type_name(self):
5574  return self.__class__.__name__
5575  def do_show(self, out):
5576  pass
5577  def get_version_info(self):
5578  if"IMP" == "IMP":
5579  return VersionInfo(self.__module__,
5580  __import__(self.__module__).get_module_version())
5581  else:
5582  return IMP.VersionInfo(self.__module__,
5583  __import__(self.__module__).get_module_version())
5584  @staticmethod
5585  def get_from(o):
5586  return _object_cast_to_Undecorator(o)
5587 
5588  __swig_destroy__ = _IMP_kernel.delete_Undecorator
5589  __del__ = lambda self: None
5590  def __disown__(self):
5591  self.this.disown()
5592  _IMP_kernel.disown_Undecorator(self)
5593  return weakref_proxy(self)
5594 
5595  def do_destroy(self):
5596  """do_destroy(Undecorator self)"""
5597  return _IMP_kernel.Undecorator_do_destroy(self)
5598 
5599 Undecorator_swigregister = _IMP_kernel.Undecorator_swigregister
5600 Undecorator_swigregister(Undecorator)
5601 
5602 class Model(Object):
5603  """Proxy of C++ IMP::Model class"""
5604  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
5605 
5606  def __init__(self, *args):
5607  """
5608  __init__(IMP::Model self, std::string name) -> Model
5609  __init__(IMP::Model self) -> Model
5610  """
5611  this = _IMP_kernel.new_Model(*args)
5612  try:
5613  self.this.append(this)
5614  except:
5615  self.this = this
5616 
5617  def clear_particle_caches(self, pi):
5618  """clear_particle_caches(Model self, ParticleIndex pi)"""
5619  return _IMP_kernel.Model_clear_particle_caches(self, pi)
5620 
5621 
5622  def add_particle(self, name):
5623  """add_particle(Model self, std::string name) -> ParticleIndex"""
5624  return _IMP_kernel.Model_add_particle(self, name)
5625 
5626 
5627  def get_particle_name(self, pi):
5628  """get_particle_name(Model self, ParticleIndex pi) -> std::string"""
5629  return _IMP_kernel.Model_get_particle_name(self, pi)
5630 
5631 
5632  def add_undecorator(self, pi, d):
5633  """add_undecorator(Model self, ParticleIndex pi, Undecorator d)"""
5634  return _IMP_kernel.Model_add_undecorator(self, pi, d)
5635 
5636 
5637  def remove_score_state(self, d):
5638  """remove_score_state(Model self, ScoreState d)"""
5639  return _IMP_kernel.Model_remove_score_state(self, d)
5640 
5641 
5642  def remove_score_states(self, d):
5643  """remove_score_states(Model self, IMP::ScoreStates const & d)"""
5644  return _IMP_kernel.Model_remove_score_states(self, d)
5645 
5646 
5647  def set_score_states(self, ps):
5648  """set_score_states(Model self, IMP::ScoreStates const & ps)"""
5649  return _IMP_kernel.Model_set_score_states(self, ps)
5650 
5651 
5652  def set_score_states_order(self, objs):
5653  """set_score_states_order(Model self, IMP::ScoreStates const & objs)"""
5654  return _IMP_kernel.Model_set_score_states_order(self, objs)
5655 
5656 
5657  def add_score_state(self, obj):
5658  """add_score_state(Model self, ScoreState obj) -> unsigned int"""
5659  return _IMP_kernel.Model_add_score_state(self, obj)
5660 
5661 
5662  def add_score_states(self, objs):
5663  """add_score_states(Model self, IMP::ScoreStates const & objs)"""
5664  return _IMP_kernel.Model_add_score_states(self, objs)
5665 
5666 
5667  def clear_score_states(self):
5668  """clear_score_states(Model self)"""
5669  return _IMP_kernel.Model_clear_score_states(self)
5670 
5671 
5672  def get_number_of_score_states(self):
5673  """get_number_of_score_states(Model self) -> unsigned int"""
5674  return _IMP_kernel.Model_get_number_of_score_states(self)
5675 
5676 
5677  def get_has_score_states(self):
5678  """get_has_score_states(Model self) -> bool"""
5679  return _IMP_kernel.Model_get_has_score_states(self)
5680 
5681 
5682  def get_score_state(self, i):
5683  """get_score_state(Model self, unsigned int i) -> ScoreState"""
5684  return _IMP_kernel.Model_get_score_state(self, i)
5685 
5686 
5687  def get_score_states(self):
5688  """get_score_states(Model self) -> IMP::ScoreStates"""
5689  return _IMP_kernel.Model_get_score_states(self)
5690 
5691 
5692  def reserve_score_states(self, sz):
5693  """reserve_score_states(Model self, unsigned int sz)"""
5694  return _IMP_kernel.Model_reserve_score_states(self, sz)
5695 
5696 
5697  def update(self):
5698  """update(Model self)"""
5699  return _IMP_kernel.Model_update(self)
5700 
5701 
5702  def add_attribute(self, *args):
5703  """
5704  add_attribute(Model self, FloatKey attribute_key, ParticleIndex particle, IMP::Float value)
5705  add_attribute(Model self, IntKey attribute_key, ParticleIndex particle, IMP::Int value)
5706  add_attribute(Model self, FloatsKey attribute_key, ParticleIndex particle, IMP::Floats value)
5707  add_attribute(Model self, IntsKey attribute_key, ParticleIndex particle, IMP::Ints value)
5708  add_attribute(Model self, StringKey attribute_key, ParticleIndex particle, IMP::String value)
5709  add_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle, IMP::ParticleIndexes value)
5710  add_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle, ParticleIndex value)
5711  add_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle, Object value)
5712  add_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle, Object value)
5713  """
5714  return _IMP_kernel.Model_add_attribute(self, *args)
5715 
5716 
5717  def remove_attribute(self, *args):
5718  """
5719  remove_attribute(Model self, FloatKey attribute_key, ParticleIndex particle)
5720  remove_attribute(Model self, IntKey attribute_key, ParticleIndex particle)
5721  remove_attribute(Model self, FloatsKey attribute_key, ParticleIndex particle)
5722  remove_attribute(Model self, IntsKey attribute_key, ParticleIndex particle)
5723  remove_attribute(Model self, StringKey attribute_key, ParticleIndex particle)
5724  remove_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle)
5725  remove_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle)
5726  remove_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle)
5727  remove_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle)
5728  """
5729  return _IMP_kernel.Model_remove_attribute(self, *args)
5730 
5731 
5732  def get_has_attribute(self, *args):
5733  """
5734  get_has_attribute(Model self, FloatKey attribute_key, ParticleIndex particle) -> bool
5735  get_has_attribute(Model self, IntKey attribute_key, ParticleIndex particle) -> bool
5736  get_has_attribute(Model self, FloatsKey attribute_key, ParticleIndex particle) -> bool
5737  get_has_attribute(Model self, IntsKey attribute_key, ParticleIndex particle) -> bool
5738  get_has_attribute(Model self, StringKey attribute_key, ParticleIndex particle) -> bool
5739  get_has_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle) -> bool
5740  get_has_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle) -> bool
5741  get_has_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle) -> bool
5742  get_has_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle) -> bool
5743  """
5744  return _IMP_kernel.Model_get_has_attribute(self, *args)
5745 
5746 
5747  def set_attribute(self, *args):
5748  """
5749  set_attribute(Model self, FloatKey attribute_key, ParticleIndex particle, IMP::Float value)
5750  set_attribute(Model self, IntKey attribute_key, ParticleIndex particle, IMP::Int value)
5751  set_attribute(Model self, FloatsKey attribute_key, ParticleIndex particle, IMP::Floats value)
5752  set_attribute(Model self, IntsKey attribute_key, ParticleIndex particle, IMP::Ints value)
5753  set_attribute(Model self, StringKey attribute_key, ParticleIndex particle, IMP::String value)
5754  set_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle, IMP::ParticleIndexes value)
5755  set_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle, ParticleIndex value)
5756  set_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle, Object value)
5757  set_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle, Object value)
5758  """
5759  return _IMP_kernel.Model_set_attribute(self, *args)
5760 
5761 
5762  def get_attribute(self, *args):
5763  """
5764  get_attribute(Model self, FloatKey attribute_key, ParticleIndex particle) -> IMP::Float
5765  get_attribute(Model self, IntKey attribute_key, ParticleIndex particle) -> IMP::Int
5766  get_attribute(Model self, FloatsKey attribute_key, ParticleIndex particle) -> IMP::Floats
5767  get_attribute(Model self, IntsKey attribute_key, ParticleIndex particle) -> IMP::Ints
5768  get_attribute(Model self, StringKey attribute_key, ParticleIndex particle) -> IMP::String
5769  get_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle) -> IMP::ParticleIndexes
5770  get_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle) -> ParticleIndex
5771  get_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle) -> Object
5772  get_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle) -> Object
5773  """
5774  return _IMP_kernel.Model_get_attribute(self, *args)
5775 
5776 
5777  def add_cache_attribute(self, *args):
5778  """
5779  add_cache_attribute(Model self, FloatKey attribute_key, ParticleIndex particle, IMP::Float value)
5780  add_cache_attribute(Model self, IntKey attribute_key, ParticleIndex particle, IMP::Int value)
5781  add_cache_attribute(Model self, FloatsKey attribute_key, ParticleIndex particle, IMP::Floats value)
5782  add_cache_attribute(Model self, IntsKey attribute_key, ParticleIndex particle, IMP::Ints value)
5783  add_cache_attribute(Model self, StringKey attribute_key, ParticleIndex particle, IMP::String value)
5784  add_cache_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle, IMP::ParticleIndexes value)
5785  add_cache_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle, ParticleIndex value)
5786  add_cache_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle, Object value)
5787  add_cache_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle, Object value)
5788  """
5789  return _IMP_kernel.Model_add_cache_attribute(self, *args)
5790 
5791 
5792  def set_is_optimized(self, arg2, arg3, arg4):
5793  """set_is_optimized(Model self, FloatKey arg2, ParticleIndex arg3, bool arg4)"""
5794  return _IMP_kernel.Model_set_is_optimized(self, arg2, arg3, arg4)
5795 
5796 
5797  def add_to_derivative(self, k, particle, v, da):
5798  """add_to_derivative(Model self, FloatKey k, ParticleIndex particle, double v, DerivativeAccumulator da)"""
5799  return _IMP_kernel.Model_add_to_derivative(self, k, particle, v, da)
5800 
5801 
5802  def get_particle(self, p):
5803  """get_particle(Model self, ParticleIndex p) -> Particle"""
5804  return _IMP_kernel.Model_get_particle(self, p)
5805 
5806 
5807  def get_has_particle(self, p):
5808  """get_has_particle(Model self, ParticleIndex p) -> bool"""
5809  return _IMP_kernel.Model_get_has_particle(self, p)
5810 
5811 
5812  def get_particle_indexes(self):
5813  """get_particle_indexes(Model self) -> IMP::ParticleIndexes"""
5814  return _IMP_kernel.Model_get_particle_indexes(self)
5815 
5816 
5817  def get_model_objects(self):
5818  """get_model_objects(Model self) -> IMP::ModelObjectsTemp"""
5819  return _IMP_kernel.Model_get_model_objects(self)
5820 
5821 
5822  def remove_particle(self, pi):
5823  """remove_particle(Model self, ParticleIndex pi)"""
5824  return _IMP_kernel.Model_remove_particle(self, pi)
5825 
5826 
5827  def add_data(self, mk, o):
5828  """add_data(Model self, ModelKey mk, Object o)"""
5829  return _IMP_kernel.Model_add_data(self, mk, o)
5830 
5831 
5832  def get_data(self, mk):
5833  """get_data(Model self, ModelKey mk) -> Object"""
5834  return _IMP_kernel.Model_get_data(self, mk)
5835 
5836 
5837  def remove_data(self, mk):
5838  """remove_data(Model self, ModelKey mk)"""
5839  return _IMP_kernel.Model_remove_data(self, mk)
5840 
5841 
5842  def get_has_data(self, mk):
5843  """get_has_data(Model self, ModelKey mk) -> bool"""
5844  return _IMP_kernel.Model_get_has_data(self, mk)
5845 
5846 
5847  def get_version_info(self):
5848  """get_version_info(Model self) -> VersionInfo"""
5849  return _IMP_kernel.Model_get_version_info(self)
5850 
5851 
5852  def do_destroy(self):
5853  """do_destroy(Model self)"""
5854  return _IMP_kernel.Model_do_destroy(self)
5855 
5856 
5857  def __str__(self):
5858  """__str__(Model self) -> std::string"""
5859  return _IMP_kernel.Model___str__(self)
5860 
5861 
5862  def __repr__(self):
5863  """__repr__(Model self) -> std::string"""
5864  return _IMP_kernel.Model___repr__(self)
5865 
5866 
5867  @staticmethod
5868  def get_from(o):
5869  return _object_cast_to_Model(o)
5870 
5871 
5872  def _get_ints_numpy(self, k):
5873  return _get_ints_numpy(self, k, self)
5874 
5875  def _get_floats_numpy(self, k):
5876  return _get_floats_numpy(self, k, self)
5877 
5878  def _get_derivatives_numpy(self, k):
5879  return _get_derivatives_numpy(self, k, self)
5880 
5881  def _get_spheres_numpy(self):
5882  return _get_spheres_numpy(self, self)
5883 
5884  def _get_sphere_derivatives_numpy(self):
5885  return _get_sphere_derivatives_numpy(self, self)
5886 
5887 Model_swigregister = _IMP_kernel.Model_swigregister
5888 Model_swigregister(Model)
5889 
5890 class Decorator(_Value):
5891  """Proxy of C++ IMP::Decorator class"""
5892  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
5893  __repr__ = _swig_repr
5894 
5895  def __init__(self, p):
5896  """__init__(IMP::Decorator self, _ParticleAdaptor p) -> Decorator"""
5897  this = _IMP_kernel.new_Decorator(p)
5898  try:
5899  self.this.append(this)
5900  except:
5901  self.this = this
5902 
5903  def __ne__(self, o):
5904  """__ne__(Decorator self, Object o) -> bool"""
5905  return _IMP_kernel.Decorator___ne__(self, o)
5906 
5907 
5908  def __lt__(self, o):
5909  """__lt__(Decorator self, Object o) -> bool"""
5910  return _IMP_kernel.Decorator___lt__(self, o)
5911 
5912 
5913  def __gt__(self, o):
5914  """__gt__(Decorator self, Object o) -> bool"""
5915  return _IMP_kernel.Decorator___gt__(self, o)
5916 
5917 
5918  def __ge__(self, o):
5919  """__ge__(Decorator self, Object o) -> bool"""
5920  return _IMP_kernel.Decorator___ge__(self, o)
5921 
5922 
5923  def __le__(self, o):
5924  """__le__(Decorator self, Object o) -> bool"""
5925  return _IMP_kernel.Decorator___le__(self, o)
5926 
5927 
5928  def get_particle(self):
5929  """get_particle(Decorator self) -> Particle"""
5930  return _IMP_kernel.Decorator_get_particle(self)
5931 
5932 
5933  def get_particle_index(self):
5934  """get_particle_index(Decorator self) -> ParticleIndex"""
5935  return _IMP_kernel.Decorator_get_particle_index(self)
5936 
5937 
5938  def get_model(self):
5939  """get_model(Decorator self) -> Model"""
5940  return _IMP_kernel.Decorator_get_model(self)
5941 
5942 
5943  def get_is_valid(self):
5944  """get_is_valid(Decorator self) -> bool"""
5945  return _IMP_kernel.Decorator_get_is_valid(self)
5946 
5947 
5948  def __hash__(self):
5949  """__hash__(Decorator self) -> std::size_t"""
5950  return _IMP_kernel.Decorator___hash__(self)
5951 
5952 
5953  def __eq__(self, *args):
5954  """
5955  __eq__(Decorator self, Object o) -> bool
5956  __eq__(Decorator self, Decorator o) -> bool
5957  __eq__(Decorator self, Particle o) -> bool
5958  """
5959  return _IMP_kernel.Decorator___eq__(self, *args)
5960 
5961 
5962  def __bool__(self):
5963  """__bool__(Decorator self) -> bool"""
5964  return _IMP_kernel.Decorator___bool__(self)
5965 
5966 
5967  __nonzero__ = __bool__
5968 
5969  __swig_destroy__ = _IMP_kernel.delete_Decorator
5970  __del__ = lambda self: None
5971 Decorator_swigregister = _IMP_kernel.Decorator_swigregister
5972 Decorator_swigregister(Decorator)
5973 
5974 
5975 def check_particle(m, pi):
5976  """check_particle(Model m, ParticleIndex pi)"""
5977  return _IMP_kernel.check_particle(m, pi)
5978 class UnaryFunction(Object):
5979  """Proxy of C++ IMP::UnaryFunction class"""
5980  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
5981 
5982  def __init__(self, *args):
5983  """
5984  __init__(IMP::UnaryFunction self, std::string name) -> UnaryFunction
5985  __init__(IMP::UnaryFunction self) -> UnaryFunction
5986  """
5987  if self.__class__ == UnaryFunction:
5988  _self = None
5989  else:
5990  _self = self
5991  this = _IMP_kernel.new_UnaryFunction(_self, *args)
5992  try:
5993  self.this.append(this)
5994  except:
5995  self.this = this
5996 
5997  if self.__class__ != UnaryFunction:
5998  _director_objects.register(self)
5999 
6000 
6001 
6002 
6003  def evaluate(self, feature):
6004  """evaluate(UnaryFunction self, double feature) -> double"""
6005  return _IMP_kernel.UnaryFunction_evaluate(self, feature)
6006 
6007 
6008  def evaluate_with_derivative(self, feature):
6009  """evaluate_with_derivative(UnaryFunction self, double feature) -> IMP::DerivativePair"""
6010  return _IMP_kernel.UnaryFunction_evaluate_with_derivative(self, feature)
6011 
6012  __swig_destroy__ = _IMP_kernel.delete_UnaryFunction
6013  __del__ = lambda self: None
6014 
6015  def __str__(self):
6016  """__str__(UnaryFunction self) -> std::string"""
6017  return _IMP_kernel.UnaryFunction___str__(self)
6018 
6019 
6020  def __repr__(self):
6021  """__repr__(UnaryFunction self) -> std::string"""
6022  return _IMP_kernel.UnaryFunction___repr__(self)
6023 
6024 
6025  @staticmethod
6026  def get_from(o):
6027  return _object_cast_to_UnaryFunction(o)
6028 
6029 
6030  def get_type_name(self):
6031  return self.__class__.__name__
6032  def do_show(self, out):
6033  pass
6034  def get_version_info(self):
6035  if"IMP" == "IMP":
6036  return VersionInfo(self.__module__,
6037  __import__(self.__module__).get_module_version())
6038  else:
6039  return IMP.VersionInfo(self.__module__,
6040  __import__(self.__module__).get_module_version())
6041  @staticmethod
6042  def get_from(o):
6043  return _object_cast_to_UnaryFunction(o)
6044 
6045  def __disown__(self):
6046  self.this.disown()
6047  _IMP_kernel.disown_UnaryFunction(self)
6048  return weakref_proxy(self)
6049 
6050  def do_destroy(self):
6051  """do_destroy(UnaryFunction self)"""
6052  return _IMP_kernel.UnaryFunction_do_destroy(self)
6053 
6054 UnaryFunction_swigregister = _IMP_kernel.UnaryFunction_swigregister
6055 UnaryFunction_swigregister(UnaryFunction)
6056 
6057 class OptimizerState(ModelObject):
6058  """Proxy of C++ IMP::OptimizerState class"""
6059  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
6060 
6061  def __init__(self, m, name):
6062  """__init__(IMP::OptimizerState self, Model m, std::string name) -> OptimizerState"""
6063  if self.__class__ == OptimizerState:
6064  _self = None
6065  else:
6066  _self = self
6067  this = _IMP_kernel.new_OptimizerState(_self, m, name)
6068  try:
6069  self.this.append(this)
6070  except:
6071  self.this = this
6072 
6073  if self.__class__ != OptimizerState:
6074  _director_objects.register(self)
6075 
6076 
6077 
6078 
6079  def update(self):
6080  """update(OptimizerState self)"""
6081  return _IMP_kernel.OptimizerState_update(self)
6082 
6083 
6084  def set_is_optimizing(self, arg0):
6085  """set_is_optimizing(OptimizerState self, bool arg0)"""
6086  return _IMP_kernel.OptimizerState_set_is_optimizing(self, arg0)
6087 
6088 
6089  def get_optimizer(self):
6090  """get_optimizer(OptimizerState self) -> Optimizer"""
6091  return _IMP_kernel.OptimizerState_get_optimizer(self)
6092 
6093 
6094  def set_period(self, p):
6095  """set_period(OptimizerState self, unsigned int p)"""
6096  return _IMP_kernel.OptimizerState_set_period(self, p)
6097 
6098 
6099  def get_period(self):
6100  """get_period(OptimizerState self) -> unsigned int"""
6101  return _IMP_kernel.OptimizerState_get_period(self)
6102 
6103 
6104  def reset(self):
6105  """reset(OptimizerState self)"""
6106  return _IMP_kernel.OptimizerState_reset(self)
6107 
6108 
6109  def update_always(self):
6110  """update_always(OptimizerState self)"""
6111  return _IMP_kernel.OptimizerState_update_always(self)
6112 
6113 
6114  def get_number_of_updates(self):
6115  """get_number_of_updates(OptimizerState self) -> unsigned int"""
6116  return _IMP_kernel.OptimizerState_get_number_of_updates(self)
6117 
6118 
6119  def set_number_of_updates(self, n):
6120  """set_number_of_updates(OptimizerState self, unsigned int n)"""
6121  return _IMP_kernel.OptimizerState_set_number_of_updates(self, n)
6122 
6123  __swig_destroy__ = _IMP_kernel.delete_OptimizerState
6124  __del__ = lambda self: None
6125 
6126  def do_update(self, arg0):
6127  """do_update(OptimizerState self, unsigned int arg0)"""
6128  return _IMP_kernel.OptimizerState_do_update(self, arg0)
6129 
6130 
6131  def do_set_is_optimizing(self, arg0):
6132  """do_set_is_optimizing(OptimizerState self, bool arg0)"""
6133  return _IMP_kernel.OptimizerState_do_set_is_optimizing(self, arg0)
6134 
6135 
6136  def do_get_inputs(self):
6137  """do_get_inputs(OptimizerState self) -> IMP::ModelObjectsTemp"""
6138  return _IMP_kernel.OptimizerState_do_get_inputs(self)
6139 
6140 
6141  def do_get_outputs(self):
6142  """do_get_outputs(OptimizerState self) -> IMP::ModelObjectsTemp"""
6143  return _IMP_kernel.OptimizerState_do_get_outputs(self)
6144 
6145 
6146  def __str__(self):
6147  """__str__(OptimizerState self) -> std::string"""
6148  return _IMP_kernel.OptimizerState___str__(self)
6149 
6150 
6151  def __repr__(self):
6152  """__repr__(OptimizerState self) -> std::string"""
6153  return _IMP_kernel.OptimizerState___repr__(self)
6154 
6155 
6156  @staticmethod
6157  def get_from(o):
6158  return _object_cast_to_OptimizerState(o)
6159 
6160 
6161  def get_type_name(self):
6162  return self.__class__.__name__
6163  def do_show(self, out):
6164  pass
6165  def get_version_info(self):
6166  if"IMP" == "IMP":
6167  return VersionInfo(self.__module__,
6168  __import__(self.__module__).get_module_version())
6169  else:
6170  return IMP.VersionInfo(self.__module__,
6171  __import__(self.__module__).get_module_version())
6172  @staticmethod
6173  def get_from(o):
6174  return _object_cast_to_OptimizerState(o)
6175 
6176  def __disown__(self):
6177  self.this.disown()
6178  _IMP_kernel.disown_OptimizerState(self)
6179  return weakref_proxy(self)
6180 
6181  def do_destroy(self):
6182  """do_destroy(OptimizerState self)"""
6183  return _IMP_kernel.OptimizerState_do_destroy(self)
6184 
6185 
6186  def handle_set_has_required_score_states(self, arg0):
6187  """handle_set_has_required_score_states(OptimizerState self, bool arg0)"""
6188  return _IMP_kernel.OptimizerState_handle_set_has_required_score_states(self, arg0)
6189 
6190 
6191  def do_get_interactions(self):
6192  """do_get_interactions(OptimizerState self) -> IMP::ModelObjectsTemps"""
6193  return _IMP_kernel.OptimizerState_do_get_interactions(self)
6194 
6195 OptimizerState_swigregister = _IMP_kernel.OptimizerState_swigregister
6196 OptimizerState_swigregister(OptimizerState)
6197 
6198 class Refiner(_ParticleInputs, Object):
6199  """Proxy of C++ IMP::Refiner class"""
6200  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
6201 
6202  def __init__(self, *args):
6203  """
6204  __init__(IMP::Refiner self, std::string name, bool is_by_ref=False) -> Refiner
6205  __init__(IMP::Refiner self, std::string name) -> Refiner
6206  __init__(IMP::Refiner self) -> Refiner
6207  """
6208  if self.__class__ == Refiner:
6209  _self = None
6210  else:
6211  _self = self
6212  this = _IMP_kernel.new_Refiner(_self, *args)
6213  try:
6214  self.this.append(this)
6215  except:
6216  self.this = this
6217 
6218  if self.__class__ != Refiner:
6219  _director_objects.register(self)
6220 
6221 
6222 
6223 
6224  def get_can_refine(self, arg0):
6225  """get_can_refine(Refiner self, Particle arg0) -> bool"""
6226  return _IMP_kernel.Refiner_get_can_refine(self, arg0)
6227 
6228 
6229  def get_refined_indexes(self, m, pi):
6230  """get_refined_indexes(Refiner self, Model m, ParticleIndex pi) -> IMP::ParticleIndexes"""
6231  return _IMP_kernel.Refiner_get_refined_indexes(self, m, pi)
6232 
6233 
6234  def get_refined_indexes_by_ref(self, m, pi):
6235  """get_refined_indexes_by_ref(Refiner self, Model m, ParticleIndex pi) -> IMP::ParticleIndexes const &"""
6236  return _IMP_kernel.Refiner_get_refined_indexes_by_ref(self, m, pi)
6237 
6238 
6239  def get_is_by_ref_supported(self):
6240  """get_is_by_ref_supported(Refiner self) -> bool"""
6241  return _IMP_kernel.Refiner_get_is_by_ref_supported(self)
6242 
6243 
6244  def get_refined(self, *args):
6245  """
6246  get_refined(Refiner self, Particle a) -> IMP::ParticlesTemp const
6247  get_refined(Refiner self, Particle a, unsigned int i) -> Particle
6248  """
6249  return _IMP_kernel.Refiner_get_refined(self, *args)
6250 
6251 
6252  def get_number_of_refined(self, a):
6253  """get_number_of_refined(Refiner self, Particle a) -> unsigned int"""
6254  return _IMP_kernel.Refiner_get_number_of_refined(self, a)
6255 
6256 
6257  def __str__(self):
6258  """__str__(Refiner self) -> std::string"""
6259  return _IMP_kernel.Refiner___str__(self)
6260 
6261 
6262  def __repr__(self):
6263  """__repr__(Refiner self) -> std::string"""
6264  return _IMP_kernel.Refiner___repr__(self)
6265 
6266 
6267  @staticmethod
6268  def get_from(o):
6269  return _object_cast_to_Refiner(o)
6270 
6271 
6272  def get_type_name(self):
6273  return self.__class__.__name__
6274  def do_show(self, out):
6275  pass
6276  def get_version_info(self):
6277  if"IMP" == "IMP":
6278  return VersionInfo(self.__module__,
6279  __import__(self.__module__).get_module_version())
6280  else:
6281  return IMP.VersionInfo(self.__module__,
6282  __import__(self.__module__).get_module_version())
6283  @staticmethod
6284  def get_from(o):
6285  return _object_cast_to_Refiner(o)
6286 
6287  __swig_destroy__ = _IMP_kernel.delete_Refiner
6288  __del__ = lambda self: None
6289  def __disown__(self):
6290  self.this.disown()
6291  _IMP_kernel.disown_Refiner(self)
6292  return weakref_proxy(self)
6293 
6294  def do_get_inputs(self, m, pis):
6295  """do_get_inputs(Refiner self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6296  return _IMP_kernel.Refiner_do_get_inputs(self, m, pis)
6297 
6298 
6299  def do_destroy(self):
6300  """do_destroy(Refiner self)"""
6301  return _IMP_kernel.Refiner_do_destroy(self)
6302 
6303 Refiner_swigregister = _IMP_kernel.Refiner_swigregister
6304 Refiner_swigregister(Refiner)
6305 
6306 class Optimizer(ModelObject):
6307  """Proxy of C++ IMP::Optimizer class"""
6308  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
6309 
6310  def set_is_optimizing_states(self, tf):
6311  """set_is_optimizing_states(Optimizer self, bool tf)"""
6312  return _IMP_kernel.Optimizer_set_is_optimizing_states(self, tf)
6313 
6314 
6315  def get_optimizer_state_inputs(self):
6316  """get_optimizer_state_inputs(Optimizer self) -> IMP::ModelObjectsTemp"""
6317  return _IMP_kernel.Optimizer_get_optimizer_state_inputs(self)
6318 
6319 
6320  def do_get_inputs(self):
6321  """do_get_inputs(Optimizer self) -> IMP::ModelObjectsTemp"""
6322  return _IMP_kernel.Optimizer_do_get_inputs(self)
6323 
6324 
6325  def do_get_outputs(self):
6326  """do_get_outputs(Optimizer self) -> IMP::ModelObjectsTemp"""
6327  return _IMP_kernel.Optimizer_do_get_outputs(self)
6328 
6329 
6330  def __init__(self, *args):
6331  """
6332  __init__(IMP::Optimizer self, Model m, std::string name) -> Optimizer
6333  __init__(IMP::Optimizer self, Model m) -> Optimizer
6334  """
6335  if self.__class__ == Optimizer:
6336  _self = None
6337  else:
6338  _self = self
6339  this = _IMP_kernel.new_Optimizer(_self, *args)
6340  try:
6341  self.this.append(this)
6342  except:
6343  self.this = this
6344 
6345  if self.__class__ != Optimizer:
6346  _director_objects.register(self)
6347 
6348 
6349 
6350 
6351  def optimize(self, max_steps):
6352  """optimize(Optimizer self, unsigned int max_steps) -> double"""
6353  return _IMP_kernel.Optimizer_optimize(self, max_steps)
6354 
6355 
6356  def set_stop_on_good_score(self, tf):
6357  """set_stop_on_good_score(Optimizer self, bool tf)"""
6358  return _IMP_kernel.Optimizer_set_stop_on_good_score(self, tf)
6359 
6360 
6361  def get_stop_on_good_score(self):
6362  """get_stop_on_good_score(Optimizer self) -> bool"""
6363  return _IMP_kernel.Optimizer_get_stop_on_good_score(self)
6364 
6365 
6366  def get_last_score(self):
6367  """get_last_score(Optimizer self) -> double"""
6368  return _IMP_kernel.Optimizer_get_last_score(self)
6369 
6370 
6371  def get_scoring_function(self):
6372  """get_scoring_function(Optimizer self) -> ScoringFunction"""
6373  return _IMP_kernel.Optimizer_get_scoring_function(self)
6374 
6375 
6376  def remove_optimizer_state(self, d):
6377  """remove_optimizer_state(Optimizer self, OptimizerState d)"""
6378  return _IMP_kernel.Optimizer_remove_optimizer_state(self, d)
6379 
6380 
6381  def remove_optimizer_states(self, d):
6382  """remove_optimizer_states(Optimizer self, IMP::OptimizerStates const & d)"""
6383  return _IMP_kernel.Optimizer_remove_optimizer_states(self, d)
6384 
6385 
6386  def set_optimizer_states(self, ps):
6387  """set_optimizer_states(Optimizer self, IMP::OptimizerStates const & ps)"""
6388  return _IMP_kernel.Optimizer_set_optimizer_states(self, ps)
6389 
6390 
6391  def set_optimizer_states_order(self, objs):
6392  """set_optimizer_states_order(Optimizer self, IMP::OptimizerStates const & objs)"""
6393  return _IMP_kernel.Optimizer_set_optimizer_states_order(self, objs)
6394 
6395 
6396  def add_optimizer_state(self, obj):
6397  """add_optimizer_state(Optimizer self, OptimizerState obj) -> unsigned int"""
6398  return _IMP_kernel.Optimizer_add_optimizer_state(self, obj)
6399 
6400 
6401  def add_optimizer_states(self, objs):
6402  """add_optimizer_states(Optimizer self, IMP::OptimizerStates const & objs)"""
6403  return _IMP_kernel.Optimizer_add_optimizer_states(self, objs)
6404 
6405 
6406  def clear_optimizer_states(self):
6407  """clear_optimizer_states(Optimizer self)"""
6408  return _IMP_kernel.Optimizer_clear_optimizer_states(self)
6409 
6410 
6411  def get_number_of_optimizer_states(self):
6412  """get_number_of_optimizer_states(Optimizer self) -> unsigned int"""
6413  return _IMP_kernel.Optimizer_get_number_of_optimizer_states(self)
6414 
6415 
6416  def get_has_optimizer_states(self):
6417  """get_has_optimizer_states(Optimizer self) -> bool"""
6418  return _IMP_kernel.Optimizer_get_has_optimizer_states(self)
6419 
6420 
6421  def get_optimizer_state(self, i):
6422  """get_optimizer_state(Optimizer self, unsigned int i) -> OptimizerState"""
6423  return _IMP_kernel.Optimizer_get_optimizer_state(self, i)
6424 
6425 
6426  def get_optimizer_states(self):
6427  """get_optimizer_states(Optimizer self) -> IMP::OptimizerStates"""
6428  return _IMP_kernel.Optimizer_get_optimizer_states(self)
6429 
6430 
6431  def reserve_optimizer_states(self, sz):
6432  """reserve_optimizer_states(Optimizer self, unsigned int sz)"""
6433  return _IMP_kernel.Optimizer_reserve_optimizer_states(self, sz)
6434 
6435 
6436  def set_scoring_function(self, sf):
6437  """set_scoring_function(Optimizer self, _ScoringFunctionAdaptor sf)"""
6438  return _IMP_kernel.Optimizer_set_scoring_function(self, sf)
6439 
6440  __swig_destroy__ = _IMP_kernel.delete_Optimizer
6441  def __del__(self):
6442  """__del__(IMP::Optimizer self)"""
6443 
6444  _director_objects.cleanup()
6445 
6446 
6447  pass
6448 
6449 
6450  def do_optimize(self, ns):
6451  """do_optimize(Optimizer self, unsigned int ns) -> double"""
6452  return _IMP_kernel.Optimizer_do_optimize(self, ns)
6453 
6454 
6455  def update_states(self):
6456  """update_states(Optimizer self)"""
6457  return _IMP_kernel.Optimizer_update_states(self)
6458 
6459 
6460  def __str__(self):
6461  """__str__(Optimizer self) -> std::string"""
6462  return _IMP_kernel.Optimizer___str__(self)
6463 
6464 
6465  def __repr__(self):
6466  """__repr__(Optimizer self) -> std::string"""
6467  return _IMP_kernel.Optimizer___repr__(self)
6468 
6469 
6470  @staticmethod
6471  def get_from(o):
6472  return _object_cast_to_Optimizer(o)
6473 
6474 
6475  def get_type_name(self):
6476  return self.__class__.__name__
6477  def do_show(self, out):
6478  pass
6479  def get_version_info(self):
6480  if"IMP" == "IMP":
6481  return VersionInfo(self.__module__,
6482  __import__(self.__module__).get_module_version())
6483  else:
6484  return IMP.VersionInfo(self.__module__,
6485  __import__(self.__module__).get_module_version())
6486  @staticmethod
6487  def get_from(o):
6488  return _object_cast_to_Optimizer(o)
6489 
6490  def __disown__(self):
6491  self.this.disown()
6492  _IMP_kernel.disown_Optimizer(self)
6493  return weakref_proxy(self)
6494 
6495  def do_destroy(self):
6496  """do_destroy(Optimizer self)"""
6497  return _IMP_kernel.Optimizer_do_destroy(self)
6498 
6499 
6500  def handle_set_has_required_score_states(self, arg0):
6501  """handle_set_has_required_score_states(Optimizer self, bool arg0)"""
6502  return _IMP_kernel.Optimizer_handle_set_has_required_score_states(self, arg0)
6503 
6504 
6505  def do_get_interactions(self):
6506  """do_get_interactions(Optimizer self) -> IMP::ModelObjectsTemps"""
6507  return _IMP_kernel.Optimizer_do_get_interactions(self)
6508 
6509 Optimizer_swigregister = _IMP_kernel.Optimizer_swigregister
6510 Optimizer_swigregister(Optimizer)
6511 
6512 class AttributeOptimizer(Optimizer):
6513  """Proxy of C++ IMP::AttributeOptimizer class"""
6514  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
6515 
6516  def __init__(self, *args):
6517  """
6518  __init__(IMP::AttributeOptimizer self, Model m, std::string name) -> AttributeOptimizer
6519  __init__(IMP::AttributeOptimizer self, Model m) -> AttributeOptimizer
6520  """
6521  if self.__class__ == AttributeOptimizer:
6522  _self = None
6523  else:
6524  _self = self
6525  this = _IMP_kernel.new_AttributeOptimizer(_self, *args)
6526  try:
6527  self.this.append(this)
6528  except:
6529  self.this = this
6530 
6531  if self.__class__ != AttributeOptimizer:
6532  _director_objects.register(self)
6533 
6534 
6535 
6536 
6537  def get_optimized_attributes(self):
6538  """get_optimized_attributes(AttributeOptimizer self) -> IMP::FloatIndexes"""
6539  return _IMP_kernel.AttributeOptimizer_get_optimized_attributes(self)
6540 
6541 
6542  def set_value(self, fi, v):
6543  """set_value(AttributeOptimizer self, FloatIndex fi, double v)"""
6544  return _IMP_kernel.AttributeOptimizer_set_value(self, fi, v)
6545 
6546 
6547  def get_value(self, fi):
6548  """get_value(AttributeOptimizer self, FloatIndex fi) -> IMP::Float"""
6549  return _IMP_kernel.AttributeOptimizer_get_value(self, fi)
6550 
6551 
6552  def get_derivative(self, fi):
6553  """get_derivative(AttributeOptimizer self, FloatIndex fi) -> IMP::Float"""
6554  return _IMP_kernel.AttributeOptimizer_get_derivative(self, fi)
6555 
6556 
6557  def get_width(self, k):
6558  """get_width(AttributeOptimizer self, FloatKey k) -> double"""
6559  return _IMP_kernel.AttributeOptimizer_get_width(self, k)
6560 
6561 
6562  def set_scaled_value(self, fi, v):
6563  """set_scaled_value(AttributeOptimizer self, FloatIndex fi, IMP::Float v)"""
6564  return _IMP_kernel.AttributeOptimizer_set_scaled_value(self, fi, v)
6565 
6566 
6567  def get_scaled_value(self, fi):
6568  """get_scaled_value(AttributeOptimizer self, FloatIndex fi) -> double"""
6569  return _IMP_kernel.AttributeOptimizer_get_scaled_value(self, fi)
6570 
6571 
6572  def get_scaled_derivative(self, fi):
6573  """get_scaled_derivative(AttributeOptimizer self, FloatIndex fi) -> double"""
6574  return _IMP_kernel.AttributeOptimizer_get_scaled_derivative(self, fi)
6575 
6576 
6577  def clear_range_cache(self):
6578  """clear_range_cache(AttributeOptimizer self)"""
6579  return _IMP_kernel.AttributeOptimizer_clear_range_cache(self)
6580 
6581 
6582  def __str__(self):
6583  """__str__(AttributeOptimizer self) -> std::string"""
6584  return _IMP_kernel.AttributeOptimizer___str__(self)
6585 
6586 
6587  def __repr__(self):
6588  """__repr__(AttributeOptimizer self) -> std::string"""
6589  return _IMP_kernel.AttributeOptimizer___repr__(self)
6590 
6591 
6592  @staticmethod
6593  def get_from(o):
6594  return _object_cast_to_AttributeOptimizer(o)
6595 
6596 
6597  def get_type_name(self):
6598  return self.__class__.__name__
6599  def do_show(self, out):
6600  pass
6601  def get_version_info(self):
6602  if"IMP" == "IMP":
6603  return VersionInfo(self.__module__,
6604  __import__(self.__module__).get_module_version())
6605  else:
6606  return IMP.VersionInfo(self.__module__,
6607  __import__(self.__module__).get_module_version())
6608  @staticmethod
6609  def get_from(o):
6610  return _object_cast_to_AttributeOptimizer(o)
6611 
6612  __swig_destroy__ = _IMP_kernel.delete_AttributeOptimizer
6613  __del__ = lambda self: None
6614  def __disown__(self):
6615  self.this.disown()
6616  _IMP_kernel.disown_AttributeOptimizer(self)
6617  return weakref_proxy(self)
6618 
6619  def do_destroy(self):
6620  """do_destroy(AttributeOptimizer self)"""
6621  return _IMP_kernel.AttributeOptimizer_do_destroy(self)
6622 
6623 
6624  def handle_set_has_required_score_states(self, arg0):
6625  """handle_set_has_required_score_states(AttributeOptimizer self, bool arg0)"""
6626  return _IMP_kernel.AttributeOptimizer_handle_set_has_required_score_states(self, arg0)
6627 
6628 
6629  def do_get_inputs(self):
6630  """do_get_inputs(AttributeOptimizer self) -> IMP::ModelObjectsTemp"""
6631  return _IMP_kernel.AttributeOptimizer_do_get_inputs(self)
6632 
6633 
6634  def do_get_outputs(self):
6635  """do_get_outputs(AttributeOptimizer self) -> IMP::ModelObjectsTemp"""
6636  return _IMP_kernel.AttributeOptimizer_do_get_outputs(self)
6637 
6638 
6639  def do_get_interactions(self):
6640  """do_get_interactions(AttributeOptimizer self) -> IMP::ModelObjectsTemps"""
6641  return _IMP_kernel.AttributeOptimizer_do_get_interactions(self)
6642 
6643 
6644  def do_optimize(self, ns):
6645  """do_optimize(AttributeOptimizer self, unsigned int ns) -> double"""
6646  return _IMP_kernel.AttributeOptimizer_do_optimize(self, ns)
6647 
6648 AttributeOptimizer_swigregister = _IMP_kernel.AttributeOptimizer_swigregister
6649 AttributeOptimizer_swigregister(AttributeOptimizer)
6650 
6651 class ConfigurationSet(Object):
6652  """Proxy of C++ IMP::ConfigurationSet class"""
6653  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
6654 
6655  def __init__(self, *args):
6656  """
6657  __init__(IMP::ConfigurationSet self, Model m, std::string name) -> ConfigurationSet
6658  __init__(IMP::ConfigurationSet self, Model m) -> ConfigurationSet
6659  """
6660  this = _IMP_kernel.new_ConfigurationSet(*args)
6661  try:
6662  self.this.append(this)
6663  except:
6664  self.this = this
6665 
6666  def save_configuration(self):
6667  """save_configuration(ConfigurationSet self)"""
6668  return _IMP_kernel.ConfigurationSet_save_configuration(self)
6669 
6670 
6671  def get_number_of_configurations(self):
6672  """get_number_of_configurations(ConfigurationSet self) -> unsigned int"""
6673  return _IMP_kernel.ConfigurationSet_get_number_of_configurations(self)
6674 
6675 
6676  def load_configuration(self, i):
6677  """load_configuration(ConfigurationSet self, int i)"""
6678  return _IMP_kernel.ConfigurationSet_load_configuration(self, i)
6679 
6680 
6681  def remove_configuration(self, i):
6682  """remove_configuration(ConfigurationSet self, unsigned int i)"""
6683  return _IMP_kernel.ConfigurationSet_remove_configuration(self, i)
6684 
6685 
6686  def get_model(self):
6687  """get_model(ConfigurationSet self) -> Model"""
6688  return _IMP_kernel.ConfigurationSet_get_model(self)
6689 
6690 
6691  def get_version_info(self):
6692  """get_version_info(ConfigurationSet self) -> VersionInfo"""
6693  return _IMP_kernel.ConfigurationSet_get_version_info(self)
6694 
6695 
6696  def __str__(self):
6697  """__str__(ConfigurationSet self) -> std::string"""
6698  return _IMP_kernel.ConfigurationSet___str__(self)
6699 
6700 
6701  def __repr__(self):
6702  """__repr__(ConfigurationSet self) -> std::string"""
6703  return _IMP_kernel.ConfigurationSet___repr__(self)
6704 
6705 
6706  @staticmethod
6707  def get_from(o):
6708  return _object_cast_to_ConfigurationSet(o)
6709 
6710 ConfigurationSet_swigregister = _IMP_kernel.ConfigurationSet_swigregister
6711 ConfigurationSet_swigregister(ConfigurationSet)
6712 
6713 class SaveToConfigurationSetOptimizerState(OptimizerState):
6714  """Proxy of C++ IMP::SaveToConfigurationSetOptimizerState class"""
6715  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
6716 
6717  def __init__(self, cs):
6718  """__init__(IMP::SaveToConfigurationSetOptimizerState self, ConfigurationSet cs) -> SaveToConfigurationSetOptimizerState"""
6719  this = _IMP_kernel.new_SaveToConfigurationSetOptimizerState(cs)
6720  try:
6721  self.this.append(this)
6722  except:
6723  self.this = this
6724 
6725  def get_version_info(self):
6726  """get_version_info(SaveToConfigurationSetOptimizerState self) -> VersionInfo"""
6727  return _IMP_kernel.SaveToConfigurationSetOptimizerState_get_version_info(self)
6728 
6729 
6730  def __str__(self):
6731  """__str__(SaveToConfigurationSetOptimizerState self) -> std::string"""
6732  return _IMP_kernel.SaveToConfigurationSetOptimizerState___str__(self)
6733 
6734 
6735  def __repr__(self):
6736  """__repr__(SaveToConfigurationSetOptimizerState self) -> std::string"""
6737  return _IMP_kernel.SaveToConfigurationSetOptimizerState___repr__(self)
6738 
6739 
6740  @staticmethod
6741  def get_from(o):
6742  return _object_cast_to_SaveToConfigurationSetOptimizerState(o)
6743 
6744 SaveToConfigurationSetOptimizerState_swigregister = _IMP_kernel.SaveToConfigurationSetOptimizerState_swigregister
6745 SaveToConfigurationSetOptimizerState_swigregister(SaveToConfigurationSetOptimizerState)
6746 
6747 class Configuration(Object):
6748  """Proxy of C++ IMP::Configuration class"""
6749  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
6750 
6751  def __init__(self, *args):
6752  """
6753  __init__(IMP::Configuration self, Model m, std::string name) -> Configuration
6754  __init__(IMP::Configuration self, Model m) -> Configuration
6755  __init__(IMP::Configuration self, Model m, Configuration base, std::string name) -> Configuration
6756  __init__(IMP::Configuration self, Model m, Configuration base) -> Configuration
6757  """
6758  this = _IMP_kernel.new_Configuration(*args)
6759  try:
6760  self.this.append(this)
6761  except:
6762  self.this = this
6763 
6764  def load_configuration(self):
6765  """load_configuration(Configuration self)"""
6766  return _IMP_kernel.Configuration_load_configuration(self)
6767 
6768 
6769  def swap_configuration(self):
6770  """swap_configuration(Configuration self)"""
6771  return _IMP_kernel.Configuration_swap_configuration(self)
6772 
6773 
6774  def get_version_info(self):
6775  """get_version_info(Configuration self) -> VersionInfo"""
6776  return _IMP_kernel.Configuration_get_version_info(self)
6777 
6778 
6779  def __str__(self):
6780  """__str__(Configuration self) -> std::string"""
6781  return _IMP_kernel.Configuration___str__(self)
6782 
6783 
6784  def __repr__(self):
6785  """__repr__(Configuration self) -> std::string"""
6786  return _IMP_kernel.Configuration___repr__(self)
6787 
6788 
6789  @staticmethod
6790  def get_from(o):
6791  return _object_cast_to_Configuration(o)
6792 
6793 Configuration_swigregister = _IMP_kernel.Configuration_swigregister
6794 Configuration_swigregister(Configuration)
6795 
6796 class Sampler(Object):
6797  """Proxy of C++ IMP::Sampler class"""
6798  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
6799 
6800  def __init__(self, *args):
6801  """
6802  __init__(IMP::Sampler self, Model m, std::string name) -> Sampler
6803  __init__(IMP::Sampler self, Model m) -> Sampler
6804  """
6805  if self.__class__ == Sampler:
6806  _self = None
6807  else:
6808  _self = self
6809  this = _IMP_kernel.new_Sampler(_self, *args)
6810  try:
6811  self.this.append(this)
6812  except:
6813  self.this = this
6814 
6815  if self.__class__ != Sampler:
6816  _director_objects.register(self)
6817 
6818 
6819 
6820 
6821  def create_sample(self):
6822  """create_sample(Sampler self) -> ConfigurationSet"""
6823  return _IMP_kernel.Sampler_create_sample(self)
6824 
6825 
6826  def get_scoring_function(self):
6827  """get_scoring_function(Sampler self) -> ScoringFunction"""
6828  return _IMP_kernel.Sampler_get_scoring_function(self)
6829 
6830 
6831  def set_scoring_function(self, sf):
6832  """set_scoring_function(Sampler self, _ScoringFunctionAdaptor sf)"""
6833  return _IMP_kernel.Sampler_set_scoring_function(self, sf)
6834 
6835 
6836  def get_model(self):
6837  """get_model(Sampler self) -> Model"""
6838  return _IMP_kernel.Sampler_get_model(self)
6839 
6840 
6841  def do_sample(self):
6842  """do_sample(Sampler self) -> ConfigurationSet"""
6843  return _IMP_kernel.Sampler_do_sample(self)
6844 
6845  __swig_destroy__ = _IMP_kernel.delete_Sampler
6846  __del__ = lambda self: None
6847 
6848  def __str__(self):
6849  """__str__(Sampler self) -> std::string"""
6850  return _IMP_kernel.Sampler___str__(self)
6851 
6852 
6853  def __repr__(self):
6854  """__repr__(Sampler self) -> std::string"""
6855  return _IMP_kernel.Sampler___repr__(self)
6856 
6857 
6858  @staticmethod
6859  def get_from(o):
6860  return _object_cast_to_Sampler(o)
6861 
6862 
6863  def get_type_name(self):
6864  return self.__class__.__name__
6865  def do_show(self, out):
6866  pass
6867  def get_version_info(self):
6868  if"IMP" == "IMP":
6869  return VersionInfo(self.__module__,
6870  __import__(self.__module__).get_module_version())
6871  else:
6872  return IMP.VersionInfo(self.__module__,
6873  __import__(self.__module__).get_module_version())
6874  @staticmethod
6875  def get_from(o):
6876  return _object_cast_to_Sampler(o)
6877 
6878  def __disown__(self):
6879  self.this.disown()
6880  _IMP_kernel.disown_Sampler(self)
6881  return weakref_proxy(self)
6882 
6883  def do_destroy(self):
6884  """do_destroy(Sampler self)"""
6885  return _IMP_kernel.Sampler_do_destroy(self)
6886 
6887 Sampler_swigregister = _IMP_kernel.Sampler_swigregister
6888 Sampler_swigregister(Sampler)
6889 
6890 class PairModifier(_ParticleInputs, _ParticleOutputs, Object):
6891  """Proxy of C++ IMP::PairModifier class"""
6892  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
6893 
6894  def __init__(self, *args):
6895  """
6896  __init__(IMP::PairModifier self, std::string name) -> PairModifier
6897  __init__(IMP::PairModifier self) -> PairModifier
6898  """
6899  if self.__class__ == PairModifier:
6900  _self = None
6901  else:
6902  _self = self
6903  this = _IMP_kernel.new_PairModifier(_self, *args)
6904  try:
6905  self.this.append(this)
6906  except:
6907  self.this = this
6908 
6909  if self.__class__ != PairModifier:
6910  _director_objects.register(self)
6911 
6912 
6913 
6914 
6915  def apply_index(self, m, v):
6916  """apply_index(PairModifier self, Model m, IMP::ParticleIndexPair const & v)"""
6917  return _IMP_kernel.PairModifier_apply_index(self, m, v)
6918 
6919 
6920  def apply_indexes(self, m, o, lower_bound, upper_bound):
6921  """apply_indexes(PairModifier self, Model m, IMP::ParticleIndexPairs const & o, unsigned int lower_bound, unsigned int upper_bound)"""
6922  return _IMP_kernel.PairModifier_apply_indexes(self, m, o, lower_bound, upper_bound)
6923 
6924 
6925  def __str__(self):
6926  """__str__(PairModifier self) -> std::string"""
6927  return _IMP_kernel.PairModifier___str__(self)
6928 
6929 
6930  def __repr__(self):
6931  """__repr__(PairModifier self) -> std::string"""
6932  return _IMP_kernel.PairModifier___repr__(self)
6933 
6934 
6935  @staticmethod
6936  def get_from(o):
6937  return _object_cast_to_PairModifier(o)
6938 
6939 
6940  def get_type_name(self):
6941  return self.__class__.__name__
6942  def do_show(self, out):
6943  pass
6944  def get_version_info(self):
6945  if"IMP" == "IMP":
6946  return VersionInfo(self.__module__,
6947  __import__(self.__module__).get_module_version())
6948  else:
6949  return IMP.VersionInfo(self.__module__,
6950  __import__(self.__module__).get_module_version())
6951  @staticmethod
6952  def get_from(o):
6953  return _object_cast_to_PairModifier(o)
6954 
6955  __swig_destroy__ = _IMP_kernel.delete_PairModifier
6956  __del__ = lambda self: None
6957  def __disown__(self):
6958  self.this.disown()
6959  _IMP_kernel.disown_PairModifier(self)
6960  return weakref_proxy(self)
6961 
6962  def do_get_inputs(self, m, pis):
6963  """do_get_inputs(PairModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6964  return _IMP_kernel.PairModifier_do_get_inputs(self, m, pis)
6965 
6966 
6967  def do_get_outputs(self, m, pis):
6968  """do_get_outputs(PairModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6969  return _IMP_kernel.PairModifier_do_get_outputs(self, m, pis)
6970 
6971 
6972  def do_destroy(self):
6973  """do_destroy(PairModifier self)"""
6974  return _IMP_kernel.PairModifier_do_destroy(self)
6975 
6976 PairModifier_swigregister = _IMP_kernel.PairModifier_swigregister
6977 PairModifier_swigregister(PairModifier)
6978 
6979 class PairScore(_ParticleInputs, Object):
6980  """Proxy of C++ IMP::PairScore class"""
6981  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
6982 
6983  def __init__(self, *args):
6984  """
6985  __init__(IMP::PairScore self, std::string name) -> PairScore
6986  __init__(IMP::PairScore self) -> PairScore
6987  """
6988  if self.__class__ == PairScore:
6989  _self = None
6990  else:
6991  _self = self
6992  this = _IMP_kernel.new_PairScore(_self, *args)
6993  try:
6994  self.this.append(this)
6995  except:
6996  self.this = this
6997 
6998  if self.__class__ != PairScore:
6999  _director_objects.register(self)
7000 
7001 
7002 
7003 
7004  def evaluate_index(self, m, vt, da):
7005  """evaluate_index(PairScore self, Model m, IMP::ParticleIndexPair const & vt, DerivativeAccumulator da) -> double"""
7006  return _IMP_kernel.PairScore_evaluate_index(self, m, vt, da)
7007 
7008 
7009  def evaluate_indexes(self, m, o, da, lower_bound, upper_bound):
7010  """evaluate_indexes(PairScore self, Model m, IMP::ParticleIndexPairs const & o, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound) -> double"""
7011  return _IMP_kernel.PairScore_evaluate_indexes(self, m, o, da, lower_bound, upper_bound)
7012 
7013 
7014  def evaluate_if_good_index(self, m, vt, da, max):
7015  """evaluate_if_good_index(PairScore self, Model m, IMP::ParticleIndexPair const & vt, DerivativeAccumulator da, double max) -> double"""
7016  return _IMP_kernel.PairScore_evaluate_if_good_index(self, m, vt, da, max)
7017 
7018 
7019  def evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound):
7020  """evaluate_if_good_indexes(PairScore self, Model m, IMP::ParticleIndexPairs const & o, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound) -> double"""
7021  return _IMP_kernel.PairScore_evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound)
7022 
7023 
7024  def create_current_decomposition(self, m, vt):
7025  """create_current_decomposition(PairScore self, Model m, IMP::ParticleIndexPair const & vt) -> IMP::Restraints"""
7026  return _IMP_kernel.PairScore_create_current_decomposition(self, m, vt)
7027 
7028 
7029  def do_create_current_decomposition(self, m, vt):
7030  """do_create_current_decomposition(PairScore self, Model m, IMP::ParticleIndexPair const & vt) -> IMP::Restraints"""
7031  return _IMP_kernel.PairScore_do_create_current_decomposition(self, m, vt)
7032 
7033  __swig_destroy__ = _IMP_kernel.delete_PairScore
7034  __del__ = lambda self: None
7035 
7036  def __str__(self):
7037  """__str__(PairScore self) -> std::string"""
7038  return _IMP_kernel.PairScore___str__(self)
7039 
7040 
7041  def __repr__(self):
7042  """__repr__(PairScore self) -> std::string"""
7043  return _IMP_kernel.PairScore___repr__(self)
7044 
7045 
7046  @staticmethod
7047  def get_from(o):
7048  return _object_cast_to_PairScore(o)
7049 
7050 
7051  def get_type_name(self):
7052  return self.__class__.__name__
7053  def do_show(self, out):
7054  pass
7055  def get_version_info(self):
7056  if"IMP" == "IMP":
7057  return VersionInfo(self.__module__,
7058  __import__(self.__module__).get_module_version())
7059  else:
7060  return IMP.VersionInfo(self.__module__,
7061  __import__(self.__module__).get_module_version())
7062  @staticmethod
7063  def get_from(o):
7064  return _object_cast_to_PairScore(o)
7065 
7066  def __disown__(self):
7067  self.this.disown()
7068  _IMP_kernel.disown_PairScore(self)
7069  return weakref_proxy(self)
7070 
7071  def do_get_inputs(self, m, pis):
7072  """do_get_inputs(PairScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7073  return _IMP_kernel.PairScore_do_get_inputs(self, m, pis)
7074 
7075 
7076  def do_destroy(self):
7077  """do_destroy(PairScore self)"""
7078  return _IMP_kernel.PairScore_do_destroy(self)
7079 
7080 PairScore_swigregister = _IMP_kernel.PairScore_swigregister
7081 PairScore_swigregister(PairScore)
7082 
7083 class PairPredicate(_ParticleInputs, Object):
7084  """Proxy of C++ IMP::PairPredicate class"""
7085  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
7086 
7087  def __init__(self, *args):
7088  """
7089  __init__(IMP::PairPredicate self, std::string name) -> PairPredicate
7090  __init__(IMP::PairPredicate self) -> PairPredicate
7091  """
7092  if self.__class__ == PairPredicate:
7093  _self = None
7094  else:
7095  _self = self
7096  this = _IMP_kernel.new_PairPredicate(_self, *args)
7097  try:
7098  self.this.append(this)
7099  except:
7100  self.this = this
7101 
7102  if self.__class__ != PairPredicate:
7103  _director_objects.register(self)
7104 
7105 
7106 
7107 
7108  def get_value(self, *args):
7109  """
7110  get_value(PairPredicate self, IMP::ParticlePair const & vt) -> int
7111  get_value(PairPredicate self, IMP::ParticlePairsTemp const & o) -> IMP::Ints
7112  """
7113  return _IMP_kernel.PairPredicate_get_value(self, *args)
7114 
7115 
7116  def setup_for_get_value_index_in_batch(self, arg0):
7117  """setup_for_get_value_index_in_batch(PairPredicate self, Model arg0)"""
7118  return _IMP_kernel.PairPredicate_setup_for_get_value_index_in_batch(self, arg0)
7119 
7120 
7121  def get_value_index_in_batch(self, m, vt):
7122  """get_value_index_in_batch(PairPredicate self, Model m, IMP::ParticleIndexPair const & vt) -> int"""
7123  return _IMP_kernel.PairPredicate_get_value_index_in_batch(self, m, vt)
7124 
7125 
7126  def __call__(self, m, vt):
7127  """__call__(PairPredicate self, Model m, IMP::ParticleIndexPair const & vt) -> int"""
7128  return _IMP_kernel.PairPredicate___call__(self, m, vt)
7129 
7130 
7131  def get_value_index(self, *args):
7132  """
7133  get_value_index(PairPredicate self, Model m, IMP::ParticleIndexPair const & vt) -> int
7134  get_value_index(PairPredicate self, Model m, IMP::ParticleIndexPairs const & o) -> IMP::Ints
7135  """
7136  return _IMP_kernel.PairPredicate_get_value_index(self, *args)
7137 
7138  __swig_destroy__ = _IMP_kernel.delete_PairPredicate
7139  __del__ = lambda self: None
7140 
7141  def __str__(self):
7142  """__str__(PairPredicate self) -> std::string"""
7143  return _IMP_kernel.PairPredicate___str__(self)
7144 
7145 
7146  def __repr__(self):
7147  """__repr__(PairPredicate self) -> std::string"""
7148  return _IMP_kernel.PairPredicate___repr__(self)
7149 
7150 
7151  @staticmethod
7152  def get_from(o):
7153  return _object_cast_to_PairPredicate(o)
7154 
7155 
7156  def get_type_name(self):
7157  return self.__class__.__name__
7158  def do_show(self, out):
7159  pass
7160  def get_version_info(self):
7161  if"IMP" == "IMP":
7162  return VersionInfo(self.__module__,
7163  __import__(self.__module__).get_module_version())
7164  else:
7165  return IMP.VersionInfo(self.__module__,
7166  __import__(self.__module__).get_module_version())
7167  @staticmethod
7168  def get_from(o):
7169  return _object_cast_to_PairPredicate(o)
7170 
7171  def __disown__(self):
7172  self.this.disown()
7173  _IMP_kernel.disown_PairPredicate(self)
7174  return weakref_proxy(self)
7175 
7176  def do_get_inputs(self, m, pis):
7177  """do_get_inputs(PairPredicate self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7178  return _IMP_kernel.PairPredicate_do_get_inputs(self, m, pis)
7179 
7180 
7181  def do_destroy(self):
7182  """do_destroy(PairPredicate self)"""
7183  return _IMP_kernel.PairPredicate_do_destroy(self)
7184 
7185 PairPredicate_swigregister = _IMP_kernel.PairPredicate_swigregister
7186 PairPredicate_swigregister(PairPredicate)
7187 
7188 class PairContainer(Container):
7189  """Proxy of C++ IMP::PairContainer class"""
7190  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
7191 
7192  def apply_generic(self, m):
7193  """apply_generic(PairContainer self, PairModifier m)"""
7194  return _IMP_kernel.PairContainer_apply_generic(self, m)
7195 
7196 
7197  def apply(self, sm):
7198  """apply(PairContainer self, PairModifier sm)"""
7199  return _IMP_kernel.PairContainer_apply(self, sm)
7200 
7201 
7202  def get_range_indexes(self):
7203  """get_range_indexes(PairContainer self) -> IMP::ParticleIndexPairs"""
7204  return _IMP_kernel.PairContainer_get_range_indexes(self)