IMP logo
IMP Reference Guide  2.6.2
The Integrative Modeling Platform
__init__.py
1 # This file was automatically generated by SWIG (http://www.swig.org).
2 # Version 3.0.8
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-2016 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 
116  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
117 
118  def __init__(self, *args, **kwargs):
119  raise AttributeError("No constructor defined - class is abstract")
120  __repr__ = _swig_repr
121  __swig_destroy__ = _IMP_kernel.delete_IMP_KERNEL_SwigPyIterator
122  __del__ = lambda self: None
123 
124  def value(self):
125  """value(IMP_KERNEL_SwigPyIterator self) -> PyObject *"""
126  return _IMP_kernel.IMP_KERNEL_SwigPyIterator_value(self)
127 
128 
129  def incr(self, n=1):
130  """
131  incr(IMP_KERNEL_SwigPyIterator self, size_t n=1) -> IMP_KERNEL_SwigPyIterator
132  incr(IMP_KERNEL_SwigPyIterator self) -> IMP_KERNEL_SwigPyIterator
133  """
134  return _IMP_kernel.IMP_KERNEL_SwigPyIterator_incr(self, n)
135 
136 
137  def decr(self, n=1):
138  """
139  decr(IMP_KERNEL_SwigPyIterator self, size_t n=1) -> IMP_KERNEL_SwigPyIterator
140  decr(IMP_KERNEL_SwigPyIterator self) -> IMP_KERNEL_SwigPyIterator
141  """
142  return _IMP_kernel.IMP_KERNEL_SwigPyIterator_decr(self, n)
143 
144 
145  def distance(self, x):
146  """distance(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> ptrdiff_t"""
147  return _IMP_kernel.IMP_KERNEL_SwigPyIterator_distance(self, x)
148 
149 
150  def equal(self, x):
151  """equal(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> bool"""
152  return _IMP_kernel.IMP_KERNEL_SwigPyIterator_equal(self, x)
153 
154 
155  def copy(self):
156  """copy(IMP_KERNEL_SwigPyIterator self) -> IMP_KERNEL_SwigPyIterator"""
157  return _IMP_kernel.IMP_KERNEL_SwigPyIterator_copy(self)
158 
159 
160  def next(self):
161  """next(IMP_KERNEL_SwigPyIterator self) -> PyObject *"""
162  return _IMP_kernel.IMP_KERNEL_SwigPyIterator_next(self)
163 
164 
165  def __next__(self):
166  """__next__(IMP_KERNEL_SwigPyIterator self) -> PyObject *"""
167  return _IMP_kernel.IMP_KERNEL_SwigPyIterator___next__(self)
168 
169 
170  def previous(self):
171  """previous(IMP_KERNEL_SwigPyIterator self) -> PyObject *"""
172  return _IMP_kernel.IMP_KERNEL_SwigPyIterator_previous(self)
173 
174 
175  def advance(self, n):
176  """advance(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator"""
177  return _IMP_kernel.IMP_KERNEL_SwigPyIterator_advance(self, n)
178 
179 
180  def __eq__(self, x):
181  """__eq__(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> bool"""
182  return _IMP_kernel.IMP_KERNEL_SwigPyIterator___eq__(self, x)
183 
184 
185  def __ne__(self, x):
186  """__ne__(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> bool"""
187  return _IMP_kernel.IMP_KERNEL_SwigPyIterator___ne__(self, x)
188 
189 
190  def __iadd__(self, n):
191  """__iadd__(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator"""
192  return _IMP_kernel.IMP_KERNEL_SwigPyIterator___iadd__(self, n)
193 
194 
195  def __isub__(self, n):
196  """__isub__(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator"""
197  return _IMP_kernel.IMP_KERNEL_SwigPyIterator___isub__(self, n)
198 
199 
200  def __add__(self, n):
201  """__add__(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator"""
202  return _IMP_kernel.IMP_KERNEL_SwigPyIterator___add__(self, n)
203 
204 
205  def __sub__(self, *args):
206  """
207  __sub__(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator
208  __sub__(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> ptrdiff_t
209  """
210  return _IMP_kernel.IMP_KERNEL_SwigPyIterator___sub__(self, *args)
211 
212  def __iter__(self):
213  return self
214 IMP_KERNEL_SwigPyIterator_swigregister = _IMP_kernel.IMP_KERNEL_SwigPyIterator_swigregister
215 IMP_KERNEL_SwigPyIterator_swigregister(IMP_KERNEL_SwigPyIterator)
216 
217 
218 _value_types=[]
219 _object_types=[]
220 _raii_types=[]
221 _plural_types=[]
222 
223 
224 _IMP_kernel.IMP_DEBUG_swigconstant(_IMP_kernel)
225 IMP_DEBUG = _IMP_kernel.IMP_DEBUG
226 
227 _IMP_kernel.IMP_RELEASE_swigconstant(_IMP_kernel)
228 IMP_RELEASE = _IMP_kernel.IMP_RELEASE
229 
230 _IMP_kernel.IMP_SILENT_swigconstant(_IMP_kernel)
231 IMP_SILENT = _IMP_kernel.IMP_SILENT
232 
233 _IMP_kernel.IMP_PROGRESS_swigconstant(_IMP_kernel)
234 IMP_PROGRESS = _IMP_kernel.IMP_PROGRESS
235 
236 _IMP_kernel.IMP_TERSE_swigconstant(_IMP_kernel)
237 IMP_TERSE = _IMP_kernel.IMP_TERSE
238 
239 _IMP_kernel.IMP_VERBOSE_swigconstant(_IMP_kernel)
240 IMP_VERBOSE = _IMP_kernel.IMP_VERBOSE
241 
242 _IMP_kernel.IMP_MEMORY_swigconstant(_IMP_kernel)
243 IMP_MEMORY = _IMP_kernel.IMP_MEMORY
244 
245 _IMP_kernel.IMP_NONE_swigconstant(_IMP_kernel)
246 IMP_NONE = _IMP_kernel.IMP_NONE
247 
248 _IMP_kernel.IMP_USAGE_swigconstant(_IMP_kernel)
249 IMP_USAGE = _IMP_kernel.IMP_USAGE
250 
251 _IMP_kernel.IMP_INTERNAL_swigconstant(_IMP_kernel)
252 IMP_INTERNAL = _IMP_kernel.IMP_INTERNAL
253 
254 _IMP_kernel.IMP_KERNEL_HAS_LOG4CXX_swigconstant(_IMP_kernel)
255 IMP_KERNEL_HAS_LOG4CXX = _IMP_kernel.IMP_KERNEL_HAS_LOG4CXX
256 
257 _IMP_kernel.IMP_COMPILER_HAS_AUTO_swigconstant(_IMP_kernel)
258 IMP_COMPILER_HAS_AUTO = _IMP_kernel.IMP_COMPILER_HAS_AUTO
259 
260 _IMP_kernel.IMP_COMPILER_HAS_DEBUG_VECTOR_swigconstant(_IMP_kernel)
261 IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_kernel.IMP_COMPILER_HAS_DEBUG_VECTOR
262 
263 _IMP_kernel.IMP_COMPILER_HAS_UNIQUE_PTR_swigconstant(_IMP_kernel)
264 IMP_COMPILER_HAS_UNIQUE_PTR = _IMP_kernel.IMP_COMPILER_HAS_UNIQUE_PTR
265 
266 _IMP_kernel.IMP_KERNEL_HAS_BOOST_RANDOM_swigconstant(_IMP_kernel)
267 IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_kernel.IMP_KERNEL_HAS_BOOST_RANDOM
268 
269 _IMP_kernel.IMP_KERNEL_HAS_GPERFTOOLS_swigconstant(_IMP_kernel)
270 IMP_KERNEL_HAS_GPERFTOOLS = _IMP_kernel.IMP_KERNEL_HAS_GPERFTOOLS
271 
272 _IMP_kernel.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER_swigconstant(_IMP_kernel)
273 IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER = _IMP_kernel.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER
274 
275 _IMP_kernel.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER_swigconstant(_IMP_kernel)
276 IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER = _IMP_kernel.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER
277 
278 _IMP_kernel.IMPKERNEL_SHOW_WARNINGS_swigconstant(_IMP_kernel)
279 IMPKERNEL_SHOW_WARNINGS = _IMP_kernel.IMPKERNEL_SHOW_WARNINGS
280 
281 import sys
282 class _DirectorObjects(object):
283  """@internal Simple class to keep references to director objects
284  to prevent premature deletion."""
285  def __init__(self):
286  self._objects = []
287  def register(self, obj):
288  """Take a reference to a director object; will only work for
289  refcounted C++ classes"""
290  if hasattr(obj, 'get_ref_count'):
291  self._objects.append(obj)
292  def cleanup(self):
293  """Only drop our reference and allow cleanup by Python if no other
294  Python references exist (we hold 3 references: one in self._objects,
295  one in x, and one in the argument list for getrefcount) *and* no
296  other C++ references exist (the Python object always holds one)"""
297  objs = [x for x in self._objects if sys.getrefcount(x) > 3 \
298  or x.get_ref_count() > 1]
299 # Do in two steps so the references are kept until the end of the
300 # function (deleting references may trigger a fresh call to this method)
301  self._objects = objs
302  def get_object_count(self):
303  """Get number of director objects (useful for testing only)"""
304  return len(self._objects)
305 _director_objects = _DirectorObjects()
306 
307 
308 _IMP_kernel.DEFAULT_CHECK_swigconstant(_IMP_kernel)
309 DEFAULT_CHECK = _IMP_kernel.DEFAULT_CHECK
310 
311 _IMP_kernel.NONE_swigconstant(_IMP_kernel)
312 NONE = _IMP_kernel.NONE
313 
314 _IMP_kernel.USAGE_swigconstant(_IMP_kernel)
315 USAGE = _IMP_kernel.USAGE
316 
317 _IMP_kernel.USAGE_AND_INTERNAL_swigconstant(_IMP_kernel)
318 USAGE_AND_INTERNAL = _IMP_kernel.USAGE_AND_INTERNAL
319 
320 def set_check_level(tf):
321  """set_check_level(IMP::CheckLevel tf)"""
322  return _IMP_kernel.set_check_level(tf)
323 
324 def get_check_level():
325  """get_check_level() -> IMP::CheckLevel"""
326  return _IMP_kernel.get_check_level()
327 
328 from _IMP_kernel import Exception, InternalException, ModelException, EventException
329 from _IMP_kernel import UsageException, IndexException, IOException, ValueException
330 from _IMP_kernel import TypeException
331 
332 class _ostream(object):
333  """Proxy of C++ std::ostream class."""
334 
335  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
336 
337  def __init__(self, *args, **kwargs):
338  raise AttributeError("No constructor defined")
339  __repr__ = _swig_repr
340 
341  def write(self, osa_buf):
342  """write(_ostream self, char const * osa_buf)"""
343  return _IMP_kernel._ostream_write(self, osa_buf)
344 
345 _ostream_swigregister = _IMP_kernel._ostream_swigregister
346 _ostream_swigregister(_ostream)
347 
348 
349 _IMP_kernel.IMP_COMPILER_HAS_OVERRIDE_swigconstant(_IMP_kernel)
350 IMP_COMPILER_HAS_OVERRIDE = _IMP_kernel.IMP_COMPILER_HAS_OVERRIDE
351 
352 _IMP_kernel.IMP_COMPILER_HAS_FINAL_swigconstant(_IMP_kernel)
353 IMP_COMPILER_HAS_FINAL = _IMP_kernel.IMP_COMPILER_HAS_FINAL
354 
355 _IMP_kernel.IMP_HAS_NOEXCEPT_swigconstant(_IMP_kernel)
356 IMP_HAS_NOEXCEPT = _IMP_kernel.IMP_HAS_NOEXCEPT
357 
358 _raii_types.append("SetLogState")
359 
360 
361 _raii_types.append("SetNumberOfThreads")
362 
363 
364 _raii_types.append("SetCheckState")
365 
366 
367 _object_types.append("Object")
368 
369 
370 def _object_cast_to_Object(o):
371  """_object_cast_to_Object(Object * o) -> Object"""
372  return _IMP_kernel._object_cast_to_Object(o)
373 
374 _object_types.append("_TestObject")
375 
376 
377 def _object_cast_to__TestObject(o):
378  """_object_cast_to__TestObject(Object * o) -> _TestObject"""
379  return _IMP_kernel._object_cast_to__TestObject(o)
380 
381 VersionInfos=list
382 _plural_types.append("VersionInfos")
383 _value_types.append("VersionInfo")
384 
385 
386 _raii_types.append("CreateLogContext")
387 
388 
389 _raii_types.append("WarningContext")
390 
391 
392 _raii_types.append("SetLogTarget")
393 
394 
395 _TestValues=list
396 _plural_types.append("_TestValues")
397 _value_types.append("_TestValue")
398 
399 
400 Floats=list
401 _plural_types.append("Floats")
402 _value_types.append("Float")
403 
404 
405 Ints=list
406 _plural_types.append("Ints")
407 _value_types.append("Int")
408 
409 
410 Strings=list
411 _plural_types.append("Strings")
412 _value_types.append("String")
413 
414 
415 _Protections=list
416 _plural_types.append("_Protections")
417 _value_types.append("_Protection")
418 
419 class _InputAdaptor(object):
420  """Proxy of C++ IMP::InputAdaptor class."""
421 
422  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
423 
424  def __init__(self, *args, **kwargs):
425  raise AttributeError("No constructor defined")
426  __repr__ = _swig_repr
427  __swig_destroy__ = _IMP_kernel.delete__InputAdaptor
428  __del__ = lambda self: None
429 _InputAdaptor_swigregister = _IMP_kernel._InputAdaptor_swigregister
430 _InputAdaptor_swigregister(_InputAdaptor)
431 
432 class _NonCopyable(object):
433  """Proxy of C++ IMP::NonCopyable class."""
434 
435  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
436 
437  def __init__(self, *args, **kwargs):
438  raise AttributeError("No constructor defined")
439  __repr__ = _swig_repr
440  __swig_destroy__ = _IMP_kernel.delete__NonCopyable
441  __del__ = lambda self: None
442 _NonCopyable_swigregister = _IMP_kernel._NonCopyable_swigregister
443 _NonCopyable_swigregister(_NonCopyable)
444 
445 class _RAII(_NonCopyable):
446  """Proxy of C++ IMP::RAII class."""
447 
448  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
449 
450  def __init__(self, *args, **kwargs):
451  raise AttributeError("No constructor defined")
452  __repr__ = _swig_repr
453  __swig_destroy__ = _IMP_kernel.delete__RAII
454  __del__ = lambda self: None
455 _RAII_swigregister = _IMP_kernel._RAII_swigregister
456 _RAII_swigregister(_RAII)
457 
458 class _Value(object):
459  """Proxy of C++ IMP::Value class."""
460 
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 
550 _IMP_kernel.NO_STATISTICS_swigconstant(_IMP_kernel)
551 NO_STATISTICS = _IMP_kernel.NO_STATISTICS
552 
553 _IMP_kernel.ALL_STATISTICS_swigconstant(_IMP_kernel)
554 ALL_STATISTICS = _IMP_kernel.ALL_STATISTICS
555 class VersionInfo(_Value):
556  """Proxy of C++ IMP::VersionInfo class."""
557 
558  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
559 
560  def __init__(self, *args):
561  """
562  __init__(IMP::VersionInfo self, std::string module, std::string version) -> VersionInfo
563  __init__(IMP::VersionInfo self) -> VersionInfo
564  """
565  this = _IMP_kernel.new_VersionInfo(*args)
566  try:
567  self.this.append(this)
568  except:
569  self.this = this
570 
571  def get_module(self):
572  """get_module(VersionInfo self) -> std::string"""
573  return _IMP_kernel.VersionInfo_get_module(self)
574 
575 
576  def get_version(self):
577  """get_version(VersionInfo self) -> std::string"""
578  return _IMP_kernel.VersionInfo_get_version(self)
579 
580 
581  def show(self, *args):
582  """
583  show(VersionInfo self, _ostream out)
584  show(VersionInfo self)
585  """
586  return _IMP_kernel.VersionInfo_show(self, *args)
587 
588 
589  def __cmp__(self, o):
590  """__cmp__(VersionInfo self, VersionInfo o) -> int"""
591  return _IMP_kernel.VersionInfo___cmp__(self, o)
592 
593 
594  def __eq__(self, o):
595  """__eq__(VersionInfo self, VersionInfo o) -> bool"""
596  return _IMP_kernel.VersionInfo___eq__(self, o)
597 
598 
599  def __ne__(self, o):
600  """__ne__(VersionInfo self, VersionInfo o) -> bool"""
601  return _IMP_kernel.VersionInfo___ne__(self, o)
602 
603 
604  def __lt__(self, o):
605  """__lt__(VersionInfo self, VersionInfo o) -> bool"""
606  return _IMP_kernel.VersionInfo___lt__(self, o)
607 
608 
609  def __gt__(self, o):
610  """__gt__(VersionInfo self, VersionInfo o) -> bool"""
611  return _IMP_kernel.VersionInfo___gt__(self, o)
612 
613 
614  def __ge__(self, o):
615  """__ge__(VersionInfo self, VersionInfo o) -> bool"""
616  return _IMP_kernel.VersionInfo___ge__(self, o)
617 
618 
619  def __le__(self, o):
620  """__le__(VersionInfo self, VersionInfo o) -> bool"""
621  return _IMP_kernel.VersionInfo___le__(self, o)
622 
623 
624  def __str__(self):
625  """__str__(VersionInfo self) -> std::string"""
626  return _IMP_kernel.VersionInfo___str__(self)
627 
628 
629  def __repr__(self):
630  """__repr__(VersionInfo self) -> std::string"""
631  return _IMP_kernel.VersionInfo___repr__(self)
632 
633  __swig_destroy__ = _IMP_kernel.delete_VersionInfo
634  __del__ = lambda self: None
635 VersionInfo_swigregister = _IMP_kernel.VersionInfo_swigregister
636 VersionInfo_swigregister(VersionInfo)
637 
638 class TextOutput(_InputAdaptor):
639  """Proxy of C++ IMP::TextOutput class."""
640 
641  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
642  __repr__ = _swig_repr
643 
644  def __init__(self, *args):
645  """
646  __init__(IMP::TextOutput self, int arg2) -> TextOutput
647  __init__(IMP::TextOutput self, double arg2) -> TextOutput
648  __init__(IMP::TextOutput self, char const * c, bool append=False) -> TextOutput
649  __init__(IMP::TextOutput self, char const * c) -> TextOutput
650  __init__(IMP::TextOutput self, IMP::TextProxy< std::ostream > p) -> TextOutput
651  __init__(IMP::TextOutput self) -> TextOutput
652  __init__(IMP::TextOutput self, std::string file_name, bool append=False) -> TextOutput
653  __init__(IMP::TextOutput self, std::string file_name) -> TextOutput
654  """
655  this = _IMP_kernel.new_TextOutput(*args)
656  try:
657  self.this.append(this)
658  except:
659  self.this = this
660 
661  def show(self, *args):
662  """
663  show(TextOutput self, _ostream out)
664  show(TextOutput self)
665  """
666  return _IMP_kernel.TextOutput_show(self, *args)
667 
668 
669  def get_name(self):
670  """get_name(TextOutput self) -> std::string"""
671  return _IMP_kernel.TextOutput_get_name(self)
672 
673  __swig_destroy__ = _IMP_kernel.delete_TextOutput
674  __del__ = lambda self: None
675 TextOutput_swigregister = _IMP_kernel.TextOutput_swigregister
676 TextOutput_swigregister(TextOutput)
677 
678 class TextInput(_InputAdaptor):
679  """Proxy of C++ IMP::TextInput class."""
680 
681  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
682  __repr__ = _swig_repr
683 
684  def __init__(self, *args):
685  """
686  __init__(IMP::TextInput self, int arg2) -> TextInput
687  __init__(IMP::TextInput self, double arg2) -> TextInput
688  __init__(IMP::TextInput self, char const * c) -> TextInput
689  __init__(IMP::TextInput self, IMP::TextProxy< std::istream > p) -> TextInput
690  __init__(IMP::TextInput self) -> TextInput
691  __init__(IMP::TextInput self, std::string file_name) -> TextInput
692  """
693  this = _IMP_kernel.new_TextInput(*args)
694  try:
695  self.this.append(this)
696  except:
697  self.this = this
698 
699  def show(self, *args):
700  """
701  show(TextInput self, _ostream out)
702  show(TextInput self)
703  """
704  return _IMP_kernel.TextInput_show(self, *args)
705 
706 
707  def get_name(self):
708  """get_name(TextInput self) -> std::string"""
709  return _IMP_kernel.TextInput_get_name(self)
710 
711  __swig_destroy__ = _IMP_kernel.delete_TextInput
712  __del__ = lambda self: None
713 TextInput_swigregister = _IMP_kernel.TextInput_swigregister
714 TextInput_swigregister(TextInput)
715 
716 class SetLogTarget(_RAII):
717  """Proxy of C++ IMP::SetLogTarget class."""
718 
719  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
720 
721  def __init__(self, *args):
722  """
723  __init__(IMP::SetLogTarget self) -> SetLogTarget
724  __init__(IMP::SetLogTarget self, TextOutput to) -> SetLogTarget
725  """
726  this = _IMP_kernel.new_SetLogTarget(*args)
727  try:
728  self.this.append(this)
729  except:
730  self.this = this
731 
732  def set(self, to):
733  """set(SetLogTarget self, TextOutput to)"""
734  return _IMP_kernel.SetLogTarget_set(self, to)
735 
736 
737  def reset(self):
738  """reset(SetLogTarget self)"""
739  return _IMP_kernel.SetLogTarget_reset(self)
740 
741  __swig_destroy__ = _IMP_kernel.delete_SetLogTarget
742  __del__ = lambda self: None
743 
744  def show(self, *args):
745  """
746  show(SetLogTarget self, _ostream out)
747  show(SetLogTarget self)
748  """
749  return _IMP_kernel.SetLogTarget_show(self, *args)
750 
751 
752  def __enter__(self):
753  return self
754  def __exit__(self, exc_type, exc_val, exc_tb):
755  self.reset()
756  return False
757 
758 
759  def __str__(self):
760  """__str__(SetLogTarget self) -> std::string"""
761  return _IMP_kernel.SetLogTarget___str__(self)
762 
763 
764  def __repr__(self):
765  """__repr__(SetLogTarget self) -> std::string"""
766  return _IMP_kernel.SetLogTarget___repr__(self)
767 
768 SetLogTarget_swigregister = _IMP_kernel.SetLogTarget_swigregister
769 SetLogTarget_swigregister(SetLogTarget)
770 
771 
772 def create_temporary_file(*args):
773  """
774  create_temporary_file(std::string prefix, std::string suffix) -> TextOutput
775  create_temporary_file(std::string prefix) -> TextOutput
776  create_temporary_file() -> TextOutput
777  """
778  return _IMP_kernel.create_temporary_file(*args)
779 
780 def create_temporary_file_name(*args):
781  """
782  create_temporary_file_name(std::string prefix, std::string suffix) -> std::string
783  create_temporary_file_name(std::string prefix) -> std::string
784  create_temporary_file_name() -> std::string
785  """
786  return _IMP_kernel.create_temporary_file_name(*args)
787 
788 def get_relative_path(base, relative):
789  """get_relative_path(std::string base, std::string relative) -> std::string"""
790  return _IMP_kernel.get_relative_path(base, relative)
791 
792 def push_log_context(functionname, object):
793  """push_log_context(char const * functionname, void const * object)"""
794  return _IMP_kernel.push_log_context(functionname, object)
795 
796 def pop_log_context():
797  """pop_log_context()"""
798  return _IMP_kernel.pop_log_context()
799 
800 def add_to_log(*args):
801  """
802  add_to_log(std::string to_write)
803  add_to_log(IMP::LogLevel level, std::string to_write)
804  """
805  return _IMP_kernel.add_to_log(*args)
806 
807 def set_log_level(l):
808  """set_log_level(IMP::LogLevel l)"""
809  return _IMP_kernel.set_log_level(l)
810 
811 def set_log_timer(tb):
812  """set_log_timer(bool tb)"""
813  return _IMP_kernel.set_log_timer(tb)
814 
815 def reset_log_timer():
816  """reset_log_timer()"""
817  return _IMP_kernel.reset_log_timer()
818 
819 def get_log_level():
820  """get_log_level() -> IMP::LogLevel"""
821  return _IMP_kernel.get_log_level()
822 
823 def set_progress_display(description, steps):
824  """set_progress_display(std::string description, unsigned int steps)"""
825  return _IMP_kernel.set_progress_display(description, steps)
826 
827 def add_to_progress_display(step=1):
828  """
829  add_to_progress_display(unsigned int step=1)
830  add_to_progress_display()
831  """
832  return _IMP_kernel.add_to_progress_display(step)
833 class Object(_NonCopyable):
834  """Proxy of C++ IMP::Object class."""
835 
836  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
837 
838  def __init__(self, name):
839  """__init__(IMP::Object self, std::string name) -> Object"""
840  if self.__class__ == Object:
841  _self = None
842  else:
843  _self = self
844  this = _IMP_kernel.new_Object(_self, name)
845  try:
846  self.this.append(this)
847  except:
848  self.this = this
849 
850  if self.__class__ != Object:
851  _director_objects.register(self)
852 
853 
854 
855  __swig_destroy__ = _IMP_kernel.delete_Object
856  __del__ = lambda self: None
857 
858  def __hash__(self):
859  """__hash__(Object self) -> std::size_t"""
860  return _IMP_kernel.Object___hash__(self)
861 
862 
863  def set_log_level(self, l):
864  """set_log_level(Object self, IMP::LogLevel l)"""
865  return _IMP_kernel.Object_set_log_level(self, l)
866 
867 
868  def set_check_level(self, l):
869  """set_check_level(Object self, IMP::CheckLevel l)"""
870  return _IMP_kernel.Object_set_check_level(self, l)
871 
872 
873  def get_log_level(self):
874  """get_log_level(Object self) -> IMP::LogLevel"""
875  return _IMP_kernel.Object_get_log_level(self)
876 
877 
878  def get_check_level(self):
879  """get_check_level(Object self) -> IMP::CheckLevel"""
880  return _IMP_kernel.Object_get_check_level(self)
881 
882 
883  def get_version_info(self):
884  """get_version_info(Object self) -> VersionInfo"""
885  return _IMP_kernel.Object_get_version_info(self)
886 
887 
888  def get_name(self):
889  """get_name(Object self) -> std::string const &"""
890  return _IMP_kernel.Object_get_name(self)
891 
892 
893  def set_name(self, name):
894  """set_name(Object self, std::string name)"""
895  return _IMP_kernel.Object_set_name(self, name)
896 
897 
898  def get_type_name(self):
899  """get_type_name(Object self) -> std::string"""
900  return _IMP_kernel.Object_get_type_name(self)
901 
902 
903  def set_was_used(self, tf):
904  """set_was_used(Object self, bool tf)"""
905  return _IMP_kernel.Object_set_was_used(self, tf)
906 
907 
908  def show(self, *args):
909  """
910  show(Object self, _ostream out)
911  show(Object self)
912  """
913  return _IMP_kernel.Object_show(self, *args)
914 
915 
916  def get_string(self):
917  """get_string(Object self) -> std::string"""
918  return _IMP_kernel.Object_get_string(self)
919 
920 
921  def _on_destruction(self):
922  """_on_destruction(Object self)"""
923  return _IMP_kernel.Object__on_destruction(self)
924 
925 
926  def get_is_valid(self):
927  """get_is_valid(Object self) -> bool"""
928  return _IMP_kernel.Object_get_is_valid(self)
929 
930 
931  def get_ref_count(self):
932  """get_ref_count(Object self) -> unsigned int"""
933  return _IMP_kernel.Object_get_ref_count(self)
934 
935 
936  def get_number_of_live_objects():
937  """get_number_of_live_objects() -> unsigned int"""
938  return _IMP_kernel.Object_get_number_of_live_objects()
939 
940  get_number_of_live_objects = staticmethod(get_number_of_live_objects)
941 
942  def get_is_shared(self):
943  """get_is_shared(Object self) -> bool"""
944  return _IMP_kernel.Object_get_is_shared(self)
945 
946 
947  def clear_caches(self):
948  """clear_caches(Object self)"""
949  return _IMP_kernel.Object_clear_caches(self)
950 
951 
952  def do_destroy(self):
953  """do_destroy(Object self)"""
954  return _IMP_kernel.Object_do_destroy(self)
955 
956 
957  def __eq__(self, o):
958  """__eq__(Object self, Object o) -> bool"""
959  return _IMP_kernel.Object___eq__(self, o)
960 
961 
962  def __ne__(self, o):
963  """__ne__(Object self, Object o) -> bool"""
964  return _IMP_kernel.Object___ne__(self, o)
965 
966 
967  def __le__(self, o):
968  """__le__(Object self, Object o) -> bool"""
969  return _IMP_kernel.Object___le__(self, o)
970 
971 
972  def __lt__(self, o):
973  """__lt__(Object self, Object o) -> bool"""
974  return _IMP_kernel.Object___lt__(self, o)
975 
976 
977  def __ge__(self, o):
978  """__ge__(Object self, Object o) -> bool"""
979  return _IMP_kernel.Object___ge__(self, o)
980 
981 
982  def __gt__(self, o):
983  """__gt__(Object self, Object o) -> bool"""
984  return _IMP_kernel.Object___gt__(self, o)
985 
986 
987  def __str__(self):
988  """__str__(Object self) -> std::string"""
989  return _IMP_kernel.Object___str__(self)
990 
991 
992  def __repr__(self):
993  """__repr__(Object self) -> std::string"""
994  return _IMP_kernel.Object___repr__(self)
995 
996 
997  @staticmethod
998  def get_from(o):
999  return _object_cast_to_Object(o)
1000 
1001  def __disown__(self):
1002  self.this.disown()
1003  _IMP_kernel.disown_Object(self)
1004  return weakref_proxy(self)
1005 Object_swigregister = _IMP_kernel.Object_swigregister
1006 Object_swigregister(Object)
1007 
1008 def Object_get_number_of_live_objects():
1009  """Object_get_number_of_live_objects() -> unsigned int"""
1010  return _IMP_kernel.Object_get_number_of_live_objects()
1011 
1012 class SetLogState(_RAII):
1013  """Proxy of C++ IMP::SetLogState class."""
1014 
1015  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1016 
1017  def reset(self):
1018  """reset(SetLogState self)"""
1019  return _IMP_kernel.SetLogState_reset(self)
1020 
1021  __swig_destroy__ = _IMP_kernel.delete_SetLogState
1022  __del__ = lambda self: None
1023 
1024  def show(self, *args):
1025  """
1026  show(SetLogState self, _ostream out)
1027  show(SetLogState self)
1028  """
1029  return _IMP_kernel.SetLogState_show(self, *args)
1030 
1031 
1032  def __init__(self, *args):
1033  """
1034  __init__(IMP::SetLogState self) -> SetLogState
1035  __init__(IMP::SetLogState self, Object o, IMP::LogLevel l) -> SetLogState
1036  __init__(IMP::SetLogState self, IMP::LogLevel l) -> SetLogState
1037  """
1038  this = _IMP_kernel.new_SetLogState(*args)
1039  try:
1040  self.this.append(this)
1041  except:
1042  self.this = this
1043 
1044  def set(self, *args):
1045  """
1046  set(SetLogState self, Object o, IMP::LogLevel l)
1047  set(SetLogState self, IMP::LogLevel l)
1048  """
1049  return _IMP_kernel.SetLogState_set(self, *args)
1050 
1051 
1052  def __enter__(self):
1053  return self
1054  def __exit__(self, exc_type, exc_val, exc_tb):
1055  self.reset()
1056  return False
1057 
1058 
1059  def __str__(self):
1060  """__str__(SetLogState self) -> std::string"""
1061  return _IMP_kernel.SetLogState___str__(self)
1062 
1063 
1064  def __repr__(self):
1065  """__repr__(SetLogState self) -> std::string"""
1066  return _IMP_kernel.SetLogState___repr__(self)
1067 
1068 SetLogState_swigregister = _IMP_kernel.SetLogState_swigregister
1069 SetLogState_swigregister(SetLogState)
1070 
1071 class WarningContext(object):
1072  """Proxy of C++ IMP::WarningContext class."""
1073 
1074  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1075  data_ = _swig_property(_IMP_kernel.WarningContext_data__get, _IMP_kernel.WarningContext_data__set)
1076 
1077  def add_warning(self, key, warning):
1078  """add_warning(WarningContext self, std::string key, std::string warning)"""
1079  return _IMP_kernel.WarningContext_add_warning(self, key, warning)
1080 
1081 
1082  def clear_warnings(self):
1083  """clear_warnings(WarningContext self)"""
1084  return _IMP_kernel.WarningContext_clear_warnings(self)
1085 
1086 
1087  def dump_warnings(self):
1088  """dump_warnings(WarningContext self)"""
1089  return _IMP_kernel.WarningContext_dump_warnings(self)
1090 
1091  __swig_destroy__ = _IMP_kernel.delete_WarningContext
1092  __del__ = lambda self: None
1093 
1094  def show(self, *args):
1095  """
1096  show(WarningContext self, _ostream out)
1097  show(WarningContext self)
1098  """
1099  return _IMP_kernel.WarningContext_show(self, *args)
1100 
1101 
1102  def __enter__(self):
1103  return self
1104  def __exit__(self, exc_type, exc_val, exc_tb):
1105  self.reset()
1106  return False
1107 
1108 
1109  def __str__(self):
1110  """__str__(WarningContext self) -> std::string"""
1111  return _IMP_kernel.WarningContext___str__(self)
1112 
1113 
1114  def __repr__(self):
1115  """__repr__(WarningContext self) -> std::string"""
1116  return _IMP_kernel.WarningContext___repr__(self)
1117 
1118 
1119  def __init__(self):
1120  """__init__(IMP::WarningContext self) -> WarningContext"""
1121  this = _IMP_kernel.new_WarningContext()
1122  try:
1123  self.this.append(this)
1124  except:
1125  self.this = this
1126 WarningContext_swigregister = _IMP_kernel.WarningContext_swigregister
1127 WarningContext_swigregister(WarningContext)
1128 
1129 class CreateLogContext(_RAII):
1130  """Proxy of C++ IMP::CreateLogContext class."""
1131 
1132  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1133 
1134  def __init__(self, *args):
1135  """
1136  __init__(IMP::CreateLogContext self, std::string fname, Object object=None) -> CreateLogContext
1137  __init__(IMP::CreateLogContext self, std::string fname) -> CreateLogContext
1138  __init__(IMP::CreateLogContext self) -> CreateLogContext
1139  __init__(IMP::CreateLogContext self, char const * fname, Object object=None) -> CreateLogContext
1140  __init__(IMP::CreateLogContext self, char const * fname) -> CreateLogContext
1141  """
1142  this = _IMP_kernel.new_CreateLogContext(*args)
1143  try:
1144  self.this.append(this)
1145  except:
1146  self.this = this
1147 
1148  def set(self, fname, object=None):
1149  """
1150  set(CreateLogContext self, char const * fname, Object object=None)
1151  set(CreateLogContext self, char const * fname)
1152  """
1153  return _IMP_kernel.CreateLogContext_set(self, fname, object)
1154 
1155 
1156  def reset(self):
1157  """reset(CreateLogContext self)"""
1158  return _IMP_kernel.CreateLogContext_reset(self)
1159 
1160  __swig_destroy__ = _IMP_kernel.delete_CreateLogContext
1161  __del__ = lambda self: None
1162 
1163  def show(self, *args):
1164  """
1165  show(CreateLogContext self, _ostream out)
1166  show(CreateLogContext self)
1167  """
1168  return _IMP_kernel.CreateLogContext_show(self, *args)
1169 
1170 
1171  def __enter__(self):
1172  return self
1173  def __exit__(self, exc_type, exc_val, exc_tb):
1174  self.reset()
1175  return False
1176 
1177 
1178  def __str__(self):
1179  """__str__(CreateLogContext self) -> std::string"""
1180  return _IMP_kernel.CreateLogContext___str__(self)
1181 
1182 
1183  def __repr__(self):
1184  """__repr__(CreateLogContext self) -> std::string"""
1185  return _IMP_kernel.CreateLogContext___repr__(self)
1186 
1187 CreateLogContext_swigregister = _IMP_kernel.CreateLogContext_swigregister
1188 CreateLogContext_swigregister(CreateLogContext)
1189 
1190 class SetCheckState(_RAII):
1191  """Proxy of C++ IMP::SetCheckState class."""
1192 
1193  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1194 
1195  def reset(self):
1196  """reset(SetCheckState self)"""
1197  return _IMP_kernel.SetCheckState_reset(self)
1198 
1199  __swig_destroy__ = _IMP_kernel.delete_SetCheckState
1200  __del__ = lambda self: None
1201 
1202  def show(self, *args):
1203  """
1204  show(SetCheckState self, _ostream out)
1205  show(SetCheckState self)
1206  """
1207  return _IMP_kernel.SetCheckState_show(self, *args)
1208 
1209 
1210  def __init__(self, *args):
1211  """
1212  __init__(IMP::SetCheckState self) -> SetCheckState
1213  __init__(IMP::SetCheckState self, Object o, IMP::CheckLevel l) -> SetCheckState
1214  __init__(IMP::SetCheckState self, IMP::CheckLevel l) -> SetCheckState
1215  """
1216  this = _IMP_kernel.new_SetCheckState(*args)
1217  try:
1218  self.this.append(this)
1219  except:
1220  self.this = this
1221 
1222  def set(self, *args):
1223  """
1224  set(SetCheckState self, Object o, IMP::CheckLevel l)
1225  set(SetCheckState self, IMP::CheckLevel l)
1226  """
1227  return _IMP_kernel.SetCheckState_set(self, *args)
1228 
1229 
1230  def __enter__(self):
1231  return self
1232  def __exit__(self, exc_type, exc_val, exc_tb):
1233  self.reset()
1234  return False
1235 
1236 
1237  def __str__(self):
1238  """__str__(SetCheckState self) -> std::string"""
1239  return _IMP_kernel.SetCheckState___str__(self)
1240 
1241 
1242  def __repr__(self):
1243  """__repr__(SetCheckState self) -> std::string"""
1244  return _IMP_kernel.SetCheckState___repr__(self)
1245 
1246 SetCheckState_swigregister = _IMP_kernel.SetCheckState_swigregister
1247 SetCheckState_swigregister(SetCheckState)
1248 
1249 
1250 def get_unique_name(templ):
1251  """get_unique_name(std::string templ) -> std::string"""
1252  return _IMP_kernel.get_unique_name(templ)
1253 class _Protection(object):
1254  """Proxy of C++ IMP::internal::_Protection class."""
1255 
1256  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1257 
1258  def __init__(self, *args, **kwargs):
1259  raise AttributeError("No constructor defined")
1260 
1261  def show(self, *args):
1262  """
1263  show(_Protection self, _ostream out)
1264  show(_Protection self)
1265  """
1266  return _IMP_kernel._Protection_show(self, *args)
1267 
1268 
1269  def __str__(self):
1270  """__str__(_Protection self) -> std::string"""
1271  return _IMP_kernel._Protection___str__(self)
1272 
1273 
1274  def __repr__(self):
1275  """__repr__(_Protection self) -> std::string"""
1276  return _IMP_kernel._Protection___repr__(self)
1277 
1278  __swig_destroy__ = _IMP_kernel.delete__Protection
1279  __del__ = lambda self: None
1280 _Protection_swigregister = _IMP_kernel._Protection_swigregister
1281 _Protection_swigregister(_Protection)
1282 
1283 
1284 def _test_log():
1285  """_test_log()"""
1286  return _IMP_kernel._test_log()
1287 
1288 def _test_intranges(ips):
1289  """_test_intranges(IMP::IntRanges const & ips) -> int"""
1290  return _IMP_kernel._test_intranges(ips)
1291 
1292 def _test_intrange(*args):
1293  """
1294  _test_intrange(IMP::IntRange const & ips) -> IMP::IntRange
1295  _test_intrange() -> IMP::IntRange
1296  """
1297  return _IMP_kernel._test_intrange(*args)
1298 
1299 def _test_ifile(a):
1300  """_test_ifile(TextInput a) -> std::string"""
1301  return _IMP_kernel._test_ifile(a)
1302 
1303 def _test_ofile(a):
1304  """_test_ofile(TextOutput a) -> std::string"""
1305  return _IMP_kernel._test_ofile(a)
1306 
1307 def _test_ifile_overloaded(*args):
1308  """
1309  _test_ifile_overloaded(TextInput a, int i) -> std::string
1310  _test_ifile_overloaded(TextInput a, std::string st) -> std::string
1311  """
1312  return _IMP_kernel._test_ifile_overloaded(*args)
1313 
1314 def _test_ofile_overloaded(*args):
1315  """
1316  _test_ofile_overloaded(TextOutput a, int i) -> std::string
1317  _test_ofile_overloaded(TextOutput a, std::string st) -> std::string
1318  """
1319  return _IMP_kernel._test_ofile_overloaded(*args)
1320 class _TestValue(object):
1321  """Proxy of C++ IMP::internal::_TestValue class."""
1322 
1323  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1324 
1325  def __init__(self, i):
1326  """__init__(IMP::internal::_TestValue self, int i) -> _TestValue"""
1327  this = _IMP_kernel.new__TestValue(i)
1328  try:
1329  self.this.append(this)
1330  except:
1331  self.this = this
1332 
1333  def show(self, *args):
1334  """
1335  show(_TestValue self, _ostream out)
1336  show(_TestValue self)
1337  """
1338  return _IMP_kernel._TestValue_show(self, *args)
1339 
1340 
1341  def __cmp__(self, o):
1342  """__cmp__(_TestValue self, _TestValue o) -> int"""
1343  return _IMP_kernel._TestValue___cmp__(self, o)
1344 
1345 
1346  def __eq__(self, o):
1347  """__eq__(_TestValue self, _TestValue o) -> bool"""
1348  return _IMP_kernel._TestValue___eq__(self, o)
1349 
1350 
1351  def __ne__(self, o):
1352  """__ne__(_TestValue self, _TestValue o) -> bool"""
1353  return _IMP_kernel._TestValue___ne__(self, o)
1354 
1355 
1356  def __lt__(self, o):
1357  """__lt__(_TestValue self, _TestValue o) -> bool"""
1358  return _IMP_kernel._TestValue___lt__(self, o)
1359 
1360 
1361  def __gt__(self, o):
1362  """__gt__(_TestValue self, _TestValue o) -> bool"""
1363  return _IMP_kernel._TestValue___gt__(self, o)
1364 
1365 
1366  def __ge__(self, o):
1367  """__ge__(_TestValue self, _TestValue o) -> bool"""
1368  return _IMP_kernel._TestValue___ge__(self, o)
1369 
1370 
1371  def __le__(self, o):
1372  """__le__(_TestValue self, _TestValue o) -> bool"""
1373  return _IMP_kernel._TestValue___le__(self, o)
1374 
1375 
1376  def get(self):
1377  """get(_TestValue self) -> int"""
1378  return _IMP_kernel._TestValue_get(self)
1379 
1380 
1381  def get_float(self):
1382  """get_float(_TestValue self) -> float const &"""
1383  return _IMP_kernel._TestValue_get_float(self)
1384 
1385 
1386  def get_double(self):
1387  """get_double(_TestValue self) -> double const &"""
1388  return _IMP_kernel._TestValue_get_double(self)
1389 
1390 
1391  def get_Float(self):
1392  """get_Float(_TestValue self) -> IMP::Float const &"""
1393  return _IMP_kernel._TestValue_get_Float(self)
1394 
1395 
1396  def get_int(self):
1397  """get_int(_TestValue self) -> int const &"""
1398  return _IMP_kernel._TestValue_get_int(self)
1399 
1400 
1401  def get_Int(self):
1402  """get_Int(_TestValue self) -> IMP::Int const &"""
1403  return _IMP_kernel._TestValue_get_Int(self)
1404 
1405 
1406  def get_string(self):
1407  """get_string(_TestValue self) -> std::string const &"""
1408  return _IMP_kernel._TestValue_get_string(self)
1409 
1410 
1411  def get_String(self):
1412  """get_String(_TestValue self) -> IMP::String const &"""
1413  return _IMP_kernel._TestValue_get_String(self)
1414 
1415 
1416  def __str__(self):
1417  """__str__(_TestValue self) -> std::string"""
1418  return _IMP_kernel._TestValue___str__(self)
1419 
1420 
1421  def __repr__(self):
1422  """__repr__(_TestValue self) -> std::string"""
1423  return _IMP_kernel._TestValue___repr__(self)
1424 
1425  __swig_destroy__ = _IMP_kernel.delete__TestValue
1426  __del__ = lambda self: None
1427 _TestValue_swigregister = _IMP_kernel._TestValue_swigregister
1428 _TestValue_swigregister(_TestValue)
1429 
1430 
1431 def _pass_plain_pair(p):
1432  """_pass_plain_pair(IMP::FloatPair p) -> IMP::FloatPair"""
1433  return _IMP_kernel._pass_plain_pair(p)
1434 
1435 def _pass_overloaded_strings(*args):
1436  """
1437  _pass_overloaded_strings(IMP::Strings const & a, int arg2) -> IMP::Strings
1438  _pass_overloaded_strings(IMP::Strings const & a) -> IMP::Strings
1439  """
1440  return _IMP_kernel._pass_overloaded_strings(*args)
1441 
1442 def _pass_pair(p):
1443  """_pass_pair(IMP::DerivativePair const & p) -> IMP::DerivativePair"""
1444  return _IMP_kernel._pass_pair(p)
1445 
1446 def _pass_floats(input):
1447  """_pass_floats(IMP::Floats const & input) -> IMP::Floats"""
1448  return _IMP_kernel._pass_floats(input)
1449 
1450 def _pass_ints(input):
1451  """_pass_ints(IMP::Ints input) -> IMP::Ints"""
1452  return _IMP_kernel._pass_ints(input)
1453 
1454 def _pass_ints_list(input):
1455  """_pass_ints_list(IMP::IntsList const & input) -> IMP::IntsList"""
1456  return _IMP_kernel._pass_ints_list(input)
1457 
1458 def _pass_ints_lists(input):
1459  """_pass_ints_lists(IMP::IntsLists const & input) -> IMP::IntsLists"""
1460  return _IMP_kernel._pass_ints_lists(input)
1461 
1462 def _pass_strings(input):
1463  """_pass_strings(IMP::Strings const & input) -> IMP::Strings const &"""
1464  return _IMP_kernel._pass_strings(input)
1465 class _TestObject(Object):
1466  """Proxy of C++ IMP::internal::_TestObject class."""
1467 
1468  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1469 
1470  def __init__(self):
1471  """__init__(IMP::internal::_TestObject self) -> _TestObject"""
1472  this = _IMP_kernel.new__TestObject()
1473  try:
1474  self.this.append(this)
1475  except:
1476  self.this = this
1477 
1478  def get_version_info(self):
1479  """get_version_info(_TestObject self) -> VersionInfo"""
1480  return _IMP_kernel._TestObject_get_version_info(self)
1481 
1482 
1483  def __str__(self):
1484  """__str__(_TestObject self) -> std::string"""
1485  return _IMP_kernel._TestObject___str__(self)
1486 
1487 
1488  def __repr__(self):
1489  """__repr__(_TestObject self) -> std::string"""
1490  return _IMP_kernel._TestObject___repr__(self)
1491 
1492 
1493  @staticmethod
1494  def get_from(o):
1495  return _object_cast_to__TestObject(o)
1496 
1497 _TestObject_swigregister = _IMP_kernel._TestObject_swigregister
1498 _TestObject_swigregister(_TestObject)
1499 
1500 
1501 def get_live_object_names():
1502  """get_live_object_names() -> IMP::Strings"""
1503  return _IMP_kernel.get_live_object_names()
1504 
1505 def get_live_objects():
1506  """get_live_objects() -> IMP::Objects"""
1507  return _IMP_kernel.get_live_objects()
1508 
1509 def set_show_leaked_objects(tf):
1510  """set_show_leaked_objects(bool tf)"""
1511  return _IMP_kernel.set_show_leaked_objects(tf)
1512 
1513 def set_deprecation_warnings(tf):
1514  """set_deprecation_warnings(bool tf)"""
1515  return _IMP_kernel.set_deprecation_warnings(tf)
1516 
1518  """set_deprecation_exceptions(bool tf)"""
1519  return _IMP_kernel.set_deprecation_exceptions(tf)
1520 
1522  """get_deprecation_exceptions() -> bool"""
1523  return _IMP_kernel.get_deprecation_exceptions()
1524 
1525 def handle_use_deprecated(message):
1526  """handle_use_deprecated(std::string message)"""
1527  return _IMP_kernel.handle_use_deprecated(message)
1528 
1529 def get_number_of_threads():
1530  """get_number_of_threads() -> unsigned int"""
1531  return _IMP_kernel.get_number_of_threads()
1532 
1533 def set_number_of_threads(n):
1534  """set_number_of_threads(unsigned int n)"""
1535  return _IMP_kernel.set_number_of_threads(n)
1536 class SetNumberOfThreads(_RAII):
1537  """Proxy of C++ IMP::SetNumberOfThreads class."""
1538 
1539  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1540 
1541  def __init__(self, *args):
1542  """
1543  __init__(IMP::SetNumberOfThreads self) -> SetNumberOfThreads
1544  __init__(IMP::SetNumberOfThreads self, unsigned int n) -> SetNumberOfThreads
1545  """
1546  this = _IMP_kernel.new_SetNumberOfThreads(*args)
1547  try:
1548  self.this.append(this)
1549  except:
1550  self.this = this
1551 
1552  def set(self, n):
1553  """set(SetNumberOfThreads self, unsigned int n)"""
1554  return _IMP_kernel.SetNumberOfThreads_set(self, n)
1555 
1556 
1557  def reset(self):
1558  """reset(SetNumberOfThreads self)"""
1559  return _IMP_kernel.SetNumberOfThreads_reset(self)
1560 
1561  __swig_destroy__ = _IMP_kernel.delete_SetNumberOfThreads
1562  __del__ = lambda self: None
1563 
1564  def show(self, *args):
1565  """
1566  show(SetNumberOfThreads self, _ostream out)
1567  show(SetNumberOfThreads self)
1568  """
1569  return _IMP_kernel.SetNumberOfThreads_show(self, *args)
1570 
1571 
1572  def __enter__(self):
1573  return self
1574  def __exit__(self, exc_type, exc_val, exc_tb):
1575  self.reset()
1576  return False
1577 
1578 
1579  def __str__(self):
1580  """__str__(SetNumberOfThreads self) -> std::string"""
1581  return _IMP_kernel.SetNumberOfThreads___str__(self)
1582 
1583 
1584  def __repr__(self):
1585  """__repr__(SetNumberOfThreads self) -> std::string"""
1586  return _IMP_kernel.SetNumberOfThreads___repr__(self)
1587 
1588 SetNumberOfThreads_swigregister = _IMP_kernel.SetNumberOfThreads_swigregister
1589 SetNumberOfThreads_swigregister(SetNumberOfThreads)
1590 
1591 
1592 def clear_statistics():
1593  """clear_statistics()"""
1594  return _IMP_kernel.clear_statistics()
1595 
1596 def show_timings(out):
1597  """show_timings(TextOutput out)"""
1598  return _IMP_kernel.show_timings(out)
1599 class Timer(_RAII):
1600  """Proxy of C++ IMP::Timer class."""
1601 
1602  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1603  __repr__ = _swig_repr
1604 
1605  def __init__(self, *args):
1606  """
1607  __init__(IMP::Timer self, Object object, std::string const & operation) -> Timer
1608  __init__(IMP::Timer self, Object object, char const * operation) -> Timer
1609  __init__(IMP::Timer self, std::string operation) -> Timer
1610  """
1611  this = _IMP_kernel.new_Timer(*args)
1612  try:
1613  self.this.append(this)
1614  except:
1615  self.this = this
1616  __swig_destroy__ = _IMP_kernel.delete_Timer
1617  __del__ = lambda self: None
1618 Timer_swigregister = _IMP_kernel.Timer_swigregister
1619 Timer_swigregister(Timer)
1620 
1621 
1622 def set_statistics_level(l):
1623  """set_statistics_level(IMP::StatisticsLevel l)"""
1624  return _IMP_kernel.set_statistics_level(l)
1625 
1626 import os
1627 i_m_p="IMP_MODULE_PATH"
1628 if i_m_p in os.environ.keys():
1629  __path__.insert(0, os.environ[i_m_p])
1630 
1631 def _forward_add_attribute(self, name, value, opt=None):
1632  if opt is not None:
1633  self.get_particle().add_attribute(name, value, opt)
1634  else:
1635  self.get_particle().add_attribute(name, value)
1636 def _forward_get_value(self, name):
1637  self.get_particle().get_value(name)
1638 def _forward_set_value(self, name, value):
1639  self.get_particle().set_value(name, value)
1640 
1641 
1642 build="release"
1643 
1644 
1645 _object_types.append("Constraint")
1646 
1647 
1648 def _object_cast_to_Constraint(o):
1649  """_object_cast_to_Constraint(Object o) -> Constraint"""
1650  return _IMP_kernel._object_cast_to_Constraint(o)
1651 
1652 _object_types.append("Undecorator")
1653 
1654 
1655 def _object_cast_to_Undecorator(o):
1656  """_object_cast_to_Undecorator(Object o) -> Undecorator"""
1657  return _IMP_kernel._object_cast_to_Undecorator(o)
1658 
1659 _object_types.append("Container")
1660 
1661 
1662 def _object_cast_to_Container(o):
1663  """_object_cast_to_Container(Object o) -> Container"""
1664  return _IMP_kernel._object_cast_to_Container(o)
1665 
1666 _object_types.append("Optimizer")
1667 
1668 
1669 def _object_cast_to_Optimizer(o):
1670  """_object_cast_to_Optimizer(Object o) -> Optimizer"""
1671  return _IMP_kernel._object_cast_to_Optimizer(o)
1672 
1673 _object_types.append("AttributeOptimizer")
1674 
1675 
1676 def _object_cast_to_AttributeOptimizer(o):
1677  """_object_cast_to_AttributeOptimizer(Object o) -> AttributeOptimizer"""
1678  return _IMP_kernel._object_cast_to_AttributeOptimizer(o)
1679 
1680 _object_types.append("OptimizerState")
1681 
1682 
1683 def _object_cast_to_OptimizerState(o):
1684  """_object_cast_to_OptimizerState(Object o) -> OptimizerState"""
1685  return _IMP_kernel._object_cast_to_OptimizerState(o)
1686 
1687 _object_types.append("PairContainer")
1688 
1689 
1690 def _object_cast_to_PairContainer(o):
1691  """_object_cast_to_PairContainer(Object o) -> PairContainer"""
1692  return _IMP_kernel._object_cast_to_PairContainer(o)
1693 
1694 _object_types.append("PairModifier")
1695 
1696 
1697 def _object_cast_to_PairModifier(o):
1698  """_object_cast_to_PairModifier(Object o) -> PairModifier"""
1699  return _IMP_kernel._object_cast_to_PairModifier(o)
1700 
1701 _object_types.append("PairScore")
1702 
1703 
1704 def _object_cast_to_PairScore(o):
1705  """_object_cast_to_PairScore(Object o) -> PairScore"""
1706  return _IMP_kernel._object_cast_to_PairScore(o)
1707 
1708 _object_types.append("QuadContainer")
1709 
1710 
1711 def _object_cast_to_QuadContainer(o):
1712  """_object_cast_to_QuadContainer(Object o) -> QuadContainer"""
1713  return _IMP_kernel._object_cast_to_QuadContainer(o)
1714 
1715 _object_types.append("QuadModifier")
1716 
1717 
1718 def _object_cast_to_QuadModifier(o):
1719  """_object_cast_to_QuadModifier(Object o) -> QuadModifier"""
1720  return _IMP_kernel._object_cast_to_QuadModifier(o)
1721 
1722 _object_types.append("QuadScore")
1723 
1724 
1725 def _object_cast_to_QuadScore(o):
1726  """_object_cast_to_QuadScore(Object o) -> QuadScore"""
1727  return _IMP_kernel._object_cast_to_QuadScore(o)
1728 
1729 _object_types.append("Refiner")
1730 
1731 
1732 def _object_cast_to_Refiner(o):
1733  """_object_cast_to_Refiner(Object o) -> Refiner"""
1734  return _IMP_kernel._object_cast_to_Refiner(o)
1735 
1736 _object_types.append("Restraint")
1737 
1738 
1739 def _object_cast_to_Restraint(o):
1740  """_object_cast_to_Restraint(Object o) -> Restraint"""
1741  return _IMP_kernel._object_cast_to_Restraint(o)
1742 
1743 _object_types.append("Sampler")
1744 
1745 
1746 def _object_cast_to_Sampler(o):
1747  """_object_cast_to_Sampler(Object o) -> Sampler"""
1748  return _IMP_kernel._object_cast_to_Sampler(o)
1749 
1750 _object_types.append("ScoreState")
1751 
1752 
1753 def _object_cast_to_ScoreState(o):
1754  """_object_cast_to_ScoreState(Object o) -> ScoreState"""
1755  return _IMP_kernel._object_cast_to_ScoreState(o)
1756 
1757 _object_types.append("SingletonContainer")
1758 
1759 
1760 def _object_cast_to_SingletonContainer(o):
1761  """_object_cast_to_SingletonContainer(Object o) -> SingletonContainer"""
1762  return _IMP_kernel._object_cast_to_SingletonContainer(o)
1763 
1764 _object_types.append("SingletonModifier")
1765 
1766 
1767 def _object_cast_to_SingletonModifier(o):
1768  """_object_cast_to_SingletonModifier(Object o) -> SingletonModifier"""
1769  return _IMP_kernel._object_cast_to_SingletonModifier(o)
1770 
1771 _object_types.append("SingletonScore")
1772 
1773 
1774 def _object_cast_to_SingletonScore(o):
1775  """_object_cast_to_SingletonScore(Object o) -> SingletonScore"""
1776  return _IMP_kernel._object_cast_to_SingletonScore(o)
1777 
1778 _object_types.append("TripletContainer")
1779 
1780 
1781 def _object_cast_to_TripletContainer(o):
1782  """_object_cast_to_TripletContainer(Object o) -> TripletContainer"""
1783  return _IMP_kernel._object_cast_to_TripletContainer(o)
1784 
1785 _object_types.append("TripletModifier")
1786 
1787 
1788 def _object_cast_to_TripletModifier(o):
1789  """_object_cast_to_TripletModifier(Object o) -> TripletModifier"""
1790  return _IMP_kernel._object_cast_to_TripletModifier(o)
1791 
1792 _object_types.append("TripletScore")
1793 
1794 
1795 def _object_cast_to_TripletScore(o):
1796  """_object_cast_to_TripletScore(Object o) -> TripletScore"""
1797  return _IMP_kernel._object_cast_to_TripletScore(o)
1798 
1799 _object_types.append("UnaryFunction")
1800 
1801 
1802 def _object_cast_to_UnaryFunction(o):
1803  """_object_cast_to_UnaryFunction(Object o) -> UnaryFunction"""
1804  return _IMP_kernel._object_cast_to_UnaryFunction(o)
1805 
1806 _object_types.append("ConfigurationSet")
1807 
1808 
1809 def _object_cast_to_ConfigurationSet(o):
1810  """_object_cast_to_ConfigurationSet(Object o) -> ConfigurationSet"""
1811  return _IMP_kernel._object_cast_to_ConfigurationSet(o)
1812 
1813 _object_types.append("Configuration")
1814 
1815 
1816 def _object_cast_to_Configuration(o):
1817  """_object_cast_to_Configuration(Object o) -> Configuration"""
1818  return _IMP_kernel._object_cast_to_Configuration(o)
1819 
1820 _object_types.append("Model")
1821 
1822 
1823 def _object_cast_to_Model(o):
1824  """_object_cast_to_Model(Object o) -> Model"""
1825  return _IMP_kernel._object_cast_to_Model(o)
1826 
1827 _object_types.append("Particle")
1828 
1829 
1830 def _object_cast_to_Particle(o):
1831  """_object_cast_to_Particle(Object o) -> Particle"""
1832  return _IMP_kernel._object_cast_to_Particle(o)
1833 
1834 _object_types.append("RestraintSet")
1835 
1836 
1837 def _object_cast_to_RestraintSet(o):
1838  """_object_cast_to_RestraintSet(Object o) -> RestraintSet"""
1839  return _IMP_kernel._object_cast_to_RestraintSet(o)
1840 
1841 ParticlePairsTemp=list
1842 _plural_types.append("ParticlePairsTemp")
1843 _value_types.append("ParticlePair")
1844 
1845 
1846 ParticleTripletsTemp=list
1847 _plural_types.append("ParticleTripletsTemp")
1848 _value_types.append("ParticleTriplet")
1849 
1850 
1851 ParticleQuadsTemp=list
1852 _plural_types.append("ParticleQuadsTemp")
1853 _value_types.append("ParticleQuad")
1854 
1855 
1856 ParticleIndexPairs=list
1857 _plural_types.append("ParticleIndexPairs")
1858 _value_types.append("ParticleIndexPair")
1859 
1860 
1861 ParticleIndexTriplets=list
1862 _plural_types.append("ParticleIndexTriplets")
1863 _value_types.append("ParticleIndexTriplet")
1864 
1865 
1866 ParticleIndexQuads=list
1867 _plural_types.append("ParticleIndexQuads")
1868 _value_types.append("ParticleIndexQuad")
1869 
1870 
1871 _object_types.append("SingletonPredicate")
1872 
1873 
1874 def _object_cast_to_SingletonPredicate(o):
1875  """_object_cast_to_SingletonPredicate(Object o) -> SingletonPredicate"""
1876  return _IMP_kernel._object_cast_to_SingletonPredicate(o)
1877 
1878 _object_types.append("PairPredicate")
1879 
1880 
1881 def _object_cast_to_PairPredicate(o):
1882  """_object_cast_to_PairPredicate(Object o) -> PairPredicate"""
1883  return _IMP_kernel._object_cast_to_PairPredicate(o)
1884 
1885 _object_types.append("TripletPredicate")
1886 
1887 
1888 def _object_cast_to_TripletPredicate(o):
1889  """_object_cast_to_TripletPredicate(Object o) -> TripletPredicate"""
1890  return _IMP_kernel._object_cast_to_TripletPredicate(o)
1891 
1892 _object_types.append("QuadPredicate")
1893 
1894 
1895 def _object_cast_to_QuadPredicate(o):
1896  """_object_cast_to_QuadPredicate(Object o) -> QuadPredicate"""
1897  return _IMP_kernel._object_cast_to_QuadPredicate(o)
1898 
1899 _object_types.append("SaveToConfigurationSetOptimizerState")
1900 
1901 
1902 def _object_cast_to_SaveToConfigurationSetOptimizerState(o):
1903  """_object_cast_to_SaveToConfigurationSetOptimizerState(Object o) -> SaveToConfigurationSetOptimizerState"""
1904  return _IMP_kernel._object_cast_to_SaveToConfigurationSetOptimizerState(o)
1905 
1906 EvaluationStates=list
1907 _plural_types.append("EvaluationStates")
1908 _value_types.append("EvaluationState")
1909 
1910 
1911 ScoreAccumulators=list
1912 _plural_types.append("ScoreAccumulators")
1913 _value_types.append("ScoreAccumulator")
1914 
1915 
1916 ParticleIndexes=list
1917 _plural_types.append("ParticleIndexes")
1918 _value_types.append("ParticleIndex")
1919 
1920 
1921 FloatIndexes=list
1922 _plural_types.append("FloatIndexes")
1923 _value_types.append("FloatIndex")
1924 
1925 
1926 FloatKeys=list
1927 _plural_types.append("FloatKeys")
1928 _value_types.append("FloatKey")
1929 
1930 
1931 IntKeys=list
1932 _plural_types.append("IntKeys")
1933 _value_types.append("IntKey")
1934 
1935 
1936 StringKeys=list
1937 _plural_types.append("StringKeys")
1938 _value_types.append("StringKey")
1939 
1940 
1941 ParticleIndexKeys=list
1942 _plural_types.append("ParticleIndexKeys")
1943 _value_types.append("ParticleIndexKey")
1944 
1945 
1946 ParticleIndexesKeys=list
1947 _plural_types.append("ParticleIndexesKeys")
1948 _value_types.append("ParticleIndexesKey")
1949 
1950 
1951 ObjectKeys=list
1952 _plural_types.append("ObjectKeys")
1953 _value_types.append("ObjectKey")
1954 
1955 
1956 ModelKeys=list
1957 _plural_types.append("ModelKeys")
1958 _value_types.append("ModelKey")
1959 
1960 
1961 _raii_types.append("ScopedSetFloatAttribute")
1962 
1963 
1964 _object_types.append("ScoringFunction")
1965 
1966 
1967 def _object_cast_to_ScoringFunction(o):
1968  """_object_cast_to_ScoringFunction(Object o) -> ScoringFunction"""
1969  return _IMP_kernel._object_cast_to_ScoringFunction(o)
1970 
1971 _object_types.append("ModelObject")
1972 
1973 
1974 def _object_cast_to_ModelObject(o):
1975  """_object_cast_to_ModelObject(Object o) -> ModelObject"""
1976  return _IMP_kernel._object_cast_to_ModelObject(o)
1977 
1978 def _TrivialDecorators(l=[]):
1979  return [_TrivialDecorator(x) for x in l]
1980 _plural_types.append("_TrivialDecorators")
1981 
1982 
1983 _value_types.append("_TrivialDecorator")
1984 
1985 
1986 def _TrivialDerivedDecorators(l=[]):
1987  return [_TrivialDerivedDecorator(x) for x in l]
1988 _plural_types.append("_TrivialDerivedDecorators")
1989 
1990 
1991 _value_types.append("_TrivialDerivedDecorator")
1992 
1993 
1994 def _TrivialTraitsDecorators(l=[]):
1995  return [_TrivialTraitsDecorator(x) for x in l]
1996 _plural_types.append("_TrivialTraitsDecorators")
1997 
1998 
1999 _value_types.append("_TrivialTraitsDecorator")
2000 
2001 
2002 _object_types.append("_ConstRestraint")
2003 
2004 
2005 def _object_cast_to__ConstRestraint(o):
2006  """_object_cast_to__ConstRestraint(Object o) -> _ConstRestraint"""
2007  return _IMP_kernel._object_cast_to__ConstRestraint(o)
2008 
2009 _object_types.append("_ConstOptimizer")
2010 
2011 
2012 def _object_cast_to__ConstOptimizer(o):
2013  """_object_cast_to__ConstOptimizer(Object o) -> _ConstOptimizer"""
2014  return _IMP_kernel._object_cast_to__ConstOptimizer(o)
2015 class DependencyGraph(Object):
2016  """Proxy of C++ IMP::internal::BoostDigraph<(IMP::DependencyGraph,p.IMP::ModelObject,IMP::ShowDependencyGraphVertex)> class."""
2017 
2018  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2019  __repr__ = _swig_repr
2020 
2021  def __init__(self):
2022  """__init__(IMP::internal::BoostDigraph<(IMP::DependencyGraph,p.IMP::ModelObject,IMP::ShowDependencyGraphVertex)> self) -> DependencyGraph"""
2023  this = _IMP_kernel.new_DependencyGraph()
2024  try:
2025  self.this.append(this)
2026  except:
2027  self.this = this
2028 
2029  def get_graph(self):
2030  """get_graph(DependencyGraph self) -> IMP::DependencyGraph const &"""
2031  return _IMP_kernel.DependencyGraph_get_graph(self)
2032 
2033 
2034  def get_vertices(self):
2035  """get_vertices(DependencyGraph self) -> IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptors"""
2036  return _IMP_kernel.DependencyGraph_get_vertices(self)
2037 
2038 
2039  def get_vertex_name(self, i):
2040  """get_vertex_name(DependencyGraph self, IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptor i) -> ModelObject"""
2041  return _IMP_kernel.DependencyGraph_get_vertex_name(self, i)
2042 
2043 
2044  def get_in_neighbors(self, v):
2045  """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"""
2046  return _IMP_kernel.DependencyGraph_get_in_neighbors(self, v)
2047 
2048 
2049  def get_out_neighbors(self, v):
2050  """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"""
2051  return _IMP_kernel.DependencyGraph_get_out_neighbors(self, v)
2052 
2053 
2054  def show_graphviz(self, *args):
2055  """
2056  show_graphviz(DependencyGraph self, _ostream out)
2057  show_graphviz(DependencyGraph self)
2058  """
2059  return _IMP_kernel.DependencyGraph_show_graphviz(self, *args)
2060 
2061 
2062  def get_graphviz_string(self):
2063  """get_graphviz_string(DependencyGraph self) -> std::string"""
2064  return _IMP_kernel.DependencyGraph_get_graphviz_string(self)
2065 
2066 
2067  def add_edge(self, v0, v1):
2068  """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)"""
2069  return _IMP_kernel.DependencyGraph_add_edge(self, v0, v1)
2070 
2071 
2072  def add_vertex(self, l):
2073  """add_vertex(DependencyGraph self, ModelObject l) -> IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptor"""
2074  return _IMP_kernel.DependencyGraph_add_vertex(self, l)
2075 
2076 
2077  def remove_vertex(self, l):
2078  """remove_vertex(DependencyGraph self, IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptor l)"""
2079  return _IMP_kernel.DependencyGraph_remove_vertex(self, l)
2080 
2081  __swig_destroy__ = _IMP_kernel.delete_DependencyGraph
2082  __del__ = lambda self: None
2083 DependencyGraph_swigregister = _IMP_kernel.DependencyGraph_swigregister
2084 DependencyGraph_swigregister(DependencyGraph)
2085 
2086 
2087 _value_types.append("DependencyGraph")
2088 
2089 class FloatKey(_Value):
2090  """Proxy of C++ IMP::Key<(0,true)> class."""
2091 
2092  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2093 
2094  def __init__(self, *args):
2095  """
2096  __init__(IMP::Key<(0,true)> self) -> FloatKey
2097  __init__(IMP::Key<(0,true)> self, std::string c) -> FloatKey
2098  __init__(IMP::Key<(0,true)> self, unsigned int i) -> FloatKey
2099  """
2100  this = _IMP_kernel.new_FloatKey(*args)
2101  try:
2102  self.this.append(this)
2103  except:
2104  self.this = this
2105 
2106  def add_key(sc):
2107  """add_key(std::string sc) -> unsigned int"""
2108  return _IMP_kernel.FloatKey_add_key(sc)
2109 
2110  add_key = staticmethod(add_key)
2111 
2112  def get_key_exists(sc):
2113  """get_key_exists(std::string sc) -> bool"""
2114  return _IMP_kernel.FloatKey_get_key_exists(sc)
2115 
2116  get_key_exists = staticmethod(get_key_exists)
2117 
2118  def get_string(self):
2119  """get_string(FloatKey self) -> std::string const"""
2120  return _IMP_kernel.FloatKey_get_string(self)
2121 
2122 
2123  def __cmp__(self, o):
2124  """__cmp__(FloatKey self, FloatKey o) -> int"""
2125  return _IMP_kernel.FloatKey___cmp__(self, o)
2126 
2127 
2128  def __eq__(self, o):
2129  """__eq__(FloatKey self, FloatKey o) -> bool"""
2130  return _IMP_kernel.FloatKey___eq__(self, o)
2131 
2132 
2133  def __ne__(self, o):
2134  """__ne__(FloatKey self, FloatKey o) -> bool"""
2135  return _IMP_kernel.FloatKey___ne__(self, o)
2136 
2137 
2138  def __lt__(self, o):
2139  """__lt__(FloatKey self, FloatKey o) -> bool"""
2140  return _IMP_kernel.FloatKey___lt__(self, o)
2141 
2142 
2143  def __gt__(self, o):
2144  """__gt__(FloatKey self, FloatKey o) -> bool"""
2145  return _IMP_kernel.FloatKey___gt__(self, o)
2146 
2147 
2148  def __ge__(self, o):
2149  """__ge__(FloatKey self, FloatKey o) -> bool"""
2150  return _IMP_kernel.FloatKey___ge__(self, o)
2151 
2152 
2153  def __le__(self, o):
2154  """__le__(FloatKey self, FloatKey o) -> bool"""
2155  return _IMP_kernel.FloatKey___le__(self, o)
2156 
2157 
2158  def __hash__(self):
2159  """__hash__(FloatKey self) -> std::size_t"""
2160  return _IMP_kernel.FloatKey___hash__(self)
2161 
2162 
2163  def show(self, *args):
2164  """
2165  show(FloatKey self, _ostream out)
2166  show(FloatKey self)
2167  """
2168  return _IMP_kernel.FloatKey_show(self, *args)
2169 
2170 
2171  def add_alias(old_key, new_name):
2172  """add_alias(FloatKey old_key, std::string new_name) -> FloatKey"""
2173  return _IMP_kernel.FloatKey_add_alias(old_key, new_name)
2174 
2175  add_alias = staticmethod(add_alias)
2176 
2177  def get_index(self):
2178  """get_index(FloatKey self) -> unsigned int"""
2179  return _IMP_kernel.FloatKey_get_index(self)
2180 
2181 
2182  def show_all(out):
2183  """show_all(_ostream out)"""
2184  return _IMP_kernel.FloatKey_show_all(out)
2185 
2186  show_all = staticmethod(show_all)
2187 
2188  def get_all_strings():
2189  """get_all_strings() -> IMP::Vector< std::string >"""
2190  return _IMP_kernel.FloatKey_get_all_strings()
2191 
2192  get_all_strings = staticmethod(get_all_strings)
2193 
2194  def get_number_unique():
2195  """get_number_unique() -> unsigned int"""
2196  return _IMP_kernel.FloatKey_get_number_unique()
2197 
2198  get_number_unique = staticmethod(get_number_unique)
2199 
2200  def __str__(self):
2201  """__str__(FloatKey self) -> std::string"""
2202  return _IMP_kernel.FloatKey___str__(self)
2203 
2204 
2205  def __repr__(self):
2206  """__repr__(FloatKey self) -> std::string"""
2207  return _IMP_kernel.FloatKey___repr__(self)
2208 
2209  __swig_destroy__ = _IMP_kernel.delete_FloatKey
2210  __del__ = lambda self: None
2211 FloatKey_swigregister = _IMP_kernel.FloatKey_swigregister
2212 FloatKey_swigregister(FloatKey)
2213 
2214 def FloatKey_add_key(sc):
2215  """FloatKey_add_key(std::string sc) -> unsigned int"""
2216  return _IMP_kernel.FloatKey_add_key(sc)
2217 
2218 def FloatKey_get_key_exists(sc):
2219  """FloatKey_get_key_exists(std::string sc) -> bool"""
2220  return _IMP_kernel.FloatKey_get_key_exists(sc)
2221 
2222 def FloatKey_add_alias(old_key, new_name):
2223  """FloatKey_add_alias(FloatKey old_key, std::string new_name) -> FloatKey"""
2224  return _IMP_kernel.FloatKey_add_alias(old_key, new_name)
2225 
2226 def FloatKey_show_all(out):
2227  """FloatKey_show_all(_ostream out)"""
2228  return _IMP_kernel.FloatKey_show_all(out)
2229 
2230 def FloatKey_get_all_strings():
2231  """FloatKey_get_all_strings() -> IMP::Vector< std::string >"""
2232  return _IMP_kernel.FloatKey_get_all_strings()
2233 
2234 def FloatKey_get_number_unique():
2235  """FloatKey_get_number_unique() -> unsigned int"""
2236  return _IMP_kernel.FloatKey_get_number_unique()
2237 
2238 class IntKey(_Value):
2239  """Proxy of C++ IMP::Key<(1,true)> class."""
2240 
2241  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2242 
2243  def __init__(self, *args):
2244  """
2245  __init__(IMP::Key<(1,true)> self) -> IntKey
2246  __init__(IMP::Key<(1,true)> self, std::string c) -> IntKey
2247  __init__(IMP::Key<(1,true)> self, unsigned int i) -> IntKey
2248  """
2249  this = _IMP_kernel.new_IntKey(*args)
2250  try:
2251  self.this.append(this)
2252  except:
2253  self.this = this
2254 
2255  def add_key(sc):
2256  """add_key(std::string sc) -> unsigned int"""
2257  return _IMP_kernel.IntKey_add_key(sc)
2258 
2259  add_key = staticmethod(add_key)
2260 
2261  def get_key_exists(sc):
2262  """get_key_exists(std::string sc) -> bool"""
2263  return _IMP_kernel.IntKey_get_key_exists(sc)
2264 
2265  get_key_exists = staticmethod(get_key_exists)
2266 
2267  def get_string(self):
2268  """get_string(IntKey self) -> std::string const"""
2269  return _IMP_kernel.IntKey_get_string(self)
2270 
2271 
2272  def __cmp__(self, o):
2273  """__cmp__(IntKey self, IntKey o) -> int"""
2274  return _IMP_kernel.IntKey___cmp__(self, o)
2275 
2276 
2277  def __eq__(self, o):
2278  """__eq__(IntKey self, IntKey o) -> bool"""
2279  return _IMP_kernel.IntKey___eq__(self, o)
2280 
2281 
2282  def __ne__(self, o):
2283  """__ne__(IntKey self, IntKey o) -> bool"""
2284  return _IMP_kernel.IntKey___ne__(self, o)
2285 
2286 
2287  def __lt__(self, o):
2288  """__lt__(IntKey self, IntKey o) -> bool"""
2289  return _IMP_kernel.IntKey___lt__(self, o)
2290 
2291 
2292  def __gt__(self, o):
2293  """__gt__(IntKey self, IntKey o) -> bool"""
2294  return _IMP_kernel.IntKey___gt__(self, o)
2295 
2296 
2297  def __ge__(self, o):
2298  """__ge__(IntKey self, IntKey o) -> bool"""
2299  return _IMP_kernel.IntKey___ge__(self, o)
2300 
2301 
2302  def __le__(self, o):
2303  """__le__(IntKey self, IntKey o) -> bool"""
2304  return _IMP_kernel.IntKey___le__(self, o)
2305 
2306 
2307  def __hash__(self):
2308  """__hash__(IntKey self) -> std::size_t"""
2309  return _IMP_kernel.IntKey___hash__(self)
2310 
2311 
2312  def show(self, *args):
2313  """
2314  show(IntKey self, _ostream out)
2315  show(IntKey self)
2316  """
2317  return _IMP_kernel.IntKey_show(self, *args)
2318 
2319 
2320  def add_alias(old_key, new_name):
2321  """add_alias(IntKey old_key, std::string new_name) -> IntKey"""
2322  return _IMP_kernel.IntKey_add_alias(old_key, new_name)
2323 
2324  add_alias = staticmethod(add_alias)
2325 
2326  def get_index(self):
2327  """get_index(IntKey self) -> unsigned int"""
2328  return _IMP_kernel.IntKey_get_index(self)
2329 
2330 
2331  def show_all(out):
2332  """show_all(_ostream out)"""
2333  return _IMP_kernel.IntKey_show_all(out)
2334 
2335  show_all = staticmethod(show_all)
2336 
2337  def get_all_strings():
2338  """get_all_strings() -> IMP::Vector< std::string >"""
2339  return _IMP_kernel.IntKey_get_all_strings()
2340 
2341  get_all_strings = staticmethod(get_all_strings)
2342 
2343  def get_number_unique():
2344  """get_number_unique() -> unsigned int"""
2345  return _IMP_kernel.IntKey_get_number_unique()
2346 
2347  get_number_unique = staticmethod(get_number_unique)
2348 
2349  def __str__(self):
2350  """__str__(IntKey self) -> std::string"""
2351  return _IMP_kernel.IntKey___str__(self)
2352 
2353 
2354  def __repr__(self):
2355  """__repr__(IntKey self) -> std::string"""
2356  return _IMP_kernel.IntKey___repr__(self)
2357 
2358  __swig_destroy__ = _IMP_kernel.delete_IntKey
2359  __del__ = lambda self: None
2360 IntKey_swigregister = _IMP_kernel.IntKey_swigregister
2361 IntKey_swigregister(IntKey)
2362 
2363 def IntKey_add_key(sc):
2364  """IntKey_add_key(std::string sc) -> unsigned int"""
2365  return _IMP_kernel.IntKey_add_key(sc)
2366 
2367 def IntKey_get_key_exists(sc):
2368  """IntKey_get_key_exists(std::string sc) -> bool"""
2369  return _IMP_kernel.IntKey_get_key_exists(sc)
2370 
2371 def IntKey_add_alias(old_key, new_name):
2372  """IntKey_add_alias(IntKey old_key, std::string new_name) -> IntKey"""
2373  return _IMP_kernel.IntKey_add_alias(old_key, new_name)
2374 
2375 def IntKey_show_all(out):
2376  """IntKey_show_all(_ostream out)"""
2377  return _IMP_kernel.IntKey_show_all(out)
2378 
2379 def IntKey_get_all_strings():
2380  """IntKey_get_all_strings() -> IMP::Vector< std::string >"""
2381  return _IMP_kernel.IntKey_get_all_strings()
2382 
2383 def IntKey_get_number_unique():
2384  """IntKey_get_number_unique() -> unsigned int"""
2385  return _IMP_kernel.IntKey_get_number_unique()
2386 
2387 class StringKey(_Value):
2388  """Proxy of C++ IMP::Key<(2,true)> class."""
2389 
2390  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2391 
2392  def __init__(self, *args):
2393  """
2394  __init__(IMP::Key<(2,true)> self) -> StringKey
2395  __init__(IMP::Key<(2,true)> self, std::string c) -> StringKey
2396  __init__(IMP::Key<(2,true)> self, unsigned int i) -> StringKey
2397  """
2398  this = _IMP_kernel.new_StringKey(*args)
2399  try:
2400  self.this.append(this)
2401  except:
2402  self.this = this
2403 
2404  def add_key(sc):
2405  """add_key(std::string sc) -> unsigned int"""
2406  return _IMP_kernel.StringKey_add_key(sc)
2407 
2408  add_key = staticmethod(add_key)
2409 
2410  def get_key_exists(sc):
2411  """get_key_exists(std::string sc) -> bool"""
2412  return _IMP_kernel.StringKey_get_key_exists(sc)
2413 
2414  get_key_exists = staticmethod(get_key_exists)
2415 
2416  def get_string(self):
2417  """get_string(StringKey self) -> std::string const"""
2418  return _IMP_kernel.StringKey_get_string(self)
2419 
2420 
2421  def __cmp__(self, o):
2422  """__cmp__(StringKey self, StringKey o) -> int"""
2423  return _IMP_kernel.StringKey___cmp__(self, o)
2424 
2425 
2426  def __eq__(self, o):
2427  """__eq__(StringKey self, StringKey o) -> bool"""
2428  return _IMP_kernel.StringKey___eq__(self, o)
2429 
2430 
2431  def __ne__(self, o):
2432  """__ne__(StringKey self, StringKey o) -> bool"""
2433  return _IMP_kernel.StringKey___ne__(self, o)
2434 
2435 
2436  def __lt__(self, o):
2437  """__lt__(StringKey self, StringKey o) -> bool"""
2438  return _IMP_kernel.StringKey___lt__(self, o)
2439 
2440 
2441  def __gt__(self, o):
2442  """__gt__(StringKey self, StringKey o) -> bool"""
2443  return _IMP_kernel.StringKey___gt__(self, o)
2444 
2445 
2446  def __ge__(self, o):
2447  """__ge__(StringKey self, StringKey o) -> bool"""
2448  return _IMP_kernel.StringKey___ge__(self, o)
2449 
2450 
2451  def __le__(self, o):
2452  """__le__(StringKey self, StringKey o) -> bool"""
2453  return _IMP_kernel.StringKey___le__(self, o)
2454 
2455 
2456  def __hash__(self):
2457  """__hash__(StringKey self) -> std::size_t"""
2458  return _IMP_kernel.StringKey___hash__(self)
2459 
2460 
2461  def show(self, *args):
2462  """
2463  show(StringKey self, _ostream out)
2464  show(StringKey self)
2465  """
2466  return _IMP_kernel.StringKey_show(self, *args)
2467 
2468 
2469  def add_alias(old_key, new_name):
2470  """add_alias(StringKey old_key, std::string new_name) -> StringKey"""
2471  return _IMP_kernel.StringKey_add_alias(old_key, new_name)
2472 
2473  add_alias = staticmethod(add_alias)
2474 
2475  def get_index(self):
2476  """get_index(StringKey self) -> unsigned int"""
2477  return _IMP_kernel.StringKey_get_index(self)
2478 
2479 
2480  def show_all(out):
2481  """show_all(_ostream out)"""
2482  return _IMP_kernel.StringKey_show_all(out)
2483 
2484  show_all = staticmethod(show_all)
2485 
2486  def get_all_strings():
2487  """get_all_strings() -> IMP::Vector< std::string >"""
2488  return _IMP_kernel.StringKey_get_all_strings()
2489 
2490  get_all_strings = staticmethod(get_all_strings)
2491 
2492  def get_number_unique():
2493  """get_number_unique() -> unsigned int"""
2494  return _IMP_kernel.StringKey_get_number_unique()
2495 
2496  get_number_unique = staticmethod(get_number_unique)
2497 
2498  def __str__(self):
2499  """__str__(StringKey self) -> std::string"""
2500  return _IMP_kernel.StringKey___str__(self)
2501 
2502 
2503  def __repr__(self):
2504  """__repr__(StringKey self) -> std::string"""
2505  return _IMP_kernel.StringKey___repr__(self)
2506 
2507  __swig_destroy__ = _IMP_kernel.delete_StringKey
2508  __del__ = lambda self: None
2509 StringKey_swigregister = _IMP_kernel.StringKey_swigregister
2510 StringKey_swigregister(StringKey)
2511 
2512 def StringKey_add_key(sc):
2513  """StringKey_add_key(std::string sc) -> unsigned int"""
2514  return _IMP_kernel.StringKey_add_key(sc)
2515 
2516 def StringKey_get_key_exists(sc):
2517  """StringKey_get_key_exists(std::string sc) -> bool"""
2518  return _IMP_kernel.StringKey_get_key_exists(sc)
2519 
2520 def StringKey_add_alias(old_key, new_name):
2521  """StringKey_add_alias(StringKey old_key, std::string new_name) -> StringKey"""
2522  return _IMP_kernel.StringKey_add_alias(old_key, new_name)
2523 
2524 def StringKey_show_all(out):
2525  """StringKey_show_all(_ostream out)"""
2526  return _IMP_kernel.StringKey_show_all(out)
2527 
2528 def StringKey_get_all_strings():
2529  """StringKey_get_all_strings() -> IMP::Vector< std::string >"""
2530  return _IMP_kernel.StringKey_get_all_strings()
2531 
2532 def StringKey_get_number_unique():
2533  """StringKey_get_number_unique() -> unsigned int"""
2534  return _IMP_kernel.StringKey_get_number_unique()
2535 
2536 class ParticleIndexKey(_Value):
2537  """Proxy of C++ IMP::Key<(3,true)> class."""
2538 
2539  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2540 
2541  def __init__(self, *args):
2542  """
2543  __init__(IMP::Key<(3,true)> self) -> ParticleIndexKey
2544  __init__(IMP::Key<(3,true)> self, std::string c) -> ParticleIndexKey
2545  __init__(IMP::Key<(3,true)> self, unsigned int i) -> ParticleIndexKey
2546  """
2547  this = _IMP_kernel.new_ParticleIndexKey(*args)
2548  try:
2549  self.this.append(this)
2550  except:
2551  self.this = this
2552 
2553  def add_key(sc):
2554  """add_key(std::string sc) -> unsigned int"""
2555  return _IMP_kernel.ParticleIndexKey_add_key(sc)
2556 
2557  add_key = staticmethod(add_key)
2558 
2559  def get_key_exists(sc):
2560  """get_key_exists(std::string sc) -> bool"""
2561  return _IMP_kernel.ParticleIndexKey_get_key_exists(sc)
2562 
2563  get_key_exists = staticmethod(get_key_exists)
2564 
2565  def get_string(self):
2566  """get_string(ParticleIndexKey self) -> std::string const"""
2567  return _IMP_kernel.ParticleIndexKey_get_string(self)
2568 
2569 
2570  def __cmp__(self, o):
2571  """__cmp__(ParticleIndexKey self, ParticleIndexKey o) -> int"""
2572  return _IMP_kernel.ParticleIndexKey___cmp__(self, o)
2573 
2574 
2575  def __eq__(self, o):
2576  """__eq__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2577  return _IMP_kernel.ParticleIndexKey___eq__(self, o)
2578 
2579 
2580  def __ne__(self, o):
2581  """__ne__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2582  return _IMP_kernel.ParticleIndexKey___ne__(self, o)
2583 
2584 
2585  def __lt__(self, o):
2586  """__lt__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2587  return _IMP_kernel.ParticleIndexKey___lt__(self, o)
2588 
2589 
2590  def __gt__(self, o):
2591  """__gt__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2592  return _IMP_kernel.ParticleIndexKey___gt__(self, o)
2593 
2594 
2595  def __ge__(self, o):
2596  """__ge__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2597  return _IMP_kernel.ParticleIndexKey___ge__(self, o)
2598 
2599 
2600  def __le__(self, o):
2601  """__le__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
2602  return _IMP_kernel.ParticleIndexKey___le__(self, o)
2603 
2604 
2605  def __hash__(self):
2606  """__hash__(ParticleIndexKey self) -> std::size_t"""
2607  return _IMP_kernel.ParticleIndexKey___hash__(self)
2608 
2609 
2610  def show(self, *args):
2611  """
2612  show(ParticleIndexKey self, _ostream out)
2613  show(ParticleIndexKey self)
2614  """
2615  return _IMP_kernel.ParticleIndexKey_show(self, *args)
2616 
2617 
2618  def add_alias(old_key, new_name):
2619  """add_alias(ParticleIndexKey old_key, std::string new_name) -> ParticleIndexKey"""
2620  return _IMP_kernel.ParticleIndexKey_add_alias(old_key, new_name)
2621 
2622  add_alias = staticmethod(add_alias)
2623 
2624  def get_index(self):
2625  """get_index(ParticleIndexKey self) -> unsigned int"""
2626  return _IMP_kernel.ParticleIndexKey_get_index(self)
2627 
2628 
2629  def show_all(out):
2630  """show_all(_ostream out)"""
2631  return _IMP_kernel.ParticleIndexKey_show_all(out)
2632 
2633  show_all = staticmethod(show_all)
2634 
2635  def get_all_strings():
2636  """get_all_strings() -> IMP::Vector< std::string >"""
2637  return _IMP_kernel.ParticleIndexKey_get_all_strings()
2638 
2639  get_all_strings = staticmethod(get_all_strings)
2640 
2641  def get_number_unique():
2642  """get_number_unique() -> unsigned int"""
2643  return _IMP_kernel.ParticleIndexKey_get_number_unique()
2644 
2645  get_number_unique = staticmethod(get_number_unique)
2646 
2647  def __str__(self):
2648  """__str__(ParticleIndexKey self) -> std::string"""
2649  return _IMP_kernel.ParticleIndexKey___str__(self)
2650 
2651 
2652  def __repr__(self):
2653  """__repr__(ParticleIndexKey self) -> std::string"""
2654  return _IMP_kernel.ParticleIndexKey___repr__(self)
2655 
2656  __swig_destroy__ = _IMP_kernel.delete_ParticleIndexKey
2657  __del__ = lambda self: None
2658 ParticleIndexKey_swigregister = _IMP_kernel.ParticleIndexKey_swigregister
2659 ParticleIndexKey_swigregister(ParticleIndexKey)
2660 
2661 def ParticleIndexKey_add_key(sc):
2662  """ParticleIndexKey_add_key(std::string sc) -> unsigned int"""
2663  return _IMP_kernel.ParticleIndexKey_add_key(sc)
2664 
2665 def ParticleIndexKey_get_key_exists(sc):
2666  """ParticleIndexKey_get_key_exists(std::string sc) -> bool"""
2667  return _IMP_kernel.ParticleIndexKey_get_key_exists(sc)
2668 
2669 def ParticleIndexKey_add_alias(old_key, new_name):
2670  """ParticleIndexKey_add_alias(ParticleIndexKey old_key, std::string new_name) -> ParticleIndexKey"""
2671  return _IMP_kernel.ParticleIndexKey_add_alias(old_key, new_name)
2672 
2673 def ParticleIndexKey_show_all(out):
2674  """ParticleIndexKey_show_all(_ostream out)"""
2675  return _IMP_kernel.ParticleIndexKey_show_all(out)
2676 
2677 def ParticleIndexKey_get_all_strings():
2678  """ParticleIndexKey_get_all_strings() -> IMP::Vector< std::string >"""
2679  return _IMP_kernel.ParticleIndexKey_get_all_strings()
2680 
2681 def ParticleIndexKey_get_number_unique():
2682  """ParticleIndexKey_get_number_unique() -> unsigned int"""
2683  return _IMP_kernel.ParticleIndexKey_get_number_unique()
2684 
2685 class ObjectKey(_Value):
2686  """Proxy of C++ IMP::Key<(4,true)> class."""
2687 
2688  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2689 
2690  def __init__(self, *args):
2691  """
2692  __init__(IMP::Key<(4,true)> self) -> ObjectKey
2693  __init__(IMP::Key<(4,true)> self, std::string c) -> ObjectKey
2694  __init__(IMP::Key<(4,true)> self, unsigned int i) -> ObjectKey
2695  """
2696  this = _IMP_kernel.new_ObjectKey(*args)
2697  try:
2698  self.this.append(this)
2699  except:
2700  self.this = this
2701 
2702  def add_key(sc):
2703  """add_key(std::string sc) -> unsigned int"""
2704  return _IMP_kernel.ObjectKey_add_key(sc)
2705 
2706  add_key = staticmethod(add_key)
2707 
2708  def get_key_exists(sc):
2709  """get_key_exists(std::string sc) -> bool"""
2710  return _IMP_kernel.ObjectKey_get_key_exists(sc)
2711 
2712  get_key_exists = staticmethod(get_key_exists)
2713 
2714  def get_string(self):
2715  """get_string(ObjectKey self) -> std::string const"""
2716  return _IMP_kernel.ObjectKey_get_string(self)
2717 
2718 
2719  def __cmp__(self, o):
2720  """__cmp__(ObjectKey self, ObjectKey o) -> int"""
2721  return _IMP_kernel.ObjectKey___cmp__(self, o)
2722 
2723 
2724  def __eq__(self, o):
2725  """__eq__(ObjectKey self, ObjectKey o) -> bool"""
2726  return _IMP_kernel.ObjectKey___eq__(self, o)
2727 
2728 
2729  def __ne__(self, o):
2730  """__ne__(ObjectKey self, ObjectKey o) -> bool"""
2731  return _IMP_kernel.ObjectKey___ne__(self, o)
2732 
2733 
2734  def __lt__(self, o):
2735  """__lt__(ObjectKey self, ObjectKey o) -> bool"""
2736  return _IMP_kernel.ObjectKey___lt__(self, o)
2737 
2738 
2739  def __gt__(self, o):
2740  """__gt__(ObjectKey self, ObjectKey o) -> bool"""
2741  return _IMP_kernel.ObjectKey___gt__(self, o)
2742 
2743 
2744  def __ge__(self, o):
2745  """__ge__(ObjectKey self, ObjectKey o) -> bool"""
2746  return _IMP_kernel.ObjectKey___ge__(self, o)
2747 
2748 
2749  def __le__(self, o):
2750  """__le__(ObjectKey self, ObjectKey o) -> bool"""
2751  return _IMP_kernel.ObjectKey___le__(self, o)
2752 
2753 
2754  def __hash__(self):
2755  """__hash__(ObjectKey self) -> std::size_t"""
2756  return _IMP_kernel.ObjectKey___hash__(self)
2757 
2758 
2759  def show(self, *args):
2760  """
2761  show(ObjectKey self, _ostream out)
2762  show(ObjectKey self)
2763  """
2764  return _IMP_kernel.ObjectKey_show(self, *args)
2765 
2766 
2767  def add_alias(old_key, new_name):
2768  """add_alias(ObjectKey old_key, std::string new_name) -> ObjectKey"""
2769  return _IMP_kernel.ObjectKey_add_alias(old_key, new_name)
2770 
2771  add_alias = staticmethod(add_alias)
2772 
2773  def get_index(self):
2774  """get_index(ObjectKey self) -> unsigned int"""
2775  return _IMP_kernel.ObjectKey_get_index(self)
2776 
2777 
2778  def show_all(out):
2779  """show_all(_ostream out)"""
2780  return _IMP_kernel.ObjectKey_show_all(out)
2781 
2782  show_all = staticmethod(show_all)
2783 
2784  def get_all_strings():
2785  """get_all_strings() -> IMP::Vector< std::string >"""
2786  return _IMP_kernel.ObjectKey_get_all_strings()
2787 
2788  get_all_strings = staticmethod(get_all_strings)
2789 
2790  def get_number_unique():
2791  """get_number_unique() -> unsigned int"""
2792  return _IMP_kernel.ObjectKey_get_number_unique()
2793 
2794  get_number_unique = staticmethod(get_number_unique)
2795 
2796  def __str__(self):
2797  """__str__(ObjectKey self) -> std::string"""
2798  return _IMP_kernel.ObjectKey___str__(self)
2799 
2800 
2801  def __repr__(self):
2802  """__repr__(ObjectKey self) -> std::string"""
2803  return _IMP_kernel.ObjectKey___repr__(self)
2804 
2805  __swig_destroy__ = _IMP_kernel.delete_ObjectKey
2806  __del__ = lambda self: None
2807 ObjectKey_swigregister = _IMP_kernel.ObjectKey_swigregister
2808 ObjectKey_swigregister(ObjectKey)
2809 
2810 def ObjectKey_add_key(sc):
2811  """ObjectKey_add_key(std::string sc) -> unsigned int"""
2812  return _IMP_kernel.ObjectKey_add_key(sc)
2813 
2814 def ObjectKey_get_key_exists(sc):
2815  """ObjectKey_get_key_exists(std::string sc) -> bool"""
2816  return _IMP_kernel.ObjectKey_get_key_exists(sc)
2817 
2818 def ObjectKey_add_alias(old_key, new_name):
2819  """ObjectKey_add_alias(ObjectKey old_key, std::string new_name) -> ObjectKey"""
2820  return _IMP_kernel.ObjectKey_add_alias(old_key, new_name)
2821 
2822 def ObjectKey_show_all(out):
2823  """ObjectKey_show_all(_ostream out)"""
2824  return _IMP_kernel.ObjectKey_show_all(out)
2825 
2826 def ObjectKey_get_all_strings():
2827  """ObjectKey_get_all_strings() -> IMP::Vector< std::string >"""
2828  return _IMP_kernel.ObjectKey_get_all_strings()
2829 
2830 def ObjectKey_get_number_unique():
2831  """ObjectKey_get_number_unique() -> unsigned int"""
2832  return _IMP_kernel.ObjectKey_get_number_unique()
2833 
2834 class ParticleIndexesKey(_Value):
2835  """Proxy of C++ IMP::Key<(6,true)> class."""
2836 
2837  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2838 
2839  def __init__(self, *args):
2840  """
2841  __init__(IMP::Key<(6,true)> self) -> ParticleIndexesKey
2842  __init__(IMP::Key<(6,true)> self, std::string c) -> ParticleIndexesKey
2843  __init__(IMP::Key<(6,true)> self, unsigned int i) -> ParticleIndexesKey
2844  """
2845  this = _IMP_kernel.new_ParticleIndexesKey(*args)
2846  try:
2847  self.this.append(this)
2848  except:
2849  self.this = this
2850 
2851  def add_key(sc):
2852  """add_key(std::string sc) -> unsigned int"""
2853  return _IMP_kernel.ParticleIndexesKey_add_key(sc)
2854 
2855  add_key = staticmethod(add_key)
2856 
2857  def get_key_exists(sc):
2858  """get_key_exists(std::string sc) -> bool"""
2859  return _IMP_kernel.ParticleIndexesKey_get_key_exists(sc)
2860 
2861  get_key_exists = staticmethod(get_key_exists)
2862 
2863  def get_string(self):
2864  """get_string(ParticleIndexesKey self) -> std::string const"""
2865  return _IMP_kernel.ParticleIndexesKey_get_string(self)
2866 
2867 
2868  def __cmp__(self, o):
2869  """__cmp__(ParticleIndexesKey self, ParticleIndexesKey o) -> int"""
2870  return _IMP_kernel.ParticleIndexesKey___cmp__(self, o)
2871 
2872 
2873  def __eq__(self, o):
2874  """__eq__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
2875  return _IMP_kernel.ParticleIndexesKey___eq__(self, o)
2876 
2877 
2878  def __ne__(self, o):
2879  """__ne__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
2880  return _IMP_kernel.ParticleIndexesKey___ne__(self, o)
2881 
2882 
2883  def __lt__(self, o):
2884  """__lt__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
2885  return _IMP_kernel.ParticleIndexesKey___lt__(self, o)
2886 
2887 
2888  def __gt__(self, o):
2889  """__gt__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
2890  return _IMP_kernel.ParticleIndexesKey___gt__(self, o)
2891 
2892 
2893  def __ge__(self, o):
2894  """__ge__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
2895  return _IMP_kernel.ParticleIndexesKey___ge__(self, o)
2896 
2897 
2898  def __le__(self, o):
2899  """__le__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
2900  return _IMP_kernel.ParticleIndexesKey___le__(self, o)
2901 
2902 
2903  def __hash__(self):
2904  """__hash__(ParticleIndexesKey self) -> std::size_t"""
2905  return _IMP_kernel.ParticleIndexesKey___hash__(self)
2906 
2907 
2908  def show(self, *args):
2909  """
2910  show(ParticleIndexesKey self, _ostream out)
2911  show(ParticleIndexesKey self)
2912  """
2913  return _IMP_kernel.ParticleIndexesKey_show(self, *args)
2914 
2915 
2916  def add_alias(old_key, new_name):
2917  """add_alias(ParticleIndexesKey old_key, std::string new_name) -> ParticleIndexesKey"""
2918  return _IMP_kernel.ParticleIndexesKey_add_alias(old_key, new_name)
2919 
2920  add_alias = staticmethod(add_alias)
2921 
2922  def get_index(self):
2923  """get_index(ParticleIndexesKey self) -> unsigned int"""
2924  return _IMP_kernel.ParticleIndexesKey_get_index(self)
2925 
2926 
2927  def show_all(out):
2928  """show_all(_ostream out)"""
2929  return _IMP_kernel.ParticleIndexesKey_show_all(out)
2930 
2931  show_all = staticmethod(show_all)
2932 
2933  def get_all_strings():
2934  """get_all_strings() -> IMP::Vector< std::string >"""
2935  return _IMP_kernel.ParticleIndexesKey_get_all_strings()
2936 
2937  get_all_strings = staticmethod(get_all_strings)
2938 
2939  def get_number_unique():
2940  """get_number_unique() -> unsigned int"""
2941  return _IMP_kernel.ParticleIndexesKey_get_number_unique()
2942 
2943  get_number_unique = staticmethod(get_number_unique)
2944 
2945  def __str__(self):
2946  """__str__(ParticleIndexesKey self) -> std::string"""
2947  return _IMP_kernel.ParticleIndexesKey___str__(self)
2948 
2949 
2950  def __repr__(self):
2951  """__repr__(ParticleIndexesKey self) -> std::string"""
2952  return _IMP_kernel.ParticleIndexesKey___repr__(self)
2953 
2954  __swig_destroy__ = _IMP_kernel.delete_ParticleIndexesKey
2955  __del__ = lambda self: None
2956 ParticleIndexesKey_swigregister = _IMP_kernel.ParticleIndexesKey_swigregister
2957 ParticleIndexesKey_swigregister(ParticleIndexesKey)
2958 
2959 def ParticleIndexesKey_add_key(sc):
2960  """ParticleIndexesKey_add_key(std::string sc) -> unsigned int"""
2961  return _IMP_kernel.ParticleIndexesKey_add_key(sc)
2962 
2963 def ParticleIndexesKey_get_key_exists(sc):
2964  """ParticleIndexesKey_get_key_exists(std::string sc) -> bool"""
2965  return _IMP_kernel.ParticleIndexesKey_get_key_exists(sc)
2966 
2967 def ParticleIndexesKey_add_alias(old_key, new_name):
2968  """ParticleIndexesKey_add_alias(ParticleIndexesKey old_key, std::string new_name) -> ParticleIndexesKey"""
2969  return _IMP_kernel.ParticleIndexesKey_add_alias(old_key, new_name)
2970 
2971 def ParticleIndexesKey_show_all(out):
2972  """ParticleIndexesKey_show_all(_ostream out)"""
2973  return _IMP_kernel.ParticleIndexesKey_show_all(out)
2974 
2975 def ParticleIndexesKey_get_all_strings():
2976  """ParticleIndexesKey_get_all_strings() -> IMP::Vector< std::string >"""
2977  return _IMP_kernel.ParticleIndexesKey_get_all_strings()
2978 
2979 def ParticleIndexesKey_get_number_unique():
2980  """ParticleIndexesKey_get_number_unique() -> unsigned int"""
2981  return _IMP_kernel.ParticleIndexesKey_get_number_unique()
2982 
2983 class ModelKey(_Value):
2984  """Proxy of C++ IMP::Key<(8,true)> class."""
2985 
2986  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2987 
2988  def __init__(self, *args):
2989  """
2990  __init__(IMP::Key<(8,true)> self) -> ModelKey
2991  __init__(IMP::Key<(8,true)> self, std::string c) -> ModelKey
2992  __init__(IMP::Key<(8,true)> self, unsigned int i) -> ModelKey
2993  """
2994  this = _IMP_kernel.new_ModelKey(*args)
2995  try:
2996  self.this.append(this)
2997  except:
2998  self.this = this
2999 
3000  def add_key(sc):
3001  """add_key(std::string sc) -> unsigned int"""
3002  return _IMP_kernel.ModelKey_add_key(sc)
3003 
3004  add_key = staticmethod(add_key)
3005 
3006  def get_key_exists(sc):
3007  """get_key_exists(std::string sc) -> bool"""
3008  return _IMP_kernel.ModelKey_get_key_exists(sc)
3009 
3010  get_key_exists = staticmethod(get_key_exists)
3011 
3012  def get_string(self):
3013  """get_string(ModelKey self) -> std::string const"""
3014  return _IMP_kernel.ModelKey_get_string(self)
3015 
3016 
3017  def __cmp__(self, o):
3018  """__cmp__(ModelKey self, ModelKey o) -> int"""
3019  return _IMP_kernel.ModelKey___cmp__(self, o)
3020 
3021 
3022  def __eq__(self, o):
3023  """__eq__(ModelKey self, ModelKey o) -> bool"""
3024  return _IMP_kernel.ModelKey___eq__(self, o)
3025 
3026 
3027  def __ne__(self, o):
3028  """__ne__(ModelKey self, ModelKey o) -> bool"""
3029  return _IMP_kernel.ModelKey___ne__(self, o)
3030 
3031 
3032  def __lt__(self, o):
3033  """__lt__(ModelKey self, ModelKey o) -> bool"""
3034  return _IMP_kernel.ModelKey___lt__(self, o)
3035 
3036 
3037  def __gt__(self, o):
3038  """__gt__(ModelKey self, ModelKey o) -> bool"""
3039  return _IMP_kernel.ModelKey___gt__(self, o)
3040 
3041 
3042  def __ge__(self, o):
3043  """__ge__(ModelKey self, ModelKey o) -> bool"""
3044  return _IMP_kernel.ModelKey___ge__(self, o)
3045 
3046 
3047  def __le__(self, o):
3048  """__le__(ModelKey self, ModelKey o) -> bool"""
3049  return _IMP_kernel.ModelKey___le__(self, o)
3050 
3051 
3052  def __hash__(self):
3053  """__hash__(ModelKey self) -> std::size_t"""
3054  return _IMP_kernel.ModelKey___hash__(self)
3055 
3056 
3057  def show(self, *args):
3058  """
3059  show(ModelKey self, _ostream out)
3060  show(ModelKey self)
3061  """
3062  return _IMP_kernel.ModelKey_show(self, *args)
3063 
3064 
3065  def add_alias(old_key, new_name):
3066  """add_alias(ModelKey old_key, std::string new_name) -> ModelKey"""
3067  return _IMP_kernel.ModelKey_add_alias(old_key, new_name)
3068 
3069  add_alias = staticmethod(add_alias)
3070 
3071  def get_index(self):
3072  """get_index(ModelKey self) -> unsigned int"""
3073  return _IMP_kernel.ModelKey_get_index(self)
3074 
3075 
3076  def show_all(out):
3077  """show_all(_ostream out)"""
3078  return _IMP_kernel.ModelKey_show_all(out)
3079 
3080  show_all = staticmethod(show_all)
3081 
3082  def get_all_strings():
3083  """get_all_strings() -> IMP::Vector< std::string >"""
3084  return _IMP_kernel.ModelKey_get_all_strings()
3085 
3086  get_all_strings = staticmethod(get_all_strings)
3087 
3088  def get_number_unique():
3089  """get_number_unique() -> unsigned int"""
3090  return _IMP_kernel.ModelKey_get_number_unique()
3091 
3092  get_number_unique = staticmethod(get_number_unique)
3093 
3094  def __str__(self):
3095  """__str__(ModelKey self) -> std::string"""
3096  return _IMP_kernel.ModelKey___str__(self)
3097 
3098 
3099  def __repr__(self):
3100  """__repr__(ModelKey self) -> std::string"""
3101  return _IMP_kernel.ModelKey___repr__(self)
3102 
3103  __swig_destroy__ = _IMP_kernel.delete_ModelKey
3104  __del__ = lambda self: None
3105 ModelKey_swigregister = _IMP_kernel.ModelKey_swigregister
3106 ModelKey_swigregister(ModelKey)
3107 
3108 def ModelKey_add_key(sc):
3109  """ModelKey_add_key(std::string sc) -> unsigned int"""
3110  return _IMP_kernel.ModelKey_add_key(sc)
3111 
3112 def ModelKey_get_key_exists(sc):
3113  """ModelKey_get_key_exists(std::string sc) -> bool"""
3114  return _IMP_kernel.ModelKey_get_key_exists(sc)
3115 
3116 def ModelKey_add_alias(old_key, new_name):
3117  """ModelKey_add_alias(ModelKey old_key, std::string new_name) -> ModelKey"""
3118  return _IMP_kernel.ModelKey_add_alias(old_key, new_name)
3119 
3120 def ModelKey_show_all(out):
3121  """ModelKey_show_all(_ostream out)"""
3122  return _IMP_kernel.ModelKey_show_all(out)
3123 
3124 def ModelKey_get_all_strings():
3125  """ModelKey_get_all_strings() -> IMP::Vector< std::string >"""
3126  return _IMP_kernel.ModelKey_get_all_strings()
3127 
3128 def ModelKey_get_number_unique():
3129  """ModelKey_get_number_unique() -> unsigned int"""
3130  return _IMP_kernel.ModelKey_get_number_unique()
3131 
3132 class ParticleIndex(_Value):
3133  """Proxy of C++ IMP::Index<(IMP::ParticleIndexTag)> class."""
3134 
3135  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3136 
3137  def __init__(self, *args):
3138  """
3139  __init__(IMP::Index<(IMP::ParticleIndexTag)> self, int i) -> ParticleIndex
3140  __init__(IMP::Index<(IMP::ParticleIndexTag)> self) -> ParticleIndex
3141  """
3142  this = _IMP_kernel.new_ParticleIndex(*args)
3143  try:
3144  self.this.append(this)
3145  except:
3146  self.this = this
3147 
3148  def get_index(self):
3149  """get_index(ParticleIndex self) -> int"""
3150  return _IMP_kernel.ParticleIndex_get_index(self)
3151 
3152 
3153  def __cmp__(self, o):
3154  """__cmp__(ParticleIndex self, ParticleIndex o) -> int"""
3155  return _IMP_kernel.ParticleIndex___cmp__(self, o)
3156 
3157 
3158  def __eq__(self, o):
3159  """__eq__(ParticleIndex self, ParticleIndex o) -> bool"""
3160  return _IMP_kernel.ParticleIndex___eq__(self, o)
3161 
3162 
3163  def __ne__(self, o):
3164  """__ne__(ParticleIndex self, ParticleIndex o) -> bool"""
3165  return _IMP_kernel.ParticleIndex___ne__(self, o)
3166 
3167 
3168  def __lt__(self, o):
3169  """__lt__(ParticleIndex self, ParticleIndex o) -> bool"""
3170  return _IMP_kernel.ParticleIndex___lt__(self, o)
3171 
3172 
3173  def __gt__(self, o):
3174  """__gt__(ParticleIndex self, ParticleIndex o) -> bool"""
3175  return _IMP_kernel.ParticleIndex___gt__(self, o)
3176 
3177 
3178  def __ge__(self, o):
3179  """__ge__(ParticleIndex self, ParticleIndex o) -> bool"""
3180  return _IMP_kernel.ParticleIndex___ge__(self, o)
3181 
3182 
3183  def __le__(self, o):
3184  """__le__(ParticleIndex self, ParticleIndex o) -> bool"""
3185  return _IMP_kernel.ParticleIndex___le__(self, o)
3186 
3187 
3188  def show(self, *args):
3189  """
3190  show(ParticleIndex self, _ostream out)
3191  show(ParticleIndex self)
3192  """
3193  return _IMP_kernel.ParticleIndex_show(self, *args)
3194 
3195 
3196  def __hash__(self):
3197  """__hash__(ParticleIndex self) -> std::size_t"""
3198  return _IMP_kernel.ParticleIndex___hash__(self)
3199 
3200 
3201  def __str__(self):
3202  """__str__(ParticleIndex self) -> std::string"""
3203  return _IMP_kernel.ParticleIndex___str__(self)
3204 
3205 
3206  def __repr__(self):
3207  """__repr__(ParticleIndex self) -> std::string"""
3208  return _IMP_kernel.ParticleIndex___repr__(self)
3209 
3210  __swig_destroy__ = _IMP_kernel.delete_ParticleIndex
3211  __del__ = lambda self: None
3212 ParticleIndex_swigregister = _IMP_kernel.ParticleIndex_swigregister
3213 ParticleIndex_swigregister(ParticleIndex)
3214 
3215 
3216 def ParticlePair(a, b):
3217  return (a,b)
3218 def ParticleTriplet(a, b, c):
3219  return (a,b,c)
3220 def ParticleQuad(a, b, c, d):
3221  return (a,b,c,d)
3222 
3223 class FloatIndex(_Value):
3224  """Proxy of C++ IMP::FloatIndex class."""
3225 
3226  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3227 
3228  def __init__(self, *args):
3229  """
3230  __init__(IMP::FloatIndex self, ParticleIndex i0, FloatKey i1) -> FloatIndex
3231  __init__(IMP::FloatIndex self, ParticleIndex i0) -> FloatIndex
3232  __init__(IMP::FloatIndex self) -> FloatIndex
3233  """
3234  this = _IMP_kernel.new_FloatIndex(*args)
3235  try:
3236  self.this.append(this)
3237  except:
3238  self.this = this
3239 
3240  def __hash__(self):
3241  """__hash__(FloatIndex self) -> std::size_t"""
3242  return _IMP_kernel.FloatIndex___hash__(self)
3243 
3244 
3245  def show(self, *args):
3246  """
3247  show(FloatIndex self, _ostream out)
3248  show(FloatIndex self)
3249  """
3250  return _IMP_kernel.FloatIndex_show(self, *args)
3251 
3252 
3253  def __cmp__(self, o):
3254  """__cmp__(FloatIndex self, FloatIndex o) -> int"""
3255  return _IMP_kernel.FloatIndex___cmp__(self, o)
3256 
3257 
3258  def __eq__(self, o):
3259  """__eq__(FloatIndex self, FloatIndex o) -> bool"""
3260  return _IMP_kernel.FloatIndex___eq__(self, o)
3261 
3262 
3263  def __ne__(self, o):
3264  """__ne__(FloatIndex self, FloatIndex o) -> bool"""
3265  return _IMP_kernel.FloatIndex___ne__(self, o)
3266 
3267 
3268  def __lt__(self, o):
3269  """__lt__(FloatIndex self, FloatIndex o) -> bool"""
3270  return _IMP_kernel.FloatIndex___lt__(self, o)
3271 
3272 
3273  def __gt__(self, o):
3274  """__gt__(FloatIndex self, FloatIndex o) -> bool"""
3275  return _IMP_kernel.FloatIndex___gt__(self, o)
3276 
3277 
3278  def __ge__(self, o):
3279  """__ge__(FloatIndex self, FloatIndex o) -> bool"""
3280  return _IMP_kernel.FloatIndex___ge__(self, o)
3281 
3282 
3283  def __le__(self, o):
3284  """__le__(FloatIndex self, FloatIndex o) -> bool"""
3285  return _IMP_kernel.FloatIndex___le__(self, o)
3286 
3287 
3288  def get_particle(self):
3289  """get_particle(FloatIndex self) -> ParticleIndex const &"""
3290  return _IMP_kernel.FloatIndex_get_particle(self)
3291 
3292 
3293  def set_particle(self, v):
3294  """set_particle(FloatIndex self, ParticleIndex const & v)"""
3295  return _IMP_kernel.FloatIndex_set_particle(self, v)
3296 
3297 
3298  def get_key(self):
3299  """get_key(FloatIndex self) -> FloatKey const &"""
3300  return _IMP_kernel.FloatIndex_get_key(self)
3301 
3302 
3303  def set_key(self, v):
3304  """set_key(FloatIndex self, FloatKey const & v)"""
3305  return _IMP_kernel.FloatIndex_set_key(self, v)
3306 
3307 
3308  def __str__(self):
3309  """__str__(FloatIndex self) -> std::string"""
3310  return _IMP_kernel.FloatIndex___str__(self)
3311 
3312 
3313  def __repr__(self):
3314  """__repr__(FloatIndex self) -> std::string"""
3315  return _IMP_kernel.FloatIndex___repr__(self)
3316 
3317  __swig_destroy__ = _IMP_kernel.delete_FloatIndex
3318  __del__ = lambda self: None
3319 FloatIndex_swigregister = _IMP_kernel.FloatIndex_swigregister
3320 FloatIndex_swigregister(FloatIndex)
3321 
3322 class _ParticleIndexTag(object):
3323  """Proxy of C++ IMP::ParticleIndexTag class."""
3324 
3325  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3326  __repr__ = _swig_repr
3327 
3328  def __init__(self):
3329  """__init__(IMP::ParticleIndexTag self) -> _ParticleIndexTag"""
3330  this = _IMP_kernel.new__ParticleIndexTag()
3331  try:
3332  self.this.append(this)
3333  except:
3334  self.this = this
3335  __swig_destroy__ = _IMP_kernel.delete__ParticleIndexTag
3336  __del__ = lambda self: None
3337 _ParticleIndexTag_swigregister = _IMP_kernel._ParticleIndexTag_swigregister
3338 _ParticleIndexTag_swigregister(_ParticleIndexTag)
3339 
3340 class ModelObject(Object):
3341  """Proxy of C++ IMP::ModelObject class."""
3342 
3343  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3344 
3345  def __init__(self, m, name):
3346  """__init__(IMP::ModelObject self, Model m, std::string name) -> ModelObject"""
3347  if self.__class__ == ModelObject:
3348  _self = None
3349  else:
3350  _self = self
3351  this = _IMP_kernel.new_ModelObject(_self, m, name)
3352  try:
3353  self.this.append(this)
3354  except:
3355  self.this = this
3356 
3357  if self.__class__ != ModelObject:
3358  _director_objects.register(self)
3359 
3360 
3361 
3362  __swig_destroy__ = _IMP_kernel.delete_ModelObject
3363  __del__ = lambda self: None
3364 
3365  def get_model(self):
3366  """get_model(ModelObject self) -> Model"""
3367  return _IMP_kernel.ModelObject_get_model(self)
3368 
3369 
3370  def get_inputs(self):
3371  """get_inputs(ModelObject self) -> IMP::ModelObjectsTemp"""
3372  return _IMP_kernel.ModelObject_get_inputs(self)
3373 
3374 
3375  def get_outputs(self):
3376  """get_outputs(ModelObject self) -> IMP::ModelObjectsTemp"""
3377  return _IMP_kernel.ModelObject_get_outputs(self)
3378 
3379 
3380  def get_interactions(self):
3381  """get_interactions(ModelObject self) -> IMP::ModelObjectsTemps"""
3382  return _IMP_kernel.ModelObject_get_interactions(self)
3383 
3384 
3385  def get_has_dependencies(self):
3386  """get_has_dependencies(ModelObject self) -> bool"""
3387  return _IMP_kernel.ModelObject_get_has_dependencies(self)
3388 
3389 
3390  def set_has_dependencies(self, tf):
3391  """set_has_dependencies(ModelObject self, bool tf)"""
3392  return _IMP_kernel.ModelObject_set_has_dependencies(self, tf)
3393 
3394 
3395  def set_has_required_score_states(self, tf):
3396  """set_has_required_score_states(ModelObject self, bool tf)"""
3397  return _IMP_kernel.ModelObject_set_has_required_score_states(self, tf)
3398 
3399 
3400  def get_has_required_score_states(self):
3401  """get_has_required_score_states(ModelObject self) -> bool"""
3402  return _IMP_kernel.ModelObject_get_has_required_score_states(self)
3403 
3404 
3405  def get_required_score_states(self):
3406  """get_required_score_states(ModelObject self) -> IMP::ScoreStatesTemp const &"""
3407  return _IMP_kernel.ModelObject_get_required_score_states(self)
3408 
3409 
3410  def handle_set_has_required_score_states(self, arg0):
3411  """handle_set_has_required_score_states(ModelObject self, bool arg0)"""
3412  return _IMP_kernel.ModelObject_handle_set_has_required_score_states(self, arg0)
3413 
3414 
3415  def do_get_inputs(self):
3416  """do_get_inputs(ModelObject self) -> IMP::ModelObjectsTemp"""
3417  return _IMP_kernel.ModelObject_do_get_inputs(self)
3418 
3419 
3420  def do_get_outputs(self):
3421  """do_get_outputs(ModelObject self) -> IMP::ModelObjectsTemp"""
3422  return _IMP_kernel.ModelObject_do_get_outputs(self)
3423 
3424 
3425  def do_get_interactions(self):
3426  """do_get_interactions(ModelObject self) -> IMP::ModelObjectsTemps"""
3427  return _IMP_kernel.ModelObject_do_get_interactions(self)
3428 
3429 
3430  def __str__(self):
3431  """__str__(ModelObject self) -> std::string"""
3432  return _IMP_kernel.ModelObject___str__(self)
3433 
3434 
3435  def __repr__(self):
3436  """__repr__(ModelObject self) -> std::string"""
3437  return _IMP_kernel.ModelObject___repr__(self)
3438 
3439 
3440  @staticmethod
3441  def get_from(o):
3442  return _object_cast_to_ModelObject(o)
3443 
3444 
3445  def get_type_name(self):
3446  return self.__class__.__name__
3447  def do_show(self, out):
3448  pass
3449  def get_version_info(self):
3450  if"IMP" == "IMP":
3451  return VersionInfo(self.__module__,
3452  __import__(self.__module__).get_module_version())
3453  else:
3454  return IMP.VersionInfo(self.__module__,
3455  __import__(self.__module__).get_module_version())
3456  @staticmethod
3457  def get_from(o):
3458  return _object_cast_to_ModelObject(o)
3459 
3460  def __disown__(self):
3461  self.this.disown()
3462  _IMP_kernel.disown_ModelObject(self)
3463  return weakref_proxy(self)
3464 
3465  def do_destroy(self):
3466  """do_destroy(ModelObject self)"""
3467  return _IMP_kernel.ModelObject_do_destroy(self)
3468 
3469 ModelObject_swigregister = _IMP_kernel.ModelObject_swigregister
3470 ModelObject_swigregister(ModelObject)
3471 cvar = _IMP_kernel.cvar
3472 NO_MAX = cvar.NO_MAX
3473 BAD_SCORE = cvar.BAD_SCORE
3474 
3475 class _ParticleInputs(object):
3476  """Proxy of C++ IMP::ParticleInputs class."""
3477 
3478  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3479 
3480  def __init__(self, *args, **kwargs):
3481  raise AttributeError("No constructor defined - class is abstract")
3482  __repr__ = _swig_repr
3483 
3484  def get_inputs(self, m, pis):
3485  """get_inputs(_ParticleInputs self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
3486  return _IMP_kernel._ParticleInputs_get_inputs(self, m, pis)
3487 
3488 _ParticleInputs_swigregister = _IMP_kernel._ParticleInputs_swigregister
3489 _ParticleInputs_swigregister(_ParticleInputs)
3490 
3491 class _ParticleOutputs(object):
3492  """Proxy of C++ IMP::ParticleOutputs class."""
3493 
3494  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3495 
3496  def __init__(self, *args, **kwargs):
3497  raise AttributeError("No constructor defined - class is abstract")
3498  __repr__ = _swig_repr
3499 
3500  def get_outputs(self, m, pis):
3501  """get_outputs(_ParticleOutputs self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
3502  return _IMP_kernel._ParticleOutputs_get_outputs(self, m, pis)
3503 
3504 _ParticleOutputs_swigregister = _IMP_kernel._ParticleOutputs_swigregister
3505 _ParticleOutputs_swigregister(_ParticleOutputs)
3506 
3507 
3508 def get_input_particles(mos):
3509  """get_input_particles(IMP::ModelObjectsTemp const & mos) -> IMP::ParticlesTemp"""
3510  return _IMP_kernel.get_input_particles(mos)
3511 
3512 def get_input_containers(mos):
3513  """get_input_containers(IMP::ModelObjectsTemp const & mos) -> IMP::ContainersTemp"""
3514  return _IMP_kernel.get_input_containers(mos)
3515 
3516 def get_output_particles(mos):
3517  """get_output_particles(IMP::ModelObjectsTemp const & mos) -> IMP::ParticlesTemp"""
3518  return _IMP_kernel.get_output_particles(mos)
3519 
3520 def get_output_containers(mos):
3521  """get_output_containers(IMP::ModelObjectsTemp const & mos) -> IMP::ContainersTemp"""
3522  return _IMP_kernel.get_output_containers(mos)
3523 class DerivativeAccumulator(object):
3524  """Proxy of C++ IMP::DerivativeAccumulator class."""
3525 
3526  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3527  __repr__ = _swig_repr
3528 
3529  def __init__(self, *args):
3530  """
3531  __init__(IMP::DerivativeAccumulator self, double weight=1.0) -> DerivativeAccumulator
3532  __init__(IMP::DerivativeAccumulator self) -> DerivativeAccumulator
3533  __init__(IMP::DerivativeAccumulator self, DerivativeAccumulator copy, double weight) -> DerivativeAccumulator
3534  """
3535  this = _IMP_kernel.new_DerivativeAccumulator(*args)
3536  try:
3537  self.this.append(this)
3538  except:
3539  self.this = this
3540 
3541  def __call__(self, value):
3542  """__call__(DerivativeAccumulator self, double const value) -> double"""
3543  return _IMP_kernel.DerivativeAccumulator___call__(self, value)
3544 
3545 
3546  def get_weight(self):
3547  """get_weight(DerivativeAccumulator self) -> double"""
3548  return _IMP_kernel.DerivativeAccumulator_get_weight(self)
3549 
3550 
3551  def show(self, *args):
3552  """
3553  show(DerivativeAccumulator self, _ostream out)
3554  show(DerivativeAccumulator self)
3555  """
3556  return _IMP_kernel.DerivativeAccumulator_show(self, *args)
3557 
3558  __swig_destroy__ = _IMP_kernel.delete_DerivativeAccumulator
3559  __del__ = lambda self: None
3560 DerivativeAccumulator_swigregister = _IMP_kernel.DerivativeAccumulator_swigregister
3561 DerivativeAccumulator_swigregister(DerivativeAccumulator)
3562 
3563 class EvaluationState(object):
3564  """Proxy of C++ IMP::EvaluationState class."""
3565 
3566  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3567  score = _swig_property(_IMP_kernel.EvaluationState_score_get, _IMP_kernel.EvaluationState_score_set)
3568  good = _swig_property(_IMP_kernel.EvaluationState_good_get, _IMP_kernel.EvaluationState_good_set)
3569 
3570  def __init__(self, *args):
3571  """
3572  __init__(IMP::EvaluationState self, double oscore, bool ogood) -> EvaluationState
3573  __init__(IMP::EvaluationState self) -> EvaluationState
3574  """
3575  this = _IMP_kernel.new_EvaluationState(*args)
3576  try:
3577  self.this.append(this)
3578  except:
3579  self.this = this
3580 
3581  def show(self, *args):
3582  """
3583  show(EvaluationState self, _ostream out)
3584  show(EvaluationState self)
3585  """
3586  return _IMP_kernel.EvaluationState_show(self, *args)
3587 
3588 
3589  def __str__(self):
3590  """__str__(EvaluationState self) -> std::string"""
3591  return _IMP_kernel.EvaluationState___str__(self)
3592 
3593 
3594  def __repr__(self):
3595  """__repr__(EvaluationState self) -> std::string"""
3596  return _IMP_kernel.EvaluationState___repr__(self)
3597 
3598  __swig_destroy__ = _IMP_kernel.delete_EvaluationState
3599  __del__ = lambda self: None
3600 EvaluationState_swigregister = _IMP_kernel.EvaluationState_swigregister
3601 EvaluationState_swigregister(EvaluationState)
3602 
3603 class ScoreAccumulator(_Value):
3604  """Proxy of C++ IMP::ScoreAccumulator class."""
3605 
3606  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3607 
3608  def __init__(self, *args):
3609  """
3610  __init__(IMP::ScoreAccumulator self) -> ScoreAccumulator
3611  __init__(IMP::ScoreAccumulator self, ScoreAccumulator o, Restraint r) -> ScoreAccumulator
3612  __init__(IMP::ScoreAccumulator self, ScoreAccumulator o, double weight, double local_max) -> ScoreAccumulator
3613  """
3614  this = _IMP_kernel.new_ScoreAccumulator(*args)
3615  try:
3616  self.this.append(this)
3617  except:
3618  self.this = this
3619 
3620  def add_score(self, score):
3621  """add_score(ScoreAccumulator self, double score)"""
3622  return _IMP_kernel.ScoreAccumulator_add_score(self, score)
3623 
3624 
3625  def get_abort_evaluation(self):
3626  """get_abort_evaluation(ScoreAccumulator self) -> bool"""
3627  return _IMP_kernel.ScoreAccumulator_get_abort_evaluation(self)
3628 
3629 
3630  def get_is_evaluate_if_below(self):
3631  """get_is_evaluate_if_below(ScoreAccumulator self) -> bool"""
3632  return _IMP_kernel.ScoreAccumulator_get_is_evaluate_if_below(self)
3633 
3634 
3635  def get_is_evaluate_if_good(self):
3636  """get_is_evaluate_if_good(ScoreAccumulator self) -> bool"""
3637  return _IMP_kernel.ScoreAccumulator_get_is_evaluate_if_good(self)
3638 
3639 
3640  def get_maximum(self):
3641  """get_maximum(ScoreAccumulator self) -> double"""
3642  return _IMP_kernel.ScoreAccumulator_get_maximum(self)
3643 
3644 
3645  def get_derivative_accumulator(self):
3646  """get_derivative_accumulator(ScoreAccumulator self) -> DerivativeAccumulator"""
3647  return _IMP_kernel.ScoreAccumulator_get_derivative_accumulator(self)
3648 
3649 
3650  def show(self, *args):
3651  """
3652  show(ScoreAccumulator self, _ostream out)
3653  show(ScoreAccumulator self)
3654  """
3655  return _IMP_kernel.ScoreAccumulator_show(self, *args)
3656 
3657 
3658  def __str__(self):
3659  """__str__(ScoreAccumulator self) -> std::string"""
3660  return _IMP_kernel.ScoreAccumulator___str__(self)
3661 
3662 
3663  def __repr__(self):
3664  """__repr__(ScoreAccumulator self) -> std::string"""
3665  return _IMP_kernel.ScoreAccumulator___repr__(self)
3666 
3667  __swig_destroy__ = _IMP_kernel.delete_ScoreAccumulator
3668  __del__ = lambda self: None
3669 ScoreAccumulator_swigregister = _IMP_kernel.ScoreAccumulator_swigregister
3670 ScoreAccumulator_swigregister(ScoreAccumulator)
3671 
3672 class ScoreState(ModelObject):
3673  """Proxy of C++ IMP::ScoreState class."""
3674 
3675  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3676 
3677  def __init__(self, m, name):
3678  """__init__(IMP::ScoreState self, Model m, std::string name) -> ScoreState"""
3679  if self.__class__ == ScoreState:
3680  _self = None
3681  else:
3682  _self = self
3683  this = _IMP_kernel.new_ScoreState(_self, m, name)
3684  try:
3685  self.this.append(this)
3686  except:
3687  self.this = this
3688 
3689  if self.__class__ != ScoreState:
3690  _director_objects.register(self)
3691 
3692 
3693 
3694 
3695  def before_evaluate(self):
3696  """before_evaluate(ScoreState self)"""
3697  return _IMP_kernel.ScoreState_before_evaluate(self)
3698 
3699 
3700  def after_evaluate(self, accpt):
3701  """after_evaluate(ScoreState self, DerivativeAccumulator accpt)"""
3702  return _IMP_kernel.ScoreState_after_evaluate(self, accpt)
3703 
3704 
3705  def get_has_update_order(self):
3706  """get_has_update_order(ScoreState self) -> bool"""
3707  return _IMP_kernel.ScoreState_get_has_update_order(self)
3708 
3709 
3710  def get_update_order(self):
3711  """get_update_order(ScoreState self) -> unsigned int"""
3712  return _IMP_kernel.ScoreState_get_update_order(self)
3713 
3714 
3715  def handle_set_has_required_score_states(self, tf):
3716  """handle_set_has_required_score_states(ScoreState self, bool tf)"""
3717  return _IMP_kernel.ScoreState_handle_set_has_required_score_states(self, tf)
3718 
3719 
3720  def do_before_evaluate(self):
3721  """do_before_evaluate(ScoreState self)"""
3722  return _IMP_kernel.ScoreState_do_before_evaluate(self)
3723 
3724 
3725  def do_after_evaluate(self, accpt):
3726  """do_after_evaluate(ScoreState self, DerivativeAccumulator accpt)"""
3727  return _IMP_kernel.ScoreState_do_after_evaluate(self, accpt)
3728 
3729  __swig_destroy__ = _IMP_kernel.delete_ScoreState
3730  __del__ = lambda self: None
3731 
3732  def __str__(self):
3733  """__str__(ScoreState self) -> std::string"""
3734  return _IMP_kernel.ScoreState___str__(self)
3735 
3736 
3737  def __repr__(self):
3738  """__repr__(ScoreState self) -> std::string"""
3739  return _IMP_kernel.ScoreState___repr__(self)
3740 
3741 
3742  @staticmethod
3743  def get_from(o):
3744  return _object_cast_to_ScoreState(o)
3745 
3746 
3747  def get_type_name(self):
3748  return self.__class__.__name__
3749  def do_show(self, out):
3750  pass
3751  def get_version_info(self):
3752  if"IMP" == "IMP":
3753  return VersionInfo(self.__module__,
3754  __import__(self.__module__).get_module_version())
3755  else:
3756  return IMP.VersionInfo(self.__module__,
3757  __import__(self.__module__).get_module_version())
3758  @staticmethod
3759  def get_from(o):
3760  return _object_cast_to_ScoreState(o)
3761 
3762  def __disown__(self):
3763  self.this.disown()
3764  _IMP_kernel.disown_ScoreState(self)
3765  return weakref_proxy(self)
3766 
3767  def do_destroy(self):
3768  """do_destroy(ScoreState self)"""
3769  return _IMP_kernel.ScoreState_do_destroy(self)
3770 
3771 
3772  def do_get_inputs(self):
3773  """do_get_inputs(ScoreState self) -> IMP::ModelObjectsTemp"""
3774  return _IMP_kernel.ScoreState_do_get_inputs(self)
3775 
3776 
3777  def do_get_outputs(self):
3778  """do_get_outputs(ScoreState self) -> IMP::ModelObjectsTemp"""
3779  return _IMP_kernel.ScoreState_do_get_outputs(self)
3780 
3781 
3782  def do_get_interactions(self):
3783  """do_get_interactions(ScoreState self) -> IMP::ModelObjectsTemps"""
3784  return _IMP_kernel.ScoreState_do_get_interactions(self)
3785 
3786 ScoreState_swigregister = _IMP_kernel.ScoreState_swigregister
3787 ScoreState_swigregister(ScoreState)
3788 
3789 
3790 def get_update_order(input):
3791  """get_update_order(IMP::ScoreStatesTemp input) -> IMP::ScoreStatesTemp"""
3792  return _IMP_kernel.get_update_order(input)
3793 class Constraint(ScoreState):
3794  """Proxy of C++ IMP::Constraint class."""
3795 
3796  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3797 
3798  def __init__(self, *args):
3799  """
3800  __init__(IMP::Constraint self, Model m, std::string name) -> Constraint
3801  __init__(IMP::Constraint self, Model m) -> Constraint
3802  """
3803  if self.__class__ == Constraint:
3804  _self = None
3805  else:
3806  _self = self
3807  this = _IMP_kernel.new_Constraint(_self, *args)
3808  try:
3809  self.this.append(this)
3810  except:
3811  self.this = this
3812 
3813  if self.__class__ != Constraint:
3814  _director_objects.register(self)
3815 
3816 
3817 
3818 
3819  def do_update_attributes(self):
3820  """do_update_attributes(Constraint self)"""
3821  return _IMP_kernel.Constraint_do_update_attributes(self)
3822 
3823 
3824  def do_update_derivatives(self, da):
3825  """do_update_derivatives(Constraint self, DerivativeAccumulator da)"""
3826  return _IMP_kernel.Constraint_do_update_derivatives(self, da)
3827 
3828 
3829  def do_before_evaluate(self):
3830  """do_before_evaluate(Constraint self)"""
3831  return _IMP_kernel.Constraint_do_before_evaluate(self)
3832 
3833 
3834  def do_after_evaluate(self, da):
3835  """do_after_evaluate(Constraint self, DerivativeAccumulator da)"""
3836  return _IMP_kernel.Constraint_do_after_evaluate(self, da)
3837 
3838  __swig_destroy__ = _IMP_kernel.delete_Constraint
3839  __del__ = lambda self: None
3840 
3841  def __str__(self):
3842  """__str__(Constraint self) -> std::string"""
3843  return _IMP_kernel.Constraint___str__(self)
3844 
3845 
3846  def __repr__(self):
3847  """__repr__(Constraint self) -> std::string"""
3848  return _IMP_kernel.Constraint___repr__(self)
3849 
3850 
3851  @staticmethod
3852  def get_from(o):
3853  return _object_cast_to_Constraint(o)
3854 
3855 
3856  def get_type_name(self):
3857  return self.__class__.__name__
3858  def do_show(self, out):
3859  pass
3860  def get_version_info(self):
3861  if"IMP" == "IMP":
3862  return VersionInfo(self.__module__,
3863  __import__(self.__module__).get_module_version())
3864  else:
3865  return IMP.VersionInfo(self.__module__,
3866  __import__(self.__module__).get_module_version())
3867  @staticmethod
3868  def get_from(o):
3869  return _object_cast_to_Constraint(o)
3870 
3871  def __disown__(self):
3872  self.this.disown()
3873  _IMP_kernel.disown_Constraint(self)
3874  return weakref_proxy(self)
3875 
3876  def do_destroy(self):
3877  """do_destroy(Constraint self)"""
3878  return _IMP_kernel.Constraint_do_destroy(self)
3879 
3880 
3881  def do_get_inputs(self):
3882  """do_get_inputs(Constraint self) -> IMP::ModelObjectsTemp"""
3883  return _IMP_kernel.Constraint_do_get_inputs(self)
3884 
3885 
3886  def do_get_outputs(self):
3887  """do_get_outputs(Constraint self) -> IMP::ModelObjectsTemp"""
3888  return _IMP_kernel.Constraint_do_get_outputs(self)
3889 
3890 
3891  def do_get_interactions(self):
3892  """do_get_interactions(Constraint self) -> IMP::ModelObjectsTemps"""
3893  return _IMP_kernel.Constraint_do_get_interactions(self)
3894 
3895 Constraint_swigregister = _IMP_kernel.Constraint_swigregister
3896 Constraint_swigregister(Constraint)
3897 
3898 class Container(ModelObject):
3899  """Proxy of C++ IMP::Container class."""
3900 
3901  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3902 
3903  def __init__(self, *args):
3904  """
3905  __init__(IMP::Container self, Model m, std::string name) -> Container
3906  __init__(IMP::Container self, Model m) -> Container
3907  """
3908  if self.__class__ == Container:
3909  _self = None
3910  else:
3911  _self = self
3912  this = _IMP_kernel.new_Container(_self, *args)
3913  try:
3914  self.this.append(this)
3915  except:
3916  self.this = this
3917 
3918  if self.__class__ != Container:
3919  _director_objects.register(self)
3920 
3921 
3922 
3923 
3924  def do_get_contents_hash(self):
3925  """do_get_contents_hash(Container self) -> std::size_t"""
3926  return _IMP_kernel.Container_do_get_contents_hash(self)
3927 
3928 
3929  def get_all_possible_indexes(self):
3930  """get_all_possible_indexes(Container self) -> IMP::ParticleIndexes"""
3931  return _IMP_kernel.Container_get_all_possible_indexes(self)
3932 
3933 
3934  def get_contents_hash(self):
3935  """get_contents_hash(Container self) -> std::size_t"""
3936  return _IMP_kernel.Container_get_contents_hash(self)
3937 
3938 
3939  def do_get_outputs(self):
3940  """do_get_outputs(Container self) -> IMP::ModelObjectsTemp"""
3941  return _IMP_kernel.Container_do_get_outputs(self)
3942 
3943 
3944  def get_is_decomposable(self):
3945  """get_is_decomposable(Container self) -> bool"""
3946  return _IMP_kernel.Container_get_is_decomposable(self)
3947 
3948 
3949  def validate_readable(self):
3950  """validate_readable(Container self)"""
3951  return _IMP_kernel.Container_validate_readable(self)
3952 
3953 
3954  def validate_writable(self):
3955  """validate_writable(Container self)"""
3956  return _IMP_kernel.Container_validate_writable(self)
3957 
3958 
3959  def set_is_readable(self, tf):
3960  """set_is_readable(Container self, bool tf)"""
3961  return _IMP_kernel.Container_set_is_readable(self, tf)
3962 
3963 
3964  def set_is_writable(self, tf):
3965  """set_is_writable(Container self, bool tf)"""
3966  return _IMP_kernel.Container_set_is_writable(self, tf)
3967 
3968  __swig_destroy__ = _IMP_kernel.delete_Container
3969  __del__ = lambda self: None
3970 
3971  def __str__(self):
3972  """__str__(Container self) -> std::string"""
3973  return _IMP_kernel.Container___str__(self)
3974 
3975 
3976  def __repr__(self):
3977  """__repr__(Container self) -> std::string"""
3978  return _IMP_kernel.Container___repr__(self)
3979 
3980 
3981  @staticmethod
3982  def get_from(o):
3983  return _object_cast_to_Container(o)
3984 
3985 
3986  def get_type_name(self):
3987  return self.__class__.__name__
3988  def do_show(self, out):
3989  pass
3990  def get_version_info(self):
3991  if"IMP" == "IMP":
3992  return VersionInfo(self.__module__,
3993  __import__(self.__module__).get_module_version())
3994  else:
3995  return IMP.VersionInfo(self.__module__,
3996  __import__(self.__module__).get_module_version())
3997  @staticmethod
3998  def get_from(o):
3999  return _object_cast_to_Container(o)
4000 
4001  def __disown__(self):
4002  self.this.disown()
4003  _IMP_kernel.disown_Container(self)
4004  return weakref_proxy(self)
4005 
4006  def do_destroy(self):
4007  """do_destroy(Container self)"""
4008  return _IMP_kernel.Container_do_destroy(self)
4009 
4010 
4011  def handle_set_has_required_score_states(self, arg0):
4012  """handle_set_has_required_score_states(Container self, bool arg0)"""
4013  return _IMP_kernel.Container_handle_set_has_required_score_states(self, arg0)
4014 
4015 
4016  def do_get_inputs(self):
4017  """do_get_inputs(Container self) -> IMP::ModelObjectsTemp"""
4018  return _IMP_kernel.Container_do_get_inputs(self)
4019 
4020 
4021  def do_get_interactions(self):
4022  """do_get_interactions(Container self) -> IMP::ModelObjectsTemps"""
4023  return _IMP_kernel.Container_do_get_interactions(self)
4024 
4025 Container_swigregister = _IMP_kernel.Container_swigregister
4026 Container_swigregister(Container)
4027 
4028 class Restraint(ModelObject):
4029  """Proxy of C++ IMP::Restraint class."""
4030 
4031  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
4032 
4033  def __init__(self, m, name):
4034  """__init__(IMP::Restraint self, Model m, std::string name) -> Restraint"""
4035  if self.__class__ == Restraint:
4036  _self = None
4037  else:
4038  _self = self
4039  this = _IMP_kernel.new_Restraint(_self, m, name)
4040  try:
4041  self.this.append(this)
4042  except:
4043  self.this = this
4044 
4045  if self.__class__ != Restraint:
4046  _director_objects.register(self)
4047 
4048 
4049 
4050 
4051  def get_score(self):
4052  """get_score(Restraint self) -> double"""
4053  return _IMP_kernel.Restraint_get_score(self)
4054 
4055 
4056  def evaluate(self, calc_derivs):
4057  """evaluate(Restraint self, bool calc_derivs) -> double"""
4058  return _IMP_kernel.Restraint_evaluate(self, calc_derivs)
4059 
4060 
4061  def evaluate_if_good(self, calc_derivatives):
4062  """evaluate_if_good(Restraint self, bool calc_derivatives) -> double"""
4063  return _IMP_kernel.Restraint_evaluate_if_good(self, calc_derivatives)
4064 
4065 
4066  def evaluate_if_below(self, calc_derivatives, max):
4067  """evaluate_if_below(Restraint self, bool calc_derivatives, double max) -> double"""
4068  return _IMP_kernel.Restraint_evaluate_if_below(self, calc_derivatives, max)
4069 
4070 
4071  def unprotected_evaluate(self, da):
4072  """unprotected_evaluate(Restraint self, DerivativeAccumulator da) -> double"""
4073  return _IMP_kernel.Restraint_unprotected_evaluate(self, da)
4074 
4075 
4076  def unprotected_evaluate_if_good(self, da, max):
4077  """unprotected_evaluate_if_good(Restraint self, DerivativeAccumulator da, double max) -> double"""
4078  return _IMP_kernel.Restraint_unprotected_evaluate_if_good(self, da, max)
4079 
4080 
4081  def unprotected_evaluate_if_below(self, da, max):
4082  """unprotected_evaluate_if_below(Restraint self, DerivativeAccumulator da, double max) -> double"""
4083  return _IMP_kernel.Restraint_unprotected_evaluate_if_below(self, da, max)
4084 
4085 
4086  def add_score_and_derivatives(self, sa):
4087  """add_score_and_derivatives(Restraint self, ScoreAccumulator sa)"""
4088  return _IMP_kernel.Restraint_add_score_and_derivatives(self, sa)
4089 
4090 
4091  def create_decomposition(self):
4092  """create_decomposition(Restraint self) -> Restraint"""
4093  return _IMP_kernel.Restraint_create_decomposition(self)
4094 
4095 
4096  def create_current_decomposition(self):
4097  """create_current_decomposition(Restraint self) -> Restraint"""
4098  return _IMP_kernel.Restraint_create_current_decomposition(self)
4099 
4100 
4101  def set_weight(self, weight):
4102  """set_weight(Restraint self, IMP::Float weight)"""
4103  return _IMP_kernel.Restraint_set_weight(self, weight)
4104 
4105 
4106  def get_weight(self):
4107  """get_weight(Restraint self) -> IMP::Float"""
4108  return _IMP_kernel.Restraint_get_weight(self)
4109 
4110 
4111  def get_maximum_score(self):
4112  """get_maximum_score(Restraint self) -> double"""
4113  return _IMP_kernel.Restraint_get_maximum_score(self)
4114 
4115 
4116  def set_maximum_score(self, s):
4117  """set_maximum_score(Restraint self, double s)"""
4118  return _IMP_kernel.Restraint_set_maximum_score(self, s)
4119 
4120 
4121  def create_scoring_function(self, *args):
4122  """
4123  create_scoring_function(Restraint self, double weight=1.0, double max) -> ScoringFunction
4124  create_scoring_function(Restraint self, double weight=1.0) -> ScoringFunction
4125  create_scoring_function(Restraint self) -> ScoringFunction
4126  """
4127  return _IMP_kernel.Restraint_create_scoring_function(self, *args)
4128 
4129 
4130  def set_last_score(self, s):
4131  """set_last_score(Restraint self, double s)"""
4132  return _IMP_kernel.Restraint_set_last_score(self, s)
4133 
4134 
4135  def get_last_score(self):
4136  """get_last_score(Restraint self) -> double"""
4137  return _IMP_kernel.Restraint_get_last_score(self)
4138 
4139 
4140  def get_was_good(self):
4141  """get_was_good(Restraint self) -> bool"""
4142  return _IMP_kernel.Restraint_get_was_good(self)
4143 
4144  __swig_destroy__ = _IMP_kernel.delete_Restraint
4145  __del__ = lambda self: None
4146 
4147  def do_create_decomposition(self):
4148  """do_create_decomposition(Restraint self) -> IMP::Restraints"""
4149  return _IMP_kernel.Restraint_do_create_decomposition(self)
4150 
4151 
4152  def do_create_current_decomposition(self):
4153  """do_create_current_decomposition(Restraint self) -> IMP::Restraints"""
4154  return _IMP_kernel.Restraint_do_create_current_decomposition(self)
4155 
4156 
4157  def do_add_score_and_derivatives(self, sa):
4158  """do_add_score_and_derivatives(Restraint self, ScoreAccumulator sa)"""
4159  return _IMP_kernel.Restraint_do_add_score_and_derivatives(self, sa)
4160 
4161 
4162  def do_get_outputs(self):
4163  """do_get_outputs(Restraint self) -> IMP::ModelObjectsTemp"""
4164  return _IMP_kernel.Restraint_do_get_outputs(self)
4165 
4166 
4167  def __str__(self):
4168  """__str__(Restraint self) -> std::string"""
4169  return _IMP_kernel.Restraint___str__(self)
4170 
4171 
4172  def __repr__(self):
4173  """__repr__(Restraint self) -> std::string"""
4174  return _IMP_kernel.Restraint___repr__(self)
4175 
4176 
4177  @staticmethod
4178  def get_from(o):
4179  return _object_cast_to_Restraint(o)
4180 
4181 
4182  def get_type_name(self):
4183  return self.__class__.__name__
4184  def do_show(self, out):
4185  pass
4186  def get_version_info(self):
4187  if"IMP" == "IMP":
4188  return VersionInfo(self.__module__,
4189  __import__(self.__module__).get_module_version())
4190  else:
4191  return IMP.VersionInfo(self.__module__,
4192  __import__(self.__module__).get_module_version())
4193  @staticmethod
4194  def get_from(o):
4195  return _object_cast_to_Restraint(o)
4196 
4197  def __disown__(self):
4198  self.this.disown()
4199  _IMP_kernel.disown_Restraint(self)
4200  return weakref_proxy(self)
4201 
4202  def do_destroy(self):
4203  """do_destroy(Restraint self)"""
4204  return _IMP_kernel.Restraint_do_destroy(self)
4205 
4206 
4207  def handle_set_has_required_score_states(self, arg0):
4208  """handle_set_has_required_score_states(Restraint self, bool arg0)"""
4209  return _IMP_kernel.Restraint_handle_set_has_required_score_states(self, arg0)
4210 
4211 
4212  def do_get_inputs(self):
4213  """do_get_inputs(Restraint self) -> IMP::ModelObjectsTemp"""
4214  return _IMP_kernel.Restraint_do_get_inputs(self)
4215 
4216 
4217  def do_get_interactions(self):
4218  """do_get_interactions(Restraint self) -> IMP::ModelObjectsTemps"""
4219  return _IMP_kernel.Restraint_do_get_interactions(self)
4220 
4221 Restraint_swigregister = _IMP_kernel.Restraint_swigregister
4222 Restraint_swigregister(Restraint)
4223 
4224 class _RestraintsAdaptor(_InputAdaptor):
4225  """Proxy of C++ IMP::RestraintsAdaptor class."""
4226 
4227  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
4228  __repr__ = _swig_repr
4229 
4230  def __init__(self, *args):
4231  """
4232  __init__(IMP::RestraintsAdaptor self) -> _RestraintsAdaptor
4233  __init__(IMP::RestraintsAdaptor self, IMP::Restraints const & sf) -> _RestraintsAdaptor
4234  __init__(IMP::RestraintsAdaptor self, IMP::RestraintsTemp const & sf) -> _RestraintsAdaptor
4235  __init__(IMP::RestraintsAdaptor self, Restraint sf) -> _RestraintsAdaptor
4236  """
4237  this = _IMP_kernel.new__RestraintsAdaptor(*args)
4238  try:
4239  self.this.append(this)
4240  except:
4241  self.this = this
4242  __swig_destroy__ = _IMP_kernel.delete__RestraintsAdaptor
4243  __del__ = lambda self: None
4244 _RestraintsAdaptor_swigregister = _IMP_kernel._RestraintsAdaptor_swigregister
4245 _RestraintsAdaptor_swigregister(_RestraintsAdaptor)
4246 
4247 class RestraintSet(Restraint):
4248  """Proxy of C++ IMP::RestraintSet class."""
4249 
4250  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
4251 
4252  def __init__(self, *args):
4253  """
4254  __init__(IMP::RestraintSet self, Model m, double weight, std::string const & name) -> RestraintSet
4255  __init__(IMP::RestraintSet self, Model m, double weight) -> RestraintSet
4256  __init__(IMP::RestraintSet self, Model m, std::string const & name) -> RestraintSet
4257  __init__(IMP::RestraintSet self, Model m) -> RestraintSet
4258  __init__(IMP::RestraintSet self, IMP::RestraintsTemp const & rs, double weight, std::string const & name) -> RestraintSet
4259  __init__(IMP::RestraintSet self, IMP::RestraintsTemp const & rs, double weight) -> RestraintSet
4260  """
4261  this = _IMP_kernel.new_RestraintSet(*args)
4262  try:
4263  self.this.append(this)
4264  except:
4265  self.this = this
4266 
4267  def get_version_info(self):
4268  """get_version_info(RestraintSet self) -> VersionInfo"""
4269  return _IMP_kernel.RestraintSet_get_version_info(self)
4270 
4271 
4272  def remove_restraint(self, d):
4273  """remove_restraint(RestraintSet self, Restraint d)"""
4274  return _IMP_kernel.RestraintSet_remove_restraint(self, d)
4275 
4276 
4277  def remove_restraints(self, d):
4278  """remove_restraints(RestraintSet self, IMP::Restraints const & d)"""
4279  return _IMP_kernel.RestraintSet_remove_restraints(self, d)
4280 
4281 
4282  def set_restraints(self, ps):
4283  """set_restraints(RestraintSet self, IMP::Restraints const & ps)"""
4284  return _IMP_kernel.RestraintSet_set_restraints(self, ps)
4285 
4286 
4287  def set_restraints_order(self, objs):
4288  """set_restraints_order(RestraintSet self, IMP::Restraints const & objs)"""
4289  return _IMP_kernel.RestraintSet_set_restraints_order(self, objs)
4290 
4291 
4292  def add_restraint(self, obj):
4293  """add_restraint(RestraintSet self, Restraint obj) -> unsigned int"""
4294  return _IMP_kernel.RestraintSet_add_restraint(self, obj)
4295 
4296 
4297  def add_restraints(self, objs):
4298  """add_restraints(RestraintSet self, IMP::Restraints const & objs)"""
4299  return _IMP_kernel.RestraintSet_add_restraints(self, objs)
4300 
4301 
4302  def clear_restraints(self):
4303  """clear_restraints(RestraintSet self)"""
4304  return _IMP_kernel.RestraintSet_clear_restraints(self)
4305 
4306 
4307  def get_number_of_restraints(self):
4308  """get_number_of_restraints(RestraintSet self) -> unsigned int"""
4309  return _IMP_kernel.RestraintSet_get_number_of_restraints(self)
4310 
4311 
4312  def get_has_restraints(self):
4313  """get_has_restraints(RestraintSet self) -> bool"""
4314  return _IMP_kernel.RestraintSet_get_has_restraints(self)
4315 
4316 
4317  def get_restraint(self, i):
4318  """get_restraint(RestraintSet self, unsigned int i) -> Restraint"""
4319  return _IMP_kernel.RestraintSet_get_restraint(self, i)
4320 
4321 
4322  def get_restraints(self):
4323  """get_restraints(RestraintSet self) -> IMP::Restraints"""
4324  return _IMP_kernel.RestraintSet_get_restraints(self)
4325 
4326 
4327  def reserve_restraints(self, sz):
4328  """reserve_restraints(RestraintSet self, unsigned int sz)"""
4329  return _IMP_kernel.RestraintSet_reserve_restraints(self, sz)
4330 
4331 
4332  def get_non_sets_and_sets(self):
4333  """get_non_sets_and_sets(RestraintSet self) -> std::pair< IMP::RestraintsTemp,IMP::RestraintSetsTemp >"""
4334  return _IMP_kernel.RestraintSet_get_non_sets_and_sets(self)
4335 
4336 
4337  def do_get_inputs(self):
4338  """do_get_inputs(RestraintSet self) -> IMP::ModelObjectsTemp"""
4339  return _IMP_kernel.RestraintSet_do_get_inputs(self)
4340 
4341 
4342  def create_scoring_function(self, *args):
4343  """
4344  create_scoring_function(RestraintSet self, double weight=1.0, double max) -> ScoringFunction
4345  create_scoring_function(RestraintSet self, double weight=1.0) -> ScoringFunction
4346  create_scoring_function(RestraintSet self) -> ScoringFunction
4347  """
4348  return _IMP_kernel.RestraintSet_create_scoring_function(self, *args)
4349 
4350 
4351  def __str__(self):
4352  """__str__(RestraintSet self) -> std::string"""
4353  return _IMP_kernel.RestraintSet___str__(self)
4354 
4355 
4356  def __repr__(self):
4357  """__repr__(RestraintSet self) -> std::string"""
4358  return _IMP_kernel.RestraintSet___repr__(self)
4359 
4360 
4361  @staticmethod
4362  def get_from(o):
4363  return _object_cast_to_RestraintSet(o)
4364 
4365 RestraintSet_swigregister = _IMP_kernel.RestraintSet_swigregister
4366 RestraintSet_swigregister(RestraintSet)
4367 
4368 
4369 def get_restraints(rs):
4370  """get_restraints(IMP::RestraintsTemp const & rs) -> IMP::RestraintsTemp"""
4371  return _IMP_kernel.get_restraints(rs)
4372 
4373 def _check_particle(p, a):
4374  if (not p.get_is_active()):
4375  raise ValueError("Inactive Particle")
4376  if (type(a)() == a):
4377  raise IndexError("Cannot use default Index")
4378  if (not p.has_attribute(a)):
4379  raise IndexError("Particle does not have attribute")
4380 
4381 class Particle(ModelObject):
4382  """Proxy of C++ IMP::Particle class."""
4383 
4384  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
4385 
4386  def get_version_info(self):
4387  """get_version_info(Particle self) -> VersionInfo"""
4388  return _IMP_kernel.Particle_get_version_info(self)
4389 
4390 
4391  def __init__(self, *args):
4392  """
4393  __init__(IMP::Particle self, Model m, std::string name) -> Particle
4394  __init__(IMP::Particle self, Model m) -> Particle
4395  """
4396  this = _IMP_kernel.new_Particle(*args)
4397  try:
4398  self.this.append(this)
4399  except:
4400  self.this = this
4401 
4402  def get_float_keys(self):
4403  """get_float_keys(Particle self) -> IMP::FloatKeys"""
4404  return _IMP_kernel.Particle_get_float_keys(self)
4405 
4406 
4407  def get_int_keys(self):
4408  """get_int_keys(Particle self) -> IMP::IntKeys"""
4409  return _IMP_kernel.Particle_get_int_keys(self)
4410 
4411 
4412  def get_string_keys(self):
4413  """get_string_keys(Particle self) -> IMP::StringKeys"""
4414  return _IMP_kernel.Particle_get_string_keys(self)
4415 
4416 
4417  def get_object_keys(self):
4418  """get_object_keys(Particle self) -> IMP::ObjectKeys"""
4419  return _IMP_kernel.Particle_get_object_keys(self)
4420 
4421 
4422  def add_cache_attribute(self, *args):
4423  """
4424  add_cache_attribute(Particle self, FloatKey name, IMP::Float value)
4425  add_cache_attribute(Particle self, IntKey name, IMP::Int value)
4426  add_cache_attribute(Particle self, StringKey name, IMP::String value)
4427  add_cache_attribute(Particle self, ObjectKey name, Object value)
4428  add_cache_attribute(Particle self, IMP::WeakObjectKey name, Object value)
4429  """
4430  return _IMP_kernel.Particle_add_cache_attribute(self, *args)
4431 
4432 
4433  def get_weak_object_keys(self):
4434  """get_weak_object_keys(Particle self) -> IMP::WeakObjectKeys"""
4435  return _IMP_kernel.Particle_get_weak_object_keys(self)
4436 
4437 
4438  def add_to_derivative(self, key, value, da):
4439  """add_to_derivative(Particle self, FloatKey key, IMP::Float value, DerivativeAccumulator da)"""
4440  return _IMP_kernel.Particle_add_to_derivative(self, key, value, da)
4441 
4442 
4443  def set_is_optimized(self, k, tf):
4444  """set_is_optimized(Particle self, FloatKey k, bool tf)"""
4445  return _IMP_kernel.Particle_set_is_optimized(self, k, tf)
4446 
4447 
4448  def get_is_optimized(self, k):
4449  """get_is_optimized(Particle self, FloatKey k) -> bool"""
4450  return _IMP_kernel.Particle_get_is_optimized(self, k)
4451 
4452 
4453  def get_derivative(self, name):
4454  """get_derivative(Particle self, FloatKey name) -> IMP::Float"""
4455  return _IMP_kernel.Particle_get_derivative(self, name)
4456 
4457 
4458  def add_attribute(self, *args):
4459  """
4460  add_attribute(Particle self, FloatKey name, IMP::Float initial_value)
4461  add_attribute(Particle self, IntKey name, IMP::Int initial_value)
4462  add_attribute(Particle self, StringKey name, IMP::String initial_value)
4463  add_attribute(Particle self, ObjectKey name, Object initial_value)
4464  add_attribute(Particle self, IMP::WeakObjectKey name, Object initial_value)
4465  add_attribute(Particle self, FloatKey name, IMP::Float const initial_value, bool optimized)
4466  add_attribute(Particle self, ParticleIndexKey k, Particle v)
4467  """
4468  return _IMP_kernel.Particle_add_attribute(self, *args)
4469 
4470 
4471  def has_attribute(self, *args):
4472  """
4473  has_attribute(Particle self, FloatKey name) -> bool
4474  has_attribute(Particle self, IntKey name) -> bool
4475  has_attribute(Particle self, StringKey name) -> bool
4476  has_attribute(Particle self, ObjectKey name) -> bool
4477  has_attribute(Particle self, IMP::WeakObjectKey name) -> bool
4478  has_attribute(Particle self, ParticleIndexKey k) -> bool
4479  """
4480  return _IMP_kernel.Particle_has_attribute(self, *args)
4481 
4482 
4483  def set_value(self, *args):
4484  """
4485  set_value(Particle self, FloatKey name, IMP::Float value)
4486  set_value(Particle self, IntKey name, IMP::Int value)
4487  set_value(Particle self, StringKey name, IMP::String value)
4488  set_value(Particle self, ObjectKey name, Object value)
4489  set_value(Particle self, IMP::WeakObjectKey name, Object value)
4490  set_value(Particle self, ParticleIndexKey k, Particle v)
4491  """
4492  return _IMP_kernel.Particle_set_value(self, *args)
4493 
4494 
4495  def get_value(self, *args):
4496  """
4497  get_value(Particle self, FloatKey name) -> IMP::Float
4498  get_value(Particle self, IntKey name) -> IMP::Int
4499  get_value(Particle self, StringKey name) -> IMP::String
4500  get_value(Particle self, ObjectKey name) -> Object
4501  get_value(Particle self, IMP::WeakObjectKey name) -> Object
4502  get_value(Particle self, ParticleIndexKey k) -> Particle
4503  """
4504  return _IMP_kernel.Particle_get_value(self, *args)
4505 
4506 
4507  def remove_attribute(self, *args):
4508  """
4509  remove_attribute(Particle self, FloatKey name)
4510  remove_attribute(Particle self, IntKey name)
4511  remove_attribute(Particle self, StringKey name)
4512  remove_attribute(Particle self, ObjectKey name)
4513  remove_attribute(Particle self, IMP::WeakObjectKey name)
4514  remove_attribute(Particle self, ParticleIndexKey k)
4515  """
4516  return _IMP_kernel.Particle_remove_attribute(self, *args)
4517 
4518 
4519  def get_particle_keys(self):
4520  """get_particle_keys(Particle self) -> IMP::ParticleIndexKeys"""
4521  return _IMP_kernel.Particle_get_particle_keys(self)
4522 
4523 
4524  def show(self, *args):
4525  """
4526  show(Particle self, _ostream out)
4527  show(Particle self)
4528  """
4529  return _IMP_kernel.Particle_show(self, *args)
4530 
4531 
4532  def get_is_active(self):
4533  """get_is_active(Particle self) -> bool"""
4534  return _IMP_kernel.Particle_get_is_active(self)
4535 
4536 
4537  def get_index(self):
4538  """get_index(Particle self) -> ParticleIndex"""
4539  return _IMP_kernel.Particle_get_index(self)
4540 
4541 
4542  def __eq__(self, *args):
4543  """
4544  __eq__(Particle self, Particle o) -> bool
4545  __eq__(Particle self, Decorator d) -> bool
4546  """
4547  return _IMP_kernel.Particle___eq__(self, *args)
4548 
4549 
4550  def __ne__(self, *args):
4551  """
4552  __ne__(Particle self, Particle o) -> bool
4553  __ne__(Particle self, Decorator d) -> bool
4554  """
4555  return _IMP_kernel.Particle___ne__(self, *args)
4556 
4557 
4558  def __le__(self, *args):
4559  """
4560  __le__(Particle self, Particle o) -> bool
4561  __le__(Particle self, Decorator d) -> bool
4562  """
4563  return _IMP_kernel.Particle___le__(self, *args)
4564 
4565 
4566  def __lt__(self, *args):
4567  """
4568  __lt__(Particle self, Particle o) -> bool
4569  __lt__(Particle self, Decorator d) -> bool
4570  """
4571  return _IMP_kernel.Particle___lt__(self, *args)
4572 
4573 
4574  def __ge__(self, *args):
4575  """
4576  __ge__(Particle self, Particle o) -> bool
4577  __ge__(Particle self, Decorator d) -> bool
4578  """
4579  return _IMP_kernel.Particle___ge__(self, *args)
4580 
4581 
4582  def __gt__(self, *args):
4583  """
4584  __gt__(Particle self, Particle o) -> bool
4585  __gt__(Particle self, Decorator d) -> bool
4586  """
4587  return _IMP_kernel.Particle___gt__(self, *args)
4588 
4589 
4590  __hash__ = ModelObject.__hash__
4591 
4592 
4593  def __str__(self):
4594  """__str__(Particle self) -> std::string"""
4595  return _IMP_kernel.Particle___str__(self)
4596 
4597 
4598  def __repr__(self):
4599  """__repr__(Particle self) -> std::string"""
4600  return _IMP_kernel.Particle___repr__(self)
4601 
4602 
4603  @staticmethod
4604  def get_from(o):
4605  return _object_cast_to_Particle(o)
4606 
4607 Particle_swigregister = _IMP_kernel.Particle_swigregister
4608 Particle_swigregister(Particle)
4609 
4610 class _ParticleAdaptor(_InputAdaptor):
4611  """Proxy of C++ IMP::ParticleAdaptor class."""
4612 
4613  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
4614  __repr__ = _swig_repr
4615 
4616  def __init__(self, *args):
4617  """
4618  __init__(IMP::ParticleAdaptor self) -> _ParticleAdaptor
4619  __init__(IMP::ParticleAdaptor self, Particle p) -> _ParticleAdaptor
4620  __init__(IMP::ParticleAdaptor self, Decorator d) -> _ParticleAdaptor
4621  """
4622  this = _IMP_kernel.new__ParticleAdaptor(*args)
4623  try:
4624  self.this.append(this)
4625  except:
4626  self.this = this
4627 
4628  def get_model(self):
4629  """get_model(_ParticleAdaptor self) -> Model"""
4630  return _IMP_kernel._ParticleAdaptor_get_model(self)
4631 
4632 
4633  def get_particle_index(self):
4634  """get_particle_index(_ParticleAdaptor self) -> ParticleIndex"""
4635  return _IMP_kernel._ParticleAdaptor_get_particle_index(self)
4636 
4637  __swig_destroy__ = _IMP_kernel.delete__ParticleAdaptor
4638  __del__ = lambda self: None
4639 _ParticleAdaptor_swigregister = _IMP_kernel._ParticleAdaptor_swigregister
4640 _ParticleAdaptor_swigregister(_ParticleAdaptor)
4641 
4642 class _DependencyGraphVertexIndex(object):
4643  """Proxy of C++ IMP::DependencyGraphVertexIndex class."""
4644 
4645  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
4646  __repr__ = _swig_repr
4647 
4648  def __init__(self):
4649  """__init__(IMP::DependencyGraphVertexIndex self) -> _DependencyGraphVertexIndex"""
4650  this = _IMP_kernel.new__DependencyGraphVertexIndex()
4651  try:
4652  self.this.append(this)
4653  except:
4654  self.this = this
4655  __swig_destroy__ = _IMP_kernel.delete__DependencyGraphVertexIndex
4656  __del__ = lambda self: None
4657 _DependencyGraphVertexIndex_swigregister = _IMP_kernel._DependencyGraphVertexIndex_swigregister
4658 _DependencyGraphVertexIndex_swigregister(_DependencyGraphVertexIndex)
4659 
4660 
4661 def show_as_graphviz(name, out):
4662  """show_as_graphviz(IMP::DependencyGraph const & name, TextOutput out)"""
4663  return _IMP_kernel.show_as_graphviz(name, out)
4664 
4665 def get_vertex_index(g):
4666  """get_vertex_index(IMP::DependencyGraph const & g) -> _DependencyGraphVertexIndex"""
4667  return _IMP_kernel.get_vertex_index(g)
4668 
4669 def get_dependency_graph(m):
4670  """get_dependency_graph(Model m) -> IMP::DependencyGraph"""
4671  return _IMP_kernel.get_dependency_graph(m)
4672 
4674  """get_pruned_dependency_graph(Model m) -> IMP::DependencyGraph"""
4675  return _IMP_kernel.get_pruned_dependency_graph(m)
4676 
4677 def get_required_score_states(*args):
4678  """
4679  get_required_score_states(IMP::ModelObjectsTemp const & mos, IMP::ScoreStatesTemp exclude) -> IMP::ScoreStatesTemp
4680  get_required_score_states(IMP::ModelObjectsTemp const & mos) -> IMP::ScoreStatesTemp
4681  get_required_score_states(ModelObject p, IMP::ModelObjectsTemp const & all, IMP::DependencyGraph const & dg, _DependencyGraphVertexIndex index) -> IMP::ScoreStatesTemp
4682  """
4683  return _IMP_kernel.get_required_score_states(*args)
4684 
4685 def get_dependent_particles(p, all, dg, index):
4686  """get_dependent_particles(ModelObject p, IMP::ModelObjectsTemp const & all, IMP::DependencyGraph const & dg, _DependencyGraphVertexIndex index) -> IMP::ParticlesTemp"""
4687  return _IMP_kernel.get_dependent_particles(p, all, dg, index)
4688 
4689 def get_dependent_restraints(m, pi):
4690  """get_dependent_restraints(Model m, ParticleIndex pi) -> IMP::RestraintsTemp"""
4691  return _IMP_kernel.get_dependent_restraints(m, pi)
4692 class ScoringFunction(ModelObject):
4693  """Proxy of C++ IMP::ScoringFunction class."""
4694 
4695  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
4696 
4697  def do_add_score_and_derivatives(self, sa, ss):
4698  """do_add_score_and_derivatives(ScoringFunction self, ScoreAccumulator sa, IMP::ScoreStatesTemp const & ss)"""
4699  return _IMP_kernel.ScoringFunction_do_add_score_and_derivatives(self, sa, ss)
4700 
4701 
4702  def get_score_accumulator_if_below(self, deriv, max):
4703  """get_score_accumulator_if_below(ScoringFunction self, bool deriv, double max) -> ScoreAccumulator"""
4704  return _IMP_kernel.ScoringFunction_get_score_accumulator_if_below(self, deriv, max)
4705 
4706 
4707  def get_score_accumulator_if_good(self, deriv):
4708  """get_score_accumulator_if_good(ScoringFunction self, bool deriv) -> ScoreAccumulator"""
4709  return _IMP_kernel.ScoringFunction_get_score_accumulator_if_good(self, deriv)
4710 
4711 
4712  def get_score_accumulator(self, deriv):
4713  """get_score_accumulator(ScoringFunction self, bool deriv) -> ScoreAccumulator"""
4714  return _IMP_kernel.ScoringFunction_get_score_accumulator(self, deriv)
4715 
4716 
4717  def __init__(self, m, name):
4718  """__init__(IMP::ScoringFunction self, Model m, std::string name) -> ScoringFunction"""
4719  if self.__class__ == ScoringFunction:
4720  _self = None
4721  else:
4722  _self = self
4723  this = _IMP_kernel.new_ScoringFunction(_self, m, name)
4724  try:
4725  self.this.append(this)
4726  except:
4727  self.this = this
4728 
4729  if self.__class__ != ScoringFunction:
4730  _director_objects.register(self)
4731 
4732 
4733 
4734 
4735  def do_get_outputs(self):
4736  """do_get_outputs(ScoringFunction self) -> IMP::ModelObjectsTemp"""
4737  return _IMP_kernel.ScoringFunction_do_get_outputs(self)
4738 
4739 
4740  def evaluate_if_good(self, derivatives):
4741  """evaluate_if_good(ScoringFunction self, bool derivatives) -> double"""
4742  return _IMP_kernel.ScoringFunction_evaluate_if_good(self, derivatives)
4743 
4744 
4745  def evaluate(self, derivatives):
4746  """evaluate(ScoringFunction self, bool derivatives) -> double"""
4747  return _IMP_kernel.ScoringFunction_evaluate(self, derivatives)
4748 
4749 
4750  def evaluate_if_below(self, derivatives, max):
4751  """evaluate_if_below(ScoringFunction self, bool derivatives, double max) -> double"""
4752  return _IMP_kernel.ScoringFunction_evaluate_if_below(self, derivatives, max)
4753 
4754 
4755  def get_had_good_score(self):
4756  """get_had_good_score(ScoringFunction self) -> bool"""
4757  return _IMP_kernel.ScoringFunction_get_had_good_score(self)
4758 
4759 
4760  def get_last_score(self):
4761  """get_last_score(ScoringFunction self) -> double"""
4762  return _IMP_kernel.ScoringFunction_get_last_score(self)
4763 
4764 
4765  def create_restraints(self):
4766  """create_restraints(ScoringFunction self) -> IMP::Restraints"""
4767  return _IMP_kernel.ScoringFunction_create_restraints(self)
4768 
4769 
4770  def __str__(self):
4771  """__str__(ScoringFunction self) -> std::string"""
4772  return _IMP_kernel.ScoringFunction___str__(self)
4773 
4774 
4775  def __repr__(self):
4776  """__repr__(ScoringFunction self) -> std::string"""
4777  return _IMP_kernel.ScoringFunction___repr__(self)
4778 
4779 
4780  @staticmethod
4781  def get_from(o):
4782  return _object_cast_to_ScoringFunction(o)
4783 
4784 
4785  def get_type_name(self):
4786  return self.__class__.__name__
4787  def do_show(self, out):
4788  pass
4789  def get_version_info(self):
4790  if"IMP" == "IMP":
4791  return VersionInfo(self.__module__,
4792  __import__(self.__module__).get_module_version())
4793  else:
4794  return IMP.VersionInfo(self.__module__,
4795  __import__(self.__module__).get_module_version())
4796  @staticmethod
4797  def get_from(o):
4798  return _object_cast_to_ScoringFunction(o)
4799 
4800  __swig_destroy__ = _IMP_kernel.delete_ScoringFunction
4801  __del__ = lambda self: None
4802  def __disown__(self):
4803  self.this.disown()
4804  _IMP_kernel.disown_ScoringFunction(self)
4805  return weakref_proxy(self)
4806 
4807  def do_destroy(self):
4808  """do_destroy(ScoringFunction self)"""
4809  return _IMP_kernel.ScoringFunction_do_destroy(self)
4810 
4811 
4812  def handle_set_has_required_score_states(self, arg0):
4813  """handle_set_has_required_score_states(ScoringFunction self, bool arg0)"""
4814  return _IMP_kernel.ScoringFunction_handle_set_has_required_score_states(self, arg0)
4815 
4816 
4817  def do_get_inputs(self):
4818  """do_get_inputs(ScoringFunction self) -> IMP::ModelObjectsTemp"""
4819  return _IMP_kernel.ScoringFunction_do_get_inputs(self)
4820 
4821 
4822  def do_get_interactions(self):
4823  """do_get_interactions(ScoringFunction self) -> IMP::ModelObjectsTemps"""
4824  return _IMP_kernel.ScoringFunction_do_get_interactions(self)
4825 
4826 ScoringFunction_swigregister = _IMP_kernel.ScoringFunction_swigregister
4827 ScoringFunction_swigregister(ScoringFunction)
4828 
4829 
4830 def create_decomposition(*args):
4831  """
4832  create_decomposition(IMP::RestraintsTemp const & rs) -> IMP::Restraints
4833  create_decomposition(ScoringFunction sf) -> IMP::ScoringFunctions
4834  """
4835  return _IMP_kernel.create_decomposition(*args)
4836 class _ScoringFunctionAdaptor(_InputAdaptor):
4837  """Proxy of C++ IMP::ScoringFunctionAdaptor class."""
4838 
4839  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
4840  __repr__ = _swig_repr
4841 
4842  def __init__(self, *args):
4843  """
4844  __init__(IMP::ScoringFunctionAdaptor self) -> _ScoringFunctionAdaptor
4845  __init__(IMP::ScoringFunctionAdaptor self, ScoringFunction sf) -> _ScoringFunctionAdaptor
4846  __init__(IMP::ScoringFunctionAdaptor self, IMP::RestraintsTemp const & sf) -> _ScoringFunctionAdaptor
4847  __init__(IMP::ScoringFunctionAdaptor self, IMP::Restraints const & sf) -> _ScoringFunctionAdaptor
4848  __init__(IMP::ScoringFunctionAdaptor self, Restraint sf) -> _ScoringFunctionAdaptor
4849  """
4850  this = _IMP_kernel.new__ScoringFunctionAdaptor(*args)
4851  try:
4852  self.this.append(this)
4853  except:
4854  self.this = this
4855  __swig_destroy__ = _IMP_kernel.delete__ScoringFunctionAdaptor
4856  __del__ = lambda self: None
4857 _ScoringFunctionAdaptor_swigregister = _IMP_kernel._ScoringFunctionAdaptor_swigregister
4858 _ScoringFunctionAdaptor_swigregister(_ScoringFunctionAdaptor)
4859 
4860 
4861 def show_restraint_hierarchy(*args):
4862  """
4863  show_restraint_hierarchy(_ScoringFunctionAdaptor rs, _ostream out)
4864  show_restraint_hierarchy(_ScoringFunctionAdaptor rs)
4865  """
4866  return _IMP_kernel.show_restraint_hierarchy(*args)
4867 class Undecorator(Object):
4868  """Proxy of C++ IMP::Undecorator class."""
4869 
4870  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
4871 
4872  def __init__(self, m, name):
4873  """__init__(IMP::Undecorator self, Model m, std::string name) -> Undecorator"""
4874  if self.__class__ == Undecorator:
4875  _self = None
4876  else:
4877  _self = self
4878  this = _IMP_kernel.new_Undecorator(_self, m, name)
4879  try:
4880  self.this.append(this)
4881  except:
4882  self.this = this
4883 
4884  if self.__class__ != Undecorator:
4885  _director_objects.register(self)
4886 
4887 
4888 
4889 
4890  def teardown(self, pi):
4891  """teardown(Undecorator self, ParticleIndex pi)"""
4892  return _IMP_kernel.Undecorator_teardown(self, pi)
4893 
4894 
4895  def __str__(self):
4896  """__str__(Undecorator self) -> std::string"""
4897  return _IMP_kernel.Undecorator___str__(self)
4898 
4899 
4900  def __repr__(self):
4901  """__repr__(Undecorator self) -> std::string"""
4902  return _IMP_kernel.Undecorator___repr__(self)
4903 
4904 
4905  @staticmethod
4906  def get_from(o):
4907  return _object_cast_to_Undecorator(o)
4908 
4909 
4910  def get_type_name(self):
4911  return self.__class__.__name__
4912  def do_show(self, out):
4913  pass
4914  def get_version_info(self):
4915  if"IMP" == "IMP":
4916  return VersionInfo(self.__module__,
4917  __import__(self.__module__).get_module_version())
4918  else:
4919  return IMP.VersionInfo(self.__module__,
4920  __import__(self.__module__).get_module_version())
4921  @staticmethod
4922  def get_from(o):
4923  return _object_cast_to_Undecorator(o)
4924 
4925  __swig_destroy__ = _IMP_kernel.delete_Undecorator
4926  __del__ = lambda self: None
4927  def __disown__(self):
4928  self.this.disown()
4929  _IMP_kernel.disown_Undecorator(self)
4930  return weakref_proxy(self)
4931 
4932  def do_destroy(self):
4933  """do_destroy(Undecorator self)"""
4934  return _IMP_kernel.Undecorator_do_destroy(self)
4935 
4936 Undecorator_swigregister = _IMP_kernel.Undecorator_swigregister
4937 Undecorator_swigregister(Undecorator)
4938 
4939 class Model(Object):
4940  """Proxy of C++ IMP::Model class."""
4941 
4942  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
4943 
4944  def __init__(self, *args):
4945  """
4946  __init__(IMP::Model self, std::string name) -> Model
4947  __init__(IMP::Model self) -> Model
4948  """
4949  this = _IMP_kernel.new_Model(*args)
4950  try:
4951  self.this.append(this)
4952  except:
4953  self.this = this
4954 
4955  def clear_particle_caches(self, pi):
4956  """clear_particle_caches(Model self, ParticleIndex pi)"""
4957  return _IMP_kernel.Model_clear_particle_caches(self, pi)
4958 
4959 
4960  def add_particle(self, name):
4961  """add_particle(Model self, std::string name) -> ParticleIndex"""
4962  return _IMP_kernel.Model_add_particle(self, name)
4963 
4964 
4965  def get_particle_name(self, pi):
4966  """get_particle_name(Model self, ParticleIndex pi) -> std::string"""
4967  return _IMP_kernel.Model_get_particle_name(self, pi)
4968 
4969 
4970  def add_undecorator(self, pi, d):
4971  """add_undecorator(Model self, ParticleIndex pi, Undecorator d)"""
4972  return _IMP_kernel.Model_add_undecorator(self, pi, d)
4973 
4974 
4975  def remove_score_state(self, d):
4976  """remove_score_state(Model self, ScoreState d)"""
4977  return _IMP_kernel.Model_remove_score_state(self, d)
4978 
4979 
4980  def remove_score_states(self, d):
4981  """remove_score_states(Model self, IMP::ScoreStates const & d)"""
4982  return _IMP_kernel.Model_remove_score_states(self, d)
4983 
4984 
4985  def set_score_states(self, ps):
4986  """set_score_states(Model self, IMP::ScoreStates const & ps)"""
4987  return _IMP_kernel.Model_set_score_states(self, ps)
4988 
4989 
4990  def set_score_states_order(self, objs):
4991  """set_score_states_order(Model self, IMP::ScoreStates const & objs)"""
4992  return _IMP_kernel.Model_set_score_states_order(self, objs)
4993 
4994 
4995  def add_score_state(self, obj):
4996  """add_score_state(Model self, ScoreState obj) -> unsigned int"""
4997  return _IMP_kernel.Model_add_score_state(self, obj)
4998 
4999 
5000  def add_score_states(self, objs):
5001  """add_score_states(Model self, IMP::ScoreStates const & objs)"""
5002  return _IMP_kernel.Model_add_score_states(self, objs)
5003 
5004 
5005  def clear_score_states(self):
5006  """clear_score_states(Model self)"""
5007  return _IMP_kernel.Model_clear_score_states(self)
5008 
5009 
5010  def get_number_of_score_states(self):
5011  """get_number_of_score_states(Model self) -> unsigned int"""
5012  return _IMP_kernel.Model_get_number_of_score_states(self)
5013 
5014 
5015  def get_has_score_states(self):
5016  """get_has_score_states(Model self) -> bool"""
5017  return _IMP_kernel.Model_get_has_score_states(self)
5018 
5019 
5020  def get_score_state(self, i):
5021  """get_score_state(Model self, unsigned int i) -> ScoreState"""
5022  return _IMP_kernel.Model_get_score_state(self, i)
5023 
5024 
5025  def get_score_states(self):
5026  """get_score_states(Model self) -> IMP::ScoreStates"""
5027  return _IMP_kernel.Model_get_score_states(self)
5028 
5029 
5030  def reserve_score_states(self, sz):
5031  """reserve_score_states(Model self, unsigned int sz)"""
5032  return _IMP_kernel.Model_reserve_score_states(self, sz)
5033 
5034 
5035  def update(self):
5036  """update(Model self)"""
5037  return _IMP_kernel.Model_update(self)
5038 
5039 
5040  def add_attribute(self, *args):
5041  """
5042  add_attribute(Model self, FloatKey attribute_key, ParticleIndex particle, IMP::Float value)
5043  add_attribute(Model self, IntKey attribute_key, ParticleIndex particle, IMP::Int value)
5044  add_attribute(Model self, IMP::IntsKey attribute_key, ParticleIndex particle, IMP::Ints value)
5045  add_attribute(Model self, StringKey attribute_key, ParticleIndex particle, IMP::String value)
5046  add_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle, IMP::ParticleIndexes value)
5047  add_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle, ParticleIndex value)
5048  add_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle, Object value)
5049  add_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle, Object value)
5050  """
5051  return _IMP_kernel.Model_add_attribute(self, *args)
5052 
5053 
5054  def remove_attribute(self, *args):
5055  """
5056  remove_attribute(Model self, FloatKey attribute_key, ParticleIndex particle)
5057  remove_attribute(Model self, IntKey attribute_key, ParticleIndex particle)
5058  remove_attribute(Model self, IMP::IntsKey attribute_key, ParticleIndex particle)
5059  remove_attribute(Model self, StringKey attribute_key, ParticleIndex particle)
5060  remove_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle)
5061  remove_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle)
5062  remove_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle)
5063  remove_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle)
5064  """
5065  return _IMP_kernel.Model_remove_attribute(self, *args)
5066 
5067 
5068  def get_has_attribute(self, *args):
5069  """
5070  get_has_attribute(Model self, FloatKey attribute_key, ParticleIndex particle) -> bool
5071  get_has_attribute(Model self, IntKey attribute_key, ParticleIndex particle) -> bool
5072  get_has_attribute(Model self, IMP::IntsKey attribute_key, ParticleIndex particle) -> bool
5073  get_has_attribute(Model self, StringKey attribute_key, ParticleIndex particle) -> bool
5074  get_has_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle) -> bool
5075  get_has_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle) -> bool
5076  get_has_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle) -> bool
5077  get_has_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle) -> bool
5078  """
5079  return _IMP_kernel.Model_get_has_attribute(self, *args)
5080 
5081 
5082  def set_attribute(self, *args):
5083  """
5084  set_attribute(Model self, FloatKey attribute_key, ParticleIndex particle, IMP::Float value)
5085  set_attribute(Model self, IntKey attribute_key, ParticleIndex particle, IMP::Int value)
5086  set_attribute(Model self, IMP::IntsKey attribute_key, ParticleIndex particle, IMP::Ints value)
5087  set_attribute(Model self, StringKey attribute_key, ParticleIndex particle, IMP::String value)
5088  set_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle, IMP::ParticleIndexes value)
5089  set_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle, ParticleIndex value)
5090  set_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle, Object value)
5091  set_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle, Object value)
5092  """
5093  return _IMP_kernel.Model_set_attribute(self, *args)
5094 
5095 
5096  def get_attribute(self, *args):
5097  """
5098  get_attribute(Model self, FloatKey attribute_key, ParticleIndex particle) -> IMP::Float
5099  get_attribute(Model self, IntKey attribute_key, ParticleIndex particle) -> IMP::Int
5100  get_attribute(Model self, IMP::IntsKey attribute_key, ParticleIndex particle) -> IMP::Ints
5101  get_attribute(Model self, StringKey attribute_key, ParticleIndex particle) -> IMP::String
5102  get_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle) -> IMP::ParticleIndexes
5103  get_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle) -> ParticleIndex
5104  get_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle) -> Object
5105  get_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle) -> Object
5106  """
5107  return _IMP_kernel.Model_get_attribute(self, *args)
5108 
5109 
5110  def add_cache_attribute(self, *args):
5111  """
5112  add_cache_attribute(Model self, FloatKey attribute_key, ParticleIndex particle, IMP::Float value)
5113  add_cache_attribute(Model self, IntKey attribute_key, ParticleIndex particle, IMP::Int value)
5114  add_cache_attribute(Model self, IMP::IntsKey attribute_key, ParticleIndex particle, IMP::Ints value)
5115  add_cache_attribute(Model self, StringKey attribute_key, ParticleIndex particle, IMP::String value)
5116  add_cache_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle, IMP::ParticleIndexes value)
5117  add_cache_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle, ParticleIndex value)
5118  add_cache_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle, Object value)
5119  add_cache_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle, Object value)
5120  """
5121  return _IMP_kernel.Model_add_cache_attribute(self, *args)
5122 
5123 
5124  def set_is_optimized(self, arg2, arg3, arg4):
5125  """set_is_optimized(Model self, FloatKey arg2, ParticleIndex arg3, bool arg4)"""
5126  return _IMP_kernel.Model_set_is_optimized(self, arg2, arg3, arg4)
5127 
5128 
5129  def add_to_derivative(self, k, particle, v, da):
5130  """add_to_derivative(Model self, FloatKey k, ParticleIndex particle, double v, DerivativeAccumulator da)"""
5131  return _IMP_kernel.Model_add_to_derivative(self, k, particle, v, da)
5132 
5133 
5134  def get_particle(self, p):
5135  """get_particle(Model self, ParticleIndex p) -> Particle"""
5136  return _IMP_kernel.Model_get_particle(self, p)
5137 
5138 
5139  def get_has_particle(self, p):
5140  """get_has_particle(Model self, ParticleIndex p) -> bool"""
5141  return _IMP_kernel.Model_get_has_particle(self, p)
5142 
5143 
5144  def get_particle_indexes(self):
5145  """get_particle_indexes(Model self) -> IMP::ParticleIndexes"""
5146  return _IMP_kernel.Model_get_particle_indexes(self)
5147 
5148 
5149  def get_model_objects(self):
5150  """get_model_objects(Model self) -> IMP::ModelObjectsTemp"""
5151  return _IMP_kernel.Model_get_model_objects(self)
5152 
5153 
5154  def remove_particle(self, pi):
5155  """remove_particle(Model self, ParticleIndex pi)"""
5156  return _IMP_kernel.Model_remove_particle(self, pi)
5157 
5158 
5159  def add_data(self, mk, o):
5160  """add_data(Model self, ModelKey mk, Object o)"""
5161  return _IMP_kernel.Model_add_data(self, mk, o)
5162 
5163 
5164  def get_data(self, mk):
5165  """get_data(Model self, ModelKey mk) -> Object"""
5166  return _IMP_kernel.Model_get_data(self, mk)
5167 
5168 
5169  def remove_data(self, mk):
5170  """remove_data(Model self, ModelKey mk)"""
5171  return _IMP_kernel.Model_remove_data(self, mk)
5172 
5173 
5174  def get_has_data(self, mk):
5175  """get_has_data(Model self, ModelKey mk) -> bool"""
5176  return _IMP_kernel.Model_get_has_data(self, mk)
5177 
5178 
5179  def get_version_info(self):
5180  """get_version_info(Model self) -> VersionInfo"""
5181  return _IMP_kernel.Model_get_version_info(self)
5182 
5183 
5184  def do_destroy(self):
5185  """do_destroy(Model self)"""
5186  return _IMP_kernel.Model_do_destroy(self)
5187 
5188 
5189  def __str__(self):
5190  """__str__(Model self) -> std::string"""
5191  return _IMP_kernel.Model___str__(self)
5192 
5193 
5194  def __repr__(self):
5195  """__repr__(Model self) -> std::string"""
5196  return _IMP_kernel.Model___repr__(self)
5197 
5198 
5199  @staticmethod
5200  def get_from(o):
5201  return _object_cast_to_Model(o)
5202 
5203 Model_swigregister = _IMP_kernel.Model_swigregister
5204 Model_swigregister(Model)
5205 
5206 class Decorator(_Value):
5207  """Proxy of C++ IMP::Decorator class."""
5208 
5209  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
5210  __repr__ = _swig_repr
5211 
5212  def __init__(self, p):
5213  """__init__(IMP::Decorator self, _ParticleAdaptor p) -> Decorator"""
5214  this = _IMP_kernel.new_Decorator(p)
5215  try:
5216  self.this.append(this)
5217  except:
5218  self.this = this
5219 
5220  def __ne__(self, o):
5221  """__ne__(Decorator self, Object o) -> bool"""
5222  return _IMP_kernel.Decorator___ne__(self, o)
5223 
5224 
5225  def __lt__(self, o):
5226  """__lt__(Decorator self, Object o) -> bool"""
5227  return _IMP_kernel.Decorator___lt__(self, o)
5228 
5229 
5230  def __gt__(self, o):
5231  """__gt__(Decorator self, Object o) -> bool"""
5232  return _IMP_kernel.Decorator___gt__(self, o)
5233 
5234 
5235  def __ge__(self, o):
5236  """__ge__(Decorator self, Object o) -> bool"""
5237  return _IMP_kernel.Decorator___ge__(self, o)
5238 
5239 
5240  def __le__(self, o):
5241  """__le__(Decorator self, Object o) -> bool"""
5242  return _IMP_kernel.Decorator___le__(self, o)
5243 
5244 
5245  def get_particle(self):
5246  """get_particle(Decorator self) -> Particle"""
5247  return _IMP_kernel.Decorator_get_particle(self)
5248 
5249 
5250  def get_particle_index(self):
5251  """get_particle_index(Decorator self) -> ParticleIndex"""
5252  return _IMP_kernel.Decorator_get_particle_index(self)
5253 
5254 
5255  def get_model(self):
5256  """get_model(Decorator self) -> Model"""
5257  return _IMP_kernel.Decorator_get_model(self)
5258 
5259 
5260  def get_is_valid(self):
5261  """get_is_valid(Decorator self) -> bool"""
5262  return _IMP_kernel.Decorator_get_is_valid(self)
5263 
5264 
5265  def __hash__(self):
5266  """__hash__(Decorator self) -> std::size_t"""
5267  return _IMP_kernel.Decorator___hash__(self)
5268 
5269 
5270  def __eq__(self, *args):
5271  """
5272  __eq__(Decorator self, Object o) -> bool
5273  __eq__(Decorator self, Decorator o) -> bool
5274  __eq__(Decorator self, Particle o) -> bool
5275  """
5276  return _IMP_kernel.Decorator___eq__(self, *args)
5277 
5278 
5279  def __bool__(self):
5280  """__bool__(Decorator self) -> bool"""
5281  return _IMP_kernel.Decorator___bool__(self)
5282 
5283 
5284  __nonzero__ = __bool__
5285 
5286  __swig_destroy__ = _IMP_kernel.delete_Decorator
5287  __del__ = lambda self: None
5288 Decorator_swigregister = _IMP_kernel.Decorator_swigregister
5289 Decorator_swigregister(Decorator)
5290 
5291 
5292 def check_particle(m, pi):
5293  """check_particle(Model m, ParticleIndex pi)"""
5294  return _IMP_kernel.check_particle(m, pi)
5295 class UnaryFunction(Object):
5296  """Proxy of C++ IMP::UnaryFunction class."""
5297 
5298  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
5299 
5300  def __init__(self, *args):
5301  """
5302  __init__(IMP::UnaryFunction self, std::string name) -> UnaryFunction
5303  __init__(IMP::UnaryFunction self) -> UnaryFunction
5304  """
5305  if self.__class__ == UnaryFunction:
5306  _self = None
5307  else:
5308  _self = self
5309  this = _IMP_kernel.new_UnaryFunction(_self, *args)
5310  try:
5311  self.this.append(this)
5312  except:
5313  self.this = this
5314 
5315  if self.__class__ != UnaryFunction:
5316  _director_objects.register(self)
5317 
5318 
5319 
5320 
5321  def evaluate(self, feature):
5322  """evaluate(UnaryFunction self, double feature) -> double"""
5323  return _IMP_kernel.UnaryFunction_evaluate(self, feature)
5324 
5325 
5326  def evaluate_with_derivative(self, feature):
5327  """evaluate_with_derivative(UnaryFunction self, double feature) -> IMP::DerivativePair"""
5328  return _IMP_kernel.UnaryFunction_evaluate_with_derivative(self, feature)
5329 
5330  __swig_destroy__ = _IMP_kernel.delete_UnaryFunction
5331  __del__ = lambda self: None
5332 
5333  def __str__(self):
5334  """__str__(UnaryFunction self) -> std::string"""
5335  return _IMP_kernel.UnaryFunction___str__(self)
5336 
5337 
5338  def __repr__(self):
5339  """__repr__(UnaryFunction self) -> std::string"""
5340  return _IMP_kernel.UnaryFunction___repr__(self)
5341 
5342 
5343  @staticmethod
5344  def get_from(o):
5345  return _object_cast_to_UnaryFunction(o)
5346 
5347 
5348  def get_type_name(self):
5349  return self.__class__.__name__
5350  def do_show(self, out):
5351  pass
5352  def get_version_info(self):
5353  if"IMP" == "IMP":
5354  return VersionInfo(self.__module__,
5355  __import__(self.__module__).get_module_version())
5356  else:
5357  return IMP.VersionInfo(self.__module__,
5358  __import__(self.__module__).get_module_version())
5359  @staticmethod
5360  def get_from(o):
5361  return _object_cast_to_UnaryFunction(o)
5362 
5363  def __disown__(self):
5364  self.this.disown()
5365  _IMP_kernel.disown_UnaryFunction(self)
5366  return weakref_proxy(self)
5367 
5368  def do_destroy(self):
5369  """do_destroy(UnaryFunction self)"""
5370  return _IMP_kernel.UnaryFunction_do_destroy(self)
5371 
5372 UnaryFunction_swigregister = _IMP_kernel.UnaryFunction_swigregister
5373 UnaryFunction_swigregister(UnaryFunction)
5374 
5375 class OptimizerState(ModelObject):
5376  """Proxy of C++ IMP::OptimizerState class."""
5377 
5378  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
5379 
5380  def __init__(self, m, name):
5381  """__init__(IMP::OptimizerState self, Model m, std::string name) -> OptimizerState"""
5382  if self.__class__ == OptimizerState:
5383  _self = None
5384  else:
5385  _self = self
5386  this = _IMP_kernel.new_OptimizerState(_self, m, name)
5387  try:
5388  self.this.append(this)
5389  except:
5390  self.this = this
5391 
5392  if self.__class__ != OptimizerState:
5393  _director_objects.register(self)
5394 
5395 
5396 
5397 
5398  def update(self):
5399  """update(OptimizerState self)"""
5400  return _IMP_kernel.OptimizerState_update(self)
5401 
5402 
5403  def set_is_optimizing(self, arg0):
5404  """set_is_optimizing(OptimizerState self, bool arg0)"""
5405  return _IMP_kernel.OptimizerState_set_is_optimizing(self, arg0)
5406 
5407 
5408  def get_optimizer(self):
5409  """get_optimizer(OptimizerState self) -> Optimizer"""
5410  return _IMP_kernel.OptimizerState_get_optimizer(self)
5411 
5412 
5413  def set_period(self, p):
5414  """set_period(OptimizerState self, unsigned int p)"""
5415  return _IMP_kernel.OptimizerState_set_period(self, p)
5416 
5417 
5418  def get_period(self):
5419  """get_period(OptimizerState self) -> unsigned int"""
5420  return _IMP_kernel.OptimizerState_get_period(self)
5421 
5422 
5423  def reset(self):
5424  """reset(OptimizerState self)"""
5425  return _IMP_kernel.OptimizerState_reset(self)
5426 
5427 
5428  def update_always(self):
5429  """update_always(OptimizerState self)"""
5430  return _IMP_kernel.OptimizerState_update_always(self)
5431 
5432 
5433  def get_number_of_updates(self):
5434  """get_number_of_updates(OptimizerState self) -> unsigned int"""
5435  return _IMP_kernel.OptimizerState_get_number_of_updates(self)
5436 
5437 
5438  def set_number_of_updates(self, n):
5439  """set_number_of_updates(OptimizerState self, unsigned int n)"""
5440  return _IMP_kernel.OptimizerState_set_number_of_updates(self, n)
5441 
5442  __swig_destroy__ = _IMP_kernel.delete_OptimizerState
5443  __del__ = lambda self: None
5444 
5445  def do_update(self, arg0):
5446  """do_update(OptimizerState self, unsigned int arg0)"""
5447  return _IMP_kernel.OptimizerState_do_update(self, arg0)
5448 
5449 
5450  def do_set_is_optimizing(self, arg0):
5451  """do_set_is_optimizing(OptimizerState self, bool arg0)"""
5452  return _IMP_kernel.OptimizerState_do_set_is_optimizing(self, arg0)
5453 
5454 
5455  def do_get_inputs(self):
5456  """do_get_inputs(OptimizerState self) -> IMP::ModelObjectsTemp"""
5457  return _IMP_kernel.OptimizerState_do_get_inputs(self)
5458 
5459 
5460  def do_get_outputs(self):
5461  """do_get_outputs(OptimizerState self) -> IMP::ModelObjectsTemp"""
5462  return _IMP_kernel.OptimizerState_do_get_outputs(self)
5463 
5464 
5465  def __str__(self):
5466  """__str__(OptimizerState self) -> std::string"""
5467  return _IMP_kernel.OptimizerState___str__(self)
5468 
5469 
5470  def __repr__(self):
5471  """__repr__(OptimizerState self) -> std::string"""
5472  return _IMP_kernel.OptimizerState___repr__(self)
5473 
5474 
5475  @staticmethod
5476  def get_from(o):
5477  return _object_cast_to_OptimizerState(o)
5478 
5479 
5480  def get_type_name(self):
5481  return self.__class__.__name__
5482  def do_show(self, out):
5483  pass
5484  def get_version_info(self):
5485  if"IMP" == "IMP":
5486  return VersionInfo(self.__module__,
5487  __import__(self.__module__).get_module_version())
5488  else:
5489  return IMP.VersionInfo(self.__module__,
5490  __import__(self.__module__).get_module_version())
5491  @staticmethod
5492  def get_from(o):
5493  return _object_cast_to_OptimizerState(o)
5494 
5495  def __disown__(self):
5496  self.this.disown()
5497  _IMP_kernel.disown_OptimizerState(self)
5498  return weakref_proxy(self)
5499 
5500  def do_destroy(self):
5501  """do_destroy(OptimizerState self)"""
5502  return _IMP_kernel.OptimizerState_do_destroy(self)
5503 
5504 
5505  def handle_set_has_required_score_states(self, arg0):
5506  """handle_set_has_required_score_states(OptimizerState self, bool arg0)"""
5507  return _IMP_kernel.OptimizerState_handle_set_has_required_score_states(self, arg0)
5508 
5509 
5510  def do_get_interactions(self):
5511  """do_get_interactions(OptimizerState self) -> IMP::ModelObjectsTemps"""
5512  return _IMP_kernel.OptimizerState_do_get_interactions(self)
5513 
5514 OptimizerState_swigregister = _IMP_kernel.OptimizerState_swigregister
5515 OptimizerState_swigregister(OptimizerState)
5516 
5517 class Refiner(_ParticleInputs, Object):
5518  """Proxy of C++ IMP::Refiner class."""
5519 
5520  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
5521 
5522  def __init__(self, *args):
5523  """
5524  __init__(IMP::Refiner self, std::string name, bool is_by_ref=False) -> Refiner
5525  __init__(IMP::Refiner self, std::string name) -> Refiner
5526  __init__(IMP::Refiner self) -> Refiner
5527  """
5528  if self.__class__ == Refiner:
5529  _self = None
5530  else:
5531  _self = self
5532  this = _IMP_kernel.new_Refiner(_self, *args)
5533  try:
5534  self.this.append(this)
5535  except:
5536  self.this = this
5537 
5538  if self.__class__ != Refiner:
5539  _director_objects.register(self)
5540 
5541 
5542 
5543 
5544  def get_can_refine(self, arg0):
5545  """get_can_refine(Refiner self, Particle arg0) -> bool"""
5546  return _IMP_kernel.Refiner_get_can_refine(self, arg0)
5547 
5548 
5549  def get_refined_indexes(self, m, pi):
5550  """get_refined_indexes(Refiner self, Model m, ParticleIndex pi) -> IMP::ParticleIndexes"""
5551  return _IMP_kernel.Refiner_get_refined_indexes(self, m, pi)
5552 
5553 
5554  def get_refined_indexes_by_ref(self, m, pi):
5555  """get_refined_indexes_by_ref(Refiner self, Model m, ParticleIndex pi) -> IMP::ParticleIndexes const &"""
5556  return _IMP_kernel.Refiner_get_refined_indexes_by_ref(self, m, pi)
5557 
5558 
5559  def get_is_by_ref_supported(self):
5560  """get_is_by_ref_supported(Refiner self) -> bool"""
5561  return _IMP_kernel.Refiner_get_is_by_ref_supported(self)
5562 
5563 
5564  def get_refined(self, *args):
5565  """
5566  get_refined(Refiner self, Particle a) -> IMP::ParticlesTemp const
5567  get_refined(Refiner self, Particle a, unsigned int i) -> Particle
5568  """
5569  return _IMP_kernel.Refiner_get_refined(self, *args)
5570 
5571 
5572  def get_number_of_refined(self, a):
5573  """get_number_of_refined(Refiner self, Particle a) -> unsigned int"""
5574  return _IMP_kernel.Refiner_get_number_of_refined(self, a)
5575 
5576 
5577  def __str__(self):
5578  """__str__(Refiner self) -> std::string"""
5579  return _IMP_kernel.Refiner___str__(self)
5580 
5581 
5582  def __repr__(self):
5583  """__repr__(Refiner self) -> std::string"""
5584  return _IMP_kernel.Refiner___repr__(self)
5585 
5586 
5587  @staticmethod
5588  def get_from(o):
5589  return _object_cast_to_Refiner(o)
5590 
5591 
5592  def get_type_name(self):
5593  return self.__class__.__name__
5594  def do_show(self, out):
5595  pass
5596  def get_version_info(self):
5597  if"IMP" == "IMP":
5598  return VersionInfo(self.__module__,
5599  __import__(self.__module__).get_module_version())
5600  else:
5601  return IMP.VersionInfo(self.__module__,
5602  __import__(self.__module__).get_module_version())
5603  @staticmethod
5604  def get_from(o):
5605  return _object_cast_to_Refiner(o)
5606 
5607  __swig_destroy__ = _IMP_kernel.delete_Refiner
5608  __del__ = lambda self: None
5609  def __disown__(self):
5610  self.this.disown()
5611  _IMP_kernel.disown_Refiner(self)
5612  return weakref_proxy(self)
5613 
5614  def do_get_inputs(self, m, pis):
5615  """do_get_inputs(Refiner self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
5616  return _IMP_kernel.Refiner_do_get_inputs(self, m, pis)
5617 
5618 
5619  def do_destroy(self):
5620  """do_destroy(Refiner self)"""
5621  return _IMP_kernel.Refiner_do_destroy(self)
5622 
5623 Refiner_swigregister = _IMP_kernel.Refiner_swigregister
5624 Refiner_swigregister(Refiner)
5625 
5626 class Optimizer(ModelObject):
5627  """Proxy of C++ IMP::Optimizer class."""
5628 
5629  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
5630 
5631  def set_is_optimizing_states(self, tf):
5632  """set_is_optimizing_states(Optimizer self, bool tf)"""
5633  return _IMP_kernel.Optimizer_set_is_optimizing_states(self, tf)
5634 
5635 
5636  def get_optimizer_state_inputs(self):
5637  """get_optimizer_state_inputs(Optimizer self) -> IMP::ModelObjectsTemp"""
5638  return _IMP_kernel.Optimizer_get_optimizer_state_inputs(self)
5639 
5640 
5641  def do_get_inputs(self):
5642  """do_get_inputs(Optimizer self) -> IMP::ModelObjectsTemp"""
5643  return _IMP_kernel.Optimizer_do_get_inputs(self)
5644 
5645 
5646  def do_get_outputs(self):
5647  """do_get_outputs(Optimizer self) -> IMP::ModelObjectsTemp"""
5648  return _IMP_kernel.Optimizer_do_get_outputs(self)
5649 
5650 
5651  def __init__(self, *args):
5652  """
5653  __init__(IMP::Optimizer self, Model m, std::string name) -> Optimizer
5654  __init__(IMP::Optimizer self, Model m) -> Optimizer
5655  """
5656  if self.__class__ == Optimizer:
5657  _self = None
5658  else:
5659  _self = self
5660  this = _IMP_kernel.new_Optimizer(_self, *args)
5661  try:
5662  self.this.append(this)
5663  except:
5664  self.this = this
5665 
5666  if self.__class__ != Optimizer:
5667  _director_objects.register(self)
5668 
5669 
5670 
5671 
5672  def optimize(self, max_steps):
5673  """optimize(Optimizer self, unsigned int max_steps) -> double"""
5674  return _IMP_kernel.Optimizer_optimize(self, max_steps)
5675 
5676 
5677  def set_stop_on_good_score(self, tf):
5678  """set_stop_on_good_score(Optimizer self, bool tf)"""
5679  return _IMP_kernel.Optimizer_set_stop_on_good_score(self, tf)
5680 
5681 
5682  def get_stop_on_good_score(self):
5683  """get_stop_on_good_score(Optimizer self) -> bool"""
5684  return _IMP_kernel.Optimizer_get_stop_on_good_score(self)
5685 
5686 
5687  def get_last_score(self):
5688  """get_last_score(Optimizer self) -> double"""
5689  return _IMP_kernel.Optimizer_get_last_score(self)
5690 
5691 
5692  def get_scoring_function(self):
5693  """get_scoring_function(Optimizer self) -> ScoringFunction"""
5694  return _IMP_kernel.Optimizer_get_scoring_function(self)
5695 
5696 
5697  def remove_optimizer_state(self, d):
5698  """remove_optimizer_state(Optimizer self, OptimizerState d)"""
5699  return _IMP_kernel.Optimizer_remove_optimizer_state(self, d)
5700 
5701 
5702  def remove_optimizer_states(self, d):
5703  """remove_optimizer_states(Optimizer self, IMP::OptimizerStates const & d)"""
5704  return _IMP_kernel.Optimizer_remove_optimizer_states(self, d)
5705 
5706 
5707  def set_optimizer_states(self, ps):
5708  """set_optimizer_states(Optimizer self, IMP::OptimizerStates const & ps)"""
5709  return _IMP_kernel.Optimizer_set_optimizer_states(self, ps)
5710 
5711 
5712  def set_optimizer_states_order(self, objs):
5713  """set_optimizer_states_order(Optimizer self, IMP::OptimizerStates const & objs)"""
5714  return _IMP_kernel.Optimizer_set_optimizer_states_order(self, objs)
5715 
5716 
5717  def add_optimizer_state(self, obj):
5718  """add_optimizer_state(Optimizer self, OptimizerState obj) -> unsigned int"""
5719  return _IMP_kernel.Optimizer_add_optimizer_state(self, obj)
5720 
5721 
5722  def add_optimizer_states(self, objs):
5723  """add_optimizer_states(Optimizer self, IMP::OptimizerStates const & objs)"""
5724  return _IMP_kernel.Optimizer_add_optimizer_states(self, objs)
5725 
5726 
5727  def clear_optimizer_states(self):
5728  """clear_optimizer_states(Optimizer self)"""
5729  return _IMP_kernel.Optimizer_clear_optimizer_states(self)
5730 
5731 
5732  def get_number_of_optimizer_states(self):
5733  """get_number_of_optimizer_states(Optimizer self) -> unsigned int"""
5734  return _IMP_kernel.Optimizer_get_number_of_optimizer_states(self)
5735 
5736 
5737  def get_has_optimizer_states(self):
5738  """get_has_optimizer_states(Optimizer self) -> bool"""
5739  return _IMP_kernel.Optimizer_get_has_optimizer_states(self)
5740 
5741 
5742  def get_optimizer_state(self, i):
5743  """get_optimizer_state(Optimizer self, unsigned int i) -> OptimizerState"""
5744  return _IMP_kernel.Optimizer_get_optimizer_state(self, i)
5745 
5746 
5747  def get_optimizer_states(self):
5748  """get_optimizer_states(Optimizer self) -> IMP::OptimizerStates"""
5749  return _IMP_kernel.Optimizer_get_optimizer_states(self)
5750 
5751 
5752  def reserve_optimizer_states(self, sz):
5753  """reserve_optimizer_states(Optimizer self, unsigned int sz)"""
5754  return _IMP_kernel.Optimizer_reserve_optimizer_states(self, sz)
5755 
5756 
5757  def set_scoring_function(self, sf):
5758  """set_scoring_function(Optimizer self, _ScoringFunctionAdaptor sf)"""
5759  return _IMP_kernel.Optimizer_set_scoring_function(self, sf)
5760 
5761  __swig_destroy__ = _IMP_kernel.delete_Optimizer
5762  def __del__(self):
5763  """__del__(IMP::Optimizer self)"""
5764 
5765  _director_objects.cleanup()
5766 
5767 
5768  pass
5769 
5770 
5771  def do_optimize(self, ns):
5772  """do_optimize(Optimizer self, unsigned int ns) -> double"""
5773  return _IMP_kernel.Optimizer_do_optimize(self, ns)
5774 
5775 
5776  def update_states(self):
5777  """update_states(Optimizer self)"""
5778  return _IMP_kernel.Optimizer_update_states(self)
5779 
5780 
5781  def __str__(self):
5782  """__str__(Optimizer self) -> std::string"""
5783  return _IMP_kernel.Optimizer___str__(self)
5784 
5785 
5786  def __repr__(self):
5787  """__repr__(Optimizer self) -> std::string"""
5788  return _IMP_kernel.Optimizer___repr__(self)
5789 
5790 
5791  @staticmethod
5792  def get_from(o):
5793  return _object_cast_to_Optimizer(o)
5794 
5795 
5796  def get_type_name(self):
5797  return self.__class__.__name__
5798  def do_show(self, out):
5799  pass
5800  def get_version_info(self):
5801  if"IMP" == "IMP":
5802  return VersionInfo(self.__module__,
5803  __import__(self.__module__).get_module_version())
5804  else:
5805  return IMP.VersionInfo(self.__module__,
5806  __import__(self.__module__).get_module_version())
5807  @staticmethod
5808  def get_from(o):
5809  return _object_cast_to_Optimizer(o)
5810 
5811  def __disown__(self):
5812  self.this.disown()
5813  _IMP_kernel.disown_Optimizer(self)
5814  return weakref_proxy(self)
5815 
5816  def do_destroy(self):
5817  """do_destroy(Optimizer self)"""
5818  return _IMP_kernel.Optimizer_do_destroy(self)
5819 
5820 
5821  def handle_set_has_required_score_states(self, arg0):
5822  """handle_set_has_required_score_states(Optimizer self, bool arg0)"""
5823  return _IMP_kernel.Optimizer_handle_set_has_required_score_states(self, arg0)
5824 
5825 
5826  def do_get_interactions(self):
5827  """do_get_interactions(Optimizer self) -> IMP::ModelObjectsTemps"""
5828  return _IMP_kernel.Optimizer_do_get_interactions(self)
5829 
5830 Optimizer_swigregister = _IMP_kernel.Optimizer_swigregister
5831 Optimizer_swigregister(Optimizer)
5832 
5833 class AttributeOptimizer(Optimizer):
5834  """Proxy of C++ IMP::AttributeOptimizer class."""
5835 
5836  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
5837 
5838  def __init__(self, *args):
5839  """
5840  __init__(IMP::AttributeOptimizer self, Model m, std::string name) -> AttributeOptimizer
5841  __init__(IMP::AttributeOptimizer self, Model m) -> AttributeOptimizer
5842  """
5843  if self.__class__ == AttributeOptimizer:
5844  _self = None
5845  else:
5846  _self = self
5847  this = _IMP_kernel.new_AttributeOptimizer(_self, *args)
5848  try:
5849  self.this.append(this)
5850  except:
5851  self.this = this
5852 
5853  if self.__class__ != AttributeOptimizer:
5854  _director_objects.register(self)
5855 
5856 
5857 
5858 
5859  def get_optimized_attributes(self):
5860  """get_optimized_attributes(AttributeOptimizer self) -> IMP::FloatIndexes"""
5861  return _IMP_kernel.AttributeOptimizer_get_optimized_attributes(self)
5862 
5863 
5864  def set_value(self, fi, v):
5865  """set_value(AttributeOptimizer self, FloatIndex fi, double v)"""
5866  return _IMP_kernel.AttributeOptimizer_set_value(self, fi, v)
5867 
5868 
5869  def get_value(self, fi):
5870  """get_value(AttributeOptimizer self, FloatIndex fi) -> IMP::Float"""
5871  return _IMP_kernel.AttributeOptimizer_get_value(self, fi)
5872 
5873 
5874  def get_derivative(self, fi):
5875  """get_derivative(AttributeOptimizer self, FloatIndex fi) -> IMP::Float"""
5876  return _IMP_kernel.AttributeOptimizer_get_derivative(self, fi)
5877 
5878 
5879  def get_width(self, k):
5880  """get_width(AttributeOptimizer self, FloatKey k) -> double"""
5881  return _IMP_kernel.AttributeOptimizer_get_width(self, k)
5882 
5883 
5884  def set_scaled_value(self, fi, v):
5885  """set_scaled_value(AttributeOptimizer self, FloatIndex fi, IMP::Float v)"""
5886  return _IMP_kernel.AttributeOptimizer_set_scaled_value(self, fi, v)
5887 
5888 
5889  def get_scaled_value(self, fi):
5890  """get_scaled_value(AttributeOptimizer self, FloatIndex fi) -> double"""
5891  return _IMP_kernel.AttributeOptimizer_get_scaled_value(self, fi)
5892 
5893 
5894  def get_scaled_derivative(self, fi):
5895  """get_scaled_derivative(AttributeOptimizer self, FloatIndex fi) -> double"""
5896  return _IMP_kernel.AttributeOptimizer_get_scaled_derivative(self, fi)
5897 
5898 
5899  def clear_range_cache(self):
5900  """clear_range_cache(AttributeOptimizer self)"""
5901  return _IMP_kernel.AttributeOptimizer_clear_range_cache(self)
5902 
5903 
5904  def __str__(self):
5905  """__str__(AttributeOptimizer self) -> std::string"""
5906  return _IMP_kernel.AttributeOptimizer___str__(self)
5907 
5908 
5909  def __repr__(self):
5910  """__repr__(AttributeOptimizer self) -> std::string"""
5911  return _IMP_kernel.AttributeOptimizer___repr__(self)
5912 
5913 
5914  @staticmethod
5915  def get_from(o):
5916  return _object_cast_to_AttributeOptimizer(o)
5917 
5918 
5919  def get_type_name(self):
5920  return self.__class__.__name__
5921  def do_show(self, out):
5922  pass
5923  def get_version_info(self):
5924  if"IMP" == "IMP":
5925  return VersionInfo(self.__module__,
5926  __import__(self.__module__).get_module_version())
5927  else:
5928  return IMP.VersionInfo(self.__module__,
5929  __import__(self.__module__).get_module_version())
5930  @staticmethod
5931  def get_from(o):
5932  return _object_cast_to_AttributeOptimizer(o)
5933 
5934  __swig_destroy__ = _IMP_kernel.delete_AttributeOptimizer
5935  __del__ = lambda self: None
5936  def __disown__(self):
5937  self.this.disown()
5938  _IMP_kernel.disown_AttributeOptimizer(self)
5939  return weakref_proxy(self)
5940 
5941  def do_destroy(self):
5942  """do_destroy(AttributeOptimizer self)"""
5943  return _IMP_kernel.AttributeOptimizer_do_destroy(self)
5944 
5945 
5946  def handle_set_has_required_score_states(self, arg0):
5947  """handle_set_has_required_score_states(AttributeOptimizer self, bool arg0)"""
5948  return _IMP_kernel.AttributeOptimizer_handle_set_has_required_score_states(self, arg0)
5949 
5950 
5951  def do_get_inputs(self):
5952  """do_get_inputs(AttributeOptimizer self) -> IMP::ModelObjectsTemp"""
5953  return _IMP_kernel.AttributeOptimizer_do_get_inputs(self)
5954 
5955 
5956  def do_get_outputs(self):
5957  """do_get_outputs(AttributeOptimizer self) -> IMP::ModelObjectsTemp"""
5958  return _IMP_kernel.AttributeOptimizer_do_get_outputs(self)
5959 
5960 
5961  def do_get_interactions(self):
5962  """do_get_interactions(AttributeOptimizer self) -> IMP::ModelObjectsTemps"""
5963  return _IMP_kernel.AttributeOptimizer_do_get_interactions(self)
5964 
5965 
5966  def do_optimize(self, ns):
5967  """do_optimize(AttributeOptimizer self, unsigned int ns) -> double"""
5968  return _IMP_kernel.AttributeOptimizer_do_optimize(self, ns)
5969 
5970 AttributeOptimizer_swigregister = _IMP_kernel.AttributeOptimizer_swigregister
5971 AttributeOptimizer_swigregister(AttributeOptimizer)
5972 
5973 class ConfigurationSet(Object):
5974  """Proxy of C++ IMP::ConfigurationSet class."""
5975 
5976  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
5977 
5978  def __init__(self, *args):
5979  """
5980  __init__(IMP::ConfigurationSet self, Model m, std::string name) -> ConfigurationSet
5981  __init__(IMP::ConfigurationSet self, Model m) -> ConfigurationSet
5982  """
5983  this = _IMP_kernel.new_ConfigurationSet(*args)
5984  try:
5985  self.this.append(this)
5986  except:
5987  self.this = this
5988 
5989  def save_configuration(self):
5990  """save_configuration(ConfigurationSet self)"""
5991  return _IMP_kernel.ConfigurationSet_save_configuration(self)
5992 
5993 
5994  def get_number_of_configurations(self):
5995  """get_number_of_configurations(ConfigurationSet self) -> unsigned int"""
5996  return _IMP_kernel.ConfigurationSet_get_number_of_configurations(self)
5997 
5998 
5999  def load_configuration(self, i):
6000  """load_configuration(ConfigurationSet self, int i)"""
6001  return _IMP_kernel.ConfigurationSet_load_configuration(self, i)
6002 
6003 
6004  def remove_configuration(self, i):
6005  """remove_configuration(ConfigurationSet self, unsigned int i)"""
6006  return _IMP_kernel.ConfigurationSet_remove_configuration(self, i)
6007 
6008 
6009  def get_model(self):
6010  """get_model(ConfigurationSet self) -> Model"""
6011  return _IMP_kernel.ConfigurationSet_get_model(self)
6012 
6013 
6014  def get_version_info(self):
6015  """get_version_info(ConfigurationSet self) -> VersionInfo"""
6016  return _IMP_kernel.ConfigurationSet_get_version_info(self)
6017 
6018 
6019  def __str__(self):
6020  """__str__(ConfigurationSet self) -> std::string"""
6021  return _IMP_kernel.ConfigurationSet___str__(self)
6022 
6023 
6024  def __repr__(self):
6025  """__repr__(ConfigurationSet self) -> std::string"""
6026  return _IMP_kernel.ConfigurationSet___repr__(self)
6027 
6028 
6029  @staticmethod
6030  def get_from(o):
6031  return _object_cast_to_ConfigurationSet(o)
6032 
6033 ConfigurationSet_swigregister = _IMP_kernel.ConfigurationSet_swigregister
6034 ConfigurationSet_swigregister(ConfigurationSet)
6035 
6036 class SaveToConfigurationSetOptimizerState(OptimizerState):
6037  """Proxy of C++ IMP::SaveToConfigurationSetOptimizerState class."""
6038 
6039  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
6040 
6041  def __init__(self, cs):
6042  """__init__(IMP::SaveToConfigurationSetOptimizerState self, ConfigurationSet cs) -> SaveToConfigurationSetOptimizerState"""
6043  this = _IMP_kernel.new_SaveToConfigurationSetOptimizerState(cs)
6044  try:
6045  self.this.append(this)
6046  except:
6047  self.this = this
6048 
6049  def get_version_info(self):
6050  """get_version_info(SaveToConfigurationSetOptimizerState self) -> VersionInfo"""
6051  return _IMP_kernel.SaveToConfigurationSetOptimizerState_get_version_info(self)
6052 
6053 
6054  def __str__(self):
6055  """__str__(SaveToConfigurationSetOptimizerState self) -> std::string"""
6056  return _IMP_kernel.SaveToConfigurationSetOptimizerState___str__(self)
6057 
6058 
6059  def __repr__(self):
6060  """__repr__(SaveToConfigurationSetOptimizerState self) -> std::string"""
6061  return _IMP_kernel.SaveToConfigurationSetOptimizerState___repr__(self)
6062 
6063 
6064  @staticmethod
6065  def get_from(o):
6066  return _object_cast_to_SaveToConfigurationSetOptimizerState(o)
6067 
6068 SaveToConfigurationSetOptimizerState_swigregister = _IMP_kernel.SaveToConfigurationSetOptimizerState_swigregister
6069 SaveToConfigurationSetOptimizerState_swigregister(SaveToConfigurationSetOptimizerState)
6070 
6071 class Configuration(Object):
6072  """Proxy of C++ IMP::Configuration class."""
6073 
6074  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
6075 
6076  def __init__(self, *args):
6077  """
6078  __init__(IMP::Configuration self, Model m, std::string name) -> Configuration
6079  __init__(IMP::Configuration self, Model m) -> Configuration
6080  __init__(IMP::Configuration self, Model m, Configuration base, std::string name) -> Configuration
6081  __init__(IMP::Configuration self, Model m, Configuration base) -> Configuration
6082  """
6083  this = _IMP_kernel.new_Configuration(*args)
6084  try:
6085  self.this.append(this)
6086  except:
6087  self.this = this
6088 
6089  def load_configuration(self):
6090  """load_configuration(Configuration self)"""
6091  return _IMP_kernel.Configuration_load_configuration(self)
6092 
6093 
6094  def swap_configuration(self):
6095  """swap_configuration(Configuration self)"""
6096  return _IMP_kernel.Configuration_swap_configuration(self)
6097 
6098 
6099  def get_version_info(self):
6100  """get_version_info(Configuration self) -> VersionInfo"""
6101  return _IMP_kernel.Configuration_get_version_info(self)
6102 
6103 
6104  def __str__(self):
6105  """__str__(Configuration self) -> std::string"""
6106  return _IMP_kernel.Configuration___str__(self)
6107 
6108 
6109  def __repr__(self):
6110  """__repr__(Configuration self) -> std::string"""
6111  return _IMP_kernel.Configuration___repr__(self)
6112 
6113 
6114  @staticmethod
6115  def get_from(o):
6116  return _object_cast_to_Configuration(o)
6117 
6118 Configuration_swigregister = _IMP_kernel.Configuration_swigregister
6119 Configuration_swigregister(Configuration)
6120 
6121 class Sampler(Object):
6122  """Proxy of C++ IMP::Sampler class."""
6123 
6124  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
6125 
6126  def __init__(self, *args):
6127  """
6128  __init__(IMP::Sampler self, Model m, std::string name) -> Sampler
6129  __init__(IMP::Sampler self, Model m) -> Sampler
6130  """
6131  if self.__class__ == Sampler:
6132  _self = None
6133  else:
6134  _self = self
6135  this = _IMP_kernel.new_Sampler(_self, *args)
6136  try:
6137  self.this.append(this)
6138  except:
6139  self.this = this
6140 
6141  if self.__class__ != Sampler:
6142  _director_objects.register(self)
6143 
6144 
6145 
6146 
6147  def create_sample(self):
6148  """create_sample(Sampler self) -> ConfigurationSet"""
6149  return _IMP_kernel.Sampler_create_sample(self)
6150 
6151 
6152  def get_scoring_function(self):
6153  """get_scoring_function(Sampler self) -> ScoringFunction"""
6154  return _IMP_kernel.Sampler_get_scoring_function(self)
6155 
6156 
6157  def set_scoring_function(self, sf):
6158  """set_scoring_function(Sampler self, _ScoringFunctionAdaptor sf)"""
6159  return _IMP_kernel.Sampler_set_scoring_function(self, sf)
6160 
6161 
6162  def get_model(self):
6163  """get_model(Sampler self) -> Model"""
6164  return _IMP_kernel.Sampler_get_model(self)
6165 
6166 
6167  def do_sample(self):
6168  """do_sample(Sampler self) -> ConfigurationSet"""
6169  return _IMP_kernel.Sampler_do_sample(self)
6170 
6171  __swig_destroy__ = _IMP_kernel.delete_Sampler
6172  __del__ = lambda self: None
6173 
6174  def __str__(self):
6175  """__str__(Sampler self) -> std::string"""
6176  return _IMP_kernel.Sampler___str__(self)
6177 
6178 
6179  def __repr__(self):
6180  """__repr__(Sampler self) -> std::string"""
6181  return _IMP_kernel.Sampler___repr__(self)
6182 
6183 
6184  @staticmethod
6185  def get_from(o):
6186  return _object_cast_to_Sampler(o)
6187 
6188 
6189  def get_type_name(self):
6190  return self.__class__.__name__
6191  def do_show(self, out):
6192  pass
6193  def get_version_info(self):
6194  if"IMP" == "IMP":
6195  return VersionInfo(self.__module__,
6196  __import__(self.__module__).get_module_version())
6197  else:
6198  return IMP.VersionInfo(self.__module__,
6199  __import__(self.__module__).get_module_version())
6200  @staticmethod
6201  def get_from(o):
6202  return _object_cast_to_Sampler(o)
6203 
6204  def __disown__(self):
6205  self.this.disown()
6206  _IMP_kernel.disown_Sampler(self)
6207  return weakref_proxy(self)
6208 
6209  def do_destroy(self):
6210  """do_destroy(Sampler self)"""
6211  return _IMP_kernel.Sampler_do_destroy(self)
6212 
6213 Sampler_swigregister = _IMP_kernel.Sampler_swigregister
6214 Sampler_swigregister(Sampler)
6215 
6216 class PairModifier(_ParticleInputs, _ParticleOutputs, Object):
6217  """Proxy of C++ IMP::PairModifier class."""
6218 
6219  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
6220 
6221  def __init__(self, *args):
6222  """
6223  __init__(IMP::PairModifier self, std::string name) -> PairModifier
6224  __init__(IMP::PairModifier self) -> PairModifier
6225  """
6226  if self.__class__ == PairModifier:
6227  _self = None
6228  else:
6229  _self = self
6230  this = _IMP_kernel.new_PairModifier(_self, *args)
6231  try:
6232  self.this.append(this)
6233  except:
6234  self.this = this
6235 
6236  if self.__class__ != PairModifier:
6237  _director_objects.register(self)
6238 
6239 
6240 
6241 
6242  def apply_index(self, m, v):
6243  """apply_index(PairModifier self, Model m, IMP::ParticleIndexPair const & v)"""
6244  return _IMP_kernel.PairModifier_apply_index(self, m, v)
6245 
6246 
6247  def apply_indexes(self, m, o, lower_bound, upper_bound):
6248  """apply_indexes(PairModifier self, Model m, IMP::ParticleIndexPairs const & o, unsigned int lower_bound, unsigned int upper_bound)"""
6249  return _IMP_kernel.PairModifier_apply_indexes(self, m, o, lower_bound, upper_bound)
6250 
6251 
6252  def __str__(self):
6253  """__str__(PairModifier self) -> std::string"""
6254  return _IMP_kernel.PairModifier___str__(self)
6255 
6256 
6257  def __repr__(self):
6258  """__repr__(PairModifier self) -> std::string"""
6259  return _IMP_kernel.PairModifier___repr__(self)
6260 
6261 
6262  @staticmethod
6263  def get_from(o):
6264  return _object_cast_to_PairModifier(o)
6265 
6266 
6267  def get_type_name(self):
6268  return self.__class__.__name__
6269  def do_show(self, out):
6270  pass
6271  def get_version_info(self):
6272  if"IMP" == "IMP":
6273  return VersionInfo(self.__module__,
6274  __import__(self.__module__).get_module_version())
6275  else:
6276  return IMP.VersionInfo(self.__module__,
6277  __import__(self.__module__).get_module_version())
6278  @staticmethod
6279  def get_from(o):
6280  return _object_cast_to_PairModifier(o)
6281 
6282  __swig_destroy__ = _IMP_kernel.delete_PairModifier
6283  __del__ = lambda self: None
6284  def __disown__(self):
6285  self.this.disown()
6286  _IMP_kernel.disown_PairModifier(self)
6287  return weakref_proxy(self)
6288 
6289  def do_get_inputs(self, m, pis):
6290  """do_get_inputs(PairModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6291  return _IMP_kernel.PairModifier_do_get_inputs(self, m, pis)
6292 
6293 
6294  def do_get_outputs(self, m, pis):
6295  """do_get_outputs(PairModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6296  return _IMP_kernel.PairModifier_do_get_outputs(self, m, pis)
6297 
6298 
6299  def do_destroy(self):
6300  """do_destroy(PairModifier self)"""
6301  return _IMP_kernel.PairModifier_do_destroy(self)
6302 
6303 PairModifier_swigregister = _IMP_kernel.PairModifier_swigregister
6304 PairModifier_swigregister(PairModifier)
6305 
6306 class PairScore(_ParticleInputs, Object):
6307  """Proxy of C++ IMP::PairScore class."""
6308 
6309  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
6310 
6311  def __init__(self, *args):
6312  """
6313  __init__(IMP::PairScore self, std::string name) -> PairScore
6314  __init__(IMP::PairScore self) -> PairScore
6315  """
6316  if self.__class__ == PairScore:
6317  _self = None
6318  else:
6319  _self = self
6320  this = _IMP_kernel.new_PairScore(_self, *args)
6321  try:
6322  self.this.append(this)
6323  except:
6324  self.this = this
6325 
6326  if self.__class__ != PairScore:
6327  _director_objects.register(self)
6328 
6329 
6330 
6331 
6332  def evaluate_index(self, m, vt, da):
6333  """evaluate_index(PairScore self, Model m, IMP::ParticleIndexPair const & vt, DerivativeAccumulator da) -> double"""
6334  return _IMP_kernel.PairScore_evaluate_index(self, m, vt, da)
6335 
6336 
6337  def evaluate_indexes(self, m, o, da, lower_bound, upper_bound):
6338  """evaluate_indexes(PairScore self, Model m, IMP::ParticleIndexPairs const & o, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound) -> double"""
6339  return _IMP_kernel.PairScore_evaluate_indexes(self, m, o, da, lower_bound, upper_bound)
6340 
6341 
6342  def evaluate_if_good_index(self, m, vt, da, max):
6343  """evaluate_if_good_index(PairScore self, Model m, IMP::ParticleIndexPair const & vt, DerivativeAccumulator da, double max) -> double"""
6344  return _IMP_kernel.PairScore_evaluate_if_good_index(self, m, vt, da, max)
6345 
6346 
6347  def evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound):
6348  """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"""
6349  return _IMP_kernel.PairScore_evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound)
6350 
6351 
6352  def create_current_decomposition(self, m, vt):
6353  """create_current_decomposition(PairScore self, Model m, IMP::ParticleIndexPair const & vt) -> IMP::Restraints"""
6354  return _IMP_kernel.PairScore_create_current_decomposition(self, m, vt)
6355 
6356 
6357  def do_create_current_decomposition(self, m, vt):
6358  """do_create_current_decomposition(PairScore self, Model m, IMP::ParticleIndexPair const & vt) -> IMP::Restraints"""
6359  return _IMP_kernel.PairScore_do_create_current_decomposition(self, m, vt)
6360 
6361  __swig_destroy__ = _IMP_kernel.delete_PairScore
6362  __del__ = lambda self: None
6363 
6364  def __str__(self):
6365  """__str__(PairScore self) -> std::string"""
6366  return _IMP_kernel.PairScore___str__(self)
6367 
6368 
6369  def __repr__(self):
6370  """__repr__(PairScore self) -> std::string"""
6371  return _IMP_kernel.PairScore___repr__(self)
6372 
6373 
6374  @staticmethod
6375  def get_from(o):
6376  return _object_cast_to_PairScore(o)
6377 
6378 
6379  def get_type_name(self):
6380  return self.__class__.__name__
6381  def do_show(self, out):
6382  pass
6383  def get_version_info(self):
6384  if"IMP" == "IMP":
6385  return VersionInfo(self.__module__,
6386  __import__(self.__module__).get_module_version())
6387  else:
6388  return IMP.VersionInfo(self.__module__,
6389  __import__(self.__module__).get_module_version())
6390  @staticmethod
6391  def get_from(o):
6392  return _object_cast_to_PairScore(o)
6393 
6394  def __disown__(self):
6395  self.this.disown()
6396  _IMP_kernel.disown_PairScore(self)
6397  return weakref_proxy(self)
6398 
6399  def do_get_inputs(self, m, pis):
6400  """do_get_inputs(PairScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6401  return _IMP_kernel.PairScore_do_get_inputs(self, m, pis)
6402 
6403 
6404  def do_destroy(self):
6405  """do_destroy(PairScore self)"""
6406  return _IMP_kernel.PairScore_do_destroy(self)
6407 
6408 PairScore_swigregister = _IMP_kernel.PairScore_swigregister
6409 PairScore_swigregister(PairScore)
6410 
6411 class PairPredicate(_ParticleInputs, Object):
6412  """Proxy of C++ IMP::PairPredicate class."""
6413 
6414  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
6415 
6416  def __init__(self, *args):
6417  """
6418  __init__(IMP::PairPredicate self, std::string name) -> PairPredicate
6419  __init__(IMP::PairPredicate self) -> PairPredicate
6420  """
6421  if self.__class__ == PairPredicate:
6422  _self = None
6423  else:
6424  _self = self
6425  this = _IMP_kernel.new_PairPredicate(_self, *args)
6426  try:
6427  self.this.append(this)
6428  except:
6429  self.this = this
6430 
6431  if self.__class__ != PairPredicate:
6432  _director_objects.register(self)
6433 
6434 
6435 
6436 
6437  def get_value(self, *args):
6438  """
6439  get_value(PairPredicate self, IMP::ParticlePair const & vt) -> int
6440  get_value(PairPredicate self, IMP::ParticlePairsTemp const & o) -> IMP::Ints
6441  """
6442  return _IMP_kernel.PairPredicate_get_value(self, *args)
6443 
6444 
6445  def __call__(self, m, vt):
6446  """__call__(PairPredicate self, Model m, IMP::ParticleIndexPair const & vt) -> int"""
6447  return _IMP_kernel.PairPredicate___call__(self, m, vt)
6448 
6449 
6450  def get_value_index(self, *args):
6451  """
6452  get_value_index(PairPredicate self, Model m, IMP::ParticleIndexPair const & vt) -> int
6453  get_value_index(PairPredicate self, Model m, IMP::ParticleIndexPairs const & o) -> IMP::Ints
6454  """
6455  return _IMP_kernel.PairPredicate_get_value_index(self, *args)
6456 
6457  __swig_destroy__ = _IMP_kernel.delete_PairPredicate
6458  __del__ = lambda self: None
6459 
6460  def __str__(self):
6461  """__str__(PairPredicate self) -> std::string"""
6462  return _IMP_kernel.PairPredicate___str__(self)
6463 
6464 
6465  def __repr__(self):
6466  """__repr__(PairPredicate self) -> std::string"""
6467  return _IMP_kernel.PairPredicate___repr__(self)
6468 
6469 
6470  @staticmethod
6471  def get_from(o):
6472  return _object_cast_to_PairPredicate(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_PairPredicate(o)
6489 
6490  def __disown__(self):
6491  self.this.disown()
6492  _IMP_kernel.disown_PairPredicate(self)
6493  return weakref_proxy(self)
6494 
6495  def do_get_inputs(self, m, pis):
6496  """do_get_inputs(PairPredicate self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6497  return _IMP_kernel.PairPredicate_do_get_inputs(self, m, pis)
6498 
6499 
6500  def do_destroy(self):
6501  """do_destroy(PairPredicate self)"""
6502  return _IMP_kernel.PairPredicate_do_destroy(self)
6503 
6504 PairPredicate_swigregister = _IMP_kernel.PairPredicate_swigregister
6505 PairPredicate_swigregister(PairPredicate)
6506 
6507 class PairContainer(Container):
6508  """Proxy of C++ IMP::PairContainer class."""
6509 
6510  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
6511 
6512  def apply_generic(self, m):
6513  """apply_generic(PairContainer self, PairModifier m)"""
6514  return _IMP_kernel.PairContainer_apply_generic(self, m)
6515 
6516 
6517  def apply(self, sm):
6518  """apply(PairContainer self, PairModifier sm)"""
6519  return _IMP_kernel.PairContainer_apply(self, sm)
6520 
6521 
6522  def get_range_indexes(self):
6523  """get_range_indexes(PairContainer self) -> IMP::ParticleIndexPairs"""
6524  return _IMP_kernel.PairContainer_get_range_indexes(self)
6525 
6526 
6527  def get_contents(self):
6528  """get_contents(PairContainer self) -> IMP::ParticleIndexPairs const &"""
6529  return _IMP_kernel.PairContainer_get_contents(self)
6530 
6531 
6532  def get_indexes(self):
6533  """get_indexes(PairContainer self) -> IMP::ParticleIndexPairs"""
6534  return _IMP_kernel.PairContainer_get_indexes(self)
6535 
6536 
6537  def get(self, *args):
6538  """
6539  get(PairContainer self) -> IMP::ParticlePairsTemp
6540  get(PairContainer self, unsigned int i) -> IMP::ParticlePair
6541  """
6542  return _IMP_kernel.PairContainer_get(self, *args)
6543 
6544 
6545  def get_number(self):
6546  """get_number(PairContainer self) -> unsigned int"""
6547  return _IMP_kernel.PairContainer_get_number(self)
6548 
6549 
6550  def get_particle_pairs(self):
6551  """get_particle_pairs(PairContainer self) -> IMP::ParticlePairsTemp"""
6552  return _IMP_kernel.PairContainer_get_particle_pairs(self)
6553 
6554 
6555  def get_particle_pair(self, i):
6556  """get_particle_pair(PairContainer self, unsigned int i) -> IMP::ParticlePair"""
6557  return _IMP_kernel.PairContainer_get_particle_pair(self, i)
6558 
6559 
6560  def __init__(self, *args):
6561  """
6562  __init__(IMP::PairContainer self, Model m, std::string name) -> PairContainer
6563  __init__(IMP::PairContainer self, Model m) -> PairContainer
6564  """
6565  if self.__class__ == PairContainer:
6566  _self = None
6567  else:
6568  _self = self
6569  this = _IMP_kernel.new_PairContainer(_self, *args)
6570  try:
6571  self.this.append(this)
6572  except:
6573  self.this = this
6574 
6575  if self.__class__ != PairContainer:
6576  _director_objects.register(self)
6577 
6578 
6579 
6580 
6581  def do_apply(self, sm):
6582  """do_apply(PairContainer self, PairModifier sm)"""
6583  return _IMP_kernel.PairContainer_do_apply(self, sm)
6584 
6585 
6586  def do_get_provides_access(self):
6587  """do_get_provides_access(PairContainer self) -> bool"""
6588  return _IMP_kernel.PairContainer_do_get_provides_access(self)
6589 
6590  __swig_destroy__ = _IMP_kernel.delete_PairContainer
6591  __del__ = lambda self: None
6592 
6593  def __str__(self):
6594  """__str__(PairContainer self) -> std::string"""
6595  return _IMP_kernel.PairContainer___str__(self)
6596 
6597 
6598  def __repr__(self):
6599  """__repr__(PairContainer self) -> std::string"""
6600  return _IMP_kernel.PairContainer___repr__(self)
6601 
6602 
6603  @staticmethod
6604  def get_from(o):
6605  return _object_cast_to_PairContainer(o)
6606 
6607 
6608  def get_type_name(self):
6609  return self.__class__.__name__
6610  def do_show(self, out):
6611  pass
6612  def get_version_info(self):
6613  if"IMP" == "IMP":
6614  return VersionInfo(self.__module__,
6615  __import__(self.__module__).get_module_version())
6616  else:
6617  return IMP.VersionInfo(self.__module__,
6618  __import__(self.__module__).get_module_version())
6619  @staticmethod
6620  def get_from(o):
6621  return _object_cast_to_PairContainer(o)
6622 
6623  def __disown__(self):
6624  self.this.disown()
6625  _IMP_kernel.disown_PairContainer(self)
6626  return weakref_proxy(self)
6627 
6628  def do_destroy(self):
6629  """do_destroy(PairContainer self)"""
6630  return _IMP_kernel.PairContainer_do_destroy(self)
6631 
6632 
6633  def handle_set_has_required_score_states(self, arg0):
6634  """handle_set_has_required_score_states(PairContainer self, bool arg0)"""
6635  return _IMP_kernel.PairContainer_handle_set_has_required_score_states(self, arg0)
6636 
6637 
6638  def do_get_inputs(self):
6639  """do_get_inputs(PairContainer self) -> IMP::ModelObjectsTemp"""
6640  return _IMP_kernel.PairContainer_do_get_inputs(self)
6641 
6642 
6643  def do_get_interactions(self):
6644  """do_get_interactions(PairContainer self) -> IMP::ModelObjectsTemps"""
6645  return _IMP_kernel.PairContainer_do_get_interactions(self)
6646 
6647 
6648  def do_get_contents_hash(self):
6649  """do_get_contents_hash(PairContainer self) -> std::size_t"""
6650  return _IMP_kernel.PairContainer_do_get_contents_hash(self)
6651 
6652 PairContainer_swigregister = _IMP_kernel.PairContainer_swigregister
6653 PairContainer_swigregister(PairContainer)
6654 
6655 class _PairContainerAdaptor(_InputAdaptor):
6656  """Proxy of C++ IMP::PairContainerAdaptor class."""
6657 
6658  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
6659  __repr__ = _swig_repr
6660 
6661  def __init__(self, *args):
6662  """
6663  __init__(IMP::PairContainerAdaptor self) -> _PairContainerAdaptor
6664  __init__(IMP::PairContainerAdaptor self, PairContainer c) -> _PairContainerAdaptor
6665  __init__(IMP::PairContainerAdaptor self, IMP::ParticlePairsTemp const & t) -> _PairContainerAdaptor
6666  """
6667  this = _IMP_kernel.new__PairContainerAdaptor(*args)
6668  try:
6669  self.this.append(this)
6670  except:
6671  self.this = this
6672 
6673  def set_name_if_default(self, name):
6674  """set_name_if_default(_PairContainerAdaptor self, std::string name)"""
6675  return _IMP_kernel._PairContainerAdaptor_set_name_if_default(self, name)
6676 
6677  __swig_destroy__ = _IMP_kernel.delete__PairContainerAdaptor
6678  __del__ = lambda self: None
6679 _PairContainerAdaptor_swigregister = _IMP_kernel._PairContainerAdaptor_swigregister
6680 _PairContainerAdaptor_swigregister(_PairContainerAdaptor)
6681 
6682 class QuadModifier(_ParticleInputs, _ParticleOutputs, Object):
6683  """Proxy of C++ IMP::QuadModifier class."""
6684 
6685  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
6686 
6687  def __init__(self, *args):
6688  """
6689  __init__(IMP::QuadModifier self, std::string name) -> QuadModifier
6690  __init__(IMP::QuadModifier self) -> QuadModifier
6691  """
6692  if self.__class__ == QuadModifier:
6693  _self = None
6694  else:
6695  _self = self
6696  this = _IMP_kernel.new_QuadModifier(_self, *args)
6697  try:
6698  self.this.append(this)
6699  except:
6700  self.this = this
6701 
6702  if self.__class__ != QuadModifier:
6703  _director_objects.register(self)
6704 
6705 
6706 
6707 
6708  def apply_index(self, m, v):
6709  """apply_index(QuadModifier self, Model m, IMP::ParticleIndexQuad const & v)"""
6710  return _IMP_kernel.QuadModifier_apply_index(self, m, v)
6711 
6712 
6713  def apply_indexes(self, m, o, lower_bound, upper_bound):
6714  """apply_indexes(QuadModifier self, Model m, IMP::ParticleIndexQuads const & o, unsigned int lower_bound, unsigned int upper_bound)"""
6715  return _IMP_kernel.QuadModifier_apply_indexes(self, m, o, lower_bound, upper_bound)
6716 
6717 
6718  def __str__(self):
6719  """__str__(QuadModifier self) -> std::string"""
6720  return _IMP_kernel.QuadModifier___str__(self)
6721 
6722 
6723  def __repr__(self):
6724  """__repr__(QuadModifier self) -> std::string"""
6725  return _IMP_kernel.QuadModifier___repr__(self)
6726 
6727 
6728  @staticmethod
6729  def get_from(o):
6730  return _object_cast_to_QuadModifier(o)
6731 
6732 
6733  def get_type_name(self):
6734  return self.__class__.__name__
6735  def do_show(self, out):
6736  pass
6737  def get_version_info(self):
6738  if"IMP" == "IMP":
6739  return VersionInfo(self.__module__,
6740  __import__(self.__module__).get_module_version())
6741  else:
6742  return IMP.VersionInfo(self.__module__,
6743  __import__(self.__module__).get_module_version())
6744  @staticmethod
6745  def get_from(o):
6746  return _object_cast_to_QuadModifier(o)
6747 
6748  __swig_destroy__ = _IMP_kernel.delete_QuadModifier
6749  __del__ = lambda self: None
6750  def __disown__(self):
6751  self.this.disown()
6752  _IMP_kernel.disown_QuadModifier(self)
6753  return weakref_proxy(self)
6754 
6755  def do_get_inputs(self, m, pis):
6756  """do_get_inputs(QuadModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6757  return _IMP_kernel.QuadModifier_do_get_inputs(self, m, pis)
6758 
6759 
6760  def do_get_outputs(self, m, pis):
6761  """do_get_outputs(QuadModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6762  return _IMP_kernel.QuadModifier_do_get_outputs(self, m, pis)
6763 
6764 
6765  def do_destroy(self):
6766  """do_destroy(QuadModifier self)"""
6767  return _IMP_kernel.QuadModifier_do_destroy(self)
6768 
6769 QuadModifier_swigregister = _IMP_kernel.QuadModifier_swigregister
6770 QuadModifier_swigregister(QuadModifier)
6771 
6772 class QuadScore(_ParticleInputs, Object):
6773  """Proxy of C++ IMP::QuadScore class."""
6774 
6775  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
6776 
6777  def __init__(self, *args):
6778  """
6779  __init__(IMP::QuadScore self, std::string name) -> QuadScore
6780  __init__(IMP::QuadScore self) -> QuadScore
6781  """
6782  if self.__class__ == QuadScore:
6783  _self = None
6784  else:
6785  _self = self
6786  this = _IMP_kernel.new_QuadScore(_self, *args)
6787  try:
6788  self.this.append(this)
6789  except:
6790  self.this = this
6791 
6792  if self.__class__ != QuadScore:
6793  _director_objects.register(self)
6794 
6795 
6796 
6797 
6798  def evaluate_index(self, m, vt, da):
6799  """evaluate_index(QuadScore self, Model m, IMP::ParticleIndexQuad const & vt, DerivativeAccumulator da) -> double"""
6800  return _IMP_kernel.QuadScore_evaluate_index(self, m, vt, da)
6801 
6802 
6803  def evaluate_indexes(self, m, o, da, lower_bound, upper_bound):
6804  """evaluate_indexes(QuadScore self, Model m, IMP::ParticleIndexQuads const & o, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound) -> double"""
6805  return _IMP_kernel.QuadScore_evaluate_indexes(self, m, o, da, lower_bound, upper_bound)
6806 
6807 
6808  def evaluate_if_good_index(self, m, vt, da, max):
6809  """evaluate_if_good_index(QuadScore self, Model m, IMP::ParticleIndexQuad const & vt, DerivativeAccumulator da, double max) -> double"""
6810  return _IMP_kernel.QuadScore_evaluate_if_good_index(self, m, vt, da, max)
6811 
6812 
6813  def evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound):
6814  """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"""
6815  return _IMP_kernel.QuadScore_evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound)
6816 
6817 
6818  def create_current_decomposition(self, m, vt):
6819  """create_current_decomposition(QuadScore self, Model m, IMP::ParticleIndexQuad const & vt) -> IMP::Restraints"""
6820  return _IMP_kernel.QuadScore_create_current_decomposition(self, m, vt)
6821 
6822 
6823  def do_create_current_decomposition(self, m, vt):
6824  """do_create_current_decomposition(QuadScore self, Model m, IMP::ParticleIndexQuad const & vt) -> IMP::Restraints"""
6825  return _IMP_kernel.QuadScore_do_create_current_decomposition(self, m, vt)
6826 
6827  __swig_destroy__ = _IMP_kernel.delete_QuadScore
6828  __del__ = lambda self: None
6829 
6830  def __str__(self):
6831  """__str__(QuadScore self) -> std::string"""
6832  return _IMP_kernel.QuadScore___str__(self)
6833 
6834 
6835  def __repr__(self):
6836  """__repr__(QuadScore self) -> std::string"""
6837  return _IMP_kernel.QuadScore___repr__(self)
6838 
6839 
6840  @staticmethod
6841  def get_from(o):
6842  return _object_cast_to_QuadScore(o)
6843 
6844 
6845  def get_type_name(self):
6846  return self.__class__.__name__
6847  def do_show(self, out):
6848  pass
6849  def get_version_info(self):
6850  if"IMP" == "IMP":
6851  return VersionInfo(self.__module__,
6852  __import__(self.__module__).get_module_version())
6853  else:
6854  return IMP.VersionInfo(self.__module__,
6855  __import__(self.__module__).get_module_version())
6856  @staticmethod
6857  def get_from(o):
6858  return _object_cast_to_QuadScore(o)
6859 
6860  def __disown__(self):
6861  self.this.disown()
6862  _IMP_kernel.disown_QuadScore(self)
6863  return weakref_proxy(self)
6864 
6865  def do_get_inputs(self, m, pis):
6866  """do_get_inputs(QuadScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6867  return _IMP_kernel.QuadScore_do_get_inputs(self, m, pis)
6868 
6869 
6870  def do_destroy(self):
6871  """do_destroy(QuadScore self)"""
6872  return _IMP_kernel.QuadScore_do_destroy(self)
6873 
6874 QuadScore_swigregister = _IMP_kernel.QuadScore_swigregister
6875 QuadScore_swigregister(QuadScore)
6876 
6877 class QuadPredicate(_ParticleInputs, Object):
6878  """Proxy of C++ IMP::QuadPredicate class."""
6879 
6880  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
6881 
6882  def __init__(self, *args):
6883  """
6884  __init__(IMP::QuadPredicate self, std::string name) -> QuadPredicate
6885  __init__(IMP::QuadPredicate self) -> QuadPredicate
6886  """
6887  if self.__class__ == QuadPredicate:
6888  _self = None
6889  else:
6890  _self = self
6891  this = _IMP_kernel.new_QuadPredicate(_self, *args)
6892  try:
6893  self.this.append(this)
6894  except:
6895  self.this = this
6896 
6897  if self.__class__ != QuadPredicate:
6898  _director_objects.register(self)
6899 
6900 
6901 
6902 
6903  def get_value(self, *args):
6904  """
6905  get_value(QuadPredicate self, IMP::ParticleQuad const & vt) -> int
6906  get_value(QuadPredicate self, IMP::ParticleQuadsTemp const & o) -> IMP::Ints
6907  """
6908  return _IMP_kernel.QuadPredicate_get_value(self, *args)
6909 
6910 
6911  def __call__(self, m, vt):
6912  """__call__(QuadPredicate self, Model m, IMP::ParticleIndexQuad const & vt) -> int"""
6913  return _IMP_kernel.QuadPredicate___call__(self, m, vt)
6914 
6915 
6916  def get_value_index(self, *args):
6917  """
6918  get_value_index(QuadPredicate self, Model m, IMP::ParticleIndexQuad const & vt) -> int
6919  get_value_index(QuadPredicate self, Model m, IMP::ParticleIndexQuads const & o) -> IMP::Ints
6920  """
6921  return _IMP_kernel.QuadPredicate_get_value_index(self, *args)
6922 
6923  __swig_destroy__ = _IMP_kernel.delete_QuadPredicate
6924  __del__ = lambda self: None
6925 
6926  def __str__(self):
6927  """__str__(QuadPredicate self) -> std::string"""
6928  return _IMP_kernel.QuadPredicate___str__(self)
6929 
6930 
6931  def __repr__(self):
6932  """__repr__(QuadPredicate self) -> std::string"""
6933  return _IMP_kernel.QuadPredicate___repr__(self)
6934 
6935 
6936  @staticmethod
6937  def get_from(o):
6938  return _object_cast_to_QuadPredicate(o)
6939 
6940 
6941  def get_type_name(self):
6942  return self.__class__.__name__
6943  def do_show(self, out):
6944  pass
6945  def get_version_info(self):
6946  if"IMP" == "IMP":
6947  return VersionInfo(self.__module__,
6948  __import__(self.__module__).get_module_version())
6949  else:
6950  return IMP.VersionInfo(self.__module__,
6951  __import__(self.__module__).get_module_version())
6952  @staticmethod
6953  def get_from(o):
6954  return _object_cast_to_QuadPredicate(o)
6955 
6956  def __disown__(self):
6957  self.this.disown()
6958  _IMP_kernel.disown_QuadPredicate(self)
6959  return weakref_proxy(self)
6960 
6961  def do_get_inputs(self, m, pis):
6962  """do_get_inputs(QuadPredicate self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
6963  return _IMP_kernel.QuadPredicate_do_get_inputs(self, m, pis)
6964 
6965 
6966  def do_destroy(self):
6967  """do_destroy(QuadPredicate self)"""
6968  return _IMP_kernel.QuadPredicate_do_destroy(self)
6969 
6970 QuadPredicate_swigregister = _IMP_kernel.QuadPredicate_swigregister
6971 QuadPredicate_swigregister(QuadPredicate)
6972 
6973 class QuadContainer(Container):
6974  """Proxy of C++ IMP::QuadContainer class."""
6975 
6976  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
6977 
6978  def apply_generic(self, m):
6979  """apply_generic(QuadContainer self, QuadModifier m)"""
6980  return _IMP_kernel.QuadContainer_apply_generic(self, m)
6981 
6982 
6983  def apply(self, sm):
6984  """apply(QuadContainer self, QuadModifier sm)"""
6985  return _IMP_kernel.QuadContainer_apply(self, sm)
6986 
6987 
6988  def get_range_indexes(self):
6989  """get_range_indexes(QuadContainer self) -> IMP::ParticleIndexQuads"""
6990  return _IMP_kernel.QuadContainer_get_range_indexes(self)
6991 
6992 
6993  def get_contents(self):
6994  """get_contents(QuadContainer self) -> IMP::ParticleIndexQuads const &"""
6995  return _IMP_kernel.QuadContainer_get_contents(self)
6996 
6997 
6998  def get_indexes(self):
6999  """get_indexes(QuadContainer self) -> IMP::ParticleIndexQuads"""
7000  return _IMP_kernel.QuadContainer_get_indexes(self)
7001 
7002 
7003  def get(self, *args):
7004  """
7005  get(QuadContainer self) -> IMP::ParticleQuadsTemp
7006  get(QuadContainer self, unsigned int i) -> IMP::ParticleQuad
7007  """
7008  return _IMP_kernel.QuadContainer_get(self, *args)
7009 
7010 
7011  def get_number(self):
7012  """get_number(QuadContainer self) -> unsigned int"""
7013  return _IMP_kernel.QuadContainer_get_number(self)
7014 
7015 
7016  def get_particle_quads(self):
7017  """get_particle_quads(QuadContainer self) -> IMP::ParticleQuadsTemp"""
7018  return _IMP_kernel.QuadContainer_get_particle_quads(self)
7019 
7020 
7021  def get_particle_quad(self, i):
7022  """get_particle_quad(QuadContainer self, unsigned int i) -> IMP::ParticleQuad"""
7023  return _IMP_kernel.QuadContainer_get_particle_quad(self, i)
7024 
7025 
7026  def __init__(self, *args):
7027  """
7028  __init__(IMP::QuadContainer self, Model m, std::string name) -> QuadContainer
7029  __init__(IMP::QuadContainer self, Model m) -> QuadContainer
7030  """
7031  if self.__class__ == QuadContainer:
7032  _self = None
7033  else:
7034  _self = self
7035  this = _IMP_kernel.new_QuadContainer(_self, *args)
7036  try:
7037  self.this.append(this)
7038  except:
7039  self.this = this
7040 
7041  if self.__class__ != QuadContainer:
7042  _director_objects.register(self)
7043 
7044 
7045 
7046 
7047  def do_apply(self, sm):
7048  """do_apply(QuadContainer self, QuadModifier sm)"""
7049  return _IMP_kernel.QuadContainer_do_apply(self, sm)
7050 
7051 
7052  def do_get_provides_access(self):
7053  """do_get_provides_access(QuadContainer self) -> bool"""
7054  return _IMP_kernel.QuadContainer_do_get_provides_access(self)
7055 
7056  __swig_destroy__ = _IMP_kernel.delete_QuadContainer
7057  __del__ = lambda self: None
7058 
7059  def __str__(self):
7060  """__str__(QuadContainer self) -> std::string"""
7061  return _IMP_kernel.QuadContainer___str__(self)
7062 
7063 
7064  def __repr__(self):
7065  """__repr__(QuadContainer self) -> std::string"""
7066  return _IMP_kernel.QuadContainer___repr__(self)
7067 
7068 
7069  @staticmethod
7070  def get_from(o):
7071  return _object_cast_to_QuadContainer(o)
7072 
7073 
7074  def get_type_name(self):
7075  return self.__class__.__name__
7076  def do_show(self, out):
7077  pass
7078  def get_version_info(self):
7079  if"IMP" == "IMP":
7080  return VersionInfo(self.__module__,
7081  __import__(self.__module__).get_module_version())
7082  else:
7083  return IMP.VersionInfo(self.__module__,
7084  __import__(self.__module__).get_module_version())
7085  @staticmethod
7086  def get_from(o):
7087  return _object_cast_to_QuadContainer(o)
7088 
7089  def __disown__(self):
7090  self.this.disown()
7091  _IMP_kernel.disown_QuadContainer(self)
7092  return weakref_proxy(self)
7093 
7094  def do_destroy(self):
7095  """do_destroy(QuadContainer self)"""
7096  return _IMP_kernel.QuadContainer_do_destroy(self)
7097 
7098 
7099  def handle_set_has_required_score_states(self, arg0):
7100  """handle_set_has_required_score_states(QuadContainer self, bool arg0)"""
7101  return _IMP_kernel.QuadContainer_handle_set_has_required_score_states(self, arg0)
7102 
7103 
7104  def do_get_inputs(self):
7105  """do_get_inputs(QuadContainer self) -> IMP::ModelObjectsTemp"""
7106  return _IMP_kernel.QuadContainer_do_get_inputs(self)
7107 
7108 
7109  def do_get_interactions(self):
7110  """do_get_interactions(QuadContainer self) -> IMP::ModelObjectsTemps"""
7111  return _IMP_kernel.QuadContainer_do_get_interactions(self)
7112 
7113 
7114  def do_get_contents_hash(self):
7115  """do_get_contents_hash(QuadContainer self) -> std::size_t"""
7116  return _IMP_kernel.QuadContainer_do_get_contents_hash(self)
7117 
7118 QuadContainer_swigregister = _IMP_kernel.QuadContainer_swigregister
7119 QuadContainer_swigregister(QuadContainer)
7120 
7121 class _QuadContainerAdaptor(_InputAdaptor):
7122  """Proxy of C++ IMP::QuadContainerAdaptor class."""
7123 
7124  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
7125  __repr__ = _swig_repr
7126 
7127  def __init__(self, *args):
7128  """
7129  __init__(IMP::QuadContainerAdaptor self) -> _QuadContainerAdaptor
7130  __init__(IMP::QuadContainerAdaptor self, QuadContainer c) -> _QuadContainerAdaptor
7131  __init__(IMP::QuadContainerAdaptor self, IMP::ParticleQuadsTemp const & t) -> _QuadContainerAdaptor
7132  """
7133  this = _IMP_kernel.new__QuadContainerAdaptor(*args)
7134  try:
7135  self.this.append(this)
7136  except:
7137  self.this = this
7138 
7139  def set_name_if_default(self, name):
7140  """set_name_if_default(_QuadContainerAdaptor self, std::string name)"""
7141  return _IMP_kernel._QuadContainerAdaptor_set_name_if_default(self, name)
7142 
7143  __swig_destroy__ = _IMP_kernel.delete__QuadContainerAdaptor
7144  __del__ = lambda self: None
7145 _QuadContainerAdaptor_swigregister = _IMP_kernel._QuadContainerAdaptor_swigregister
7146 _QuadContainerAdaptor_swigregister(_QuadContainerAdaptor)
7147 
7148 class SingletonModifier(_ParticleInputs, _ParticleOutputs, Object):
7149  """Proxy of C++ IMP::SingletonModifier class."""
7150 
7151  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
7152 
7153  def __init__(self, *args):
7154  """
7155  __init__(IMP::SingletonModifier self, std::string name) -> SingletonModifier
7156  __init__(IMP::SingletonModifier self) -> SingletonModifier
7157  """
7158  if self.__class__ == SingletonModifier:
7159  _self = None
7160  else:
7161  _self = self
7162  this = _IMP_kernel.new_SingletonModifier(_self, *args)
7163  try:
7164  self.this.append(this)
7165  except:
7166  self.this = this
7167 
7168  if self.__class__ != SingletonModifier:
7169  _director_objects.register(self)
7170 
7171 
7172 
7173 
7174  def apply_index(self, m, v):
7175  """apply_index(SingletonModifier self, Model m, ParticleIndex v)"""
7176  return _IMP_kernel.SingletonModifier_apply_index(self, m, v)
7177 
7178 
7179  def apply_indexes(self, m, o, lower_bound, upper_bound):
7180  """apply_indexes(SingletonModifier self, Model m, IMP::ParticleIndexes const & o, unsigned int lower_bound, unsigned int upper_bound)"""
7181  return _IMP_kernel.SingletonModifier_apply_indexes(self, m, o, lower_bound, upper_bound)
7182 
7183 
7184  def __str__(self):
7185  """__str__(SingletonModifier self) -> std::string"""
7186  return _IMP_kernel.SingletonModifier___str__(self)
7187 
7188 
7189  def __repr__(self):
7190  """__repr__(SingletonModifier self) -> std::string"""
7191  return _IMP_kernel.SingletonModifier___repr__(self)
7192 
7193 
7194  @staticmethod
7195  def get_from(o):
7196  return _object_cast_to_SingletonModifier(o)
7197 
7198 
7199  def get_type_name(self):
7200  return self.__class__.__name__
7201  def do_show(self, out):
7202  pass
7203  def get_version_info(self):
7204  if"IMP" == "IMP":
7205  return VersionInfo(self.__module__,
7206  __import__(self.__module__).get_module_version())
7207  else:
7208  return IMP.VersionInfo(self.__module__,
7209  __import__(self.__module__).get_module_version())
7210  @staticmethod
7211  def get_from(o):
7212  return _object_cast_to_SingletonModifier(o)
7213 
7214  __swig_destroy__ = _IMP_kernel.delete_SingletonModifier
7215  __del__ = lambda self: None
7216  def __disown__(self):
7217  self.this.disown()
7218  _IMP_kernel.disown_SingletonModifier(self)
7219  return weakref_proxy(self)
7220 
7221  def do_get_inputs(self, m, pis):
7222  """do_get_inputs(SingletonModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7223  return _IMP_kernel.SingletonModifier_do_get_inputs(self, m, pis)
7224 
7225 
7226  def do_get_outputs(self, m, pis):
7227  """do_get_outputs(SingletonModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7228  return _IMP_kernel.SingletonModifier_do_get_outputs(self, m, pis)
7229 
7230 
7231  def do_destroy(self):
7232  """do_destroy(SingletonModifier self)"""
7233  return _IMP_kernel.SingletonModifier_do_destroy(self)
7234 
7235 SingletonModifier_swigregister = _IMP_kernel.SingletonModifier_swigregister
7236 SingletonModifier_swigregister(SingletonModifier)
7237 
7238 class SingletonScore(_ParticleInputs, Object):
7239  """Proxy of C++ IMP::SingletonScore class."""
7240 
7241  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
7242 
7243  def __init__(self, *args):
7244  """
7245  __init__(IMP::SingletonScore self, std::string name) -> SingletonScore
7246  __init__(IMP::SingletonScore self) -> SingletonScore
7247  """
7248  if self.__class__ == SingletonScore:
7249  _self = None
7250  else:
7251  _self = self
7252  this = _IMP_kernel.new_SingletonScore(_self, *args)
7253  try:
7254  self.this.append(this)
7255  except:
7256  self.this = this
7257 
7258  if self.__class__ != SingletonScore:
7259  _director_objects.register(self)
7260 
7261 
7262 
7263 
7264  def evaluate_index(self, m, vt, da):
7265  """evaluate_index(SingletonScore self, Model m, ParticleIndex vt, DerivativeAccumulator da) -> double"""
7266  return _IMP_kernel.SingletonScore_evaluate_index(self, m, vt, da)
7267 
7268 
7269  def evaluate_indexes(self, m, o, da, lower_bound, upper_bound):
7270  """evaluate_indexes(SingletonScore self, Model m, IMP::ParticleIndexes const & o, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound) -> double"""
7271  return _IMP_kernel.SingletonScore_evaluate_indexes(self, m, o, da, lower_bound, upper_bound)
7272 
7273 
7274  def evaluate_if_good_index(self, m, vt, da, max):
7275  """evaluate_if_good_index(SingletonScore self, Model m, ParticleIndex vt, DerivativeAccumulator da, double max) -> double"""
7276  return _IMP_kernel.SingletonScore_evaluate_if_good_index(self, m, vt, da, max)
7277 
7278 
7279  def evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound):
7280  """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"""
7281  return _IMP_kernel.SingletonScore_evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound)
7282 
7283 
7284  def create_current_decomposition(self, m, vt):
7285  """create_current_decomposition(SingletonScore self, Model m, ParticleIndex vt) -> IMP::Restraints"""
7286  return _IMP_kernel.SingletonScore_create_current_decomposition(self, m, vt)
7287 
7288 
7289  def do_create_current_decomposition(self, m, vt):
7290  """do_create_current_decomposition(SingletonScore self, Model m, ParticleIndex vt) -> IMP::Restraints"""
7291  return _IMP_kernel.SingletonScore_do_create_current_decomposition(self, m, vt)
7292 
7293  __swig_destroy__ = _IMP_kernel.delete_SingletonScore
7294  __del__ = lambda self: None
7295 
7296  def __str__(self):
7297  """__str__(SingletonScore self) -> std::string"""
7298  return _IMP_kernel.SingletonScore___str__(self)
7299 
7300 
7301  def __repr__(self):
7302  """__repr__(SingletonScore self) -> std::string"""
7303  return _IMP_kernel.SingletonScore___repr__(self)
7304 
7305 
7306  @staticmethod
7307  def get_from(o):
7308  return _object_cast_to_SingletonScore(o)
7309 
7310 
7311  def get_type_name(self):
7312  return self.__class__.__name__
7313  def do_show(self, out):
7314  pass
7315  def get_version_info(self):
7316  if"IMP" == "IMP":
7317  return VersionInfo(self.__module__,
7318  __import__(self.__module__).get_module_version())
7319  else:
7320  return IMP.VersionInfo(self.__module__,
7321  __import__(self.__module__).get_module_version())
7322  @staticmethod
7323  def get_from(o):
7324  return _object_cast_to_SingletonScore(o)
7325 
7326  def __disown__(self):
7327  self.this.disown()
7328  _IMP_kernel.disown_SingletonScore(self)
7329  return weakref_proxy(self)
7330 
7331  def do_get_inputs(self, m, pis):
7332  """do_get_inputs(SingletonScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7333  return _IMP_kernel.SingletonScore_do_get_inputs(self, m, pis)
7334 
7335 
7336  def do_destroy(self):
7337  """do_destroy(SingletonScore self)"""
7338  return _IMP_kernel.SingletonScore_do_destroy(self)
7339 
7340 SingletonScore_swigregister = _IMP_kernel.SingletonScore_swigregister
7341 SingletonScore_swigregister(SingletonScore)
7342 
7343 class SingletonPredicate(_ParticleInputs, Object):
7344  """Proxy of C++ IMP::SingletonPredicate class."""
7345 
7346  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
7347 
7348  def __init__(self, *args):
7349  """
7350  __init__(IMP::SingletonPredicate self, std::string name) -> SingletonPredicate
7351  __init__(IMP::SingletonPredicate self) -> SingletonPredicate
7352  """
7353  if self.__class__ == SingletonPredicate:
7354  _self = None
7355  else:
7356  _self = self
7357  this = _IMP_kernel.new_SingletonPredicate(_self, *args)
7358  try:
7359  self.this.append(this)
7360  except:
7361  self.this = this
7362 
7363  if self.__class__ != SingletonPredicate:
7364  _director_objects.register(self)
7365 
7366 
7367 
7368 
7369  def get_value(self, *args):
7370  """
7371  get_value(SingletonPredicate self, Particle vt) -> int
7372  get_value(SingletonPredicate self, IMP::ParticlesTemp const & o) -> IMP::Ints
7373  """
7374  return _IMP_kernel.SingletonPredicate_get_value(self, *args)
7375 
7376 
7377  def __call__(self, m, vt):
7378  """__call__(SingletonPredicate self, Model m, ParticleIndex vt) -> int"""
7379  return _IMP_kernel.SingletonPredicate___call__(self, m, vt)
7380 
7381 
7382  def get_value_index(self, *args):
7383  """
7384  get_value_index(SingletonPredicate self, Model m, ParticleIndex vt) -> int
7385  get_value_index(SingletonPredicate self, Model m, IMP::ParticleIndexes const & o) -> IMP::Ints
7386  """
7387  return _IMP_kernel.SingletonPredicate_get_value_index(self, *args)
7388 
7389  __swig_destroy__ = _IMP_kernel.delete_SingletonPredicate
7390  __del__ = lambda self: None
7391 
7392  def __str__(self):
7393  """__str__(SingletonPredicate self) -> std::string"""
7394  return _IMP_kernel.SingletonPredicate___str__(self)
7395 
7396 
7397  def __repr__(self):
7398  """__repr__(SingletonPredicate self) -> std::string"""
7399  return _IMP_kernel.SingletonPredicate___repr__(self)
7400 
7401 
7402  @staticmethod
7403  def get_from(o):
7404  return _object_cast_to_SingletonPredicate(o)
7405 
7406 
7407  def get_type_name(self):
7408  return self.__class__.__name__
7409  def do_show(self, out):
7410  pass
7411  def get_version_info(self):
7412  if"IMP" == "IMP":
7413  return VersionInfo(self.__module__,
7414  __import__(self.__module__).get_module_version())
7415  else:
7416  return IMP.VersionInfo(self.__module__,
7417  __import__(self.__module__).get_module_version())
7418  @staticmethod
7419  def get_from(o):
7420  return _object_cast_to_SingletonPredicate(o)
7421 
7422  def __disown__(self):
7423  self.this.disown()
7424  _IMP_kernel.disown_SingletonPredicate(self)
7425  return weakref_proxy(self)
7426 
7427  def do_get_inputs(self, m, pis):
7428  """do_get_inputs(SingletonPredicate self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7429  return _IMP_kernel.SingletonPredicate_do_get_inputs(self, m, pis)
7430 
7431 
7432  def do_destroy(self):
7433  """do_destroy(SingletonPredicate self)"""
7434  return _IMP_kernel.SingletonPredicate_do_destroy(self)
7435 
7436 SingletonPredicate_swigregister = _IMP_kernel.SingletonPredicate_swigregister
7437 SingletonPredicate_swigregister(SingletonPredicate)
7438 
7439 class SingletonContainer(Container):
7440  """Proxy of C++ IMP::SingletonContainer class."""
7441 
7442  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
7443 
7444  def apply_generic(self, m):
7445  """apply_generic(SingletonContainer self, SingletonModifier m)"""
7446  return _IMP_kernel.SingletonContainer_apply_generic(self, m)
7447 
7448 
7449  def apply(self, sm):
7450  """apply(SingletonContainer self, SingletonModifier sm)"""
7451  return _IMP_kernel.SingletonContainer_apply(self, sm)
7452 
7453 
7454  def get_range_indexes(self):
7455  """get_range_indexes(SingletonContainer self) -> IMP::ParticleIndexes"""
7456  return _IMP_kernel.SingletonContainer_get_range_indexes(self)
7457 
7458 
7459  def get_contents(self):
7460  """get_contents(SingletonContainer self) -> IMP::ParticleIndexes const &"""
7461  return _IMP_kernel.SingletonContainer_get_contents(self)
7462 
7463 
7464  def get_indexes(self):
7465  """get_indexes(SingletonContainer self) -> IMP::ParticleIndexes"""
7466  return _IMP_kernel.SingletonContainer_get_indexes(self)
7467 
7468 
7469  def get(self, *args):
7470  """
7471  get(SingletonContainer self) -> IMP::ParticlesTemp
7472  get(SingletonContainer self, unsigned int i) -> Particle
7473  """
7474  return _IMP_kernel.SingletonContainer_get(self, *args)
7475 
7476 
7477  def get_number(self):
7478  """get_number(SingletonContainer self) -> unsigned int"""
7479  return _IMP_kernel.SingletonContainer_get_number(self)
7480 
7481 
7482  def get_particles(self):
7483  """get_particles(SingletonContainer self) -> IMP::ParticlesTemp"""
7484  return _IMP_kernel.SingletonContainer_get_particles(self)
7485 
7486 
7487  def get_particle(self, i):
7488  """get_particle(SingletonContainer self, unsigned int i) -> Particle"""
7489  return _IMP_kernel.SingletonContainer_get_particle(self, i)
7490 
7491 
7492  def __init__(self, *args):
7493  """
7494  __init__(IMP::SingletonContainer self, Model m, std::string name) -> SingletonContainer
7495  __init__(IMP::SingletonContainer self, Model m) -> SingletonContainer
7496  """
7497  if self.__class__ == SingletonContainer:
7498  _self = None
7499  else:
7500  _self = self
7501  this = _IMP_kernel.new_SingletonContainer(_self, *args)
7502  try:
7503  self.this.append(this)
7504  except:
7505  self.this = this
7506 
7507  if self.__class__ != SingletonContainer:
7508  _director_objects.register(self)
7509 
7510 
7511 
7512 
7513  def do_apply(self, sm):
7514  """do_apply(SingletonContainer self, SingletonModifier sm)"""
7515  return _IMP_kernel.SingletonContainer_do_apply(self, sm)
7516 
7517 
7518  def do_get_provides_access(self):
7519  """do_get_provides_access(SingletonContainer self) -> bool"""
7520  return _IMP_kernel.SingletonContainer_do_get_provides_access(self)
7521 
7522  __swig_destroy__ = _IMP_kernel.delete_SingletonContainer
7523  __del__ = lambda self: None
7524 
7525  def __str__(self):
7526  """__str__(SingletonContainer self) -> std::string"""
7527  return _IMP_kernel.SingletonContainer___str__(self)
7528 
7529 
7530  def __repr__(self):
7531  """__repr__(SingletonContainer self) -> std::string"""
7532  return _IMP_kernel.SingletonContainer___repr__(self)
7533 
7534 
7535  @staticmethod
7536  def get_from(o):
7537  return _object_cast_to_SingletonContainer(o)
7538 
7539 
7540  def get_type_name(self):
7541  return self.__class__.__name__
7542  def do_show(self, out):
7543  pass
7544  def get_version_info(self):
7545  if"IMP" == "IMP":
7546  return VersionInfo(self.__module__,
7547  __import__(self.__module__).get_module_version())
7548  else:
7549  return IMP.VersionInfo(self.__module__,
7550  __import__(self.__module__).get_module_version())
7551  @staticmethod
7552  def get_from(o):
7553  return _object_cast_to_SingletonContainer(o)
7554 
7555  def __disown__(self):
7556  self.this.disown()
7557  _IMP_kernel.disown_SingletonContainer(self)
7558  return weakref_proxy(self)
7559 
7560  def do_destroy(self):
7561  """do_destroy(SingletonContainer self)"""
7562  return _IMP_kernel.SingletonContainer_do_destroy(self)
7563 
7564 
7565  def handle_set_has_required_score_states(self, arg0):
7566  """handle_set_has_required_score_states(SingletonContainer self, bool arg0)"""
7567  return _IMP_kernel.SingletonContainer_handle_set_has_required_score_states(self, arg0)
7568 
7569 
7570  def do_get_inputs(self):
7571  """do_get_inputs(SingletonContainer self) -> IMP::ModelObjectsTemp"""
7572  return _IMP_kernel.SingletonContainer_do_get_inputs(self)
7573 
7574 
7575  def do_get_interactions(self):
7576  """do_get_interactions(SingletonContainer self) -> IMP::ModelObjectsTemps"""
7577  return _IMP_kernel.SingletonContainer_do_get_interactions(self)
7578 
7579 
7580  def do_get_contents_hash(self):
7581  """do_get_contents_hash(SingletonContainer self) -> std::size_t"""
7582  return _IMP_kernel.SingletonContainer_do_get_contents_hash(self)
7583 
7584 SingletonContainer_swigregister = _IMP_kernel.SingletonContainer_swigregister
7585 SingletonContainer_swigregister(SingletonContainer)
7586 
7587 class _SingletonContainerAdaptor(_InputAdaptor):
7588  """Proxy of C++ IMP::SingletonContainerAdaptor class."""
7589 
7590  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
7591  __repr__ = _swig_repr
7592 
7593  def __init__(self, *args):
7594  """
7595  __init__(IMP::SingletonContainerAdaptor self) -> _SingletonContainerAdaptor
7596  __init__(IMP::SingletonContainerAdaptor self, SingletonContainer c) -> _SingletonContainerAdaptor
7597  __init__(IMP::SingletonContainerAdaptor self, IMP::ParticlesTemp const & t) -> _SingletonContainerAdaptor
7598  """
7599  this = _IMP_kernel.new__SingletonContainerAdaptor(*args)
7600  try:
7601  self.this.append(this)
7602  except:
7603  self.this = this
7604 
7605  def set_name_if_default(self, name):
7606  """set_name_if_default(_SingletonContainerAdaptor self, std::string name)"""
7607  return _IMP_kernel._SingletonContainerAdaptor_set_name_if_default(self, name)
7608 
7609  __swig_destroy__ = _IMP_kernel.delete__SingletonContainerAdaptor
7610  __del__ = lambda self: None
7611 _SingletonContainerAdaptor_swigregister = _IMP_kernel._SingletonContainerAdaptor_swigregister
7612 _SingletonContainerAdaptor_swigregister(_SingletonContainerAdaptor)
7613 
7614 class TripletModifier(_ParticleInputs, _ParticleOutputs, Object):
7615  """Proxy of C++ IMP::TripletModifier class."""
7616 
7617  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
7618 
7619  def __init__(self, *args):
7620  """
7621  __init__(IMP::TripletModifier self, std::string name) -> TripletModifier
7622  __init__(IMP::TripletModifier self) -> TripletModifier
7623  """
7624  if self.__class__ == TripletModifier:
7625  _self = None
7626  else:
7627  _self = self
7628  this = _IMP_kernel.new_TripletModifier(_self, *args)
7629  try:
7630  self.this.append(this)
7631  except:
7632  self.this = this
7633 
7634  if self.__class__ != TripletModifier:
7635  _director_objects.register(self)
7636 
7637 
7638 
7639 
7640  def apply_index(self, m, v):
7641  """apply_index(TripletModifier self, Model m, IMP::ParticleIndexTriplet const & v)"""
7642  return _IMP_kernel.TripletModifier_apply_index(self, m, v)
7643 
7644 
7645  def apply_indexes(self, m, o, lower_bound, upper_bound):
7646  """apply_indexes(TripletModifier self, Model m, IMP::ParticleIndexTriplets const & o, unsigned int lower_bound, unsigned int upper_bound)"""
7647  return _IMP_kernel.TripletModifier_apply_indexes(self, m, o, lower_bound, upper_bound)
7648 
7649 
7650  def __str__(self):
7651  """__str__(TripletModifier self) -> std::string"""
7652  return _IMP_kernel.TripletModifier___str__(self)
7653 
7654 
7655  def __repr__(self):
7656  """__repr__(TripletModifier self) -> std::string"""
7657  return _IMP_kernel.TripletModifier___repr__(self)
7658 
7659 
7660  @staticmethod
7661  def get_from(o):
7662  return _object_cast_to_TripletModifier(o)
7663 
7664 
7665  def get_type_name(self):
7666  return self.__class__.__name__
7667  def do_show(self, out):
7668  pass
7669  def get_version_info(self):
7670  if"IMP" == "IMP":
7671  return VersionInfo(self.__module__,
7672  __import__(self.__module__).get_module_version())
7673  else:
7674  return IMP.VersionInfo(self.__module__,
7675  __import__(self.__module__).get_module_version())
7676  @staticmethod
7677  def get_from(o):
7678  return _object_cast_to_TripletModifier(o)
7679 
7680  __swig_destroy__ = _IMP_kernel.delete_TripletModifier
7681  __del__ = lambda self: None
7682  def __disown__(self):
7683  self.this.disown()
7684  _IMP_kernel.disown_TripletModifier(self)
7685  return weakref_proxy(self)
7686 
7687  def do_get_inputs(self, m, pis):
7688  """do_get_inputs(TripletModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7689  return _IMP_kernel.TripletModifier_do_get_inputs(self, m, pis)
7690 
7691 
7692  def do_get_outputs(self, m, pis):
7693  """do_get_outputs(TripletModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7694  return _IMP_kernel.TripletModifier_do_get_outputs(self, m, pis)
7695 
7696 
7697  def do_destroy(self):
7698  """do_destroy(TripletModifier self)"""
7699  return _IMP_kernel.TripletModifier_do_destroy(self)
7700 
7701 TripletModifier_swigregister = _IMP_kernel.TripletModifier_swigregister
7702 TripletModifier_swigregister(TripletModifier)
7703 
7704 class TripletScore(_ParticleInputs, Object):
7705  """Proxy of C++ IMP::TripletScore class."""
7706 
7707  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
7708 
7709  def __init__(self, *args):
7710  """
7711  __init__(IMP::TripletScore self, std::string name) -> TripletScore
7712  __init__(IMP::TripletScore self) -> TripletScore
7713  """
7714  if self.__class__ == TripletScore:
7715  _self = None
7716  else:
7717  _self = self
7718  this = _IMP_kernel.new_TripletScore(_self, *args)
7719  try:
7720  self.this.append(this)
7721  except:
7722  self.this = this
7723 
7724  if self.__class__ != TripletScore:
7725  _director_objects.register(self)
7726 
7727 
7728 
7729 
7730  def evaluate_index(self, m, vt, da):
7731  """evaluate_index(TripletScore self, Model m, IMP::ParticleIndexTriplet const & vt, DerivativeAccumulator da) -> double"""
7732  return _IMP_kernel.TripletScore_evaluate_index(self, m, vt, da)
7733 
7734 
7735  def evaluate_indexes(self, m, o, da, lower_bound, upper_bound):
7736  """evaluate_indexes(TripletScore self, Model m, IMP::ParticleIndexTriplets const & o, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound) -> double"""
7737  return _IMP_kernel.TripletScore_evaluate_indexes(self, m, o, da, lower_bound, upper_bound)
7738 
7739 
7740  def evaluate_if_good_index(self, m, vt, da, max):
7741  """evaluate_if_good_index(TripletScore self, Model m, IMP::ParticleIndexTriplet const & vt, DerivativeAccumulator da, double max) -> double"""
7742  return _IMP_kernel.TripletScore_evaluate_if_good_index(self, m, vt, da, max)
7743 
7744 
7745  def evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound):
7746  """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"""
7747  return _IMP_kernel.TripletScore_evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound)
7748 
7749 
7750  def create_current_decomposition(self, m, vt):
7751  """create_current_decomposition(TripletScore self, Model m, IMP::ParticleIndexTriplet const & vt) -> IMP::Restraints"""
7752  return _IMP_kernel.TripletScore_create_current_decomposition(self, m, vt)
7753 
7754 
7755  def do_create_current_decomposition(self, m, vt):
7756  """do_create_current_decomposition(TripletScore self, Model m, IMP::ParticleIndexTriplet const & vt) -> IMP::Restraints"""
7757  return _IMP_kernel.TripletScore_do_create_current_decomposition(self, m, vt)
7758 
7759  __swig_destroy__ = _IMP_kernel.delete_TripletScore
7760  __del__ = lambda self: None
7761 
7762  def __str__(self):
7763  """__str__(TripletScore self) -> std::string"""
7764  return _IMP_kernel.TripletScore___str__(self)
7765 
7766 
7767  def __repr__(self):
7768  """__repr__(TripletScore self) -> std::string"""
7769  return _IMP_kernel.TripletScore___repr__(self)
7770 
7771 
7772  @staticmethod
7773  def get_from(o):
7774  return _object_cast_to_TripletScore(o)
7775 
7776 
7777  def get_type_name(self):
7778  return self.__class__.__name__
7779  def do_show(self, out):
7780  pass
7781  def get_version_info(self):
7782  if"IMP" == "IMP":
7783  return VersionInfo(self.__module__,
7784  __import__(self.__module__).get_module_version())
7785  else:
7786  return IMP.VersionInfo(self.__module__,
7787  __import__(self.__module__).get_module_version())
7788  @staticmethod
7789  def get_from(o):
7790  return _object_cast_to_TripletScore(o)
7791 
7792  def __disown__(self):
7793  self.this.disown()
7794  _IMP_kernel.disown_TripletScore(self)
7795  return weakref_proxy(self)
7796 
7797  def do_get_inputs(self, m, pis):
7798  """do_get_inputs(TripletScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7799  return _IMP_kernel.TripletScore_do_get_inputs(self, m, pis)
7800 
7801 
7802  def do_destroy(self):
7803  """do_destroy(TripletScore self)"""
7804  return _IMP_kernel.TripletScore_do_destroy(self)
7805 
7806 TripletScore_swigregister = _IMP_kernel.TripletScore_swigregister
7807 TripletScore_swigregister(TripletScore)
7808 
7809 class TripletPredicate(_ParticleInputs, Object):
7810  """Proxy of C++ IMP::TripletPredicate class."""
7811 
7812  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
7813 
7814  def __init__(self, *args):
7815  """
7816  __init__(IMP::TripletPredicate self, std::string name) -> TripletPredicate
7817  __init__(IMP::TripletPredicate self) -> TripletPredicate
7818  """
7819  if self.__class__ == TripletPredicate:
7820  _self = None
7821  else:
7822  _self = self
7823  this = _IMP_kernel.new_TripletPredicate(_self, *args)
7824  try:
7825  self.this.append(this)
7826  except:
7827  self.this = this
7828 
7829  if self.__class__ != TripletPredicate:
7830  _director_objects.register(self)
7831 
7832 
7833 
7834 
7835  def get_value(self, *args):
7836  """
7837  get_value(TripletPredicate self, IMP::ParticleTriplet const & vt) -> int
7838  get_value(TripletPredicate self, IMP::ParticleTripletsTemp const & o) -> IMP::Ints
7839  """
7840  return _IMP_kernel.TripletPredicate_get_value(self, *args)
7841 
7842 
7843  def __call__(self, m, vt):
7844  """__call__(TripletPredicate self, Model m, IMP::ParticleIndexTriplet const & vt) -> int"""
7845  return _IMP_kernel.TripletPredicate___call__(self, m, vt)
7846 
7847 
7848  def get_value_index(self, *args):
7849  """
7850  get_value_index(TripletPredicate self, Model m, IMP::ParticleIndexTriplet const & vt) -> int
7851  get_value_index(TripletPredicate self, Model m, IMP::ParticleIndexTriplets const & o) -> IMP::Ints
7852  """
7853  return _IMP_kernel.TripletPredicate_get_value_index(self, *args)
7854 
7855  __swig_destroy__ = _IMP_kernel.delete_TripletPredicate
7856  __del__ = lambda self: None
7857 
7858  def __str__(self):
7859  """__str__(TripletPredicate self) -> std::string"""
7860  return _IMP_kernel.TripletPredicate___str__(self)
7861 
7862 
7863  def __repr__(self):
7864  """__repr__(TripletPredicate self) -> std::string"""
7865  return _IMP_kernel.TripletPredicate___repr__(self)
7866 
7867 
7868  @staticmethod
7869  def get_from(o):
7870  return _object_cast_to_TripletPredicate(o)
7871 
7872 
7873  def get_type_name(self):
7874  return self.__class__.__name__
7875  def do_show(self, out):
7876  pass
7877  def get_version_info(self):
7878  if"IMP" == "IMP":
7879  return VersionInfo(self.__module__,
7880  __import__(self.__module__).get_module_version())
7881  else:
7882  return IMP.VersionInfo(self.__module__,
7883  __import__(self.__module__).get_module_version())
7884  @staticmethod
7885  def get_from(o):
7886  return _object_cast_to_TripletPredicate(o)
7887 
7888  def __disown__(self):
7889  self.this.disown()
7890  _IMP_kernel.disown_TripletPredicate(self)
7891  return weakref_proxy(self)
7892 
7893  def do_get_inputs(self, m, pis):
7894  """do_get_inputs(TripletPredicate self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
7895  return _IMP_kernel.TripletPredicate_do_get_inputs(self, m, pis)
7896 
7897 
7898  def do_destroy(self):
7899  """do_destroy(TripletPredicate self)"""
7900  return _IMP_kernel.TripletPredicate_do_destroy(self)
7901 
7902 TripletPredicate_swigregister = _IMP_kernel.TripletPredicate_swigregister
7903 TripletPredicate_swigregister(TripletPredicate)
7904 
7905 class TripletContainer(Container):
7906  """Proxy of C++ IMP::TripletContainer class."""
7907 
7908  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
7909 
7910  def apply_generic(self, m):
7911  """apply_generic(TripletContainer self, TripletModifier m)"""
7912  return _IMP_kernel.TripletContainer_apply_generic(self, m)
7913 
7914 
7915  def apply(self, sm):
7916  """apply(TripletContainer self, TripletModifier sm)"""
7917  return _IMP_kernel.TripletContainer_apply(self, sm)
7918 
7919 
7920  def get_range_indexes(self):
7921  """get_range_indexes(TripletContainer self) -> IMP::ParticleIndexTriplets"""
7922  return _IMP_kernel.TripletContainer_get_range_indexes(self)
7923 
7924 
7925  def get_contents(self):
7926  """get_contents(TripletContainer self) -> IMP::ParticleIndexTriplets const &"""
7927  return _IMP_kernel.TripletContainer_get_contents(self)
7928 
7929 
7930  def get_indexes(self):
7931  """get_indexes(TripletContainer self) -> IMP::ParticleIndexTriplets"""
7932  return _IMP_kernel.TripletContainer_get_indexes(self)
7933 
7934 
7935  def get(self, *args):
7936  """
7937  get(TripletContainer self) -> IMP::ParticleTripletsTemp
7938  get(TripletContainer self, unsigned int i) -> IMP::ParticleTriplet
7939  """
7940  return _IMP_kernel.TripletContainer_get(self, *args)
7941 
7942 
7943  def get_number(self):
7944  """get_number(TripletContainer self) -> unsigned int"""
7945  return _IMP_kernel.TripletContainer_get_number(self)
7946 
7947 
7948  def get_particle_triplets(self):
7949  """get_particle_triplets(TripletContainer self) -> IMP::ParticleTripletsTemp"""
7950  return _IMP_kernel.TripletContainer_get_particle_triplets(self)
7951 
7952 
7953  def get_particle_triplet(self, i):
7954  """get_particle_triplet(TripletContainer self, unsigned int i) -> IMP::ParticleTriplet"""
7955  return _IMP_kernel.TripletContainer_get_particle_triplet(self, i)
7956 
7957 
7958  def __init__(self, *args):
7959  """
7960  __init__(IMP::TripletContainer self, Model m, std::string name) -> TripletContainer
7961  __init__(IMP::TripletContainer self, Model m) -> TripletContainer
7962  """
7963  if self.__class__ == TripletContainer:
7964  _self = None
7965  else:
7966  _self = self
7967  this = _IMP_kernel.new_TripletContainer(_self, *args)
7968  try:
7969  self.this.append(this)
7970  except:
7971  self.this = this
7972 
7973  if self.__class__ != TripletContainer:
7974  _director_objects.register(self)
7975 
7976 
7977 
7978 
7979  def do_apply(self, sm):
7980  """do_apply(TripletContainer self, TripletModifier sm)"""
7981  return _IMP_kernel.TripletContainer_do_apply(self, sm)
7982 
7983 
7984  def do_get_provides_access(self):
7985  """do_get_provides_access(TripletContainer self) -> bool"""
7986  return _IMP_kernel.TripletContainer_do_get_provides_access(self)
7987 
7988  __swig_destroy__ = _IMP_kernel.delete_TripletContainer
7989  __del__ = lambda self: None
7990 
7991  def __str__(self):
7992  """__str__(TripletContainer self) -> std::string"""
7993  return _IMP_kernel.TripletContainer___str__(self)
7994 
7995 
7996  def __repr__(self):
7997  """__repr__(TripletContainer self) -> std::string"""
7998  return _IMP_kernel.TripletContainer___repr__(self)
7999 
8000 
8001  @staticmethod
8002  def get_from(o):
8003  return _object_cast_to_TripletContainer(o)
8004 
8005 
8006  def get_type_name(self):
8007  return self.__class__.__name__
8008  def do_show(self, out):
8009  pass
8010  def get_version_info(self):
8011  if"IMP" == "IMP":
8012  return VersionInfo(self.__module__,
8013  __import__(self.__module__).get_module_version())
8014  else:
8015  return IMP.VersionInfo(self.__module__,
8016  __import__(self.__module__).get_module_version())
8017  @staticmethod
8018  def get_from(o):
8019  return _object_cast_to_TripletContainer(o)
8020 
8021  def __disown__(self):
8022  self.this.disown()
8023  _IMP_kernel.disown_TripletContainer(self)
8024  return weakref_proxy(self)
8025 
8026  def do_destroy(self):
8027  """do_destroy(TripletContainer self)"""
8028  return _IMP_kernel.TripletContainer_do_destroy(self)
8029 
8030 
8031  def handle_set_has_required_score_states(self, arg0):
8032  """handle_set_has_required_score_states(TripletContainer self, bool arg0)"""
8033  return _IMP_kernel.TripletContainer_handle_set_has_required_score_states(self, arg0)
8034 
8035 
8036  def do_get_inputs(self):
8037  """do_get_inputs(TripletContainer self) -> IMP::ModelObjectsTemp"""
8038  return _IMP_kernel.TripletContainer_do_get_inputs(self)
8039 
8040 
8041  def do_get_interactions(self):
8042  """do_get_interactions(TripletContainer self) -> IMP::ModelObjectsTemps"""
8043  return _IMP_kernel.TripletContainer_do_get_interactions(self)
8044 
8045 
8046  def do_get_contents_hash(self):
8047  """do_get_contents_hash(TripletContainer self) -> std::size_t"""
8048  return _IMP_kernel.TripletContainer_do_get_contents_hash(self)
8049 
8050 TripletContainer_swigregister = _IMP_kernel.TripletContainer_swigregister
8051 TripletContainer_swigregister(TripletContainer)
8052 
8053 class _TripletContainerAdaptor(_InputAdaptor):
8054  """Proxy of C++ IMP::TripletContainerAdaptor class."""
8055 
8056  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
8057  __repr__ = _swig_repr
8058 
8059  def __init__(self, *args):
8060  """
8061  __init__(IMP::TripletContainerAdaptor self) -> _TripletContainerAdaptor
8062  __init__(IMP::TripletContainerAdaptor self, TripletContainer c) -> _TripletContainerAdaptor
8063  __init__(IMP::TripletContainerAdaptor self, IMP::ParticleTripletsTemp const & t) -> _TripletContainerAdaptor
8064  """
8065  this = _IMP_kernel.new__TripletContainerAdaptor(*args)
8066  try:
8067  self.this.append(this)
8068  except:
8069  self.this = this
8070 
8071  def set_name_if_default(self, name):
8072  """set_name_if_default(_TripletContainerAdaptor self, std::string name)"""
8073  return _IMP_kernel._TripletContainerAdaptor_set_name_if_default(self, name)
8074 
8075  __swig_destroy__ = _IMP_kernel.delete__TripletContainerAdaptor
8076  __del__ = lambda self: None
8077 _TripletContainerAdaptor_swigregister = _IMP_kernel._TripletContainerAdaptor_swigregister
8078 _TripletContainerAdaptor_swigregister(_TripletContainerAdaptor)
8079 
8080 
8081 def write_particles_to_buffer(particles, keys):
8082  """write_particles_to_buffer(IMP::ParticlesTemp const & particles, IMP::FloatKeys const & keys) -> IMP::Vector< char >"""
8083  return _IMP_kernel.write_particles_to_buffer(particles, keys)
8084 
8085 def read_particles_from_buffer(buffer, particles, keys):
8086  """read_particles_from_buffer(IMP::Vector< char > const & buffer, IMP::ParticlesTemp const & particles, IMP::FloatKeys const & keys)"""
8087  return _IMP_kernel.read_particles_from_buffer(buffer, particles, keys)
8088 
8089 def get_particles(m, ps):
8090  """get_particles(Model m, IMP::ParticleIndexes const & ps) -> IMP::ParticlesTemp"""
8091  return _IMP_kernel.get_particles(m, ps)
8092 
8093 def get_indexes(*args):
8094  """
8095  get_indexes(IMP::ParticlesTemp const & ps) -> IMP::ParticleIndexes
8096  get_indexes(IMP::ParticlePairsTemp const & ps) -> IMP::ParticleIndexPairs
8097  """
8098  return _IMP_kernel.get_indexes(*args)
8099 class _ParticleIndexAdaptor(object):
8100  """Proxy of C++ IMP::ParticleIndexAdaptor class."""
8101 
8102  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
8103  __repr__ = _swig_repr
8104 
8105  def __init__(self, *args):
8106  """
8107  __init__(IMP::ParticleIndexAdaptor self, Particle p) -> _ParticleIndexAdaptor
8108  __init__(IMP::ParticleIndexAdaptor self, ParticleIndex pi) -> _ParticleIndexAdaptor
8109  __init__(IMP::ParticleIndexAdaptor self, Decorator d) -> _ParticleIndexAdaptor
8110  """
8111  this = _IMP_kernel.new__ParticleIndexAdaptor(*args)
8112  try:
8113  self.this.append(this)
8114  except:
8115  self.this = this
8116  __swig_destroy__ = _IMP_kernel.delete__ParticleIndexAdaptor
8117  __del__ = lambda self: None
8118 _ParticleIndexAdaptor_swigregister = _IMP_kernel._ParticleIndexAdaptor_swigregister
8119 _ParticleIndexAdaptor_swigregister(_ParticleIndexAdaptor)
8120 
8121 class _ParticleIndexesAdaptor(_InputAdaptor):
8122  """Proxy of C++ IMP::ParticleIndexesAdaptor class."""
8123 
8124  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
8125  __repr__ = _swig_repr
8126 
8127  def __init__(self, *args):
8128  """
8129  __init__(IMP::ParticleIndexesAdaptor self, IMP::ParticlesTemp const & ps) -> _ParticleIndexesAdaptor
8130  __init__(IMP::ParticleIndexesAdaptor self, IMP::ParticleIndexes const & pi) -> _ParticleIndexesAdaptor
8131  __init__(IMP::ParticleIndexesAdaptor self) -> _ParticleIndexesAdaptor
8132  """
8133  this = _IMP_kernel.new__ParticleIndexesAdaptor(*args)
8134  try:
8135  self.this.append(this)
8136  except:
8137  self.this = this
8138  __swig_destroy__ = _IMP_kernel.delete__ParticleIndexesAdaptor
8139  __del__ = lambda self: None
8140 _ParticleIndexesAdaptor_swigregister = _IMP_kernel._ParticleIndexesAdaptor_swigregister
8141 _ParticleIndexesAdaptor_swigregister(_ParticleIndexesAdaptor)
8142 
8143 class _ParticleIndexPairsAdaptor(object):
8144  """Proxy of C++ IMP::ParticleIndexPairsAdaptor class."""
8145 
8146  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
8147  __repr__ = _swig_repr
8148 
8149  def __init__(self, *args):
8150  """
8151  __init__(IMP::ParticleIndexPairsAdaptor self, IMP::ParticlePairsTemp const & ps) -> _ParticleIndexPairsAdaptor
8152  __init__(IMP::ParticleIndexPairsAdaptor self, IMP::ParticleIndexPairs const & pi) -> _ParticleIndexPairsAdaptor
8153  __init__(IMP::ParticleIndexPairsAdaptor self) -> _ParticleIndexPairsAdaptor
8154  """
8155  this = _IMP_kernel.new__ParticleIndexPairsAdaptor(*args)
8156  try:
8157  self.this.append(this)
8158  except:
8159  self.this = this
8160  __swig_destroy__ = _IMP_kernel.delete__ParticleIndexPairsAdaptor
8161  __del__ = lambda self: None
8162 _ParticleIndexPairsAdaptor_swigregister = _IMP_kernel._ParticleIndexPairsAdaptor_swigregister
8163 _ParticleIndexPairsAdaptor_swigregister(_ParticleIndexPairsAdaptor)
8164 
8165 class _ConstRestraint(Restraint):
8166  """Proxy of C++ IMP::internal::_ConstRestraint class."""
8167 
8168  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
8169 
8170  def __init__(self, *args):
8171  """
8172  __init__(IMP::internal::_ConstRestraint self, double v, IMP::ParticlesTemp const ps) -> _ConstRestraint
8173  __init__(IMP::internal::_ConstRestraint self, Model m, IMP::ParticleIndexes const & pis, double v) -> _ConstRestraint
8174  """
8175  this = _IMP_kernel.new__ConstRestraint(*args)
8176  try:
8177  self.this.append(this)
8178  except:
8179  self.this = this
8180 
8181  def get_value(self):
8182  """get_value(_ConstRestraint self) -> double"""
8183  return _IMP_kernel._ConstRestraint_get_value(self)
8184 
8185 
8186  def do_create_decomposition(self):
8187  """do_create_decomposition(_ConstRestraint self) -> IMP::Restraints"""
8188  return _IMP_kernel._ConstRestraint_do_create_decomposition(self)
8189 
8190 
8191  def do_get_inputs(self):
8192  """do_get_inputs(_ConstRestraint self) -> IMP::ModelObjectsTemp"""
8193  return _IMP_kernel._ConstRestraint_do_get_inputs(self)
8194 
8195 
8196  def get_version_info(self):
8197  """get_version_info(_ConstRestraint self) -> VersionInfo"""
8198  return _IMP_kernel._ConstRestraint_get_version_info(self)
8199 
8200 
8201  def __str__(self):
8202  """__str__(_ConstRestraint self) -> std::string"""
8203  return _IMP_kernel._ConstRestraint___str__(self)
8204 
8205 
8206  def __repr__(self):
8207  """__repr__(_ConstRestraint self) -> std::string"""
8208  return _IMP_kernel._ConstRestraint___repr__(self)
8209 
8210 
8211  @staticmethod
8212  def get_from(o):
8213  return _object_cast_to__ConstRestraint(o)
8214 
8215 _ConstRestraint_swigregister = _IMP_kernel._ConstRestraint_swigregister
8216 _ConstRestraint_swigregister(_ConstRestraint)
8217 
8218 class _ConstSingletonScore(SingletonScore):
8219  """Proxy of C++ IMP::internal::_ConstSingletonScore class."""
8220 
8221  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
8222  __repr__ = _swig_repr
8223 
8224  def __init__(self, v):
8225  """__init__(IMP::internal::_ConstSingletonScore self, double v) -> _ConstSingletonScore"""
8226  this = _IMP_kernel.new__ConstSingletonScore(v)
8227  try:
8228  self.this.append(this)
8229  except:
8230  self.this = this
8231 
8232  def do_get_inputs(self, arg2, arg3):
8233  """do_get_inputs(_ConstSingletonScore self, Model arg2, IMP::ParticleIndexes const & arg3) -> IMP::ModelObjectsTemp"""
8234  return _IMP_kernel._ConstSingletonScore_do_get_inputs(self, arg2, arg3)
8235 
8236 
8237  def get_version_info(self):
8238  """get_version_info(_ConstSingletonScore self) -> VersionInfo"""
8239  return _IMP_kernel._ConstSingletonScore_get_version_info(self)
8240 
8241 _ConstSingletonScore_swigregister = _IMP_kernel._ConstSingletonScore_swigregister
8242 _ConstSingletonScore_swigregister(_ConstSingletonScore)
8243 
8244 class _ConstPairScore(PairScore):
8245  """Proxy of C++ IMP::internal::_ConstPairScore class."""
8246 
8247  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
8248  __repr__ = _swig_repr
8249 
8250  def __init__(self, v):
8251  """__init__(IMP::internal::_ConstPairScore self, double v) -> _ConstPairScore"""
8252  this = _IMP_kernel.new__ConstPairScore(v)
8253  try:
8254  self.this.append(this)
8255  except:
8256  self.this = this
8257 
8258  def do_get_inputs(self, arg2, arg3):
8259  """do_get_inputs(_ConstPairScore self, Model arg2, IMP::ParticleIndexes const & arg3) -> IMP::ModelObjectsTemp"""
8260  return _IMP_kernel._ConstPairScore_do_get_inputs(self, arg2, arg3)
8261 
8262 
8263  def get_version_info(self):
8264  """get_version_info(_ConstPairScore self) -> VersionInfo"""
8265  return _IMP_kernel._ConstPairScore_get_version_info(self)
8266 
8267 _ConstPairScore_swigregister = _IMP_kernel._ConstPairScore_swigregister
8268 _ConstPairScore_swigregister(_ConstPairScore)
8269 
8270 class _TrivialDecorator(Decorator):
8271  """Proxy of C++ IMP::internal::_TrivialDecorator class."""
8272 
8273  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
8274 
8275  def __init__(self, *args):
8276  """
8277  __init__(IMP::internal::_TrivialDecorator self) -> _TrivialDecorator
8278  __init__(IMP::internal::_TrivialDecorator self, Model m, ParticleIndex id) -> _TrivialDecorator
8279  __init__(IMP::internal::_TrivialDecorator self, _ParticleAdaptor d) -> _TrivialDecorator
8280  """
8281  this = _IMP_kernel.new__TrivialDecorator(*args)
8282  try:
8283  self.this.append(this)
8284  except:
8285  self.this = this
8286 
8287  def show(self, *args):
8288  """
8289  show(_TrivialDecorator self, _ostream out)
8290  show(_TrivialDecorator self)
8291  """
8292  return _IMP_kernel._TrivialDecorator_show(self, *args)
8293 
8294 
8295  def setup_particle(*args):
8296  """
8297  setup_particle(Model m, ParticleIndex pi) -> _TrivialDecorator
8298  setup_particle(_ParticleAdaptor decorator) -> _TrivialDecorator
8299  """
8300  return _IMP_kernel._TrivialDecorator_setup_particle(*args)
8301 
8302  setup_particle = staticmethod(setup_particle)
8303 
8304  def get_is_setup(*args):
8305  """
8306  get_is_setup(_ParticleAdaptor p) -> bool
8307  get_is_setup(Model m, ParticleIndex pi) -> bool
8308  """
8309  return _IMP_kernel._TrivialDecorator_get_is_setup(*args)
8310 
8311  get_is_setup = staticmethod(get_is_setup)
8312 
8313  def add_attribute(self, *args):
8314  """
8315  add_attribute(_TrivialDecorator self, FloatKey k, IMP::Float v, bool opt)
8316  add_attribute(_TrivialDecorator self, FloatKey a0, IMP::Float a1)
8317  add_attribute(_TrivialDecorator self, IntKey a0, IMP::Int a1)
8318  add_attribute(_TrivialDecorator self, StringKey a0, IMP::String a1)
8319  add_attribute(_TrivialDecorator self, ParticleIndexKey a0, Particle a1)
8320  add_attribute(_TrivialDecorator self, ObjectKey a0, Object a1)
8321  """
8322  return _IMP_kernel._TrivialDecorator_add_attribute(self, *args)
8323 
8324 
8325  def get_value(self, *args):
8326  """
8327  get_value(_TrivialDecorator self, FloatKey a0) -> IMP::Float
8328  get_value(_TrivialDecorator self, IntKey a0) -> IMP::Int
8329  get_value(_TrivialDecorator self, StringKey a0) -> IMP::String
8330  get_value(_TrivialDecorator self, ParticleIndexKey a0) -> Particle
8331  get_value(_TrivialDecorator self, ObjectKey a0) -> Object
8332  """
8333  return _IMP_kernel._TrivialDecorator_get_value(self, *args)
8334 
8335 
8336  def set_value(self, *args):
8337  """
8338  set_value(_TrivialDecorator self, FloatKey a0, IMP::Float a1)
8339  set_value(_TrivialDecorator self, IntKey a0, IMP::Int a1)
8340  set_value(_TrivialDecorator self, StringKey a0, IMP::String a1)
8341  set_value(_TrivialDecorator self, ParticleIndexKey a0, Particle a1)
8342  set_value(_TrivialDecorator self, ObjectKey a0, Object a1)
8343  """
8344  return _IMP_kernel._TrivialDecorator_set_value(self, *args)
8345 
8346 
8347  def remove_attribute(self, *args):
8348  """
8349  remove_attribute(_TrivialDecorator self, FloatKey a0)
8350  remove_attribute(_TrivialDecorator self, IntKey a0)
8351  remove_attribute(_TrivialDecorator self, StringKey a0)
8352  remove_attribute(_TrivialDecorator self, ParticleIndexKey a0)
8353  remove_attribute(_TrivialDecorator self, ObjectKey a0)
8354  """
8355  return _IMP_kernel._TrivialDecorator_remove_attribute(self, *args)
8356 
8357 
8358  def has_attribute(self, *args):
8359  """
8360  has_attribute(_TrivialDecorator self, FloatKey a0) -> bool
8361  has_attribute(_TrivialDecorator self, IntKey a0) -> bool
8362  has_attribute(_TrivialDecorator self, StringKey a0) -> bool
8363  has_attribute(_TrivialDecorator self, ParticleIndexKey a0) -> bool
8364  has_attribute(_TrivialDecorator self, ObjectKey a0) -> bool
8365  """
8366  return _IMP_kernel._TrivialDecorator_has_attribute(self, *args)
8367 
8368 
8369  def get_derivative(self, a0):
8370  """get_derivative(_TrivialDecorator self, FloatKey a0) -> double"""
8371  return _IMP_kernel._TrivialDecorator_get_derivative(self, a0)
8372 
8373 
8374  def get_name(self):
8375  """get_name(_TrivialDecorator self) -> std::string"""
8376  return _IMP_kernel._TrivialDecorator_get_name(self)
8377 
8378 
8379  def clear_caches(self):
8380  """clear_caches(_TrivialDecorator self)"""
8381  return _IMP_kernel._TrivialDecorator_clear_caches(self)
8382 
8383 
8384  def set_name(self, a0):
8385  """set_name(_TrivialDecorator self, std::string a0)"""
8386  return _IMP_kernel._TrivialDecorator_set_name(self, a0)
8387 
8388 
8389  def set_check_level(self, a0):
8390  """set_check_level(_TrivialDecorator self, IMP::CheckLevel a0)"""
8391  return _IMP_kernel._TrivialDecorator_set_check_level(self, a0)
8392 
8393 
8394  def add_to_derivative(self, a0, a1, a2):
8395  """add_to_derivative(_TrivialDecorator self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
8396  return _IMP_kernel._TrivialDecorator_add_to_derivative(self, a0, a1, a2)
8397 
8398 
8399  def set_is_optimized(self, a0, a1):
8400  """set_is_optimized(_TrivialDecorator self, FloatKey a0, bool a1)"""
8401  return _IMP_kernel._TrivialDecorator_set_is_optimized(self, a0, a1)
8402 
8403 
8404  def get_is_optimized(self, a0):
8405  """get_is_optimized(_TrivialDecorator self, FloatKey a0) -> bool"""
8406  return _IMP_kernel._TrivialDecorator_get_is_optimized(self, a0)
8407 
8408 
8409  def get_check_level(self):
8410  """get_check_level(_TrivialDecorator self) -> IMP::CheckLevel"""
8411  return _IMP_kernel._TrivialDecorator_get_check_level(self)
8412 
8413 
8414  def __eq__(self, *args):
8415  """
8416  __eq__(_TrivialDecorator self, _TrivialDecorator o) -> bool
8417  __eq__(_TrivialDecorator self, Particle d) -> bool
8418  """
8419  return _IMP_kernel._TrivialDecorator___eq__(self, *args)
8420 
8421 
8422  def __ne__(self, *args):
8423  """
8424  __ne__(_TrivialDecorator self, _TrivialDecorator o) -> bool
8425  __ne__(_TrivialDecorator self, Particle d) -> bool
8426  """
8427  return _IMP_kernel._TrivialDecorator___ne__(self, *args)
8428 
8429 
8430  def __le__(self, *args):
8431  """
8432  __le__(_TrivialDecorator self, _TrivialDecorator o) -> bool
8433  __le__(_TrivialDecorator self, Particle d) -> bool
8434  """
8435  return _IMP_kernel._TrivialDecorator___le__(self, *args)
8436 
8437 
8438  def __lt__(self, *args):
8439  """
8440  __lt__(_TrivialDecorator self, _TrivialDecorator o) -> bool
8441  __lt__(_TrivialDecorator self, Particle d) -> bool
8442  """
8443  return _IMP_kernel._TrivialDecorator___lt__(self, *args)
8444 
8445 
8446  def __ge__(self, *args):
8447  """
8448  __ge__(_TrivialDecorator self, _TrivialDecorator o) -> bool
8449  __ge__(_TrivialDecorator self, Particle d) -> bool
8450  """
8451  return _IMP_kernel._TrivialDecorator___ge__(self, *args)
8452 
8453 
8454  def __gt__(self, *args):
8455  """
8456  __gt__(_TrivialDecorator self, _TrivialDecorator o) -> bool
8457  __gt__(_TrivialDecorator self, Particle d) -> bool
8458  """
8459  return _IMP_kernel._TrivialDecorator___gt__(self, *args)
8460 
8461 
8462  def __hash__(self):
8463  """__hash__(_TrivialDecorator self) -> std::size_t"""
8464  return _IMP_kernel._TrivialDecorator___hash__(self)
8465 
8466 
8467  def __str__(self):
8468  """__str__(_TrivialDecorator self) -> std::string"""
8469  return _IMP_kernel._TrivialDecorator___str__(self)
8470 
8471 
8472  def __repr__(self):
8473  """__repr__(_TrivialDecorator self) -> std::string"""
8474  return _IMP_kernel._TrivialDecorator___repr__(self)
8475 
8476  __swig_destroy__ = _IMP_kernel.delete__TrivialDecorator
8477  __del__ = lambda self: None
8478 _TrivialDecorator_swigregister = _IMP_kernel._TrivialDecorator_swigregister
8479 _TrivialDecorator_swigregister(_TrivialDecorator)
8480 
8481 def _TrivialDecorator_setup_particle(*args):
8482  """
8483  setup_particle(Model m, ParticleIndex pi) -> _TrivialDecorator
8484  _TrivialDecorator_setup_particle(_ParticleAdaptor decorator) -> _TrivialDecorator
8485  """
8486  return _IMP_kernel._TrivialDecorator_setup_particle(*args)
8487 
8488 def _TrivialDecorator_get_is_setup(*args):
8489  """
8490  get_is_setup(_ParticleAdaptor p) -> bool
8491  _TrivialDecorator_get_is_setup(Model m, ParticleIndex pi) -> bool
8492  """
8493  return _IMP_kernel._TrivialDecorator_get_is_setup(*args)
8494 
8495 class _TrivialDerivedDecorator(_TrivialDecorator):
8496  """Proxy of C++ IMP::internal::_TrivialDerivedDecorator class."""
8497 
8498  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
8499 
8500  def __init__(self, *args):
8501  """
8502  __init__(IMP::internal::_TrivialDerivedDecorator self) -> _TrivialDerivedDecorator
8503  __init__(IMP::internal::_TrivialDerivedDecorator self, Model m, ParticleIndex id) -> _TrivialDerivedDecorator
8504  __init__(IMP::internal::_TrivialDerivedDecorator self, _ParticleAdaptor d) -> _TrivialDerivedDecorator
8505  """
8506  this = _IMP_kernel.new__TrivialDerivedDecorator(*args)
8507  try:
8508  self.this.append(this)
8509  except:
8510  self.this = this
8511 
8512  def show(self, *args):
8513  """
8514  show(_TrivialDerivedDecorator self, _ostream out)
8515  show(_TrivialDerivedDecorator self)
8516  """
8517  return _IMP_kernel._TrivialDerivedDecorator_show(self, *args)
8518 
8519 
8520  def setup_particle(*args):
8521  """
8522  setup_particle(Model m, ParticleIndex pi) -> _TrivialDerivedDecorator
8523  setup_particle(_ParticleAdaptor decorator) -> _TrivialDerivedDecorator
8524  """
8525  return _IMP_kernel._TrivialDerivedDecorator_setup_particle(*args)
8526 
8527  setup_particle = staticmethod(setup_particle)
8528 
8529  def get_is_setup(*args):
8530  """
8531  get_is_setup(_ParticleAdaptor p) -> bool
8532  get_is_setup(Model m, ParticleIndex pi) -> bool
8533  """
8534  return _IMP_kernel._TrivialDerivedDecorator_get_is_setup(*args)
8535 
8536  get_is_setup = staticmethod(get_is_setup)
8537 
8538  def add_attribute(self, *args):
8539  """
8540  add_attribute(_TrivialDerivedDecorator self, FloatKey k, IMP::Float v, bool opt)
8541  add_attribute(_TrivialDerivedDecorator self, FloatKey a0, IMP::Float a1)
8542  add_attribute(_TrivialDerivedDecorator self, IntKey a0, IMP::Int a1)
8543  add_attribute(_TrivialDerivedDecorator self, StringKey a0, IMP::String a1)
8544  add_attribute(_TrivialDerivedDecorator self, ParticleIndexKey a0, Particle a1)
8545  add_attribute(_TrivialDerivedDecorator self, ObjectKey a0, Object a1)
8546  """
8547  return _IMP_kernel._TrivialDerivedDecorator_add_attribute(self, *args)
8548 
8549 
8550  def get_value(self, *args):
8551  """
8552  get_value(_TrivialDerivedDecorator self, FloatKey a0) -> IMP::Float
8553  get_value(_TrivialDerivedDecorator self, IntKey a0) -> IMP::Int
8554  get_value(_TrivialDerivedDecorator self, StringKey a0) -> IMP::String
8555  get_value(_TrivialDerivedDecorator self, ParticleIndexKey a0) -> Particle
8556  get_value(_TrivialDerivedDecorator self, ObjectKey a0) -> Object
8557  """
8558  return _IMP_kernel._TrivialDerivedDecorator_get_value(self, *args)
8559 
8560 
8561  def set_value(self, *args):
8562  """
8563  set_value(_TrivialDerivedDecorator self, FloatKey a0, IMP::Float a1)
8564  set_value(_TrivialDerivedDecorator self, IntKey a0, IMP::Int a1)
8565  set_value(_TrivialDerivedDecorator self, StringKey a0, IMP::String a1)
8566  set_value(_TrivialDerivedDecorator self, ParticleIndexKey a0, Particle a1)
8567  set_value(_TrivialDerivedDecorator self, ObjectKey a0, Object a1)
8568  """
8569  return _IMP_kernel._TrivialDerivedDecorator_set_value(self, *args)
8570 
8571 
8572  def remove_attribute(self, *args):
8573  """
8574  remove_attribute(_TrivialDerivedDecorator self, FloatKey a0)
8575  remove_attribute(_TrivialDerivedDecorator self, IntKey a0)
8576  remove_attribute(_TrivialDerivedDecorator self, StringKey a0)
8577  remove_attribute(_TrivialDerivedDecorator self, ParticleIndexKey a0)
8578  remove_attribute(_TrivialDerivedDecorator self, ObjectKey a0)
8579  """
8580  return _IMP_kernel._TrivialDerivedDecorator_remove_attribute(self, *args)
8581 
8582 
8583  def has_attribute(self, *args):
8584  """
8585  has_attribute(_TrivialDerivedDecorator self, FloatKey a0) -> bool
8586  has_attribute(_TrivialDerivedDecorator self, IntKey a0) -> bool
8587  has_attribute(_TrivialDerivedDecorator self, StringKey a0) -> bool
8588  has_attribute(_TrivialDerivedDecorator self, ParticleIndexKey a0) -> bool
8589  has_attribute(_TrivialDerivedDecorator self, ObjectKey a0) -> bool
8590  """
8591  return _IMP_kernel._TrivialDerivedDecorator_has_attribute(self, *args)
8592 
8593 
8594  def get_derivative(self, a0):
8595  """get_derivative(_TrivialDerivedDecorator self, FloatKey a0) -> double"""
8596  return _IMP_kernel._TrivialDerivedDecorator_get_derivative(self, a0)
8597 
8598 
8599  def get_name(self):
8600  """get_name(_TrivialDerivedDecorator self) -> std::string"""
8601  return _IMP_kernel._TrivialDerivedDecorator_get_name(self)
8602 
8603 
8604  def clear_caches(self):
8605  """clear_caches(_TrivialDerivedDecorator self)"""
8606  return _IMP_kernel._TrivialDerivedDecorator_clear_caches(self)
8607 
8608 
8609  def set_name(self, a0):
8610  """set_name(_TrivialDerivedDecorator self, std::string a0)"""
8611  return _IMP_kernel._TrivialDerivedDecorator_set_name(self, a0)
8612 
8613 
8614  def set_check_level(self, a0):
8615  """set_check_level(_TrivialDerivedDecorator self, IMP::CheckLevel a0)"""
8616  return _IMP_kernel._TrivialDerivedDecorator_set_check_level(self, a0)
8617 
8618 
8619  def add_to_derivative(self, a0, a1, a2):
8620  """add_to_derivative(_TrivialDerivedDecorator self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
8621  return _IMP_kernel._TrivialDerivedDecorator_add_to_derivative(self, a0, a1, a2)
8622 
8623 
8624  def set_is_optimized(self, a0, a1):
8625  """set_is_optimized(_TrivialDerivedDecorator self, FloatKey a0, bool a1)"""
8626  return _IMP_kernel._TrivialDerivedDecorator_set_is_optimized(self, a0, a1)
8627 
8628 
8629  def get_is_optimized(self, a0):
8630  """get_is_optimized(_TrivialDerivedDecorator self, FloatKey a0) -> bool"""
8631  return _IMP_kernel._TrivialDerivedDecorator_get_is_optimized(self, a0)
8632 
8633 
8634  def get_check_level(self):
8635  """get_check_level(_TrivialDerivedDecorator self) -> IMP::CheckLevel"""
8636  return _IMP_kernel._TrivialDerivedDecorator_get_check_level(self)
8637 
8638 
8639  def __eq__(self, *args):
8640  """
8641  __eq__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
8642  __eq__(_TrivialDerivedDecorator self, Particle d) -> bool
8643  """
8644  return _IMP_kernel._TrivialDerivedDecorator___eq__(self, *args)
8645 
8646 
8647  def __ne__(self, *args):
8648  """
8649  __ne__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
8650  __ne__(_TrivialDerivedDecorator self, Particle d) -> bool
8651  """
8652  return _IMP_kernel._TrivialDerivedDecorator___ne__(self, *args)
8653 
8654 
8655  def __le__(self, *args):
8656  """
8657  __le__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
8658  __le__(_TrivialDerivedDecorator self, Particle d) -> bool
8659  """
8660  return _IMP_kernel._TrivialDerivedDecorator___le__(self, *args)
8661 
8662 
8663  def __lt__(self, *args):
8664  """
8665  __lt__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
8666  __lt__(_TrivialDerivedDecorator self, Particle d) -> bool
8667  """
8668  return _IMP_kernel._TrivialDerivedDecorator___lt__(self, *args)
8669 
8670 
8671  def __ge__(self, *args):
8672  """
8673  __ge__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
8674  __ge__(_TrivialDerivedDecorator self, Particle d) -> bool
8675  """
8676  return _IMP_kernel._TrivialDerivedDecorator___ge__(self, *args)
8677 
8678 
8679  def __gt__(self, *args):
8680  """
8681  __gt__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
8682  __gt__(_TrivialDerivedDecorator self, Particle d) -> bool
8683  """
8684  return _IMP_kernel._TrivialDerivedDecorator___gt__(self, *args)
8685 
8686 
8687  def __hash__(self):
8688  """__hash__(_TrivialDerivedDecorator self) -> std::size_t"""
8689  return _IMP_kernel._TrivialDerivedDecorator___hash__(self)
8690 
8691 
8692  def __str__(self):
8693  """__str__(_TrivialDerivedDecorator self) -> std::string"""
8694  return _IMP_kernel._TrivialDerivedDecorator___str__(self)
8695 
8696 
8697  def __repr__(self):
8698  """__repr__(_TrivialDerivedDecorator self) -> std::string"""
8699  return _IMP_kernel._TrivialDerivedDecorator___repr__(self)
8700 
8701  __swig_destroy__ = _IMP_kernel.delete__TrivialDerivedDecorator
8702  __del__ = lambda self: None
8703 _TrivialDerivedDecorator_swigregister = _IMP_kernel._TrivialDerivedDecorator_swigregister
8704 _TrivialDerivedDecorator_swigregister(_TrivialDerivedDecorator)
8705 
8706 def _TrivialDerivedDecorator_setup_particle(*args):
8707  """
8708  setup_particle(Model m, ParticleIndex pi) -> _TrivialDerivedDecorator
8709  _TrivialDerivedDecorator_setup_particle(_ParticleAdaptor decorator) -> _TrivialDerivedDecorator
8710  """
8711  return _IMP_kernel._TrivialDerivedDecorator_setup_particle(*args)
8712 
8713 def _TrivialDerivedDecorator_get_is_setup(*args):
8714  """
8715  get_is_setup(_ParticleAdaptor p) -> bool
8716  _TrivialDerivedDecorator_get_is_setup(Model m, ParticleIndex pi) -> bool
8717  """
8718  return _IMP_kernel._TrivialDerivedDecorator_get_is_setup(*args)
8719 
8720 class _TrivialTraitsDecorator(Decorator):
8721  """Proxy of C++ IMP::internal::_TrivialTraitsDecorator class."""
8722 
8723  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
8724 
8725  def get_decorator_traits(self):
8726  """get_decorator_traits(_TrivialTraitsDecorator self) -> StringKey"""
8727  return _IMP_kernel._TrivialTraitsDecorator_get_decorator_traits(self)
8728 
8729 
8730  def get_default_decorator_traits():
8731  """get_default_decorator_traits() -> StringKey"""
8732  return _IMP_kernel._TrivialTraitsDecorator_get_default_decorator_traits()
8733 
8734  get_default_decorator_traits = staticmethod(get_default_decorator_traits)
8735 
8736  def __init__(self, *args):
8737  """
8738  __init__(IMP::internal::_TrivialTraitsDecorator self) -> _TrivialTraitsDecorator
8739  __init__(IMP::internal::_TrivialTraitsDecorator self, Model m, ParticleIndex id, StringKey tr) -> _TrivialTraitsDecorator
8740  __init__(IMP::internal::_TrivialTraitsDecorator self, Model m, ParticleIndex id) -> _TrivialTraitsDecorator
8741  __init__(IMP::internal::_TrivialTraitsDecorator self, _ParticleAdaptor d, StringKey tr) -> _TrivialTraitsDecorator
8742  __init__(IMP::internal::_TrivialTraitsDecorator self, _ParticleAdaptor d) -> _TrivialTraitsDecorator
8743  """
8744  this = _IMP_kernel.new__TrivialTraitsDecorator(*args)
8745  try:
8746  self.this.append(this)
8747  except:
8748  self.this = this
8749 
8750  def show(self, *args):
8751  """
8752  show(_TrivialTraitsDecorator self, _ostream out)
8753  show(_TrivialTraitsDecorator self)
8754  """
8755  return _IMP_kernel._TrivialTraitsDecorator_show(self, *args)
8756 
8757 
8758  def setup_particle(*args):
8759  """
8760  setup_particle(Model m, ParticleIndex pi, StringKey tr) -> _TrivialTraitsDecorator
8761  setup_particle(Model m, ParticleIndex pi) -> _TrivialTraitsDecorator
8762  setup_particle(_ParticleAdaptor d, StringKey tr) -> _TrivialTraitsDecorator
8763  setup_particle(_ParticleAdaptor d) -> _TrivialTraitsDecorator
8764  """
8765  return _IMP_kernel._TrivialTraitsDecorator_setup_particle(*args)
8766 
8767  setup_particle = staticmethod(setup_particle)
8768 
8769  def get_is_setup(*args):
8770  """
8771  get_is_setup(_ParticleAdaptor p, StringKey tr) -> bool
8772  get_is_setup(_ParticleAdaptor p) -> bool
8773  get_is_setup(Model m, ParticleIndex pi, StringKey k) -> bool
8774  get_is_setup(Model m, ParticleIndex pi) -> bool
8775  """
8776  return _IMP_kernel._TrivialTraitsDecorator_get_is_setup(*args)
8777 
8778  get_is_setup = staticmethod(get_is_setup)
8779 
8780  def get_default_key():
8781  """get_default_key() -> StringKey"""
8782  return _IMP_kernel._TrivialTraitsDecorator_get_default_key()
8783 
8784  get_default_key = staticmethod(get_default_key)
8785 
8786  def add_attribute(self, *args):
8787  """
8788  add_attribute(_TrivialTraitsDecorator self, FloatKey k, IMP::Float v, bool opt)
8789  add_attribute(_TrivialTraitsDecorator self, FloatKey a0, IMP::Float a1)
8790  add_attribute(_TrivialTraitsDecorator self, IntKey a0, IMP::Int a1)
8791  add_attribute(_TrivialTraitsDecorator self, StringKey a0, IMP::String a1)
8792  add_attribute(_TrivialTraitsDecorator self, ParticleIndexKey a0, Particle a1)
8793  add_attribute(_TrivialTraitsDecorator self, ObjectKey a0, Object a1)
8794  """
8795  return _IMP_kernel._TrivialTraitsDecorator_add_attribute(self, *args)
8796 
8797 
8798  def get_value(self, *args):
8799  """
8800  get_value(_TrivialTraitsDecorator self, FloatKey a0) -> IMP::Float
8801  get_value(_TrivialTraitsDecorator self, IntKey a0) -> IMP::Int
8802  get_value(_TrivialTraitsDecorator self, StringKey a0) -> IMP::String
8803  get_value(_TrivialTraitsDecorator self, ParticleIndexKey a0) -> Particle
8804  get_value(_TrivialTraitsDecorator self, ObjectKey a0) -> Object
8805  """
8806  return _IMP_kernel._TrivialTraitsDecorator_get_value(self, *args)
8807 
8808 
8809  def set_value(self, *args):
8810  """
8811  set_value(_TrivialTraitsDecorator self, FloatKey a0, IMP::Float a1)
8812  set_value(_TrivialTraitsDecorator self, IntKey a0, IMP::Int a1)
8813  set_value(_TrivialTraitsDecorator self, StringKey a0, IMP::String a1)
8814  set_value(_TrivialTraitsDecorator self, ParticleIndexKey a0, Particle a1)
8815  set_value(_TrivialTraitsDecorator self, ObjectKey a0, Object a1)
8816  """
8817  return _IMP_kernel._TrivialTraitsDecorator_set_value(self, *args)
8818 
8819 
8820  def remove_attribute(self, *args):
8821  """
8822  remove_attribute(_TrivialTraitsDecorator self, FloatKey a0)
8823  remove_attribute(_TrivialTraitsDecorator self, IntKey a0)
8824  remove_attribute(_TrivialTraitsDecorator self, StringKey a0)
8825  remove_attribute(_TrivialTraitsDecorator self, ParticleIndexKey a0)
8826  remove_attribute(_TrivialTraitsDecorator self, ObjectKey a0)
8827  """
8828  return _IMP_kernel._TrivialTraitsDecorator_remove_attribute(self, *args)
8829 
8830 
8831  def has_attribute(self, *args):
8832  """
8833  has_attribute(_TrivialTraitsDecorator self, FloatKey a0) -> bool
8834  has_attribute(_TrivialTraitsDecorator self, IntKey a0) -> bool
8835  has_attribute(_TrivialTraitsDecorator self, StringKey a0) -> bool
8836  has_attribute(_TrivialTraitsDecorator self, ParticleIndexKey a0) -> bool
8837  has_attribute(_TrivialTraitsDecorator self, ObjectKey a0) -> bool
8838  """
8839  return _IMP_kernel._TrivialTraitsDecorator_has_attribute(self, *args)
8840 
8841 
8842  def get_derivative(self, a0):
8843  """get_derivative(_TrivialTraitsDecorator self, FloatKey a0) -> double"""
8844  return _IMP_kernel._TrivialTraitsDecorator_get_derivative(self, a0)
8845 
8846 
8847  def get_name(self):
8848  """get_name(_TrivialTraitsDecorator self) -> std::string"""
8849  return _IMP_kernel._TrivialTraitsDecorator_get_name(self)
8850 
8851 
8852  def clear_caches(self):
8853  """clear_caches(_TrivialTraitsDecorator self)"""
8854  return _IMP_kernel._TrivialTraitsDecorator_clear_caches(self)
8855 
8856 
8857  def set_name(self, a0):
8858  """set_name(_TrivialTraitsDecorator self, std::string a0)"""
8859  return _IMP_kernel._TrivialTraitsDecorator_set_name(self, a0)
8860 
8861 
8862  def set_check_level(self, a0):
8863  """set_check_level(_TrivialTraitsDecorator self, IMP::CheckLevel a0)"""
8864  return _IMP_kernel._TrivialTraitsDecorator_set_check_level(self, a0)
8865 
8866 
8867  def add_to_derivative(self, a0, a1, a2):
8868  """add_to_derivative(_TrivialTraitsDecorator self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
8869  return _IMP_kernel._TrivialTraitsDecorator_add_to_derivative(self, a0, a1, a2)
8870 
8871 
8872  def set_is_optimized(self, a0, a1):
8873  """set_is_optimized(_TrivialTraitsDecorator self, FloatKey a0, bool a1)"""
8874  return _IMP_kernel._TrivialTraitsDecorator_set_is_optimized(self, a0, a1)
8875 
8876 
8877  def get_is_optimized(self, a0):
8878  """get_is_optimized(_TrivialTraitsDecorator self, FloatKey a0) -> bool"""
8879  return _IMP_kernel._TrivialTraitsDecorator_get_is_optimized(self, a0)
8880 
8881 
8882  def get_check_level(self):
8883  """get_check_level(_TrivialTraitsDecorator self) -> IMP::CheckLevel"""
8884  return _IMP_kernel._TrivialTraitsDecorator_get_check_level(self)
8885 
8886 
8887  def __eq__(self, *args):
8888  """
8889  __eq__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
8890  __eq__(_TrivialTraitsDecorator self, Particle d) -> bool
8891  """
8892  return _IMP_kernel._TrivialTraitsDecorator___eq__(self, *args)
8893 
8894 
8895  def __ne__(self, *args):
8896  """
8897  __ne__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
8898  __ne__(_TrivialTraitsDecorator self, Particle d) -> bool
8899  """
8900  return _IMP_kernel._TrivialTraitsDecorator___ne__(self, *args)
8901 
8902 
8903  def __le__(self, *args):
8904  """
8905  __le__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
8906  __le__(_TrivialTraitsDecorator self, Particle d) -> bool
8907  """
8908  return _IMP_kernel._TrivialTraitsDecorator___le__(self, *args)
8909 
8910 
8911  def __lt__(self, *args):
8912  """
8913  __lt__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
8914  __lt__(_TrivialTraitsDecorator self, Particle d) -> bool
8915  """
8916  return _IMP_kernel._TrivialTraitsDecorator___lt__(self, *args)
8917 
8918 
8919  def __ge__(self, *args):
8920  """
8921  __ge__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
8922  __ge__(_TrivialTraitsDecorator self, Particle d) -> bool
8923  """
8924  return _IMP_kernel._TrivialTraitsDecorator___ge__(self, *args)
8925 
8926 
8927  def __gt__(self, *args):
8928  """
8929  __gt__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
8930  __gt__(_TrivialTraitsDecorator self, Particle d) -> bool
8931  """
8932  return _IMP_kernel._TrivialTraitsDecorator___gt__(self, *args)
8933 
8934 
8935  def __hash__(self):
8936  """__hash__(_TrivialTraitsDecorator self) -> std::size_t"""
8937  return _IMP_kernel._TrivialTraitsDecorator___hash__(self)
8938 
8939 
8940  def __str__(self):
8941  """__str__(_TrivialTraitsDecorator self) -> std::string"""
8942  return _IMP_kernel._TrivialTraitsDecorator___str__(self)
8943 
8944 
8945  def __repr__(self):
8946  """__repr__(_TrivialTraitsDecorator self) -> std::string"""
8947  return _IMP_kernel._TrivialTraitsDecorator___repr__(self)
8948 
8949  __swig_destroy__ = _IMP_kernel.delete__TrivialTraitsDecorator
8950  __del__ = lambda self: None
8951 _TrivialTraitsDecorator_swigregister = _IMP_kernel._TrivialTraitsDecorator_swigregister
8952 _TrivialTraitsDecorator_swigregister(_TrivialTraitsDecorator)
8953 
8954 def _TrivialTraitsDecorator_get_default_decorator_traits():
8955  """_TrivialTraitsDecorator_get_default_decorator_traits() -> StringKey"""
8956  return _IMP_kernel._TrivialTraitsDecorator_get_default_decorator_traits()
8957 
8958 def _TrivialTraitsDecorator_setup_particle(*args):
8959  """
8960  setup_particle(Model m, ParticleIndex pi, StringKey tr) -> _TrivialTraitsDecorator
8961  setup_particle(Model m, ParticleIndex pi) -> _TrivialTraitsDecorator
8962  setup_particle(_ParticleAdaptor d, StringKey tr) -> _TrivialTraitsDecorator
8963  _TrivialTraitsDecorator_setup_particle(_ParticleAdaptor d) -> _TrivialTraitsDecorator
8964  """
8965  return _IMP_kernel._TrivialTraitsDecorator_setup_particle(*args)
8966 
8967 def _TrivialTraitsDecorator_get_is_setup(*args):
8968  """
8969  get_is_setup(_ParticleAdaptor p, StringKey tr) -> bool
8970  get_is_setup(_ParticleAdaptor p) -> bool
8971  get_is_setup(Model m, ParticleIndex pi, StringKey k) -> bool
8972  _TrivialTraitsDecorator_get_is_setup(Model m, ParticleIndex pi) -> bool
8973  """
8974  return _IMP_kernel._TrivialTraitsDecorator_get_is_setup(*args)
8975 
8976 def _TrivialTraitsDecorator_get_default_key():
8977  """_TrivialTraitsDecorator_get_default_key() -> StringKey"""
8978  return _IMP_kernel._TrivialTraitsDecorator_get_default_key()
8979 
8980 
8981 def __lshift__(*args):
8982  """
8983  __lshift__(_ostream out, _TrivialDecorator n) -> _ostream
8984  __lshift__(_ostream out, _TrivialDerivedDecorator n) -> _ostream
8985  __lshift__(_ostream out, _TrivialTraitsDecorator n) -> _ostream
8986  """
8987  return _IMP_kernel.__lshift__(*args)
8988 class _ConstOptimizer(Optimizer):
8989  """Proxy of C++ IMP::internal::_ConstOptimizer class."""
8990 
8991  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
8992 
8993  def __init__(self, m):
8994  """__init__(IMP::internal::_ConstOptimizer self, Model m) -> _ConstOptimizer"""
8995  this = _IMP_kernel.new__ConstOptimizer(m)
8996  try:
8997  self.this.append(this)
8998  except:
8999  self.this = this
9000 
9001  def do_optimize(self, max_steps):
9002  """do_optimize(_ConstOptimizer self, unsigned int max_steps) -> IMP::Float"""
9003  return _IMP_kernel._ConstOptimizer_do_optimize(self, max_steps)
9004 
9005 
9006  def get_version_info(self):
9007  """get_version_info(_ConstOptimizer self) -> VersionInfo"""
9008  return _IMP_kernel._ConstOptimizer_get_version_info(self)
9009 
9010 
9011  def __str__(self):
9012  """__str__(_ConstOptimizer self) -> std::string"""
9013  return _IMP_kernel._ConstOptimizer___str__(self)
9014 
9015 
9016  def __repr__(self):
9017  """__repr__(_ConstOptimizer self) -> std::string"""
9018  return _IMP_kernel._ConstOptimizer___repr__(self)
9019 
9020 
9021  @staticmethod
9022  def get_from(o):
9023  return _object_cast_to__ConstOptimizer(o)
9024 
9025 _ConstOptimizer_swigregister = _IMP_kernel._ConstOptimizer_swigregister
9026 _ConstOptimizer_swigregister(_ConstOptimizer)
9027 
9028 
9029 def get_particle(p):
9030  """get_particle(Particle p) -> Particle"""
9031  return _IMP_kernel.get_particle(p)
9032 
9033 def _decorator_test(p):
9034  """_decorator_test(Particle p)"""
9035  return _IMP_kernel._decorator_test(p)
9036 
9037 def _overloaded_decorator(*args):
9038  """
9039  _overloaded_decorator(_TrivialDecorator a) -> int
9040  _overloaded_decorator(_TrivialDerivedDecorator a) -> int
9041  """
9042  return _IMP_kernel._overloaded_decorator(*args)
9043 
9044 def _take_particles(*args):
9045  """
9046  _take_particles(IMP::Particles const & ps) -> unsigned int
9047  _take_particles(Model m, IMP::Particles const & ps) -> unsigned int
9048  _take_particles(Model m, IMP::Particles const & ps, TextOutput out) -> unsigned int
9049  """
9050  return _IMP_kernel._take_particles(*args)
9051 
9052 def _give_particles(m):
9053  """_give_particles(Model m) -> IMP::Particles const &"""
9054  return _IMP_kernel._give_particles(m)
9055 
9056 def _pass_particles(ps):
9057  """_pass_particles(IMP::Particles const & ps) -> IMP::Particles const &"""
9058  return _IMP_kernel._pass_particles(ps)
9059 
9060 def _pass_particle(ps):
9061  """_pass_particle(Particle ps) -> Particle"""
9062  return _IMP_kernel._pass_particle(ps)
9063 
9064 def _pass_particle_pair(pp):
9065  """_pass_particle_pair(IMP::ParticlePair const & pp) -> IMP::ParticlePair const &"""
9066  return _IMP_kernel._pass_particle_pair(pp)
9067 
9068 def _give_particles_copy(m):
9069  """_give_particles_copy(Model m) -> IMP::Particles"""
9070  return _IMP_kernel._give_particles_copy(m)
9071 
9072 def _pass_float_keys(input):
9073  """_pass_float_keys(IMP::FloatKeys const & input) -> IMP::FloatKeys"""
9074  return _IMP_kernel._pass_float_keys(input)
9075 
9076 def _pass(*args):
9077  """
9078  _pass(IMP::Particles const & p) -> IMP::Particles const
9079  _pass(IMP::Restraints const & p) -> IMP::Restraints const &
9080  """
9081  return _IMP_kernel._pass(*args)
9082 
9083 def _pass_decorators(p):
9084  """_pass_decorators(IMP::internal::_TrivialDecorators const & p) -> IMP::internal::_TrivialDecorators const &"""
9085  return _IMP_kernel._pass_decorators(p)
9086 
9087 def _pass_decorator_traits(p):
9088  """_pass_decorator_traits(IMP::internal::_TrivialTraitsDecorators const & p) -> IMP::internal::_TrivialTraitsDecorators const &"""
9089  return _IMP_kernel._pass_decorator_traits(p)
9090 
9091 def _pass_particle_pairs(p):
9092  """_pass_particle_pairs(IMP::ParticlePairsTemp const & p) -> IMP::ParticlePairsTemp"""
9093  return _IMP_kernel._pass_particle_pairs(p)
9094 
9095 def _pass_particle_index_pairs(p):
9096  """_pass_particle_index_pairs(IMP::ParticleIndexPairs const & p) -> IMP::ParticleIndexPairs"""
9097  return _IMP_kernel._pass_particle_index_pairs(p)
9098 
9099 def _pass_model_objects(p):
9100  """_pass_model_objects(IMP::ModelObjectsTemp const & p) -> IMP::ModelObjectsTemp"""
9101  return _IMP_kernel._pass_model_objects(p)
9102 
9103 def _pass_particles_temps(ps):
9104  """_pass_particles_temps(IMP::ParticlesTemps const & ps) -> IMP::ParticlesTemps"""
9105  return _IMP_kernel._pass_particles_temps(ps)
9106 
9107 def _test_overload(*args):
9108  """
9109  _test_overload(IMP::Particles const & ps) -> int
9110  _test_overload(IMP::Restraints const & ps) -> int
9111  """
9112  return _IMP_kernel._test_overload(*args)
9113 
9114 def _get_range(m, k):
9115  """_get_range(Model m, FloatKey k) -> IMP::FloatRange"""
9116  return _IMP_kernel._get_range(m, k)
9117 
9118 def _create_particles_from_pdb(name, m):
9119  """_create_particles_from_pdb(std::string name, Model m) -> IMP::ParticleIndexes"""
9120  return _IMP_kernel._create_particles_from_pdb(name, m)
9121 class _LogPairScore(PairScore):
9122  """Proxy of C++ IMP::internal::_LogPairScore class."""
9123 
9124  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
9125  __repr__ = _swig_repr
9126 
9127  def __init__(self):
9128  """__init__(IMP::internal::_LogPairScore self) -> _LogPairScore"""
9129  this = _IMP_kernel.new__LogPairScore()
9130  try:
9131  self.this.append(this)
9132  except:
9133  self.this = this
9134 
9135  def do_get_inputs(self, arg2, arg3):
9136  """do_get_inputs(_LogPairScore self, Model arg2, IMP::ParticleIndexes const & arg3) -> IMP::ModelObjectsTemp"""
9137  return _IMP_kernel._LogPairScore_do_get_inputs(self, arg2, arg3)
9138 
9139 
9140  def get_version_info(self):
9141  """get_version_info(_LogPairScore self) -> VersionInfo"""
9142  return _IMP_kernel._LogPairScore_get_version_info(self)
9143 
9144 
9145  def get_particle_pairs(self):
9146  """get_particle_pairs(_LogPairScore self) -> IMP::ParticlePairsTemp"""
9147  return _IMP_kernel._LogPairScore_get_particle_pairs(self)
9148 
9149 
9150  def clear(self):
9151  """clear(_LogPairScore self)"""
9152  return _IMP_kernel._LogPairScore_clear(self)
9153 
9154 
9155  def get_contains(self, pp):
9156  """get_contains(_LogPairScore self, IMP::ParticlePair const & pp) -> bool"""
9157  return _IMP_kernel._LogPairScore_get_contains(self, pp)
9158 
9159 _LogPairScore_swigregister = _IMP_kernel._LogPairScore_swigregister
9160 _LogPairScore_swigregister(_LogPairScore)
9161 
9162 
9163 def _overloaded_particles(*args):
9164  """
9165  _overloaded_particles(Particle arg1)
9166  _overloaded_particles(IMP::Particles const & arg1)
9167  _overloaded_particles(IMP::ParticlesTemp const & arg1)
9168  _overloaded_particles(Model arg1, IMP::ParticleIndexes const & arg2)
9169  _overloaded_particles(IMP::internal::_TrivialDecorators const & arg1)
9170  _overloaded_particles(_TrivialDecorator arg1)
9171  """
9172  return _IMP_kernel._overloaded_particles(*args)
9173 class _ImplicitParticles(object):
9174  """Proxy of C++ IMP::internal::_ImplicitParticles class."""
9175 
9176  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
9177  __repr__ = _swig_repr
9178 
9179  def __init__(self, *args):
9180  """
9181  __init__(IMP::internal::_ImplicitParticles self, Particle arg2) -> _ImplicitParticles
9182  __init__(IMP::internal::_ImplicitParticles self, IMP::Particles const & arg2) -> _ImplicitParticles
9183  __init__(IMP::internal::_ImplicitParticles self, IMP::ParticlesTemp const & arg2) -> _ImplicitParticles
9184  __init__(IMP::internal::_ImplicitParticles self, Model arg2, IMP::ParticleIndexes const & arg3) -> _ImplicitParticles
9185  __init__(IMP::internal::_ImplicitParticles self, IMP::internal::_TrivialDecorators const & arg2) -> _ImplicitParticles
9186  __init__(IMP::internal::_ImplicitParticles self, _TrivialDecorator arg2) -> _ImplicitParticles
9187  """
9188  this = _IMP_kernel.new__ImplicitParticles(*args)
9189  try:
9190  self.this.append(this)
9191  except:
9192  self.this = this
9193  __swig_destroy__ = _IMP_kernel.delete__ImplicitParticles
9194  __del__ = lambda self: None
9195 _ImplicitParticles_swigregister = _IMP_kernel._ImplicitParticles_swigregister
9196 _ImplicitParticles_swigregister(_ImplicitParticles)
9197 
9198 
9199 def _implicit_particles(arg1):
9200  """_implicit_particles(_ImplicitParticles arg1)"""
9201  return _IMP_kernel._implicit_particles(arg1)
9202 
9203 def _take_particle_adaptor(pa):
9204  """_take_particle_adaptor(_ParticleAdaptor pa) -> ParticleIndex"""
9205  return _IMP_kernel._take_particle_adaptor(pa)
9206 
9207 def _take_particle_indexes_adaptor(pa):
9208  """_take_particle_indexes_adaptor(_ParticleIndexesAdaptor pa) -> IMP::ParticleIndexes"""
9209  return _IMP_kernel._take_particle_indexes_adaptor(pa)
9210 class ScopedSetFloatAttribute(_RAII):
9211  """Proxy of C++ IMP::ScopedSetAttribute<(FloatKey,IMP::Float)> class."""
9212 
9213  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
9214 
9215  def __init__(self, *args):
9216  """
9217  __init__(IMP::ScopedSetAttribute<(FloatKey,IMP::Float)> self) -> ScopedSetFloatAttribute
9218  __init__(IMP::ScopedSetAttribute<(FloatKey,IMP::Float)> self, Particle p, FloatKey key, double const & value) -> ScopedSetFloatAttribute
9219  """
9220  this = _IMP_kernel.new_ScopedSetFloatAttribute(*args)
9221  try:
9222  self.this.append(this)
9223  except:
9224  self.this = this
9225 
9226  def set(self, p, key, value):
9227  """set(ScopedSetFloatAttribute self, Particle p, FloatKey key, double const & value)"""
9228  return _IMP_kernel.ScopedSetFloatAttribute_set(self, p, key, value)
9229 
9230 
9231  def reset(self):
9232  """reset(ScopedSetFloatAttribute self)"""
9233  return _IMP_kernel.ScopedSetFloatAttribute_reset(self)
9234 
9235  __swig_destroy__ = _IMP_kernel.delete_ScopedSetFloatAttribute
9236  __del__ = lambda self: None
9237 
9238  def show(self, *args):
9239  """
9240  show(ScopedSetFloatAttribute self, _ostream out)
9241  show(ScopedSetFloatAttribute self)
9242  """
9243  return _IMP_kernel.ScopedSetFloatAttribute_show(self, *args)
9244 
9245 
9246  def __str__(self):
9247  """__str__(ScopedSetFloatAttribute self) -> std::string"""
9248  return _IMP_kernel.ScopedSetFloatAttribute___str__(self)
9249 
9250 
9251  def __repr__(self):
9252  """__repr__(ScopedSetFloatAttribute self) -> std::string"""
9253  return _IMP_kernel.ScopedSetFloatAttribute___repr__(self)
9254 
9255 ScopedSetFloatAttribute_swigregister = _IMP_kernel.ScopedSetFloatAttribute_swigregister
9256 ScopedSetFloatAttribute_swigregister(ScopedSetFloatAttribute)
9257 
9258 
9259 #used_modules=[]
9260 #def show_used_modules():
9261 # for m in used_modules:
9262 # print "%-20s %s" % (m.get_module(), m.get_version())
9263 
9264 # Ensure that Windows gets the PATH set to include anything in the library
9265 # search path
9266 if sys.platform == 'win32' and 'IMP_LD_PATH' in os.environ:
9267  dirs = os.environ['IMP_LD_PATH'].split(":")
9268  pathcomps = os.environ['PATH'].split(";")
9269  for d in dirs:
9270  if d not in pathcomps:
9271  os.environ['PATH'] = d + ';' + os.environ['PATH']
9272 
9273 
9274 
9275 import sys
9276 import os
9277 
9278 class CommandDispatcher(object):
9279  """Allow command line tools to easily implement multiple commands.
9280  Typically, an IMP command line tool will use an instance of this class
9281  to provide a consistent interface to multiple distinct commands
9282  from a single binary, rather than providing a potentially large
9283  number of binaries. This is similar to the way a number of common
9284  command line tools outside of %IMP function (e.g. Git provides a single
9285  `git` tool which implements multiple commands - `git add`, `git commit`,
9286  `git push` and so on).
9287 
9288  Each command is implemented with a Python module of the same name
9289  that can be imported from the module (for example, if `module_name`
9290  is `IMP.foo`, the `bar` command is provided by the `IMP.foo.bar` Python
9291  module, which would usually be found as `modules/foo/pyext/src/bar.py`).
9292  Each such module should have a docstring and a `%main()` method
9293  that takes no arguments (the module should also call its `%main()` method
9294  if it is run directly, i.e. with something like
9295  `if __name__=="__main__": %main()`). The encompassing module
9296  (`IMP.foo` in the example) should define `_all_commands` as a Python
9297  list of all valid commands.
9298 
9299  See the `multifit` and `cnmultifit` command line tools for example
9300  usage.
9301  """
9302 
9303  def __init__(self, short_help, long_help, module_name):
9304  """Constructor.
9305  @param short_help A few words that describe the command line tool.
9306  @param long_help Longer text, used in the `help` command.
9307  @param module_name Name of the module (e.g. `IMP.foo`) that
9308  implements the commands.
9309  """
9310  self.short_help = short_help
9311  self.long_help = long_help
9312  self.module_name = module_name
9313  self._all_commands = self.import_module()._all_commands
9314  self._progname = os.path.basename(sys.argv[0])
9315 
9316  def main(self):
9317  """Call this method to act upon the user-provided command line"""
9318  if len(sys.argv) <= 1:
9319  print(self.short_help + " Use '%s help' for help." % self._progname)
9320  else:
9321  command = sys.argv[1]
9322  if command in ('help', '--help', '-h'):
9323  if len(sys.argv) == 3:
9324  self.show_command_help(sys.argv[2])
9325  else:
9326  self.show_help()
9327  elif command == '--version':
9328  self.show_version()
9329  elif command in self._all_commands:
9330  self.do_command(command)
9331  else:
9332  self.unknown_command(command)
9333 
9334  def import_module(self, mod=None):
9335  modname = self.module_name
9336  if mod is not None:
9337  modname += "." + mod
9338  return __import__(modname, {}, {}, [''])
9339 
9340  def unknown_command(self, command):
9341  print("Unknown command: '%s'" % command)
9342  print("Use '%s help' for help." % self._progname)
9343  sys.exit(1)
9344 
9345  def _get_version(self):
9346  return self.import_module().get_module_version()
9347 
9348  def show_version(self):
9349  print(self._progname + ' ' + self._get_version())
9350 
9351  def show_help(self):
9352  ver = self._get_version()
9353  print("%s, version %s." % (self._progname, ver))
9354  print(self.long_help + """
9355 
9356 This program is part of IMP, the Integrative Modeling Platform,
9357 which is Copyright 2007-2016 IMP Inventors.
9358 For additional information about IMP, see <https://integrativemodeling.org>.
9359 
9360 Usage: %s <command> [options] [args]
9361 
9362 Commands:""" % self._progname)
9363  commands = self._all_commands[:] + ['help']
9364  commands.sort()
9365  cmdlen = max([len(c) for c in commands])
9366  for c in commands:
9367  if c == 'help':
9368  doc = 'Get help on using %s.' % self._progname
9369  else:
9370  doc = self.import_module(c).__doc__ or "<no help>"
9371  c += ' ' * (cmdlen - len(c))
9372  print(' ' + c + ' ' + doc)
9373  print("""
9374 Use "%s help <command>" for detailed help on any command
9375  or "%s --version" to see the version number.""" % (self._progname,
9376  self._progname))
9377 
9378  def do_command(self, command):
9379  mod = self.import_module(command)
9380  sys.argv[0] = self._progname + ' ' + command
9381  del sys.argv[1]
9382  mod.main()
9383 
9384  def show_command_help(self, command):
9385  if command == 'help':
9386  self.show_help()
9387  elif command in self._all_commands or command == 'help':
9388  mod = self.import_module(command)
9389  sys.argv = [self._progname + ' ' + command, '--help']
9390  mod.main()
9391  else:
9392  self.unknown_command(command)
9393 
9394 
9395 
9396 
9397 import optparse
9398 import sys
9399 
9400 class OptionParser(optparse.OptionParser):
9401  """IMP-specific subclass of optparse.OptionParser.
9402  This adds options common to all IMP applications
9403  (see IMP::setup_from_argv()).
9404  """
9405 
9406  _use_boost_parser = True
9407 
9408  def __init__(self, *args, **kwargs):
9409 # Don't add --help or --version options (since the Boost
9410 # option parser handles those)
9411  kwargs['add_help_option'] = False
9412  kwargs['version'] = None
9413 # Handle old users of IMP.OptionParser that set imp_module
9414  if 'imp_module' in kwargs:
9415  del kwargs['imp_module']
9416  try:
9417  optparse.OptionParser.__init__(self, *args, **kwargs)
9418  except TypeError:
9419  if 'epilog' in kwargs:
9420 # Older optparse doesn't support the epilog keyword
9421  del kwargs['epilog']
9422  optparse.OptionParser.__init__(self, *args, **kwargs)
9423  else:
9424  raise
9425 
9426 # Don't complain if invalid options are encountered; pass them through
9427 # unmodified
9428  def _process_long_opt(self, rargs, values):
9429  if self._use_boost_parser:
9430  try:
9431  optparse.OptionParser._process_long_opt(self, rargs, values)
9432  except optparse.BadOptionError as err:
9433  if not hasattr(err, 'opt_str') \
9434  and err.msg.startswith('no such option:'):
9435  self.largs.append(err.msg[16:])
9436  else:
9437  self.largs.append(err.opt_str)
9438  else:
9439  optparse.OptionParser._process_long_opt(self, rargs, values)
9440  def _process_short_opts(self, rargs, values):
9441  if self._use_boost_parser:
9442  try:
9443  optparse.OptionParser._process_short_opts(self, rargs, values)
9444  except optparse.BadOptionError as err:
9445  self.largs.append(err.opt_str)
9446  else:
9447  optparse.OptionParser._process_short_opts(self, rargs, values)
9448 
9449  def _process_args(self, largs, rargs, values):
9450  if self._use_boost_parser:
9451 # If the special argument -- is present, preserve it (by default
9452 # optparse will remove it). Otherwise, the Boost option parser will
9453 # not treat positional arguments after -- correctly.
9454  try:
9455  dashdash = rargs.index('--')
9456  except ValueError:
9457  dashdash = len(rargs)
9458  saved_args = rargs[dashdash:]
9459  del rargs[dashdash:]
9460  optparse.OptionParser._process_args(self, largs, rargs, values)
9461  rargs.extend(saved_args)
9462  else:
9463  optparse.OptionParser._process_args(self, largs, rargs, values)
9464 
9465  def parse_args(self, num_positional=None):
9466  """Parse the command line and return options and positional arguments.
9467  This functions in the same way as the method in the base class
9468  optparse.OptionParser, except that it also processes options common
9469  to all IMP applications (these are not returned in opts, but can be
9470  obtained in the usual way, e.g. by calling
9471  IMP::get_string_flag()).
9472  @param[in] num_positional If a positive integer, exactly that
9473  many positional arguments must be specified on the
9474  command line; if a negative integer, that many or
9475  more must be given; if None, any number of positional
9476  arguments can be given.
9477  @returns opts, args
9478  """
9479 # First, parse the command line with optparse
9480  opts, args = optparse.OptionParser.parse_args(self)
9481  if not self._use_boost_parser:
9482  return opts, args
9483  orig_desc = self.description
9484  orig_usage = self.usage
9485  if self.usage:
9486  usage = self.usage.replace('%prog ', '')
9487  else:
9488  usage = ''
9489  if num_positional is None:
9490 # If num_positional was not specified, prevent the Boost parser
9491 # from complaining about the number of positional arguments
9492  numpos = -1
9493  args.append('dummy')
9494  else:
9495  numpos = num_positional
9496  try:
9497  self.usage = self.description = None
9498 # Pass the rest of the command line to the Boost parser; add the
9499 # optparse-generated help to that from Boost
9500  args = setup_from_argv([sys.argv[0]] + args,
9501  self.format_help() \
9502  + "\nOptions common to all IMP applications:",
9503  usage, numpos)
9504  finally:
9505  self.description = orig_desc
9506  self.usage = orig_usage
9507  if num_positional is None:
9508  args.pop()
9509  return opts, args
9510 
9511 
9512 
9513 def get_networkx_graph(ig):
9514  import networkx
9515  g = networkx.DiGraph()
9516  if len(ig.get_vertices()) == 0:
9517  return g
9518 
9519  class NodeWrapper:
9520 
9521  def __init__(self, p):
9522  self.p = p
9523 
9524  def __str__(self):
9525  return self.p.get_name()
9526 
9527  def __call__(self, name):
9528  return self.p.__call__(name)
9529 
9530  for vi in ig.get_vertices():
9531  n = ig.get_vertex_name(vi)
9532  g.add_node(NodeWrapper(n))
9533  for vi in ig.get_vertices():
9534  n = ig.get_vertex_name(vi)
9535  for ni in ig.get_out_neighbors(vi):
9536  nn = ig.get_vertex_name(ni)
9537  g.add_edge(NodeWrapper(n), NodeWrapper(nn))
9538  return g
9539 
9540 
9541 def show_altgraph(g):
9542  def clean(name):
9543  try:
9544  n0 = name.get_name()
9545  except:
9546  n0 = str(name)
9547  n1 = str(n0).replace('"', '')
9548  n2 = n1.replace("\n", '')
9549  return n2
9550  import altgraph
9551  from altgraph import Graph, Dot
9552  graph = Graph.Graph()
9553  for i, v in enumerate(g.get_vertices()):
9554  graph.add_node(i) # , node_data=g.get_vertex_name(v)
9555  for i, v in enumerate(g.get_vertices()):
9556  for n in g.get_out_neighbors(v):
9557  graph.add_edge(v, n)
9558  dot = Dot.Dot(graph) # , graph_type="digraph"
9559  for i, v in enumerate(g.get_vertices()):
9560  dot.node_style(i, label=clean(g.get_vertex_name(v)))
9561  dot.display()
9562 
9563 
9564 def show_graphviz(g):
9565  tfn = create_temporary_file_name("graph", ".dot")
9566  tfon = create_temporary_file_name("graph", ".pdf")
9567  st = g.get_graphviz_string()
9568  open(tfn, "w").write(st)
9569  try:
9570  import subprocess
9571  except ImportError:
9572  import sys
9573  sys.stderr.write("Cannot run dot on Python 2.3 systems.\n")
9574  return
9575  try:
9576  print("running dot")
9577  sp = subprocess.Popen(["dot", "-Tpdf", tfn, "-o" + tfon])
9578  sp.wait()
9579  except:
9580  import sys
9581  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")
9582  return
9583  import platform
9584  if platform.system() == "Darwin":
9585  cmd = ["open"]
9586  else:
9587  cmd = ["gv", "acroread", "xpdf"]
9588  success = False
9589  for c in cmd:
9590  print("launching viewer " + c)
9591  try:
9592  subprocess.check_call([c, tfon])
9593  success = True
9594  break
9595  except:
9596  pass
9597  if not success:
9598  print("Could not display file. It is saved at " + tfon)
9599  return tfon
9600 
9601 
9602 
9603 
9604 import functools
9605 import contextlib
9606 
9607 def deprecated_module(version, module, help_message):
9608  """Mark a Python module as deprecated.
9609  @note The `module` argument would normally be `__name__`.
9610  @see [deprecation support](@ref deprecation)."""
9612  "Module %s is deprecated. %s\n" % (module, help_message))
9613 
9614 def deprecated_object(version, help_message):
9615  """Python decorator to mark a class as deprecated.
9616  @see [deprecation support](@ref deprecation)."""
9617  def wrapper(obj):
9618  orig_init = obj.__init__
9619 # Don't try to copy __module__ since __init__ may not have it
9620 # (e.g. if we subclassed object but didn't override __init__)
9621  @functools.wraps(orig_init, ('__name__', '__doc__'))
9622  def __init__(obj, *args, **keys):
9623  handle_use_deprecated("Object %s is deprecated. %s\n"
9624  % (type(obj), help_message))
9625  orig_init(obj, *args, **keys)
9626  obj.__init__ = __init__
9627  return obj
9628  return wrapper
9629 
9630 def deprecated_method(version, help_message):
9631  """Python decorator to mark a method as deprecated.
9632  @see [deprecation support](@ref deprecation)."""
9633  def out_wrapper(obj):
9634  @functools.wraps(obj)
9635  def wrapper(cls, *args, **keys):
9636  handle_use_deprecated("Method %s in %s is deprecated. %s\n"
9637  % (obj.__name__, type(cls), help_message))
9638  return obj(cls, *args, **keys)
9639  return wrapper
9640  return out_wrapper
9641 
9642 def deprecated_function(version, help_message):
9643  """Python decorator to mark a function as deprecated.
9644  @see [deprecation support](@ref deprecation)."""
9645  def out_wrapper(obj):
9646  @functools.wraps(obj)
9647  def wrapper(*args, **keys):
9648  handle_use_deprecated("Function %s is deprecated. %s\n"
9649  % (obj.__name__, help_message))
9650  return obj(*args, **keys)
9651  return wrapper
9652  return out_wrapper
9653 
9654 @contextlib.contextmanager
9655 def allow_deprecated(allow=True):
9656  """Context manager to temporarily allow (or disallow) deprecated code.
9657  @see [deprecation support](@ref deprecation)."""
9659  set_deprecation_exceptions(not allow)
9660  yield
9662 
9663 class RandomNumberGenerator(object):
9664  """Proxy of C++ IMP::RandomNumberGenerator class."""
9665 
9666  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
9667  __repr__ = _swig_repr
9668 
9669  def seed(self, x):
9670  """seed(RandomNumberGenerator self, ::boost::int32_t x)"""
9671  return _IMP_kernel.RandomNumberGenerator_seed(self, x)
9672 
9673 
9674  def __call__(self):
9675  """__call__(RandomNumberGenerator self) -> int"""
9676  return _IMP_kernel.RandomNumberGenerator___call__(self)
9677 
9678 
9679  def __init__(self):
9680  """__init__(IMP::RandomNumberGenerator self) -> RandomNumberGenerator"""
9681  this = _IMP_kernel.new_RandomNumberGenerator()
9682  try:
9683  self.this.append(this)
9684  except:
9685  self.this = this
9686  __swig_destroy__ = _IMP_kernel.delete_RandomNumberGenerator
9687  __del__ = lambda self: None
9688 RandomNumberGenerator_swigregister = _IMP_kernel.RandomNumberGenerator_swigregister
9689 RandomNumberGenerator_swigregister(RandomNumberGenerator)
9690 
9691 
9692 def get_random_float_uniform(*args):
9693  """
9694  get_random_float_uniform() -> float
9695  get_random_float_uniform(float min, float max) -> float
9696  """
9697  return _IMP_kernel.get_random_float_uniform(*args)
9698 
9699 def get_random_double_uniform(*args):
9700  """
9701  get_random_double_uniform() -> double
9702  get_random_double_uniform(double min, double max) -> double
9703  """
9704  return _IMP_kernel.get_random_double_uniform(*args)
9705 
9706 def get_random_floats_normal(n, mean=0.0, stddev=1.0):
9707  """
9708  get_random_floats_normal(unsigned int n, float mean=0.0, float stddev=1.0) -> IMP::Vector< float >
9709  get_random_floats_normal(unsigned int n, float mean=0.0) -> IMP::Vector< float >
9710  get_random_floats_normal(unsigned int n) -> IMP::Vector< float >
9711  """
9712  return _IMP_kernel.get_random_floats_normal(n, mean, stddev)
9713 
9714 def get_random_doubles_normal(n, mean=0.0, stddev=1.0):
9715  """
9716  get_random_doubles_normal(unsigned int n, double mean=0.0, double stddev=1.0) -> IMP::Vector< double >
9717  get_random_doubles_normal(unsigned int n, double mean=0.0) -> IMP::Vector< double >
9718  get_random_doubles_normal(unsigned int n) -> IMP::Vector< double >
9719  """
9720  return _IMP_kernel.get_random_doubles_normal(n, mean, stddev)
9721 
9722 def get_random_floats_uniform(n):
9723  """get_random_floats_uniform(unsigned int n) -> IMP::Vector< float >"""
9724  return _IMP_kernel.get_random_floats_uniform(n)
9725 
9726 def get_random_doubles_uniform(n):
9727  """get_random_doubles_uniform(unsigned int n) -> IMP::Vector< double >"""
9728  return _IMP_kernel.get_random_doubles_uniform(n)
9729 
9730 def get_random_seed():
9731  """get_random_seed() -> boost::uint64_t"""
9732  return _IMP_kernel.get_random_seed()
9733 
9734 def get_module_version():
9735  """get_module_version() -> std::string const"""
9736  return _IMP_kernel.get_module_version()
9737 
9738 def get_example_path(fname):
9739  """get_example_path(std::string fname) -> std::string"""
9740  return _IMP_kernel.get_example_path(fname)
9741 
9742 def get_data_path(fname):
9743  """get_data_path(std::string fname) -> std::string"""
9744  return _IMP_kernel.get_data_path(fname)
9745 
9746 from . import _version_check
9747 _version_check.check_version(get_module_version())
9748 __version__ = get_module_version()
9749 
9750 
9751 random_number_generator = cvar.random_number_generator
9752 
Key< 4, true > ObjectKey
The type used to identify an Object attribute.
Definition: base_types.h:48
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:9278
CheckLevel get_check_level()
Get the current audit mode.
Definition: exception.h:81
bool get_is_quick_test()
Definition: flags.h:178
def allow_deprecated
Context manager to temporarily allow (or disallow) deprecated code.
Definition: __init__.py:9654
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
void show_timings(TextOutput out)
Show all captured timings.
def main
Call this method to act upon the user-provided command line.
Definition: __init__.py:9316
boost::graph DependencyGraph
A directed graph on the interactions between the various objects in the model.
ContainersTemp get_input_containers(const ModelObjectsTemp &mos)
Return all the input particles for a given ModelObject.
ParticlesTemp get_dependent_particles(ModelObject *p, const ModelObjectsTemp &all, const DependencyGraph &dg, const DependencyGraphVertexIndex &index)
def deprecated_module
Mark a Python module as deprecated.
Definition: __init__.py:9607
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
Key< 8, true > ModelKey
The type used to identify data stored directly in the model.
Definition: base_types.h:74
Array< 4, WeakPointer< Particle >, Particle * > ParticleQuad
Definition: base_types.h:144
bool get_bool_flag(std::string name)
void handle_use_deprecated(std::string message)
void set_progress_display(std::string description, unsigned int steps)
Set up the progress bar with the passed description.
def deprecated_function
Python decorator to mark a function as deprecated.
Definition: __init__.py:9642
def parse_args
Parse the command line and return options and positional arguments.
Definition: __init__.py:9465
Index< ParticleIndexTag > ParticleIndex
Definition: base_types.h:154
ParticlesTemp get_particles(Model *m, const ParticleIndexes &ps)
Array< 3, WeakPointer< Particle >, Particle * > ParticleTriplet
Definition: base_types.h:141
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.
IMP-specific subclass of optparse.OptionParser.
Definition: __init__.py:9400
ScoringFunction * create_scoring_function(RestraintType *rs, double weight=1.0, double max=NO_MAX, std::string name=std::string())
Definition: generic.h:23
void clear_statistics()
Reset all the statistics for IMP.
Key< 1, true > IntKey
The type used to identify int attributes in the Particles.
Definition: base_types.h:36
void write_help(std::ostream &out=std::cerr)
size_t get_int_flag(std::string name)
void add_restraint(RMF::FileHandle fh, Restraint *hs)
ScoreStatesTemp get_required_score_states(ModelObject *p, const ModelObjectsTemp &all, const DependencyGraph &dg, const DependencyGraphVertexIndex &index)
boost::uint64_t get_random_seed()
Return the initial random seed.
Strings get_live_object_names()
Return the names of all live objects.
void add_to_progress_display(unsigned int step=1)
Set the current progress.
void add_float_flag(std::string name, double default_value, std::string description)
Ints get_index(const ParticlesTemp &particles, const Subset &subset, const Subsets &excluded)
def deprecated_method
Python decorator to mark a method as deprecated.
Definition: __init__.py:9630
void reset_log_timer()
Reset the log timer.
void add_restraints(RMF::FileHandle fh, const Restraints &hs)
void add_to_log(LogLevel level, std::string to_write)
Write a string to the log, for Python.
Key< 3, true > ParticleIndexKey
The type used to identify a particle attribute in the Particles.
Definition: base_types.h:44
Version and module information for Objects.
Definition: VersionInfo.h:28
Key< 0, true > FloatKey
The type used to identify float attributes in the Particles.
Definition: base_types.h:32
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.
std::ostream & show(Hierarchy h, std::ostream &out=std::cout)
Print the hierarchy using a given decorator to display each node.
std::string get_executable_name()
Return the name of the current executable.
void set_log_level(LogLevel l)
Set the current global log level.
unsigned int get_number_of_threads()
float get_random_float_uniform()
Return a uniformly distributed float number in range [0..1)
Definition: random_utils.h:117
def deprecated_object
Python decorator to mark a class as deprecated.
Definition: __init__.py:9614
ParticlesTemp get_input_particles(const ModelObjectsTemp &mos)
Return all the input particles for a given ModelObject.
Key< 6, true > ParticleIndexesKey
The type used to identify a particle attribute in the Particles.
Definition: base_types.h:60
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.
void set_statistics_level(StatisticsLevel l)
Set the level of statistics to be gathered.
Array< 2, WeakPointer< Particle >, Particle * > ParticlePair
Definition: base_types.h:135
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:9303
double get_random_double_uniform()
Return a uniformly distributed double number in range [0..1)
Definition: random_utils.h:149
Key< 2, true > StringKey
The type used to identify string attributes in the Particles.
Definition: base_types.h:40
void show_altgraph(Graph g)
void setup_from_argv(int argc, char **argv, std::string description)
Parse the command line flags and return the positional arguments.
void add_bool_flag(std::string name, std::string description)
ParticleIndexes get_indexes(const ParticlesTemp &ps)
void read_particles_from_buffer(const Vector< char > &buffer, const ParticlesTemp &particles, const FloatKeys &keys)
load found attributes into the particles
void set_number_of_threads(unsigned int n)
double get_float_flag(std::string name)
void set_check_level(CheckLevel tf)
Control runtime checks in the code.
Definition: exception.h:73
ScoreStatesTemp get_update_order(ScoreStatesTemp input)
std::string create_temporary_file_name(std::string prefix="imp_temp", std::string suffix="")
Create a temporary file.