IMP logo
IMP Reference Guide  2.15.0
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)
7205 
7206 
7207  def get_contents(self):
7208  """get_contents(PairContainer self) -> IMP::ParticleIndexPairs const &"""
7209  return _IMP_kernel.PairContainer_get_contents(self)
7210 
7211 
7212  def get_indexes(self):
7213  """get_indexes(PairContainer self) -> IMP::ParticleIndexPairs"""
7214  return _IMP_kernel.PairContainer_get_indexes(self)
7215 
7216 
7217  def get(self, *args):
7218  """
7219  get(PairContainer self) -> IMP::ParticlePairsTemp
7220  get(PairContainer self, unsigned int i) -> IMP::ParticlePair
7221  """
7222  return _IMP_kernel.PairContainer_get(self, *args)
7223 
7224 
7225  def get_number(self):
7226  """get_number(PairContainer self) -> unsigned int"""
7227  return _IMP_kernel.PairContainer_get_number(self)
7228 
7229 
7230  def get_particle_pairs(self):
7231  """get_particle_pairs(PairContainer self) -> IMP::ParticlePairsTemp"""
7232  return _IMP_kernel.PairContainer_get_particle_pairs(self)
7233 
7234 
7235  def __init__(self, *args):
7236  """
7237  __init__(IMP::PairContainer self, Model m, std::string name) -> PairContainer
7238  __init__(IMP::PairContainer self, Model m) -> PairContainer
7239  """
7240  if self.__class__ == PairContainer:
7241  _self = None
7242  else:
7243  _self = self
7244  this = _IMP_kernel.new_PairContainer(_self, *args)
7245  try:
7246  self.this.append(this)
7247  except:
7248  self.this = this
7249 
7250  if self.__class__ != PairContainer:
7251  _director_objects.register(self)
7252 
7253 
7254 
7255 
7256  def do_apply(self, sm):
7257  """do_apply(PairContainer self, PairModifier sm)"""
7258  return _IMP_kernel.PairContainer_do_apply(self, sm)
7259 
7260 
7261  def do_get_provides_access(self):
7262  """do_get_provides_access(PairContainer self) -> bool"""
7263  return _IMP_kernel.PairContainer_do_get_provides_access(self)
7264 
7265  __swig_destroy__ = _IMP_kernel.delete_PairContainer
7266  __del__ = lambda self: None
7267 
7268  def __str__(self):
7269  """__str__(PairContainer self) -> std::string"""
7270  return _IMP_kernel.PairContainer___str__(self)
7271 
7272 
7273  def __repr__(self):
7274  """__repr__(PairContainer self) -> std::string"""
7275  return _IMP_kernel.PairContainer___repr__(self)
7276 
7277 
7278  @staticmethod
7279  def get_from(o):
7280  return _object_cast_to_PairContainer(o)
7281 
7282 
7283  def get_type_name(self):
7284  return self.__class__.__name__
7285  def do_show(self, out):
7286  pass
7287  def get_version_info(self):
7288  if"IMP" == "IMP":
7289  return VersionInfo(self.__module__,
7290  __import__(self.__module__).get_module_version())
7291  else:
7292  return IMP.VersionInfo(self.__module__,
7293  __import__(self.__module__).get_module_version())
7294  @staticmethod
7295  def get_from(o):
7296  return _object_cast_to_PairContainer(o)
7297 
7298  def __disown__(self):
7299  self.this.disown()
7300  _IMP_kernel.disown_PairContainer(self)
7301  return weakref_proxy(self)
7302 
7303  def do_destroy(self):
7304  """do_destroy(PairContainer self)"""
7305  return _IMP_kernel.PairContainer_do_destroy(self)
7306 
7307 
7308  def handle_set_has_required_score_states(self, arg0):
7309  """handle_set_has_required_score_states(PairContainer self, bool arg0)"""
7310  return _IMP_kernel.PairContainer_handle_set_has_required_score_states(self, arg0)
7311 
7312 
7313  def do_get_inputs(self):
7314  """do_get_inputs(PairContainer self) -> IMP::ModelObjectsTemp"""
7315  return _IMP_kernel.PairContainer_do_get_inputs(self)
7316 
7317 
7318  def do_get_interactions(self):
7319  """do_get_interactions(PairContainer self) -> IMP::ModelObjectsTemps"""
7320  return _IMP_kernel.PairContainer_do_get_interactions(self)
7321 
7322 
7323  def do_get_contents_hash(self):
7324  """do_get_contents_hash(PairContainer self) -> std::size_t"""
7325  return _IMP_kernel.PairContainer_do_get_contents_hash(self)
7326 
7327 PairContainer_swigregister = _IMP_kernel.PairContainer_swigregister
7328 PairContainer_swigregister(PairContainer)
7329 
7330 class _PairContainerAdaptor(_InputAdaptor):
7331  """Proxy of C++ IMP::PairContainerAdaptor class"""
7332  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
7333  __repr__ = _swig_repr
7334 
7335  def __init__(self, *args):
7336  """
7337  __init__(IMP::PairContainerAdaptor self) -> _PairContainerAdaptor
7338  __init__(IMP::PairContainerAdaptor self, PairContainer c) -> _PairContainerAdaptor
7339  __init__(IMP::PairContainerAdaptor self, IMP::ParticlePairsTemp const & t) -> _PairContainerAdaptor
7340  """
7341  this = _IMP_kernel.new__PairContainerAdaptor(*args)
7342  try:
7343  self.this.append(this)
7344  except:
7345  self.this = this
7346 
7347  def set_name_if_default(self, name):
7348  """set_name_if_default(_PairContainerAdaptor self, std::string name)"""
7349  return _IMP_kernel._PairContainerAdaptor_set_name_if_default(self, name)
7350 
7351  __swig_destroy__ = _IMP_kernel.delete__PairContainerAdaptor
7352  __del__ = lambda self: None
7353 _PairContainerAdaptor_swigregister = _IMP_kernel._PairContainerAdaptor_swigregister
7354 _PairContainerAdaptor_swigregister(_PairContainerAdaptor)
7355 
7356 class QuadModifier(_ParticleInputs, _ParticleOutputs, Object):
7357  """Proxy of C++ IMP::QuadModifier class"""
7358  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
7359 
7360  def __init__(self, *args):
7361  """
7362  __init__(IMP::QuadModifier self, std::string name) -> QuadModifier
7363  __init__(IMP::QuadModifier self) -> QuadModifier
7364  """
7365  if self.__class__ == QuadModifier:
7366  _self = None
7367  else:
7368  _self = self
7369  this = _IMP_kernel.new_QuadModifier(_self, *args)
7370  try:
7371  self.this.append(this)
7372  except:
7373  self.this = this
7374 
7375  if self.__class__ != QuadModifier:
7376  _director_objects.register(self)
7377 
7378 
7379 
7380 
7381  def apply_index(self, m, v):
7382  """apply_index(QuadModifier self, Model m, IMP::ParticleIndexQuad const & v)"""
7383  return _IMP_kernel.QuadModifier_apply_index(self, m, v)
7384 
7385 
7386  def apply_indexes(self, m, o, lower_bound, upper_bound):
7387  """apply_indexes(QuadModifier self, Model m, IMP::ParticleIndexQuads const & o, unsigned int lower_bound, unsigned int upper_bound)"""
7388  return _IMP_kernel.QuadModifier_apply_indexes(self, m, o, lower_bound, upper_bound)
7389 
7390 
7391  def __str__(self):
7392  """__str__(QuadModifier self) -> std::string"""
7393  return _IMP_kernel.QuadModifier___str__(self)
7394 
7395 
7396  def __repr__(self):
7397  """__repr__(QuadModifier self) -> std::string"""
7398  return _IMP_kernel.QuadModifier___repr__(self)
7399 
7400 
7401  @staticmethod
7402  def get_from(o):
7403  return _object_cast_to_QuadModifier(o)
7404 
7405 
7406  def get_type_name(self):
7407  return self.__class__.__name__
7408  def do_show(self, out):
7409  pass
7410  def get_version_info(self):
7411  if"IMP" == "IMP":
7412  return VersionInfo(self.__module__,
7413  __import__(self.__module__).get_module_version())
7414  else:
7415  return IMP.VersionInfo(self.__module__,
7416  __import__(self.__module__).get_module_version())
7417  @staticmethod
7418  def get_from(o):
7419  return _object_cast_to_QuadModifier(o)
7420 
7421  __swig_destroy__ = _IMP_kernel.delete_QuadModifier
7422  __del__ = lambda self: None
7423  def __disown__(self):
7424  self.this.disown()
7425  _IMP_kernel.disown_QuadModifier(self)
7426  return weakref_proxy(self)
7427 
7428  def do_get_inputs(self, m, pis):
7429  """do_get_inputs(QuadModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7430  return _IMP_kernel.QuadModifier_do_get_inputs(self, m, pis)
7431 
7432 
7433  def do_get_outputs(self, m, pis):
7434  """do_get_outputs(QuadModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7435  return _IMP_kernel.QuadModifier_do_get_outputs(self, m, pis)
7436 
7437 
7438  def do_destroy(self):
7439  """do_destroy(QuadModifier self)"""
7440  return _IMP_kernel.QuadModifier_do_destroy(self)
7441 
7442 QuadModifier_swigregister = _IMP_kernel.QuadModifier_swigregister
7443 QuadModifier_swigregister(QuadModifier)
7444 
7445 class QuadScore(_ParticleInputs, Object):
7446  """Proxy of C++ IMP::QuadScore class"""
7447  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
7448 
7449  def __init__(self, *args):
7450  """
7451  __init__(IMP::QuadScore self, std::string name) -> QuadScore
7452  __init__(IMP::QuadScore self) -> QuadScore
7453  """
7454  if self.__class__ == QuadScore:
7455  _self = None
7456  else:
7457  _self = self
7458  this = _IMP_kernel.new_QuadScore(_self, *args)
7459  try:
7460  self.this.append(this)
7461  except:
7462  self.this = this
7463 
7464  if self.__class__ != QuadScore:
7465  _director_objects.register(self)
7466 
7467 
7468 
7469 
7470  def evaluate_index(self, m, vt, da):
7471  """evaluate_index(QuadScore self, Model m, IMP::ParticleIndexQuad const & vt, DerivativeAccumulator da) -> double"""
7472  return _IMP_kernel.QuadScore_evaluate_index(self, m, vt, da)
7473 
7474 
7475  def evaluate_indexes(self, m, o, da, lower_bound, upper_bound):
7476  """evaluate_indexes(QuadScore self, Model m, IMP::ParticleIndexQuads const & o, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound) -> double"""
7477  return _IMP_kernel.QuadScore_evaluate_indexes(self, m, o, da, lower_bound, upper_bound)
7478 
7479 
7480  def evaluate_if_good_index(self, m, vt, da, max):
7481  """evaluate_if_good_index(QuadScore self, Model m, IMP::ParticleIndexQuad const & vt, DerivativeAccumulator da, double max) -> double"""
7482  return _IMP_kernel.QuadScore_evaluate_if_good_index(self, m, vt, da, max)
7483 
7484 
7485  def evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound):
7486  """evaluate_if_good_indexes(QuadScore self, Model m, IMP::ParticleIndexQuads const & o, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound) -> double"""
7487  return _IMP_kernel.QuadScore_evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound)
7488 
7489 
7490  def create_current_decomposition(self, m, vt):
7491  """create_current_decomposition(QuadScore self, Model m, IMP::ParticleIndexQuad const & vt) -> IMP::Restraints"""
7492  return _IMP_kernel.QuadScore_create_current_decomposition(self, m, vt)
7493 
7494 
7495  def do_create_current_decomposition(self, m, vt):
7496  """do_create_current_decomposition(QuadScore self, Model m, IMP::ParticleIndexQuad const & vt) -> IMP::Restraints"""
7497  return _IMP_kernel.QuadScore_do_create_current_decomposition(self, m, vt)
7498 
7499  __swig_destroy__ = _IMP_kernel.delete_QuadScore
7500  __del__ = lambda self: None
7501 
7502  def __str__(self):
7503  """__str__(QuadScore self) -> std::string"""
7504  return _IMP_kernel.QuadScore___str__(self)
7505 
7506 
7507  def __repr__(self):
7508  """__repr__(QuadScore self) -> std::string"""
7509  return _IMP_kernel.QuadScore___repr__(self)
7510 
7511 
7512  @staticmethod
7513  def get_from(o):
7514  return _object_cast_to_QuadScore(o)
7515 
7516 
7517  def get_type_name(self):
7518  return self.__class__.__name__
7519  def do_show(self, out):
7520  pass
7521  def get_version_info(self):
7522  if"IMP" == "IMP":
7523  return VersionInfo(self.__module__,
7524  __import__(self.__module__).get_module_version())
7525  else:
7526  return IMP.VersionInfo(self.__module__,
7527  __import__(self.__module__).get_module_version())
7528  @staticmethod
7529  def get_from(o):
7530  return _object_cast_to_QuadScore(o)
7531 
7532  def __disown__(self):
7533  self.this.disown()
7534  _IMP_kernel.disown_QuadScore(self)
7535  return weakref_proxy(self)
7536 
7537  def do_get_inputs(self, m, pis):
7538  """do_get_inputs(QuadScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7539  return _IMP_kernel.QuadScore_do_get_inputs(self, m, pis)
7540 
7541 
7542  def do_destroy(self):
7543  """do_destroy(QuadScore self)"""
7544  return _IMP_kernel.QuadScore_do_destroy(self)
7545 
7546 QuadScore_swigregister = _IMP_kernel.QuadScore_swigregister
7547 QuadScore_swigregister(QuadScore)
7548 
7549 class QuadPredicate(_ParticleInputs, Object):
7550  """Proxy of C++ IMP::QuadPredicate class"""
7551  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
7552 
7553  def __init__(self, *args):
7554  """
7555  __init__(IMP::QuadPredicate self, std::string name) -> QuadPredicate
7556  __init__(IMP::QuadPredicate self) -> QuadPredicate
7557  """
7558  if self.__class__ == QuadPredicate:
7559  _self = None
7560  else:
7561  _self = self
7562  this = _IMP_kernel.new_QuadPredicate(_self, *args)
7563  try:
7564  self.this.append(this)
7565  except:
7566  self.this = this
7567 
7568  if self.__class__ != QuadPredicate:
7569  _director_objects.register(self)
7570 
7571 
7572 
7573 
7574  def get_value(self, *args):
7575  """
7576  get_value(QuadPredicate self, IMP::ParticleQuad const & vt) -> int
7577  get_value(QuadPredicate self, IMP::ParticleQuadsTemp const & o) -> IMP::Ints
7578  """
7579  return _IMP_kernel.QuadPredicate_get_value(self, *args)
7580 
7581 
7582  def setup_for_get_value_index_in_batch(self, arg0):
7583  """setup_for_get_value_index_in_batch(QuadPredicate self, Model arg0)"""
7584  return _IMP_kernel.QuadPredicate_setup_for_get_value_index_in_batch(self, arg0)
7585 
7586 
7587  def get_value_index_in_batch(self, m, vt):
7588  """get_value_index_in_batch(QuadPredicate self, Model m, IMP::ParticleIndexQuad const & vt) -> int"""
7589  return _IMP_kernel.QuadPredicate_get_value_index_in_batch(self, m, vt)
7590 
7591 
7592  def __call__(self, m, vt):
7593  """__call__(QuadPredicate self, Model m, IMP::ParticleIndexQuad const & vt) -> int"""
7594  return _IMP_kernel.QuadPredicate___call__(self, m, vt)
7595 
7596 
7597  def get_value_index(self, *args):
7598  """
7599  get_value_index(QuadPredicate self, Model m, IMP::ParticleIndexQuad const & vt) -> int
7600  get_value_index(QuadPredicate self, Model m, IMP::ParticleIndexQuads const & o) -> IMP::Ints
7601  """
7602  return _IMP_kernel.QuadPredicate_get_value_index(self, *args)
7603 
7604  __swig_destroy__ = _IMP_kernel.delete_QuadPredicate
7605  __del__ = lambda self: None
7606 
7607  def __str__(self):
7608  """__str__(QuadPredicate self) -> std::string"""
7609  return _IMP_kernel.QuadPredicate___str__(self)
7610 
7611 
7612  def __repr__(self):
7613  """__repr__(QuadPredicate self) -> std::string"""
7614  return _IMP_kernel.QuadPredicate___repr__(self)
7615 
7616 
7617  @staticmethod
7618  def get_from(o):
7619  return _object_cast_to_QuadPredicate(o)
7620 
7621 
7622  def get_type_name(self):
7623  return self.__class__.__name__
7624  def do_show(self, out):
7625  pass
7626  def get_version_info(self):
7627  if"IMP" == "IMP":
7628  return VersionInfo(self.__module__,
7629  __import__(self.__module__).get_module_version())
7630  else:
7631  return IMP.VersionInfo(self.__module__,
7632  __import__(self.__module__).get_module_version())
7633  @staticmethod
7634  def get_from(o):
7635  return _object_cast_to_QuadPredicate(o)
7636 
7637  def __disown__(self):
7638  self.this.disown()
7639  _IMP_kernel.disown_QuadPredicate(self)
7640  return weakref_proxy(self)
7641 
7642  def do_get_inputs(self, m, pis):
7643  """do_get_inputs(QuadPredicate self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7644  return _IMP_kernel.QuadPredicate_do_get_inputs(self, m, pis)
7645 
7646 
7647  def do_destroy(self):
7648  """do_destroy(QuadPredicate self)"""
7649  return _IMP_kernel.QuadPredicate_do_destroy(self)
7650 
7651 QuadPredicate_swigregister = _IMP_kernel.QuadPredicate_swigregister
7652 QuadPredicate_swigregister(QuadPredicate)
7653 
7654 class QuadContainer(Container):
7655  """Proxy of C++ IMP::QuadContainer class"""
7656  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
7657 
7658  def apply_generic(self, m):
7659  """apply_generic(QuadContainer self, QuadModifier m)"""
7660  return _IMP_kernel.QuadContainer_apply_generic(self, m)
7661 
7662 
7663  def apply(self, sm):
7664  """apply(QuadContainer self, QuadModifier sm)"""
7665  return _IMP_kernel.QuadContainer_apply(self, sm)
7666 
7667 
7668  def get_range_indexes(self):
7669  """get_range_indexes(QuadContainer self) -> IMP::ParticleIndexQuads"""
7670  return _IMP_kernel.QuadContainer_get_range_indexes(self)
7671 
7672 
7673  def get_contents(self):
7674  """get_contents(QuadContainer self) -> IMP::ParticleIndexQuads const &"""
7675  return _IMP_kernel.QuadContainer_get_contents(self)
7676 
7677 
7678  def get_indexes(self):
7679  """get_indexes(QuadContainer self) -> IMP::ParticleIndexQuads"""
7680  return _IMP_kernel.QuadContainer_get_indexes(self)
7681 
7682 
7683  def get(self, *args):
7684  """
7685  get(QuadContainer self) -> IMP::ParticleQuadsTemp
7686  get(QuadContainer self, unsigned int i) -> IMP::ParticleQuad
7687  """
7688  return _IMP_kernel.QuadContainer_get(self, *args)
7689 
7690 
7691  def get_number(self):
7692  """get_number(QuadContainer self) -> unsigned int"""
7693  return _IMP_kernel.QuadContainer_get_number(self)
7694 
7695 
7696  def get_particle_quads(self):
7697  """get_particle_quads(QuadContainer self) -> IMP::ParticleQuadsTemp"""
7698  return _IMP_kernel.QuadContainer_get_particle_quads(self)
7699 
7700 
7701  def __init__(self, *args):
7702  """
7703  __init__(IMP::QuadContainer self, Model m, std::string name) -> QuadContainer
7704  __init__(IMP::QuadContainer self, Model m) -> QuadContainer
7705  """
7706  if self.__class__ == QuadContainer:
7707  _self = None
7708  else:
7709  _self = self
7710  this = _IMP_kernel.new_QuadContainer(_self, *args)
7711  try:
7712  self.this.append(this)
7713  except:
7714  self.this = this
7715 
7716  if self.__class__ != QuadContainer:
7717  _director_objects.register(self)
7718 
7719 
7720 
7721 
7722  def do_apply(self, sm):
7723  """do_apply(QuadContainer self, QuadModifier sm)"""
7724  return _IMP_kernel.QuadContainer_do_apply(self, sm)
7725 
7726 
7727  def do_get_provides_access(self):
7728  """do_get_provides_access(QuadContainer self) -> bool"""
7729  return _IMP_kernel.QuadContainer_do_get_provides_access(self)
7730 
7731  __swig_destroy__ = _IMP_kernel.delete_QuadContainer
7732  __del__ = lambda self: None
7733 
7734  def __str__(self):
7735  """__str__(QuadContainer self) -> std::string"""
7736  return _IMP_kernel.QuadContainer___str__(self)
7737 
7738 
7739  def __repr__(self):
7740  """__repr__(QuadContainer self) -> std::string"""
7741  return _IMP_kernel.QuadContainer___repr__(self)
7742 
7743 
7744  @staticmethod
7745  def get_from(o):
7746  return _object_cast_to_QuadContainer(o)
7747 
7748 
7749  def get_type_name(self):
7750  return self.__class__.__name__
7751  def do_show(self, out):
7752  pass
7753  def get_version_info(self):
7754  if"IMP" == "IMP":
7755  return VersionInfo(self.__module__,
7756  __import__(self.__module__).get_module_version())
7757  else:
7758  return IMP.VersionInfo(self.__module__,
7759  __import__(self.__module__).get_module_version())
7760  @staticmethod
7761  def get_from(o):
7762  return _object_cast_to_QuadContainer(o)
7763 
7764  def __disown__(self):
7765  self.this.disown()
7766  _IMP_kernel.disown_QuadContainer(self)
7767  return weakref_proxy(self)
7768 
7769  def do_destroy(self):
7770  """do_destroy(QuadContainer self)"""
7771  return _IMP_kernel.QuadContainer_do_destroy(self)
7772 
7773 
7774  def handle_set_has_required_score_states(self, arg0):
7775  """handle_set_has_required_score_states(QuadContainer self, bool arg0)"""
7776  return _IMP_kernel.QuadContainer_handle_set_has_required_score_states(self, arg0)
7777 
7778 
7779  def do_get_inputs(self):
7780  """do_get_inputs(QuadContainer self) -> IMP::ModelObjectsTemp"""
7781  return _IMP_kernel.QuadContainer_do_get_inputs(self)
7782 
7783 
7784  def do_get_interactions(self):
7785  """do_get_interactions(QuadContainer self) -> IMP::ModelObjectsTemps"""
7786  return _IMP_kernel.QuadContainer_do_get_interactions(self)
7787 
7788 
7789  def do_get_contents_hash(self):
7790  """do_get_contents_hash(QuadContainer self) -> std::size_t"""
7791  return _IMP_kernel.QuadContainer_do_get_contents_hash(self)
7792 
7793 QuadContainer_swigregister = _IMP_kernel.QuadContainer_swigregister
7794 QuadContainer_swigregister(QuadContainer)
7795 
7796 class _QuadContainerAdaptor(_InputAdaptor):
7797  """Proxy of C++ IMP::QuadContainerAdaptor class"""
7798  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
7799  __repr__ = _swig_repr
7800 
7801  def __init__(self, *args):
7802  """
7803  __init__(IMP::QuadContainerAdaptor self) -> _QuadContainerAdaptor
7804  __init__(IMP::QuadContainerAdaptor self, QuadContainer c) -> _QuadContainerAdaptor
7805  __init__(IMP::QuadContainerAdaptor self, IMP::ParticleQuadsTemp const & t) -> _QuadContainerAdaptor
7806  """
7807  this = _IMP_kernel.new__QuadContainerAdaptor(*args)
7808  try:
7809  self.this.append(this)
7810  except:
7811  self.this = this
7812 
7813  def set_name_if_default(self, name):
7814  """set_name_if_default(_QuadContainerAdaptor self, std::string name)"""
7815  return _IMP_kernel._QuadContainerAdaptor_set_name_if_default(self, name)
7816 
7817  __swig_destroy__ = _IMP_kernel.delete__QuadContainerAdaptor
7818  __del__ = lambda self: None
7819 _QuadContainerAdaptor_swigregister = _IMP_kernel._QuadContainerAdaptor_swigregister
7820 _QuadContainerAdaptor_swigregister(_QuadContainerAdaptor)
7821 
7822 class SingletonModifier(_ParticleInputs, _ParticleOutputs, Object):
7823  """Proxy of C++ IMP::SingletonModifier class"""
7824  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
7825 
7826  def __init__(self, *args):
7827  """
7828  __init__(IMP::SingletonModifier self, std::string name) -> SingletonModifier
7829  __init__(IMP::SingletonModifier self) -> SingletonModifier
7830  """
7831  if self.__class__ == SingletonModifier:
7832  _self = None
7833  else:
7834  _self = self
7835  this = _IMP_kernel.new_SingletonModifier(_self, *args)
7836  try:
7837  self.this.append(this)
7838  except:
7839  self.this = this
7840 
7841  if self.__class__ != SingletonModifier:
7842  _director_objects.register(self)
7843 
7844 
7845 
7846 
7847  def apply_index(self, m, v):
7848  """apply_index(SingletonModifier self, Model m, ParticleIndex v)"""
7849  return _IMP_kernel.SingletonModifier_apply_index(self, m, v)
7850 
7851 
7852  def apply_indexes(self, m, o, lower_bound, upper_bound):
7853  """apply_indexes(SingletonModifier self, Model m, IMP::ParticleIndexes const & o, unsigned int lower_bound, unsigned int upper_bound)"""
7854  return _IMP_kernel.SingletonModifier_apply_indexes(self, m, o, lower_bound, upper_bound)
7855 
7856 
7857  def __str__(self):
7858  """__str__(SingletonModifier self) -> std::string"""
7859  return _IMP_kernel.SingletonModifier___str__(self)
7860 
7861 
7862  def __repr__(self):
7863  """__repr__(SingletonModifier self) -> std::string"""
7864  return _IMP_kernel.SingletonModifier___repr__(self)
7865 
7866 
7867  @staticmethod
7868  def get_from(o):
7869  return _object_cast_to_SingletonModifier(o)
7870 
7871 
7872  def get_type_name(self):
7873  return self.__class__.__name__
7874  def do_show(self, out):
7875  pass
7876  def get_version_info(self):
7877  if"IMP" == "IMP":
7878  return VersionInfo(self.__module__,
7879  __import__(self.__module__).get_module_version())
7880  else:
7881  return IMP.VersionInfo(self.__module__,
7882  __import__(self.__module__).get_module_version())
7883  @staticmethod
7884  def get_from(o):
7885  return _object_cast_to_SingletonModifier(o)
7886 
7887  __swig_destroy__ = _IMP_kernel.delete_SingletonModifier
7888  __del__ = lambda self: None
7889  def __disown__(self):
7890  self.this.disown()
7891  _IMP_kernel.disown_SingletonModifier(self)
7892  return weakref_proxy(self)
7893 
7894  def do_get_inputs(self, m, pis):
7895  """do_get_inputs(SingletonModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7896  return _IMP_kernel.SingletonModifier_do_get_inputs(self, m, pis)
7897 
7898 
7899  def do_get_outputs(self, m, pis):
7900  """do_get_outputs(SingletonModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7901  return _IMP_kernel.SingletonModifier_do_get_outputs(self, m, pis)
7902 
7903 
7904  def do_destroy(self):
7905  """do_destroy(SingletonModifier self)"""
7906  return _IMP_kernel.SingletonModifier_do_destroy(self)
7907 
7908 SingletonModifier_swigregister = _IMP_kernel.SingletonModifier_swigregister
7909 SingletonModifier_swigregister(SingletonModifier)
7910 
7911 class SingletonScore(_ParticleInputs, Object):
7912  """Proxy of C++ IMP::SingletonScore class"""
7913  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
7914 
7915  def __init__(self, *args):
7916  """
7917  __init__(IMP::SingletonScore self, std::string name) -> SingletonScore
7918  __init__(IMP::SingletonScore self) -> SingletonScore
7919  """
7920  if self.__class__ == SingletonScore:
7921  _self = None
7922  else:
7923  _self = self
7924  this = _IMP_kernel.new_SingletonScore(_self, *args)
7925  try:
7926  self.this.append(this)
7927  except:
7928  self.this = this
7929 
7930  if self.__class__ != SingletonScore:
7931  _director_objects.register(self)
7932 
7933 
7934 
7935 
7936  def evaluate_index(self, m, vt, da):
7937  """evaluate_index(SingletonScore self, Model m, ParticleIndex vt, DerivativeAccumulator da) -> double"""
7938  return _IMP_kernel.SingletonScore_evaluate_index(self, m, vt, da)
7939 
7940 
7941  def evaluate_indexes(self, m, o, da, lower_bound, upper_bound):
7942  """evaluate_indexes(SingletonScore self, Model m, IMP::ParticleIndexes const & o, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound) -> double"""
7943  return _IMP_kernel.SingletonScore_evaluate_indexes(self, m, o, da, lower_bound, upper_bound)
7944 
7945 
7946  def evaluate_if_good_index(self, m, vt, da, max):
7947  """evaluate_if_good_index(SingletonScore self, Model m, ParticleIndex vt, DerivativeAccumulator da, double max) -> double"""
7948  return _IMP_kernel.SingletonScore_evaluate_if_good_index(self, m, vt, da, max)
7949 
7950 
7951  def evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound):
7952  """evaluate_if_good_indexes(SingletonScore self, Model m, IMP::ParticleIndexes const & o, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound) -> double"""
7953  return _IMP_kernel.SingletonScore_evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound)
7954 
7955 
7956  def create_current_decomposition(self, m, vt):
7957  """create_current_decomposition(SingletonScore self, Model m, ParticleIndex vt) -> IMP::Restraints"""
7958  return _IMP_kernel.SingletonScore_create_current_decomposition(self, m, vt)
7959 
7960 
7961  def do_create_current_decomposition(self, m, vt):
7962  """do_create_current_decomposition(SingletonScore self, Model m, ParticleIndex vt) -> IMP::Restraints"""
7963  return _IMP_kernel.SingletonScore_do_create_current_decomposition(self, m, vt)
7964 
7965  __swig_destroy__ = _IMP_kernel.delete_SingletonScore
7966  __del__ = lambda self: None
7967 
7968  def __str__(self):
7969  """__str__(SingletonScore self) -> std::string"""
7970  return _IMP_kernel.SingletonScore___str__(self)
7971 
7972 
7973  def __repr__(self):
7974  """__repr__(SingletonScore self) -> std::string"""
7975  return _IMP_kernel.SingletonScore___repr__(self)
7976 
7977 
7978  @staticmethod
7979  def get_from(o):
7980  return _object_cast_to_SingletonScore(o)
7981 
7982 
7983  def get_type_name(self):
7984  return self.__class__.__name__
7985  def do_show(self, out):
7986  pass
7987  def get_version_info(self):
7988  if"IMP" == "IMP":
7989  return VersionInfo(self.__module__,
7990  __import__(self.__module__).get_module_version())
7991  else:
7992  return IMP.VersionInfo(self.__module__,
7993  __import__(self.__module__).get_module_version())
7994  @staticmethod
7995  def get_from(o):
7996  return _object_cast_to_SingletonScore(o)
7997 
7998  def __disown__(self):
7999  self.this.disown()
8000  _IMP_kernel.disown_SingletonScore(self)
8001  return weakref_proxy(self)
8002 
8003  def do_get_inputs(self, m, pis):
8004  """do_get_inputs(SingletonScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
8005  return _IMP_kernel.SingletonScore_do_get_inputs(self, m, pis)
8006 
8007 
8008  def do_destroy(self):
8009  """do_destroy(SingletonScore self)"""
8010  return _IMP_kernel.SingletonScore_do_destroy(self)
8011 
8012 SingletonScore_swigregister = _IMP_kernel.SingletonScore_swigregister
8013 SingletonScore_swigregister(SingletonScore)
8014 
8015 class SingletonPredicate(_ParticleInputs, Object):
8016  """Proxy of C++ IMP::SingletonPredicate class"""
8017  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
8018 
8019  def __init__(self, *args):
8020  """
8021  __init__(IMP::SingletonPredicate self, std::string name) -> SingletonPredicate
8022  __init__(IMP::SingletonPredicate self) -> SingletonPredicate
8023  """
8024  if self.__class__ == SingletonPredicate:
8025  _self = None
8026  else:
8027  _self = self
8028  this = _IMP_kernel.new_SingletonPredicate(_self, *args)
8029  try:
8030  self.this.append(this)
8031  except:
8032  self.this = this
8033 
8034  if self.__class__ != SingletonPredicate:
8035  _director_objects.register(self)
8036 
8037 
8038 
8039 
8040  def get_value(self, *args):
8041  """
8042  get_value(SingletonPredicate self, Particle vt) -> int
8043  get_value(SingletonPredicate self, IMP::ParticlesTemp const & o) -> IMP::Ints
8044  """
8045  return _IMP_kernel.SingletonPredicate_get_value(self, *args)
8046 
8047 
8048  def setup_for_get_value_index_in_batch(self, arg0):
8049  """setup_for_get_value_index_in_batch(SingletonPredicate self, Model arg0)"""
8050  return _IMP_kernel.SingletonPredicate_setup_for_get_value_index_in_batch(self, arg0)
8051 
8052 
8053  def get_value_index_in_batch(self, m, vt):
8054  """get_value_index_in_batch(SingletonPredicate self, Model m, ParticleIndex vt) -> int"""
8055  return _IMP_kernel.SingletonPredicate_get_value_index_in_batch(self, m, vt)
8056 
8057 
8058  def __call__(self, m, vt):
8059  """__call__(SingletonPredicate self, Model m, ParticleIndex vt) -> int"""
8060  return _IMP_kernel.SingletonPredicate___call__(self, m, vt)
8061 
8062 
8063  def get_value_index(self, *args):
8064  """
8065  get_value_index(SingletonPredicate self, Model m, ParticleIndex vt) -> int
8066  get_value_index(SingletonPredicate self, Model m, IMP::ParticleIndexes const & o) -> IMP::Ints
8067  """
8068  return _IMP_kernel.SingletonPredicate_get_value_index(self, *args)
8069 
8070  __swig_destroy__ = _IMP_kernel.delete_SingletonPredicate
8071  __del__ = lambda self: None
8072 
8073  def __str__(self):
8074  """__str__(SingletonPredicate self) -> std::string"""
8075  return _IMP_kernel.SingletonPredicate___str__(self)
8076 
8077 
8078  def __repr__(self):
8079  """__repr__(SingletonPredicate self) -> std::string"""
8080  return _IMP_kernel.SingletonPredicate___repr__(self)
8081 
8082 
8083  @staticmethod
8084  def get_from(o):
8085  return _object_cast_to_SingletonPredicate(o)
8086 
8087 
8088  def get_type_name(self):
8089  return self.__class__.__name__
8090  def do_show(self, out):
8091  pass
8092  def get_version_info(self):
8093  if"IMP" == "IMP":
8094  return VersionInfo(self.__module__,
8095  __import__(self.__module__).get_module_version())
8096  else:
8097  return IMP.VersionInfo(self.__module__,
8098  __import__(self.__module__).get_module_version())
8099  @staticmethod
8100  def get_from(o):
8101  return _object_cast_to_SingletonPredicate(o)
8102 
8103  def __disown__(self):
8104  self.this.disown()
8105  _IMP_kernel.disown_SingletonPredicate(self)
8106  return weakref_proxy(self)
8107 
8108  def do_get_inputs(self, m, pis):
8109  """do_get_inputs(SingletonPredicate self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
8110  return _IMP_kernel.SingletonPredicate_do_get_inputs(self, m, pis)
8111 
8112 
8113  def do_destroy(self):
8114  """do_destroy(SingletonPredicate self)"""
8115  return _IMP_kernel.SingletonPredicate_do_destroy(self)
8116 
8117 SingletonPredicate_swigregister = _IMP_kernel.SingletonPredicate_swigregister
8118 SingletonPredicate_swigregister(SingletonPredicate)
8119 
8120 class SingletonContainer(Container):
8121  """Proxy of C++ IMP::SingletonContainer class"""
8122  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
8123 
8124  def apply_generic(self, m):
8125  """apply_generic(SingletonContainer self, SingletonModifier m)"""
8126  return _IMP_kernel.SingletonContainer_apply_generic(self, m)
8127 
8128 
8129  def apply(self, sm):
8130  """apply(SingletonContainer self, SingletonModifier sm)"""
8131  return _IMP_kernel.SingletonContainer_apply(self, sm)
8132 
8133 
8134  def get_range_indexes(self):
8135  """get_range_indexes(SingletonContainer self) -> IMP::ParticleIndexes"""
8136  return _IMP_kernel.SingletonContainer_get_range_indexes(self)
8137 
8138 
8139  def get_contents(self):
8140  """get_contents(SingletonContainer self) -> IMP::ParticleIndexes const &"""
8141  return _IMP_kernel.SingletonContainer_get_contents(self)
8142 
8143 
8144  def get_indexes(self):
8145  """get_indexes(SingletonContainer self) -> IMP::ParticleIndexes"""
8146  return _IMP_kernel.SingletonContainer_get_indexes(self)
8147 
8148 
8149  def get(self, *args):
8150  """
8151  get(SingletonContainer self) -> IMP::ParticlesTemp
8152  get(SingletonContainer self, unsigned int i) -> Particle
8153  """
8154  return _IMP_kernel.SingletonContainer_get(self, *args)
8155 
8156 
8157  def get_number(self):
8158  """get_number(SingletonContainer self) -> unsigned int"""
8159  return _IMP_kernel.SingletonContainer_get_number(self)
8160 
8161 
8162  def get_particles(self):
8163  """get_particles(SingletonContainer self) -> IMP::ParticlesTemp"""
8164  return _IMP_kernel.SingletonContainer_get_particles(self)
8165 
8166 
8167  def __init__(self, *args):
8168  """
8169  __init__(IMP::SingletonContainer self, Model m, std::string name) -> SingletonContainer
8170  __init__(IMP::SingletonContainer self, Model m) -> SingletonContainer
8171  """
8172  if self.__class__ == SingletonContainer:
8173  _self = None
8174  else:
8175  _self = self
8176  this = _IMP_kernel.new_SingletonContainer(_self, *args)
8177  try:
8178  self.this.append(this)
8179  except:
8180  self.this = this
8181 
8182  if self.__class__ != SingletonContainer:
8183  _director_objects.register(self)
8184 
8185 
8186 
8187 
8188  def do_apply(self, sm):
8189  """do_apply(SingletonContainer self, SingletonModifier sm)"""
8190  return _IMP_kernel.SingletonContainer_do_apply(self, sm)
8191 
8192 
8193  def do_get_provides_access(self):
8194  """do_get_provides_access(SingletonContainer self) -> bool"""
8195  return _IMP_kernel.SingletonContainer_do_get_provides_access(self)
8196 
8197  __swig_destroy__ = _IMP_kernel.delete_SingletonContainer
8198  __del__ = lambda self: None
8199 
8200  def __str__(self):
8201  """__str__(SingletonContainer self) -> std::string"""
8202  return _IMP_kernel.SingletonContainer___str__(self)
8203 
8204 
8205  def __repr__(self):
8206  """__repr__(SingletonContainer self) -> std::string"""
8207  return _IMP_kernel.SingletonContainer___repr__(self)
8208 
8209 
8210  @staticmethod
8211  def get_from(o):
8212  return _object_cast_to_SingletonContainer(o)
8213 
8214 
8215  def get_type_name(self):
8216  return self.__class__.__name__
8217  def do_show(self, out):
8218  pass
8219  def get_version_info(self):
8220  if"IMP" == "IMP":
8221  return VersionInfo(self.__module__,
8222  __import__(self.__module__).get_module_version())
8223  else:
8224  return IMP.VersionInfo(self.__module__,
8225  __import__(self.__module__).get_module_version())
8226  @staticmethod
8227  def get_from(o):
8228  return _object_cast_to_SingletonContainer(o)
8229 
8230  def __disown__(self):
8231  self.this.disown()
8232  _IMP_kernel.disown_SingletonContainer(self)
8233  return weakref_proxy(self)
8234 
8235  def do_destroy(self):
8236  """do_destroy(SingletonContainer self)"""
8237  return _IMP_kernel.SingletonContainer_do_destroy(self)
8238 
8239 
8240  def handle_set_has_required_score_states(self, arg0):
8241  """handle_set_has_required_score_states(SingletonContainer self, bool arg0)"""
8242  return _IMP_kernel.SingletonContainer_handle_set_has_required_score_states(self, arg0)
8243 
8244 
8245  def do_get_inputs(self):
8246  """do_get_inputs(SingletonContainer self) -> IMP::ModelObjectsTemp"""
8247  return _IMP_kernel.SingletonContainer_do_get_inputs(self)
8248 
8249 
8250  def do_get_interactions(self):
8251  """do_get_interactions(SingletonContainer self) -> IMP::ModelObjectsTemps"""
8252  return _IMP_kernel.SingletonContainer_do_get_interactions(self)
8253 
8254 
8255  def do_get_contents_hash(self):
8256  """do_get_contents_hash(SingletonContainer self) -> std::size_t"""
8257  return _IMP_kernel.SingletonContainer_do_get_contents_hash(self)
8258 
8259 SingletonContainer_swigregister = _IMP_kernel.SingletonContainer_swigregister
8260 SingletonContainer_swigregister(SingletonContainer)
8261 
8262 class _SingletonContainerAdaptor(_InputAdaptor):
8263  """Proxy of C++ IMP::SingletonContainerAdaptor class"""
8264  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
8265  __repr__ = _swig_repr
8266 
8267  def __init__(self, *args):
8268  """
8269  __init__(IMP::SingletonContainerAdaptor self) -> _SingletonContainerAdaptor
8270  __init__(IMP::SingletonContainerAdaptor self, SingletonContainer c) -> _SingletonContainerAdaptor
8271  __init__(IMP::SingletonContainerAdaptor self, IMP::ParticlesTemp const & t) -> _SingletonContainerAdaptor
8272  """
8273  this = _IMP_kernel.new__SingletonContainerAdaptor(*args)
8274  try:
8275  self.this.append(this)
8276  except:
8277  self.this = this
8278 
8279  def set_name_if_default(self, name):
8280  """set_name_if_default(_SingletonContainerAdaptor self, std::string name)"""
8281  return _IMP_kernel._SingletonContainerAdaptor_set_name_if_default(self, name)
8282 
8283  __swig_destroy__ = _IMP_kernel.delete__SingletonContainerAdaptor
8284  __del__ = lambda self: None
8285 _SingletonContainerAdaptor_swigregister = _IMP_kernel._SingletonContainerAdaptor_swigregister
8286 _SingletonContainerAdaptor_swigregister(_SingletonContainerAdaptor)
8287 
8288 class TripletModifier(_ParticleInputs, _ParticleOutputs, Object):
8289  """Proxy of C++ IMP::TripletModifier class"""
8290  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
8291 
8292  def __init__(self, *args):
8293  """
8294  __init__(IMP::TripletModifier self, std::string name) -> TripletModifier
8295  __init__(IMP::TripletModifier self) -> TripletModifier
8296  """
8297  if self.__class__ == TripletModifier:
8298  _self = None
8299  else:
8300  _self = self
8301  this = _IMP_kernel.new_TripletModifier(_self, *args)
8302  try:
8303  self.this.append(this)
8304  except:
8305  self.this = this
8306 
8307  if self.__class__ != TripletModifier:
8308  _director_objects.register(self)
8309 
8310 
8311 
8312 
8313  def apply_index(self, m, v):
8314  """apply_index(TripletModifier self, Model m, IMP::ParticleIndexTriplet const & v)"""
8315  return _IMP_kernel.TripletModifier_apply_index(self, m, v)
8316 
8317 
8318  def apply_indexes(self, m, o, lower_bound, upper_bound):
8319  """apply_indexes(TripletModifier self, Model m, IMP::ParticleIndexTriplets const & o, unsigned int lower_bound, unsigned int upper_bound)"""
8320  return _IMP_kernel.TripletModifier_apply_indexes(self, m, o, lower_bound, upper_bound)
8321 
8322 
8323  def __str__(self):
8324  """__str__(TripletModifier self) -> std::string"""
8325  return _IMP_kernel.TripletModifier___str__(self)
8326 
8327 
8328  def __repr__(self):
8329  """__repr__(TripletModifier self) -> std::string"""
8330  return _IMP_kernel.TripletModifier___repr__(self)
8331 
8332 
8333  @staticmethod
8334  def get_from(o):
8335  return _object_cast_to_TripletModifier(o)
8336 
8337 
8338  def get_type_name(self):
8339  return self.__class__.__name__
8340  def do_show(self, out):
8341  pass
8342  def get_version_info(self):
8343  if"IMP" == "IMP":
8344  return VersionInfo(self.__module__,
8345  __import__(self.__module__).get_module_version())
8346  else:
8347  return IMP.VersionInfo(self.__module__,
8348  __import__(self.__module__).get_module_version())
8349  @staticmethod
8350  def get_from(o):
8351  return _object_cast_to_TripletModifier(o)
8352 
8353  __swig_destroy__ = _IMP_kernel.delete_TripletModifier
8354  __del__ = lambda self: None
8355  def __disown__(self):
8356  self.this.disown()
8357  _IMP_kernel.disown_TripletModifier(self)
8358  return weakref_proxy(self)
8359 
8360  def do_get_inputs(self, m, pis):
8361  """do_get_inputs(TripletModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
8362  return _IMP_kernel.TripletModifier_do_get_inputs(self, m, pis)
8363 
8364 
8365  def do_get_outputs(self, m, pis):
8366  """do_get_outputs(TripletModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
8367  return _IMP_kernel.TripletModifier_do_get_outputs(self, m, pis)
8368 
8369 
8370  def do_destroy(self):
8371  """do_destroy(TripletModifier self)"""
8372  return _IMP_kernel.TripletModifier_do_destroy(self)
8373 
8374 TripletModifier_swigregister = _IMP_kernel.TripletModifier_swigregister
8375 TripletModifier_swigregister(TripletModifier)
8376 
8377 class TripletScore(_ParticleInputs, Object):
8378  """Proxy of C++ IMP::TripletScore class"""
8379  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
8380 
8381  def __init__(self, *args):
8382  """
8383  __init__(IMP::TripletScore self, std::string name) -> TripletScore
8384  __init__(IMP::TripletScore self) -> TripletScore
8385  """
8386  if self.__class__ == TripletScore:
8387  _self = None
8388  else:
8389  _self = self
8390  this = _IMP_kernel.new_TripletScore(_self, *args)
8391  try:
8392  self.this.append(this)
8393  except:
8394  self.this = this
8395 
8396  if self.__class__ != TripletScore:
8397  _director_objects.register(self)
8398 
8399 
8400 
8401 
8402  def evaluate_index(self, m, vt, da):
8403  """evaluate_index(TripletScore self, Model m, IMP::ParticleIndexTriplet const & vt, DerivativeAccumulator da) -> double"""
8404  return _IMP_kernel.TripletScore_evaluate_index(self, m, vt, da)
8405 
8406 
8407  def evaluate_indexes(self, m, o, da, lower_bound, upper_bound):
8408  """evaluate_indexes(TripletScore self, Model m, IMP::ParticleIndexTriplets const & o, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound) -> double"""
8409  return _IMP_kernel.TripletScore_evaluate_indexes(self, m, o, da, lower_bound, upper_bound)
8410 
8411 
8412  def evaluate_if_good_index(self, m, vt, da, max):
8413  """evaluate_if_good_index(TripletScore self, Model m, IMP::ParticleIndexTriplet const & vt, DerivativeAccumulator da, double max) -> double"""
8414  return _IMP_kernel.TripletScore_evaluate_if_good_index(self, m, vt, da, max)
8415 
8416 
8417  def evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound):
8418  """evaluate_if_good_indexes(TripletScore self, Model m, IMP::ParticleIndexTriplets const & o, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound) -> double"""
8419  return _IMP_kernel.TripletScore_evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound)
8420 
8421 
8422  def create_current_decomposition(self, m, vt):
8423  """create_current_decomposition(TripletScore self, Model m, IMP::ParticleIndexTriplet const & vt) -> IMP::Restraints"""
8424  return _IMP_kernel.TripletScore_create_current_decomposition(self, m, vt)
8425 
8426 
8427  def do_create_current_decomposition(self, m, vt):
8428  """do_create_current_decomposition(TripletScore self, Model m, IMP::ParticleIndexTriplet const & vt) -> IMP::Restraints"""
8429  return _IMP_kernel.TripletScore_do_create_current_decomposition(self, m, vt)
8430 
8431  __swig_destroy__ = _IMP_kernel.delete_TripletScore
8432  __del__ = lambda self: None
8433 
8434  def __str__(self):
8435  """__str__(TripletScore self) -> std::string"""
8436  return _IMP_kernel.TripletScore___str__(self)
8437 
8438 
8439  def __repr__(self):
8440  """__repr__(TripletScore self) -> std::string"""
8441  return _IMP_kernel.TripletScore___repr__(self)
8442 
8443 
8444  @staticmethod
8445  def get_from(o):
8446  return _object_cast_to_TripletScore(o)
8447 
8448 
8449  def get_type_name(self):
8450  return self.__class__.__name__
8451  def do_show(self, out):
8452  pass
8453  def get_version_info(self):
8454  if"IMP" == "IMP":
8455  return VersionInfo(self.__module__,
8456  __import__(self.__module__).get_module_version())
8457  else:
8458  return IMP.VersionInfo(self.__module__,
8459  __import__(self.__module__).get_module_version())
8460  @staticmethod
8461  def get_from(o):
8462  return _object_cast_to_TripletScore(o)
8463 
8464  def __disown__(self):
8465  self.this.disown()
8466  _IMP_kernel.disown_TripletScore(self)
8467  return weakref_proxy(self)
8468 
8469  def do_get_inputs(self, m, pis):
8470  """do_get_inputs(TripletScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
8471  return _IMP_kernel.TripletScore_do_get_inputs(self, m, pis)
8472 
8473 
8474  def do_destroy(self):
8475  """do_destroy(TripletScore self)"""
8476  return _IMP_kernel.TripletScore_do_destroy(self)
8477 
8478 TripletScore_swigregister = _IMP_kernel.TripletScore_swigregister
8479 TripletScore_swigregister(TripletScore)
8480 
8481 class TripletPredicate(_ParticleInputs, Object):
8482  """Proxy of C++ IMP::TripletPredicate class"""
8483  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
8484 
8485  def __init__(self, *args):
8486  """
8487  __init__(IMP::TripletPredicate self, std::string name) -> TripletPredicate
8488  __init__(IMP::TripletPredicate self) -> TripletPredicate
8489  """
8490  if self.__class__ == TripletPredicate:
8491  _self = None
8492  else:
8493  _self = self
8494  this = _IMP_kernel.new_TripletPredicate(_self, *args)
8495  try:
8496  self.this.append(this)
8497  except:
8498  self.this = this
8499 
8500  if self.__class__ != TripletPredicate:
8501  _director_objects.register(self)
8502 
8503 
8504 
8505 
8506  def get_value(self, *args):
8507  """
8508  get_value(TripletPredicate self, IMP::ParticleTriplet const & vt) -> int
8509  get_value(TripletPredicate self, IMP::ParticleTripletsTemp const & o) -> IMP::Ints
8510  """
8511  return _IMP_kernel.TripletPredicate_get_value(self, *args)
8512 
8513 
8514  def setup_for_get_value_index_in_batch(self, arg0):
8515  """setup_for_get_value_index_in_batch(TripletPredicate self, Model arg0)"""
8516  return _IMP_kernel.TripletPredicate_setup_for_get_value_index_in_batch(self, arg0)
8517 
8518 
8519  def get_value_index_in_batch(self, m, vt):
8520  """get_value_index_in_batch(TripletPredicate self, Model m, IMP::ParticleIndexTriplet const & vt) -> int"""
8521  return _IMP_kernel.TripletPredicate_get_value_index_in_batch(self, m, vt)
8522 
8523 
8524  def __call__(self, m, vt):
8525  """__call__(TripletPredicate self, Model m, IMP::ParticleIndexTriplet const & vt) -> int"""
8526  return _IMP_kernel.TripletPredicate___call__(self, m, vt)
8527 
8528 
8529  def get_value_index(self, *args):
8530  """
8531  get_value_index(TripletPredicate self, Model m, IMP::ParticleIndexTriplet const & vt) -> int
8532  get_value_index(TripletPredicate self, Model m, IMP::ParticleIndexTriplets const & o) -> IMP::Ints
8533  """
8534  return _IMP_kernel.TripletPredicate_get_value_index(self, *args)
8535 
8536  __swig_destroy__ = _IMP_kernel.delete_TripletPredicate
8537  __del__ = lambda self: None
8538 
8539  def __str__(self):
8540  """__str__(TripletPredicate self) -> std::string"""
8541  return _IMP_kernel.TripletPredicate___str__(self)
8542 
8543 
8544  def __repr__(self):
8545  """__repr__(TripletPredicate self) -> std::string"""
8546  return _IMP_kernel.TripletPredicate___repr__(self)
8547 
8548 
8549  @staticmethod
8550  def get_from(o):
8551  return _object_cast_to_TripletPredicate(o)
8552 
8553 
8554  def get_type_name(self):
8555  return self.__class__.__name__
8556  def do_show(self, out):
8557  pass
8558  def get_version_info(self):
8559  if"IMP" == "IMP":
8560  return VersionInfo(self.__module__,
8561  __import__(self.__module__).get_module_version())
8562  else:
8563  return IMP.VersionInfo(self.__module__,
8564  __import__(self.__module__).get_module_version())
8565  @staticmethod
8566  def get_from(o):
8567  return _object_cast_to_TripletPredicate(o)
8568 
8569  def __disown__(self):
8570  self.this.disown()
8571  _IMP_kernel.disown_TripletPredicate(self)
8572  return weakref_proxy(self)
8573 
8574  def do_get_inputs(self, m, pis):
8575  """do_get_inputs(TripletPredicate self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
8576  return _IMP_kernel.TripletPredicate_do_get_inputs(self, m, pis)
8577 
8578 
8579  def do_destroy(self):
8580  """do_destroy(TripletPredicate self)"""
8581  return _IMP_kernel.TripletPredicate_do_destroy(self)
8582 
8583 TripletPredicate_swigregister = _IMP_kernel.TripletPredicate_swigregister
8584 TripletPredicate_swigregister(TripletPredicate)
8585 
8586 class TripletContainer(Container):
8587  """Proxy of C++ IMP::TripletContainer class"""
8588  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
8589 
8590  def apply_generic(self, m):
8591  """apply_generic(TripletContainer self, TripletModifier m)"""
8592  return _IMP_kernel.TripletContainer_apply_generic(self, m)
8593 
8594 
8595  def apply(self, sm):
8596  """apply(TripletContainer self, TripletModifier sm)"""
8597  return _IMP_kernel.TripletContainer_apply(self, sm)
8598 
8599 
8600  def get_range_indexes(self):
8601  """get_range_indexes(TripletContainer self) -> IMP::ParticleIndexTriplets"""
8602  return _IMP_kernel.TripletContainer_get_range_indexes(self)
8603 
8604 
8605  def get_contents(self):
8606  """get_contents(TripletContainer self) -> IMP::ParticleIndexTriplets const &"""
8607  return _IMP_kernel.TripletContainer_get_contents(self)
8608 
8609 
8610  def get_indexes(self):
8611  """get_indexes(TripletContainer self) -> IMP::ParticleIndexTriplets"""
8612  return _IMP_kernel.TripletContainer_get_indexes(self)
8613 
8614 
8615  def get(self, *args):
8616  """
8617  get(TripletContainer self) -> IMP::ParticleTripletsTemp
8618  get(TripletContainer self, unsigned int i) -> IMP::ParticleTriplet
8619  """
8620  return _IMP_kernel.TripletContainer_get(self, *args)
8621 
8622 
8623  def get_number(self):
8624  """get_number(TripletContainer self) -> unsigned int"""
8625  return _IMP_kernel.TripletContainer_get_number(self)
8626 
8627 
8628  def get_particle_triplets(self):
8629  """get_particle_triplets(TripletContainer self) -> IMP::ParticleTripletsTemp"""
8630  return _IMP_kernel.TripletContainer_get_particle_triplets(self)
8631 
8632 
8633  def __init__(self, *args):
8634  """
8635  __init__(IMP::TripletContainer self, Model m, std::string name) -> TripletContainer
8636  __init__(IMP::TripletContainer self, Model m) -> TripletContainer
8637  """
8638  if self.__class__ == TripletContainer:
8639  _self = None
8640  else:
8641  _self = self
8642  this = _IMP_kernel.new_TripletContainer(_self, *args)
8643  try:
8644  self.this.append(this)
8645  except:
8646  self.this = this
8647 
8648  if self.__class__ != TripletContainer:
8649  _director_objects.register(self)
8650 
8651 
8652 
8653 
8654  def do_apply(self, sm):
8655  """do_apply(TripletContainer self, TripletModifier sm)"""
8656  return _IMP_kernel.TripletContainer_do_apply(self, sm)
8657 
8658 
8659  def do_get_provides_access(self):
8660  """do_get_provides_access(TripletContainer self) -> bool"""
8661  return _IMP_kernel.TripletContainer_do_get_provides_access(self)
8662 
8663  __swig_destroy__ = _IMP_kernel.delete_TripletContainer
8664  __del__ = lambda self: None
8665 
8666  def __str__(self):
8667  """__str__(TripletContainer self) -> std::string"""
8668  return _IMP_kernel.TripletContainer___str__(self)
8669 
8670 
8671  def __repr__(self):
8672  """__repr__(TripletContainer self) -> std::string"""
8673  return _IMP_kernel.TripletContainer___repr__(self)
8674 
8675 
8676  @staticmethod
8677  def get_from(o):
8678  return _object_cast_to_TripletContainer(o)
8679 
8680 
8681  def get_type_name(self):
8682  return self.__class__.__name__
8683  def do_show(self, out):
8684  pass
8685  def get_version_info(self):
8686  if"IMP" == "IMP":
8687  return VersionInfo(self.__module__,
8688  __import__(self.__module__).get_module_version())
8689  else:
8690  return IMP.VersionInfo(self.__module__,
8691  __import__(self.__module__).get_module_version())
8692  @staticmethod
8693  def get_from(o):
8694  return _object_cast_to_TripletContainer(o)
8695 
8696  def __disown__(self):
8697  self.this.disown()
8698  _IMP_kernel.disown_TripletContainer(self)
8699  return weakref_proxy(self)
8700 
8701  def do_destroy(self):
8702  """do_destroy(TripletContainer self)"""
8703  return _IMP_kernel.TripletContainer_do_destroy(self)
8704 
8705 
8706  def handle_set_has_required_score_states(self, arg0):
8707  """handle_set_has_required_score_states(TripletContainer self, bool arg0)"""
8708  return _IMP_kernel.TripletContainer_handle_set_has_required_score_states(self, arg0)
8709 
8710 
8711  def do_get_inputs(self):
8712  """do_get_inputs(TripletContainer self) -> IMP::ModelObjectsTemp"""
8713  return _IMP_kernel.TripletContainer_do_get_inputs(self)
8714 
8715 
8716  def do_get_interactions(self):
8717  """do_get_interactions(TripletContainer self) -> IMP::ModelObjectsTemps"""
8718  return _IMP_kernel.TripletContainer_do_get_interactions(self)
8719 
8720 
8721  def do_get_contents_hash(self):
8722  """do_get_contents_hash(TripletContainer self) -> std::size_t"""
8723  return _IMP_kernel.TripletContainer_do_get_contents_hash(self)
8724 
8725 TripletContainer_swigregister = _IMP_kernel.TripletContainer_swigregister
8726 TripletContainer_swigregister(TripletContainer)
8727 
8728 class _TripletContainerAdaptor(_InputAdaptor):
8729  """Proxy of C++ IMP::TripletContainerAdaptor class"""
8730  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
8731  __repr__ = _swig_repr
8732 
8733  def __init__(self, *args):
8734  """
8735  __init__(IMP::TripletContainerAdaptor self) -> _TripletContainerAdaptor
8736  __init__(IMP::TripletContainerAdaptor self, TripletContainer c) -> _TripletContainerAdaptor
8737  __init__(IMP::TripletContainerAdaptor self, IMP::ParticleTripletsTemp const & t) -> _TripletContainerAdaptor
8738  """
8739  this = _IMP_kernel.new__TripletContainerAdaptor(*args)
8740  try:
8741  self.this.append(this)
8742  except:
8743  self.this = this
8744 
8745  def set_name_if_default(self, name):
8746  """set_name_if_default(_TripletContainerAdaptor self, std::string name)"""
8747  return _IMP_kernel._TripletContainerAdaptor_set_name_if_default(self, name)
8748 
8749  __swig_destroy__ = _IMP_kernel.delete__TripletContainerAdaptor
8750  __del__ = lambda self: None
8751 _TripletContainerAdaptor_swigregister = _IMP_kernel._TripletContainerAdaptor_swigregister
8752 _TripletContainerAdaptor_swigregister(_TripletContainerAdaptor)
8753 
8754 
8755 def write_particles_to_buffer(particles, keys):
8756  """write_particles_to_buffer(IMP::ParticlesTemp const & particles, IMP::FloatKeys const & keys) -> IMP::Vector< char >"""
8757  return _IMP_kernel.write_particles_to_buffer(particles, keys)
8758 
8759 def read_particles_from_buffer(buffer, particles, keys):
8760  """read_particles_from_buffer(IMP::Vector< char > const & buffer, IMP::ParticlesTemp const & particles, IMP::FloatKeys const & keys)"""
8761  return _IMP_kernel.read_particles_from_buffer(buffer, particles, keys)
8762 
8763 def get_particles(m, ps):
8764  """get_particles(Model m, IMP::ParticleIndexes const & ps) -> IMP::ParticlesTemp"""
8765  return _IMP_kernel.get_particles(m, ps)
8766 
8767 def get_indexes(*args):
8768  """
8769  get_indexes(IMP::ParticlesTemp const & ps) -> IMP::ParticleIndexes
8770  get_indexes(IMP::ParticlePairsTemp const & ps) -> IMP::ParticleIndexPairs
8771  """
8772  return _IMP_kernel.get_indexes(*args)
8773 class _ParticleIndexAdaptor(object):
8774  """Proxy of C++ IMP::ParticleIndexAdaptor class"""
8775  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
8776  __repr__ = _swig_repr
8777 
8778  def __init__(self, *args):
8779  """
8780  __init__(IMP::ParticleIndexAdaptor self, Particle p) -> _ParticleIndexAdaptor
8781  __init__(IMP::ParticleIndexAdaptor self, ParticleIndex pi) -> _ParticleIndexAdaptor
8782  __init__(IMP::ParticleIndexAdaptor self, Decorator d) -> _ParticleIndexAdaptor
8783  """
8784  this = _IMP_kernel.new__ParticleIndexAdaptor(*args)
8785  try:
8786  self.this.append(this)
8787  except:
8788  self.this = this
8789  __swig_destroy__ = _IMP_kernel.delete__ParticleIndexAdaptor
8790  __del__ = lambda self: None
8791 _ParticleIndexAdaptor_swigregister = _IMP_kernel._ParticleIndexAdaptor_swigregister
8792 _ParticleIndexAdaptor_swigregister(_ParticleIndexAdaptor)
8793 
8794 class _ParticleIndexesAdaptor(_InputAdaptor):
8795  """Proxy of C++ IMP::ParticleIndexesAdaptor class"""
8796  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
8797  __repr__ = _swig_repr
8798 
8799  def __init__(self, *args):
8800  """
8801  __init__(IMP::ParticleIndexesAdaptor self, IMP::ParticlesTemp const & ps) -> _ParticleIndexesAdaptor
8802  __init__(IMP::ParticleIndexesAdaptor self, IMP::ParticleIndexes const & pi) -> _ParticleIndexesAdaptor
8803  __init__(IMP::ParticleIndexesAdaptor self) -> _ParticleIndexesAdaptor
8804  """
8805  this = _IMP_kernel.new__ParticleIndexesAdaptor(*args)
8806  try:
8807  self.this.append(this)
8808  except:
8809  self.this = this
8810  __swig_destroy__ = _IMP_kernel.delete__ParticleIndexesAdaptor
8811  __del__ = lambda self: None
8812 _ParticleIndexesAdaptor_swigregister = _IMP_kernel._ParticleIndexesAdaptor_swigregister
8813 _ParticleIndexesAdaptor_swigregister(_ParticleIndexesAdaptor)
8814 
8815 class _ParticleIndexPairsAdaptor(object):
8816  """Proxy of C++ IMP::ParticleIndexPairsAdaptor class"""
8817  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
8818  __repr__ = _swig_repr
8819 
8820  def __init__(self, *args):
8821  """
8822  __init__(IMP::ParticleIndexPairsAdaptor self, IMP::ParticlePairsTemp const & ps) -> _ParticleIndexPairsAdaptor
8823  __init__(IMP::ParticleIndexPairsAdaptor self, IMP::ParticleIndexPairs const & pi) -> _ParticleIndexPairsAdaptor
8824  __init__(IMP::ParticleIndexPairsAdaptor self) -> _ParticleIndexPairsAdaptor
8825  """
8826  this = _IMP_kernel.new__ParticleIndexPairsAdaptor(*args)
8827  try:
8828  self.this.append(this)
8829  except:
8830  self.this = this
8831  __swig_destroy__ = _IMP_kernel.delete__ParticleIndexPairsAdaptor
8832  __del__ = lambda self: None
8833 _ParticleIndexPairsAdaptor_swigregister = _IMP_kernel._ParticleIndexPairsAdaptor_swigregister
8834 _ParticleIndexPairsAdaptor_swigregister(_ParticleIndexPairsAdaptor)
8835 
8836 class _ConstRestraint(Restraint):
8837  """Proxy of C++ IMP::internal::_ConstRestraint class"""
8838  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
8839 
8840  def __init__(self, *args):
8841  """
8842  __init__(IMP::internal::_ConstRestraint self, double v, IMP::ParticlesTemp const ps) -> _ConstRestraint
8843  __init__(IMP::internal::_ConstRestraint self, Model m, IMP::ParticleIndexes const & pis, double v) -> _ConstRestraint
8844  """
8845  this = _IMP_kernel.new__ConstRestraint(*args)
8846  try:
8847  self.this.append(this)
8848  except:
8849  self.this = this
8850 
8851  def get_value(self):
8852  """get_value(_ConstRestraint self) -> double"""
8853  return _IMP_kernel._ConstRestraint_get_value(self)
8854 
8855 
8856  def do_create_decomposition(self):
8857  """do_create_decomposition(_ConstRestraint self) -> IMP::Restraints"""
8858  return _IMP_kernel._ConstRestraint_do_create_decomposition(self)
8859 
8860 
8861  def do_get_inputs(self):
8862  """do_get_inputs(_ConstRestraint self) -> IMP::ModelObjectsTemp"""
8863  return _IMP_kernel._ConstRestraint_do_get_inputs(self)
8864 
8865 
8866  def get_version_info(self):
8867  """get_version_info(_ConstRestraint self) -> VersionInfo"""
8868  return _IMP_kernel._ConstRestraint_get_version_info(self)
8869 
8870 
8871  def __str__(self):
8872  """__str__(_ConstRestraint self) -> std::string"""
8873  return _IMP_kernel._ConstRestraint___str__(self)
8874 
8875 
8876  def __repr__(self):
8877  """__repr__(_ConstRestraint self) -> std::string"""
8878  return _IMP_kernel._ConstRestraint___repr__(self)
8879 
8880 
8881  @staticmethod
8882  def get_from(o):
8883  return _object_cast_to__ConstRestraint(o)
8884 
8885 _ConstRestraint_swigregister = _IMP_kernel._ConstRestraint_swigregister
8886 _ConstRestraint_swigregister(_ConstRestraint)
8887 
8888 class _ConstSingletonScore(SingletonScore):
8889  """Proxy of C++ IMP::internal::_ConstSingletonScore class"""
8890  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
8891  __repr__ = _swig_repr
8892 
8893  def __init__(self, v):
8894  """__init__(IMP::internal::_ConstSingletonScore self, double v) -> _ConstSingletonScore"""
8895  this = _IMP_kernel.new__ConstSingletonScore(v)
8896  try:
8897  self.this.append(this)
8898  except:
8899  self.this = this
8900 
8901  def do_get_inputs(self, arg2, arg3):
8902  """do_get_inputs(_ConstSingletonScore self, Model arg2, IMP::ParticleIndexes const & arg3) -> IMP::ModelObjectsTemp"""
8903  return _IMP_kernel._ConstSingletonScore_do_get_inputs(self, arg2, arg3)
8904 
8905 
8906  def get_version_info(self):
8907  """get_version_info(_ConstSingletonScore self) -> VersionInfo"""
8908  return _IMP_kernel._ConstSingletonScore_get_version_info(self)
8909 
8910 _ConstSingletonScore_swigregister = _IMP_kernel._ConstSingletonScore_swigregister
8911 _ConstSingletonScore_swigregister(_ConstSingletonScore)
8912 
8913 class _ConstPairScore(PairScore):
8914  """Proxy of C++ IMP::internal::_ConstPairScore class"""
8915  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
8916  __repr__ = _swig_repr
8917 
8918  def __init__(self, v):
8919  """__init__(IMP::internal::_ConstPairScore self, double v) -> _ConstPairScore"""
8920  this = _IMP_kernel.new__ConstPairScore(v)
8921  try:
8922  self.this.append(this)
8923  except:
8924  self.this = this
8925 
8926  def do_get_inputs(self, arg2, arg3):
8927  """do_get_inputs(_ConstPairScore self, Model arg2, IMP::ParticleIndexes const & arg3) -> IMP::ModelObjectsTemp"""
8928  return _IMP_kernel._ConstPairScore_do_get_inputs(self, arg2, arg3)
8929 
8930 
8931  def get_version_info(self):
8932  """get_version_info(_ConstPairScore self) -> VersionInfo"""
8933  return _IMP_kernel._ConstPairScore_get_version_info(self)
8934 
8935 _ConstPairScore_swigregister = _IMP_kernel._ConstPairScore_swigregister
8936 _ConstPairScore_swigregister(_ConstPairScore)
8937 
8938 class _TrivialDecorator(Decorator):
8939  """Proxy of C++ IMP::internal::_TrivialDecorator class"""
8940  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
8941 
8942  def __init__(self, *args):
8943  """
8944  __init__(IMP::internal::_TrivialDecorator self) -> _TrivialDecorator
8945  __init__(IMP::internal::_TrivialDecorator self, Model m, ParticleIndex id) -> _TrivialDecorator
8946  __init__(IMP::internal::_TrivialDecorator self, _ParticleAdaptor d) -> _TrivialDecorator
8947  """
8948  this = _IMP_kernel.new__TrivialDecorator(*args)
8949  try:
8950  self.this.append(this)
8951  except:
8952  self.this = this
8953 
8954  def show(self, *args):
8955  """
8956  show(_TrivialDecorator self, _ostream out)
8957  show(_TrivialDecorator self)
8958  """
8959  return _IMP_kernel._TrivialDecorator_show(self, *args)
8960 
8961 
8962  def setup_particle(*args):
8963  """
8964  setup_particle(Model m, ParticleIndex pi) -> _TrivialDecorator
8965  setup_particle(_ParticleAdaptor decorator) -> _TrivialDecorator
8966  """
8967  return _IMP_kernel._TrivialDecorator_setup_particle(*args)
8968 
8969  setup_particle = staticmethod(setup_particle)
8970 
8971  def get_is_setup(*args):
8972  """
8973  get_is_setup(_ParticleAdaptor p) -> bool
8974  get_is_setup(Model m, ParticleIndex pi) -> bool
8975  """
8976  return _IMP_kernel._TrivialDecorator_get_is_setup(*args)
8977 
8978  get_is_setup = staticmethod(get_is_setup)
8979 
8980  def add_attribute(self, *args):
8981  """
8982  add_attribute(_TrivialDecorator self, FloatKey k, IMP::Float v, bool opt)
8983  add_attribute(_TrivialDecorator self, FloatKey a0, IMP::Float a1)
8984  add_attribute(_TrivialDecorator self, IntKey a0, IMP::Int a1)
8985  add_attribute(_TrivialDecorator self, FloatsKey a0, IMP::Floats a1)
8986  add_attribute(_TrivialDecorator self, IntsKey a0, IMP::Ints a1)
8987  add_attribute(_TrivialDecorator self, StringKey a0, IMP::String a1)
8988  add_attribute(_TrivialDecorator self, ParticleIndexKey a0, Particle a1)
8989  add_attribute(_TrivialDecorator self, ObjectKey a0, Object a1)
8990  """
8991  return _IMP_kernel._TrivialDecorator_add_attribute(self, *args)
8992 
8993 
8994  def get_value(self, *args):
8995  """
8996  get_value(_TrivialDecorator self, FloatKey a0) -> IMP::Float
8997  get_value(_TrivialDecorator self, IntKey a0) -> IMP::Int
8998  get_value(_TrivialDecorator self, FloatsKey a0) -> IMP::Floats
8999  get_value(_TrivialDecorator self, IntsKey a0) -> IMP::Ints
9000  get_value(_TrivialDecorator self, StringKey a0) -> IMP::String
9001  get_value(_TrivialDecorator self, ParticleIndexKey a0) -> Particle
9002  get_value(_TrivialDecorator self, ObjectKey a0) -> Object
9003  """
9004  return _IMP_kernel._TrivialDecorator_get_value(self, *args)
9005 
9006 
9007  def set_value(self, *args):
9008  """
9009  set_value(_TrivialDecorator self, FloatKey a0, IMP::Float a1)
9010  set_value(_TrivialDecorator self, IntKey a0, IMP::Int a1)
9011  set_value(_TrivialDecorator self, FloatsKey a0, IMP::Floats a1)
9012  set_value(_TrivialDecorator self, IntsKey a0, IMP::Ints a1)
9013  set_value(_TrivialDecorator self, StringKey a0, IMP::String a1)
9014  set_value(_TrivialDecorator self, ParticleIndexKey a0, Particle a1)
9015  set_value(_TrivialDecorator self, ObjectKey a0, Object a1)
9016  """
9017  return _IMP_kernel._TrivialDecorator_set_value(self, *args)
9018 
9019 
9020  def remove_attribute(self, *args):
9021  """
9022  remove_attribute(_TrivialDecorator self, FloatKey a0)
9023  remove_attribute(_TrivialDecorator self, IntKey a0)
9024  remove_attribute(_TrivialDecorator self, FloatsKey a0)
9025  remove_attribute(_TrivialDecorator self, IntsKey a0)
9026  remove_attribute(_TrivialDecorator self, StringKey a0)
9027  remove_attribute(_TrivialDecorator self, ParticleIndexKey a0)
9028  remove_attribute(_TrivialDecorator self, ObjectKey a0)
9029  """
9030  return _IMP_kernel._TrivialDecorator_remove_attribute(self, *args)
9031 
9032 
9033  def has_attribute(self, *args):
9034  """
9035  has_attribute(_TrivialDecorator self, FloatKey a0) -> bool
9036  has_attribute(_TrivialDecorator self, IntKey a0) -> bool
9037  has_attribute(_TrivialDecorator self, FloatsKey a0) -> bool
9038  has_attribute(_TrivialDecorator self, IntsKey a0) -> bool
9039  has_attribute(_TrivialDecorator self, StringKey a0) -> bool
9040  has_attribute(_TrivialDecorator self, ParticleIndexKey a0) -> bool
9041  has_attribute(_TrivialDecorator self, ObjectKey a0) -> bool
9042  """
9043  return _IMP_kernel._TrivialDecorator_has_attribute(self, *args)
9044 
9045 
9046  def get_derivative(self, a0):
9047  """get_derivative(_TrivialDecorator self, FloatKey a0) -> double"""
9048  return _IMP_kernel._TrivialDecorator_get_derivative(self, a0)
9049 
9050 
9051  def get_name(self):
9052  """get_name(_TrivialDecorator self) -> std::string"""
9053  return _IMP_kernel._TrivialDecorator_get_name(self)
9054 
9055 
9056  def clear_caches(self):
9057  """clear_caches(_TrivialDecorator self)"""
9058  return _IMP_kernel._TrivialDecorator_clear_caches(self)
9059 
9060 
9061  def set_name(self, a0):
9062  """set_name(_TrivialDecorator self, std::string a0)"""
9063  return _IMP_kernel._TrivialDecorator_set_name(self, a0)
9064 
9065 
9066  def set_check_level(self, a0):
9067  """set_check_level(_TrivialDecorator self, IMP::CheckLevel a0)"""
9068  return _IMP_kernel._TrivialDecorator_set_check_level(self, a0)
9069 
9070 
9071  def add_to_derivative(self, a0, a1, a2):
9072  """add_to_derivative(_TrivialDecorator self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
9073  return _IMP_kernel._TrivialDecorator_add_to_derivative(self, a0, a1, a2)
9074 
9075 
9076  def set_is_optimized(self, a0, a1):
9077  """set_is_optimized(_TrivialDecorator self, FloatKey a0, bool a1)"""
9078  return _IMP_kernel._TrivialDecorator_set_is_optimized(self, a0, a1)
9079 
9080 
9081  def get_is_optimized(self, a0):
9082  """get_is_optimized(_TrivialDecorator self, FloatKey a0) -> bool"""
9083  return _IMP_kernel._TrivialDecorator_get_is_optimized(self, a0)
9084 
9085 
9086  def get_check_level(self):
9087  """get_check_level(_TrivialDecorator self) -> IMP::CheckLevel"""
9088  return _IMP_kernel._TrivialDecorator_get_check_level(self)
9089 
9090 
9091  def __eq__(self, *args):
9092  """
9093  __eq__(_TrivialDecorator self, _TrivialDecorator o) -> bool
9094  __eq__(_TrivialDecorator self, Particle d) -> bool
9095  """
9096  return _IMP_kernel._TrivialDecorator___eq__(self, *args)
9097 
9098 
9099  def __ne__(self, *args):
9100  """
9101  __ne__(_TrivialDecorator self, _TrivialDecorator o) -> bool
9102  __ne__(_TrivialDecorator self, Particle d) -> bool
9103  """
9104  return _IMP_kernel._TrivialDecorator___ne__(self, *args)
9105 
9106 
9107  def __le__(self, *args):
9108  """
9109  __le__(_TrivialDecorator self, _TrivialDecorator o) -> bool
9110  __le__(_TrivialDecorator self, Particle d) -> bool
9111  """
9112  return _IMP_kernel._TrivialDecorator___le__(self, *args)
9113 
9114 
9115  def __lt__(self, *args):
9116  """
9117  __lt__(_TrivialDecorator self, _TrivialDecorator o) -> bool
9118  __lt__(_TrivialDecorator self, Particle d) -> bool
9119  """
9120  return _IMP_kernel._TrivialDecorator___lt__(self, *args)
9121 
9122 
9123  def __ge__(self, *args):
9124  """
9125  __ge__(_TrivialDecorator self, _TrivialDecorator o) -> bool
9126  __ge__(_TrivialDecorator self, Particle d) -> bool
9127  """
9128  return _IMP_kernel._TrivialDecorator___ge__(self, *args)
9129 
9130 
9131  def __gt__(self, *args):
9132  """
9133  __gt__(_TrivialDecorator self, _TrivialDecorator o) -> bool
9134  __gt__(_TrivialDecorator self, Particle d) -> bool
9135  """
9136  return _IMP_kernel._TrivialDecorator___gt__(self, *args)
9137 
9138 
9139  def __hash__(self):
9140  """__hash__(_TrivialDecorator self) -> std::size_t"""
9141  return _IMP_kernel._TrivialDecorator___hash__(self)
9142 
9143 
9144  def __str__(self):
9145  """__str__(_TrivialDecorator self) -> std::string"""
9146  return _IMP_kernel._TrivialDecorator___str__(self)
9147 
9148 
9149  def __repr__(self):
9150  """__repr__(_TrivialDecorator self) -> std::string"""
9151  return _IMP_kernel._TrivialDecorator___repr__(self)
9152 
9153  __swig_destroy__ = _IMP_kernel.delete__TrivialDecorator
9154  __del__ = lambda self: None
9155 _TrivialDecorator_swigregister = _IMP_kernel._TrivialDecorator_swigregister
9156 _TrivialDecorator_swigregister(_TrivialDecorator)
9157 
9158 def _TrivialDecorator_setup_particle(*args):
9159  """
9160  setup_particle(Model m, ParticleIndex pi) -> _TrivialDecorator
9161  _TrivialDecorator_setup_particle(_ParticleAdaptor decorator) -> _TrivialDecorator
9162  """
9163  return _IMP_kernel._TrivialDecorator_setup_particle(*args)
9164 
9165 def _TrivialDecorator_get_is_setup(*args):
9166  """
9167  get_is_setup(_ParticleAdaptor p) -> bool
9168  _TrivialDecorator_get_is_setup(Model m, ParticleIndex pi) -> bool
9169  """
9170  return _IMP_kernel._TrivialDecorator_get_is_setup(*args)
9171 
9172 class _TrivialDerivedDecorator(_TrivialDecorator):
9173  """Proxy of C++ IMP::internal::_TrivialDerivedDecorator class"""
9174  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
9175 
9176  def __init__(self, *args):
9177  """
9178  __init__(IMP::internal::_TrivialDerivedDecorator self) -> _TrivialDerivedDecorator
9179  __init__(IMP::internal::_TrivialDerivedDecorator self, Model m, ParticleIndex id) -> _TrivialDerivedDecorator
9180  __init__(IMP::internal::_TrivialDerivedDecorator self, _ParticleAdaptor d) -> _TrivialDerivedDecorator
9181  """
9182  this = _IMP_kernel.new__TrivialDerivedDecorator(*args)
9183  try:
9184  self.this.append(this)
9185  except:
9186  self.this = this
9187 
9188  def show(self, *args):
9189  """
9190  show(_TrivialDerivedDecorator self, _ostream out)
9191  show(_TrivialDerivedDecorator self)
9192  """
9193  return _IMP_kernel._TrivialDerivedDecorator_show(self, *args)
9194 
9195 
9196  def setup_particle(*args):
9197  """
9198  setup_particle(Model m, ParticleIndex pi) -> _TrivialDerivedDecorator
9199  setup_particle(_ParticleAdaptor decorator) -> _TrivialDerivedDecorator
9200  """
9201  return _IMP_kernel._TrivialDerivedDecorator_setup_particle(*args)
9202 
9203  setup_particle = staticmethod(setup_particle)
9204 
9205  def get_is_setup(*args):
9206  """
9207  get_is_setup(_ParticleAdaptor p) -> bool
9208  get_is_setup(Model m, ParticleIndex pi) -> bool
9209  """
9210  return _IMP_kernel._TrivialDerivedDecorator_get_is_setup(*args)
9211 
9212  get_is_setup = staticmethod(get_is_setup)
9213 
9214  def add_attribute(self, *args):
9215  """
9216  add_attribute(_TrivialDerivedDecorator self, FloatKey k, IMP::Float v, bool opt)
9217  add_attribute(_TrivialDerivedDecorator self, FloatKey a0, IMP::Float a1)
9218  add_attribute(_TrivialDerivedDecorator self, IntKey a0, IMP::Int a1)
9219  add_attribute(_TrivialDerivedDecorator self, FloatsKey a0, IMP::Floats a1)
9220  add_attribute(_TrivialDerivedDecorator self, IntsKey a0, IMP::Ints a1)
9221  add_attribute(_TrivialDerivedDecorator self, StringKey a0, IMP::String a1)
9222  add_attribute(_TrivialDerivedDecorator self, ParticleIndexKey a0, Particle a1)
9223  add_attribute(_TrivialDerivedDecorator self, ObjectKey a0, Object a1)
9224  """
9225  return _IMP_kernel._TrivialDerivedDecorator_add_attribute(self, *args)
9226 
9227 
9228  def get_value(self, *args):
9229  """
9230  get_value(_TrivialDerivedDecorator self, FloatKey a0) -> IMP::Float
9231  get_value(_TrivialDerivedDecorator self, IntKey a0) -> IMP::Int
9232  get_value(_TrivialDerivedDecorator self, FloatsKey a0) -> IMP::Floats
9233  get_value(_TrivialDerivedDecorator self, IntsKey a0) -> IMP::Ints
9234  get_value(_TrivialDerivedDecorator self, StringKey a0) -> IMP::String
9235  get_value(_TrivialDerivedDecorator self, ParticleIndexKey a0) -> Particle
9236  get_value(_TrivialDerivedDecorator self, ObjectKey a0) -> Object
9237  """
9238  return _IMP_kernel._TrivialDerivedDecorator_get_value(self, *args)
9239 
9240 
9241  def set_value(self, *args):
9242  """
9243  set_value(_TrivialDerivedDecorator self, FloatKey a0, IMP::Float a1)
9244  set_value(_TrivialDerivedDecorator self, IntKey a0, IMP::Int a1)
9245  set_value(_TrivialDerivedDecorator self, FloatsKey a0, IMP::Floats a1)
9246  set_value(_TrivialDerivedDecorator self, IntsKey a0, IMP::Ints a1)
9247  set_value(_TrivialDerivedDecorator self, StringKey a0, IMP::String a1)
9248  set_value(_TrivialDerivedDecorator self, ParticleIndexKey a0, Particle a1)
9249  set_value(_TrivialDerivedDecorator self, ObjectKey a0, Object a1)
9250  """
9251  return _IMP_kernel._TrivialDerivedDecorator_set_value(self, *args)
9252 
9253 
9254  def remove_attribute(self, *args):
9255  """
9256  remove_attribute(_TrivialDerivedDecorator self, FloatKey a0)
9257  remove_attribute(_TrivialDerivedDecorator self, IntKey a0)
9258  remove_attribute(_TrivialDerivedDecorator self, FloatsKey a0)
9259  remove_attribute(_TrivialDerivedDecorator self, IntsKey a0)
9260  remove_attribute(_TrivialDerivedDecorator self, StringKey a0)
9261  remove_attribute(_TrivialDerivedDecorator self, ParticleIndexKey a0)
9262  remove_attribute(_TrivialDerivedDecorator self, ObjectKey a0)
9263  """
9264  return _IMP_kernel._TrivialDerivedDecorator_remove_attribute(self, *args)
9265 
9266 
9267  def has_attribute(self, *args):
9268  """
9269  has_attribute(_TrivialDerivedDecorator self, FloatKey a0) -> bool
9270  has_attribute(_TrivialDerivedDecorator self, IntKey a0) -> bool
9271  has_attribute(_TrivialDerivedDecorator self, FloatsKey a0) -> bool
9272  has_attribute(_TrivialDerivedDecorator self, IntsKey a0) -> bool
9273  has_attribute(_TrivialDerivedDecorator self, StringKey a0) -> bool
9274  has_attribute(_TrivialDerivedDecorator self, ParticleIndexKey a0) -> bool
9275  has_attribute(_TrivialDerivedDecorator self, ObjectKey a0) -> bool
9276  """
9277  return _IMP_kernel._TrivialDerivedDecorator_has_attribute(self, *args)
9278 
9279 
9280  def get_derivative(self, a0):
9281  """get_derivative(_TrivialDerivedDecorator self, FloatKey a0) -> double"""
9282  return _IMP_kernel._TrivialDerivedDecorator_get_derivative(self, a0)
9283 
9284 
9285  def get_name(self):
9286  """get_name(_TrivialDerivedDecorator self) -> std::string"""
9287  return _IMP_kernel._TrivialDerivedDecorator_get_name(self)
9288 
9289 
9290  def clear_caches(self):
9291  """clear_caches(_TrivialDerivedDecorator self)"""
9292  return _IMP_kernel._TrivialDerivedDecorator_clear_caches(self)
9293 
9294 
9295  def set_name(self, a0):
9296  """set_name(_TrivialDerivedDecorator self, std::string a0)"""
9297  return _IMP_kernel._TrivialDerivedDecorator_set_name(self, a0)
9298 
9299 
9300  def set_check_level(self, a0):
9301  """set_check_level(_TrivialDerivedDecorator self, IMP::CheckLevel a0)"""
9302  return _IMP_kernel._TrivialDerivedDecorator_set_check_level(self, a0)
9303 
9304 
9305  def add_to_derivative(self, a0, a1, a2):
9306  """add_to_derivative(_TrivialDerivedDecorator self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
9307  return _IMP_kernel._TrivialDerivedDecorator_add_to_derivative(self, a0, a1, a2)
9308 
9309 
9310  def set_is_optimized(self, a0, a1):
9311  """set_is_optimized(_TrivialDerivedDecorator self, FloatKey a0, bool a1)"""
9312  return _IMP_kernel._TrivialDerivedDecorator_set_is_optimized(self, a0, a1)
9313 
9314 
9315  def get_is_optimized(self, a0):
9316  """get_is_optimized(_TrivialDerivedDecorator self, FloatKey a0) -> bool"""
9317  return _IMP_kernel._TrivialDerivedDecorator_get_is_optimized(self, a0)
9318 
9319 
9320  def get_check_level(self):
9321  """get_check_level(_TrivialDerivedDecorator self) -> IMP::CheckLevel"""
9322  return _IMP_kernel._TrivialDerivedDecorator_get_check_level(self)
9323 
9324 
9325  def __eq__(self, *args):
9326  """
9327  __eq__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
9328  __eq__(_TrivialDerivedDecorator self, Particle d) -> bool
9329  """
9330  return _IMP_kernel._TrivialDerivedDecorator___eq__(self, *args)
9331 
9332 
9333  def __ne__(self, *args):
9334  """
9335  __ne__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
9336  __ne__(_TrivialDerivedDecorator self, Particle d) -> bool
9337  """
9338  return _IMP_kernel._TrivialDerivedDecorator___ne__(self, *args)
9339 
9340 
9341  def __le__(self, *args):
9342  """
9343  __le__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
9344  __le__(_TrivialDerivedDecorator self, Particle d) -> bool
9345  """
9346  return _IMP_kernel._TrivialDerivedDecorator___le__(self, *args)
9347 
9348 
9349  def __lt__(self, *args):
9350  """
9351  __lt__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
9352  __lt__(_TrivialDerivedDecorator self, Particle d) -> bool
9353  """
9354  return _IMP_kernel._TrivialDerivedDecorator___lt__(self, *args)
9355 
9356 
9357  def __ge__(self, *args):
9358  """
9359  __ge__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
9360  __ge__(_TrivialDerivedDecorator self, Particle d) -> bool
9361  """
9362  return _IMP_kernel._TrivialDerivedDecorator___ge__(self, *args)
9363 
9364 
9365  def __gt__(self, *args):
9366  """
9367  __gt__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
9368  __gt__(_TrivialDerivedDecorator self, Particle d) -> bool
9369  """
9370  return _IMP_kernel._TrivialDerivedDecorator___gt__(self, *args)
9371 
9372 
9373  def __hash__(self):
9374  """__hash__(_TrivialDerivedDecorator self) -> std::size_t"""
9375  return _IMP_kernel._TrivialDerivedDecorator___hash__(self)
9376 
9377 
9378  def __str__(self):
9379  """__str__(_TrivialDerivedDecorator self) -> std::string"""
9380  return _IMP_kernel._TrivialDerivedDecorator___str__(self)
9381 
9382 
9383  def __repr__(self):
9384  """__repr__(_TrivialDerivedDecorator self) -> std::string"""
9385  return _IMP_kernel._TrivialDerivedDecorator___repr__(self)
9386 
9387  __swig_destroy__ = _IMP_kernel.delete__TrivialDerivedDecorator
9388  __del__ = lambda self: None
9389 _TrivialDerivedDecorator_swigregister = _IMP_kernel._TrivialDerivedDecorator_swigregister
9390 _TrivialDerivedDecorator_swigregister(_TrivialDerivedDecorator)
9391 
9392 def _TrivialDerivedDecorator_setup_particle(*args):
9393  """
9394  setup_particle(Model m, ParticleIndex pi) -> _TrivialDerivedDecorator
9395  _TrivialDerivedDecorator_setup_particle(_ParticleAdaptor decorator) -> _TrivialDerivedDecorator
9396  """
9397  return _IMP_kernel._TrivialDerivedDecorator_setup_particle(*args)
9398 
9399 def _TrivialDerivedDecorator_get_is_setup(*args):
9400  """
9401  get_is_setup(_ParticleAdaptor p) -> bool
9402  _TrivialDerivedDecorator_get_is_setup(Model m, ParticleIndex pi) -> bool
9403  """
9404  return _IMP_kernel._TrivialDerivedDecorator_get_is_setup(*args)
9405 
9406 class _TrivialTraitsDecorator(Decorator):
9407  """Proxy of C++ IMP::internal::_TrivialTraitsDecorator class"""
9408  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
9409 
9410  def get_decorator_traits(self):
9411  """get_decorator_traits(_TrivialTraitsDecorator self) -> StringKey"""
9412  return _IMP_kernel._TrivialTraitsDecorator_get_decorator_traits(self)
9413 
9414 
9415  def get_default_decorator_traits():
9416  """get_default_decorator_traits() -> StringKey"""
9417  return _IMP_kernel._TrivialTraitsDecorator_get_default_decorator_traits()
9418 
9419  get_default_decorator_traits = staticmethod(get_default_decorator_traits)
9420 
9421  def __init__(self, *args):
9422  """
9423  __init__(IMP::internal::_TrivialTraitsDecorator self) -> _TrivialTraitsDecorator
9424  __init__(IMP::internal::_TrivialTraitsDecorator self, Model m, ParticleIndex id, StringKey tr) -> _TrivialTraitsDecorator
9425  __init__(IMP::internal::_TrivialTraitsDecorator self, Model m, ParticleIndex id) -> _TrivialTraitsDecorator
9426  __init__(IMP::internal::_TrivialTraitsDecorator self, _ParticleAdaptor d, StringKey tr) -> _TrivialTraitsDecorator
9427  __init__(IMP::internal::_TrivialTraitsDecorator self, _ParticleAdaptor d) -> _TrivialTraitsDecorator
9428  """
9429  this = _IMP_kernel.new__TrivialTraitsDecorator(*args)
9430  try:
9431  self.this.append(this)
9432  except:
9433  self.this = this
9434 
9435  def show(self, *args):
9436  """
9437  show(_TrivialTraitsDecorator self, _ostream out)
9438  show(_TrivialTraitsDecorator self)
9439  """
9440  return _IMP_kernel._TrivialTraitsDecorator_show(self, *args)
9441 
9442 
9443  def setup_particle(*args):
9444  """
9445  setup_particle(Model m, ParticleIndex pi, StringKey tr) -> _TrivialTraitsDecorator
9446  setup_particle(Model m, ParticleIndex pi) -> _TrivialTraitsDecorator
9447  setup_particle(_ParticleAdaptor d, StringKey tr) -> _TrivialTraitsDecorator
9448  setup_particle(_ParticleAdaptor d) -> _TrivialTraitsDecorator
9449  """
9450  return _IMP_kernel._TrivialTraitsDecorator_setup_particle(*args)
9451 
9452  setup_particle = staticmethod(setup_particle)
9453 
9454  def get_is_setup(*args):
9455  """
9456  get_is_setup(_ParticleAdaptor p, StringKey tr) -> bool
9457  get_is_setup(_ParticleAdaptor p) -> bool
9458  get_is_setup(Model m, ParticleIndex pi, StringKey k) -> bool
9459  get_is_setup(Model m, ParticleIndex pi) -> bool
9460  """
9461  return _IMP_kernel._TrivialTraitsDecorator_get_is_setup(*args)
9462 
9463  get_is_setup = staticmethod(get_is_setup)
9464 
9465  def get_default_key():
9466  """get_default_key() -> StringKey"""
9467  return _IMP_kernel._TrivialTraitsDecorator_get_default_key()
9468 
9469  get_default_key = staticmethod(get_default_key)
9470 
9471  def add_attribute(self, *args):
9472  """
9473  add_attribute(_TrivialTraitsDecorator self, FloatKey k, IMP::Float v, bool opt)
9474  add_attribute(_TrivialTraitsDecorator self, FloatKey a0, IMP::Float a1)
9475  add_attribute(_TrivialTraitsDecorator self, IntKey a0, IMP::Int a1)
9476  add_attribute(_TrivialTraitsDecorator self, FloatsKey a0, IMP::Floats a1)
9477  add_attribute(_TrivialTraitsDecorator self, IntsKey a0, IMP::Ints a1)
9478  add_attribute(_TrivialTraitsDecorator self, StringKey a0, IMP::String a1)
9479  add_attribute(_TrivialTraitsDecorator self, ParticleIndexKey a0, Particle a1)
9480  add_attribute(_TrivialTraitsDecorator self, ObjectKey a0, Object a1)
9481  """
9482  return _IMP_kernel._TrivialTraitsDecorator_add_attribute(self, *args)
9483 
9484 
9485  def get_value(self, *args):
9486  """
9487  get_value(_TrivialTraitsDecorator self, FloatKey a0) -> IMP::Float
9488  get_value(_TrivialTraitsDecorator self, IntKey a0) -> IMP::Int
9489  get_value(_TrivialTraitsDecorator self, FloatsKey a0) -> IMP::Floats
9490  get_value(_TrivialTraitsDecorator self, IntsKey a0) -> IMP::Ints
9491  get_value(_TrivialTraitsDecorator self, StringKey a0) -> IMP::String
9492  get_value(_TrivialTraitsDecorator self, ParticleIndexKey a0) -> Particle
9493  get_value(_TrivialTraitsDecorator self, ObjectKey a0) -> Object
9494  """
9495  return _IMP_kernel._TrivialTraitsDecorator_get_value(self, *args)
9496 
9497 
9498  def set_value(self, *args):
9499  """
9500  set_value(_TrivialTraitsDecorator self, FloatKey a0, IMP::Float a1)
9501  set_value(_TrivialTraitsDecorator self, IntKey a0, IMP::Int a1)
9502  set_value(_TrivialTraitsDecorator self, FloatsKey a0, IMP::Floats a1)
9503  set_value(_TrivialTraitsDecorator self, IntsKey a0, IMP::Ints a1)
9504  set_value(_TrivialTraitsDecorator self, StringKey a0, IMP::String a1)
9505  set_value(_TrivialTraitsDecorator self, ParticleIndexKey a0, Particle a1)
9506  set_value(_TrivialTraitsDecorator self, ObjectKey a0, Object a1)
9507  """
9508  return _IMP_kernel._TrivialTraitsDecorator_set_value(self, *args)
9509 
9510 
9511  def remove_attribute(self, *args):
9512  """
9513  remove_attribute(_TrivialTraitsDecorator self, FloatKey a0)
9514  remove_attribute(_TrivialTraitsDecorator self, IntKey a0)
9515  remove_attribute(_TrivialTraitsDecorator self, FloatsKey a0)
9516  remove_attribute(_TrivialTraitsDecorator self, IntsKey a0)
9517  remove_attribute(_TrivialTraitsDecorator self, StringKey a0)
9518  remove_attribute(_TrivialTraitsDecorator self, ParticleIndexKey a0)
9519  remove_attribute(_TrivialTraitsDecorator self, ObjectKey a0)
9520  """
9521  return _IMP_kernel._TrivialTraitsDecorator_remove_attribute(self, *args)
9522 
9523 
9524  def has_attribute(self, *args):
9525  """
9526  has_attribute(_TrivialTraitsDecorator self, FloatKey a0) -> bool
9527  has_attribute(_TrivialTraitsDecorator self, IntKey a0) -> bool
9528  has_attribute(_TrivialTraitsDecorator self, FloatsKey a0) -> bool
9529  has_attribute(_TrivialTraitsDecorator self, IntsKey a0) -> bool
9530  has_attribute(_TrivialTraitsDecorator self, StringKey a0) -> bool
9531  has_attribute(_TrivialTraitsDecorator self, ParticleIndexKey a0) -> bool
9532  has_attribute(_TrivialTraitsDecorator self, ObjectKey a0) -> bool
9533  """
9534  return _IMP_kernel._TrivialTraitsDecorator_has_attribute(self, *args)
9535 
9536 
9537  def get_derivative(self, a0):
9538  """get_derivative(_TrivialTraitsDecorator self, FloatKey a0) -> double"""
9539  return _IMP_kernel._TrivialTraitsDecorator_get_derivative(self, a0)
9540 
9541 
9542  def get_name(self):
9543  """get_name(_TrivialTraitsDecorator self) -> std::string"""
9544  return _IMP_kernel._TrivialTraitsDecorator_get_name(self)
9545 
9546 
9547  def clear_caches(self):
9548  """clear_caches(_TrivialTraitsDecorator self)"""
9549  return _IMP_kernel._TrivialTraitsDecorator_clear_caches(self)
9550 
9551 
9552  def set_name(self, a0):
9553  """set_name(_TrivialTraitsDecorator self, std::string a0)"""
9554  return _IMP_kernel._TrivialTraitsDecorator_set_name(self, a0)
9555 
9556 
9557  def set_check_level(self, a0):
9558  """set_check_level(_TrivialTraitsDecorator self, IMP::CheckLevel a0)"""
9559  return _IMP_kernel._TrivialTraitsDecorator_set_check_level(self, a0)
9560 
9561 
9562  def add_to_derivative(self, a0, a1, a2):
9563  """add_to_derivative(_TrivialTraitsDecorator self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
9564  return _IMP_kernel._TrivialTraitsDecorator_add_to_derivative(self, a0, a1, a2)
9565 
9566 
9567  def set_is_optimized(self, a0, a1):
9568  """set_is_optimized(_TrivialTraitsDecorator self, FloatKey a0, bool a1)"""
9569  return _IMP_kernel._TrivialTraitsDecorator_set_is_optimized(self, a0, a1)
9570 
9571 
9572  def get_is_optimized(self, a0):
9573  """get_is_optimized(_TrivialTraitsDecorator self, FloatKey a0) -> bool"""
9574  return _IMP_kernel._TrivialTraitsDecorator_get_is_optimized(self, a0)
9575 
9576 
9577  def get_check_level(self):
9578  """get_check_level(_TrivialTraitsDecorator self) -> IMP::CheckLevel"""
9579  return _IMP_kernel._TrivialTraitsDecorator_get_check_level(self)
9580 
9581 
9582  def __eq__(self, *args):
9583  """
9584  __eq__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
9585  __eq__(_TrivialTraitsDecorator self, Particle d) -> bool
9586  """
9587  return _IMP_kernel._TrivialTraitsDecorator___eq__(self, *args)
9588 
9589 
9590  def __ne__(self, *args):
9591  """
9592  __ne__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
9593  __ne__(_TrivialTraitsDecorator self, Particle d) -> bool
9594  """
9595  return _IMP_kernel._TrivialTraitsDecorator___ne__(self, *args)
9596 
9597 
9598  def __le__(self, *args):
9599  """
9600  __le__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
9601  __le__(_TrivialTraitsDecorator self, Particle d) -> bool
9602  """
9603  return _IMP_kernel._TrivialTraitsDecorator___le__(self, *args)
9604 
9605 
9606  def __lt__(self, *args):
9607  """
9608  __lt__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
9609  __lt__(_TrivialTraitsDecorator self, Particle d) -> bool
9610  """
9611  return _IMP_kernel._TrivialTraitsDecorator___lt__(self, *args)
9612 
9613 
9614  def __ge__(self, *args):
9615  """
9616  __ge__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
9617  __ge__(_TrivialTraitsDecorator self, Particle d) -> bool
9618  """
9619  return _IMP_kernel._TrivialTraitsDecorator___ge__(self, *args)
9620 
9621 
9622  def __gt__(self, *args):
9623  """
9624  __gt__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
9625  __gt__(_TrivialTraitsDecorator self, Particle d) -> bool
9626  """
9627  return _IMP_kernel._TrivialTraitsDecorator___gt__(self, *args)
9628 
9629 
9630  def __hash__(self):
9631  """__hash__(_TrivialTraitsDecorator self) -> std::size_t"""
9632  return _IMP_kernel._TrivialTraitsDecorator___hash__(self)
9633 
9634 
9635  def __str__(self):
9636  """__str__(_TrivialTraitsDecorator self) -> std::string"""
9637  return _IMP_kernel._TrivialTraitsDecorator___str__(self)
9638 
9639 
9640  def __repr__(self):
9641  """__repr__(_TrivialTraitsDecorator self) -> std::string"""
9642  return _IMP_kernel._TrivialTraitsDecorator___repr__(self)
9643 
9644  __swig_destroy__ = _IMP_kernel.delete__TrivialTraitsDecorator
9645  __del__ = lambda self: None
9646 _TrivialTraitsDecorator_swigregister = _IMP_kernel._TrivialTraitsDecorator_swigregister
9647 _TrivialTraitsDecorator_swigregister(_TrivialTraitsDecorator)
9648 
9649 def _TrivialTraitsDecorator_get_default_decorator_traits():
9650  """_TrivialTraitsDecorator_get_default_decorator_traits() -> StringKey"""
9651  return _IMP_kernel._TrivialTraitsDecorator_get_default_decorator_traits()
9652 
9653 def _TrivialTraitsDecorator_setup_particle(*args):
9654  """
9655  setup_particle(Model m, ParticleIndex pi, StringKey tr) -> _TrivialTraitsDecorator
9656  setup_particle(Model m, ParticleIndex pi) -> _TrivialTraitsDecorator
9657  setup_particle(_ParticleAdaptor d, StringKey tr) -> _TrivialTraitsDecorator
9658  _TrivialTraitsDecorator_setup_particle(_ParticleAdaptor d) -> _TrivialTraitsDecorator
9659  """
9660  return _IMP_kernel._TrivialTraitsDecorator_setup_particle(*args)
9661 
9662 def _TrivialTraitsDecorator_get_is_setup(*args):
9663  """
9664  get_is_setup(_ParticleAdaptor p, StringKey tr) -> bool
9665  get_is_setup(_ParticleAdaptor p) -> bool
9666  get_is_setup(Model m, ParticleIndex pi, StringKey k) -> bool
9667  _TrivialTraitsDecorator_get_is_setup(Model m, ParticleIndex pi) -> bool
9668  """
9669  return _IMP_kernel._TrivialTraitsDecorator_get_is_setup(*args)
9670 
9671 def _TrivialTraitsDecorator_get_default_key():
9672  """_TrivialTraitsDecorator_get_default_key() -> StringKey"""
9673  return _IMP_kernel._TrivialTraitsDecorator_get_default_key()
9674 
9675 
9676 def __lshift__(*args):
9677  """
9678  __lshift__(_ostream out, _TrivialDecorator n) -> _ostream
9679  __lshift__(_ostream out, _TrivialDerivedDecorator n) -> _ostream
9680  __lshift__(_ostream out, _TrivialTraitsDecorator n) -> _ostream
9681  """
9682  return _IMP_kernel.__lshift__(*args)
9683 class _ConstOptimizer(Optimizer):
9684  """Proxy of C++ IMP::internal::_ConstOptimizer class"""
9685  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
9686 
9687  def __init__(self, m):
9688  """__init__(IMP::internal::_ConstOptimizer self, Model m) -> _ConstOptimizer"""
9689  this = _IMP_kernel.new__ConstOptimizer(m)
9690  try:
9691  self.this.append(this)
9692  except:
9693  self.this = this
9694 
9695  def do_optimize(self, max_steps):
9696  """do_optimize(_ConstOptimizer self, unsigned int max_steps) -> IMP::Float"""
9697  return _IMP_kernel._ConstOptimizer_do_optimize(self, max_steps)
9698 
9699 
9700  def get_version_info(self):
9701  """get_version_info(_ConstOptimizer self) -> VersionInfo"""
9702  return _IMP_kernel._ConstOptimizer_get_version_info(self)
9703 
9704 
9705  def __str__(self):
9706  """__str__(_ConstOptimizer self) -> std::string"""
9707  return _IMP_kernel._ConstOptimizer___str__(self)
9708 
9709 
9710  def __repr__(self):
9711  """__repr__(_ConstOptimizer self) -> std::string"""
9712  return _IMP_kernel._ConstOptimizer___repr__(self)
9713 
9714 
9715  @staticmethod
9716  def get_from(o):
9717  return _object_cast_to__ConstOptimizer(o)
9718 
9719 _ConstOptimizer_swigregister = _IMP_kernel._ConstOptimizer_swigregister
9720 _ConstOptimizer_swigregister(_ConstOptimizer)
9721 
9722 
9723 def get_particle(p):
9724  """get_particle(Particle p) -> Particle"""
9725  return _IMP_kernel.get_particle(p)
9726 
9727 def _decorator_test(p):
9728  """_decorator_test(Particle p)"""
9729  return _IMP_kernel._decorator_test(p)
9730 
9731 def _overloaded_decorator(*args):
9732  """
9733  _overloaded_decorator(_TrivialDecorator a) -> int
9734  _overloaded_decorator(_TrivialDerivedDecorator a) -> int
9735  """
9736  return _IMP_kernel._overloaded_decorator(*args)
9737 
9738 def _take_particles(*args):
9739  """
9740  _take_particles(IMP::Particles const & ps) -> unsigned int
9741  _take_particles(Model m, IMP::Particles const & ps) -> unsigned int
9742  _take_particles(Model m, IMP::Particles const & ps, TextOutput out) -> unsigned int
9743  """
9744  return _IMP_kernel._take_particles(*args)
9745 
9746 def _give_particles(m):
9747  """_give_particles(Model m) -> IMP::Particles const &"""
9748  return _IMP_kernel._give_particles(m)
9749 
9750 def _pass_particles(ps):
9751  """_pass_particles(IMP::Particles const & ps) -> IMP::Particles const &"""
9752  return _IMP_kernel._pass_particles(ps)
9753 
9754 def _pass_particle(ps):
9755  """_pass_particle(Particle ps) -> Particle"""
9756  return _IMP_kernel._pass_particle(ps)
9757 
9758 def _pass_particle_pair(pp):
9759  """_pass_particle_pair(IMP::ParticlePair const & pp) -> IMP::ParticlePair const &"""
9760  return _IMP_kernel._pass_particle_pair(pp)
9761 
9762 def _give_particles_copy(m):
9763  """_give_particles_copy(Model m) -> IMP::Particles"""
9764  return _IMP_kernel._give_particles_copy(m)
9765 
9766 def _pass_float_keys(input):
9767  """_pass_float_keys(IMP::FloatKeys const & input) -> IMP::FloatKeys"""
9768  return _IMP_kernel._pass_float_keys(input)
9769 
9770 def _pass(*args):
9771  """
9772  _pass(IMP::Particles const & p) -> IMP::Particles const
9773  _pass(IMP::Restraints const & p) -> IMP::Restraints const &
9774  """
9775  return _IMP_kernel._pass(*args)
9776 
9777 def _pass_decorators(p):
9778  """_pass_decorators(IMP::internal::_TrivialDecorators const & p) -> IMP::internal::_TrivialDecorators const &"""
9779  return _IMP_kernel._pass_decorators(p)
9780 
9781 def _pass_decorator_traits(p):
9782  """_pass_decorator_traits(IMP::internal::_TrivialTraitsDecorators const & p) -> IMP::internal::_TrivialTraitsDecorators const &"""
9783  return _IMP_kernel._pass_decorator_traits(p)
9784 
9785 def _pass_particle_pairs(p):
9786  """_pass_particle_pairs(IMP::ParticlePairsTemp const & p) -> IMP::ParticlePairsTemp"""
9787  return _IMP_kernel._pass_particle_pairs(p)
9788 
9789 def _pass_particle_index_pairs(p):
9790  """_pass_particle_index_pairs(IMP::ParticleIndexPairs const & p) -> IMP::ParticleIndexPairs"""
9791  return _IMP_kernel._pass_particle_index_pairs(p)
9792 
9793 def _pass_model_objects(p):
9794  """_pass_model_objects(IMP::ModelObjectsTemp const & p) -> IMP::ModelObjectsTemp"""
9795  return _IMP_kernel._pass_model_objects(p)
9796 
9797 def _pass_particles_temps(ps):
9798  """_pass_particles_temps(IMP::ParticlesTemps const & ps) -> IMP::ParticlesTemps"""
9799  return _IMP_kernel._pass_particles_temps(ps)
9800 
9801 def _test_overload(*args):
9802  """
9803  _test_overload(IMP::Particles const & ps) -> int
9804  _test_overload(IMP::Restraints const & ps) -> int
9805  """
9806  return _IMP_kernel._test_overload(*args)
9807 
9808 def _get_range(m, k):
9809  """_get_range(Model m, FloatKey k) -> IMP::FloatRange"""
9810  return _IMP_kernel._get_range(m, k)
9811 
9812 def _create_particles_from_pdb(name, m):
9813  """_create_particles_from_pdb(std::string name, Model m) -> IMP::ParticleIndexes"""
9814  return _IMP_kernel._create_particles_from_pdb(name, m)
9815 class _LogPairScore(PairScore):
9816  """Proxy of C++ IMP::internal::_LogPairScore class"""
9817  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
9818  __repr__ = _swig_repr
9819 
9820  def __init__(self):
9821  """__init__(IMP::internal::_LogPairScore self) -> _LogPairScore"""
9822  this = _IMP_kernel.new__LogPairScore()
9823  try:
9824  self.this.append(this)
9825  except:
9826  self.this = this
9827 
9828  def do_get_inputs(self, arg2, arg3):
9829  """do_get_inputs(_LogPairScore self, Model arg2, IMP::ParticleIndexes const & arg3) -> IMP::ModelObjectsTemp"""
9830  return _IMP_kernel._LogPairScore_do_get_inputs(self, arg2, arg3)
9831 
9832 
9833  def get_version_info(self):
9834  """get_version_info(_LogPairScore self) -> VersionInfo"""
9835  return _IMP_kernel._LogPairScore_get_version_info(self)
9836 
9837 
9838  def get_particle_pairs(self):
9839  """get_particle_pairs(_LogPairScore self) -> IMP::ParticlePairsTemp"""
9840  return _IMP_kernel._LogPairScore_get_particle_pairs(self)
9841 
9842 
9843  def clear(self):
9844  """clear(_LogPairScore self)"""
9845  return _IMP_kernel._LogPairScore_clear(self)
9846 
9847 
9848  def get_contains(self, pp):
9849  """get_contains(_LogPairScore self, IMP::ParticlePair const & pp) -> bool"""
9850  return _IMP_kernel._LogPairScore_get_contains(self, pp)
9851 
9852 _LogPairScore_swigregister = _IMP_kernel._LogPairScore_swigregister
9853 _LogPairScore_swigregister(_LogPairScore)
9854 
9855 
9856 def _overloaded_particles(*args):
9857  """
9858  _overloaded_particles(Particle arg1)
9859  _overloaded_particles(IMP::Particles const & arg1)
9860  _overloaded_particles(IMP::ParticlesTemp const & arg1)
9861  _overloaded_particles(Model arg1, IMP::ParticleIndexes const & arg2)
9862  _overloaded_particles(IMP::internal::_TrivialDecorators const & arg1)
9863  _overloaded_particles(_TrivialDecorator arg1)
9864  """
9865  return _IMP_kernel._overloaded_particles(*args)
9866 class _ImplicitParticles(object):
9867  """Proxy of C++ IMP::internal::_ImplicitParticles class"""
9868  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
9869  __repr__ = _swig_repr
9870 
9871  def __init__(self, *args):
9872  """
9873  __init__(IMP::internal::_ImplicitParticles self, Particle arg2) -> _ImplicitParticles
9874  __init__(IMP::internal::_ImplicitParticles self, IMP::Particles const & arg2) -> _ImplicitParticles
9875  __init__(IMP::internal::_ImplicitParticles self, IMP::ParticlesTemp const & arg2) -> _ImplicitParticles
9876  __init__(IMP::internal::_ImplicitParticles self, Model arg2, IMP::ParticleIndexes const & arg3) -> _ImplicitParticles
9877  __init__(IMP::internal::_ImplicitParticles self, IMP::internal::_TrivialDecorators const & arg2) -> _ImplicitParticles
9878  __init__(IMP::internal::_ImplicitParticles self, _TrivialDecorator arg2) -> _ImplicitParticles
9879  """
9880  this = _IMP_kernel.new__ImplicitParticles(*args)
9881  try:
9882  self.this.append(this)
9883  except:
9884  self.this = this
9885  __swig_destroy__ = _IMP_kernel.delete__ImplicitParticles
9886  __del__ = lambda self: None
9887 _ImplicitParticles_swigregister = _IMP_kernel._ImplicitParticles_swigregister
9888 _ImplicitParticles_swigregister(_ImplicitParticles)
9889 
9890 
9891 def _implicit_particles(arg1):
9892  """_implicit_particles(_ImplicitParticles arg1)"""
9893  return _IMP_kernel._implicit_particles(arg1)
9894 
9895 def _take_particle_adaptor(pa):
9896  """_take_particle_adaptor(_ParticleAdaptor pa) -> ParticleIndex"""
9897  return _IMP_kernel._take_particle_adaptor(pa)
9898 
9899 def _take_particle_indexes_adaptor(pa):
9900  """_take_particle_indexes_adaptor(_ParticleIndexesAdaptor pa) -> IMP::ParticleIndexes"""
9901  return _IMP_kernel._take_particle_indexes_adaptor(pa)
9902 class ScopedSetFloatAttribute(_RAII):
9903  """Proxy of C++ IMP::ScopedSetAttribute<(FloatKey,IMP::Float)> class"""
9904  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
9905 
9906  def __init__(self, *args):
9907  """
9908  __init__(IMP::ScopedSetAttribute<(FloatKey,IMP::Float)> self) -> ScopedSetFloatAttribute
9909  __init__(IMP::ScopedSetAttribute<(FloatKey,IMP::Float)> self, Particle p, FloatKey key, double const & value) -> ScopedSetFloatAttribute
9910  """
9911  this = _IMP_kernel.new_ScopedSetFloatAttribute(*args)
9912  try:
9913  self.this.append(this)
9914  except:
9915  self.this = this
9916 
9917  def set(self, p, key, value):
9918  """set(ScopedSetFloatAttribute self, Particle p, FloatKey key, double const & value)"""
9919  return _IMP_kernel.ScopedSetFloatAttribute_set(self, p, key, value)
9920 
9921 
9922  def reset(self):
9923  """reset(ScopedSetFloatAttribute self)"""
9924  return _IMP_kernel.ScopedSetFloatAttribute_reset(self)
9925 
9926  __swig_destroy__ = _IMP_kernel.delete_ScopedSetFloatAttribute
9927  __del__ = lambda self: None
9928 
9929  def show(self, *args):
9930  """
9931  show(ScopedSetFloatAttribute self, _ostream out)
9932  show(ScopedSetFloatAttribute self)
9933  """
9934  return _IMP_kernel.ScopedSetFloatAttribute_show(self, *args)
9935 
9936 
9937  def __str__(self):
9938  """__str__(ScopedSetFloatAttribute self) -> std::string"""
9939  return _IMP_kernel.ScopedSetFloatAttribute___str__(self)
9940 
9941 
9942  def __repr__(self):
9943  """__repr__(ScopedSetFloatAttribute self) -> std::string"""
9944  return _IMP_kernel.ScopedSetFloatAttribute___repr__(self)
9945 
9946 ScopedSetFloatAttribute_swigregister = _IMP_kernel.ScopedSetFloatAttribute_swigregister
9947 ScopedSetFloatAttribute_swigregister(ScopedSetFloatAttribute)
9948 
9949 
9950 def _get_module_data_path(module, file_name):
9951  """_get_module_data_path(std::string module, std::string file_name) -> std::string"""
9952  return _IMP_kernel._get_module_data_path(module, file_name)
9953 
9954 def _get_module_example_path(module, file_name):
9955  """_get_module_example_path(std::string module, std::string file_name) -> std::string"""
9956  return _IMP_kernel._get_module_example_path(module, file_name)
9957 
9958 #used_modules=[]
9959 #def show_used_modules():
9960 # for m in used_modules:
9961 # print "%-20s %s" % (m.get_module(), m.get_version())
9962 
9963 # Ensure that Windows gets the PATH set to include anything in the library
9964 # search path
9965 if sys.platform == 'win32' and 'IMP_LD_PATH' in os.environ:
9966  dirs = os.environ['IMP_LD_PATH'].split(":")
9967  pathcomps = os.environ['PATH'].split(";")
9968  for d in dirs:
9969  if d not in pathcomps:
9970  os.environ['PATH'] = d + ';' + os.environ['PATH']
9971 
9972 
9973 
9974 import sys
9975 import os
9976 
9977 class CommandDispatcher(object):
9978  """Allow command line tools to easily implement multiple commands.
9979  Typically, an IMP command line tool will use an instance of this class
9980  to provide a consistent interface to multiple distinct commands
9981  from a single binary, rather than providing a potentially large
9982  number of binaries. This is similar to the way a number of common
9983  command line tools outside of IMP function (e.g. Git provides a single
9984  `git` tool which implements multiple commands - `git add`, `git commit`,
9985  `git push` and so on).
9986 
9987  Each command is implemented with a Python module of the same name
9988  that can be imported from the module (for example, if `module_name`
9989  is `IMP.foo`, the `bar` command is provided by the `IMP.foo.bar` Python
9990  module, which would usually be found as `modules/foo/pyext/src/bar.py`).
9991  Each such module should have a docstring and a `%main()` method
9992  that takes no arguments (the module should also call its `%main()` method
9993  if it is run directly, i.e. with something like
9994  `if __name__=="__main__": %main()`). The encompassing module
9995  (`IMP.foo` in the example) should define `_all_commands` as a Python
9996  list of all valid commands.
9997 
9998  See the `multifit` and `cnmultifit` command line tools for example
9999  usage.
10000  """
10001 
10002  def __init__(self, short_help, long_help, module_name):
10003  """Constructor.
10004  @param short_help A few words that describe the command line tool.
10005  @param long_help Longer text, used in the `help` command.
10006  @param module_name Name of the module (e.g. `IMP.foo`) that
10007  implements the commands.
10008  """
10009  self.short_help = short_help
10010  self.long_help = long_help
10011  self.module_name = module_name
10012  self._all_commands = self.import_module()._all_commands
10013  self._progname = os.path.basename(sys.argv[0])
10014 
10015  def main(self):
10016  """Call this method to act upon the user-provided command line"""
10017  if len(sys.argv) <= 1:
10018  print(self.short_help + " Use '%s help' for help." % self._progname)
10019  else:
10020  command = sys.argv[1]
10021  if command in ('help', '--help', '-h'):
10022  if len(sys.argv) == 3:
10023  self.show_command_help(sys.argv[2])
10024  else:
10025  self.show_help()
10026  elif command == '--version':
10027  self.show_version()
10028  elif command in self._all_commands:
10029  self.do_command(command)
10030  else:
10031  self.unknown_command(command)
10032 
10033  def import_module(self, mod=None):
10034  modname = self.module_name
10035  if mod is not None:
10036  modname += "." + mod
10037  return __import__(modname, {}, {}, [''])
10038 
10039  def unknown_command(self, command):
10040  print("Unknown command: '%s'" % command)
10041  print("Use '%s help' for help." % self._progname)
10042  sys.exit(1)
10043 
10044  def _get_version(self):
10045  return self.import_module().get_module_version()
10046 
10047  def show_version(self):
10048  print(self._progname + ' ' + self._get_version())
10049 
10050  def show_help(self):
10051  ver = self._get_version()
10052  print("%s, version %s." % (self._progname, ver))
10053  print(self.long_help + """
10054 
10055 This program is part of IMP, the Integrative Modeling Platform,
10056 which is Copyright 2007-2021 IMP Inventors.
10057 For additional information about IMP, see <https://integrativemodeling.org>.
10058 
10059 Usage: %s <command> [options] [args]
10060 
10061 Commands:""" % self._progname)
10062  commands = self._all_commands[:] + ['help']
10063  commands.sort()
10064  cmdlen = max([len(c) for c in commands])
10065  for c in commands:
10066  if c == 'help':
10067  doc = 'Get help on using %s.' % self._progname
10068  else:
10069  doc = self.import_module(c).__doc__ or "<no help>"
10070  c += ' ' * (cmdlen - len(c))
10071  print(' ' + c + ' ' + doc)
10072  print("""
10073 Use "%s help <command>" for detailed help on any command
10074  or "%s --version" to see the version number.""" % (self._progname,
10075  self._progname))
10076 
10077  def do_command(self, command):
10078  mod = self.import_module(command)
10079  sys.argv[0] = self._progname + ' ' + command
10080  del sys.argv[1]
10081  mod.main()
10082 
10083  def show_command_help(self, command):
10084  if command == 'help':
10085  self.show_help()
10086  elif command in self._all_commands or command == 'help':
10087  mod = self.import_module(command)
10088  sys.argv = [self._progname + ' ' + command, '--help']
10089  mod.main()
10090  else:
10091  self.unknown_command(command)
10092 
10093 
10094 
10095 
10096 def get_networkx_graph(ig):
10097  import networkx
10098  g = networkx.DiGraph()
10099  if len(ig.get_vertices()) == 0:
10100  return g
10101 
10102  class NodeWrapper:
10103 
10104  def __init__(self, p):
10105  self.p = p
10106 
10107  def __str__(self):
10108  return self.p.get_name()
10109 
10110  def __call__(self, name):
10111  return self.p.__call__(name)
10112 
10113  for vi in ig.get_vertices():
10114  n = ig.get_vertex_name(vi)
10115  g.add_node(NodeWrapper(n))
10116  for vi in ig.get_vertices():
10117  n = ig.get_vertex_name(vi)
10118  for ni in ig.get_out_neighbors(vi):
10119  nn = ig.get_vertex_name(ni)
10120  g.add_edge(NodeWrapper(n), NodeWrapper(nn))
10121  return g
10122 
10123 
10124 def show_altgraph(g):
10125  def clean(name):
10126  try:
10127  n0 = name.get_name()
10128  except:
10129  n0 = str(name)
10130  n1 = str(n0).replace('"', '')
10131  n2 = n1.replace("\n", '')
10132  return n2
10133  import altgraph
10134  from altgraph import Graph, Dot
10135  graph = Graph.Graph()
10136  for i, v in enumerate(g.get_vertices()):
10137  graph.add_node(i) # , node_data=g.get_vertex_name(v)
10138  for i, v in enumerate(g.get_vertices()):
10139  for n in g.get_out_neighbors(v):
10140  graph.add_edge(v, n)
10141  dot = Dot.Dot(graph) # , graph_type="digraph"
10142  for i, v in enumerate(g.get_vertices()):
10143  dot.node_style(i, label=clean(g.get_vertex_name(v)))
10144  dot.display()
10145 
10146 
10147 def show_graphviz(g):
10148  tfn = create_temporary_file_name("graph", ".dot")
10149  tfon = create_temporary_file_name("graph", ".pdf")
10150  st = g.get_graphviz_string()
10151  open(tfn, "w").write(st)
10152  try:
10153  import subprocess
10154  except ImportError:
10155  import sys
10156  sys.stderr.write("Cannot run dot on Python 2.3 systems.\n")
10157  return
10158  try:
10159  print("running dot")
10160  sp = subprocess.Popen(["dot", "-Tpdf", tfn, "-o" + tfon])
10161  sp.wait()
10162  except:
10163  import sys
10164  sys.stderr.write("The dot command from the graphviz package was not found. Please make sure it is in the PATH passed to IMP.\n")
10165  return
10166  import platform
10167  if platform.system() == "Darwin":
10168  cmd = ["open"]
10169  else:
10170  cmd = ["gv", "acroread", "xpdf"]
10171  success = False
10172  for c in cmd:
10173  print("launching viewer " + c)
10174  try:
10175  subprocess.check_call([c, tfon])
10176  success = True
10177  break
10178  except:
10179  pass
10180  if not success:
10181  print("Could not display file. It is saved at " + tfon)
10182  return tfon
10183 
10184 
10185 
10186 
10187 import functools
10188 import contextlib
10189 
10190 def deprecated_module(version, module, help_message):
10191  """Mark a Python module as deprecated.
10192  @note The `module` argument would normally be `__name__`.
10193  @see [deprecation support](@ref deprecation)."""
10195  "Module %s is deprecated. %s\n" % (module, help_message))
10196 
10197 def deprecated_object(version, help_message):
10198  """Python decorator to mark a class as deprecated.
10199  @see [deprecation support](@ref deprecation)."""
10200  def wrapper(obj):
10201  orig_init = obj.__init__
10202 # Don't try to copy __module__ since __init__ may not have it
10203 # (e.g. if we subclassed object but didn't override __init__)
10204  @functools.wraps(orig_init, ('__name__', '__doc__'))
10205  def __init__(obj, *args, **keys):
10206  handle_use_deprecated("Object %s is deprecated. %s\n"
10207  % (type(obj), help_message))
10208  orig_init(obj, *args, **keys)
10209  obj.__init__ = __init__
10210  return obj
10211  return wrapper
10212 
10213 def deprecated_method(version, help_message):
10214  """Python decorator to mark a method as deprecated.
10215  @see [deprecation support](@ref deprecation)."""
10216  def out_wrapper(obj):
10217  @functools.wraps(obj)
10218  def wrapper(cls, *args, **keys):
10219  handle_use_deprecated("Method %s in %s is deprecated. %s\n"
10220  % (obj.__name__, type(cls), help_message))
10221  return obj(cls, *args, **keys)
10222  return wrapper
10223  return out_wrapper
10224 
10225 def deprecated_function(version, help_message):
10226  """Python decorator to mark a function as deprecated.
10227  @see [deprecation support](@ref deprecation)."""
10228  def out_wrapper(obj):
10229  @functools.wraps(obj)
10230  def wrapper(*args, **keys):
10231  handle_use_deprecated("Function %s is deprecated. %s\n"
10232  % (obj.__name__, help_message))
10233  return obj(*args, **keys)
10234  return wrapper
10235  return out_wrapper
10236 
10237 @contextlib.contextmanager
10238 def allow_deprecated(allow=True):
10239  """Context manager to temporarily allow (or disallow) deprecated code.
10240  @see [deprecation support](@ref deprecation)."""
10242  set_deprecation_exceptions(not allow)
10243  yield
10245 
10246 
10247 def _get_all_flags(ntokens):
10248  """_get_all_flags(unsigned int ntokens) -> IMP::Strings"""
10249  return _IMP_kernel._get_all_flags(ntokens)
10250 
10251 def _print_internal_help(out, description):
10252  """_print_internal_help(_ostream out, std::string description)"""
10253  return _IMP_kernel._print_internal_help(out, description)
10254 
10255 
10256 import argparse
10257 import sys
10258 
10259 class _PassThroughAction(argparse.Action):
10260  """Pass an argument through to the IMP Boost parser"""
10261  def __call__(self, parser, namespace, values, option_string=None):
10262  parser._boost_command_line.append(option_string)
10263  if values != []:
10264  parser._boost_command_line.append(values)
10265 # Terminate processing immediately if necessary (otherwise argparse
10266 # may fail if we're missing positional arguments)
10267  if option_string in ('-h', '--help', '--help_advanced', '--version'):
10268  parser._handle_boost()
10269 
10270 
10271 class ArgumentParser(argparse.ArgumentParser):
10272  """IMP-specific subclass of argparse.ArgumentParser.
10273  This adds options common to all IMP applications
10274  (see IMP::setup_from_argv()).
10275  """
10276 
10277  def __init__(self, *args, **kwargs):
10278 # Don't add --help option (since the Boost option parser handles it)
10279  kwargs['add_help'] = False
10280  super(ArgumentParser, self).__init__(*args, **kwargs)
10281  for ntoken in (0, 1):
10282  flags = _get_all_flags(ntoken)
10283  for f in flags:
10284  arg = ['-h', '--help'] if f == 'help' else ['--' + f]
10285  self.add_argument(*arg, help=argparse.SUPPRESS,
10286  nargs=None if ntoken else 0,
10287  action=_PassThroughAction,
10288  default=argparse.SUPPRESS)
10289 
10290  def parse_args(self, args=None, namespace=None):
10291  """Parse the command line and return optional and positional arguments.
10292  This functions in the same way as the method in the base class
10293  argparse.ArgumentParser, except that it also processes optional
10294  arguments common to all IMP applications (these are not returned
10295  in `args`, but can be obtained in the usual way, e.g. by calling
10296  IMP::get_string_flag()).
10297  @returns args
10298  """
10299  self._boost_command_line = [sys.argv[0]]
10300  ret = super(ArgumentParser, self).parse_args(args, namespace)
10301  if len(self._boost_command_line) > 1:
10302  self._handle_boost()
10303  return ret
10304 
10305  def _get_description(self):
10306  return self.format_help() + "\nOptions common to all IMP applications:"
10307 
10308  def print_help(self, file=None):
10309  _print_internal_help(file if file else sys.stdout,
10310  self._get_description())
10311 
10312  def _handle_boost(self):
10313  setup_from_argv(self._boost_command_line,
10314  self._get_description(),
10315  '==SUPPRESS==', 0)
10316 
10317 class RandomNumberGenerator(object):
10318  """Proxy of C++ IMP::RandomNumberGenerator class"""
10319  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
10320  __repr__ = _swig_repr
10321 
10322  def seed(self, x):
10323  """seed(RandomNumberGenerator self, ::boost::int32_t x)"""
10324  return _IMP_kernel.RandomNumberGenerator_seed(self, x)
10325 
10326 
10327  def __call__(self):
10328  """__call__(RandomNumberGenerator self) -> int"""
10329  return _IMP_kernel.RandomNumberGenerator___call__(self)
10330 
10331 
10332  def __init__(self):
10333  """__init__(IMP::RandomNumberGenerator self) -> RandomNumberGenerator"""
10334  this = _IMP_kernel.new_RandomNumberGenerator()
10335  try:
10336  self.this.append(this)
10337  except:
10338  self.this = this
10339  __swig_destroy__ = _IMP_kernel.delete_RandomNumberGenerator
10340  __del__ = lambda self: None
10341 RandomNumberGenerator_swigregister = _IMP_kernel.RandomNumberGenerator_swigregister
10342 RandomNumberGenerator_swigregister(RandomNumberGenerator)
10343 
10344 
10345 def get_random_float_uniform(*args):
10346  """
10347  get_random_float_uniform() -> float
10348  get_random_float_uniform(float min, float max) -> float
10349  """
10350  return _IMP_kernel.get_random_float_uniform(*args)
10351 
10352 def get_random_double_uniform(*args):
10353  """
10354  get_random_double_uniform() -> double
10355  get_random_double_uniform(double min, double max) -> double
10356  """
10357  return _IMP_kernel.get_random_double_uniform(*args)
10358 
10359 def get_random_floats_normal(n, mean=0.0, stddev=1.0):
10360  """
10361  get_random_floats_normal(unsigned int n, float mean=0.0, float stddev=1.0) -> IMP::Vector< float >
10362  get_random_floats_normal(unsigned int n, float mean=0.0) -> IMP::Vector< float >
10363  get_random_floats_normal(unsigned int n) -> IMP::Vector< float >
10364  """
10365  return _IMP_kernel.get_random_floats_normal(n, mean, stddev)
10366 
10367 def get_random_doubles_normal(n, mean=0.0, stddev=1.0):
10368  """
10369  get_random_doubles_normal(unsigned int n, double mean=0.0, double stddev=1.0) -> IMP::Vector< double >
10370  get_random_doubles_normal(unsigned int n, double mean=0.0) -> IMP::Vector< double >
10371  get_random_doubles_normal(unsigned int n) -> IMP::Vector< double >
10372  """
10373  return _IMP_kernel.get_random_doubles_normal(n, mean, stddev)
10374 
10375 def get_random_floats_uniform(n):
10376  """get_random_floats_uniform(unsigned int n) -> IMP::Vector< float >"""
10377  return _IMP_kernel.get_random_floats_uniform(n)
10378 
10379 def get_random_doubles_uniform(n):
10380  """get_random_doubles_uniform(unsigned int n) -> IMP::Vector< double >"""
10381  return _IMP_kernel.get_random_doubles_uniform(n)
10382 
10383 def get_random_seed():
10384  """get_random_seed() -> boost::uint64_t"""
10385  return _IMP_kernel.get_random_seed()
10386 
10387 def _get_derivatives_numpy(m, k, m_pyobj):
10388  """_get_derivatives_numpy(Model m, FloatKey k, PyObject * m_pyobj) -> PyObject *"""
10389  return _IMP_kernel._get_derivatives_numpy(m, k, m_pyobj)
10390 
10391 def _get_floats_numpy(m, k, m_pyobj):
10392  """_get_floats_numpy(Model m, FloatKey k, PyObject * m_pyobj) -> PyObject *"""
10393  return _IMP_kernel._get_floats_numpy(m, k, m_pyobj)
10394 
10395 def _get_ints_numpy(m, k, m_pyobj):
10396  """_get_ints_numpy(Model m, IntKey k, PyObject * m_pyobj) -> PyObject *"""
10397  return _IMP_kernel._get_ints_numpy(m, k, m_pyobj)
10398 
10399 def _get_spheres_numpy(m, m_pyobj):
10400  """_get_spheres_numpy(Model m, PyObject * m_pyobj) -> PyObject *"""
10401  return _IMP_kernel._get_spheres_numpy(m, m_pyobj)
10402 
10403 def _get_sphere_derivatives_numpy(m, m_pyobj):
10404  """_get_sphere_derivatives_numpy(Model m, PyObject * m_pyobj) -> PyObject *"""
10405  return _IMP_kernel._get_sphere_derivatives_numpy(m, m_pyobj)
10406 
10407 def get_module_version():
10408  """get_module_version() -> std::string const"""
10409  return _IMP_kernel.get_module_version()
10410 
10411 def get_example_path(fname):
10412  """get_example_path(std::string fname) -> std::string"""
10413  return _IMP_kernel.get_example_path(fname)
10414 
10415 def get_data_path(fname):
10416  """get_data_path(std::string fname) -> std::string"""
10417  return _IMP_kernel.get_data_path(fname)
10418 
10419 from . import _version_check
10420 _version_check.check_version(get_module_version())
10421 __version__ = get_module_version()
10422 
10423 
10424 random_number_generator = cvar.random_number_generator
10425 
void add_int_flag(std::string name, size_t default_value, std::string description)
Allow command line tools to easily implement multiple commands.
Definition: __init__.py:9977
CheckLevel get_check_level()
Get the current audit mode.
Definition: exception.h:81
bool get_is_quick_test()
Definition: flags.h:183
Key< 0 > FloatKey
The type used to identify float attributes in the Particles.
Definition: base_types.h:32
def allow_deprecated
Context manager to temporarily allow (or disallow) deprecated code.
Definition: __init__.py:10237
std::string get_unique_name(std::string templ)
Return a unique name produced from the string.
DependencyGraph get_dependency_graph(Model *m)
Objects get_live_objects()
Return pointers to all live objects.
Vector< char > write_particles_to_buffer(const ParticlesTemp &particles, const FloatKeys &keys)
return a binary buffer with the data
def main
Call this method to act upon the user-provided command line.
Definition: __init__.py:10015
boost::graph DependencyGraph
Directed graph on the interactions between the various objects in the model.
ContainersTemp get_input_containers(const ModelObjectsTemp &mos)
Return all the input particles for a given ModelObject.
ParticlesTemp get_dependent_particles(ModelObject *p, const ModelObjectsTemp &all, const DependencyGraph &dg, const DependencyGraphVertexIndex &index)
def deprecated_module
Mark a Python module as deprecated.
Definition: __init__.py:10190
Vector< VectorD< D > > get_vertices(const BoundingBoxD< D > &bb)
Return a list of the 2^D bounding points for the bounding box.
Definition: BoundingBoxD.h:274
Array< 4, WeakPointer< Particle >, Particle * > ParticleQuad
Definition: base_types.h:148
bool get_bool_flag(std::string name)
void handle_use_deprecated(std::string message)
Break in this method in gdb to find deprecated uses at runtime.
void set_progress_display(std::string description, unsigned int steps)
Set up the progress bar with the passed description.
def deprecated_function
Python decorator to mark a function as deprecated.
Definition: __init__.py:10225
Index< ParticleIndexTag > ParticleIndex
Definition: base_types.h:158
ParticlesTemp get_particles(Model *m, const ParticleIndexes &ps)
Get the particles from a list of indexes.
Key< 6 > ParticleIndexesKey
The type used to identify a particle attribute in the Particles.
Definition: base_types.h:64
Array< 3, WeakPointer< Particle >, Particle * > ParticleTriplet
Definition: base_types.h:145
ContainersTemp get_output_containers(const ModelObjectsTemp &mos)
Return all the output particles for a given ModelObject.
void add_particle(RMF::FileHandle fh, Particle *hs)
std::string get_data_path(std::string file_name)
Return the full path to one of this module's data files.
void add_string_flag(std::string name, std::string default_value, std::string description)
LogLevel get_log_level()
Get the currently active global log level.
Definition: log.h:92
void set_deprecation_warnings(bool tf)
Toggle printing of warnings on using deprecated classes.
TextOutput create_temporary_file(std::string prefix="imp_temp", std::string suffix="")
ParticlesTemp get_output_particles(const ModelObjectsTemp &mos)
Return all the output particles for a given ModelObject.
ScoringFunction * create_scoring_function(RestraintType *rs, double weight=1.0, double max=NO_MAX, std::string name=std::string())
Create a ScoringFunction on a single restraint.
Definition: generic.h:23
void write_help(std::ostream &out=std::cerr)
Key< 2 > StringKey
The type used to identify string attributes in the Particles.
Definition: base_types.h:40
size_t get_int_flag(std::string name)
Key< 10 > FloatsKey
The type used to identify float vector attributes in the Particles.
Definition: base_types.h:60
void add_restraint(RMF::FileHandle fh, Restraint *hs)
ScoreStatesTemp get_required_score_states(ModelObject *p, const ModelObjectsTemp &all, const DependencyGraph &dg, const DependencyGraphVertexIndex &index)
boost::uint64_t get_random_seed()
Return the initial random seed.
Key< 3 > ParticleIndexKey
The type used to identify a particle attribute in the Particles.
Definition: base_types.h:44
Strings get_live_object_names()
Return the names of all live objects.
void add_to_progress_display(unsigned int step=1)
Set the current progress.
void add_float_flag(std::string name, double default_value, std::string description)
Ints get_index(const ParticlesTemp &particles, const Subset &subset, const Subsets &excluded)
ParticleIndexes get_particle_indexes(ParticlesTemp const &particles)
def deprecated_method
Python decorator to mark a method as deprecated.
Definition: __init__.py:10213
void reset_log_timer()
Reset the log timer.
void add_restraints(RMF::FileHandle fh, const Restraints &hs)
void add_to_log(LogLevel level, std::string to_write)
Write a string to the log, for Python.
def parse_args
Parse the command line and return optional and positional arguments.
Definition: __init__.py:10290
Key< 1 > IntKey
The type used to identify int attributes in the Particles.
Definition: base_types.h:36
Version and module information for Objects.
Definition: VersionInfo.h:28
Restraints create_decomposition(const RestraintsTemp &rs)
Return the decomposition of a list of restraints.
std::string get_relative_path(std::string base, std::string relative)
Return a path to a file relative to another file.
void set_deprecation_exceptions(bool tf)
Toggle whether an exception is thrown when a deprecated method is used.
Key< 4 > ObjectKey
The type used to identify an Object attribute.
Definition: base_types.h:48
IMP-specific subclass of argparse.ArgumentParser.
Definition: __init__.py:10271
std::ostream & show(Hierarchy h, std::ostream &out=std::cout)
Print the hierarchy using a given decorator to display each node.
std::string get_absolute_path(std::string file)
Convert a possibly relative path to an absolute path.
std::string get_executable_name()
Return the name of the current executable.
void set_log_level(LogLevel l)
Set the current global log level.
unsigned int get_number_of_threads()
float get_random_float_uniform()
Return a uniformly distributed float number in range [0..1)
Definition: random_utils.h:130
def deprecated_object
Python decorator to mark a class as deprecated.
Definition: __init__.py:10197
ParticlesTemp get_input_particles(const ModelObjectsTemp &mos)
Return all the input particles for a given ModelObject.
void set_show_leaked_objects(bool tf)
Set whether to complain about objects not being properly cleaned up.
bool get_deprecation_exceptions()
Get whether an exception is thrown when a deprecated method is used.
void set_log_timer(bool tb)
Set whether log messages are tagged with the current log time.
void show_restraint_hierarchy(ScoringFunctionAdaptor rs, std::ostream &out=std::cout)
Print the hierarchy of restraints.
DependencyGraph get_pruned_dependency_graph(Model *m)
std::string get_example_path(std::string file_name)
Return the full path to one of this module's example files.
Array< 2, WeakPointer< Particle >, Particle * > ParticlePair
Definition: base_types.h:139
Key< 5 > IntsKey
The type used to identify int attributes in the Particles.
Definition: base_types.h:56
Restraints create_restraints(RMF::FileConstHandle fh, Model *m)
std::string show_graphviz(Graph g)
std::string get_string_flag(std::string name)
networkx::DiGraph get_networkx_graph(Graph g)
def __init__
Constructor.
Definition: __init__.py:10002
double get_random_double_uniform()
Return a uniformly distributed double number in range [0..1)
Definition: random_utils.h:162
Key< 8 > ModelKey
The type used to identify data stored directly in the model.
Definition: base_types.h:78
void show_altgraph(Graph g)
void setup_from_argv(int argc, char **argv, std::string description)
Parse the command line flags and return the positional arguments.
void add_bool_flag(std::string name, std::string description)
ParticleIndexes get_indexes(const ParticlesTemp &ps)
Get the indexes from a list of particles.
void read_particles_from_buffer(const Vector< char > &buffer, const ParticlesTemp &particles, const FloatKeys &keys)
load found attributes into the particles
void set_number_of_threads(unsigned int n)
double get_float_flag(std::string name)
void set_check_level(CheckLevel tf)
Control runtime checks in the code.
Definition: exception.h:73
ScoreStatesTemp get_update_order(ScoreStatesTemp input)
std::string get_module_version()
Return the version of this module, as a string.
std::string create_temporary_file_name(std::string prefix="imp_temp", std::string suffix="")
Create a temporary file.