9 from sys
import version_info
10 if version_info >= (2,6,0):
11 def swig_import_helper():
12 from os.path
import dirname
16 fp, pathname, description = imp.find_module(
'_IMP_domino', [dirname(__file__)])
22 _mod = imp.load_module(
'_IMP_domino', fp, pathname, description)
26 _IMP_domino = swig_import_helper()
27 del swig_import_helper
32 _swig_property = property
35 def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
36 if (name ==
"thisown"):
return self.this.own(value)
38 if type(value).__name__ ==
'SwigPyObject':
39 self.__dict__[name] = value
41 method = class_type.__swig_setmethods__.get(name,
None)
42 if method:
return method(self,value)
44 self.__dict__[name] = value
46 raise AttributeError(
"You cannot add attributes to %s" % self)
48 def _swig_setattr(self,class_type,name,value):
49 return _swig_setattr_nondynamic(self,class_type,name,value,0)
51 def _swig_getattr(self,class_type,name):
52 if (name ==
"thisown"):
return self.this.own()
53 method = class_type.__swig_getmethods__.get(name,
None)
54 if method:
return method(self)
55 raise AttributeError(name)
58 try: strthis =
"proxy of " + self.this.__repr__()
60 return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
65 except AttributeError:
72 weakref_proxy = weakref.proxy
74 weakref_proxy =
lambda x: x
77 class IMP_DOMINO_SwigPyIterator(_object):
78 """Proxy of C++ swig::IMP_DOMINO_SwigPyIterator class"""
79 __swig_setmethods__ = {}
80 __setattr__ =
lambda self, name, value: _swig_setattr(self, IMP_DOMINO_SwigPyIterator, name, value)
81 __swig_getmethods__ = {}
82 __getattr__ =
lambda self, name: _swig_getattr(self, IMP_DOMINO_SwigPyIterator, name)
83 def __init__(self, *args, **kwargs):
raise AttributeError(
"No constructor defined - class is abstract")
85 __swig_destroy__ = _IMP_domino.delete_IMP_DOMINO_SwigPyIterator
86 __del__ =
lambda self :
None;
88 """value(IMP_DOMINO_SwigPyIterator self) -> PyObject *"""
89 return _IMP_domino.IMP_DOMINO_SwigPyIterator_value(self)
93 incr(IMP_DOMINO_SwigPyIterator self, size_t n=1) -> IMP_DOMINO_SwigPyIterator
94 incr(IMP_DOMINO_SwigPyIterator self) -> IMP_DOMINO_SwigPyIterator
96 return _IMP_domino.IMP_DOMINO_SwigPyIterator_incr(self, n)
100 decr(IMP_DOMINO_SwigPyIterator self, size_t n=1) -> IMP_DOMINO_SwigPyIterator
101 decr(IMP_DOMINO_SwigPyIterator self) -> IMP_DOMINO_SwigPyIterator
103 return _IMP_domino.IMP_DOMINO_SwigPyIterator_decr(self, n)
105 def distance(self, *args):
106 """distance(IMP_DOMINO_SwigPyIterator self, IMP_DOMINO_SwigPyIterator x) -> ptrdiff_t"""
107 return _IMP_domino.IMP_DOMINO_SwigPyIterator_distance(self, *args)
109 def equal(self, *args):
110 """equal(IMP_DOMINO_SwigPyIterator self, IMP_DOMINO_SwigPyIterator x) -> bool"""
111 return _IMP_domino.IMP_DOMINO_SwigPyIterator_equal(self, *args)
114 """copy(IMP_DOMINO_SwigPyIterator self) -> IMP_DOMINO_SwigPyIterator"""
115 return _IMP_domino.IMP_DOMINO_SwigPyIterator_copy(self)
118 """next(IMP_DOMINO_SwigPyIterator self) -> PyObject *"""
119 return _IMP_domino.IMP_DOMINO_SwigPyIterator_next(self)
122 """__next__(IMP_DOMINO_SwigPyIterator self) -> PyObject *"""
123 return _IMP_domino.IMP_DOMINO_SwigPyIterator___next__(self)
126 """previous(IMP_DOMINO_SwigPyIterator self) -> PyObject *"""
127 return _IMP_domino.IMP_DOMINO_SwigPyIterator_previous(self)
129 def advance(self, *args):
130 """advance(IMP_DOMINO_SwigPyIterator self, ptrdiff_t n) -> IMP_DOMINO_SwigPyIterator"""
131 return _IMP_domino.IMP_DOMINO_SwigPyIterator_advance(self, *args)
133 def __eq__(self, *args):
134 """__eq__(IMP_DOMINO_SwigPyIterator self, IMP_DOMINO_SwigPyIterator x) -> bool"""
135 return _IMP_domino.IMP_DOMINO_SwigPyIterator___eq__(self, *args)
137 def __ne__(self, *args):
138 """__ne__(IMP_DOMINO_SwigPyIterator self, IMP_DOMINO_SwigPyIterator x) -> bool"""
139 return _IMP_domino.IMP_DOMINO_SwigPyIterator___ne__(self, *args)
141 def __iadd__(self, *args):
142 """__iadd__(IMP_DOMINO_SwigPyIterator self, ptrdiff_t n) -> IMP_DOMINO_SwigPyIterator"""
143 return _IMP_domino.IMP_DOMINO_SwigPyIterator___iadd__(self, *args)
145 def __isub__(self, *args):
146 """__isub__(IMP_DOMINO_SwigPyIterator self, ptrdiff_t n) -> IMP_DOMINO_SwigPyIterator"""
147 return _IMP_domino.IMP_DOMINO_SwigPyIterator___isub__(self, *args)
149 def __add__(self, *args):
150 """__add__(IMP_DOMINO_SwigPyIterator self, ptrdiff_t n) -> IMP_DOMINO_SwigPyIterator"""
151 return _IMP_domino.IMP_DOMINO_SwigPyIterator___add__(self, *args)
153 def __sub__(self, *args):
155 __sub__(IMP_DOMINO_SwigPyIterator self, ptrdiff_t n) -> IMP_DOMINO_SwigPyIterator
156 __sub__(IMP_DOMINO_SwigPyIterator self, IMP_DOMINO_SwigPyIterator x) -> ptrdiff_t
158 return _IMP_domino.IMP_DOMINO_SwigPyIterator___sub__(self, *args)
160 def __iter__(self):
return self
161 IMP_DOMINO_SwigPyIterator_swigregister = _IMP_domino.IMP_DOMINO_SwigPyIterator_swigregister
162 IMP_DOMINO_SwigPyIterator_swigregister(IMP_DOMINO_SwigPyIterator)
169 IMP_HAS_DEPRECATED = _IMP_domino.IMP_HAS_DEPRECATED
170 IMP_DEBUG = _IMP_domino.IMP_DEBUG
171 IMP_RELEASE = _IMP_domino.IMP_RELEASE
172 IMP_SILENT = _IMP_domino.IMP_SILENT
173 IMP_PROGRESS = _IMP_domino.IMP_PROGRESS
174 IMP_TERSE = _IMP_domino.IMP_TERSE
175 IMP_VERBOSE = _IMP_domino.IMP_VERBOSE
176 IMP_NONE = _IMP_domino.IMP_NONE
177 IMP_USAGE = _IMP_domino.IMP_USAGE
178 IMP_INTERNAL = _IMP_domino.IMP_INTERNAL
179 IMP_COMPILER_HAS_AUTO = _IMP_domino.IMP_COMPILER_HAS_AUTO
180 IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_domino.IMP_COMPILER_HAS_DEBUG_VECTOR
181 IMP_COMPILER_HAS_NULLPTR = _IMP_domino.IMP_COMPILER_HAS_NULLPTR
182 IMP_BASE_HAS_BOOST_RANDOM = _IMP_domino.IMP_BASE_HAS_BOOST_RANDOM
183 IMP_BASE_HAS_GPERFTOOLS = _IMP_domino.IMP_BASE_HAS_GPERFTOOLS
184 IMP_BASE_HAS_LOG4CXX = _IMP_domino.IMP_BASE_HAS_LOG4CXX
185 IMP_BASE_HAS_TCMALLOC_HEAPCHECKER = _IMP_domino.IMP_BASE_HAS_TCMALLOC_HEAPCHECKER
186 IMP_BASE_HAS_TCMALLOC_HEAPPROFILER = _IMP_domino.IMP_BASE_HAS_TCMALLOC_HEAPPROFILER
188 class _DirectorObjects(object):
189 """@internal Simple class to keep references to director objects
190 to prevent premature deletion."""
193 def register(self, obj):
194 """Take a reference to a director object; will only work for
195 refcounted C++ classes"""
196 if hasattr(obj,
'get_ref_count'):
197 self._objects.append(obj)
199 """Only drop our reference and allow cleanup by Python if no other
200 Python references exist (we hold 3 references: one in self._objects,
201 one in x, and one in the argument list for getrefcount) *and* no
202 other C++ references exist (the Python object always holds one)"""
203 objs = [x
for x
in self._objects
if sys.getrefcount(x) > 3 \
204 or x.get_ref_count() > 1]
208 def get_object_count(self):
209 """Get number of director objects (useful for testing only)"""
210 return len(self._objects)
211 _director_objects = _DirectorObjects()
213 DEFAULT_CHECK = _IMP_domino.DEFAULT_CHECK
214 NONE = _IMP_domino.NONE
215 USAGE = _IMP_domino.USAGE
216 USAGE_AND_INTERNAL = _IMP_domino.USAGE_AND_INTERNAL
219 """set_check_level(IMP::base::CheckLevel tf)"""
220 return _IMP_domino.set_check_level(*args)
223 """get_check_level() -> IMP::base::CheckLevel"""
224 return _IMP_domino.get_check_level()
225 class _ostream(_object):
226 """Proxy of C++ std::ostream class"""
227 __swig_setmethods__ = {}
228 __setattr__ =
lambda self, name, value: _swig_setattr(self, _ostream, name, value)
229 __swig_getmethods__ = {}
230 __getattr__ =
lambda self, name: _swig_getattr(self, _ostream, name)
231 def __init__(self, *args, **kwargs):
raise AttributeError(
"No constructor defined")
232 __repr__ = _swig_repr
233 def write(self, *args):
234 """write(_ostream self, char const * osa_buf)"""
235 return _IMP_domino._ostream_write(self, *args)
237 _ostream_swigregister = _IMP_domino._ostream_swigregister
238 _ostream_swigregister(_ostream)
240 IMP_COMPILER_HAS_OVERRIDE = _IMP_domino.IMP_COMPILER_HAS_OVERRIDE
241 IMP_COMPILER_HAS_FINAL = _IMP_domino.IMP_COMPILER_HAS_FINAL
243 IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_domino.IMP_CGAL_HAS_BOOST_FILESYSTEM
244 IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_domino.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS
245 IMP_CGAL_HAS_BOOST_RANDOM = _IMP_domino.IMP_CGAL_HAS_BOOST_RANDOM
246 IMP_CGAL_HAS_BOOST_SYSTEM = _IMP_domino.IMP_CGAL_HAS_BOOST_SYSTEM
248 IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_domino.IMP_ALGEBRA_HAS_IMP_CGAL
249 IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_domino.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM
250 IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_domino.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS
251 IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_domino.IMP_ALGEBRA_HAS_BOOST_RANDOM
252 IMP_ALGEBRA_HAS_BOOST_SYSTEM = _IMP_domino.IMP_ALGEBRA_HAS_BOOST_SYSTEM
253 IMP_ALGEBRA_HAS_CGAL = _IMP_domino.IMP_ALGEBRA_HAS_CGAL
254 IMP_ALGEBRA_HAS_ANN = _IMP_domino.IMP_ALGEBRA_HAS_ANN
256 IMP_KERNEL_HAS_IMP_CGAL = _IMP_domino.IMP_KERNEL_HAS_IMP_CGAL
257 IMP_KERNEL_HAS_BOOST_PROGRAMOPTIONS = _IMP_domino.IMP_KERNEL_HAS_BOOST_PROGRAMOPTIONS
258 IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_domino.IMP_KERNEL_HAS_BOOST_RANDOM
259 IMP_KERNEL_HAS_BOOST_SYSTEM = _IMP_domino.IMP_KERNEL_HAS_BOOST_SYSTEM
260 IMP_KERNEL_HAS_CGAL = _IMP_domino.IMP_KERNEL_HAS_CGAL
262 IMP_DISPLAY_HAS_IMP_BASE = _IMP_domino.IMP_DISPLAY_HAS_IMP_BASE
263 IMP_DISPLAY_HAS_IMP_CGAL = _IMP_domino.IMP_DISPLAY_HAS_IMP_CGAL
264 IMP_DISPLAY_HAS_BOOST_FILESYSTEM = _IMP_domino.IMP_DISPLAY_HAS_BOOST_FILESYSTEM
265 IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS = _IMP_domino.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS
266 IMP_DISPLAY_HAS_BOOST_RANDOM = _IMP_domino.IMP_DISPLAY_HAS_BOOST_RANDOM
267 IMP_DISPLAY_HAS_BOOST_SYSTEM = _IMP_domino.IMP_DISPLAY_HAS_BOOST_SYSTEM
268 IMP_DISPLAY_HAS_CGAL = _IMP_domino.IMP_DISPLAY_HAS_CGAL
270 IMP_SCORE_FUNCTOR_HAS_IMP_CGAL = _IMP_domino.IMP_SCORE_FUNCTOR_HAS_IMP_CGAL
271 IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM = _IMP_domino.IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM
272 IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS = _IMP_domino.IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS
273 IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM = _IMP_domino.IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM
274 IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM = _IMP_domino.IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM
275 IMP_SCORE_FUNCTOR_HAS_CGAL = _IMP_domino.IMP_SCORE_FUNCTOR_HAS_CGAL
277 IMP_STATISTICS_HAS_IMP_BASE = _IMP_domino.IMP_STATISTICS_HAS_IMP_BASE
278 IMP_STATISTICS_HAS_IMP_CGAL = _IMP_domino.IMP_STATISTICS_HAS_IMP_CGAL
279 IMP_STATISTICS_HAS_BOOST_FILESYSTEM = _IMP_domino.IMP_STATISTICS_HAS_BOOST_FILESYSTEM
280 IMP_STATISTICS_HAS_BOOST_PROGRAMOPTIONS = _IMP_domino.IMP_STATISTICS_HAS_BOOST_PROGRAMOPTIONS
281 IMP_STATISTICS_HAS_BOOST_RANDOM = _IMP_domino.IMP_STATISTICS_HAS_BOOST_RANDOM
282 IMP_STATISTICS_HAS_BOOST_SYSTEM = _IMP_domino.IMP_STATISTICS_HAS_BOOST_SYSTEM
283 IMP_STATISTICS_HAS_CGAL = _IMP_domino.IMP_STATISTICS_HAS_CGAL
285 IMP_CORE_HAS_IMP_BASE = _IMP_domino.IMP_CORE_HAS_IMP_BASE
286 IMP_CORE_HAS_IMP_CGAL = _IMP_domino.IMP_CORE_HAS_IMP_CGAL
287 IMP_CORE_HAS_IMP_KERNEL = _IMP_domino.IMP_CORE_HAS_IMP_KERNEL
288 IMP_CORE_HAS_BOOST_FILESYSTEM = _IMP_domino.IMP_CORE_HAS_BOOST_FILESYSTEM
289 IMP_CORE_HAS_BOOST_PROGRAMOPTIONS = _IMP_domino.IMP_CORE_HAS_BOOST_PROGRAMOPTIONS
290 IMP_CORE_HAS_BOOST_RANDOM = _IMP_domino.IMP_CORE_HAS_BOOST_RANDOM
291 IMP_CORE_HAS_BOOST_SYSTEM = _IMP_domino.IMP_CORE_HAS_BOOST_SYSTEM
292 IMP_CORE_HAS_CGAL = _IMP_domino.IMP_CORE_HAS_CGAL
294 IMP_CONTAINER_HAS_IMP_ALGEBRA = _IMP_domino.IMP_CONTAINER_HAS_IMP_ALGEBRA
295 IMP_CONTAINER_HAS_IMP_BASE = _IMP_domino.IMP_CONTAINER_HAS_IMP_BASE
296 IMP_CONTAINER_HAS_IMP_CGAL = _IMP_domino.IMP_CONTAINER_HAS_IMP_CGAL
297 IMP_CONTAINER_HAS_IMP_DISPLAY = _IMP_domino.IMP_CONTAINER_HAS_IMP_DISPLAY
298 IMP_CONTAINER_HAS_IMP_KERNEL = _IMP_domino.IMP_CONTAINER_HAS_IMP_KERNEL
299 IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR = _IMP_domino.IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR
300 IMP_CONTAINER_HAS_BOOST_FILESYSTEM = _IMP_domino.IMP_CONTAINER_HAS_BOOST_FILESYSTEM
301 IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS = _IMP_domino.IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS
302 IMP_CONTAINER_HAS_BOOST_RANDOM = _IMP_domino.IMP_CONTAINER_HAS_BOOST_RANDOM
303 IMP_CONTAINER_HAS_BOOST_SYSTEM = _IMP_domino.IMP_CONTAINER_HAS_BOOST_SYSTEM
304 IMP_CONTAINER_HAS_CGAL = _IMP_domino.IMP_CONTAINER_HAS_CGAL
306 IMP_ATOM_HAS_IMP_BASE = _IMP_domino.IMP_ATOM_HAS_IMP_BASE
307 IMP_ATOM_HAS_IMP_CGAL = _IMP_domino.IMP_ATOM_HAS_IMP_CGAL
308 IMP_ATOM_HAS_IMP_KERNEL = _IMP_domino.IMP_ATOM_HAS_IMP_KERNEL
309 IMP_ATOM_HAS_IMP_SCORE_FUNCTOR = _IMP_domino.IMP_ATOM_HAS_IMP_SCORE_FUNCTOR
310 IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS = _IMP_domino.IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS
311 IMP_ATOM_HAS_BOOST_RANDOM = _IMP_domino.IMP_ATOM_HAS_BOOST_RANDOM
312 IMP_ATOM_HAS_BOOST_REGEX = _IMP_domino.IMP_ATOM_HAS_BOOST_REGEX
313 IMP_ATOM_HAS_BOOST_SYSTEM = _IMP_domino.IMP_ATOM_HAS_BOOST_SYSTEM
314 IMP_ATOM_HAS_CGAL = _IMP_domino.IMP_ATOM_HAS_CGAL
315 IMP_ATOM_TYPE_INDEX = _IMP_domino.IMP_ATOM_TYPE_INDEX
316 IMP_RESIDUE_TYPE_INDEX = _IMP_domino.IMP_RESIDUE_TYPE_INDEX
317 IMP_HIERARCHY_TYPE_INDEX = _IMP_domino.IMP_HIERARCHY_TYPE_INDEX
319 IMP_RMF_HAS_IMP_BASE = _IMP_domino.IMP_RMF_HAS_IMP_BASE
320 IMP_RMF_HAS_IMP_CGAL = _IMP_domino.IMP_RMF_HAS_IMP_CGAL
321 IMP_RMF_HAS_IMP_SCORE_FUNCTOR = _IMP_domino.IMP_RMF_HAS_IMP_SCORE_FUNCTOR
322 IMP_RMF_HAS_BOOST_FILESYSTEM = _IMP_domino.IMP_RMF_HAS_BOOST_FILESYSTEM
323 IMP_RMF_HAS_BOOST_PROGRAMOPTIONS = _IMP_domino.IMP_RMF_HAS_BOOST_PROGRAMOPTIONS
324 IMP_RMF_HAS_BOOST_RANDOM = _IMP_domino.IMP_RMF_HAS_BOOST_RANDOM
325 IMP_RMF_HAS_BOOST_REGEX = _IMP_domino.IMP_RMF_HAS_BOOST_REGEX
326 IMP_RMF_HAS_BOOST_SYSTEM = _IMP_domino.IMP_RMF_HAS_BOOST_SYSTEM
327 IMP_RMF_HAS_CGAL = _IMP_domino.IMP_RMF_HAS_CGAL
330 IMP_DOMINO_HAS_IMP_ATOM = _IMP_domino.IMP_DOMINO_HAS_IMP_ATOM
331 IMP_DOMINO_HAS_IMP_BASE = _IMP_domino.IMP_DOMINO_HAS_IMP_BASE
332 IMP_DOMINO_HAS_IMP_CGAL = _IMP_domino.IMP_DOMINO_HAS_IMP_CGAL
333 IMP_DOMINO_HAS_IMP_KERNEL = _IMP_domino.IMP_DOMINO_HAS_IMP_KERNEL
334 IMP_DOMINO_HAS_IMP_RMF = _IMP_domino.IMP_DOMINO_HAS_IMP_RMF
335 IMP_DOMINO_HAS_IMP_SCORE_FUNCTOR = _IMP_domino.IMP_DOMINO_HAS_IMP_SCORE_FUNCTOR
336 IMP_DOMINO_HAS_BOOST_FILESYSTEM = _IMP_domino.IMP_DOMINO_HAS_BOOST_FILESYSTEM
337 IMP_DOMINO_HAS_BOOST_PROGRAMOPTIONS = _IMP_domino.IMP_DOMINO_HAS_BOOST_PROGRAMOPTIONS
338 IMP_DOMINO_HAS_BOOST_RANDOM = _IMP_domino.IMP_DOMINO_HAS_BOOST_RANDOM
339 IMP_DOMINO_HAS_BOOST_REGEX = _IMP_domino.IMP_DOMINO_HAS_BOOST_REGEX
340 IMP_DOMINO_HAS_BOOST_SYSTEM = _IMP_domino.IMP_DOMINO_HAS_BOOST_SYSTEM
341 IMP_DOMINO_HAS_CGAL = _IMP_domino.IMP_DOMINO_HAS_CGAL
342 IMP_DOMINO_HAS_HDF5 = _IMP_domino.IMP_DOMINO_HAS_HDF5
343 IMP_DOMINO_HAS_RMF = _IMP_domino.IMP_DOMINO_HAS_RMF
345 _object_types.append(
"DiscreteSampler")
348 def _object_cast_to_DiscreteSampler(*args):
349 """_object_cast_to_DiscreteSampler(Object o) -> DiscreteSampler"""
350 return _IMP_domino._object_cast_to_DiscreteSampler(*args)
351 _object_types.append(
"ParticleStates")
354 def _object_cast_to_ParticleStates(*args):
355 """_object_cast_to_ParticleStates(Object o) -> ParticleStates"""
356 return _IMP_domino._object_cast_to_ParticleStates(*args)
357 _object_types.append(
"SubsetFilter")
360 def _object_cast_to_SubsetFilter(*args):
361 """_object_cast_to_SubsetFilter(Object o) -> SubsetFilter"""
362 return _IMP_domino._object_cast_to_SubsetFilter(*args)
363 _object_types.append(
"SubsetFilterTable")
366 def _object_cast_to_SubsetFilterTable(*args):
367 """_object_cast_to_SubsetFilterTable(Object o) -> SubsetFilterTable"""
368 return _IMP_domino._object_cast_to_SubsetFilterTable(*args)
369 _object_types.append(
"AssignmentsTable")
372 def _object_cast_to_AssignmentsTable(*args):
373 """_object_cast_to_AssignmentsTable(Object o) -> AssignmentsTable"""
374 return _IMP_domino._object_cast_to_AssignmentsTable(*args)
375 _object_types.append(
"AssignmentContainer")
378 def _object_cast_to_AssignmentContainer(*args):
379 """_object_cast_to_AssignmentContainer(Object o) -> AssignmentContainer"""
380 return _IMP_domino._object_cast_to_AssignmentContainer(*args)
382 """Proxy of C++ IMP::base::internal::BoostDigraph<(IMP::domino::InteractionGraph,p.IMP::kernel::Particle)> class"""
383 __swig_setmethods__ = {}
384 for _s
in [
IMP.base.Object]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
385 __setattr__ =
lambda self, name, value: _swig_setattr(self, InteractionGraph, name, value)
386 __swig_getmethods__ = {}
387 for _s
in [
IMP.base.Object]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
388 __getattr__ =
lambda self, name: _swig_getattr(self, InteractionGraph, name)
389 __repr__ = _swig_repr
391 """__init__(IMP::base::internal::BoostDigraph<(IMP::domino::InteractionGraph,p.IMP::kernel::Particle)> self) -> InteractionGraph"""
392 this = _IMP_domino.new_InteractionGraph()
393 try: self.this.append(this)
394 except: self.this = this
396 """get_graph(InteractionGraph self) -> IMP::domino::InteractionGraph const &"""
397 return _IMP_domino.InteractionGraph_get_graph(self)
400 """get_vertices(InteractionGraph self) -> IMP::base::internal::BoostDigraph< IMP::domino::InteractionGraph,IMP::kernel::Particle * >::VertexDescriptors"""
401 return _IMP_domino.InteractionGraph_get_vertices(self)
403 def get_vertex_name(self, *args):
404 """get_vertex_name(InteractionGraph self, IMP::base::internal::BoostDigraph< IMP::domino::InteractionGraph,IMP::kernel::Particle * >::VertexDescriptor i) -> Particle"""
405 return _IMP_domino.InteractionGraph_get_vertex_name(self, *args)
407 def get_in_neighbors(self, *args):
408 """get_in_neighbors(InteractionGraph self, IMP::base::internal::BoostDigraph< IMP::domino::InteractionGraph,IMP::kernel::Particle * >::VertexDescriptor v) -> IMP::base::internal::BoostDigraph< IMP::domino::InteractionGraph,IMP::kernel::Particle * >::VertexDescriptors"""
409 return _IMP_domino.InteractionGraph_get_in_neighbors(self, *args)
411 def get_out_neighbors(self, *args):
412 """get_out_neighbors(InteractionGraph self, IMP::base::internal::BoostDigraph< IMP::domino::InteractionGraph,IMP::kernel::Particle * >::VertexDescriptor v) -> IMP::base::internal::BoostDigraph< IMP::domino::InteractionGraph,IMP::kernel::Particle * >::VertexDescriptors"""
413 return _IMP_domino.InteractionGraph_get_out_neighbors(self, *args)
415 def do_show(self, *args):
416 """do_show(InteractionGraph self, _ostream out)"""
417 return _IMP_domino.InteractionGraph_do_show(self, *args)
421 show_graphviz(InteractionGraph self, _ostream out=std::cout)
422 show_graphviz(InteractionGraph self)
424 return _IMP_domino.InteractionGraph_show_graphviz(self, *args)
426 def get_graphviz_string(self):
427 """get_graphviz_string(InteractionGraph self) -> std::string"""
428 return _IMP_domino.InteractionGraph_get_graphviz_string(self)
430 def get_type_name(self):
431 """get_type_name(InteractionGraph self) -> std::string"""
432 return _IMP_domino.InteractionGraph_get_type_name(self)
434 def add_edge(self, *args):
436 add_edge(InteractionGraph self, IMP::base::internal::BoostDigraph< IMP::domino::InteractionGraph,IMP::kernel::Particle * >::VertexDescriptor v0,
437 IMP::base::internal::BoostDigraph< IMP::domino::InteractionGraph,IMP::kernel::Particle * >::VertexDescriptor v1)
439 return _IMP_domino.InteractionGraph_add_edge(self, *args)
441 def add_vertex(self, *args):
442 """add_vertex(InteractionGraph self, Particle l) -> IMP::base::internal::BoostDigraph< IMP::domino::InteractionGraph,IMP::kernel::Particle * >::VertexDescriptor"""
443 return _IMP_domino.InteractionGraph_add_vertex(self, *args)
445 def remove_vertex(self, *args):
446 """remove_vertex(InteractionGraph self, IMP::base::internal::BoostDigraph< IMP::domino::InteractionGraph,IMP::kernel::Particle * >::VertexDescriptor l)"""
447 return _IMP_domino.InteractionGraph_remove_vertex(self, *args)
449 __swig_destroy__ = _IMP_domino.delete_InteractionGraph
450 __del__ =
lambda self :
None;
451 InteractionGraph_swigregister = _IMP_domino.InteractionGraph_swigregister
452 InteractionGraph_swigregister(InteractionGraph)
454 _value_types.append(
"InteractionGraph")
457 """Proxy of C++ IMP::base::internal::BoostDigraph<(IMP::domino::SubsetGraph,IMP::domino::Subset)> class"""
458 __swig_setmethods__ = {}
459 for _s
in [
IMP.base.Object]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
460 __setattr__ =
lambda self, name, value: _swig_setattr(self, SubsetGraph, name, value)
461 __swig_getmethods__ = {}
462 for _s
in [
IMP.base.Object]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
463 __getattr__ =
lambda self, name: _swig_getattr(self, SubsetGraph, name)
464 __repr__ = _swig_repr
466 """__init__(IMP::base::internal::BoostDigraph<(IMP::domino::SubsetGraph,IMP::domino::Subset)> self) -> SubsetGraph"""
467 this = _IMP_domino.new_SubsetGraph()
468 try: self.this.append(this)
469 except: self.this = this
471 """get_graph(SubsetGraph self) -> IMP::domino::SubsetGraph const &"""
472 return _IMP_domino.SubsetGraph_get_graph(self)
475 """get_vertices(SubsetGraph self) -> IMP::base::internal::BoostDigraph< IMP::domino::SubsetGraph,IMP::domino::Subset >::VertexDescriptors"""
476 return _IMP_domino.SubsetGraph_get_vertices(self)
478 def get_vertex_name(self, *args):
479 """get_vertex_name(SubsetGraph self, IMP::base::internal::BoostDigraph< IMP::domino::SubsetGraph,IMP::domino::Subset >::VertexDescriptor i) -> Subset"""
480 return _IMP_domino.SubsetGraph_get_vertex_name(self, *args)
482 def get_in_neighbors(self, *args):
483 """get_in_neighbors(SubsetGraph self, IMP::base::internal::BoostDigraph< IMP::domino::SubsetGraph,IMP::domino::Subset >::VertexDescriptor v) -> IMP::base::internal::BoostDigraph< IMP::domino::SubsetGraph,IMP::domino::Subset >::VertexDescriptors"""
484 return _IMP_domino.SubsetGraph_get_in_neighbors(self, *args)
486 def get_out_neighbors(self, *args):
487 """get_out_neighbors(SubsetGraph self, IMP::base::internal::BoostDigraph< IMP::domino::SubsetGraph,IMP::domino::Subset >::VertexDescriptor v) -> IMP::base::internal::BoostDigraph< IMP::domino::SubsetGraph,IMP::domino::Subset >::VertexDescriptors"""
488 return _IMP_domino.SubsetGraph_get_out_neighbors(self, *args)
490 def do_show(self, *args):
491 """do_show(SubsetGraph self, _ostream out)"""
492 return _IMP_domino.SubsetGraph_do_show(self, *args)
496 show_graphviz(SubsetGraph self, _ostream out=std::cout)
497 show_graphviz(SubsetGraph self)
499 return _IMP_domino.SubsetGraph_show_graphviz(self, *args)
501 def get_graphviz_string(self):
502 """get_graphviz_string(SubsetGraph self) -> std::string"""
503 return _IMP_domino.SubsetGraph_get_graphviz_string(self)
505 def get_type_name(self):
506 """get_type_name(SubsetGraph self) -> std::string"""
507 return _IMP_domino.SubsetGraph_get_type_name(self)
509 def add_edge(self, *args):
511 add_edge(SubsetGraph self, IMP::base::internal::BoostDigraph< IMP::domino::SubsetGraph,IMP::domino::Subset >::VertexDescriptor v0,
512 IMP::base::internal::BoostDigraph< IMP::domino::SubsetGraph,IMP::domino::Subset >::VertexDescriptor v1)
514 return _IMP_domino.SubsetGraph_add_edge(self, *args)
516 def add_vertex(self, *args):
517 """add_vertex(SubsetGraph self, Subset l) -> IMP::base::internal::BoostDigraph< IMP::domino::SubsetGraph,IMP::domino::Subset >::VertexDescriptor"""
518 return _IMP_domino.SubsetGraph_add_vertex(self, *args)
520 def remove_vertex(self, *args):
521 """remove_vertex(SubsetGraph self, IMP::base::internal::BoostDigraph< IMP::domino::SubsetGraph,IMP::domino::Subset >::VertexDescriptor l)"""
522 return _IMP_domino.SubsetGraph_remove_vertex(self, *args)
524 __swig_destroy__ = _IMP_domino.delete_SubsetGraph
525 __del__ =
lambda self :
None;
526 SubsetGraph_swigregister = _IMP_domino.SubsetGraph_swigregister
527 SubsetGraph_swigregister(SubsetGraph)
529 _value_types.append(
"SubsetGraph")
532 """Proxy of C++ IMP::base::internal::BoostDigraph<(IMP::domino::CliqueGraph,IMP::domino::Subset)> class"""
533 __swig_setmethods__ = {}
534 for _s
in [
IMP.base.Object]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
535 __setattr__ =
lambda self, name, value: _swig_setattr(self, CliqueGraph, name, value)
536 __swig_getmethods__ = {}
537 for _s
in [
IMP.base.Object]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
538 __getattr__ =
lambda self, name: _swig_getattr(self, CliqueGraph, name)
539 __repr__ = _swig_repr
541 """__init__(IMP::base::internal::BoostDigraph<(IMP::domino::CliqueGraph,IMP::domino::Subset)> self) -> CliqueGraph"""
542 this = _IMP_domino.new_CliqueGraph()
543 try: self.this.append(this)
544 except: self.this = this
546 """get_graph(CliqueGraph self) -> IMP::domino::CliqueGraph const &"""
547 return _IMP_domino.CliqueGraph_get_graph(self)
550 """get_vertices(CliqueGraph self) -> IMP::base::internal::BoostDigraph< IMP::domino::CliqueGraph,IMP::domino::Subset >::VertexDescriptors"""
551 return _IMP_domino.CliqueGraph_get_vertices(self)
553 def get_vertex_name(self, *args):
554 """get_vertex_name(CliqueGraph self, IMP::base::internal::BoostDigraph< IMP::domino::CliqueGraph,IMP::domino::Subset >::VertexDescriptor i) -> Subset"""
555 return _IMP_domino.CliqueGraph_get_vertex_name(self, *args)
557 def get_in_neighbors(self, *args):
558 """get_in_neighbors(CliqueGraph self, IMP::base::internal::BoostDigraph< IMP::domino::CliqueGraph,IMP::domino::Subset >::VertexDescriptor v) -> IMP::base::internal::BoostDigraph< IMP::domino::CliqueGraph,IMP::domino::Subset >::VertexDescriptors"""
559 return _IMP_domino.CliqueGraph_get_in_neighbors(self, *args)
561 def get_out_neighbors(self, *args):
562 """get_out_neighbors(CliqueGraph self, IMP::base::internal::BoostDigraph< IMP::domino::CliqueGraph,IMP::domino::Subset >::VertexDescriptor v) -> IMP::base::internal::BoostDigraph< IMP::domino::CliqueGraph,IMP::domino::Subset >::VertexDescriptors"""
563 return _IMP_domino.CliqueGraph_get_out_neighbors(self, *args)
565 def do_show(self, *args):
566 """do_show(CliqueGraph self, _ostream out)"""
567 return _IMP_domino.CliqueGraph_do_show(self, *args)
571 show_graphviz(CliqueGraph self, _ostream out=std::cout)
572 show_graphviz(CliqueGraph self)
574 return _IMP_domino.CliqueGraph_show_graphviz(self, *args)
576 def get_graphviz_string(self):
577 """get_graphviz_string(CliqueGraph self) -> std::string"""
578 return _IMP_domino.CliqueGraph_get_graphviz_string(self)
580 def get_type_name(self):
581 """get_type_name(CliqueGraph self) -> std::string"""
582 return _IMP_domino.CliqueGraph_get_type_name(self)
584 def add_edge(self, *args):
586 add_edge(CliqueGraph self, IMP::base::internal::BoostDigraph< IMP::domino::CliqueGraph,IMP::domino::Subset >::VertexDescriptor v0,
587 IMP::base::internal::BoostDigraph< IMP::domino::CliqueGraph,IMP::domino::Subset >::VertexDescriptor v1)
589 return _IMP_domino.CliqueGraph_add_edge(self, *args)
591 def add_vertex(self, *args):
592 """add_vertex(CliqueGraph self, Subset l) -> IMP::base::internal::BoostDigraph< IMP::domino::CliqueGraph,IMP::domino::Subset >::VertexDescriptor"""
593 return _IMP_domino.CliqueGraph_add_vertex(self, *args)
595 def remove_vertex(self, *args):
596 """remove_vertex(CliqueGraph self, IMP::base::internal::BoostDigraph< IMP::domino::CliqueGraph,IMP::domino::Subset >::VertexDescriptor l)"""
597 return _IMP_domino.CliqueGraph_remove_vertex(self, *args)
599 __swig_destroy__ = _IMP_domino.delete_CliqueGraph
600 __del__ =
lambda self :
None;
601 CliqueGraph_swigregister = _IMP_domino.CliqueGraph_swigregister
602 CliqueGraph_swigregister(CliqueGraph)
604 _value_types.append(
"CliqueGraph")
607 """Proxy of C++ IMP::base::internal::BoostDigraph<(IMP::domino::MergeTree,IMP::domino::Subset)> class"""
608 __swig_setmethods__ = {}
609 for _s
in [
IMP.base.Object]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
610 __setattr__ =
lambda self, name, value: _swig_setattr(self, MergeTree, name, value)
611 __swig_getmethods__ = {}
612 for _s
in [
IMP.base.Object]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
613 __getattr__ =
lambda self, name: _swig_getattr(self, MergeTree, name)
614 __repr__ = _swig_repr
616 """__init__(IMP::base::internal::BoostDigraph<(IMP::domino::MergeTree,IMP::domino::Subset)> self) -> MergeTree"""
617 this = _IMP_domino.new_MergeTree()
618 try: self.this.append(this)
619 except: self.this = this
621 """get_graph(MergeTree self) -> IMP::domino::MergeTree const &"""
622 return _IMP_domino.MergeTree_get_graph(self)
625 """get_vertices(MergeTree self) -> IMP::base::internal::BoostDigraph< IMP::domino::MergeTree,IMP::domino::Subset >::VertexDescriptors"""
626 return _IMP_domino.MergeTree_get_vertices(self)
628 def get_vertex_name(self, *args):
629 """get_vertex_name(MergeTree self, IMP::base::internal::BoostDigraph< IMP::domino::MergeTree,IMP::domino::Subset >::VertexDescriptor i) -> Subset"""
630 return _IMP_domino.MergeTree_get_vertex_name(self, *args)
632 def get_in_neighbors(self, *args):
633 """get_in_neighbors(MergeTree self, IMP::base::internal::BoostDigraph< IMP::domino::MergeTree,IMP::domino::Subset >::VertexDescriptor v) -> IMP::base::internal::BoostDigraph< IMP::domino::MergeTree,IMP::domino::Subset >::VertexDescriptors"""
634 return _IMP_domino.MergeTree_get_in_neighbors(self, *args)
636 def get_out_neighbors(self, *args):
637 """get_out_neighbors(MergeTree self, IMP::base::internal::BoostDigraph< IMP::domino::MergeTree,IMP::domino::Subset >::VertexDescriptor v) -> IMP::base::internal::BoostDigraph< IMP::domino::MergeTree,IMP::domino::Subset >::VertexDescriptors"""
638 return _IMP_domino.MergeTree_get_out_neighbors(self, *args)
640 def do_show(self, *args):
641 """do_show(MergeTree self, _ostream out)"""
642 return _IMP_domino.MergeTree_do_show(self, *args)
646 show_graphviz(MergeTree self, _ostream out=std::cout)
647 show_graphviz(MergeTree self)
649 return _IMP_domino.MergeTree_show_graphviz(self, *args)
651 def get_graphviz_string(self):
652 """get_graphviz_string(MergeTree self) -> std::string"""
653 return _IMP_domino.MergeTree_get_graphviz_string(self)
655 def get_type_name(self):
656 """get_type_name(MergeTree self) -> std::string"""
657 return _IMP_domino.MergeTree_get_type_name(self)
659 def add_edge(self, *args):
661 add_edge(MergeTree self, IMP::base::internal::BoostDigraph< IMP::domino::MergeTree,IMP::domino::Subset >::VertexDescriptor v0,
662 IMP::base::internal::BoostDigraph< IMP::domino::MergeTree,IMP::domino::Subset >::VertexDescriptor v1)
664 return _IMP_domino.MergeTree_add_edge(self, *args)
666 def add_vertex(self, *args):
667 """add_vertex(MergeTree self, Subset l) -> IMP::base::internal::BoostDigraph< IMP::domino::MergeTree,IMP::domino::Subset >::VertexDescriptor"""
668 return _IMP_domino.MergeTree_add_vertex(self, *args)
670 def remove_vertex(self, *args):
671 """remove_vertex(MergeTree self, IMP::base::internal::BoostDigraph< IMP::domino::MergeTree,IMP::domino::Subset >::VertexDescriptor l)"""
672 return _IMP_domino.MergeTree_remove_vertex(self, *args)
674 __swig_destroy__ = _IMP_domino.delete_MergeTree
675 __del__ =
lambda self :
None;
676 MergeTree_swigregister = _IMP_domino.MergeTree_swigregister
677 MergeTree_swigregister(MergeTree)
679 _value_types.append(
"MergeTree")
681 _object_types.append(
"BranchAndBoundSampler")
684 def _object_cast_to_BranchAndBoundSampler(*args):
685 """_object_cast_to_BranchAndBoundSampler(Object o) -> BranchAndBoundSampler"""
686 return _IMP_domino._object_cast_to_BranchAndBoundSampler(*args)
687 _object_types.append(
"BranchAndBoundAssignmentsTable")
690 def _object_cast_to_BranchAndBoundAssignmentsTable(*args):
691 """_object_cast_to_BranchAndBoundAssignmentsTable(Object o) -> BranchAndBoundAssignmentsTable"""
692 return _IMP_domino._object_cast_to_BranchAndBoundAssignmentsTable(*args)
693 _object_types.append(
"RecursiveAssignmentsTable")
696 def _object_cast_to_RecursiveAssignmentsTable(*args):
697 """_object_cast_to_RecursiveAssignmentsTable(Object o) -> RecursiveAssignmentsTable"""
698 return _IMP_domino._object_cast_to_RecursiveAssignmentsTable(*args)
699 _object_types.append(
"SimpleAssignmentsTable")
702 def _object_cast_to_SimpleAssignmentsTable(*args):
703 """_object_cast_to_SimpleAssignmentsTable(Object o) -> SimpleAssignmentsTable"""
704 return _IMP_domino._object_cast_to_SimpleAssignmentsTable(*args)
705 _object_types.append(
"CompoundStates")
708 def _object_cast_to_CompoundStates(*args):
709 """_object_cast_to_CompoundStates(Object o) -> CompoundStates"""
710 return _IMP_domino._object_cast_to_CompoundStates(*args)
711 _object_types.append(
"DisjointSetsSubsetFilterTable")
714 def _object_cast_to_DisjointSetsSubsetFilterTable(*args):
715 """_object_cast_to_DisjointSetsSubsetFilterTable(Object o) -> DisjointSetsSubsetFilterTable"""
716 return _IMP_domino._object_cast_to_DisjointSetsSubsetFilterTable(*args)
717 _object_types.append(
"MinimumRestraintScoreSubsetFilterTable")
720 def _object_cast_to_MinimumRestraintScoreSubsetFilterTable(*args):
721 """_object_cast_to_MinimumRestraintScoreSubsetFilterTable(Object o) -> MinimumRestraintScoreSubsetFilterTable"""
722 return _IMP_domino._object_cast_to_MinimumRestraintScoreSubsetFilterTable(*args)
723 _object_types.append(
"DominoSampler")
726 def _object_cast_to_DominoSampler(*args):
727 """_object_cast_to_DominoSampler(Object o) -> DominoSampler"""
728 return _IMP_domino._object_cast_to_DominoSampler(*args)
729 _object_types.append(
"EqualitySubsetFilterTable")
732 def _object_cast_to_EqualitySubsetFilterTable(*args):
733 """_object_cast_to_EqualitySubsetFilterTable(Object o) -> EqualitySubsetFilterTable"""
734 return _IMP_domino._object_cast_to_EqualitySubsetFilterTable(*args)
735 _object_types.append(
"EquivalenceSubsetFilterTable")
738 def _object_cast_to_EquivalenceSubsetFilterTable(*args):
739 """_object_cast_to_EquivalenceSubsetFilterTable(Object o) -> EquivalenceSubsetFilterTable"""
740 return _IMP_domino._object_cast_to_EquivalenceSubsetFilterTable(*args)
741 _object_types.append(
"EquivalenceAndExclusionSubsetFilterTable")
744 def _object_cast_to_EquivalenceAndExclusionSubsetFilterTable(*args):
745 """_object_cast_to_EquivalenceAndExclusionSubsetFilterTable(Object o) -> EquivalenceAndExclusionSubsetFilterTable"""
746 return _IMP_domino._object_cast_to_EquivalenceAndExclusionSubsetFilterTable(*args)
747 _object_types.append(
"ExclusionSubsetFilterTable")
750 def _object_cast_to_ExclusionSubsetFilterTable(*args):
751 """_object_cast_to_ExclusionSubsetFilterTable(Object o) -> ExclusionSubsetFilterTable"""
752 return _IMP_domino._object_cast_to_ExclusionSubsetFilterTable(*args)
753 _object_types.append(
"IndexStates")
756 def _object_cast_to_IndexStates(*args):
757 """_object_cast_to_IndexStates(Object o) -> IndexStates"""
758 return _IMP_domino._object_cast_to_IndexStates(*args)
759 _object_types.append(
"ListSubsetFilterTable")
762 def _object_cast_to_ListSubsetFilterTable(*args):
763 """_object_cast_to_ListSubsetFilterTable(Object o) -> ListSubsetFilterTable"""
764 return _IMP_domino._object_cast_to_ListSubsetFilterTable(*args)
765 _object_types.append(
"ListAssignmentsTable")
768 def _object_cast_to_ListAssignmentsTable(*args):
769 """_object_cast_to_ListAssignmentsTable(Object o) -> ListAssignmentsTable"""
770 return _IMP_domino._object_cast_to_ListAssignmentsTable(*args)
771 _object_types.append(
"ParticleStatesTable")
774 def _object_cast_to_ParticleStatesTable(*args):
775 """_object_cast_to_ParticleStatesTable(Object o) -> ParticleStatesTable"""
776 return _IMP_domino._object_cast_to_ParticleStatesTable(*args)
777 _object_types.append(
"RecursiveStates")
780 def _object_cast_to_RecursiveStates(*args):
781 """_object_cast_to_RecursiveStates(Object o) -> RecursiveStates"""
782 return _IMP_domino._object_cast_to_RecursiveStates(*args)
783 _object_types.append(
"ProbabilisticSubsetFilterTable")
786 def _object_cast_to_ProbabilisticSubsetFilterTable(*args):
787 """_object_cast_to_ProbabilisticSubsetFilterTable(Object o) -> ProbabilisticSubsetFilterTable"""
788 return _IMP_domino._object_cast_to_ProbabilisticSubsetFilterTable(*args)
789 _object_types.append(
"RestraintScoreSubsetFilterTable")
792 def _object_cast_to_RestraintScoreSubsetFilterTable(*args):
793 """_object_cast_to_RestraintScoreSubsetFilterTable(Object o) -> RestraintScoreSubsetFilterTable"""
794 return _IMP_domino._object_cast_to_RestraintScoreSubsetFilterTable(*args)
795 _object_types.append(
"RigidBodyStates")
798 def _object_cast_to_RigidBodyStates(*args):
799 """_object_cast_to_RigidBodyStates(Object o) -> RigidBodyStates"""
800 return _IMP_domino._object_cast_to_RigidBodyStates(*args)
801 _object_types.append(
"XYZStates")
804 def _object_cast_to_XYZStates(*args):
805 """_object_cast_to_XYZStates(Object o) -> XYZStates"""
806 return _IMP_domino._object_cast_to_XYZStates(*args)
807 _object_types.append(
"NestedRigidBodyStates")
810 def _object_cast_to_NestedRigidBodyStates(*args):
811 """_object_cast_to_NestedRigidBodyStates(Object o) -> NestedRigidBodyStates"""
812 return _IMP_domino._object_cast_to_NestedRigidBodyStates(*args)
813 _object_types.append(
"DependencyScoreState")
816 def _object_cast_to_DependencyScoreState(*args):
817 """_object_cast_to_DependencyScoreState(Object o) -> DependencyScoreState"""
818 return _IMP_domino._object_cast_to_DependencyScoreState(*args)
819 _object_types.append(
"PairListSubsetFilterTable")
822 def _object_cast_to_PairListSubsetFilterTable(*args):
823 """_object_cast_to_PairListSubsetFilterTable(Object o) -> PairListSubsetFilterTable"""
824 return _IMP_domino._object_cast_to_PairListSubsetFilterTable(*args)
825 _object_types.append(
"ListAssignmentContainer")
828 def _object_cast_to_ListAssignmentContainer(*args):
829 """_object_cast_to_ListAssignmentContainer(Object o) -> ListAssignmentContainer"""
830 return _IMP_domino._object_cast_to_ListAssignmentContainer(*args)
831 _object_types.append(
"PackedAssignmentContainer")
834 def _object_cast_to_PackedAssignmentContainer(*args):
835 """_object_cast_to_PackedAssignmentContainer(Object o) -> PackedAssignmentContainer"""
836 return _IMP_domino._object_cast_to_PackedAssignmentContainer(*args)
837 _object_types.append(
"HeapAssignmentContainer")
840 def _object_cast_to_HeapAssignmentContainer(*args):
841 """_object_cast_to_HeapAssignmentContainer(Object o) -> HeapAssignmentContainer"""
842 return _IMP_domino._object_cast_to_HeapAssignmentContainer(*args)
843 _object_types.append(
"RangeViewAssignmentContainer")
846 def _object_cast_to_RangeViewAssignmentContainer(*args):
847 """_object_cast_to_RangeViewAssignmentContainer(Object o) -> RangeViewAssignmentContainer"""
848 return _IMP_domino._object_cast_to_RangeViewAssignmentContainer(*args)
849 _object_types.append(
"SampleAssignmentContainer")
852 def _object_cast_to_SampleAssignmentContainer(*args):
853 """_object_cast_to_SampleAssignmentContainer(Object o) -> SampleAssignmentContainer"""
854 return _IMP_domino._object_cast_to_SampleAssignmentContainer(*args)
855 _object_types.append(
"PermutationStates")
858 def _object_cast_to_PermutationStates(*args):
859 """_object_cast_to_PermutationStates(Object o) -> PermutationStates"""
860 return _IMP_domino._object_cast_to_PermutationStates(*args)
861 _object_types.append(
"WriteHDF5AssignmentContainer")
864 def _object_cast_to_WriteHDF5AssignmentContainer(*args):
865 """_object_cast_to_WriteHDF5AssignmentContainer(Object o) -> WriteHDF5AssignmentContainer"""
866 return _IMP_domino._object_cast_to_WriteHDF5AssignmentContainer(*args)
867 _object_types.append(
"ReadHDF5AssignmentContainer")
870 def _object_cast_to_ReadHDF5AssignmentContainer(*args):
871 """_object_cast_to_ReadHDF5AssignmentContainer(Object o) -> ReadHDF5AssignmentContainer"""
872 return _IMP_domino._object_cast_to_ReadHDF5AssignmentContainer(*args)
873 _object_types.append(
"ReadAssignmentContainer")
876 def _object_cast_to_ReadAssignmentContainer(*args):
877 """_object_cast_to_ReadAssignmentContainer(Object o) -> ReadAssignmentContainer"""
878 return _IMP_domino._object_cast_to_ReadAssignmentContainer(*args)
879 _object_types.append(
"WriteAssignmentContainer")
882 def _object_cast_to_WriteAssignmentContainer(*args):
883 """_object_cast_to_WriteAssignmentContainer(Object o) -> WriteAssignmentContainer"""
884 return _IMP_domino._object_cast_to_WriteAssignmentContainer(*args)
885 _object_types.append(
"CappedAssignmentContainer")
888 def _object_cast_to_CappedAssignmentContainer(*args):
889 """_object_cast_to_CappedAssignmentContainer(Object o) -> CappedAssignmentContainer"""
890 return _IMP_domino._object_cast_to_CappedAssignmentContainer(*args)
891 _object_types.append(
"RestraintCache")
894 def _object_cast_to_RestraintCache(*args):
895 """_object_cast_to_RestraintCache(Object o) -> RestraintCache"""
896 return _IMP_domino._object_cast_to_RestraintCache(*args)
898 _plural_types.append(
"Subsets")
899 _value_types.append(
"Subset")
902 _plural_types.append(
"Assignments")
903 _value_types.append(
"Assignment")
906 _plural_types.append(
"Slices")
907 _value_types.append(
"Slice")
910 _plural_types.append(
"Orders")
911 _value_types.append(
"Order")
913 class _IntArray(IMP.base._Value):
914 """Proxy of C++ IMP::base::ConstVector<(int)> class"""
915 __swig_setmethods__ = {}
916 for _s
in [IMP.base._Value]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
917 __setattr__ =
lambda self, name, value: _swig_setattr(self, _IntArray, name, value)
918 __swig_getmethods__ = {}
919 for _s
in [IMP.base._Value]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
920 __getattr__ =
lambda self, name: _swig_getattr(self, _IntArray, name)
921 __repr__ = _swig_repr
922 __swig_destroy__ = _IMP_domino.delete__IntArray
923 __del__ =
lambda self :
None;
924 def __init__(self, *args):
926 __init__(IMP::base::ConstVector<(int)> self, unsigned int sz, int fill) -> _IntArray
927 __init__(IMP::base::ConstVector<(int)> self) -> _IntArray
929 this = _IMP_domino.new__IntArray(*args)
930 try: self.this.append(this)
931 except: self.this = this
932 def __eq__(self, *args):
933 """__eq__(_IntArray self, _IntArray o) -> bool"""
934 return _IMP_domino._IntArray___eq__(self, *args)
936 def __ne__(self, *args):
937 """__ne__(_IntArray self, _IntArray o) -> bool"""
938 return _IMP_domino._IntArray___ne__(self, *args)
940 def __lt__(self, *args):
941 """__lt__(_IntArray self, _IntArray o) -> bool"""
942 return _IMP_domino._IntArray___lt__(self, *args)
944 def __gt__(self, *args):
945 """__gt__(_IntArray self, _IntArray o) -> bool"""
946 return _IMP_domino._IntArray___gt__(self, *args)
948 def __ge__(self, *args):
949 """__ge__(_IntArray self, _IntArray o) -> bool"""
950 return _IMP_domino._IntArray___ge__(self, *args)
952 def __le__(self, *args):
953 """__le__(_IntArray self, _IntArray o) -> bool"""
954 return _IMP_domino._IntArray___le__(self, *args)
956 def __getitem__(self, *args):
957 """__getitem__(_IntArray self, unsigned int i) -> int"""
958 return _IMP_domino._IntArray___getitem__(self, *args)
961 """__len__(_IntArray self) -> unsigned int"""
962 return _IMP_domino._IntArray___len__(self)
964 def show(self, *args):
966 show(_IntArray self, _ostream out=std::cout)
969 return _IMP_domino._IntArray_show(self, *args)
972 """__hash__(_IntArray self) -> std::size_t"""
973 return _IMP_domino._IntArray___hash__(self)
975 _IntArray_swigregister = _IMP_domino._IntArray_swigregister
976 _IntArray_swigregister(_IntArray)
978 class _UIntArray(IMP.base._Value):
979 """Proxy of C++ IMP::base::ConstVector<(unsigned int)> class"""
980 __swig_setmethods__ = {}
981 for _s
in [IMP.base._Value]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
982 __setattr__ =
lambda self, name, value: _swig_setattr(self, _UIntArray, name, value)
983 __swig_getmethods__ = {}
984 for _s
in [IMP.base._Value]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
985 __getattr__ =
lambda self, name: _swig_getattr(self, _UIntArray, name)
986 __repr__ = _swig_repr
987 __swig_destroy__ = _IMP_domino.delete__UIntArray
988 __del__ =
lambda self :
None;
989 def __init__(self, *args):
991 __init__(IMP::base::ConstVector<(unsigned int)> self, unsigned int sz, unsigned int fill) -> _UIntArray
992 __init__(IMP::base::ConstVector<(unsigned int)> self) -> _UIntArray
994 this = _IMP_domino.new__UIntArray(*args)
995 try: self.this.append(this)
996 except: self.this = this
997 def __eq__(self, *args):
998 """__eq__(_UIntArray self, _UIntArray o) -> bool"""
999 return _IMP_domino._UIntArray___eq__(self, *args)
1001 def __ne__(self, *args):
1002 """__ne__(_UIntArray self, _UIntArray o) -> bool"""
1003 return _IMP_domino._UIntArray___ne__(self, *args)
1005 def __lt__(self, *args):
1006 """__lt__(_UIntArray self, _UIntArray o) -> bool"""
1007 return _IMP_domino._UIntArray___lt__(self, *args)
1009 def __gt__(self, *args):
1010 """__gt__(_UIntArray self, _UIntArray o) -> bool"""
1011 return _IMP_domino._UIntArray___gt__(self, *args)
1013 def __ge__(self, *args):
1014 """__ge__(_UIntArray self, _UIntArray o) -> bool"""
1015 return _IMP_domino._UIntArray___ge__(self, *args)
1017 def __le__(self, *args):
1018 """__le__(_UIntArray self, _UIntArray o) -> bool"""
1019 return _IMP_domino._UIntArray___le__(self, *args)
1021 def __getitem__(self, *args):
1022 """__getitem__(_UIntArray self, unsigned int i) -> unsigned int"""
1023 return _IMP_domino._UIntArray___getitem__(self, *args)
1026 """__len__(_UIntArray self) -> unsigned int"""
1027 return _IMP_domino._UIntArray___len__(self)
1029 def show(self, *args):
1031 show(_UIntArray self, _ostream out=std::cout)
1032 show(_UIntArray self)
1034 return _IMP_domino._UIntArray_show(self, *args)
1037 """__hash__(_UIntArray self) -> std::size_t"""
1038 return _IMP_domino._UIntArray___hash__(self)
1040 _UIntArray_swigregister = _IMP_domino._UIntArray_swigregister
1041 _UIntArray_swigregister(_UIntArray)
1043 class _ParticleArray(IMP.base._Value):
1044 """Proxy of C++ IMP::base::ConstVector<(IMP::base::WeakPointer<(Particle)>,p.Particle)> class"""
1045 __swig_setmethods__ = {}
1046 for _s
in [IMP.base._Value]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
1047 __setattr__ =
lambda self, name, value: _swig_setattr(self, _ParticleArray, name, value)
1048 __swig_getmethods__ = {}
1049 for _s
in [IMP.base._Value]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
1050 __getattr__ =
lambda self, name: _swig_getattr(self, _ParticleArray, name)
1051 __repr__ = _swig_repr
1052 __swig_destroy__ = _IMP_domino.delete__ParticleArray
1053 __del__ =
lambda self :
None;
1054 def __init__(self, *args):
1056 __init__(IMP::base::ConstVector<(IMP::base::WeakPointer<(Particle)>,p.Particle)> self, unsigned int sz, IMP::base::WeakPointer< IMP::kernel::Particle > fill) -> _ParticleArray
1057 __init__(IMP::base::ConstVector<(IMP::base::WeakPointer<(Particle)>,p.Particle)> self) -> _ParticleArray
1059 this = _IMP_domino.new__ParticleArray(*args)
1060 try: self.this.append(this)
1061 except: self.this = this
1062 def __eq__(self, *args):
1063 """__eq__(_ParticleArray self, _ParticleArray o) -> bool"""
1064 return _IMP_domino._ParticleArray___eq__(self, *args)
1066 def __ne__(self, *args):
1067 """__ne__(_ParticleArray self, _ParticleArray o) -> bool"""
1068 return _IMP_domino._ParticleArray___ne__(self, *args)
1070 def __lt__(self, *args):
1071 """__lt__(_ParticleArray self, _ParticleArray o) -> bool"""
1072 return _IMP_domino._ParticleArray___lt__(self, *args)
1074 def __gt__(self, *args):
1075 """__gt__(_ParticleArray self, _ParticleArray o) -> bool"""
1076 return _IMP_domino._ParticleArray___gt__(self, *args)
1078 def __ge__(self, *args):
1079 """__ge__(_ParticleArray self, _ParticleArray o) -> bool"""
1080 return _IMP_domino._ParticleArray___ge__(self, *args)
1082 def __le__(self, *args):
1083 """__le__(_ParticleArray self, _ParticleArray o) -> bool"""
1084 return _IMP_domino._ParticleArray___le__(self, *args)
1086 def __getitem__(self, *args):
1087 """__getitem__(_ParticleArray self, unsigned int i) -> Particle"""
1088 return _IMP_domino._ParticleArray___getitem__(self, *args)
1091 """__len__(_ParticleArray self) -> unsigned int"""
1092 return _IMP_domino._ParticleArray___len__(self)
1094 def show(self, *args):
1096 show(_ParticleArray self, _ostream out=std::cout)
1097 show(_ParticleArray self)
1099 return _IMP_domino._ParticleArray_show(self, *args)
1102 """__hash__(_ParticleArray self) -> std::size_t"""
1103 return _IMP_domino._ParticleArray___hash__(self)
1105 _ParticleArray_swigregister = _IMP_domino._ParticleArray_swigregister
1106 _ParticleArray_swigregister(_ParticleArray)
1108 class Subset(_ParticleArray):
1109 """Proxy of C++ IMP::domino::Subset class"""
1110 __swig_setmethods__ = {}
1111 for _s
in [_ParticleArray]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
1112 __setattr__ =
lambda self, name, value: _swig_setattr(self, Subset, name, value)
1113 __swig_getmethods__ = {}
1114 for _s
in [_ParticleArray]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
1115 __getattr__ =
lambda self, name: _swig_getattr(self, Subset, name)
1116 def __init__(self, *args):
1118 __init__(IMP::domino::Subset self, IMP::kernel::ParticlesTemp const & ps, bool arg3) -> Subset
1119 __init__(IMP::domino::Subset self) -> Subset
1120 __init__(IMP::domino::Subset self, IMP::kernel::ParticlesTemp ps) -> Subset
1122 this = _IMP_domino.new_Subset(*args)
1123 try: self.this.append(this)
1124 except: self.this = this
1125 def get_model(self):
1126 """get_model(Subset self) -> Model"""
1127 return _IMP_domino.Subset_get_model(self)
1130 """get_name(Subset self) -> std::string"""
1131 return _IMP_domino.Subset_get_name(self)
1133 def get_contains(self, *args):
1134 """get_contains(Subset self, Subset o) -> bool"""
1135 return _IMP_domino.Subset_get_contains(self, *args)
1138 """__str__(Subset self) -> std::string"""
1139 return _IMP_domino.Subset___str__(self)
1142 """__repr__(Subset self) -> std::string"""
1143 return _IMP_domino.Subset___repr__(self)
1145 __swig_destroy__ = _IMP_domino.delete_Subset
1146 __del__ =
lambda self :
None;
1147 Subset_swigregister = _IMP_domino.Subset_swigregister
1148 Subset_swigregister(Subset)
1152 """get_union(Subset a, Subset b) -> Subset"""
1153 return _IMP_domino.get_union(*args)
1156 """get_intersection(Subset a, Subset b) -> Subset"""
1157 return _IMP_domino.get_intersection(*args)
1159 def get_difference(*args):
1160 """get_difference(Subset a, Subset b) -> Subset"""
1161 return _IMP_domino.get_difference(*args)
1162 class Assignment(_IntArray):
1163 """Proxy of C++ IMP::domino::Assignment class"""
1164 __swig_setmethods__ = {}
1165 for _s
in [_IntArray]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
1166 __setattr__ =
lambda self, name, value: _swig_setattr(self, Assignment, name, value)
1167 __swig_getmethods__ = {}
1168 for _s
in [_IntArray]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
1169 __getattr__ =
lambda self, name: _swig_getattr(self, Assignment, name)
1170 def __init__(self, *args):
1172 __init__(IMP::domino::Assignment self) -> Assignment
1173 __init__(IMP::domino::Assignment self, unsigned int sz) -> Assignment
1174 __init__(IMP::domino::Assignment self, IMP::Ints const & i) -> Assignment
1176 this = _IMP_domino.new_Assignment(*args)
1177 try: self.this.append(this)
1178 except: self.this = this
1180 """__str__(Assignment self) -> std::string"""
1181 return _IMP_domino.Assignment___str__(self)
1184 """__repr__(Assignment self) -> std::string"""
1185 return _IMP_domino.Assignment___repr__(self)
1187 __swig_destroy__ = _IMP_domino.delete_Assignment
1188 __del__ =
lambda self :
None;
1189 Assignment_swigregister = _IMP_domino.Assignment_swigregister
1190 Assignment_swigregister(Assignment)
1192 class Slice(_UIntArray):
1193 """Proxy of C++ IMP::domino::Slice class"""
1194 __swig_setmethods__ = {}
1195 for _s
in [_UIntArray]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
1196 __setattr__ =
lambda self, name, value: _swig_setattr(self, Slice, name, value)
1197 __swig_getmethods__ = {}
1198 for _s
in [_UIntArray]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
1199 __getattr__ =
lambda self, name: _swig_getattr(self, Slice, name)
1200 def __init__(self, *args):
1202 __init__(IMP::domino::Slice self) -> Slice
1203 __init__(IMP::domino::Slice self, Subset outer, Subset inner) -> Slice
1205 this = _IMP_domino.new_Slice(*args)
1206 try: self.this.append(this)
1207 except: self.this = this
1208 def get_sliced(self, *args):
1210 get_sliced(Slice self, Assignment a) -> Assignment
1211 get_sliced(Slice self, Subset a) -> Subset
1213 return _IMP_domino.Slice_get_sliced(self, *args)
1216 """__str__(Slice self) -> std::string"""
1217 return _IMP_domino.Slice___str__(self)
1220 """__repr__(Slice self) -> std::string"""
1221 return _IMP_domino.Slice___repr__(self)
1223 __swig_destroy__ = _IMP_domino.delete_Slice
1224 __del__ =
lambda self :
None;
1225 Slice_swigregister = _IMP_domino.Slice_swigregister
1226 Slice_swigregister(Slice)
1230 """get_slice(Subset outer, Subset inner, IMP::domino::Subsets const & excluded) -> Slice"""
1231 return _IMP_domino.get_slice(*args)
1232 class Order(_UIntArray):
1233 """Proxy of C++ IMP::domino::Order class"""
1234 __swig_setmethods__ = {}
1235 for _s
in [_UIntArray]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
1236 __setattr__ =
lambda self, name, value: _swig_setattr(self, Order, name, value)
1237 __swig_getmethods__ = {}
1238 for _s
in [_UIntArray]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
1239 __getattr__ =
lambda self, name: _swig_getattr(self, Order, name)
1240 def __init__(self, *args):
1242 __init__(IMP::domino::Order self) -> Order
1243 __init__(IMP::domino::Order self, Subset outer, IMP::kernel::ParticlesTemp const & order) -> Order
1245 this = _IMP_domino.new_Order(*args)
1246 try: self.this.append(this)
1247 except: self.this = this
1248 def get_list_ordered(self, *args):
1249 """get_list_ordered(Order self, Assignment a) -> IMP::Ints"""
1250 return _IMP_domino.Order_get_list_ordered(self, *args)
1252 def get_subset_ordered(self, *args):
1253 """get_subset_ordered(Order self, IMP::Ints const & a) -> Assignment"""
1254 return _IMP_domino.Order_get_subset_ordered(self, *args)
1257 """__str__(Order self) -> std::string"""
1258 return _IMP_domino.Order___str__(self)
1261 """__repr__(Order self) -> std::string"""
1262 return _IMP_domino.Order___repr__(self)
1264 __swig_destroy__ = _IMP_domino.delete_Order
1265 __del__ =
lambda self :
None;
1266 Order_swigregister = _IMP_domino.Order_swigregister
1267 Order_swigregister(Order)
1270 """Proxy of C++ IMP::domino::ParticleStates class"""
1271 __swig_setmethods__ = {}
1272 for _s
in [
IMP.base.Object]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
1273 __setattr__ =
lambda self, name, value: _swig_setattr(self, ParticleStates, name, value)
1274 __swig_getmethods__ = {}
1275 for _s
in [
IMP.base.Object]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
1276 __getattr__ =
lambda self, name: _swig_getattr(self, ParticleStates, name)
1277 def __init__(self, name="ParticleStates %1%"):
1279 __init__(IMP::domino::ParticleStates self, std::string name="ParticleStates %1%") -> ParticleStates
1280 __init__(IMP::domino::ParticleStates self) -> ParticleStates
1282 if self.__class__ == ParticleStates:
1286 this = _IMP_domino.new_ParticleStates(_self, name)
1287 try: self.this.append(this)
1288 except: self.this = this
1289 if self.__class__ != ParticleStates:
1291 IMP.base._director_objects.register(self)
1295 def get_number_of_particle_states(self):
1296 """get_number_of_particle_states(ParticleStates self) -> unsigned int"""
1297 return _IMP_domino.ParticleStates_get_number_of_particle_states(self)
1299 def load_particle_state(self, *args):
1300 """load_particle_state(ParticleStates self, unsigned int arg0, Particle arg1)"""
1301 return _IMP_domino.ParticleStates_load_particle_state(self, *args)
1304 """get_embedding(ParticleStates self, unsigned int i) -> VectorKD"""
1305 return _IMP_domino.ParticleStates_get_embedding(self, *args)
1307 def get_nearest_state(self, *args):
1308 """get_nearest_state(ParticleStates self, VectorKD v) -> unsigned int"""
1309 return _IMP_domino.ParticleStates_get_nearest_state(self, *args)
1311 __swig_destroy__ = _IMP_domino.delete_ParticleStates
1312 __del__ =
lambda self :
None;
1314 """__str__(ParticleStates self) -> std::string"""
1315 return _IMP_domino.ParticleStates___str__(self)
1318 """__repr__(ParticleStates self) -> std::string"""
1319 return _IMP_domino.ParticleStates___repr__(self)
1322 return _object_cast_to_ParticleStates(o)
1323 get_from = staticmethod(get_from)
1325 def get_type_name(self):
1326 return self.__class__.__name__
1327 def do_show(self, out):
1329 def get_version_info(self):
1330 if"IMP::domino" ==
"IMP":
1331 return VersionInfo(
"python",
"0")
1333 return IMP.VersionInfo(
"python",
"0")
1335 return _object_cast_to_ParticleStates(o)
1336 get_from = staticmethod(get_from)
1338 def __disown__(self):
1340 _IMP_domino.disown_ParticleStates(self)
1341 return weakref_proxy(self)
1342 ParticleStates_swigregister = _IMP_domino.ParticleStates_swigregister
1343 ParticleStates_swigregister(ParticleStates)
1346 """Proxy of C++ IMP::domino::ParticleStatesTable class"""
1347 __swig_setmethods__ = {}
1348 for _s
in [
IMP.base.Object]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
1349 __setattr__ =
lambda self, name, value: _swig_setattr(self, ParticleStatesTable, name, value)
1350 __swig_getmethods__ = {}
1351 for _s
in [
IMP.base.Object]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
1352 __getattr__ =
lambda self, name: _swig_getattr(self, ParticleStatesTable, name)
1354 """__init__(IMP::domino::ParticleStatesTable self) -> ParticleStatesTable"""
1355 this = _IMP_domino.new_ParticleStatesTable()
1356 try: self.this.append(this)
1357 except: self.this = this
1358 def get_particle_states(self, *args):
1359 """get_particle_states(ParticleStatesTable self, Particle p) -> ParticleStates"""
1360 return _IMP_domino.ParticleStatesTable_get_particle_states(self, *args)
1362 def get_has_particle(self, *args):
1363 """get_has_particle(ParticleStatesTable self, Particle p) -> bool"""
1364 return _IMP_domino.ParticleStatesTable_get_has_particle(self, *args)
1367 """get_particles(ParticleStatesTable self) -> IMP::kernel::ParticlesTemp"""
1368 return _IMP_domino.ParticleStatesTable_get_particles(self)
1370 def get_subset(self):
1371 """get_subset(ParticleStatesTable self) -> Subset"""
1372 return _IMP_domino.ParticleStatesTable_get_subset(self)
1374 def set_particle_states(self, *args):
1375 """set_particle_states(ParticleStatesTable self, Particle p, ParticleStates e)"""
1376 return _IMP_domino.ParticleStatesTable_set_particle_states(self, *args)
1378 def get_version_info(self):
1379 """get_version_info(ParticleStatesTable self) -> VersionInfo"""
1380 return _IMP_domino.ParticleStatesTable_get_version_info(self)
1382 def do_show(self, *args):
1383 """do_show(ParticleStatesTable self, _ostream out)"""
1384 return _IMP_domino.ParticleStatesTable_do_show(self, *args)
1386 __swig_destroy__ = _IMP_domino.delete_ParticleStatesTable
1387 __del__ =
lambda self :
None;
1389 """__str__(ParticleStatesTable self) -> std::string"""
1390 return _IMP_domino.ParticleStatesTable___str__(self)
1393 """__repr__(ParticleStatesTable self) -> std::string"""
1394 return _IMP_domino.ParticleStatesTable___repr__(self)
1397 return _object_cast_to_ParticleStatesTable(o)
1398 get_from = staticmethod(get_from)
1400 ParticleStatesTable_swigregister = _IMP_domino.ParticleStatesTable_swigregister
1401 ParticleStatesTable_swigregister(ParticleStatesTable)
1403 class IndexStates(ParticleStates):
1404 """Proxy of C++ IMP::domino::IndexStates class"""
1405 __swig_setmethods__ = {}
1406 for _s
in [ParticleStates]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
1407 __setattr__ =
lambda self, name, value: _swig_setattr(self, IndexStates, name, value)
1408 __swig_getmethods__ = {}
1409 for _s
in [ParticleStates]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
1410 __getattr__ =
lambda self, name: _swig_getattr(self, IndexStates, name)
1411 def __init__(self, *args):
1413 __init__(IMP::domino::IndexStates self, unsigned int n, IntKey k=IntKey("state")) -> IndexStates
1414 __init__(IMP::domino::IndexStates self, unsigned int n) -> IndexStates
1416 this = _IMP_domino.new_IndexStates(*args)
1417 try: self.this.append(this)
1418 except: self.this = this
1419 def get_version_info(self):
1420 """get_version_info(IndexStates self) -> VersionInfo"""
1421 return _IMP_domino.IndexStates_get_version_info(self)
1423 def do_show(self, *args):
1424 """do_show(IndexStates self, _ostream out)"""
1425 return _IMP_domino.IndexStates_do_show(self, *args)
1427 __swig_destroy__ = _IMP_domino.delete_IndexStates
1428 __del__ =
lambda self :
None;
1430 """__str__(IndexStates self) -> std::string"""
1431 return _IMP_domino.IndexStates___str__(self)
1434 """__repr__(IndexStates self) -> std::string"""
1435 return _IMP_domino.IndexStates___repr__(self)
1438 return _object_cast_to_IndexStates(o)
1439 get_from = staticmethod(get_from)
1441 IndexStates_swigregister = _IMP_domino.IndexStates_swigregister
1442 IndexStates_swigregister(IndexStates)
1444 class XYZStates(ParticleStates):
1445 """Proxy of C++ IMP::domino::XYZStates class"""
1446 __swig_setmethods__ = {}
1447 for _s
in [ParticleStates]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
1448 __setattr__ =
lambda self, name, value: _swig_setattr(self, XYZStates, name, value)
1449 __swig_getmethods__ = {}
1450 for _s
in [ParticleStates]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
1451 __getattr__ =
lambda self, name: _swig_getattr(self, XYZStates, name)
1452 def __init__(self, *args):
1453 """__init__(IMP::domino::XYZStates self, IMP::algebra::Vector3Ds const & states) -> XYZStates"""
1454 this = _IMP_domino.new_XYZStates(*args)
1455 try: self.this.append(this)
1456 except: self.this = this
1457 def get_vector(self, *args):
1458 """get_vector(XYZStates self, unsigned int i) -> Vector3D"""
1459 return _IMP_domino.XYZStates_get_vector(self, *args)
1461 def get_version_info(self):
1462 """get_version_info(XYZStates self) -> VersionInfo"""
1463 return _IMP_domino.XYZStates_get_version_info(self)
1465 def do_show(self, *args):
1466 """do_show(XYZStates self, _ostream out)"""
1467 return _IMP_domino.XYZStates_do_show(self, *args)
1469 __swig_destroy__ = _IMP_domino.delete_XYZStates
1470 __del__ =
lambda self :
None;
1472 """__str__(XYZStates self) -> std::string"""
1473 return _IMP_domino.XYZStates___str__(self)
1476 """__repr__(XYZStates self) -> std::string"""
1477 return _IMP_domino.XYZStates___repr__(self)
1480 return _object_cast_to_XYZStates(o)
1481 get_from = staticmethod(get_from)
1483 XYZStates_swigregister = _IMP_domino.XYZStates_swigregister
1484 XYZStates_swigregister(XYZStates)
1486 class RigidBodyStates(ParticleStates):
1487 """Proxy of C++ IMP::domino::RigidBodyStates class"""
1488 __swig_setmethods__ = {}
1489 for _s
in [ParticleStates]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
1490 __setattr__ =
lambda self, name, value: _swig_setattr(self, RigidBodyStates, name, value)
1491 __swig_getmethods__ = {}
1492 for _s
in [ParticleStates]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
1493 __getattr__ =
lambda self, name: _swig_getattr(self, RigidBodyStates, name)
1494 def __init__(self, *args):
1496 __init__(IMP::domino::RigidBodyStates self, IMP::algebra::ReferenceFrame3Ds const & states, double scale=1) -> RigidBodyStates
1497 __init__(IMP::domino::RigidBodyStates self, IMP::algebra::ReferenceFrame3Ds const & states) -> RigidBodyStates
1499 this = _IMP_domino.new_RigidBodyStates(*args)
1500 try: self.this.append(this)
1501 except: self.this = this
1502 def get_reference_frame(self, *args):
1503 """get_reference_frame(RigidBodyStates self, unsigned int i) -> ReferenceFrame3D"""
1504 return _IMP_domino.RigidBodyStates_get_reference_frame(self, *args)
1506 def get_version_info(self):
1507 """get_version_info(RigidBodyStates self) -> VersionInfo"""
1508 return _IMP_domino.RigidBodyStates_get_version_info(self)
1510 def do_show(self, *args):
1511 """do_show(RigidBodyStates self, _ostream out)"""
1512 return _IMP_domino.RigidBodyStates_do_show(self, *args)
1514 __swig_destroy__ = _IMP_domino.delete_RigidBodyStates
1515 __del__ =
lambda self :
None;
1517 """__str__(RigidBodyStates self) -> std::string"""
1518 return _IMP_domino.RigidBodyStates___str__(self)
1521 """__repr__(RigidBodyStates self) -> std::string"""
1522 return _IMP_domino.RigidBodyStates___repr__(self)
1525 return _object_cast_to_RigidBodyStates(o)
1526 get_from = staticmethod(get_from)
1528 RigidBodyStates_swigregister = _IMP_domino.RigidBodyStates_swigregister
1529 RigidBodyStates_swigregister(RigidBodyStates)
1531 class NestedRigidBodyStates(ParticleStates):
1532 """Proxy of C++ IMP::domino::NestedRigidBodyStates class"""
1533 __swig_setmethods__ = {}
1534 for _s
in [ParticleStates]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
1535 __setattr__ =
lambda self, name, value: _swig_setattr(self, NestedRigidBodyStates, name, value)
1536 __swig_getmethods__ = {}
1537 for _s
in [ParticleStates]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
1538 __getattr__ =
lambda self, name: _swig_getattr(self, NestedRigidBodyStates, name)
1539 def __init__(self, *args):
1541 __init__(IMP::domino::NestedRigidBodyStates self, IMP::algebra::Transformation3Ds const & states, double scale=100) -> NestedRigidBodyStates
1542 __init__(IMP::domino::NestedRigidBodyStates self, IMP::algebra::Transformation3Ds const & states) -> NestedRigidBodyStates
1544 this = _IMP_domino.new_NestedRigidBodyStates(*args)
1545 try: self.this.append(this)
1546 except: self.this = this
1547 def get_transformation(self, *args):
1548 """get_transformation(NestedRigidBodyStates self, unsigned int i) -> Transformation3D"""
1549 return _IMP_domino.NestedRigidBodyStates_get_transformation(self, *args)
1551 def get_version_info(self):
1552 """get_version_info(NestedRigidBodyStates self) -> VersionInfo"""
1553 return _IMP_domino.NestedRigidBodyStates_get_version_info(self)
1555 def do_show(self, *args):
1556 """do_show(NestedRigidBodyStates self, _ostream out)"""
1557 return _IMP_domino.NestedRigidBodyStates_do_show(self, *args)
1559 __swig_destroy__ = _IMP_domino.delete_NestedRigidBodyStates
1560 __del__ =
lambda self :
None;
1562 """__str__(NestedRigidBodyStates self) -> std::string"""
1563 return _IMP_domino.NestedRigidBodyStates___str__(self)
1566 """__repr__(NestedRigidBodyStates self) -> std::string"""
1567 return _IMP_domino.NestedRigidBodyStates___repr__(self)
1570 return _object_cast_to_NestedRigidBodyStates(o)
1571 get_from = staticmethod(get_from)
1573 NestedRigidBodyStates_swigregister = _IMP_domino.NestedRigidBodyStates_swigregister
1574 NestedRigidBodyStates_swigregister(NestedRigidBodyStates)
1576 class CompoundStates(ParticleStates):
1577 """Proxy of C++ IMP::domino::CompoundStates class"""
1578 __swig_setmethods__ = {}
1579 for _s
in [ParticleStates]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
1580 __setattr__ =
lambda self, name, value: _swig_setattr(self, CompoundStates, name, value)
1581 __swig_getmethods__ = {}
1582 for _s
in [ParticleStates]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
1583 __getattr__ =
lambda self, name: _swig_getattr(self, CompoundStates, name)
1584 def __init__(self, *args):
1585 """__init__(IMP::domino::CompoundStates self, ParticleStates a, ParticleStates b) -> CompoundStates"""
1586 this = _IMP_domino.new_CompoundStates(*args)
1587 try: self.this.append(this)
1588 except: self.this = this
1589 def get_version_info(self):
1590 """get_version_info(CompoundStates self) -> VersionInfo"""
1591 return _IMP_domino.CompoundStates_get_version_info(self)
1593 def do_show(self, *args):
1594 """do_show(CompoundStates self, _ostream out)"""
1595 return _IMP_domino.CompoundStates_do_show(self, *args)
1597 __swig_destroy__ = _IMP_domino.delete_CompoundStates
1598 __del__ =
lambda self :
None;
1600 """__str__(CompoundStates self) -> std::string"""
1601 return _IMP_domino.CompoundStates___str__(self)
1604 """__repr__(CompoundStates self) -> std::string"""
1605 return _IMP_domino.CompoundStates___repr__(self)
1608 return _object_cast_to_CompoundStates(o)
1609 get_from = staticmethod(get_from)
1611 CompoundStates_swigregister = _IMP_domino.CompoundStates_swigregister
1612 CompoundStates_swigregister(CompoundStates)
1614 class RecursiveStates(ParticleStates):
1615 """Proxy of C++ IMP::domino::RecursiveStates class"""
1616 __swig_setmethods__ = {}
1617 for _s
in [ParticleStates]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
1618 __setattr__ =
lambda self, name, value: _swig_setattr(self, RecursiveStates, name, value)
1619 __swig_getmethods__ = {}
1620 for _s
in [ParticleStates]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
1621 __getattr__ =
lambda self, name: _swig_getattr(self, RecursiveStates, name)
1622 def __init__(self, *args):
1623 """__init__(IMP::domino::RecursiveStates self, Particle p, Subset s, IMP::domino::Assignments const & ss, ParticleStatesTable pst) -> RecursiveStates"""
1624 this = _IMP_domino.new_RecursiveStates(*args)
1625 try: self.this.append(this)
1626 except: self.this = this
1627 def get_version_info(self):
1628 """get_version_info(RecursiveStates self) -> VersionInfo"""
1629 return _IMP_domino.RecursiveStates_get_version_info(self)
1631 def do_show(self, *args):
1632 """do_show(RecursiveStates self, _ostream out)"""
1633 return _IMP_domino.RecursiveStates_do_show(self, *args)
1635 __swig_destroy__ = _IMP_domino.delete_RecursiveStates
1636 __del__ =
lambda self :
None;
1638 """__str__(RecursiveStates self) -> std::string"""
1639 return _IMP_domino.RecursiveStates___str__(self)
1642 """__repr__(RecursiveStates self) -> std::string"""
1643 return _IMP_domino.RecursiveStates___repr__(self)
1646 return _object_cast_to_RecursiveStates(o)
1647 get_from = staticmethod(get_from)
1649 RecursiveStates_swigregister = _IMP_domino.RecursiveStates_swigregister
1650 RecursiveStates_swigregister(RecursiveStates)
1652 class PermutationStates(ParticleStates):
1653 """Proxy of C++ IMP::domino::PermutationStates class"""
1654 __swig_setmethods__ = {}
1655 for _s
in [ParticleStates]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
1656 __setattr__ =
lambda self, name, value: _swig_setattr(self, PermutationStates, name, value)
1657 __swig_getmethods__ = {}
1658 for _s
in [ParticleStates]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
1659 __getattr__ =
lambda self, name: _swig_getattr(self, PermutationStates, name)
1660 def __init__(self, *args):
1661 """__init__(IMP::domino::PermutationStates self, ParticleStates inner) -> PermutationStates"""
1662 this = _IMP_domino.new_PermutationStates(*args)
1663 try: self.this.append(this)
1664 except: self.this = this
1665 def get_inner_state(self, *args):
1666 """get_inner_state(PermutationStates self, unsigned int i) -> unsigned int"""
1667 return _IMP_domino.PermutationStates_get_inner_state(self, *args)
1669 def get_version_info(self):
1670 """get_version_info(PermutationStates self) -> VersionInfo"""
1671 return _IMP_domino.PermutationStates_get_version_info(self)
1673 def do_show(self, *args):
1674 """do_show(PermutationStates self, _ostream out)"""
1675 return _IMP_domino.PermutationStates_do_show(self, *args)
1677 __swig_destroy__ = _IMP_domino.delete_PermutationStates
1678 __del__ =
lambda self :
None;
1680 """__str__(PermutationStates self) -> std::string"""
1681 return _IMP_domino.PermutationStates___str__(self)
1684 """__repr__(PermutationStates self) -> std::string"""
1685 return _IMP_domino.PermutationStates___repr__(self)
1688 return _object_cast_to_PermutationStates(o)
1689 get_from = staticmethod(get_from)
1691 PermutationStates_swigregister = _IMP_domino.PermutationStates_swigregister
1692 PermutationStates_swigregister(PermutationStates)
1694 class _ParticlesAdaptor(IMP.base._InputAdaptor):
1695 """Proxy of C++ IMP::domino::ParticlesAdaptor class"""
1696 __swig_setmethods__ = {}
1697 for _s
in [IMP.base._InputAdaptor]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
1698 __setattr__ =
lambda self, name, value: _swig_setattr(self, _ParticlesAdaptor, name, value)
1699 __swig_getmethods__ = {}
1700 for _s
in [IMP.base._InputAdaptor]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
1701 __getattr__ =
lambda self, name: _swig_getattr(self, _ParticlesAdaptor, name)
1702 __repr__ = _swig_repr
1703 def __init__(self, *args):
1705 ParticlesAdaptor(ParticleStatesTable pst) -> _ParticlesAdaptor
1706 __init__(IMP::domino::ParticlesAdaptor self, IMP::kernel::ParticlesTemp const & ps) -> _ParticlesAdaptor
1708 this = _IMP_domino.new__ParticlesAdaptor(*args)
1709 try: self.this.append(this)
1710 except: self.this = this
1711 __swig_destroy__ = _IMP_domino.delete__ParticlesAdaptor
1712 __del__ =
lambda self :
None;
1713 _ParticlesAdaptor_swigregister = _IMP_domino._ParticlesAdaptor_swigregister
1714 _ParticlesAdaptor_swigregister(_ParticlesAdaptor)
1717 """Proxy of C++ IMP::domino::RestraintCache class"""
1718 __swig_setmethods__ = {}
1719 for _s
in [
IMP.base.Object]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
1720 __setattr__ =
lambda self, name, value: _swig_setattr(self, RestraintCache, name, value)
1721 __swig_getmethods__ = {}
1722 for _s
in [
IMP.base.Object]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
1723 __getattr__ =
lambda self, name: _swig_getattr(self, RestraintCache, name)
1724 def __init__(self, *args):
1726 __init__(IMP::domino::RestraintCache self, ParticleStatesTable pst, unsigned int size=std::numeric_limits< unsigned int >::max()) -> RestraintCache
1727 __init__(IMP::domino::RestraintCache self, ParticleStatesTable pst) -> RestraintCache
1729 this = _IMP_domino.new_RestraintCache(*args)
1730 try: self.this.append(this)
1731 except: self.this = this
1733 """add_restraints(RestraintCache self, IMP::kernel::RestraintsTemp const & rs)"""
1734 return _IMP_domino.RestraintCache_add_restraints(self, *args)
1736 def get_score(self, *args):
1738 get_score(RestraintCache self, Restraint r, Assignment a) -> double
1739 get_score(RestraintCache self, Restraint r, Subset s, Assignment a) -> double
1741 return _IMP_domino.RestraintCache_get_score(self, *args)
1743 def load_last_score(self, *args):
1744 """load_last_score(RestraintCache self, Restraint r, Subset s, Assignment a)"""
1745 return _IMP_domino.RestraintCache_load_last_score(self, *args)
1749 get_restraints(RestraintCache self, Subset s, IMP::domino::Subsets const & exclusions) -> IMP::kernel::RestraintsTemp
1750 get_restraints(RestraintCache self) -> IMP::kernel::RestraintsTemp
1752 return _IMP_domino.RestraintCache_get_restraints(self, *args)
1754 def save_cache(self, *args):
1756 save_cache(RestraintCache self, IMP::kernel::ParticlesTemp const & particle_ordering, IMP::kernel::RestraintsTemp const & restraints,
1757 Group group, unsigned int max_entries)
1759 return _IMP_domino.RestraintCache_save_cache(self, *args)
1761 def load_cache(self, *args):
1762 """load_cache(RestraintCache self, IMP::kernel::ParticlesTemp const & ps, ConstGroup group)"""
1763 return _IMP_domino.RestraintCache_load_cache(self, *args)
1766 """get_slice(RestraintCache self, Restraint r, Subset s) -> Slice"""
1767 return _IMP_domino.RestraintCache_get_slice(self, *args)
1769 def get_number_of_entries(self):
1770 """get_number_of_entries(RestraintCache self) -> unsigned int"""
1771 return _IMP_domino.RestraintCache_get_number_of_entries(self)
1774 """validate(RestraintCache self)"""
1775 return _IMP_domino.RestraintCache_validate(self)
1777 def show_restraint_information(self, *args):
1779 show_restraint_information(RestraintCache self, _ostream out=std::cout)
1780 show_restraint_information(RestraintCache self)
1782 return _IMP_domino.RestraintCache_show_restraint_information(self, *args)
1784 def get_hit_rate(self):
1785 """get_hit_rate(RestraintCache self) -> double"""
1786 return _IMP_domino.RestraintCache_get_hit_rate(self)
1788 def get_version_info(self):
1789 """get_version_info(RestraintCache self) -> VersionInfo"""
1790 return _IMP_domino.RestraintCache_get_version_info(self)
1792 __swig_destroy__ = _IMP_domino.delete_RestraintCache
1793 __del__ =
lambda self :
None;
1795 """__str__(RestraintCache self) -> std::string"""
1796 return _IMP_domino.RestraintCache___str__(self)
1799 """__repr__(RestraintCache self) -> std::string"""
1800 return _IMP_domino.RestraintCache___repr__(self)
1803 return _object_cast_to_RestraintCache(o)
1804 get_from = staticmethod(get_from)
1806 RestraintCache_swigregister = _IMP_domino.RestraintCache_swigregister
1807 RestraintCache_swigregister(RestraintCache)
1810 """Proxy of C++ IMP::domino::SubsetFilter class"""
1811 __swig_setmethods__ = {}
1812 for _s
in [
IMP.base.Object]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
1813 __setattr__ =
lambda self, name, value: _swig_setattr(self, SubsetFilter, name, value)
1814 __swig_getmethods__ = {}
1815 for _s
in [
IMP.base.Object]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
1816 __getattr__ =
lambda self, name: _swig_getattr(self, SubsetFilter, name)
1817 def __init__(self, name="SubsetFilter%1%"):
1819 __init__(IMP::domino::SubsetFilter self, std::string name="SubsetFilter%1%") -> SubsetFilter
1820 __init__(IMP::domino::SubsetFilter self) -> SubsetFilter
1822 if self.__class__ == SubsetFilter:
1826 this = _IMP_domino.new_SubsetFilter(_self, name)
1827 try: self.this.append(this)
1828 except: self.this = this
1829 if self.__class__ != SubsetFilter:
1831 IMP.base._director_objects.register(self)
1835 def get_is_ok(self, *args):
1836 """get_is_ok(SubsetFilter self, Assignment state) -> bool"""
1837 return _IMP_domino.SubsetFilter_get_is_ok(self, *args)
1839 def get_next_state(self, *args):
1840 """get_next_state(SubsetFilter self, int pos, Assignment state) -> int"""
1841 return _IMP_domino.SubsetFilter_get_next_state(self, *args)
1843 __swig_destroy__ = _IMP_domino.delete_SubsetFilter
1844 __del__ =
lambda self :
None;
1846 """__str__(SubsetFilter self) -> std::string"""
1847 return _IMP_domino.SubsetFilter___str__(self)
1850 """__repr__(SubsetFilter self) -> std::string"""
1851 return _IMP_domino.SubsetFilter___repr__(self)
1854 return _object_cast_to_SubsetFilter(o)
1855 get_from = staticmethod(get_from)
1857 def get_type_name(self):
1858 return self.__class__.__name__
1859 def do_show(self, out):
1861 def get_version_info(self):
1862 if"IMP::domino" ==
"IMP":
1863 return VersionInfo(
"python",
"0")
1865 return IMP.VersionInfo(
"python",
"0")
1867 return _object_cast_to_SubsetFilter(o)
1868 get_from = staticmethod(get_from)
1870 def __disown__(self):
1872 _IMP_domino.disown_SubsetFilter(self)
1873 return weakref_proxy(self)
1874 SubsetFilter_swigregister = _IMP_domino.SubsetFilter_swigregister
1875 SubsetFilter_swigregister(SubsetFilter)
1878 """Proxy of C++ IMP::domino::SubsetFilterTable class"""
1879 __swig_setmethods__ = {}
1880 for _s
in [
IMP.base.Object]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
1881 __setattr__ =
lambda self, name, value: _swig_setattr(self, SubsetFilterTable, name, value)
1882 __swig_getmethods__ = {}
1883 for _s
in [
IMP.base.Object]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
1884 __getattr__ =
lambda self, name: _swig_getattr(self, SubsetFilterTable, name)
1885 def __init__(self, name="SubsetFilterTable%1%"):
1887 __init__(IMP::domino::SubsetFilterTable self, std::string name="SubsetFilterTable%1%") -> SubsetFilterTable
1888 __init__(IMP::domino::SubsetFilterTable self) -> SubsetFilterTable
1890 if self.__class__ == SubsetFilterTable:
1894 this = _IMP_domino.new_SubsetFilterTable(_self, name)
1895 try: self.this.append(this)
1896 except: self.this = this
1897 if self.__class__ != SubsetFilterTable:
1899 IMP.base._director_objects.register(self)
1903 def get_subset_filter(self, *args):
1904 """get_subset_filter(SubsetFilterTable self, Subset s, IMP::domino::Subsets const & prior_subsets) -> SubsetFilter"""
1905 return _IMP_domino.SubsetFilterTable_get_subset_filter(self, *args)
1907 def get_strength(self, *args):
1908 """get_strength(SubsetFilterTable self, Subset s, IMP::domino::Subsets const & prior_subsets) -> double"""
1909 return _IMP_domino.SubsetFilterTable_get_strength(self, *args)
1911 __swig_destroy__ = _IMP_domino.delete_SubsetFilterTable
1912 __del__ =
lambda self :
None;
1914 """__str__(SubsetFilterTable self) -> std::string"""
1915 return _IMP_domino.SubsetFilterTable___str__(self)
1918 """__repr__(SubsetFilterTable self) -> std::string"""
1919 return _IMP_domino.SubsetFilterTable___repr__(self)
1922 return _object_cast_to_SubsetFilterTable(o)
1923 get_from = staticmethod(get_from)
1925 def get_type_name(self):
1926 return self.__class__.__name__
1927 def do_show(self, out):
1929 def get_version_info(self):
1930 if"IMP::domino" ==
"IMP":
1931 return VersionInfo(
"python",
"0")
1933 return IMP.VersionInfo(
"python",
"0")
1935 return _object_cast_to_SubsetFilterTable(o)
1936 get_from = staticmethod(get_from)
1938 def __disown__(self):
1940 _IMP_domino.disown_SubsetFilterTable(self)
1941 return weakref_proxy(self)
1942 SubsetFilterTable_swigregister = _IMP_domino.SubsetFilterTable_swigregister
1943 SubsetFilterTable_swigregister(SubsetFilterTable)
1945 class RestraintScoreSubsetFilterTable(SubsetFilterTable):
1946 """Proxy of C++ IMP::domino::RestraintScoreSubsetFilterTable class"""
1947 __swig_setmethods__ = {}
1948 for _s
in [SubsetFilterTable]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
1949 __setattr__ =
lambda self, name, value: _swig_setattr(self, RestraintScoreSubsetFilterTable, name, value)
1950 __swig_getmethods__ = {}
1951 for _s
in [SubsetFilterTable]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
1952 __getattr__ =
lambda self, name: _swig_getattr(self, RestraintScoreSubsetFilterTable, name)
1953 def __init__(self, *args):
1955 __init__(IMP::domino::RestraintScoreSubsetFilterTable self, RestraintCache rc) -> RestraintScoreSubsetFilterTable
1956 __init__(IMP::domino::RestraintScoreSubsetFilterTable self, RestraintSet rs, ParticleStatesTable pst) -> RestraintScoreSubsetFilterTable
1957 __init__(IMP::domino::RestraintScoreSubsetFilterTable self, IMP::kernel::RestraintsTemp rs, ParticleStatesTable pst) -> RestraintScoreSubsetFilterTable
1959 this = _IMP_domino.new_RestraintScoreSubsetFilterTable(*args)
1960 try: self.this.append(this)
1961 except: self.this = this
1962 def get_version_info(self):
1963 """get_version_info(RestraintScoreSubsetFilterTable self) -> VersionInfo"""
1964 return _IMP_domino.RestraintScoreSubsetFilterTable_get_version_info(self)
1966 def do_show(self, *args):
1967 """do_show(RestraintScoreSubsetFilterTable self, _ostream out)"""
1968 return _IMP_domino.RestraintScoreSubsetFilterTable_do_show(self, *args)
1970 __swig_destroy__ = _IMP_domino.delete_RestraintScoreSubsetFilterTable
1971 __del__ =
lambda self :
None;
1973 """__str__(RestraintScoreSubsetFilterTable self) -> std::string"""
1974 return _IMP_domino.RestraintScoreSubsetFilterTable___str__(self)
1977 """__repr__(RestraintScoreSubsetFilterTable self) -> std::string"""
1978 return _IMP_domino.RestraintScoreSubsetFilterTable___repr__(self)
1981 return _object_cast_to_RestraintScoreSubsetFilterTable(o)
1982 get_from = staticmethod(get_from)
1984 RestraintScoreSubsetFilterTable_swigregister = _IMP_domino.RestraintScoreSubsetFilterTable_swigregister
1985 RestraintScoreSubsetFilterTable_swigregister(RestraintScoreSubsetFilterTable)
1987 class MinimumRestraintScoreSubsetFilterTable(SubsetFilterTable):
1988 """Proxy of C++ IMP::domino::MinimumRestraintScoreSubsetFilterTable class"""
1989 __swig_setmethods__ = {}
1990 for _s
in [SubsetFilterTable]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
1991 __setattr__ =
lambda self, name, value: _swig_setattr(self, MinimumRestraintScoreSubsetFilterTable, name, value)
1992 __swig_getmethods__ = {}
1993 for _s
in [SubsetFilterTable]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
1994 __getattr__ =
lambda self, name: _swig_getattr(self, MinimumRestraintScoreSubsetFilterTable, name)
1995 def __init__(self, *args):
1996 """__init__(IMP::domino::MinimumRestraintScoreSubsetFilterTable self, IMP::kernel::RestraintsTemp const & rs, RestraintCache rc, int max_number_allowed_violations) -> MinimumRestraintScoreSubsetFilterTable"""
1997 this = _IMP_domino.new_MinimumRestraintScoreSubsetFilterTable(*args)
1998 try: self.this.append(this)
1999 except: self.this = this
2000 def get_maximum_number_of_violated_restraints(self):
2001 """get_maximum_number_of_violated_restraints(MinimumRestraintScoreSubsetFilterTable self) -> int"""
2002 return _IMP_domino.MinimumRestraintScoreSubsetFilterTable_get_maximum_number_of_violated_restraints(self)
2004 def get_version_info(self):
2005 """get_version_info(MinimumRestraintScoreSubsetFilterTable self) -> VersionInfo"""
2006 return _IMP_domino.MinimumRestraintScoreSubsetFilterTable_get_version_info(self)
2008 def do_show(self, *args):
2009 """do_show(MinimumRestraintScoreSubsetFilterTable self, _ostream out)"""
2010 return _IMP_domino.MinimumRestraintScoreSubsetFilterTable_do_show(self, *args)
2012 __swig_destroy__ = _IMP_domino.delete_MinimumRestraintScoreSubsetFilterTable
2013 __del__ =
lambda self :
None;
2015 """__str__(MinimumRestraintScoreSubsetFilterTable self) -> std::string"""
2016 return _IMP_domino.MinimumRestraintScoreSubsetFilterTable___str__(self)
2019 """__repr__(MinimumRestraintScoreSubsetFilterTable self) -> std::string"""
2020 return _IMP_domino.MinimumRestraintScoreSubsetFilterTable___repr__(self)
2023 return _object_cast_to_MinimumRestraintScoreSubsetFilterTable(o)
2024 get_from = staticmethod(get_from)
2026 MinimumRestraintScoreSubsetFilterTable_swigregister = _IMP_domino.MinimumRestraintScoreSubsetFilterTable_swigregister
2027 MinimumRestraintScoreSubsetFilterTable_swigregister(MinimumRestraintScoreSubsetFilterTable)
2029 class DisjointSetsSubsetFilterTable(SubsetFilterTable):
2030 """Proxy of C++ IMP::domino::DisjointSetsSubsetFilterTable class"""
2031 __swig_setmethods__ = {}
2032 for _s
in [SubsetFilterTable]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2033 __setattr__ =
lambda self, name, value: _swig_setattr(self, DisjointSetsSubsetFilterTable, name, value)
2034 __swig_getmethods__ = {}
2035 for _s
in [SubsetFilterTable]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2036 __getattr__ =
lambda self, name: _swig_getattr(self, DisjointSetsSubsetFilterTable, name)
2037 def __init__(self, *args, **kwargs):
raise AttributeError(
"No constructor defined - class is abstract")
2038 def add_set(self, *args):
2039 """add_set(DisjointSetsSubsetFilterTable self, IMP::kernel::ParticlesTemp const & ps)"""
2040 return _IMP_domino.DisjointSetsSubsetFilterTable_add_set(self, *args)
2042 def add_pair(self, *args):
2043 """add_pair(DisjointSetsSubsetFilterTable self, IMP::kernel::ParticlePair const & pp)"""
2044 return _IMP_domino.DisjointSetsSubsetFilterTable_add_pair(self, *args)
2047 """__str__(DisjointSetsSubsetFilterTable self) -> std::string"""
2048 return _IMP_domino.DisjointSetsSubsetFilterTable___str__(self)
2051 """__repr__(DisjointSetsSubsetFilterTable self) -> std::string"""
2052 return _IMP_domino.DisjointSetsSubsetFilterTable___repr__(self)
2055 return _object_cast_to_DisjointSetsSubsetFilterTable(o)
2056 get_from = staticmethod(get_from)
2058 __swig_destroy__ = _IMP_domino.delete_DisjointSetsSubsetFilterTable
2059 __del__ =
lambda self :
None;
2060 DisjointSetsSubsetFilterTable_swigregister = _IMP_domino.DisjointSetsSubsetFilterTable_swigregister
2061 DisjointSetsSubsetFilterTable_swigregister(DisjointSetsSubsetFilterTable)
2063 class ExclusionSubsetFilterTable(DisjointSetsSubsetFilterTable):
2064 """Proxy of C++ IMP::domino::ExclusionSubsetFilterTable class"""
2065 __swig_setmethods__ = {}
2066 for _s
in [DisjointSetsSubsetFilterTable]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2067 __setattr__ =
lambda self, name, value: _swig_setattr(self, ExclusionSubsetFilterTable, name, value)
2068 __swig_getmethods__ = {}
2069 for _s
in [DisjointSetsSubsetFilterTable]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2070 __getattr__ =
lambda self, name: _swig_getattr(self, ExclusionSubsetFilterTable, name)
2071 def __init__(self, *args):
2073 __init__(IMP::domino::ExclusionSubsetFilterTable self, ParticleStatesTable pst) -> ExclusionSubsetFilterTable
2074 __init__(IMP::domino::ExclusionSubsetFilterTable self) -> ExclusionSubsetFilterTable
2076 this = _IMP_domino.new_ExclusionSubsetFilterTable(*args)
2077 try: self.this.append(this)
2078 except: self.this = this
2079 def get_version_info(self):
2080 """get_version_info(ExclusionSubsetFilterTable self) -> VersionInfo"""
2081 return _IMP_domino.ExclusionSubsetFilterTable_get_version_info(self)
2083 def do_show(self, *args):
2084 """do_show(ExclusionSubsetFilterTable self, _ostream out)"""
2085 return _IMP_domino.ExclusionSubsetFilterTable_do_show(self, *args)
2087 __swig_destroy__ = _IMP_domino.delete_ExclusionSubsetFilterTable
2088 __del__ =
lambda self :
None;
2090 """__str__(ExclusionSubsetFilterTable self) -> std::string"""
2091 return _IMP_domino.ExclusionSubsetFilterTable___str__(self)
2094 """__repr__(ExclusionSubsetFilterTable self) -> std::string"""
2095 return _IMP_domino.ExclusionSubsetFilterTable___repr__(self)
2098 return _object_cast_to_ExclusionSubsetFilterTable(o)
2099 get_from = staticmethod(get_from)
2101 ExclusionSubsetFilterTable_swigregister = _IMP_domino.ExclusionSubsetFilterTable_swigregister
2102 ExclusionSubsetFilterTable_swigregister(ExclusionSubsetFilterTable)
2104 class EqualitySubsetFilterTable(DisjointSetsSubsetFilterTable):
2105 """Proxy of C++ IMP::domino::EqualitySubsetFilterTable class"""
2106 __swig_setmethods__ = {}
2107 for _s
in [DisjointSetsSubsetFilterTable]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2108 __setattr__ =
lambda self, name, value: _swig_setattr(self, EqualitySubsetFilterTable, name, value)
2109 __swig_getmethods__ = {}
2110 for _s
in [DisjointSetsSubsetFilterTable]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2111 __getattr__ =
lambda self, name: _swig_getattr(self, EqualitySubsetFilterTable, name)
2112 def __init__(self, *args):
2114 __init__(IMP::domino::EqualitySubsetFilterTable self, ParticleStatesTable pst) -> EqualitySubsetFilterTable
2115 __init__(IMP::domino::EqualitySubsetFilterTable self) -> EqualitySubsetFilterTable
2117 this = _IMP_domino.new_EqualitySubsetFilterTable(*args)
2118 try: self.this.append(this)
2119 except: self.this = this
2120 def get_version_info(self):
2121 """get_version_info(EqualitySubsetFilterTable self) -> VersionInfo"""
2122 return _IMP_domino.EqualitySubsetFilterTable_get_version_info(self)
2124 def do_show(self, *args):
2125 """do_show(EqualitySubsetFilterTable self, _ostream out)"""
2126 return _IMP_domino.EqualitySubsetFilterTable_do_show(self, *args)
2128 __swig_destroy__ = _IMP_domino.delete_EqualitySubsetFilterTable
2129 __del__ =
lambda self :
None;
2131 """__str__(EqualitySubsetFilterTable self) -> std::string"""
2132 return _IMP_domino.EqualitySubsetFilterTable___str__(self)
2135 """__repr__(EqualitySubsetFilterTable self) -> std::string"""
2136 return _IMP_domino.EqualitySubsetFilterTable___repr__(self)
2139 return _object_cast_to_EqualitySubsetFilterTable(o)
2140 get_from = staticmethod(get_from)
2142 EqualitySubsetFilterTable_swigregister = _IMP_domino.EqualitySubsetFilterTable_swigregister
2143 EqualitySubsetFilterTable_swigregister(EqualitySubsetFilterTable)
2145 class EquivalenceSubsetFilterTable(DisjointSetsSubsetFilterTable):
2146 """Proxy of C++ IMP::domino::EquivalenceSubsetFilterTable class"""
2147 __swig_setmethods__ = {}
2148 for _s
in [DisjointSetsSubsetFilterTable]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2149 __setattr__ =
lambda self, name, value: _swig_setattr(self, EquivalenceSubsetFilterTable, name, value)
2150 __swig_getmethods__ = {}
2151 for _s
in [DisjointSetsSubsetFilterTable]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2152 __getattr__ =
lambda self, name: _swig_getattr(self, EquivalenceSubsetFilterTable, name)
2153 def __init__(self, *args):
2155 __init__(IMP::domino::EquivalenceSubsetFilterTable self, ParticleStatesTable pst) -> EquivalenceSubsetFilterTable
2156 __init__(IMP::domino::EquivalenceSubsetFilterTable self) -> EquivalenceSubsetFilterTable
2158 this = _IMP_domino.new_EquivalenceSubsetFilterTable(*args)
2159 try: self.this.append(this)
2160 except: self.this = this
2161 def get_version_info(self):
2162 """get_version_info(EquivalenceSubsetFilterTable self) -> VersionInfo"""
2163 return _IMP_domino.EquivalenceSubsetFilterTable_get_version_info(self)
2165 def do_show(self, *args):
2166 """do_show(EquivalenceSubsetFilterTable self, _ostream out)"""
2167 return _IMP_domino.EquivalenceSubsetFilterTable_do_show(self, *args)
2169 __swig_destroy__ = _IMP_domino.delete_EquivalenceSubsetFilterTable
2170 __del__ =
lambda self :
None;
2172 """__str__(EquivalenceSubsetFilterTable self) -> std::string"""
2173 return _IMP_domino.EquivalenceSubsetFilterTable___str__(self)
2176 """__repr__(EquivalenceSubsetFilterTable self) -> std::string"""
2177 return _IMP_domino.EquivalenceSubsetFilterTable___repr__(self)
2180 return _object_cast_to_EquivalenceSubsetFilterTable(o)
2181 get_from = staticmethod(get_from)
2183 EquivalenceSubsetFilterTable_swigregister = _IMP_domino.EquivalenceSubsetFilterTable_swigregister
2184 EquivalenceSubsetFilterTable_swigregister(EquivalenceSubsetFilterTable)
2186 class EquivalenceAndExclusionSubsetFilterTable(DisjointSetsSubsetFilterTable):
2187 """Proxy of C++ IMP::domino::EquivalenceAndExclusionSubsetFilterTable class"""
2188 __swig_setmethods__ = {}
2189 for _s
in [DisjointSetsSubsetFilterTable]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2190 __setattr__ =
lambda self, name, value: _swig_setattr(self, EquivalenceAndExclusionSubsetFilterTable, name, value)
2191 __swig_getmethods__ = {}
2192 for _s
in [DisjointSetsSubsetFilterTable]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2193 __getattr__ =
lambda self, name: _swig_getattr(self, EquivalenceAndExclusionSubsetFilterTable, name)
2194 def __init__(self, *args):
2196 __init__(IMP::domino::EquivalenceAndExclusionSubsetFilterTable self, ParticleStatesTable pst) -> EquivalenceAndExclusionSubsetFilterTable
2197 __init__(IMP::domino::EquivalenceAndExclusionSubsetFilterTable self) -> EquivalenceAndExclusionSubsetFilterTable
2199 this = _IMP_domino.new_EquivalenceAndExclusionSubsetFilterTable(*args)
2200 try: self.this.append(this)
2201 except: self.this = this
2202 def get_version_info(self):
2203 """get_version_info(EquivalenceAndExclusionSubsetFilterTable self) -> VersionInfo"""
2204 return _IMP_domino.EquivalenceAndExclusionSubsetFilterTable_get_version_info(self)
2206 def do_show(self, *args):
2207 """do_show(EquivalenceAndExclusionSubsetFilterTable self, _ostream out)"""
2208 return _IMP_domino.EquivalenceAndExclusionSubsetFilterTable_do_show(self, *args)
2210 __swig_destroy__ = _IMP_domino.delete_EquivalenceAndExclusionSubsetFilterTable
2211 __del__ =
lambda self :
None;
2213 """__str__(EquivalenceAndExclusionSubsetFilterTable self) -> std::string"""
2214 return _IMP_domino.EquivalenceAndExclusionSubsetFilterTable___str__(self)
2217 """__repr__(EquivalenceAndExclusionSubsetFilterTable self) -> std::string"""
2218 return _IMP_domino.EquivalenceAndExclusionSubsetFilterTable___repr__(self)
2221 return _object_cast_to_EquivalenceAndExclusionSubsetFilterTable(o)
2222 get_from = staticmethod(get_from)
2224 EquivalenceAndExclusionSubsetFilterTable_swigregister = _IMP_domino.EquivalenceAndExclusionSubsetFilterTable_swigregister
2225 EquivalenceAndExclusionSubsetFilterTable_swigregister(EquivalenceAndExclusionSubsetFilterTable)
2227 class ListSubsetFilterTable(SubsetFilterTable):
2228 """Proxy of C++ IMP::domino::ListSubsetFilterTable class"""
2229 __swig_setmethods__ = {}
2230 for _s
in [SubsetFilterTable]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2231 __setattr__ =
lambda self, name, value: _swig_setattr(self, ListSubsetFilterTable, name, value)
2232 __swig_getmethods__ = {}
2233 for _s
in [SubsetFilterTable]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2234 __getattr__ =
lambda self, name: _swig_getattr(self, ListSubsetFilterTable, name)
2235 def __init__(self, *args):
2236 """__init__(IMP::domino::ListSubsetFilterTable self, ParticleStatesTable pst) -> ListSubsetFilterTable"""
2237 this = _IMP_domino.new_ListSubsetFilterTable(*args)
2238 try: self.this.append(this)
2239 except: self.this = this
2240 def get_ok_rate(self):
2241 """get_ok_rate(ListSubsetFilterTable self) -> double"""
2242 return _IMP_domino.ListSubsetFilterTable_get_ok_rate(self)
2244 def get_number_of_particle_states(self, *args):
2245 """get_number_of_particle_states(ListSubsetFilterTable self, Particle p) -> unsigned int"""
2246 return _IMP_domino.ListSubsetFilterTable_get_number_of_particle_states(self, *args)
2248 def set_allowed_states(self, *args):
2249 """set_allowed_states(ListSubsetFilterTable self, Particle p, IMP::Ints const & states)"""
2250 return _IMP_domino.ListSubsetFilterTable_set_allowed_states(self, *args)
2252 def get_version_info(self):
2253 """get_version_info(ListSubsetFilterTable self) -> VersionInfo"""
2254 return _IMP_domino.ListSubsetFilterTable_get_version_info(self)
2256 def do_show(self, *args):
2257 """do_show(ListSubsetFilterTable self, _ostream out)"""
2258 return _IMP_domino.ListSubsetFilterTable_do_show(self, *args)
2260 __swig_destroy__ = _IMP_domino.delete_ListSubsetFilterTable
2261 __del__ =
lambda self :
None;
2263 """__str__(ListSubsetFilterTable self) -> std::string"""
2264 return _IMP_domino.ListSubsetFilterTable___str__(self)
2267 """__repr__(ListSubsetFilterTable self) -> std::string"""
2268 return _IMP_domino.ListSubsetFilterTable___repr__(self)
2271 return _object_cast_to_ListSubsetFilterTable(o)
2272 get_from = staticmethod(get_from)
2274 ListSubsetFilterTable_swigregister = _IMP_domino.ListSubsetFilterTable_swigregister
2275 ListSubsetFilterTable_swigregister(ListSubsetFilterTable)
2277 class PairListSubsetFilterTable(SubsetFilterTable):
2278 """Proxy of C++ IMP::domino::PairListSubsetFilterTable class"""
2279 __swig_setmethods__ = {}
2280 for _s
in [SubsetFilterTable]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2281 __setattr__ =
lambda self, name, value: _swig_setattr(self, PairListSubsetFilterTable, name, value)
2282 __swig_getmethods__ = {}
2283 for _s
in [SubsetFilterTable]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2284 __getattr__ =
lambda self, name: _swig_getattr(self, PairListSubsetFilterTable, name)
2286 """__init__(IMP::domino::PairListSubsetFilterTable self) -> PairListSubsetFilterTable"""
2287 this = _IMP_domino.new_PairListSubsetFilterTable()
2288 try: self.this.append(this)
2289 except: self.this = this
2290 def set_allowed_states(self, *args):
2291 """set_allowed_states(PairListSubsetFilterTable self, IMP::kernel::ParticlePair p, IMP::IntPairs const & states)"""
2292 return _IMP_domino.PairListSubsetFilterTable_set_allowed_states(self, *args)
2294 def get_version_info(self):
2295 """get_version_info(PairListSubsetFilterTable self) -> VersionInfo"""
2296 return _IMP_domino.PairListSubsetFilterTable_get_version_info(self)
2298 def do_show(self, *args):
2299 """do_show(PairListSubsetFilterTable self, _ostream out)"""
2300 return _IMP_domino.PairListSubsetFilterTable_do_show(self, *args)
2302 __swig_destroy__ = _IMP_domino.delete_PairListSubsetFilterTable
2303 __del__ =
lambda self :
None;
2305 """__str__(PairListSubsetFilterTable self) -> std::string"""
2306 return _IMP_domino.PairListSubsetFilterTable___str__(self)
2309 """__repr__(PairListSubsetFilterTable self) -> std::string"""
2310 return _IMP_domino.PairListSubsetFilterTable___repr__(self)
2313 return _object_cast_to_PairListSubsetFilterTable(o)
2314 get_from = staticmethod(get_from)
2316 PairListSubsetFilterTable_swigregister = _IMP_domino.PairListSubsetFilterTable_swigregister
2317 PairListSubsetFilterTable_swigregister(PairListSubsetFilterTable)
2319 class ProbabilisticSubsetFilterTable(SubsetFilterTable):
2320 """Proxy of C++ IMP::domino::ProbabilisticSubsetFilterTable class"""
2321 __swig_setmethods__ = {}
2322 for _s
in [SubsetFilterTable]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2323 __setattr__ =
lambda self, name, value: _swig_setattr(self, ProbabilisticSubsetFilterTable, name, value)
2324 __swig_getmethods__ = {}
2325 for _s
in [SubsetFilterTable]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2326 __getattr__ =
lambda self, name: _swig_getattr(self, ProbabilisticSubsetFilterTable, name)
2327 def __init__(self, *args):
2329 __init__(IMP::domino::ProbabilisticSubsetFilterTable self, double p, bool leaves_only=False) -> ProbabilisticSubsetFilterTable
2330 __init__(IMP::domino::ProbabilisticSubsetFilterTable self, double p) -> ProbabilisticSubsetFilterTable
2332 this = _IMP_domino.new_ProbabilisticSubsetFilterTable(*args)
2333 try: self.this.append(this)
2334 except: self.this = this
2335 def get_version_info(self):
2336 """get_version_info(ProbabilisticSubsetFilterTable self) -> VersionInfo"""
2337 return _IMP_domino.ProbabilisticSubsetFilterTable_get_version_info(self)
2339 def do_show(self, *args):
2340 """do_show(ProbabilisticSubsetFilterTable self, _ostream out)"""
2341 return _IMP_domino.ProbabilisticSubsetFilterTable_do_show(self, *args)
2343 __swig_destroy__ = _IMP_domino.delete_ProbabilisticSubsetFilterTable
2344 __del__ =
lambda self :
None;
2346 """__str__(ProbabilisticSubsetFilterTable self) -> std::string"""
2347 return _IMP_domino.ProbabilisticSubsetFilterTable___str__(self)
2350 """__repr__(ProbabilisticSubsetFilterTable self) -> std::string"""
2351 return _IMP_domino.ProbabilisticSubsetFilterTable___repr__(self)
2354 return _object_cast_to_ProbabilisticSubsetFilterTable(o)
2355 get_from = staticmethod(get_from)
2357 ProbabilisticSubsetFilterTable_swigregister = _IMP_domino.ProbabilisticSubsetFilterTable_swigregister
2358 ProbabilisticSubsetFilterTable_swigregister(ProbabilisticSubsetFilterTable)
2361 """Proxy of C++ IMP::domino::AssignmentContainer class"""
2362 __swig_setmethods__ = {}
2363 for _s
in [
IMP.base.Object]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2364 __setattr__ =
lambda self, name, value: _swig_setattr(self, AssignmentContainer, name, value)
2365 __swig_getmethods__ = {}
2366 for _s
in [
IMP.base.Object]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2367 __getattr__ =
lambda self, name: _swig_getattr(self, AssignmentContainer, name)
2368 def __init__(self, name="AssignmentsContainer %1%"):
2370 __init__(IMP::domino::AssignmentContainer self, std::string name="AssignmentsContainer %1%") -> AssignmentContainer
2371 __init__(IMP::domino::AssignmentContainer self) -> AssignmentContainer
2373 if self.__class__ == AssignmentContainer:
2377 this = _IMP_domino.new_AssignmentContainer(_self, name)
2378 try: self.this.append(this)
2379 except: self.this = this
2380 if self.__class__ != AssignmentContainer:
2382 IMP.base._director_objects.register(self)
2386 def get_number_of_assignments(self):
2387 """get_number_of_assignments(AssignmentContainer self) -> unsigned int"""
2388 return _IMP_domino.AssignmentContainer_get_number_of_assignments(self)
2390 def get_assignment(self, *args):
2391 """get_assignment(AssignmentContainer self, unsigned int i) -> Assignment"""
2392 return _IMP_domino.AssignmentContainer_get_assignment(self, *args)
2394 def get_assignments(self, *args):
2396 get_assignments(AssignmentContainer self, IMP::IntRange ir) -> IMP::domino::Assignments
2397 get_assignments(AssignmentContainer self) -> IMP::domino::Assignments
2399 return _IMP_domino.AssignmentContainer_get_assignments(self, *args)
2401 def add_assignment(self, *args):
2402 """add_assignment(AssignmentContainer self, Assignment a)"""
2403 return _IMP_domino.AssignmentContainer_add_assignment(self, *args)
2405 def add_assignments(self, *args):
2406 """add_assignments(AssignmentContainer self, IMP::domino::Assignments const & as)"""
2407 return _IMP_domino.AssignmentContainer_add_assignments(self, *args)
2409 def get_particle_assignments(self, *args):
2410 """get_particle_assignments(AssignmentContainer self, unsigned int i) -> IMP::Ints"""
2411 return _IMP_domino.AssignmentContainer_get_particle_assignments(self, *args)
2413 __swig_destroy__ = _IMP_domino.delete_AssignmentContainer
2414 __del__ =
lambda self :
None;
2416 """__str__(AssignmentContainer self) -> std::string"""
2417 return _IMP_domino.AssignmentContainer___str__(self)
2420 """__repr__(AssignmentContainer self) -> std::string"""
2421 return _IMP_domino.AssignmentContainer___repr__(self)
2424 return _object_cast_to_AssignmentContainer(o)
2425 get_from = staticmethod(get_from)
2427 def get_type_name(self):
2428 return self.__class__.__name__
2429 def do_show(self, out):
2431 def get_version_info(self):
2432 if"IMP::domino" ==
"IMP":
2433 return VersionInfo(
"python",
"0")
2435 return IMP.VersionInfo(
"python",
"0")
2437 return _object_cast_to_AssignmentContainer(o)
2438 get_from = staticmethod(get_from)
2440 def __disown__(self):
2442 _IMP_domino.disown_AssignmentContainer(self)
2443 return weakref_proxy(self)
2444 AssignmentContainer_swigregister = _IMP_domino.AssignmentContainer_swigregister
2445 AssignmentContainer_swigregister(AssignmentContainer)
2447 class PackedAssignmentContainer(AssignmentContainer):
2448 """Proxy of C++ IMP::domino::PackedAssignmentContainer class"""
2449 __swig_setmethods__ = {}
2450 for _s
in [AssignmentContainer]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2451 __setattr__ =
lambda self, name, value: _swig_setattr(self, PackedAssignmentContainer, name, value)
2452 __swig_getmethods__ = {}
2453 for _s
in [AssignmentContainer]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2454 __getattr__ =
lambda self, name: _swig_getattr(self, PackedAssignmentContainer, name)
2455 def __init__(self, name="PackedAssignmentsContainer %1%"):
2457 __init__(IMP::domino::PackedAssignmentContainer self, std::string name="PackedAssignmentsContainer %1%") -> PackedAssignmentContainer
2458 __init__(IMP::domino::PackedAssignmentContainer self) -> PackedAssignmentContainer
2460 this = _IMP_domino.new_PackedAssignmentContainer(name)
2461 try: self.this.append(this)
2462 except: self.this = this
2463 def get_assignments(self, *args):
2465 get_assignments(PackedAssignmentContainer self, IMP::IntRange r) -> IMP::domino::Assignments
2466 get_assignments(PackedAssignmentContainer self) -> IMP::domino::Assignments
2468 return _IMP_domino.PackedAssignmentContainer_get_assignments(self, *args)
2470 def get_version_info(self):
2471 """get_version_info(PackedAssignmentContainer self) -> VersionInfo"""
2472 return _IMP_domino.PackedAssignmentContainer_get_version_info(self)
2474 def do_show(self, *args):
2475 """do_show(PackedAssignmentContainer self, _ostream out)"""
2476 return _IMP_domino.PackedAssignmentContainer_do_show(self, *args)
2478 __swig_destroy__ = _IMP_domino.delete_PackedAssignmentContainer
2479 __del__ =
lambda self :
None;
2481 """__str__(PackedAssignmentContainer self) -> std::string"""
2482 return _IMP_domino.PackedAssignmentContainer___str__(self)
2485 """__repr__(PackedAssignmentContainer self) -> std::string"""
2486 return _IMP_domino.PackedAssignmentContainer___repr__(self)
2489 return _object_cast_to_PackedAssignmentContainer(o)
2490 get_from = staticmethod(get_from)
2492 PackedAssignmentContainer_swigregister = _IMP_domino.PackedAssignmentContainer_swigregister
2493 PackedAssignmentContainer_swigregister(PackedAssignmentContainer)
2495 class ListAssignmentContainer(AssignmentContainer):
2496 """Proxy of C++ IMP::domino::ListAssignmentContainer class"""
2497 __swig_setmethods__ = {}
2498 for _s
in [AssignmentContainer]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2499 __setattr__ =
lambda self, name, value: _swig_setattr(self, ListAssignmentContainer, name, value)
2500 __swig_getmethods__ = {}
2501 for _s
in [AssignmentContainer]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2502 __getattr__ =
lambda self, name: _swig_getattr(self, ListAssignmentContainer, name)
2503 def __init__(self, name="ListAssignmentsContainer %1%"):
2505 __init__(IMP::domino::ListAssignmentContainer self, std::string name="ListAssignmentsContainer %1%") -> ListAssignmentContainer
2506 __init__(IMP::domino::ListAssignmentContainer self) -> ListAssignmentContainer
2508 this = _IMP_domino.new_ListAssignmentContainer(name)
2509 try: self.this.append(this)
2510 except: self.this = this
2511 def get_assignments(self, *args):
2513 get_assignments(ListAssignmentContainer self, IMP::IntRange r) -> IMP::domino::Assignments
2514 get_assignments(ListAssignmentContainer self) -> IMP::domino::Assignments
2516 return _IMP_domino.ListAssignmentContainer_get_assignments(self, *args)
2518 def get_version_info(self):
2519 """get_version_info(ListAssignmentContainer self) -> VersionInfo"""
2520 return _IMP_domino.ListAssignmentContainer_get_version_info(self)
2522 def do_show(self, *args):
2523 """do_show(ListAssignmentContainer self, _ostream out)"""
2524 return _IMP_domino.ListAssignmentContainer_do_show(self, *args)
2526 __swig_destroy__ = _IMP_domino.delete_ListAssignmentContainer
2527 __del__ =
lambda self :
None;
2529 """__str__(ListAssignmentContainer self) -> std::string"""
2530 return _IMP_domino.ListAssignmentContainer___str__(self)
2533 """__repr__(ListAssignmentContainer self) -> std::string"""
2534 return _IMP_domino.ListAssignmentContainer___repr__(self)
2537 return _object_cast_to_ListAssignmentContainer(o)
2538 get_from = staticmethod(get_from)
2540 ListAssignmentContainer_swigregister = _IMP_domino.ListAssignmentContainer_swigregister
2541 ListAssignmentContainer_swigregister(ListAssignmentContainer)
2543 class SampleAssignmentContainer(AssignmentContainer):
2544 """Proxy of C++ IMP::domino::SampleAssignmentContainer class"""
2545 __swig_setmethods__ = {}
2546 for _s
in [AssignmentContainer]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2547 __setattr__ =
lambda self, name, value: _swig_setattr(self, SampleAssignmentContainer, name, value)
2548 __swig_getmethods__ = {}
2549 for _s
in [AssignmentContainer]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2550 __getattr__ =
lambda self, name: _swig_getattr(self, SampleAssignmentContainer, name)
2551 def __init__(self, *args):
2553 __init__(IMP::domino::SampleAssignmentContainer self, unsigned int k, std::string name="SampleAssignmentsContainer %1%") -> SampleAssignmentContainer
2554 __init__(IMP::domino::SampleAssignmentContainer self, unsigned int k) -> SampleAssignmentContainer
2556 this = _IMP_domino.new_SampleAssignmentContainer(*args)
2557 try: self.this.append(this)
2558 except: self.this = this
2559 def get_assignments(self, *args):
2561 get_assignments(SampleAssignmentContainer self, IMP::IntRange r) -> IMP::domino::Assignments
2562 get_assignments(SampleAssignmentContainer self) -> IMP::domino::Assignments
2564 return _IMP_domino.SampleAssignmentContainer_get_assignments(self, *args)
2566 def get_version_info(self):
2567 """get_version_info(SampleAssignmentContainer self) -> VersionInfo"""
2568 return _IMP_domino.SampleAssignmentContainer_get_version_info(self)
2570 def do_show(self, *args):
2571 """do_show(SampleAssignmentContainer self, _ostream out)"""
2572 return _IMP_domino.SampleAssignmentContainer_do_show(self, *args)
2574 __swig_destroy__ = _IMP_domino.delete_SampleAssignmentContainer
2575 __del__ =
lambda self :
None;
2577 """__str__(SampleAssignmentContainer self) -> std::string"""
2578 return _IMP_domino.SampleAssignmentContainer___str__(self)
2581 """__repr__(SampleAssignmentContainer self) -> std::string"""
2582 return _IMP_domino.SampleAssignmentContainer___repr__(self)
2585 return _object_cast_to_SampleAssignmentContainer(o)
2586 get_from = staticmethod(get_from)
2588 SampleAssignmentContainer_swigregister = _IMP_domino.SampleAssignmentContainer_swigregister
2589 SampleAssignmentContainer_swigregister(SampleAssignmentContainer)
2591 class WriteHDF5AssignmentContainer(AssignmentContainer):
2592 """Proxy of C++ IMP::domino::WriteHDF5AssignmentContainer class"""
2593 __swig_setmethods__ = {}
2594 for _s
in [AssignmentContainer]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2595 __setattr__ =
lambda self, name, value: _swig_setattr(self, WriteHDF5AssignmentContainer, name, value)
2596 __swig_getmethods__ = {}
2597 for _s
in [AssignmentContainer]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2598 __getattr__ =
lambda self, name: _swig_getattr(self, WriteHDF5AssignmentContainer, name)
2599 def __init__(self, *args):
2601 __init__(IMP::domino::WriteHDF5AssignmentContainer self, Group parent, Subset s, IMP::kernel::ParticlesTemp const & all_particles, std::string name) -> WriteHDF5AssignmentContainer
2602 __init__(IMP::domino::WriteHDF5AssignmentContainer self, IndexDataSet2D dataset, Subset s, IMP::kernel::ParticlesTemp const & all_particles,
2603 std::string name) -> WriteHDF5AssignmentContainer
2605 this = _IMP_domino.new_WriteHDF5AssignmentContainer(*args)
2606 try: self.this.append(this)
2607 except: self.this = this
2608 def set_cache_size(self, *args):
2609 """set_cache_size(WriteHDF5AssignmentContainer self, unsigned int words)"""
2610 return _IMP_domino.WriteHDF5AssignmentContainer_set_cache_size(self, *args)
2612 def get_assignments(self, *args):
2614 get_assignments(WriteHDF5AssignmentContainer self, IMP::IntRange r) -> IMP::domino::Assignments
2615 get_assignments(WriteHDF5AssignmentContainer self) -> IMP::domino::Assignments
2617 return _IMP_domino.WriteHDF5AssignmentContainer_get_assignments(self, *args)
2619 def get_version_info(self):
2620 """get_version_info(WriteHDF5AssignmentContainer self) -> VersionInfo"""
2621 return _IMP_domino.WriteHDF5AssignmentContainer_get_version_info(self)
2623 __swig_destroy__ = _IMP_domino.delete_WriteHDF5AssignmentContainer
2624 __del__ =
lambda self :
None;
2626 """__str__(WriteHDF5AssignmentContainer self) -> std::string"""
2627 return _IMP_domino.WriteHDF5AssignmentContainer___str__(self)
2630 """__repr__(WriteHDF5AssignmentContainer self) -> std::string"""
2631 return _IMP_domino.WriteHDF5AssignmentContainer___repr__(self)
2634 return _object_cast_to_WriteHDF5AssignmentContainer(o)
2635 get_from = staticmethod(get_from)
2637 WriteHDF5AssignmentContainer_swigregister = _IMP_domino.WriteHDF5AssignmentContainer_swigregister
2638 WriteHDF5AssignmentContainer_swigregister(WriteHDF5AssignmentContainer)
2640 class ReadHDF5AssignmentContainer(AssignmentContainer):
2641 """Proxy of C++ IMP::domino::ReadHDF5AssignmentContainer class"""
2642 __swig_setmethods__ = {}
2643 for _s
in [AssignmentContainer]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2644 __setattr__ =
lambda self, name, value: _swig_setattr(self, ReadHDF5AssignmentContainer, name, value)
2645 __swig_getmethods__ = {}
2646 for _s
in [AssignmentContainer]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2647 __getattr__ =
lambda self, name: _swig_getattr(self, ReadHDF5AssignmentContainer, name)
2648 def __init__(self, *args):
2650 __init__(IMP::domino::ReadHDF5AssignmentContainer self, IndexConstDataSet2D dataset, Subset s, IMP::kernel::ParticlesTemp const & all_particles,
2651 std::string name) -> ReadHDF5AssignmentContainer
2653 this = _IMP_domino.new_ReadHDF5AssignmentContainer(*args)
2654 try: self.this.append(this)
2655 except: self.this = this
2656 def set_cache_size(self, *args):
2657 """set_cache_size(ReadHDF5AssignmentContainer self, unsigned int words)"""
2658 return _IMP_domino.ReadHDF5AssignmentContainer_set_cache_size(self, *args)
2660 def get_assignments(self, *args):
2662 get_assignments(ReadHDF5AssignmentContainer self, IMP::IntRange r) -> IMP::domino::Assignments
2663 get_assignments(ReadHDF5AssignmentContainer self) -> IMP::domino::Assignments
2665 return _IMP_domino.ReadHDF5AssignmentContainer_get_assignments(self, *args)
2667 def get_version_info(self):
2668 """get_version_info(ReadHDF5AssignmentContainer self) -> VersionInfo"""
2669 return _IMP_domino.ReadHDF5AssignmentContainer_get_version_info(self)
2671 __swig_destroy__ = _IMP_domino.delete_ReadHDF5AssignmentContainer
2672 __del__ =
lambda self :
None;
2674 """__str__(ReadHDF5AssignmentContainer self) -> std::string"""
2675 return _IMP_domino.ReadHDF5AssignmentContainer___str__(self)
2678 """__repr__(ReadHDF5AssignmentContainer self) -> std::string"""
2679 return _IMP_domino.ReadHDF5AssignmentContainer___repr__(self)
2682 return _object_cast_to_ReadHDF5AssignmentContainer(o)
2683 get_from = staticmethod(get_from)
2685 ReadHDF5AssignmentContainer_swigregister = _IMP_domino.ReadHDF5AssignmentContainer_swigregister
2686 ReadHDF5AssignmentContainer_swigregister(ReadHDF5AssignmentContainer)
2688 class WriteAssignmentContainer(AssignmentContainer):
2689 """Proxy of C++ IMP::domino::WriteAssignmentContainer class"""
2690 __swig_setmethods__ = {}
2691 for _s
in [AssignmentContainer]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2692 __setattr__ =
lambda self, name, value: _swig_setattr(self, WriteAssignmentContainer, name, value)
2693 __swig_getmethods__ = {}
2694 for _s
in [AssignmentContainer]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2695 __getattr__ =
lambda self, name: _swig_getattr(self, WriteAssignmentContainer, name)
2696 def __init__(self, *args):
2698 __init__(IMP::domino::WriteAssignmentContainer self, std::string out_file, Subset s, IMP::kernel::ParticlesTemp const & all_particles,
2699 std::string name) -> WriteAssignmentContainer
2701 this = _IMP_domino.new_WriteAssignmentContainer(*args)
2702 try: self.this.append(this)
2703 except: self.this = this
2704 def set_cache_size(self, *args):
2705 """set_cache_size(WriteAssignmentContainer self, unsigned int words)"""
2706 return _IMP_domino.WriteAssignmentContainer_set_cache_size(self, *args)
2708 def get_assignments(self, *args):
2710 get_assignments(WriteAssignmentContainer self, IMP::IntRange r) -> IMP::domino::Assignments
2711 get_assignments(WriteAssignmentContainer self) -> IMP::domino::Assignments
2713 return _IMP_domino.WriteAssignmentContainer_get_assignments(self, *args)
2715 def get_version_info(self):
2716 """get_version_info(WriteAssignmentContainer self) -> VersionInfo"""
2717 return _IMP_domino.WriteAssignmentContainer_get_version_info(self)
2719 __swig_destroy__ = _IMP_domino.delete_WriteAssignmentContainer
2720 __del__ =
lambda self :
None;
2722 """__str__(WriteAssignmentContainer self) -> std::string"""
2723 return _IMP_domino.WriteAssignmentContainer___str__(self)
2726 """__repr__(WriteAssignmentContainer self) -> std::string"""
2727 return _IMP_domino.WriteAssignmentContainer___repr__(self)
2730 return _object_cast_to_WriteAssignmentContainer(o)
2731 get_from = staticmethod(get_from)
2733 WriteAssignmentContainer_swigregister = _IMP_domino.WriteAssignmentContainer_swigregister
2734 WriteAssignmentContainer_swigregister(WriteAssignmentContainer)
2736 class ReadAssignmentContainer(AssignmentContainer):
2737 """Proxy of C++ IMP::domino::ReadAssignmentContainer class"""
2738 __swig_setmethods__ = {}
2739 for _s
in [AssignmentContainer]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2740 __setattr__ =
lambda self, name, value: _swig_setattr(self, ReadAssignmentContainer, name, value)
2741 __swig_getmethods__ = {}
2742 for _s
in [AssignmentContainer]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2743 __getattr__ =
lambda self, name: _swig_getattr(self, ReadAssignmentContainer, name)
2744 def __init__(self, *args):
2746 __init__(IMP::domino::ReadAssignmentContainer self, std::string out_file, Subset s, IMP::kernel::ParticlesTemp const & all_particles,
2747 std::string name) -> ReadAssignmentContainer
2749 this = _IMP_domino.new_ReadAssignmentContainer(*args)
2750 try: self.this.append(this)
2751 except: self.this = this
2752 def set_cache_size(self, *args):
2753 """set_cache_size(ReadAssignmentContainer self, unsigned int words)"""
2754 return _IMP_domino.ReadAssignmentContainer_set_cache_size(self, *args)
2756 def get_assignments(self, *args):
2758 get_assignments(ReadAssignmentContainer self, IMP::IntRange r) -> IMP::domino::Assignments
2759 get_assignments(ReadAssignmentContainer self) -> IMP::domino::Assignments
2761 return _IMP_domino.ReadAssignmentContainer_get_assignments(self, *args)
2763 def get_version_info(self):
2764 """get_version_info(ReadAssignmentContainer self) -> VersionInfo"""
2765 return _IMP_domino.ReadAssignmentContainer_get_version_info(self)
2767 __swig_destroy__ = _IMP_domino.delete_ReadAssignmentContainer
2768 __del__ =
lambda self :
None;
2770 """__str__(ReadAssignmentContainer self) -> std::string"""
2771 return _IMP_domino.ReadAssignmentContainer___str__(self)
2774 """__repr__(ReadAssignmentContainer self) -> std::string"""
2775 return _IMP_domino.ReadAssignmentContainer___repr__(self)
2778 return _object_cast_to_ReadAssignmentContainer(o)
2779 get_from = staticmethod(get_from)
2781 ReadAssignmentContainer_swigregister = _IMP_domino.ReadAssignmentContainer_swigregister
2782 ReadAssignmentContainer_swigregister(ReadAssignmentContainer)
2784 class RangeViewAssignmentContainer(AssignmentContainer):
2785 """Proxy of C++ IMP::domino::RangeViewAssignmentContainer class"""
2786 __swig_setmethods__ = {}
2787 for _s
in [AssignmentContainer]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2788 __setattr__ =
lambda self, name, value: _swig_setattr(self, RangeViewAssignmentContainer, name, value)
2789 __swig_getmethods__ = {}
2790 for _s
in [AssignmentContainer]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2791 __getattr__ =
lambda self, name: _swig_getattr(self, RangeViewAssignmentContainer, name)
2792 def __init__(self, *args):
2793 """__init__(IMP::domino::RangeViewAssignmentContainer self, AssignmentContainer inner, unsigned int begin, unsigned int end) -> RangeViewAssignmentContainer"""
2794 this = _IMP_domino.new_RangeViewAssignmentContainer(*args)
2795 try: self.this.append(this)
2796 except: self.this = this
2797 def get_assignments(self, *args):
2799 get_assignments(RangeViewAssignmentContainer self, IMP::IntRange r) -> IMP::domino::Assignments
2800 get_assignments(RangeViewAssignmentContainer self) -> IMP::domino::Assignments
2802 return _IMP_domino.RangeViewAssignmentContainer_get_assignments(self, *args)
2804 def get_version_info(self):
2805 """get_version_info(RangeViewAssignmentContainer self) -> VersionInfo"""
2806 return _IMP_domino.RangeViewAssignmentContainer_get_version_info(self)
2808 def do_show(self, *args):
2809 """do_show(RangeViewAssignmentContainer self, _ostream out)"""
2810 return _IMP_domino.RangeViewAssignmentContainer_do_show(self, *args)
2812 __swig_destroy__ = _IMP_domino.delete_RangeViewAssignmentContainer
2813 __del__ =
lambda self :
None;
2815 """__str__(RangeViewAssignmentContainer self) -> std::string"""
2816 return _IMP_domino.RangeViewAssignmentContainer___str__(self)
2819 """__repr__(RangeViewAssignmentContainer self) -> std::string"""
2820 return _IMP_domino.RangeViewAssignmentContainer___repr__(self)
2823 return _object_cast_to_RangeViewAssignmentContainer(o)
2824 get_from = staticmethod(get_from)
2826 RangeViewAssignmentContainer_swigregister = _IMP_domino.RangeViewAssignmentContainer_swigregister
2827 RangeViewAssignmentContainer_swigregister(RangeViewAssignmentContainer)
2829 class HeapAssignmentContainer(AssignmentContainer):
2830 """Proxy of C++ IMP::domino::HeapAssignmentContainer class"""
2831 __swig_setmethods__ = {}
2832 for _s
in [AssignmentContainer]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2833 __setattr__ =
lambda self, name, value: _swig_setattr(self, HeapAssignmentContainer, name, value)
2834 __swig_getmethods__ = {}
2835 for _s
in [AssignmentContainer]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2836 __getattr__ =
lambda self, name: _swig_getattr(self, HeapAssignmentContainer, name)
2837 def __init__(self, *args):
2839 __init__(IMP::domino::HeapAssignmentContainer self, Subset subset, unsigned int k, RestraintCache rssf, std::string name="HeapAssignmentsContainer %1%") -> HeapAssignmentContainer
2840 __init__(IMP::domino::HeapAssignmentContainer self, Subset subset, unsigned int k, RestraintCache rssf) -> HeapAssignmentContainer
2842 this = _IMP_domino.new_HeapAssignmentContainer(*args)
2843 try: self.this.append(this)
2844 except: self.this = this
2845 def get_assignments(self, *args):
2847 get_assignments(HeapAssignmentContainer self, IMP::IntRange r) -> IMP::domino::Assignments
2848 get_assignments(HeapAssignmentContainer self) -> IMP::domino::Assignments
2850 return _IMP_domino.HeapAssignmentContainer_get_assignments(self, *args)
2852 def get_version_info(self):
2853 """get_version_info(HeapAssignmentContainer self) -> VersionInfo"""
2854 return _IMP_domino.HeapAssignmentContainer_get_version_info(self)
2856 def do_show(self, *args):
2857 """do_show(HeapAssignmentContainer self, _ostream out)"""
2858 return _IMP_domino.HeapAssignmentContainer_do_show(self, *args)
2860 __swig_destroy__ = _IMP_domino.delete_HeapAssignmentContainer
2861 __del__ =
lambda self :
None;
2863 """__str__(HeapAssignmentContainer self) -> std::string"""
2864 return _IMP_domino.HeapAssignmentContainer___str__(self)
2867 """__repr__(HeapAssignmentContainer self) -> std::string"""
2868 return _IMP_domino.HeapAssignmentContainer___repr__(self)
2871 return _object_cast_to_HeapAssignmentContainer(o)
2872 get_from = staticmethod(get_from)
2874 HeapAssignmentContainer_swigregister = _IMP_domino.HeapAssignmentContainer_swigregister
2875 HeapAssignmentContainer_swigregister(HeapAssignmentContainer)
2877 class CappedAssignmentContainer(AssignmentContainer):
2878 """Proxy of C++ IMP::domino::CappedAssignmentContainer class"""
2879 __swig_setmethods__ = {}
2880 for _s
in [AssignmentContainer]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2881 __setattr__ =
lambda self, name, value: _swig_setattr(self, CappedAssignmentContainer, name, value)
2882 __swig_getmethods__ = {}
2883 for _s
in [AssignmentContainer]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2884 __getattr__ =
lambda self, name: _swig_getattr(self, CappedAssignmentContainer, name)
2885 def __init__(self, *args):
2886 """__init__(IMP::domino::CappedAssignmentContainer self, AssignmentContainer contained, int max_states, std::string name) -> CappedAssignmentContainer"""
2887 this = _IMP_domino.new_CappedAssignmentContainer(*args)
2888 try: self.this.append(this)
2889 except: self.this = this
2890 def get_assignments(self, *args):
2892 get_assignments(CappedAssignmentContainer self, IMP::IntRange r) -> IMP::domino::Assignments
2893 get_assignments(CappedAssignmentContainer self) -> IMP::domino::Assignments
2895 return _IMP_domino.CappedAssignmentContainer_get_assignments(self, *args)
2897 def get_version_info(self):
2898 """get_version_info(CappedAssignmentContainer self) -> VersionInfo"""
2899 return _IMP_domino.CappedAssignmentContainer_get_version_info(self)
2901 __swig_destroy__ = _IMP_domino.delete_CappedAssignmentContainer
2902 __del__ =
lambda self :
None;
2904 """__str__(CappedAssignmentContainer self) -> std::string"""
2905 return _IMP_domino.CappedAssignmentContainer___str__(self)
2908 """__repr__(CappedAssignmentContainer self) -> std::string"""
2909 return _IMP_domino.CappedAssignmentContainer___repr__(self)
2912 return _object_cast_to_CappedAssignmentContainer(o)
2913 get_from = staticmethod(get_from)
2915 CappedAssignmentContainer_swigregister = _IMP_domino.CappedAssignmentContainer_swigregister
2916 CappedAssignmentContainer_swigregister(CappedAssignmentContainer)
2919 """Proxy of C++ IMP::domino::AssignmentsTable class"""
2920 __swig_setmethods__ = {}
2921 for _s
in [
IMP.base.Object]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2922 __setattr__ =
lambda self, name, value: _swig_setattr(self, AssignmentsTable, name, value)
2923 __swig_getmethods__ = {}
2924 for _s
in [
IMP.base.Object]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2925 __getattr__ =
lambda self, name: _swig_getattr(self, AssignmentsTable, name)
2926 def __init__(self, name="SubsetStatesTable %1%"):
2928 __init__(IMP::domino::AssignmentsTable self, std::string name="SubsetStatesTable %1%") -> AssignmentsTable
2929 __init__(IMP::domino::AssignmentsTable self) -> AssignmentsTable
2931 if self.__class__ == AssignmentsTable:
2935 this = _IMP_domino.new_AssignmentsTable(_self, name)
2936 try: self.this.append(this)
2937 except: self.this = this
2938 if self.__class__ != AssignmentsTable:
2940 IMP.base._director_objects.register(self)
2944 def load_assignments(self, *args):
2945 """load_assignments(AssignmentsTable self, Subset s, AssignmentContainer ac)"""
2946 return _IMP_domino.AssignmentsTable_load_assignments(self, *args)
2948 __swig_destroy__ = _IMP_domino.delete_AssignmentsTable
2949 __del__ =
lambda self :
None;
2951 """__str__(AssignmentsTable self) -> std::string"""
2952 return _IMP_domino.AssignmentsTable___str__(self)
2955 """__repr__(AssignmentsTable self) -> std::string"""
2956 return _IMP_domino.AssignmentsTable___repr__(self)
2959 return _object_cast_to_AssignmentsTable(o)
2960 get_from = staticmethod(get_from)
2962 def get_type_name(self):
2963 return self.__class__.__name__
2964 def do_show(self, out):
2966 def get_version_info(self):
2967 if"IMP::domino" ==
"IMP":
2968 return VersionInfo(
"python",
"0")
2970 return IMP.VersionInfo(
"python",
"0")
2972 return _object_cast_to_AssignmentsTable(o)
2973 get_from = staticmethod(get_from)
2975 def __disown__(self):
2977 _IMP_domino.disown_AssignmentsTable(self)
2978 return weakref_proxy(self)
2979 AssignmentsTable_swigregister = _IMP_domino.AssignmentsTable_swigregister
2980 AssignmentsTable_swigregister(AssignmentsTable)
2982 class SimpleAssignmentsTable(AssignmentsTable):
2983 """Proxy of C++ IMP::domino::SimpleAssignmentsTable class"""
2984 __swig_setmethods__ = {}
2985 for _s
in [AssignmentsTable]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2986 __setattr__ =
lambda self, name, value: _swig_setattr(self, SimpleAssignmentsTable, name, value)
2987 __swig_getmethods__ = {}
2988 for _s
in [AssignmentsTable]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2989 __getattr__ =
lambda self, name: _swig_getattr(self, SimpleAssignmentsTable, name)
2990 def __init__(self, *args):
2992 __init__(IMP::domino::SimpleAssignmentsTable self, ParticleStatesTable pst, IMP::domino::SubsetFilterTables const & sft=IMP::domino::SubsetFilterTables(),
2993 unsigned int max=std::numeric_limits< unsigned int >::max()) -> SimpleAssignmentsTable
2994 __init__(IMP::domino::SimpleAssignmentsTable self, ParticleStatesTable pst, IMP::domino::SubsetFilterTables const & sft=IMP::domino::SubsetFilterTables()) -> SimpleAssignmentsTable
2995 __init__(IMP::domino::SimpleAssignmentsTable self, ParticleStatesTable pst) -> SimpleAssignmentsTable
2997 this = _IMP_domino.new_SimpleAssignmentsTable(*args)
2998 try: self.this.append(this)
2999 except: self.this = this
3000 def get_version_info(self):
3001 """get_version_info(SimpleAssignmentsTable self) -> VersionInfo"""
3002 return _IMP_domino.SimpleAssignmentsTable_get_version_info(self)
3004 def do_show(self, *args):
3005 """do_show(SimpleAssignmentsTable self, _ostream out)"""
3006 return _IMP_domino.SimpleAssignmentsTable_do_show(self, *args)
3008 __swig_destroy__ = _IMP_domino.delete_SimpleAssignmentsTable
3009 __del__ =
lambda self :
None;
3011 """__str__(SimpleAssignmentsTable self) -> std::string"""
3012 return _IMP_domino.SimpleAssignmentsTable___str__(self)
3015 """__repr__(SimpleAssignmentsTable self) -> std::string"""
3016 return _IMP_domino.SimpleAssignmentsTable___repr__(self)
3019 return _object_cast_to_SimpleAssignmentsTable(o)
3020 get_from = staticmethod(get_from)
3022 SimpleAssignmentsTable_swigregister = _IMP_domino.SimpleAssignmentsTable_swigregister
3023 SimpleAssignmentsTable_swigregister(SimpleAssignmentsTable)
3025 class RecursiveAssignmentsTable(AssignmentsTable):
3026 """Proxy of C++ IMP::domino::RecursiveAssignmentsTable class"""
3027 __swig_setmethods__ = {}
3028 for _s
in [AssignmentsTable]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
3029 __setattr__ =
lambda self, name, value: _swig_setattr(self, RecursiveAssignmentsTable, name, value)
3030 __swig_getmethods__ = {}
3031 for _s
in [AssignmentsTable]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
3032 __getattr__ =
lambda self, name: _swig_getattr(self, RecursiveAssignmentsTable, name)
3033 def __init__(self, *args):
3035 __init__(IMP::domino::RecursiveAssignmentsTable self, ParticleStatesTable pst, IMP::domino::SubsetFilterTables const & sft=IMP::domino::SubsetFilterTables(),
3036 unsigned int max=std::numeric_limits< unsigned int >::max()) -> RecursiveAssignmentsTable
3037 __init__(IMP::domino::RecursiveAssignmentsTable self, ParticleStatesTable pst, IMP::domino::SubsetFilterTables const & sft=IMP::domino::SubsetFilterTables()) -> RecursiveAssignmentsTable
3038 __init__(IMP::domino::RecursiveAssignmentsTable self, ParticleStatesTable pst) -> RecursiveAssignmentsTable
3040 this = _IMP_domino.new_RecursiveAssignmentsTable(*args)
3041 try: self.this.append(this)
3042 except: self.this = this
3043 def get_version_info(self):
3044 """get_version_info(RecursiveAssignmentsTable self) -> VersionInfo"""
3045 return _IMP_domino.RecursiveAssignmentsTable_get_version_info(self)
3047 def do_show(self, *args):
3048 """do_show(RecursiveAssignmentsTable self, _ostream out)"""
3049 return _IMP_domino.RecursiveAssignmentsTable_do_show(self, *args)
3051 __swig_destroy__ = _IMP_domino.delete_RecursiveAssignmentsTable
3052 __del__ =
lambda self :
None;
3054 """__str__(RecursiveAssignmentsTable self) -> std::string"""
3055 return _IMP_domino.RecursiveAssignmentsTable___str__(self)
3058 """__repr__(RecursiveAssignmentsTable self) -> std::string"""
3059 return _IMP_domino.RecursiveAssignmentsTable___repr__(self)
3062 return _object_cast_to_RecursiveAssignmentsTable(o)
3063 get_from = staticmethod(get_from)
3065 RecursiveAssignmentsTable_swigregister = _IMP_domino.RecursiveAssignmentsTable_swigregister
3066 RecursiveAssignmentsTable_swigregister(RecursiveAssignmentsTable)
3068 class BranchAndBoundAssignmentsTable(AssignmentsTable):
3069 """Proxy of C++ IMP::domino::BranchAndBoundAssignmentsTable class"""
3070 __swig_setmethods__ = {}
3071 for _s
in [AssignmentsTable]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
3072 __setattr__ =
lambda self, name, value: _swig_setattr(self, BranchAndBoundAssignmentsTable, name, value)
3073 __swig_getmethods__ = {}
3074 for _s
in [AssignmentsTable]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
3075 __getattr__ =
lambda self, name: _swig_getattr(self, BranchAndBoundAssignmentsTable, name)
3076 def __init__(self, *args):
3078 __init__(IMP::domino::BranchAndBoundAssignmentsTable self, ParticleStatesTable pst, IMP::domino::SubsetFilterTables const & sft=IMP::domino::SubsetFilterTables(),
3079 unsigned int max=std::numeric_limits< unsigned int >::max()) -> BranchAndBoundAssignmentsTable
3080 __init__(IMP::domino::BranchAndBoundAssignmentsTable self, ParticleStatesTable pst, IMP::domino::SubsetFilterTables const & sft=IMP::domino::SubsetFilterTables()) -> BranchAndBoundAssignmentsTable
3081 __init__(IMP::domino::BranchAndBoundAssignmentsTable self, ParticleStatesTable pst) -> BranchAndBoundAssignmentsTable
3083 this = _IMP_domino.new_BranchAndBoundAssignmentsTable(*args)
3084 try: self.this.append(this)
3085 except: self.this = this
3086 def get_version_info(self):
3087 """get_version_info(BranchAndBoundAssignmentsTable self) -> VersionInfo"""
3088 return _IMP_domino.BranchAndBoundAssignmentsTable_get_version_info(self)
3090 def do_show(self, *args):
3091 """do_show(BranchAndBoundAssignmentsTable self, _ostream out)"""
3092 return _IMP_domino.BranchAndBoundAssignmentsTable_do_show(self, *args)
3094 __swig_destroy__ = _IMP_domino.delete_BranchAndBoundAssignmentsTable
3095 __del__ =
lambda self :
None;
3097 """__str__(BranchAndBoundAssignmentsTable self) -> std::string"""
3098 return _IMP_domino.BranchAndBoundAssignmentsTable___str__(self)
3101 """__repr__(BranchAndBoundAssignmentsTable self) -> std::string"""
3102 return _IMP_domino.BranchAndBoundAssignmentsTable___repr__(self)
3105 return _object_cast_to_BranchAndBoundAssignmentsTable(o)
3106 get_from = staticmethod(get_from)
3108 BranchAndBoundAssignmentsTable_swigregister = _IMP_domino.BranchAndBoundAssignmentsTable_swigregister
3109 BranchAndBoundAssignmentsTable_swigregister(BranchAndBoundAssignmentsTable)
3111 class ListAssignmentsTable(AssignmentsTable):
3112 """Proxy of C++ IMP::domino::ListAssignmentsTable class"""
3113 __swig_setmethods__ = {}
3114 for _s
in [AssignmentsTable]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
3115 __setattr__ =
lambda self, name, value: _swig_setattr(self, ListAssignmentsTable, name, value)
3116 __swig_getmethods__ = {}
3117 for _s
in [AssignmentsTable]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
3118 __getattr__ =
lambda self, name: _swig_getattr(self, ListAssignmentsTable, name)
3119 def __init__(self, name="ListSubsetStatesTable %1%"):
3121 __init__(IMP::domino::ListAssignmentsTable self, std::string name="ListSubsetStatesTable %1%") -> ListAssignmentsTable
3122 __init__(IMP::domino::ListAssignmentsTable self) -> ListAssignmentsTable
3124 this = _IMP_domino.new_ListAssignmentsTable(name)
3125 try: self.this.append(this)
3126 except: self.this = this
3127 def set_assignments(self, *args):
3128 """set_assignments(ListAssignmentsTable self, Subset s, AssignmentContainer lsc)"""
3129 return _IMP_domino.ListAssignmentsTable_set_assignments(self, *args)
3131 def get_version_info(self):
3132 """get_version_info(ListAssignmentsTable self) -> VersionInfo"""
3133 return _IMP_domino.ListAssignmentsTable_get_version_info(self)
3135 def do_show(self, *args):
3136 """do_show(ListAssignmentsTable self, _ostream out)"""
3137 return _IMP_domino.ListAssignmentsTable_do_show(self, *args)
3139 __swig_destroy__ = _IMP_domino.delete_ListAssignmentsTable
3140 __del__ =
lambda self :
None;
3142 """__str__(ListAssignmentsTable self) -> std::string"""
3143 return _IMP_domino.ListAssignmentsTable___str__(self)
3146 """__repr__(ListAssignmentsTable self) -> std::string"""
3147 return _IMP_domino.ListAssignmentsTable___repr__(self)
3150 return _object_cast_to_ListAssignmentsTable(o)
3151 get_from = staticmethod(get_from)
3153 ListAssignmentsTable_swigregister = _IMP_domino.ListAssignmentsTable_swigregister
3154 ListAssignmentsTable_swigregister(ListAssignmentsTable)
3158 """get_order(Subset s, IMP::domino::SubsetFilterTables const & sft) -> IMP::kernel::ParticlesTemp"""
3159 return _IMP_domino.get_order(*args)
3160 class _SubsetGraphVertexIndex(_object):
3161 """Proxy of C++ IMP::domino::SubsetGraphVertexIndex class"""
3162 __swig_setmethods__ = {}
3163 __setattr__ =
lambda self, name, value: _swig_setattr(self, _SubsetGraphVertexIndex, name, value)
3164 __swig_getmethods__ = {}
3165 __getattr__ =
lambda self, name: _swig_getattr(self, _SubsetGraphVertexIndex, name)
3166 __repr__ = _swig_repr
3168 """__init__(IMP::domino::SubsetGraphVertexIndex self) -> _SubsetGraphVertexIndex"""
3169 this = _IMP_domino.new__SubsetGraphVertexIndex()
3170 try: self.this.append(this)
3171 except: self.this = this
3172 __swig_destroy__ = _IMP_domino.delete__SubsetGraphVertexIndex
3173 __del__ =
lambda self :
None;
3174 _SubsetGraphVertexIndex_swigregister = _IMP_domino._SubsetGraphVertexIndex_swigregister
3175 _SubsetGraphVertexIndex_swigregister(_SubsetGraphVertexIndex)
3177 class _InteractionGraphVertexIndex(_object):
3178 """Proxy of C++ IMP::domino::InteractionGraphVertexIndex class"""
3179 __swig_setmethods__ = {}
3180 __setattr__ =
lambda self, name, value: _swig_setattr(self, _InteractionGraphVertexIndex, name, value)
3181 __swig_getmethods__ = {}
3182 __getattr__ =
lambda self, name: _swig_getattr(self, _InteractionGraphVertexIndex, name)
3183 __repr__ = _swig_repr
3185 """__init__(IMP::domino::InteractionGraphVertexIndex self) -> _InteractionGraphVertexIndex"""
3186 this = _IMP_domino.new__InteractionGraphVertexIndex()
3187 try: self.this.append(this)
3188 except: self.this = this
3189 __swig_destroy__ = _IMP_domino.delete__InteractionGraphVertexIndex
3190 __del__ =
lambda self :
None;
3191 _InteractionGraphVertexIndex_swigregister = _IMP_domino._InteractionGraphVertexIndex_swigregister
3192 _InteractionGraphVertexIndex_swigregister(_InteractionGraphVertexIndex)
3196 """get_subsets(IMP::domino::SubsetGraph const & g) -> IMP::domino::Subsets"""
3197 return _IMP_domino.get_subsets(*args)
3200 """get_junction_tree(IMP::domino::InteractionGraph const & ig) -> IMP::domino::SubsetGraph"""
3201 return _IMP_domino.get_junction_tree(*args)
3203 def get_triangulated(*args):
3204 """get_triangulated(IMP::domino::InteractionGraph const & input) -> IMP::domino::InteractionGraph"""
3205 return _IMP_domino.get_triangulated(*args)
3207 def get_clique_graph(*args):
3208 """get_clique_graph(IMP::domino::InteractionGraph const & input) -> IMP::domino::CliqueGraph"""
3209 return _IMP_domino.get_clique_graph(*args)
3211 def get_minimum_spanning_tree(*args):
3212 """get_minimum_spanning_tree(IMP::domino::CliqueGraph const & input) -> IMP::domino::SubsetGraph"""
3213 return _IMP_domino.get_minimum_spanning_tree(*args)
3216 """get_restraint_graph(_ScoringFunctionAdaptor rs, ParticleStatesTable pst) -> IMP::domino::SubsetGraph"""
3217 return _IMP_domino.get_restraint_graph(*args)
3221 get_interaction_graph(_ScoringFunctionAdaptor rs, ParticleStatesTable pst) -> IMP::domino::InteractionGraph
3222 get_interaction_graph(_ScoringFunctionAdaptor rs, IMP::kernel::ParticlesTemp const & pst) -> IMP::domino::InteractionGraph
3224 return _IMP_domino.get_interaction_graph(*args)
3227 """get_interaction_graph_geometry(IMP::domino::InteractionGraph const & ig) -> IMP::display::Geometries"""
3228 return _IMP_domino.get_interaction_graph_geometry(*args)
3231 """get_subset_graph_geometry(IMP::domino::SubsetGraph const & ig) -> IMP::display::Geometries"""
3232 return _IMP_domino.get_subset_graph_geometry(*args)
3233 class _MergeTreeVertexIndex(_object):
3234 """Proxy of C++ IMP::domino::MergeTreeVertexIndex class"""
3235 __swig_setmethods__ = {}
3236 __setattr__ =
lambda self, name, value: _swig_setattr(self, _MergeTreeVertexIndex, name, value)
3237 __swig_getmethods__ = {}
3238 __getattr__ =
lambda self, name: _swig_getattr(self, _MergeTreeVertexIndex, name)
3239 __repr__ = _swig_repr
3241 """__init__(IMP::domino::MergeTreeVertexIndex self) -> _MergeTreeVertexIndex"""
3242 this = _IMP_domino.new__MergeTreeVertexIndex()
3243 try: self.this.append(this)
3244 except: self.this = this
3245 __swig_destroy__ = _IMP_domino.delete__MergeTreeVertexIndex
3246 __del__ =
lambda self :
None;
3247 _MergeTreeVertexIndex_swigregister = _IMP_domino._MergeTreeVertexIndex_swigregister
3248 _MergeTreeVertexIndex_swigregister(_MergeTreeVertexIndex)
3251 def get_vertex_index(*args):
3253 get_vertex_index(IMP::domino::SubsetGraph const & g) -> _SubsetGraphVertexIndex
3254 get_vertex_index(IMP::domino::InteractionGraph const & g) -> _InteractionGraphVertexIndex
3255 get_vertex_index(IMP::domino::MergeTree const & g) -> _MergeTreeVertexIndex
3257 return _IMP_domino.get_vertex_index(*args)
3261 get_merge_tree(_ScoringFunctionAdaptor input, ParticleStatesTable pst) -> IMP::domino::MergeTree
3262 get_merge_tree(IMP::domino::SubsetGraph const & junction_tree) -> IMP::domino::MergeTree
3264 return _IMP_domino.get_merge_tree(*args)
3267 """get_balanced_merge_tree(IMP::domino::SubsetGraph const & junction_tree) -> IMP::domino::MergeTree"""
3268 return _IMP_domino.get_balanced_merge_tree(*args)
3270 def get_is_merge_tree(*args):
3272 get_is_merge_tree(IMP::domino::MergeTree const & tree, Subset all, bool verbose=True) -> bool
3273 get_is_merge_tree(IMP::domino::MergeTree const & tree, Subset all) -> bool
3275 return _IMP_domino.get_is_merge_tree(*args)
3277 def write_merge_tree(*args):
3278 """write_merge_tree(IMP::domino::MergeTree const & tree, IMP::kernel::ParticlesTemp const & ps, _ostream out)"""
3279 return _IMP_domino.write_merge_tree(*args)
3281 def read_merge_tree(*args):
3282 """read_merge_tree(std::istream & input, IMP::kernel::ParticlesTemp const & ps) -> IMP::domino::MergeTree"""
3283 return _IMP_domino.read_merge_tree(*args)
3285 """Proxy of C++ IMP::domino::DiscreteSampler class"""
3286 __swig_setmethods__ = {}
3287 for _s
in [
IMP.kernel.Sampler]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
3288 __setattr__ =
lambda self, name, value: _swig_setattr(self, DiscreteSampler, name, value)
3289 __swig_getmethods__ = {}
3290 for _s
in [
IMP.kernel.Sampler]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
3291 __getattr__ =
lambda self, name: _swig_getattr(self, DiscreteSampler, name)
3292 def get_subset_filter_tables_to_use(self, *args):
3293 """get_subset_filter_tables_to_use(DiscreteSampler self, IMP::kernel::RestraintsTemp const & rs, ParticleStatesTable pst) -> IMP::domino::SubsetFilterTables"""
3294 return _IMP_domino.DiscreteSampler_get_subset_filter_tables_to_use(self, *args)
3296 def get_assignments_table_to_use(self, *args):
3298 get_assignments_table_to_use(DiscreteSampler self, IMP::domino::SubsetFilterTables const & sfts, unsigned int max=std::numeric_limits< int >::max()) -> AssignmentsTable
3299 get_assignments_table_to_use(DiscreteSampler self, IMP::domino::SubsetFilterTables const & sfts) -> AssignmentsTable
3301 return _IMP_domino.DiscreteSampler_get_assignments_table_to_use(self, *args)
3303 def do_sample(self):
3304 """do_sample(DiscreteSampler self) -> ConfigurationSet"""
3305 return _IMP_domino.DiscreteSampler_do_sample(self)
3307 def do_get_sample_assignments(self, *args):
3308 """do_get_sample_assignments(DiscreteSampler self, Subset all) -> IMP::domino::Assignments"""
3309 return _IMP_domino.DiscreteSampler_do_get_sample_assignments(self, *args)
3311 def __init__(self, *args):
3312 """__init__(IMP::domino::DiscreteSampler self, Model m, ParticleStatesTable pst, std::string name) -> DiscreteSampler"""
3313 if self.__class__ == DiscreteSampler:
3317 this = _IMP_domino.new_DiscreteSampler(_self, *args)
3318 try: self.this.append(this)
3319 except: self.this = this
3320 if self.__class__ != DiscreteSampler:
3322 IMP.base._director_objects.register(self)
3326 __swig_destroy__ = _IMP_domino.delete_DiscreteSampler
3327 __del__ =
lambda self :
None;
3328 def set_particle_states(self, *args):
3329 """set_particle_states(DiscreteSampler self, Particle p, ParticleStates se)"""
3330 return _IMP_domino.DiscreteSampler_set_particle_states(self, *args)
3332 def get_sample_assignments(self, *args):
3333 """get_sample_assignments(DiscreteSampler self, Subset s) -> IMP::domino::Assignments"""
3334 return _IMP_domino.DiscreteSampler_get_sample_assignments(self, *args)
3336 def set_particle_states_table(self, *args):
3337 """set_particle_states_table(DiscreteSampler self, ParticleStatesTable cse)"""
3338 return _IMP_domino.DiscreteSampler_set_particle_states_table(self, *args)
3340 def set_assignments_table(self, *args):
3341 """set_assignments_table(DiscreteSampler self, AssignmentsTable sst)"""
3342 return _IMP_domino.DiscreteSampler_set_assignments_table(self, *args)
3344 def get_particle_states_table(self):
3345 """get_particle_states_table(DiscreteSampler self) -> ParticleStatesTable"""
3346 return _IMP_domino.DiscreteSampler_get_particle_states_table(self)
3348 def remove_subset_filter_table(self, *args):
3349 """remove_subset_filter_table(DiscreteSampler self, SubsetFilterTable d)"""
3350 return _IMP_domino.DiscreteSampler_remove_subset_filter_table(self, *args)
3352 def remove_subset_filter_tables(self, *args):
3353 """remove_subset_filter_tables(DiscreteSampler self, IMP::domino::SubsetFilterTables const & d)"""
3354 return _IMP_domino.DiscreteSampler_remove_subset_filter_tables(self, *args)
3356 def set_subset_filter_tables(self, *args):
3357 """set_subset_filter_tables(DiscreteSampler self, IMP::domino::SubsetFilterTables const & ps)"""
3358 return _IMP_domino.DiscreteSampler_set_subset_filter_tables(self, *args)
3360 def set_subset_filter_tables_order(self, *args):
3361 """set_subset_filter_tables_order(DiscreteSampler self, IMP::domino::SubsetFilterTables const & objs)"""
3362 return _IMP_domino.DiscreteSampler_set_subset_filter_tables_order(self, *args)
3364 def add_subset_filter_table(self, *args):
3365 """add_subset_filter_table(DiscreteSampler self, SubsetFilterTable obj) -> unsigned int"""
3366 return _IMP_domino.DiscreteSampler_add_subset_filter_table(self, *args)
3368 def add_subset_filter_tables(self, *args):
3369 """add_subset_filter_tables(DiscreteSampler self, IMP::domino::SubsetFilterTables const & objs)"""
3370 return _IMP_domino.DiscreteSampler_add_subset_filter_tables(self, *args)
3372 def clear_subset_filter_tables(self):
3373 """clear_subset_filter_tables(DiscreteSampler self)"""
3374 return _IMP_domino.DiscreteSampler_clear_subset_filter_tables(self)
3376 def get_number_of_subset_filter_tables(self):
3377 """get_number_of_subset_filter_tables(DiscreteSampler self) -> unsigned int"""
3378 return _IMP_domino.DiscreteSampler_get_number_of_subset_filter_tables(self)
3380 def get_has_subset_filter_tables(self):
3381 """get_has_subset_filter_tables(DiscreteSampler self) -> bool"""
3382 return _IMP_domino.DiscreteSampler_get_has_subset_filter_tables(self)
3384 def get_subset_filter_table(self, *args):
3385 """get_subset_filter_table(DiscreteSampler self, unsigned int i) -> SubsetFilterTable"""
3386 return _IMP_domino.DiscreteSampler_get_subset_filter_table(self, *args)
3388 def get_subset_filter_tables(self):
3389 """get_subset_filter_tables(DiscreteSampler self) -> IMP::domino::SubsetFilterTables"""
3390 return _IMP_domino.DiscreteSampler_get_subset_filter_tables(self)
3392 def reserve_subset_filter_tables(self, *args):
3393 """reserve_subset_filter_tables(DiscreteSampler self, unsigned int sz)"""
3394 return _IMP_domino.DiscreteSampler_reserve_subset_filter_tables(self, *args)
3396 def set_maximum_number_of_assignments(self, *args):
3397 """set_maximum_number_of_assignments(DiscreteSampler self, unsigned int mx)"""
3398 return _IMP_domino.DiscreteSampler_set_maximum_number_of_assignments(self, *args)
3400 def get_maximum_number_of_assignments(self):
3401 """get_maximum_number_of_assignments(DiscreteSampler self) -> unsigned int"""
3402 return _IMP_domino.DiscreteSampler_get_maximum_number_of_assignments(self)
3405 """__str__(DiscreteSampler self) -> std::string"""
3406 return _IMP_domino.DiscreteSampler___str__(self)
3409 """__repr__(DiscreteSampler self) -> std::string"""
3410 return _IMP_domino.DiscreteSampler___repr__(self)
3413 return _object_cast_to_DiscreteSampler(o)
3414 get_from = staticmethod(get_from)
3416 def get_type_name(self):
3417 return self.__class__.__name__
3418 def do_show(self, out):
3420 def get_version_info(self):
3421 if"IMP::domino" ==
"IMP":
3422 return VersionInfo(
"python",
"0")
3424 return IMP.VersionInfo(
"python",
"0")
3426 return _object_cast_to_DiscreteSampler(o)
3427 get_from = staticmethod(get_from)
3429 def __disown__(self):
3431 _IMP_domino.disown_DiscreteSampler(self)
3432 return weakref_proxy(self)
3433 DiscreteSampler_swigregister = _IMP_domino.DiscreteSampler_swigregister
3434 DiscreteSampler_swigregister(DiscreteSampler)
3436 class DominoSampler(DiscreteSampler):
3437 """Proxy of C++ IMP::domino::DominoSampler class"""
3438 __swig_setmethods__ = {}
3439 for _s
in [DiscreteSampler]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
3440 __setattr__ =
lambda self, name, value: _swig_setattr(self, DominoSampler, name, value)
3441 __swig_getmethods__ = {}
3442 for _s
in [DiscreteSampler]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
3443 __getattr__ =
lambda self, name: _swig_getattr(self, DominoSampler, name)
3444 def __init__(self, *args):
3446 __init__(IMP::domino::DominoSampler self, Model m, std::string name="DominoSampler %1%") -> DominoSampler
3447 __init__(IMP::domino::DominoSampler self, Model m) -> DominoSampler
3448 __init__(IMP::domino::DominoSampler self, Model m, ParticleStatesTable pst, std::string name="DominoSampler %1%") -> DominoSampler
3449 __init__(IMP::domino::DominoSampler self, Model m, ParticleStatesTable pst) -> DominoSampler
3451 this = _IMP_domino.new_DominoSampler(*args)
3452 try: self.this.append(this)
3453 except: self.this = this
3454 def do_get_sample_assignments(self, *args):
3455 """do_get_sample_assignments(DominoSampler self, Subset known) -> IMP::domino::Assignments"""
3456 return _IMP_domino.DominoSampler_do_get_sample_assignments(self, *args)
3458 def get_version_info(self):
3459 """get_version_info(DominoSampler self) -> VersionInfo"""
3460 return _IMP_domino.DominoSampler_get_version_info(self)
3462 def do_show(self, *args):
3463 """do_show(DominoSampler self, _ostream out)"""
3464 return _IMP_domino.DominoSampler_do_show(self, *args)
3466 __swig_destroy__ = _IMP_domino.delete_DominoSampler
3467 __del__ =
lambda self :
None;
3468 def set_subset_graph(self, *args):
3469 """set_subset_graph(DominoSampler self, IMP::domino::SubsetGraph const & sg)"""
3470 return _IMP_domino.DominoSampler_set_subset_graph(self, *args)
3472 def set_merge_tree(self, *args):
3473 """set_merge_tree(DominoSampler self, IMP::domino::MergeTree const & mt)"""
3474 return _IMP_domino.DominoSampler_set_merge_tree(self, *args)
3476 def set_use_cross_subset_filtering(self, *args):
3477 """set_use_cross_subset_filtering(DominoSampler self, bool tf)"""
3478 return _IMP_domino.DominoSampler_set_use_cross_subset_filtering(self, *args)
3480 def get_number_of_assignments_for_vertex(self, *args):
3481 """get_number_of_assignments_for_vertex(DominoSampler self, unsigned int tree_vertex) -> unsigned int"""
3482 return _IMP_domino.DominoSampler_get_number_of_assignments_for_vertex(self, *args)
3484 def get_sample_assignments_for_vertex(self, *args):
3485 """get_sample_assignments_for_vertex(DominoSampler self, unsigned int tree_vertex) -> IMP::domino::Assignments"""
3486 return _IMP_domino.DominoSampler_get_sample_assignments_for_vertex(self, *args)
3488 def get_vertex_assignments(self, *args):
3490 get_vertex_assignments(DominoSampler self, unsigned int node_index, unsigned int max_states=std::numeric_limits< int >::max()) -> IMP::domino::Assignments
3491 get_vertex_assignments(DominoSampler self, unsigned int node_index) -> IMP::domino::Assignments
3492 get_vertex_assignments(DominoSampler self, unsigned int node_index, IMP::domino::Assignments const & first, IMP::domino::Assignments const & second,
3493 unsigned int max_states=std::numeric_limits< int >::max()) -> IMP::domino::Assignments
3494 get_vertex_assignments(DominoSampler self, unsigned int node_index, IMP::domino::Assignments const & first, IMP::domino::Assignments const & second) -> IMP::domino::Assignments
3496 return _IMP_domino.DominoSampler_get_vertex_assignments(self, *args)
3498 def load_vertex_assignments(self, *args):
3500 load_vertex_assignments(DominoSampler self, unsigned int node_index, AssignmentContainer ac, unsigned int max_states=std::numeric_limits< int >::max())
3501 load_vertex_assignments(DominoSampler self, unsigned int node_index, AssignmentContainer ac)
3502 load_vertex_assignments(DominoSampler self, unsigned int node_index, AssignmentContainer first, AssignmentContainer second, AssignmentContainer ac,
3503 unsigned int max_states=std::numeric_limits< int >::max())
3504 load_vertex_assignments(DominoSampler self, unsigned int node_index, AssignmentContainer first, AssignmentContainer second, AssignmentContainer ac)
3506 return _IMP_domino.DominoSampler_load_vertex_assignments(self, *args)
3509 """__str__(DominoSampler self) -> std::string"""
3510 return _IMP_domino.DominoSampler___str__(self)
3513 """__repr__(DominoSampler self) -> std::string"""
3514 return _IMP_domino.DominoSampler___repr__(self)
3517 return _object_cast_to_DominoSampler(o)
3518 get_from = staticmethod(get_from)
3520 DominoSampler_swigregister = _IMP_domino.DominoSampler_swigregister
3521 DominoSampler_swigregister(DominoSampler)
3523 class BranchAndBoundSampler(DiscreteSampler):
3524 """Proxy of C++ IMP::domino::BranchAndBoundSampler class"""
3525 __swig_setmethods__ = {}
3526 for _s
in [DiscreteSampler]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
3527 __setattr__ =
lambda self, name, value: _swig_setattr(self, BranchAndBoundSampler, name, value)
3528 __swig_getmethods__ = {}
3529 for _s
in [DiscreteSampler]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
3530 __getattr__ =
lambda self, name: _swig_getattr(self, BranchAndBoundSampler, name)
3531 def __init__(self, *args):
3533 __init__(IMP::domino::BranchAndBoundSampler self, Model m, std::string name="BranchAndBoundSampler %1%") -> BranchAndBoundSampler
3534 __init__(IMP::domino::BranchAndBoundSampler self, Model m) -> BranchAndBoundSampler
3535 __init__(IMP::domino::BranchAndBoundSampler self, Model m, ParticleStatesTable pst, std::string name="BranchAndBoundSampler %1%") -> BranchAndBoundSampler
3536 __init__(IMP::domino::BranchAndBoundSampler self, Model m, ParticleStatesTable pst) -> BranchAndBoundSampler
3538 this = _IMP_domino.new_BranchAndBoundSampler(*args)
3539 try: self.this.append(this)
3540 except: self.this = this
3541 def do_get_sample_assignments(self, *args):
3542 """do_get_sample_assignments(BranchAndBoundSampler self, Subset known) -> IMP::domino::Assignments"""
3543 return _IMP_domino.BranchAndBoundSampler_do_get_sample_assignments(self, *args)
3545 def get_version_info(self):
3546 """get_version_info(BranchAndBoundSampler self) -> VersionInfo"""
3547 return _IMP_domino.BranchAndBoundSampler_get_version_info(self)
3549 def do_show(self, *args):
3550 """do_show(BranchAndBoundSampler self, _ostream out)"""
3551 return _IMP_domino.BranchAndBoundSampler_do_show(self, *args)
3553 __swig_destroy__ = _IMP_domino.delete_BranchAndBoundSampler
3554 __del__ =
lambda self :
None;
3556 """__str__(BranchAndBoundSampler self) -> std::string"""
3557 return _IMP_domino.BranchAndBoundSampler___str__(self)
3560 """__repr__(BranchAndBoundSampler self) -> std::string"""
3561 return _IMP_domino.BranchAndBoundSampler___repr__(self)
3564 return _object_cast_to_BranchAndBoundSampler(o)
3565 get_from = staticmethod(get_from)
3567 BranchAndBoundSampler_swigregister = _IMP_domino.BranchAndBoundSampler_swigregister
3568 BranchAndBoundSampler_swigregister(BranchAndBoundSampler)
3572 """load_particle_states(Subset s, Assignment ss, ParticleStatesTable pst)"""
3573 return _IMP_domino.load_particle_states(*args)
3576 """get_restraints(Subset s, ParticleStatesTable pst, IMP::kernel::DependencyGraph const & dg, RestraintSet rs) -> IMP::kernel::RestraintsTemp"""
3577 return _IMP_domino.get_restraints(*args)
3580 """get_index(IMP::kernel::ParticlesTemp const & particles, Subset subset, IMP::domino::Subsets const & excluded) -> IMP::Ints"""
3581 return _IMP_domino.get_index(*args)
3584 """get_partial_index(IMP::kernel::ParticlesTemp const & particles, Subset subset, IMP::domino::Subsets const & excluded) -> IMP::Ints"""
3585 return _IMP_domino.get_partial_index(*args)
3588 """get_possible_interactions(IMP::kernel::ParticlesTemp const & ps, double max_distance, ParticleStatesTable pst) -> IMP::kernel::ParticlePairsTemp"""
3589 return _IMP_domino.get_possible_interactions(*args)
3592 """get_embedding(Subset s, Assignment a, ParticleStatesTable pst) -> VectorKD"""
3593 return _IMP_domino.get_embedding(*args)
3596 """get_nearest_assignment(Subset s, VectorKD embedding, ParticleStatesTable pst) -> Assignment"""
3597 return _IMP_domino.get_nearest_assignment(*args)
3601 get_distance_if_smaller_than(Subset s, Assignment a, Assignment b, ParticleStatesTable pst, IMP::statistics::Metrics const & metrics,
3602 double max) -> double
3604 return _IMP_domino.get_distance_if_smaller_than(*args)
3607 """load_leaf_assignments(Subset subset, AssignmentsTable at, AssignmentContainer ac)"""
3608 return _IMP_domino.load_leaf_assignments(*args)
3612 load_merged_assignments(Subset first_subset, AssignmentContainer first, Subset second_subset, AssignmentContainer second,
3613 IMP::domino::SubsetFilterTablesTemp const & filters, AssignmentContainer ret)
3615 return _IMP_domino.load_merged_assignments(*args)
3619 load_merged_assignments_random_order(Subset first_subset, AssignmentContainer first, Subset second_subset, AssignmentContainer second,
3620 IMP::domino::SubsetFilterTablesTemp const & filters, unsigned int maximum_tries,
3621 AssignmentContainer ret)
3623 return _IMP_domino.load_merged_assignments_random_order(*args)
3627 get_state_clusters(Subset subset, IMP::domino::Assignments const & states, ParticleStatesTable pst,
3628 double resolution) -> IMP::domino::Assignments
3630 return _IMP_domino.get_state_clusters(*args)
3632 """Proxy of C++ IMP::domino::DependencyScoreState class"""
3633 __swig_setmethods__ = {}
3635 __setattr__ =
lambda self, name, value: _swig_setattr(self, DependencyScoreState, name, value)
3636 __swig_getmethods__ = {}
3638 __getattr__ =
lambda self, name: _swig_getattr(self, DependencyScoreState, name)
3640 """__init__(IMP::domino::DependencyScoreState self) -> DependencyScoreState"""
3641 this = _IMP_domino.new_DependencyScoreState()
3642 try: self.this.append(this)
3643 except: self.this = this
3644 def set_input_particles(self, *args):
3645 """set_input_particles(DependencyScoreState self, IMP::kernel::ParticlesTemp const & pt)"""
3646 return _IMP_domino.DependencyScoreState_set_input_particles(self, *args)
3648 def set_output_particles(self, *args):
3649 """set_output_particles(DependencyScoreState self, IMP::kernel::ParticlesTemp const & pt)"""
3650 return _IMP_domino.DependencyScoreState_set_output_particles(self, *args)
3652 def set_input_containers(self, *args):
3653 """set_input_containers(DependencyScoreState self, IMP::kernel::ContainersTemp const & pt)"""
3654 return _IMP_domino.DependencyScoreState_set_input_containers(self, *args)
3656 def set_output_containers(self, *args):
3657 """set_output_containers(DependencyScoreState self, IMP::kernel::ContainersTemp const & pt)"""
3658 return _IMP_domino.DependencyScoreState_set_output_containers(self, *args)
3660 def get_version_info(self):
3661 """get_version_info(DependencyScoreState self) -> VersionInfo"""
3662 return _IMP_domino.DependencyScoreState_get_version_info(self)
3664 __swig_destroy__ = _IMP_domino.delete_DependencyScoreState
3665 __del__ =
lambda self :
None;
3667 """__str__(DependencyScoreState self) -> std::string"""
3668 return _IMP_domino.DependencyScoreState___str__(self)
3671 """__repr__(DependencyScoreState self) -> std::string"""
3672 return _IMP_domino.DependencyScoreState___repr__(self)
3675 return _object_cast_to_DependencyScoreState(o)
3676 get_from = staticmethod(get_from)
3678 DependencyScoreState_swigregister = _IMP_domino.DependencyScoreState_swigregister
3679 DependencyScoreState_swigregister(DependencyScoreState)
3682 def _get_ints_list(*args):
3683 """_get_ints_list(IMP::IntsList const & input) -> IMP::IntsList"""
3684 return _IMP_domino._get_ints_list(*args)
3686 def get_module_version():
3687 """get_module_version() -> std::string const"""
3688 return _IMP_domino.get_module_version()
3690 def get_example_path(*args):
3691 """get_example_path(std::string fname) -> std::string"""
3692 return _IMP_domino.get_example_path(*args)
3694 def get_data_path(*args):
3695 """get_data_path(std::string fname) -> std::string"""
3696 return _IMP_domino.get_data_path(*args)
3697 import _version_check
3698 _version_check.check_version(get_module_version())