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_kernel', [dirname(__file__)])
22 _mod = imp.load_module(
'_IMP_kernel', fp, pathname, description)
26 _IMP_kernel = 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_KERNEL_SwigPyIterator(_object):
78 """Proxy of C++ swig::IMP_KERNEL_SwigPyIterator class"""
79 __swig_setmethods__ = {}
80 __setattr__ =
lambda self, name, value: _swig_setattr(self, IMP_KERNEL_SwigPyIterator, name, value)
81 __swig_getmethods__ = {}
82 __getattr__ =
lambda self, name: _swig_getattr(self, IMP_KERNEL_SwigPyIterator, name)
83 def __init__(self, *args, **kwargs):
raise AttributeError(
"No constructor defined - class is abstract")
85 __swig_destroy__ = _IMP_kernel.delete_IMP_KERNEL_SwigPyIterator
86 __del__ =
lambda self :
None;
88 """value(IMP_KERNEL_SwigPyIterator self) -> PyObject *"""
89 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_value(self)
93 incr(IMP_KERNEL_SwigPyIterator self, size_t n=1) -> IMP_KERNEL_SwigPyIterator
94 incr(IMP_KERNEL_SwigPyIterator self) -> IMP_KERNEL_SwigPyIterator
96 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_incr(self, n)
100 decr(IMP_KERNEL_SwigPyIterator self, size_t n=1) -> IMP_KERNEL_SwigPyIterator
101 decr(IMP_KERNEL_SwigPyIterator self) -> IMP_KERNEL_SwigPyIterator
103 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_decr(self, n)
105 def distance(self, *args):
106 """distance(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> ptrdiff_t"""
107 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_distance(self, *args)
109 def equal(self, *args):
110 """equal(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> bool"""
111 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_equal(self, *args)
114 """copy(IMP_KERNEL_SwigPyIterator self) -> IMP_KERNEL_SwigPyIterator"""
115 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_copy(self)
118 """next(IMP_KERNEL_SwigPyIterator self) -> PyObject *"""
119 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_next(self)
122 """__next__(IMP_KERNEL_SwigPyIterator self) -> PyObject *"""
123 return _IMP_kernel.IMP_KERNEL_SwigPyIterator___next__(self)
126 """previous(IMP_KERNEL_SwigPyIterator self) -> PyObject *"""
127 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_previous(self)
129 def advance(self, *args):
130 """advance(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator"""
131 return _IMP_kernel.IMP_KERNEL_SwigPyIterator_advance(self, *args)
133 def __eq__(self, *args):
134 """__eq__(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> bool"""
135 return _IMP_kernel.IMP_KERNEL_SwigPyIterator___eq__(self, *args)
137 def __ne__(self, *args):
138 """__ne__(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> bool"""
139 return _IMP_kernel.IMP_KERNEL_SwigPyIterator___ne__(self, *args)
141 def __iadd__(self, *args):
142 """__iadd__(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator"""
143 return _IMP_kernel.IMP_KERNEL_SwigPyIterator___iadd__(self, *args)
145 def __isub__(self, *args):
146 """__isub__(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator"""
147 return _IMP_kernel.IMP_KERNEL_SwigPyIterator___isub__(self, *args)
149 def __add__(self, *args):
150 """__add__(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator"""
151 return _IMP_kernel.IMP_KERNEL_SwigPyIterator___add__(self, *args)
153 def __sub__(self, *args):
155 __sub__(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator
156 __sub__(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> ptrdiff_t
158 return _IMP_kernel.IMP_KERNEL_SwigPyIterator___sub__(self, *args)
160 def __iter__(self):
return self
161 IMP_KERNEL_SwigPyIterator_swigregister = _IMP_kernel.IMP_KERNEL_SwigPyIterator_swigregister
162 IMP_KERNEL_SwigPyIterator_swigregister(IMP_KERNEL_SwigPyIterator)
169 IMP_HAS_DEPRECATED = _IMP_kernel.IMP_HAS_DEPRECATED
170 IMP_DEBUG = _IMP_kernel.IMP_DEBUG
171 IMP_RELEASE = _IMP_kernel.IMP_RELEASE
172 IMP_SILENT = _IMP_kernel.IMP_SILENT
173 IMP_PROGRESS = _IMP_kernel.IMP_PROGRESS
174 IMP_TERSE = _IMP_kernel.IMP_TERSE
175 IMP_VERBOSE = _IMP_kernel.IMP_VERBOSE
176 IMP_NONE = _IMP_kernel.IMP_NONE
177 IMP_USAGE = _IMP_kernel.IMP_USAGE
178 IMP_INTERNAL = _IMP_kernel.IMP_INTERNAL
179 IMP_COMPILER_HAS_AUTO = _IMP_kernel.IMP_COMPILER_HAS_AUTO
180 IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_kernel.IMP_COMPILER_HAS_DEBUG_VECTOR
181 IMP_COMPILER_HAS_NULLPTR = _IMP_kernel.IMP_COMPILER_HAS_NULLPTR
182 IMP_BASE_HAS_BOOST_RANDOM = _IMP_kernel.IMP_BASE_HAS_BOOST_RANDOM
183 IMP_BASE_HAS_GPERFTOOLS = _IMP_kernel.IMP_BASE_HAS_GPERFTOOLS
184 IMP_BASE_HAS_LOG4CXX = _IMP_kernel.IMP_BASE_HAS_LOG4CXX
185 IMP_BASE_HAS_TCMALLOC_HEAPCHECKER = _IMP_kernel.IMP_BASE_HAS_TCMALLOC_HEAPCHECKER
186 IMP_BASE_HAS_TCMALLOC_HEAPPROFILER = _IMP_kernel.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_kernel.DEFAULT_CHECK
214 NONE = _IMP_kernel.NONE
215 USAGE = _IMP_kernel.USAGE
216 USAGE_AND_INTERNAL = _IMP_kernel.USAGE_AND_INTERNAL
219 """set_check_level(IMP::base::CheckLevel tf)"""
220 return _IMP_kernel.set_check_level(*args)
223 """get_check_level() -> IMP::base::CheckLevel"""
224 return _IMP_kernel.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_kernel._ostream_write(self, *args)
237 _ostream_swigregister = _IMP_kernel._ostream_swigregister
238 _ostream_swigregister(_ostream)
240 IMP_COMPILER_HAS_OVERRIDE = _IMP_kernel.IMP_COMPILER_HAS_OVERRIDE
241 IMP_COMPILER_HAS_FINAL = _IMP_kernel.IMP_COMPILER_HAS_FINAL
243 IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_kernel.IMP_CGAL_HAS_BOOST_FILESYSTEM
244 IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_kernel.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS
245 IMP_CGAL_HAS_BOOST_RANDOM = _IMP_kernel.IMP_CGAL_HAS_BOOST_RANDOM
246 IMP_CGAL_HAS_BOOST_SYSTEM = _IMP_kernel.IMP_CGAL_HAS_BOOST_SYSTEM
248 IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_kernel.IMP_ALGEBRA_HAS_IMP_CGAL
249 IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_kernel.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM
250 IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_kernel.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS
251 IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_kernel.IMP_ALGEBRA_HAS_BOOST_RANDOM
252 IMP_ALGEBRA_HAS_BOOST_SYSTEM = _IMP_kernel.IMP_ALGEBRA_HAS_BOOST_SYSTEM
253 IMP_ALGEBRA_HAS_CGAL = _IMP_kernel.IMP_ALGEBRA_HAS_CGAL
254 IMP_ALGEBRA_HAS_ANN = _IMP_kernel.IMP_ALGEBRA_HAS_ANN
256 IMP_KERNEL_HAS_IMP_CGAL = _IMP_kernel.IMP_KERNEL_HAS_IMP_CGAL
257 IMP_KERNEL_HAS_BOOST_PROGRAMOPTIONS = _IMP_kernel.IMP_KERNEL_HAS_BOOST_PROGRAMOPTIONS
258 IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_kernel.IMP_KERNEL_HAS_BOOST_RANDOM
259 IMP_KERNEL_HAS_BOOST_SYSTEM = _IMP_kernel.IMP_KERNEL_HAS_BOOST_SYSTEM
260 IMP_KERNEL_HAS_CGAL = _IMP_kernel.IMP_KERNEL_HAS_CGAL
262 i_m_p=
"IMP_MODULE_PATH"
263 if i_m_p
in os.environ.keys():
264 __path__.insert(0, os.environ[i_m_p])
266 def _forward_add_attribute(self, name, value, opt=None):
268 self.get_particle().add_attribute(name, value, opt)
270 self.get_particle().add_attribute(name, value)
271 def _forward_get_value(self, name):
272 self.get_particle().get_value(name)
273 def _forward_set_value(self, name, value):
274 self.get_particle().set_value(name, value)
278 _object_types.append(
"Constraint")
281 def _object_cast_to_Constraint(*args):
282 """_object_cast_to_Constraint(Object o) -> Constraint"""
283 return _IMP_kernel._object_cast_to_Constraint(*args)
284 _object_types.append(
"Undecorator")
287 def _object_cast_to_Undecorator(*args):
288 """_object_cast_to_Undecorator(Object o) -> Undecorator"""
289 return _IMP_kernel._object_cast_to_Undecorator(*args)
290 _object_types.append(
"Container")
293 def _object_cast_to_Container(*args):
294 """_object_cast_to_Container(Object o) -> Container"""
295 return _IMP_kernel._object_cast_to_Container(*args)
296 _object_types.append(
"Optimizer")
299 def _object_cast_to_Optimizer(*args):
300 """_object_cast_to_Optimizer(Object o) -> Optimizer"""
301 return _IMP_kernel._object_cast_to_Optimizer(*args)
302 _object_types.append(
"OptimizerState")
305 def _object_cast_to_OptimizerState(*args):
306 """_object_cast_to_OptimizerState(Object o) -> OptimizerState"""
307 return _IMP_kernel._object_cast_to_OptimizerState(*args)
308 _object_types.append(
"PairContainer")
311 def _object_cast_to_PairContainer(*args):
312 """_object_cast_to_PairContainer(Object o) -> PairContainer"""
313 return _IMP_kernel._object_cast_to_PairContainer(*args)
314 _object_types.append(
"PairModifier")
317 def _object_cast_to_PairModifier(*args):
318 """_object_cast_to_PairModifier(Object o) -> PairModifier"""
319 return _IMP_kernel._object_cast_to_PairModifier(*args)
320 _object_types.append(
"PairScore")
323 def _object_cast_to_PairScore(*args):
324 """_object_cast_to_PairScore(Object o) -> PairScore"""
325 return _IMP_kernel._object_cast_to_PairScore(*args)
326 _object_types.append(
"QuadContainer")
329 def _object_cast_to_QuadContainer(*args):
330 """_object_cast_to_QuadContainer(Object o) -> QuadContainer"""
331 return _IMP_kernel._object_cast_to_QuadContainer(*args)
332 _object_types.append(
"QuadModifier")
335 def _object_cast_to_QuadModifier(*args):
336 """_object_cast_to_QuadModifier(Object o) -> QuadModifier"""
337 return _IMP_kernel._object_cast_to_QuadModifier(*args)
338 _object_types.append(
"QuadScore")
341 def _object_cast_to_QuadScore(*args):
342 """_object_cast_to_QuadScore(Object o) -> QuadScore"""
343 return _IMP_kernel._object_cast_to_QuadScore(*args)
344 _object_types.append(
"Refiner")
347 def _object_cast_to_Refiner(*args):
348 """_object_cast_to_Refiner(Object o) -> Refiner"""
349 return _IMP_kernel._object_cast_to_Refiner(*args)
350 _object_types.append(
"Restraint")
353 def _object_cast_to_Restraint(*args):
354 """_object_cast_to_Restraint(Object o) -> Restraint"""
355 return _IMP_kernel._object_cast_to_Restraint(*args)
356 _object_types.append(
"Sampler")
359 def _object_cast_to_Sampler(*args):
360 """_object_cast_to_Sampler(Object o) -> Sampler"""
361 return _IMP_kernel._object_cast_to_Sampler(*args)
362 _object_types.append(
"ScoreState")
365 def _object_cast_to_ScoreState(*args):
366 """_object_cast_to_ScoreState(Object o) -> ScoreState"""
367 return _IMP_kernel._object_cast_to_ScoreState(*args)
368 _object_types.append(
"SingletonContainer")
371 def _object_cast_to_SingletonContainer(*args):
372 """_object_cast_to_SingletonContainer(Object o) -> SingletonContainer"""
373 return _IMP_kernel._object_cast_to_SingletonContainer(*args)
374 _object_types.append(
"SingletonModifier")
377 def _object_cast_to_SingletonModifier(*args):
378 """_object_cast_to_SingletonModifier(Object o) -> SingletonModifier"""
379 return _IMP_kernel._object_cast_to_SingletonModifier(*args)
380 _object_types.append(
"SingletonScore")
383 def _object_cast_to_SingletonScore(*args):
384 """_object_cast_to_SingletonScore(Object o) -> SingletonScore"""
385 return _IMP_kernel._object_cast_to_SingletonScore(*args)
386 _object_types.append(
"TripletContainer")
389 def _object_cast_to_TripletContainer(*args):
390 """_object_cast_to_TripletContainer(Object o) -> TripletContainer"""
391 return _IMP_kernel._object_cast_to_TripletContainer(*args)
392 _object_types.append(
"TripletModifier")
395 def _object_cast_to_TripletModifier(*args):
396 """_object_cast_to_TripletModifier(Object o) -> TripletModifier"""
397 return _IMP_kernel._object_cast_to_TripletModifier(*args)
398 _object_types.append(
"TripletScore")
401 def _object_cast_to_TripletScore(*args):
402 """_object_cast_to_TripletScore(Object o) -> TripletScore"""
403 return _IMP_kernel._object_cast_to_TripletScore(*args)
404 _object_types.append(
"UnaryFunction")
407 def _object_cast_to_UnaryFunction(*args):
408 """_object_cast_to_UnaryFunction(Object o) -> UnaryFunction"""
409 return _IMP_kernel._object_cast_to_UnaryFunction(*args)
410 _object_types.append(
"ConfigurationSet")
413 def _object_cast_to_ConfigurationSet(*args):
414 """_object_cast_to_ConfigurationSet(Object o) -> ConfigurationSet"""
415 return _IMP_kernel._object_cast_to_ConfigurationSet(*args)
416 _object_types.append(
"Configuration")
419 def _object_cast_to_Configuration(*args):
420 """_object_cast_to_Configuration(Object o) -> Configuration"""
421 return _IMP_kernel._object_cast_to_Configuration(*args)
422 _object_types.append(
"Model")
425 def _object_cast_to_Model(*args):
426 """_object_cast_to_Model(Object o) -> Model"""
427 return _IMP_kernel._object_cast_to_Model(*args)
428 _object_types.append(
"Particle")
431 def _object_cast_to_Particle(*args):
432 """_object_cast_to_Particle(Object o) -> Particle"""
433 return _IMP_kernel._object_cast_to_Particle(*args)
434 _object_types.append(
"PythonRestraint")
437 def _object_cast_to_PythonRestraint(*args):
438 """_object_cast_to_PythonRestraint(Object o) -> PythonRestraint"""
439 return _IMP_kernel._object_cast_to_PythonRestraint(*args)
440 _object_types.append(
"PythonScoreState")
443 def _object_cast_to_PythonScoreState(*args):
444 """_object_cast_to_PythonScoreState(Object o) -> PythonScoreState"""
445 return _IMP_kernel._object_cast_to_PythonScoreState(*args)
446 _object_types.append(
"RestraintSet")
449 def _object_cast_to_RestraintSet(*args):
450 """_object_cast_to_RestraintSet(Object o) -> RestraintSet"""
451 return _IMP_kernel._object_cast_to_RestraintSet(*args)
452 ParticlePairsTemp=list
453 _plural_types.append(
"ParticlePairsTemp")
454 _value_types.append(
"ParticlePair")
456 ParticleTripletsTemp=list
457 _plural_types.append(
"ParticleTripletsTemp")
458 _value_types.append(
"ParticleTriplet")
460 ParticleQuadsTemp=list
461 _plural_types.append(
"ParticleQuadsTemp")
462 _value_types.append(
"ParticleQuad")
464 ParticleIndexPairs=list
465 _plural_types.append(
"ParticleIndexPairs")
466 _value_types.append(
"ParticleIndexPair")
468 ParticleIndexTriplets=list
469 _plural_types.append(
"ParticleIndexTriplets")
470 _value_types.append(
"ParticleIndexTriplet")
472 ParticleIndexQuads=list
473 _plural_types.append(
"ParticleIndexQuads")
474 _value_types.append(
"ParticleIndexQuad")
476 _object_types.append(
"SingletonPredicate")
479 def _object_cast_to_SingletonPredicate(*args):
480 """_object_cast_to_SingletonPredicate(Object o) -> SingletonPredicate"""
481 return _IMP_kernel._object_cast_to_SingletonPredicate(*args)
482 _object_types.append(
"PairPredicate")
485 def _object_cast_to_PairPredicate(*args):
486 """_object_cast_to_PairPredicate(Object o) -> PairPredicate"""
487 return _IMP_kernel._object_cast_to_PairPredicate(*args)
488 _object_types.append(
"TripletPredicate")
491 def _object_cast_to_TripletPredicate(*args):
492 """_object_cast_to_TripletPredicate(Object o) -> TripletPredicate"""
493 return _IMP_kernel._object_cast_to_TripletPredicate(*args)
494 _object_types.append(
"QuadPredicate")
497 def _object_cast_to_QuadPredicate(*args):
498 """_object_cast_to_QuadPredicate(Object o) -> QuadPredicate"""
499 return _IMP_kernel._object_cast_to_QuadPredicate(*args)
500 _object_types.append(
"SaveToConfigurationSetOptimizerState")
503 def _object_cast_to_SaveToConfigurationSetOptimizerState(*args):
504 """_object_cast_to_SaveToConfigurationSetOptimizerState(Object o) -> SaveToConfigurationSetOptimizerState"""
505 return _IMP_kernel._object_cast_to_SaveToConfigurationSetOptimizerState(*args)
506 EvaluationStates=list
507 _plural_types.append(
"EvaluationStates")
508 _value_types.append(
"EvaluationState")
510 ScoreAccumulators=list
511 _plural_types.append(
"ScoreAccumulators")
512 _value_types.append(
"ScoreAccumulator")
515 _plural_types.append(
"ParticleIndexes")
516 _value_types.append(
"ParticleIndex")
519 _plural_types.append(
"FloatIndexes")
520 _value_types.append(
"FloatIndex")
523 _plural_types.append(
"FloatKeys")
524 _value_types.append(
"FloatKey")
527 _plural_types.append(
"IntKeys")
528 _value_types.append(
"IntKey")
531 _plural_types.append(
"StringKeys")
532 _value_types.append(
"StringKey")
534 ParticleIndexKeys=list
535 _plural_types.append(
"ParticleIndexKeys")
536 _value_types.append(
"ParticleIndexKey")
538 ParticleIndexesKeys=list
539 _plural_types.append(
"ParticleIndexesKeys")
540 _value_types.append(
"ParticleIndexesKey")
543 _plural_types.append(
"ObjectKeys")
544 _value_types.append(
"ObjectKey")
546 _raii_types.append(
"ScopedRestraint")
548 _raii_types.append(
"ScopedRemoveRestraint")
550 _raii_types.append(
"ScopedRemoveScoreState")
552 _raii_types.append(
"ScopedScoreState")
554 _raii_types.append(
"ScopedSetFloatAttribute")
556 RestraintStatisticsList=list
557 _plural_types.append(
"RestraintStatisticsList")
558 _value_types.append(
"RestraintStatistics")
560 _object_types.append(
"ScoringFunction")
563 def _object_cast_to_ScoringFunction(*args):
564 """_object_cast_to_ScoringFunction(Object o) -> ScoringFunction"""
565 return _IMP_kernel._object_cast_to_ScoringFunction(*args)
566 _object_types.append(
"ModelObject")
569 def _object_cast_to_ModelObject(*args):
570 """_object_cast_to_ModelObject(Object o) -> ModelObject"""
571 return _IMP_kernel._object_cast_to_ModelObject(*args)
572 def _TrivialDecorators(l=[]):
573 return [_TrivialDecorator(x)
for x
in l]
574 _plural_types.append(
"_TrivialDecorators")
576 _value_types.append(
"_TrivialDecorator")
578 def _TrivialDerivedDecorators(l=[]):
579 return [_TrivialDerivedDecorator(x)
for x
in l]
580 _plural_types.append(
"_TrivialDerivedDecorators")
582 _value_types.append(
"_TrivialDerivedDecorator")
584 def _TrivialTraitsDecorators(l=[]):
585 return [_TrivialTraitsDecorator(x)
for x
in l]
586 _plural_types.append(
"_TrivialTraitsDecorators")
588 _value_types.append(
"_TrivialTraitsDecorator")
590 _object_types.append(
"_ConstRestraint")
593 def _object_cast_to__ConstRestraint(*args):
594 """_object_cast_to__ConstRestraint(Object o) -> _ConstRestraint"""
595 return _IMP_kernel._object_cast_to__ConstRestraint(*args)
596 _object_types.append(
"_ConstOptimizer")
599 def _object_cast_to__ConstOptimizer(*args):
600 """_object_cast_to__ConstOptimizer(Object o) -> _ConstOptimizer"""
601 return _IMP_kernel._object_cast_to__ConstOptimizer(*args)
603 """Proxy of C++ IMP::base::internal::BoostDigraph<(IMP::kernel::DependencyGraph,p.IMP::kernel::ModelObject)> class"""
604 __swig_setmethods__ = {}
605 for _s
in [
IMP.base.Object]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
606 __setattr__ =
lambda self, name, value: _swig_setattr(self, DependencyGraph, name, value)
607 __swig_getmethods__ = {}
608 for _s
in [
IMP.base.Object]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
609 __getattr__ =
lambda self, name: _swig_getattr(self, DependencyGraph, name)
610 __repr__ = _swig_repr
612 """__init__(IMP::base::internal::BoostDigraph<(IMP::kernel::DependencyGraph,p.IMP::kernel::ModelObject)> self) -> DependencyGraph"""
613 this = _IMP_kernel.new_DependencyGraph()
614 try: self.this.append(this)
615 except: self.this = this
617 """get_graph(DependencyGraph self) -> IMP::kernel::DependencyGraph const &"""
618 return _IMP_kernel.DependencyGraph_get_graph(self)
620 def get_vertices(self):
621 """get_vertices(DependencyGraph self) -> IMP::base::internal::BoostDigraph< IMP::kernel::DependencyGraph,IMP::kernel::ModelObject * >::VertexDescriptors"""
622 return _IMP_kernel.DependencyGraph_get_vertices(self)
624 def get_vertex_name(self, *args):
625 """get_vertex_name(DependencyGraph self, IMP::base::internal::BoostDigraph< IMP::kernel::DependencyGraph,IMP::kernel::ModelObject * >::VertexDescriptor i) -> ModelObject"""
626 return _IMP_kernel.DependencyGraph_get_vertex_name(self, *args)
628 def get_in_neighbors(self, *args):
629 """get_in_neighbors(DependencyGraph self, IMP::base::internal::BoostDigraph< IMP::kernel::DependencyGraph,IMP::kernel::ModelObject * >::VertexDescriptor v) -> IMP::base::internal::BoostDigraph< IMP::kernel::DependencyGraph,IMP::kernel::ModelObject * >::VertexDescriptors"""
630 return _IMP_kernel.DependencyGraph_get_in_neighbors(self, *args)
632 def get_out_neighbors(self, *args):
633 """get_out_neighbors(DependencyGraph self, IMP::base::internal::BoostDigraph< IMP::kernel::DependencyGraph,IMP::kernel::ModelObject * >::VertexDescriptor v) -> IMP::base::internal::BoostDigraph< IMP::kernel::DependencyGraph,IMP::kernel::ModelObject * >::VertexDescriptors"""
634 return _IMP_kernel.DependencyGraph_get_out_neighbors(self, *args)
636 def do_show(self, *args):
637 """do_show(DependencyGraph self, _ostream out)"""
638 return _IMP_kernel.DependencyGraph_do_show(self, *args)
642 show_graphviz(DependencyGraph self, _ostream out=std::cout)
643 show_graphviz(DependencyGraph self)
645 return _IMP_kernel.DependencyGraph_show_graphviz(self, *args)
647 def get_graphviz_string(self):
648 """get_graphviz_string(DependencyGraph self) -> std::string"""
649 return _IMP_kernel.DependencyGraph_get_graphviz_string(self)
651 def get_type_name(self):
652 """get_type_name(DependencyGraph self) -> std::string"""
653 return _IMP_kernel.DependencyGraph_get_type_name(self)
655 def add_edge(self, *args):
657 add_edge(DependencyGraph self, IMP::base::internal::BoostDigraph< IMP::kernel::DependencyGraph,IMP::kernel::ModelObject * >::VertexDescriptor v0,
658 IMP::base::internal::BoostDigraph< IMP::kernel::DependencyGraph,IMP::kernel::ModelObject * >::VertexDescriptor v1)
660 return _IMP_kernel.DependencyGraph_add_edge(self, *args)
662 def add_vertex(self, *args):
663 """add_vertex(DependencyGraph self, ModelObject l) -> IMP::base::internal::BoostDigraph< IMP::kernel::DependencyGraph,IMP::kernel::ModelObject * >::VertexDescriptor"""
664 return _IMP_kernel.DependencyGraph_add_vertex(self, *args)
666 def remove_vertex(self, *args):
667 """remove_vertex(DependencyGraph self, IMP::base::internal::BoostDigraph< IMP::kernel::DependencyGraph,IMP::kernel::ModelObject * >::VertexDescriptor l)"""
668 return _IMP_kernel.DependencyGraph_remove_vertex(self, *args)
670 __swig_destroy__ = _IMP_kernel.delete_DependencyGraph
671 __del__ =
lambda self :
None;
672 DependencyGraph_swigregister = _IMP_kernel.DependencyGraph_swigregister
673 DependencyGraph_swigregister(DependencyGraph)
675 _value_types.append(
"DependencyGraph")
678 """Proxy of C++ IMP::kernel::Key<(0,true)> class"""
679 __swig_setmethods__ = {}
680 for _s
in [IMP.base._Value]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
681 __setattr__ =
lambda self, name, value: _swig_setattr(self, FloatKey, name, value)
682 __swig_getmethods__ = {}
683 for _s
in [IMP.base._Value]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
684 __getattr__ =
lambda self, name: _swig_getattr(self, FloatKey, name)
685 def __init__(self, *args):
687 __init__(IMP::kernel::Key<(0,true)> self) -> FloatKey
688 __init__(IMP::kernel::Key<(0,true)> self, std::string c) -> FloatKey
689 __init__(IMP::kernel::Key<(0,true)> self, unsigned int i) -> FloatKey
691 this = _IMP_kernel.new_FloatKey(*args)
692 try: self.this.append(this)
693 except: self.this = this
695 """add_key(std::string sc) -> unsigned int"""
696 return _IMP_kernel.FloatKey_add_key(*args)
698 if _newclass:add_key = staticmethod(add_key)
699 __swig_getmethods__[
"add_key"] =
lambda x: add_key
700 def get_key_exists(*args):
701 """get_key_exists(std::string sc) -> bool"""
702 return _IMP_kernel.FloatKey_get_key_exists(*args)
704 if _newclass:get_key_exists = staticmethod(get_key_exists)
705 __swig_getmethods__[
"get_key_exists"] =
lambda x: get_key_exists
706 def get_string(self):
707 """get_string(FloatKey self) -> std::string const"""
708 return _IMP_kernel.FloatKey_get_string(self)
710 def __eq__(self, *args):
711 """__eq__(FloatKey self, FloatKey o) -> bool"""
712 return _IMP_kernel.FloatKey___eq__(self, *args)
714 def __ne__(self, *args):
715 """__ne__(FloatKey self, FloatKey o) -> bool"""
716 return _IMP_kernel.FloatKey___ne__(self, *args)
718 def __lt__(self, *args):
719 """__lt__(FloatKey self, FloatKey o) -> bool"""
720 return _IMP_kernel.FloatKey___lt__(self, *args)
722 def __gt__(self, *args):
723 """__gt__(FloatKey self, FloatKey o) -> bool"""
724 return _IMP_kernel.FloatKey___gt__(self, *args)
726 def __ge__(self, *args):
727 """__ge__(FloatKey self, FloatKey o) -> bool"""
728 return _IMP_kernel.FloatKey___ge__(self, *args)
730 def __le__(self, *args):
731 """__le__(FloatKey self, FloatKey o) -> bool"""
732 return _IMP_kernel.FloatKey___le__(self, *args)
735 """__hash__(FloatKey self) -> std::size_t"""
736 return _IMP_kernel.FloatKey___hash__(self)
738 def show(self, *args):
740 show(FloatKey self, _ostream out=std::cout)
743 return _IMP_kernel.FloatKey_show(self, *args)
745 def add_alias(*args):
746 """add_alias(FloatKey old_key, std::string new_name) -> FloatKey"""
747 return _IMP_kernel.FloatKey_add_alias(*args)
749 if _newclass:add_alias = staticmethod(add_alias)
750 __swig_getmethods__[
"add_alias"] =
lambda x: add_alias
752 """get_index(FloatKey self) -> unsigned int"""
753 return _IMP_kernel.FloatKey_get_index(self)
756 """show_all(_ostream out)"""
757 return _IMP_kernel.FloatKey_show_all(*args)
759 if _newclass:show_all = staticmethod(show_all)
760 __swig_getmethods__[
"show_all"] =
lambda x: show_all
761 def get_all_strings():
762 """get_all_strings() -> IMP::base::Vector< std::string >"""
763 return _IMP_kernel.FloatKey_get_all_strings()
765 if _newclass:get_all_strings = staticmethod(get_all_strings)
766 __swig_getmethods__[
"get_all_strings"] =
lambda x: get_all_strings
767 def get_number_unique():
768 """get_number_unique() -> unsigned int"""
769 return _IMP_kernel.FloatKey_get_number_unique()
771 if _newclass:get_number_unique = staticmethod(get_number_unique)
772 __swig_getmethods__[
"get_number_unique"] =
lambda x: get_number_unique
774 """__str__(FloatKey self) -> std::string"""
775 return _IMP_kernel.FloatKey___str__(self)
778 """__repr__(FloatKey self) -> std::string"""
779 return _IMP_kernel.FloatKey___repr__(self)
781 __swig_destroy__ = _IMP_kernel.delete_FloatKey
782 __del__ =
lambda self :
None;
783 FloatKey_swigregister = _IMP_kernel.FloatKey_swigregister
784 FloatKey_swigregister(FloatKey)
786 def FloatKey_add_key(*args):
787 """FloatKey_add_key(std::string sc) -> unsigned int"""
788 return _IMP_kernel.FloatKey_add_key(*args)
790 def FloatKey_get_key_exists(*args):
791 """FloatKey_get_key_exists(std::string sc) -> bool"""
792 return _IMP_kernel.FloatKey_get_key_exists(*args)
794 def FloatKey_add_alias(*args):
795 """FloatKey_add_alias(FloatKey old_key, std::string new_name) -> FloatKey"""
796 return _IMP_kernel.FloatKey_add_alias(*args)
798 def FloatKey_show_all(*args):
799 """FloatKey_show_all(_ostream out)"""
800 return _IMP_kernel.FloatKey_show_all(*args)
802 def FloatKey_get_all_strings():
803 """FloatKey_get_all_strings() -> IMP::base::Vector< std::string >"""
804 return _IMP_kernel.FloatKey_get_all_strings()
806 def FloatKey_get_number_unique():
807 """FloatKey_get_number_unique() -> unsigned int"""
808 return _IMP_kernel.FloatKey_get_number_unique()
810 class IntKey(IMP.base._Value):
811 """Proxy of C++ IMP::kernel::Key<(1,true)> class"""
812 __swig_setmethods__ = {}
813 for _s
in [IMP.base._Value]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
814 __setattr__ =
lambda self, name, value: _swig_setattr(self, IntKey, name, value)
815 __swig_getmethods__ = {}
816 for _s
in [IMP.base._Value]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
817 __getattr__ =
lambda self, name: _swig_getattr(self, IntKey, name)
818 def __init__(self, *args):
820 __init__(IMP::kernel::Key<(1,true)> self) -> IntKey
821 __init__(IMP::kernel::Key<(1,true)> self, std::string c) -> IntKey
822 __init__(IMP::kernel::Key<(1,true)> self, unsigned int i) -> IntKey
824 this = _IMP_kernel.new_IntKey(*args)
825 try: self.this.append(this)
826 except: self.this = this
828 """add_key(std::string sc) -> unsigned int"""
829 return _IMP_kernel.IntKey_add_key(*args)
831 if _newclass:add_key = staticmethod(add_key)
832 __swig_getmethods__[
"add_key"] =
lambda x: add_key
833 def get_key_exists(*args):
834 """get_key_exists(std::string sc) -> bool"""
835 return _IMP_kernel.IntKey_get_key_exists(*args)
837 if _newclass:get_key_exists = staticmethod(get_key_exists)
838 __swig_getmethods__[
"get_key_exists"] =
lambda x: get_key_exists
839 def get_string(self):
840 """get_string(IntKey self) -> std::string const"""
841 return _IMP_kernel.IntKey_get_string(self)
843 def __eq__(self, *args):
844 """__eq__(IntKey self, IntKey o) -> bool"""
845 return _IMP_kernel.IntKey___eq__(self, *args)
847 def __ne__(self, *args):
848 """__ne__(IntKey self, IntKey o) -> bool"""
849 return _IMP_kernel.IntKey___ne__(self, *args)
851 def __lt__(self, *args):
852 """__lt__(IntKey self, IntKey o) -> bool"""
853 return _IMP_kernel.IntKey___lt__(self, *args)
855 def __gt__(self, *args):
856 """__gt__(IntKey self, IntKey o) -> bool"""
857 return _IMP_kernel.IntKey___gt__(self, *args)
859 def __ge__(self, *args):
860 """__ge__(IntKey self, IntKey o) -> bool"""
861 return _IMP_kernel.IntKey___ge__(self, *args)
863 def __le__(self, *args):
864 """__le__(IntKey self, IntKey o) -> bool"""
865 return _IMP_kernel.IntKey___le__(self, *args)
868 """__hash__(IntKey self) -> std::size_t"""
869 return _IMP_kernel.IntKey___hash__(self)
871 def show(self, *args):
873 show(IntKey self, _ostream out=std::cout)
876 return _IMP_kernel.IntKey_show(self, *args)
878 def add_alias(*args):
879 """add_alias(IntKey old_key, std::string new_name) -> IntKey"""
880 return _IMP_kernel.IntKey_add_alias(*args)
882 if _newclass:add_alias = staticmethod(add_alias)
883 __swig_getmethods__[
"add_alias"] =
lambda x: add_alias
885 """get_index(IntKey self) -> unsigned int"""
886 return _IMP_kernel.IntKey_get_index(self)
889 """show_all(_ostream out)"""
890 return _IMP_kernel.IntKey_show_all(*args)
892 if _newclass:show_all = staticmethod(show_all)
893 __swig_getmethods__[
"show_all"] =
lambda x: show_all
894 def get_all_strings():
895 """get_all_strings() -> IMP::base::Vector< std::string >"""
896 return _IMP_kernel.IntKey_get_all_strings()
898 if _newclass:get_all_strings = staticmethod(get_all_strings)
899 __swig_getmethods__[
"get_all_strings"] =
lambda x: get_all_strings
900 def get_number_unique():
901 """get_number_unique() -> unsigned int"""
902 return _IMP_kernel.IntKey_get_number_unique()
904 if _newclass:get_number_unique = staticmethod(get_number_unique)
905 __swig_getmethods__[
"get_number_unique"] =
lambda x: get_number_unique
907 """__str__(IntKey self) -> std::string"""
908 return _IMP_kernel.IntKey___str__(self)
911 """__repr__(IntKey self) -> std::string"""
912 return _IMP_kernel.IntKey___repr__(self)
914 __swig_destroy__ = _IMP_kernel.delete_IntKey
915 __del__ =
lambda self :
None;
916 IntKey_swigregister = _IMP_kernel.IntKey_swigregister
917 IntKey_swigregister(IntKey)
919 def IntKey_add_key(*args):
920 """IntKey_add_key(std::string sc) -> unsigned int"""
921 return _IMP_kernel.IntKey_add_key(*args)
923 def IntKey_get_key_exists(*args):
924 """IntKey_get_key_exists(std::string sc) -> bool"""
925 return _IMP_kernel.IntKey_get_key_exists(*args)
927 def IntKey_add_alias(*args):
928 """IntKey_add_alias(IntKey old_key, std::string new_name) -> IntKey"""
929 return _IMP_kernel.IntKey_add_alias(*args)
931 def IntKey_show_all(*args):
932 """IntKey_show_all(_ostream out)"""
933 return _IMP_kernel.IntKey_show_all(*args)
935 def IntKey_get_all_strings():
936 """IntKey_get_all_strings() -> IMP::base::Vector< std::string >"""
937 return _IMP_kernel.IntKey_get_all_strings()
939 def IntKey_get_number_unique():
940 """IntKey_get_number_unique() -> unsigned int"""
941 return _IMP_kernel.IntKey_get_number_unique()
944 """Proxy of C++ IMP::kernel::Key<(2,true)> class"""
945 __swig_setmethods__ = {}
946 for _s
in [IMP.base._Value]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
947 __setattr__ =
lambda self, name, value: _swig_setattr(self, StringKey, name, value)
948 __swig_getmethods__ = {}
949 for _s
in [IMP.base._Value]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
950 __getattr__ =
lambda self, name: _swig_getattr(self, StringKey, name)
951 def __init__(self, *args):
953 __init__(IMP::kernel::Key<(2,true)> self) -> StringKey
954 __init__(IMP::kernel::Key<(2,true)> self, std::string c) -> StringKey
955 __init__(IMP::kernel::Key<(2,true)> self, unsigned int i) -> StringKey
957 this = _IMP_kernel.new_StringKey(*args)
958 try: self.this.append(this)
959 except: self.this = this
961 """add_key(std::string sc) -> unsigned int"""
962 return _IMP_kernel.StringKey_add_key(*args)
964 if _newclass:add_key = staticmethod(add_key)
965 __swig_getmethods__[
"add_key"] =
lambda x: add_key
966 def get_key_exists(*args):
967 """get_key_exists(std::string sc) -> bool"""
968 return _IMP_kernel.StringKey_get_key_exists(*args)
970 if _newclass:get_key_exists = staticmethod(get_key_exists)
971 __swig_getmethods__[
"get_key_exists"] =
lambda x: get_key_exists
972 def get_string(self):
973 """get_string(StringKey self) -> std::string const"""
974 return _IMP_kernel.StringKey_get_string(self)
976 def __eq__(self, *args):
977 """__eq__(StringKey self, StringKey o) -> bool"""
978 return _IMP_kernel.StringKey___eq__(self, *args)
980 def __ne__(self, *args):
981 """__ne__(StringKey self, StringKey o) -> bool"""
982 return _IMP_kernel.StringKey___ne__(self, *args)
984 def __lt__(self, *args):
985 """__lt__(StringKey self, StringKey o) -> bool"""
986 return _IMP_kernel.StringKey___lt__(self, *args)
988 def __gt__(self, *args):
989 """__gt__(StringKey self, StringKey o) -> bool"""
990 return _IMP_kernel.StringKey___gt__(self, *args)
992 def __ge__(self, *args):
993 """__ge__(StringKey self, StringKey o) -> bool"""
994 return _IMP_kernel.StringKey___ge__(self, *args)
996 def __le__(self, *args):
997 """__le__(StringKey self, StringKey o) -> bool"""
998 return _IMP_kernel.StringKey___le__(self, *args)
1001 """__hash__(StringKey self) -> std::size_t"""
1002 return _IMP_kernel.StringKey___hash__(self)
1004 def show(self, *args):
1006 show(StringKey self, _ostream out=std::cout)
1007 show(StringKey self)
1009 return _IMP_kernel.StringKey_show(self, *args)
1011 def add_alias(*args):
1012 """add_alias(StringKey old_key, std::string new_name) -> StringKey"""
1013 return _IMP_kernel.StringKey_add_alias(*args)
1015 if _newclass:add_alias = staticmethod(add_alias)
1016 __swig_getmethods__[
"add_alias"] =
lambda x: add_alias
1018 """get_index(StringKey self) -> unsigned int"""
1019 return _IMP_kernel.StringKey_get_index(self)
1021 def show_all(*args):
1022 """show_all(_ostream out)"""
1023 return _IMP_kernel.StringKey_show_all(*args)
1025 if _newclass:show_all = staticmethod(show_all)
1026 __swig_getmethods__[
"show_all"] =
lambda x: show_all
1027 def get_all_strings():
1028 """get_all_strings() -> IMP::base::Vector< std::string >"""
1029 return _IMP_kernel.StringKey_get_all_strings()
1031 if _newclass:get_all_strings = staticmethod(get_all_strings)
1032 __swig_getmethods__[
"get_all_strings"] =
lambda x: get_all_strings
1033 def get_number_unique():
1034 """get_number_unique() -> unsigned int"""
1035 return _IMP_kernel.StringKey_get_number_unique()
1037 if _newclass:get_number_unique = staticmethod(get_number_unique)
1038 __swig_getmethods__[
"get_number_unique"] =
lambda x: get_number_unique
1040 """__str__(StringKey self) -> std::string"""
1041 return _IMP_kernel.StringKey___str__(self)
1044 """__repr__(StringKey self) -> std::string"""
1045 return _IMP_kernel.StringKey___repr__(self)
1047 __swig_destroy__ = _IMP_kernel.delete_StringKey
1048 __del__ =
lambda self :
None;
1049 StringKey_swigregister = _IMP_kernel.StringKey_swigregister
1050 StringKey_swigregister(StringKey)
1052 def StringKey_add_key(*args):
1053 """StringKey_add_key(std::string sc) -> unsigned int"""
1054 return _IMP_kernel.StringKey_add_key(*args)
1056 def StringKey_get_key_exists(*args):
1057 """StringKey_get_key_exists(std::string sc) -> bool"""
1058 return _IMP_kernel.StringKey_get_key_exists(*args)
1060 def StringKey_add_alias(*args):
1061 """StringKey_add_alias(StringKey old_key, std::string new_name) -> StringKey"""
1062 return _IMP_kernel.StringKey_add_alias(*args)
1064 def StringKey_show_all(*args):
1065 """StringKey_show_all(_ostream out)"""
1066 return _IMP_kernel.StringKey_show_all(*args)
1068 def StringKey_get_all_strings():
1069 """StringKey_get_all_strings() -> IMP::base::Vector< std::string >"""
1070 return _IMP_kernel.StringKey_get_all_strings()
1072 def StringKey_get_number_unique():
1073 """StringKey_get_number_unique() -> unsigned int"""
1074 return _IMP_kernel.StringKey_get_number_unique()
1077 """Proxy of C++ IMP::kernel::Key<(3,true)> class"""
1078 __swig_setmethods__ = {}
1079 for _s
in [IMP.base._Value]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
1080 __setattr__ =
lambda self, name, value: _swig_setattr(self, ParticleIndexKey, name, value)
1081 __swig_getmethods__ = {}
1082 for _s
in [IMP.base._Value]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
1083 __getattr__ =
lambda self, name: _swig_getattr(self, ParticleIndexKey, name)
1084 def __init__(self, *args):
1086 __init__(IMP::kernel::Key<(3,true)> self) -> ParticleIndexKey
1087 __init__(IMP::kernel::Key<(3,true)> self, std::string c) -> ParticleIndexKey
1088 __init__(IMP::kernel::Key<(3,true)> self, unsigned int i) -> ParticleIndexKey
1090 this = _IMP_kernel.new_ParticleIndexKey(*args)
1091 try: self.this.append(this)
1092 except: self.this = this
1094 """add_key(std::string sc) -> unsigned int"""
1095 return _IMP_kernel.ParticleIndexKey_add_key(*args)
1097 if _newclass:add_key = staticmethod(add_key)
1098 __swig_getmethods__[
"add_key"] =
lambda x: add_key
1099 def get_key_exists(*args):
1100 """get_key_exists(std::string sc) -> bool"""
1101 return _IMP_kernel.ParticleIndexKey_get_key_exists(*args)
1103 if _newclass:get_key_exists = staticmethod(get_key_exists)
1104 __swig_getmethods__[
"get_key_exists"] =
lambda x: get_key_exists
1105 def get_string(self):
1106 """get_string(ParticleIndexKey self) -> std::string const"""
1107 return _IMP_kernel.ParticleIndexKey_get_string(self)
1109 def __eq__(self, *args):
1110 """__eq__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
1111 return _IMP_kernel.ParticleIndexKey___eq__(self, *args)
1113 def __ne__(self, *args):
1114 """__ne__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
1115 return _IMP_kernel.ParticleIndexKey___ne__(self, *args)
1117 def __lt__(self, *args):
1118 """__lt__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
1119 return _IMP_kernel.ParticleIndexKey___lt__(self, *args)
1121 def __gt__(self, *args):
1122 """__gt__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
1123 return _IMP_kernel.ParticleIndexKey___gt__(self, *args)
1125 def __ge__(self, *args):
1126 """__ge__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
1127 return _IMP_kernel.ParticleIndexKey___ge__(self, *args)
1129 def __le__(self, *args):
1130 """__le__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
1131 return _IMP_kernel.ParticleIndexKey___le__(self, *args)
1134 """__hash__(ParticleIndexKey self) -> std::size_t"""
1135 return _IMP_kernel.ParticleIndexKey___hash__(self)
1137 def show(self, *args):
1139 show(ParticleIndexKey self, _ostream out=std::cout)
1140 show(ParticleIndexKey self)
1142 return _IMP_kernel.ParticleIndexKey_show(self, *args)
1144 def add_alias(*args):
1145 """add_alias(ParticleIndexKey old_key, std::string new_name) -> ParticleIndexKey"""
1146 return _IMP_kernel.ParticleIndexKey_add_alias(*args)
1148 if _newclass:add_alias = staticmethod(add_alias)
1149 __swig_getmethods__[
"add_alias"] =
lambda x: add_alias
1151 """get_index(ParticleIndexKey self) -> unsigned int"""
1152 return _IMP_kernel.ParticleIndexKey_get_index(self)
1154 def show_all(*args):
1155 """show_all(_ostream out)"""
1156 return _IMP_kernel.ParticleIndexKey_show_all(*args)
1158 if _newclass:show_all = staticmethod(show_all)
1159 __swig_getmethods__[
"show_all"] =
lambda x: show_all
1160 def get_all_strings():
1161 """get_all_strings() -> IMP::base::Vector< std::string >"""
1162 return _IMP_kernel.ParticleIndexKey_get_all_strings()
1164 if _newclass:get_all_strings = staticmethod(get_all_strings)
1165 __swig_getmethods__[
"get_all_strings"] =
lambda x: get_all_strings
1166 def get_number_unique():
1167 """get_number_unique() -> unsigned int"""
1168 return _IMP_kernel.ParticleIndexKey_get_number_unique()
1170 if _newclass:get_number_unique = staticmethod(get_number_unique)
1171 __swig_getmethods__[
"get_number_unique"] =
lambda x: get_number_unique
1173 """__str__(ParticleIndexKey self) -> std::string"""
1174 return _IMP_kernel.ParticleIndexKey___str__(self)
1177 """__repr__(ParticleIndexKey self) -> std::string"""
1178 return _IMP_kernel.ParticleIndexKey___repr__(self)
1180 __swig_destroy__ = _IMP_kernel.delete_ParticleIndexKey
1181 __del__ =
lambda self :
None;
1182 ParticleIndexKey_swigregister = _IMP_kernel.ParticleIndexKey_swigregister
1183 ParticleIndexKey_swigregister(ParticleIndexKey)
1185 def ParticleIndexKey_add_key(*args):
1186 """ParticleIndexKey_add_key(std::string sc) -> unsigned int"""
1187 return _IMP_kernel.ParticleIndexKey_add_key(*args)
1189 def ParticleIndexKey_get_key_exists(*args):
1190 """ParticleIndexKey_get_key_exists(std::string sc) -> bool"""
1191 return _IMP_kernel.ParticleIndexKey_get_key_exists(*args)
1193 def ParticleIndexKey_add_alias(*args):
1194 """ParticleIndexKey_add_alias(ParticleIndexKey old_key, std::string new_name) -> ParticleIndexKey"""
1195 return _IMP_kernel.ParticleIndexKey_add_alias(*args)
1197 def ParticleIndexKey_show_all(*args):
1198 """ParticleIndexKey_show_all(_ostream out)"""
1199 return _IMP_kernel.ParticleIndexKey_show_all(*args)
1201 def ParticleIndexKey_get_all_strings():
1202 """ParticleIndexKey_get_all_strings() -> IMP::base::Vector< std::string >"""
1203 return _IMP_kernel.ParticleIndexKey_get_all_strings()
1205 def ParticleIndexKey_get_number_unique():
1206 """ParticleIndexKey_get_number_unique() -> unsigned int"""
1207 return _IMP_kernel.ParticleIndexKey_get_number_unique()
1210 """Proxy of C++ IMP::kernel::Key<(4,true)> class"""
1211 __swig_setmethods__ = {}
1212 for _s
in [IMP.base._Value]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
1213 __setattr__ =
lambda self, name, value: _swig_setattr(self, ObjectKey, name, value)
1214 __swig_getmethods__ = {}
1215 for _s
in [IMP.base._Value]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
1216 __getattr__ =
lambda self, name: _swig_getattr(self, ObjectKey, name)
1217 def __init__(self, *args):
1219 __init__(IMP::kernel::Key<(4,true)> self) -> ObjectKey
1220 __init__(IMP::kernel::Key<(4,true)> self, std::string c) -> ObjectKey
1221 __init__(IMP::kernel::Key<(4,true)> self, unsigned int i) -> ObjectKey
1223 this = _IMP_kernel.new_ObjectKey(*args)
1224 try: self.this.append(this)
1225 except: self.this = this
1227 """add_key(std::string sc) -> unsigned int"""
1228 return _IMP_kernel.ObjectKey_add_key(*args)
1230 if _newclass:add_key = staticmethod(add_key)
1231 __swig_getmethods__[
"add_key"] =
lambda x: add_key
1232 def get_key_exists(*args):
1233 """get_key_exists(std::string sc) -> bool"""
1234 return _IMP_kernel.ObjectKey_get_key_exists(*args)
1236 if _newclass:get_key_exists = staticmethod(get_key_exists)
1237 __swig_getmethods__[
"get_key_exists"] =
lambda x: get_key_exists
1238 def get_string(self):
1239 """get_string(ObjectKey self) -> std::string const"""
1240 return _IMP_kernel.ObjectKey_get_string(self)
1242 def __eq__(self, *args):
1243 """__eq__(ObjectKey self, ObjectKey o) -> bool"""
1244 return _IMP_kernel.ObjectKey___eq__(self, *args)
1246 def __ne__(self, *args):
1247 """__ne__(ObjectKey self, ObjectKey o) -> bool"""
1248 return _IMP_kernel.ObjectKey___ne__(self, *args)
1250 def __lt__(self, *args):
1251 """__lt__(ObjectKey self, ObjectKey o) -> bool"""
1252 return _IMP_kernel.ObjectKey___lt__(self, *args)
1254 def __gt__(self, *args):
1255 """__gt__(ObjectKey self, ObjectKey o) -> bool"""
1256 return _IMP_kernel.ObjectKey___gt__(self, *args)
1258 def __ge__(self, *args):
1259 """__ge__(ObjectKey self, ObjectKey o) -> bool"""
1260 return _IMP_kernel.ObjectKey___ge__(self, *args)
1262 def __le__(self, *args):
1263 """__le__(ObjectKey self, ObjectKey o) -> bool"""
1264 return _IMP_kernel.ObjectKey___le__(self, *args)
1267 """__hash__(ObjectKey self) -> std::size_t"""
1268 return _IMP_kernel.ObjectKey___hash__(self)
1270 def show(self, *args):
1272 show(ObjectKey self, _ostream out=std::cout)
1273 show(ObjectKey self)
1275 return _IMP_kernel.ObjectKey_show(self, *args)
1277 def add_alias(*args):
1278 """add_alias(ObjectKey old_key, std::string new_name) -> ObjectKey"""
1279 return _IMP_kernel.ObjectKey_add_alias(*args)
1281 if _newclass:add_alias = staticmethod(add_alias)
1282 __swig_getmethods__[
"add_alias"] =
lambda x: add_alias
1284 """get_index(ObjectKey self) -> unsigned int"""
1285 return _IMP_kernel.ObjectKey_get_index(self)
1287 def show_all(*args):
1288 """show_all(_ostream out)"""
1289 return _IMP_kernel.ObjectKey_show_all(*args)
1291 if _newclass:show_all = staticmethod(show_all)
1292 __swig_getmethods__[
"show_all"] =
lambda x: show_all
1293 def get_all_strings():
1294 """get_all_strings() -> IMP::base::Vector< std::string >"""
1295 return _IMP_kernel.ObjectKey_get_all_strings()
1297 if _newclass:get_all_strings = staticmethod(get_all_strings)
1298 __swig_getmethods__[
"get_all_strings"] =
lambda x: get_all_strings
1299 def get_number_unique():
1300 """get_number_unique() -> unsigned int"""
1301 return _IMP_kernel.ObjectKey_get_number_unique()
1303 if _newclass:get_number_unique = staticmethod(get_number_unique)
1304 __swig_getmethods__[
"get_number_unique"] =
lambda x: get_number_unique
1306 """__str__(ObjectKey self) -> std::string"""
1307 return _IMP_kernel.ObjectKey___str__(self)
1310 """__repr__(ObjectKey self) -> std::string"""
1311 return _IMP_kernel.ObjectKey___repr__(self)
1313 __swig_destroy__ = _IMP_kernel.delete_ObjectKey
1314 __del__ =
lambda self :
None;
1315 ObjectKey_swigregister = _IMP_kernel.ObjectKey_swigregister
1316 ObjectKey_swigregister(ObjectKey)
1318 def ObjectKey_add_key(*args):
1319 """ObjectKey_add_key(std::string sc) -> unsigned int"""
1320 return _IMP_kernel.ObjectKey_add_key(*args)
1322 def ObjectKey_get_key_exists(*args):
1323 """ObjectKey_get_key_exists(std::string sc) -> bool"""
1324 return _IMP_kernel.ObjectKey_get_key_exists(*args)
1326 def ObjectKey_add_alias(*args):
1327 """ObjectKey_add_alias(ObjectKey old_key, std::string new_name) -> ObjectKey"""
1328 return _IMP_kernel.ObjectKey_add_alias(*args)
1330 def ObjectKey_show_all(*args):
1331 """ObjectKey_show_all(_ostream out)"""
1332 return _IMP_kernel.ObjectKey_show_all(*args)
1334 def ObjectKey_get_all_strings():
1335 """ObjectKey_get_all_strings() -> IMP::base::Vector< std::string >"""
1336 return _IMP_kernel.ObjectKey_get_all_strings()
1338 def ObjectKey_get_number_unique():
1339 """ObjectKey_get_number_unique() -> unsigned int"""
1340 return _IMP_kernel.ObjectKey_get_number_unique()
1343 """Proxy of C++ IMP::kernel::Key<(6,true)> class"""
1344 __swig_setmethods__ = {}
1345 for _s
in [IMP.base._Value]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
1346 __setattr__ =
lambda self, name, value: _swig_setattr(self, ParticleIndexesKey, name, value)
1347 __swig_getmethods__ = {}
1348 for _s
in [IMP.base._Value]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
1349 __getattr__ =
lambda self, name: _swig_getattr(self, ParticleIndexesKey, name)
1350 def __init__(self, *args):
1352 __init__(IMP::kernel::Key<(6,true)> self) -> ParticleIndexesKey
1353 __init__(IMP::kernel::Key<(6,true)> self, std::string c) -> ParticleIndexesKey
1354 __init__(IMP::kernel::Key<(6,true)> self, unsigned int i) -> ParticleIndexesKey
1356 this = _IMP_kernel.new_ParticleIndexesKey(*args)
1357 try: self.this.append(this)
1358 except: self.this = this
1360 """add_key(std::string sc) -> unsigned int"""
1361 return _IMP_kernel.ParticleIndexesKey_add_key(*args)
1363 if _newclass:add_key = staticmethod(add_key)
1364 __swig_getmethods__[
"add_key"] =
lambda x: add_key
1365 def get_key_exists(*args):
1366 """get_key_exists(std::string sc) -> bool"""
1367 return _IMP_kernel.ParticleIndexesKey_get_key_exists(*args)
1369 if _newclass:get_key_exists = staticmethod(get_key_exists)
1370 __swig_getmethods__[
"get_key_exists"] =
lambda x: get_key_exists
1371 def get_string(self):
1372 """get_string(ParticleIndexesKey self) -> std::string const"""
1373 return _IMP_kernel.ParticleIndexesKey_get_string(self)
1375 def __eq__(self, *args):
1376 """__eq__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
1377 return _IMP_kernel.ParticleIndexesKey___eq__(self, *args)
1379 def __ne__(self, *args):
1380 """__ne__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
1381 return _IMP_kernel.ParticleIndexesKey___ne__(self, *args)
1383 def __lt__(self, *args):
1384 """__lt__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
1385 return _IMP_kernel.ParticleIndexesKey___lt__(self, *args)
1387 def __gt__(self, *args):
1388 """__gt__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
1389 return _IMP_kernel.ParticleIndexesKey___gt__(self, *args)
1391 def __ge__(self, *args):
1392 """__ge__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
1393 return _IMP_kernel.ParticleIndexesKey___ge__(self, *args)
1395 def __le__(self, *args):
1396 """__le__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
1397 return _IMP_kernel.ParticleIndexesKey___le__(self, *args)
1400 """__hash__(ParticleIndexesKey self) -> std::size_t"""
1401 return _IMP_kernel.ParticleIndexesKey___hash__(self)
1403 def show(self, *args):
1405 show(ParticleIndexesKey self, _ostream out=std::cout)
1406 show(ParticleIndexesKey self)
1408 return _IMP_kernel.ParticleIndexesKey_show(self, *args)
1410 def add_alias(*args):
1411 """add_alias(ParticleIndexesKey old_key, std::string new_name) -> ParticleIndexesKey"""
1412 return _IMP_kernel.ParticleIndexesKey_add_alias(*args)
1414 if _newclass:add_alias = staticmethod(add_alias)
1415 __swig_getmethods__[
"add_alias"] =
lambda x: add_alias
1417 """get_index(ParticleIndexesKey self) -> unsigned int"""
1418 return _IMP_kernel.ParticleIndexesKey_get_index(self)
1420 def show_all(*args):
1421 """show_all(_ostream out)"""
1422 return _IMP_kernel.ParticleIndexesKey_show_all(*args)
1424 if _newclass:show_all = staticmethod(show_all)
1425 __swig_getmethods__[
"show_all"] =
lambda x: show_all
1426 def get_all_strings():
1427 """get_all_strings() -> IMP::base::Vector< std::string >"""
1428 return _IMP_kernel.ParticleIndexesKey_get_all_strings()
1430 if _newclass:get_all_strings = staticmethod(get_all_strings)
1431 __swig_getmethods__[
"get_all_strings"] =
lambda x: get_all_strings
1432 def get_number_unique():
1433 """get_number_unique() -> unsigned int"""
1434 return _IMP_kernel.ParticleIndexesKey_get_number_unique()
1436 if _newclass:get_number_unique = staticmethod(get_number_unique)
1437 __swig_getmethods__[
"get_number_unique"] =
lambda x: get_number_unique
1439 """__str__(ParticleIndexesKey self) -> std::string"""
1440 return _IMP_kernel.ParticleIndexesKey___str__(self)
1443 """__repr__(ParticleIndexesKey self) -> std::string"""
1444 return _IMP_kernel.ParticleIndexesKey___repr__(self)
1446 __swig_destroy__ = _IMP_kernel.delete_ParticleIndexesKey
1447 __del__ =
lambda self :
None;
1448 ParticleIndexesKey_swigregister = _IMP_kernel.ParticleIndexesKey_swigregister
1449 ParticleIndexesKey_swigregister(ParticleIndexesKey)
1451 def ParticleIndexesKey_add_key(*args):
1452 """ParticleIndexesKey_add_key(std::string sc) -> unsigned int"""
1453 return _IMP_kernel.ParticleIndexesKey_add_key(*args)
1455 def ParticleIndexesKey_get_key_exists(*args):
1456 """ParticleIndexesKey_get_key_exists(std::string sc) -> bool"""
1457 return _IMP_kernel.ParticleIndexesKey_get_key_exists(*args)
1459 def ParticleIndexesKey_add_alias(*args):
1460 """ParticleIndexesKey_add_alias(ParticleIndexesKey old_key, std::string new_name) -> ParticleIndexesKey"""
1461 return _IMP_kernel.ParticleIndexesKey_add_alias(*args)
1463 def ParticleIndexesKey_show_all(*args):
1464 """ParticleIndexesKey_show_all(_ostream out)"""
1465 return _IMP_kernel.ParticleIndexesKey_show_all(*args)
1467 def ParticleIndexesKey_get_all_strings():
1468 """ParticleIndexesKey_get_all_strings() -> IMP::base::Vector< std::string >"""
1469 return _IMP_kernel.ParticleIndexesKey_get_all_strings()
1471 def ParticleIndexesKey_get_number_unique():
1472 """ParticleIndexesKey_get_number_unique() -> unsigned int"""
1473 return _IMP_kernel.ParticleIndexesKey_get_number_unique()
1476 """Proxy of C++ IMP::base::Index<(IMP::ParticleIndexTag)> class"""
1477 __swig_setmethods__ = {}
1478 for _s
in [IMP.base._Value]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
1479 __setattr__ =
lambda self, name, value: _swig_setattr(self, ParticleIndex, name, value)
1480 __swig_getmethods__ = {}
1481 for _s
in [IMP.base._Value]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
1482 __getattr__ =
lambda self, name: _swig_getattr(self, ParticleIndex, name)
1483 def __init__(self, *args):
1485 __init__(IMP::base::Index<(IMP::ParticleIndexTag)> self, int i) -> ParticleIndex
1486 __init__(IMP::base::Index<(IMP::ParticleIndexTag)> self) -> ParticleIndex
1488 this = _IMP_kernel.new_ParticleIndex(*args)
1489 try: self.this.append(this)
1490 except: self.this = this
1492 """get_index(ParticleIndex self) -> int"""
1493 return _IMP_kernel.ParticleIndex_get_index(self)
1495 def __eq__(self, *args):
1496 """__eq__(ParticleIndex self, ParticleIndex o) -> bool"""
1497 return _IMP_kernel.ParticleIndex___eq__(self, *args)
1499 def __ne__(self, *args):
1500 """__ne__(ParticleIndex self, ParticleIndex o) -> bool"""
1501 return _IMP_kernel.ParticleIndex___ne__(self, *args)
1503 def __lt__(self, *args):
1504 """__lt__(ParticleIndex self, ParticleIndex o) -> bool"""
1505 return _IMP_kernel.ParticleIndex___lt__(self, *args)
1507 def __gt__(self, *args):
1508 """__gt__(ParticleIndex self, ParticleIndex o) -> bool"""
1509 return _IMP_kernel.ParticleIndex___gt__(self, *args)
1511 def __ge__(self, *args):
1512 """__ge__(ParticleIndex self, ParticleIndex o) -> bool"""
1513 return _IMP_kernel.ParticleIndex___ge__(self, *args)
1515 def __le__(self, *args):
1516 """__le__(ParticleIndex self, ParticleIndex o) -> bool"""
1517 return _IMP_kernel.ParticleIndex___le__(self, *args)
1519 def show(self, *args):
1521 show(ParticleIndex self, _ostream out=std::cout)
1522 show(ParticleIndex self)
1524 return _IMP_kernel.ParticleIndex_show(self, *args)
1527 """__hash__(ParticleIndex self) -> std::size_t"""
1528 return _IMP_kernel.ParticleIndex___hash__(self)
1531 """__str__(ParticleIndex self) -> std::string"""
1532 return _IMP_kernel.ParticleIndex___str__(self)
1535 """__repr__(ParticleIndex self) -> std::string"""
1536 return _IMP_kernel.ParticleIndex___repr__(self)
1538 __swig_destroy__ = _IMP_kernel.delete_ParticleIndex
1539 __del__ =
lambda self :
None;
1540 ParticleIndex_swigregister = _IMP_kernel.ParticleIndex_swigregister
1541 ParticleIndex_swigregister(ParticleIndex)
1552 """get_particles(Model * m, ParticleIndexes const & ps) -> ParticlesTemp"""
1553 return _IMP_kernel.get_particles(*args)
1557 get_indexes(ParticlesTemp const & ps) -> ParticleIndexes
1558 get_indexes(ParticlePairsTemp const & ps) -> ParticleIndexPairs
1560 return _IMP_kernel.get_indexes(*args)
1562 """Proxy of C++ IMP::kernel::FloatIndex class"""
1563 __swig_setmethods__ = {}
1564 for _s
in [IMP.base._Value]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
1565 __setattr__ =
lambda self, name, value: _swig_setattr(self, FloatIndex, name, value)
1566 __swig_getmethods__ = {}
1567 for _s
in [IMP.base._Value]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
1568 __getattr__ =
lambda self, name: _swig_getattr(self, FloatIndex, name)
1569 def __init__(self, *args):
1571 __init__(IMP::kernel::FloatIndex self, ParticleIndex i0=ParticleIndex(), FloatKey i1=FloatKey()) -> FloatIndex
1572 __init__(IMP::kernel::FloatIndex self, ParticleIndex i0=ParticleIndex()) -> FloatIndex
1573 __init__(IMP::kernel::FloatIndex self) -> FloatIndex
1575 this = _IMP_kernel.new_FloatIndex(*args)
1576 try: self.this.append(this)
1577 except: self.this = this
1579 """__hash__(FloatIndex self) -> std::size_t"""
1580 return _IMP_kernel.FloatIndex___hash__(self)
1582 def show(self, *args):
1584 show(FloatIndex self, _ostream out=std::cout)
1585 show(FloatIndex self)
1587 return _IMP_kernel.FloatIndex_show(self, *args)
1589 def __eq__(self, *args):
1590 """__eq__(FloatIndex self, FloatIndex o) -> bool"""
1591 return _IMP_kernel.FloatIndex___eq__(self, *args)
1593 def __ne__(self, *args):
1594 """__ne__(FloatIndex self, FloatIndex o) -> bool"""
1595 return _IMP_kernel.FloatIndex___ne__(self, *args)
1597 def __lt__(self, *args):
1598 """__lt__(FloatIndex self, FloatIndex o) -> bool"""
1599 return _IMP_kernel.FloatIndex___lt__(self, *args)
1601 def __gt__(self, *args):
1602 """__gt__(FloatIndex self, FloatIndex o) -> bool"""
1603 return _IMP_kernel.FloatIndex___gt__(self, *args)
1605 def __ge__(self, *args):
1606 """__ge__(FloatIndex self, FloatIndex o) -> bool"""
1607 return _IMP_kernel.FloatIndex___ge__(self, *args)
1609 def __le__(self, *args):
1610 """__le__(FloatIndex self, FloatIndex o) -> bool"""
1611 return _IMP_kernel.FloatIndex___le__(self, *args)
1613 def get_particle(self):
1614 """get_particle(FloatIndex self) -> ParticleIndex const &"""
1615 return _IMP_kernel.FloatIndex_get_particle(self)
1617 def set_particle(self, *args):
1618 """set_particle(FloatIndex self, ParticleIndex const & v)"""
1619 return _IMP_kernel.FloatIndex_set_particle(self, *args)
1622 """get_key(FloatIndex self) -> FloatKey const &"""
1623 return _IMP_kernel.FloatIndex_get_key(self)
1625 def set_key(self, *args):
1626 """set_key(FloatIndex self, FloatKey const & v)"""
1627 return _IMP_kernel.FloatIndex_set_key(self, *args)
1630 """__str__(FloatIndex self) -> std::string"""
1631 return _IMP_kernel.FloatIndex___str__(self)
1634 """__repr__(FloatIndex self) -> std::string"""
1635 return _IMP_kernel.FloatIndex___repr__(self)
1637 __swig_destroy__ = _IMP_kernel.delete_FloatIndex
1638 __del__ =
lambda self :
None;
1639 FloatIndex_swigregister = _IMP_kernel.FloatIndex_swigregister
1640 FloatIndex_swigregister(FloatIndex)
1642 class _ParticleIndexTag(_object):
1643 """Proxy of C++ IMP::kernel::ParticleIndexTag class"""
1644 __swig_setmethods__ = {}
1645 __setattr__ =
lambda self, name, value: _swig_setattr(self, _ParticleIndexTag, name, value)
1646 __swig_getmethods__ = {}
1647 __getattr__ =
lambda self, name: _swig_getattr(self, _ParticleIndexTag, name)
1648 __repr__ = _swig_repr
1650 """__init__(IMP::kernel::ParticleIndexTag self) -> _ParticleIndexTag"""
1651 this = _IMP_kernel.new__ParticleIndexTag()
1652 try: self.this.append(this)
1653 except: self.this = this
1654 __swig_destroy__ = _IMP_kernel.delete__ParticleIndexTag
1655 __del__ =
lambda self :
None;
1656 _ParticleIndexTag_swigregister = _IMP_kernel._ParticleIndexTag_swigregister
1657 _ParticleIndexTag_swigregister(_ParticleIndexTag)
1660 """Proxy of C++ IMP::kernel::ModelObject class"""
1661 __swig_setmethods__ = {}
1662 for _s
in [
IMP.base.Object]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
1663 __setattr__ =
lambda self, name, value: _swig_setattr(self, ModelObject, name, value)
1664 __swig_getmethods__ = {}
1665 for _s
in [
IMP.base.Object]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
1666 __getattr__ =
lambda self, name: _swig_getattr(self, ModelObject, name)
1667 def __init__(self, *args):
1669 __init__(IMP::kernel::ModelObject self, Model m, std::string name) -> ModelObject
1670 __init__(IMP::kernel::ModelObject self, std::string name) -> ModelObject
1672 if self.__class__ == ModelObject:
1676 this = _IMP_kernel.new_ModelObject(_self, *args)
1677 try: self.this.append(this)
1678 except: self.this = this
1679 if self.__class__ != ModelObject:
1681 IMP.base._director_objects.register(self)
1685 def set_model(self, *args):
1686 """set_model(ModelObject self, Model m)"""
1687 return _IMP_kernel.ModelObject_set_model(self, *args)
1689 def get_is_part_of_model(self):
1690 """get_is_part_of_model(ModelObject self) -> bool"""
1691 return _IMP_kernel.ModelObject_get_is_part_of_model(self)
1693 def get_model(self):
1694 """get_model(ModelObject self) -> Model"""
1695 return _IMP_kernel.ModelObject_get_model(self)
1697 def get_inputs(self):
1698 """get_inputs(ModelObject self) -> IMP::kernel::ModelObjectsTemp"""
1699 return _IMP_kernel.ModelObject_get_inputs(self)
1701 def get_outputs(self):
1702 """get_outputs(ModelObject self) -> IMP::kernel::ModelObjectsTemp"""
1703 return _IMP_kernel.ModelObject_get_outputs(self)
1705 def get_interactions(self):
1706 """get_interactions(ModelObject self) -> IMP::kernel::ModelObjectsTemps"""
1707 return _IMP_kernel.ModelObject_get_interactions(self)
1709 def update_dependencies(self):
1710 """update_dependencies(ModelObject self)"""
1711 return _IMP_kernel.ModelObject_update_dependencies(self)
1713 def do_get_inputs(self):
1714 """do_get_inputs(ModelObject self) -> IMP::kernel::ModelObjectsTemp"""
1715 return _IMP_kernel.ModelObject_do_get_inputs(self)
1717 def do_get_outputs(self):
1718 """do_get_outputs(ModelObject self) -> IMP::kernel::ModelObjectsTemp"""
1719 return _IMP_kernel.ModelObject_do_get_outputs(self)
1721 def do_get_interactions(self):
1722 """do_get_interactions(ModelObject self) -> IMP::kernel::ModelObjectsTemps"""
1723 return _IMP_kernel.ModelObject_do_get_interactions(self)
1725 __swig_destroy__ = _IMP_kernel.delete_ModelObject
1726 __del__ =
lambda self :
None;
1728 """__str__(ModelObject self) -> std::string"""
1729 return _IMP_kernel.ModelObject___str__(self)
1732 """__repr__(ModelObject self) -> std::string"""
1733 return _IMP_kernel.ModelObject___repr__(self)
1736 return _object_cast_to_ModelObject(o)
1737 get_from = staticmethod(get_from)
1739 def get_type_name(self):
1740 return self.__class__.__name__
1741 def do_show(self, out):
1743 def get_version_info(self):
1744 if"IMP::kernel" ==
"IMP":
1745 return VersionInfo(
"python",
"0")
1747 return IMP.VersionInfo(
"python",
"0")
1749 return _object_cast_to_ModelObject(o)
1750 get_from = staticmethod(get_from)
1752 def __disown__(self):
1754 _IMP_kernel.disown_ModelObject(self)
1755 return weakref_proxy(self)
1756 ModelObject_swigregister = _IMP_kernel.ModelObject_swigregister
1757 ModelObject_swigregister(ModelObject)
1758 cvar = _IMP_kernel.cvar
1759 NO_MAX = cvar.NO_MAX
1760 BAD_SCORE = cvar.BAD_SCORE
1764 """get_input_particles(IMP::kernel::ModelObjectsTemp const & mos) -> IMP::kernel::ParticlesTemp"""
1765 return _IMP_kernel.get_input_particles(*args)
1768 """get_input_containers(IMP::kernel::ModelObjectsTemp const & mos) -> IMP::kernel::ContainersTemp"""
1769 return _IMP_kernel.get_input_containers(*args)
1772 """get_output_particles(IMP::kernel::ModelObjectsTemp const & mos) -> IMP::kernel::ParticlesTemp"""
1773 return _IMP_kernel.get_output_particles(*args)
1776 """get_output_containers(IMP::kernel::ModelObjectsTemp const & mos) -> IMP::kernel::ContainersTemp"""
1777 return _IMP_kernel.get_output_containers(*args)
1779 """Proxy of C++ IMP::kernel::DerivativeAccumulator class"""
1780 __swig_setmethods__ = {}
1781 __setattr__ =
lambda self, name, value: _swig_setattr(self, DerivativeAccumulator, name, value)
1782 __swig_getmethods__ = {}
1783 __getattr__ =
lambda self, name: _swig_getattr(self, DerivativeAccumulator, name)
1784 __repr__ = _swig_repr
1785 def __init__(self, *args):
1787 __init__(IMP::kernel::DerivativeAccumulator self, double weight=1.0) -> DerivativeAccumulator
1788 __init__(IMP::kernel::DerivativeAccumulator self) -> DerivativeAccumulator
1789 __init__(IMP::kernel::DerivativeAccumulator self, DerivativeAccumulator copy, double weight=1.0) -> DerivativeAccumulator
1790 __init__(IMP::kernel::DerivativeAccumulator self, DerivativeAccumulator copy) -> DerivativeAccumulator
1792 this = _IMP_kernel.new_DerivativeAccumulator(*args)
1793 try: self.this.append(this)
1794 except: self.this = this
1795 def __call__(self, *args):
1796 """__call__(DerivativeAccumulator self, double const value) -> double"""
1797 return _IMP_kernel.DerivativeAccumulator___call__(self, *args)
1799 def get_weight(self):
1800 """get_weight(DerivativeAccumulator self) -> double"""
1801 return _IMP_kernel.DerivativeAccumulator_get_weight(self)
1803 def show(self, *args):
1805 show(DerivativeAccumulator self, _ostream out=std::cout)
1806 show(DerivativeAccumulator self)
1808 return _IMP_kernel.DerivativeAccumulator_show(self, *args)
1810 __swig_destroy__ = _IMP_kernel.delete_DerivativeAccumulator
1811 __del__ =
lambda self :
None;
1812 DerivativeAccumulator_swigregister = _IMP_kernel.DerivativeAccumulator_swigregister
1813 DerivativeAccumulator_swigregister(DerivativeAccumulator)
1816 """Proxy of C++ IMP::kernel::EvaluationState class"""
1817 __swig_setmethods__ = {}
1818 __setattr__ =
lambda self, name, value: _swig_setattr(self, EvaluationState, name, value)
1819 __swig_getmethods__ = {}
1820 __getattr__ =
lambda self, name: _swig_getattr(self, EvaluationState, name)
1821 __swig_setmethods__[
"score"] = _IMP_kernel.EvaluationState_score_set
1822 __swig_getmethods__[
"score"] = _IMP_kernel.EvaluationState_score_get
1823 if _newclass:score = _swig_property(_IMP_kernel.EvaluationState_score_get, _IMP_kernel.EvaluationState_score_set)
1824 __swig_setmethods__[
"good"] = _IMP_kernel.EvaluationState_good_set
1825 __swig_getmethods__[
"good"] = _IMP_kernel.EvaluationState_good_get
1826 if _newclass:good = _swig_property(_IMP_kernel.EvaluationState_good_get, _IMP_kernel.EvaluationState_good_set)
1827 def __init__(self, *args):
1829 __init__(IMP::kernel::EvaluationState self, double oscore, bool ogood) -> EvaluationState
1830 __init__(IMP::kernel::EvaluationState self) -> EvaluationState
1832 this = _IMP_kernel.new_EvaluationState(*args)
1833 try: self.this.append(this)
1834 except: self.this = this
1835 def show(self, *args):
1837 show(EvaluationState self, _ostream out=std::cout)
1838 show(EvaluationState self)
1840 return _IMP_kernel.EvaluationState_show(self, *args)
1843 """__str__(EvaluationState self) -> std::string"""
1844 return _IMP_kernel.EvaluationState___str__(self)
1847 """__repr__(EvaluationState self) -> std::string"""
1848 return _IMP_kernel.EvaluationState___repr__(self)
1850 __swig_destroy__ = _IMP_kernel.delete_EvaluationState
1851 __del__ =
lambda self :
None;
1852 EvaluationState_swigregister = _IMP_kernel.EvaluationState_swigregister
1853 EvaluationState_swigregister(EvaluationState)
1856 """Proxy of C++ IMP::kernel::ScoreAccumulator class"""
1857 __swig_setmethods__ = {}
1858 for _s
in [IMP.base._Value]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
1859 __setattr__ =
lambda self, name, value: _swig_setattr(self, ScoreAccumulator, name, value)
1860 __swig_getmethods__ = {}
1861 for _s
in [IMP.base._Value]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
1862 __getattr__ =
lambda self, name: _swig_getattr(self, ScoreAccumulator, name)
1863 def __init__(self, *args):
1865 __init__(IMP::kernel::ScoreAccumulator self) -> ScoreAccumulator
1866 __init__(IMP::kernel::ScoreAccumulator self, ScoreAccumulator o, Restraint r) -> ScoreAccumulator
1867 __init__(IMP::kernel::ScoreAccumulator self, ScoreAccumulator o, double weight, double local_max) -> ScoreAccumulator
1869 this = _IMP_kernel.new_ScoreAccumulator(*args)
1870 try: self.this.append(this)
1871 except: self.this = this
1872 def add_score(self, *args):
1873 """add_score(ScoreAccumulator self, double score)"""
1874 return _IMP_kernel.ScoreAccumulator_add_score(self, *args)
1876 def get_abort_evaluation(self):
1877 """get_abort_evaluation(ScoreAccumulator self) -> bool"""
1878 return _IMP_kernel.ScoreAccumulator_get_abort_evaluation(self)
1880 def get_is_evaluate_if_below(self):
1881 """get_is_evaluate_if_below(ScoreAccumulator self) -> bool"""
1882 return _IMP_kernel.ScoreAccumulator_get_is_evaluate_if_below(self)
1884 def get_is_evaluate_if_good(self):
1885 """get_is_evaluate_if_good(ScoreAccumulator self) -> bool"""
1886 return _IMP_kernel.ScoreAccumulator_get_is_evaluate_if_good(self)
1888 def get_maximum(self):
1889 """get_maximum(ScoreAccumulator self) -> double"""
1890 return _IMP_kernel.ScoreAccumulator_get_maximum(self)
1892 def get_derivative_accumulator(self):
1893 """get_derivative_accumulator(ScoreAccumulator self) -> DerivativeAccumulator"""
1894 return _IMP_kernel.ScoreAccumulator_get_derivative_accumulator(self)
1896 def show(self, *args):
1898 show(ScoreAccumulator self, _ostream out=std::cout)
1899 show(ScoreAccumulator self)
1901 return _IMP_kernel.ScoreAccumulator_show(self, *args)
1904 """__str__(ScoreAccumulator self) -> std::string"""
1905 return _IMP_kernel.ScoreAccumulator___str__(self)
1908 """__repr__(ScoreAccumulator self) -> std::string"""
1909 return _IMP_kernel.ScoreAccumulator___repr__(self)
1911 __swig_destroy__ = _IMP_kernel.delete_ScoreAccumulator
1912 __del__ =
lambda self :
None;
1913 ScoreAccumulator_swigregister = _IMP_kernel.ScoreAccumulator_swigregister
1914 ScoreAccumulator_swigregister(ScoreAccumulator)
1917 """Proxy of C++ IMP::kernel::ScoreState class"""
1918 __swig_setmethods__ = {}
1919 for _s
in [ModelObject]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
1920 __setattr__ =
lambda self, name, value: _swig_setattr(self, ScoreState, name, value)
1921 __swig_getmethods__ = {}
1922 for _s
in [ModelObject]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
1923 __getattr__ =
lambda self, name: _swig_getattr(self, ScoreState, name)
1924 def __init__(self, *args):
1926 __init__(IMP::kernel::ScoreState self, std::string name="ScoreState %1%") -> ScoreState
1927 __init__(IMP::kernel::ScoreState self) -> ScoreState
1928 __init__(IMP::kernel::ScoreState self, Model m, std::string name="ScoreState %1%") -> ScoreState
1929 __init__(IMP::kernel::ScoreState self, Model m) -> ScoreState
1931 if self.__class__ == ScoreState:
1935 this = _IMP_kernel.new_ScoreState(_self, *args)
1936 try: self.this.append(this)
1937 except: self.this = this
1938 if self.__class__ != ScoreState:
1940 IMP.base._director_objects.register(self)
1944 def before_evaluate(self):
1945 """before_evaluate(ScoreState self)"""
1946 return _IMP_kernel.ScoreState_before_evaluate(self)
1948 def after_evaluate(self, *args):
1949 """after_evaluate(ScoreState self, DerivativeAccumulator accpt)"""
1950 return _IMP_kernel.ScoreState_after_evaluate(self, *args)
1952 def do_before_evaluate(self):
1953 """do_before_evaluate(ScoreState self)"""
1954 return _IMP_kernel.ScoreState_do_before_evaluate(self)
1956 def do_after_evaluate(self, *args):
1957 """do_after_evaluate(ScoreState self, DerivativeAccumulator accpt)"""
1958 return _IMP_kernel.ScoreState_do_after_evaluate(self, *args)
1960 __swig_destroy__ = _IMP_kernel.delete_ScoreState
1961 __del__ =
lambda self :
None;
1963 """get_input_particles(ScoreState self) -> IMP::kernel::ParticlesTemp"""
1964 return _IMP_kernel.ScoreState_get_input_particles(self)
1967 """get_input_containers(ScoreState self) -> IMP::kernel::ContainersTemp"""
1968 return _IMP_kernel.ScoreState_get_input_containers(self)
1971 """get_output_particles(ScoreState self) -> IMP::kernel::ParticlesTemp"""
1972 return _IMP_kernel.ScoreState_get_output_particles(self)
1975 """get_output_containers(ScoreState self) -> IMP::kernel::ContainersTemp"""
1976 return _IMP_kernel.ScoreState_get_output_containers(self)
1978 def do_update_dependencies(self):
1979 """do_update_dependencies(ScoreState self)"""
1980 return _IMP_kernel.ScoreState_do_update_dependencies(self)
1983 """__str__(ScoreState self) -> std::string"""
1984 return _IMP_kernel.ScoreState___str__(self)
1987 """__repr__(ScoreState self) -> std::string"""
1988 return _IMP_kernel.ScoreState___repr__(self)
1991 return _object_cast_to_ScoreState(o)
1992 get_from = staticmethod(get_from)
1994 def get_type_name(self):
1995 return self.__class__.__name__
1996 def do_show(self, out):
1998 def get_version_info(self):
1999 if"IMP::kernel" ==
"IMP":
2000 return VersionInfo(
"python",
"0")
2002 return IMP.VersionInfo(
"python",
"0")
2004 return _object_cast_to_ScoreState(o)
2005 get_from = staticmethod(get_from)
2007 def __disown__(self):
2009 _IMP_kernel.disown_ScoreState(self)
2010 return weakref_proxy(self)
2011 def update_dependencies(self):
2012 """update_dependencies(ScoreState self)"""
2013 return _IMP_kernel.ScoreState_update_dependencies(self)
2015 def do_get_inputs(self):
2016 """do_get_inputs(ScoreState self) -> IMP::kernel::ModelObjectsTemp"""
2017 return _IMP_kernel.ScoreState_do_get_inputs(self)
2019 def do_get_outputs(self):
2020 """do_get_outputs(ScoreState self) -> IMP::kernel::ModelObjectsTemp"""
2021 return _IMP_kernel.ScoreState_do_get_outputs(self)
2023 def do_get_interactions(self):
2024 """do_get_interactions(ScoreState self) -> IMP::kernel::ModelObjectsTemps"""
2025 return _IMP_kernel.ScoreState_do_get_interactions(self)
2027 ScoreState_swigregister = _IMP_kernel.ScoreState_swigregister
2028 ScoreState_swigregister(ScoreState)
2032 """get_update_order(IMP::kernel::ScoreStatesTemp input) -> IMP::kernel::ScoreStatesTemp"""
2033 return _IMP_kernel.get_update_order(*args)
2035 """Proxy of C++ IMP::kernel::Constraint class"""
2036 __swig_setmethods__ = {}
2037 for _s
in [ScoreState]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2038 __setattr__ =
lambda self, name, value: _swig_setattr(self, Constraint, name, value)
2039 __swig_getmethods__ = {}
2040 for _s
in [ScoreState]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2041 __getattr__ =
lambda self, name: _swig_getattr(self, Constraint, name)
2042 def __init__(self, *args):
2044 __init__(IMP::kernel::Constraint self, std::string name="Constraint %1%") -> Constraint
2045 __init__(IMP::kernel::Constraint self) -> Constraint
2046 __init__(IMP::kernel::Constraint self, Model m, std::string name="Constraint %1%") -> Constraint
2047 __init__(IMP::kernel::Constraint self, Model m) -> Constraint
2049 if self.__class__ == Constraint:
2053 this = _IMP_kernel.new_Constraint(_self, *args)
2054 try: self.this.append(this)
2055 except: self.this = this
2056 if self.__class__ != Constraint:
2058 IMP.base._director_objects.register(self)
2062 def do_update_attributes(self):
2063 """do_update_attributes(Constraint self)"""
2064 return _IMP_kernel.Constraint_do_update_attributes(self)
2066 def do_update_derivatives(self, *args):
2067 """do_update_derivatives(Constraint self, DerivativeAccumulator da)"""
2068 return _IMP_kernel.Constraint_do_update_derivatives(self, *args)
2070 def do_before_evaluate(self):
2071 """do_before_evaluate(Constraint self)"""
2072 return _IMP_kernel.Constraint_do_before_evaluate(self)
2074 def do_after_evaluate(self, *args):
2075 """do_after_evaluate(Constraint self, DerivativeAccumulator da)"""
2076 return _IMP_kernel.Constraint_do_after_evaluate(self, *args)
2078 __swig_destroy__ = _IMP_kernel.delete_Constraint
2079 __del__ =
lambda self :
None;
2081 """__str__(Constraint self) -> std::string"""
2082 return _IMP_kernel.Constraint___str__(self)
2085 """__repr__(Constraint self) -> std::string"""
2086 return _IMP_kernel.Constraint___repr__(self)
2089 return _object_cast_to_Constraint(o)
2090 get_from = staticmethod(get_from)
2092 def get_type_name(self):
2093 return self.__class__.__name__
2094 def do_show(self, out):
2096 def get_version_info(self):
2097 if"IMP::kernel" ==
"IMP":
2098 return VersionInfo(
"python",
"0")
2100 return IMP.VersionInfo(
"python",
"0")
2102 return _object_cast_to_Constraint(o)
2103 get_from = staticmethod(get_from)
2105 def __disown__(self):
2107 _IMP_kernel.disown_Constraint(self)
2108 return weakref_proxy(self)
2109 def update_dependencies(self):
2110 """update_dependencies(Constraint self)"""
2111 return _IMP_kernel.Constraint_update_dependencies(self)
2113 def do_get_inputs(self):
2114 """do_get_inputs(Constraint self) -> IMP::kernel::ModelObjectsTemp"""
2115 return _IMP_kernel.Constraint_do_get_inputs(self)
2117 def do_get_outputs(self):
2118 """do_get_outputs(Constraint self) -> IMP::kernel::ModelObjectsTemp"""
2119 return _IMP_kernel.Constraint_do_get_outputs(self)
2121 def do_get_interactions(self):
2122 """do_get_interactions(Constraint self) -> IMP::kernel::ModelObjectsTemps"""
2123 return _IMP_kernel.Constraint_do_get_interactions(self)
2125 def do_update_dependencies(self):
2126 """do_update_dependencies(Constraint self)"""
2127 return _IMP_kernel.Constraint_do_update_dependencies(self)
2129 Constraint_swigregister = _IMP_kernel.Constraint_swigregister
2130 Constraint_swigregister(Constraint)
2133 """Proxy of C++ IMP::kernel::Container class"""
2134 __swig_setmethods__ = {}
2135 for _s
in [ScoreState]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2136 __setattr__ =
lambda self, name, value: _swig_setattr(self, Container, name, value)
2137 __swig_getmethods__ = {}
2138 for _s
in [ScoreState]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2139 __getattr__ =
lambda self, name: _swig_getattr(self, Container, name)
2140 def set_is_changed(self, *args):
2141 """set_is_changed(Container self, bool tf)"""
2142 return _IMP_kernel.Container_set_is_changed(self, *args)
2144 def __init__(self, *args):
2146 __init__(IMP::kernel::Container self, Model m, std::string name="Container %1%") -> Container
2147 __init__(IMP::kernel::Container self, Model m) -> Container
2149 if self.__class__ == Container:
2153 this = _IMP_kernel.new_Container(_self, *args)
2154 try: self.this.append(this)
2155 except: self.this = this
2156 if self.__class__ != Container:
2158 IMP.base._director_objects.register(self)
2162 def get_all_possible_indexes(self):
2163 """get_all_possible_indexes(Container self) -> IMP::kernel::ParticleIndexes"""
2164 return _IMP_kernel.Container_get_all_possible_indexes(self)
2166 def get_all_possible_particles(self):
2167 """get_all_possible_particles(Container self) -> IMP::kernel::ParticlesTemp"""
2168 return _IMP_kernel.Container_get_all_possible_particles(self)
2170 def get_is_changed(self):
2171 """get_is_changed(Container self) -> bool"""
2172 return _IMP_kernel.Container_get_is_changed(self)
2174 def do_get_outputs(self):
2175 """do_get_outputs(Container self) -> IMP::kernel::ModelObjectsTemp"""
2176 return _IMP_kernel.Container_do_get_outputs(self)
2178 def do_after_evaluate(self, *args):
2179 """do_after_evaluate(Container self, DerivativeAccumulator accpt)"""
2180 return _IMP_kernel.Container_do_after_evaluate(self, *args)
2182 def get_is_decomposable(self):
2183 """get_is_decomposable(Container self) -> bool"""
2184 return _IMP_kernel.Container_get_is_decomposable(self)
2186 def validate_readable(self):
2187 """validate_readable(Container self)"""
2188 return _IMP_kernel.Container_validate_readable(self)
2190 def validate_writable(self):
2191 """validate_writable(Container self)"""
2192 return _IMP_kernel.Container_validate_writable(self)
2194 def set_is_readable(self, *args):
2195 """set_is_readable(Container self, bool tf)"""
2196 return _IMP_kernel.Container_set_is_readable(self, *args)
2198 def set_is_writable(self, *args):
2199 """set_is_writable(Container self, bool tf)"""
2200 return _IMP_kernel.Container_set_is_writable(self, *args)
2202 __swig_destroy__ = _IMP_kernel.delete_Container
2203 __del__ =
lambda self :
None;
2205 """__str__(Container self) -> std::string"""
2206 return _IMP_kernel.Container___str__(self)
2209 """__repr__(Container self) -> std::string"""
2210 return _IMP_kernel.Container___repr__(self)
2213 return _object_cast_to_Container(o)
2214 get_from = staticmethod(get_from)
2216 def get_type_name(self):
2217 return self.__class__.__name__
2218 def do_show(self, out):
2220 def get_version_info(self):
2221 if"IMP::kernel" ==
"IMP":
2222 return VersionInfo(
"python",
"0")
2224 return IMP.VersionInfo(
"python",
"0")
2226 return _object_cast_to_Container(o)
2227 get_from = staticmethod(get_from)
2229 def __disown__(self):
2231 _IMP_kernel.disown_Container(self)
2232 return weakref_proxy(self)
2233 def update_dependencies(self):
2234 """update_dependencies(Container self)"""
2235 return _IMP_kernel.Container_update_dependencies(self)
2237 def do_get_inputs(self):
2238 """do_get_inputs(Container self) -> IMP::kernel::ModelObjectsTemp"""
2239 return _IMP_kernel.Container_do_get_inputs(self)
2241 def do_get_interactions(self):
2242 """do_get_interactions(Container self) -> IMP::kernel::ModelObjectsTemps"""
2243 return _IMP_kernel.Container_do_get_interactions(self)
2245 def do_before_evaluate(self):
2246 """do_before_evaluate(Container self)"""
2247 return _IMP_kernel.Container_do_before_evaluate(self)
2249 def do_update_dependencies(self):
2250 """do_update_dependencies(Container self)"""
2251 return _IMP_kernel.Container_do_update_dependencies(self)
2253 Container_swigregister = _IMP_kernel.Container_swigregister
2254 Container_swigregister(Container)
2257 """Proxy of C++ IMP::kernel::Restraint class"""
2258 __swig_setmethods__ = {}
2259 for _s
in [ModelObject]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2260 __setattr__ =
lambda self, name, value: _swig_setattr(self, Restraint, name, value)
2261 __swig_getmethods__ = {}
2262 for _s
in [ModelObject]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2263 __getattr__ =
lambda self, name: _swig_getattr(self, Restraint, name)
2264 def __init__(self, *args):
2266 __init__(IMP::kernel::Restraint self, Model m, std::string name) -> Restraint
2267 __init__(IMP::kernel::Restraint self, std::string name="Restraint %1%") -> Restraint
2268 __init__(IMP::kernel::Restraint self) -> Restraint
2270 if self.__class__ == Restraint:
2274 this = _IMP_kernel.new_Restraint(_self, *args)
2275 try: self.this.append(this)
2276 except: self.this = this
2277 if self.__class__ != Restraint:
2279 IMP.base._director_objects.register(self)
2283 def get_score(self):
2284 """get_score(Restraint self) -> double"""
2285 return _IMP_kernel.Restraint_get_score(self)
2287 def evaluate(self, *args):
2288 """evaluate(Restraint self, bool calc_derivs) -> double"""
2289 return _IMP_kernel.Restraint_evaluate(self, *args)
2291 def evaluate_if_good(self, *args):
2292 """evaluate_if_good(Restraint self, bool calc_derivatives) -> double"""
2293 return _IMP_kernel.Restraint_evaluate_if_good(self, *args)
2295 def evaluate_if_below(self, *args):
2296 """evaluate_if_below(Restraint self, bool calc_derivatives, double max) -> double"""
2297 return _IMP_kernel.Restraint_evaluate_if_below(self, *args)
2299 def unprotected_evaluate(self, *args):
2300 """unprotected_evaluate(Restraint self, DerivativeAccumulator da) -> double"""
2301 return _IMP_kernel.Restraint_unprotected_evaluate(self, *args)
2303 def unprotected_evaluate_if_good(self, *args):
2304 """unprotected_evaluate_if_good(Restraint self, DerivativeAccumulator da, double max) -> double"""
2305 return _IMP_kernel.Restraint_unprotected_evaluate_if_good(self, *args)
2307 def unprotected_evaluate_if_below(self, *args):
2308 """unprotected_evaluate_if_below(Restraint self, DerivativeAccumulator da, double max) -> double"""
2309 return _IMP_kernel.Restraint_unprotected_evaluate_if_below(self, *args)
2311 def add_score_and_derivatives(self, *args):
2312 """add_score_and_derivatives(Restraint self, ScoreAccumulator sa)"""
2313 return _IMP_kernel.Restraint_add_score_and_derivatives(self, *args)
2316 """create_decomposition(Restraint self) -> Restraint"""
2317 return _IMP_kernel.Restraint_create_decomposition(self)
2319 def create_current_decomposition(self):
2320 """create_current_decomposition(Restraint self) -> Restraint"""
2321 return _IMP_kernel.Restraint_create_current_decomposition(self)
2323 def set_weight(self, *args):
2324 """set_weight(Restraint self, IMP::Float weight)"""
2325 return _IMP_kernel.Restraint_set_weight(self, *args)
2327 def get_weight(self):
2328 """get_weight(Restraint self) -> IMP::Float"""
2329 return _IMP_kernel.Restraint_get_weight(self)
2331 def get_maximum_score(self):
2332 """get_maximum_score(Restraint self) -> double"""
2333 return _IMP_kernel.Restraint_get_maximum_score(self)
2335 def set_maximum_score(self, *args):
2336 """set_maximum_score(Restraint self, double s)"""
2337 return _IMP_kernel.Restraint_set_maximum_score(self, *args)
2341 create_scoring_function(Restraint self, double weight=1.0, double max=NO_MAX) -> ScoringFunction
2342 create_scoring_function(Restraint self, double weight=1.0) -> ScoringFunction
2343 create_scoring_function(Restraint self) -> ScoringFunction
2345 return _IMP_kernel.Restraint_create_scoring_function(self, *args)
2347 def set_last_score(self, *args):
2348 """set_last_score(Restraint self, double s)"""
2349 return _IMP_kernel.Restraint_set_last_score(self, *args)
2351 def get_last_score(self):
2352 """get_last_score(Restraint self) -> double"""
2353 return _IMP_kernel.Restraint_get_last_score(self)
2355 def get_was_good(self):
2356 """get_was_good(Restraint self) -> bool"""
2357 return _IMP_kernel.Restraint_get_was_good(self)
2360 """get_input_particles(Restraint self) -> IMP::kernel::ParticlesTemp"""
2361 return _IMP_kernel.Restraint_get_input_particles(self)
2364 """get_input_containers(Restraint self) -> IMP::kernel::ContainersTemp"""
2365 return _IMP_kernel.Restraint_get_input_containers(self)
2367 __swig_destroy__ = _IMP_kernel.delete_Restraint
2368 __del__ =
lambda self :
None;
2369 def do_create_decomposition(self):
2370 """do_create_decomposition(Restraint self) -> IMP::kernel::Restraints"""
2371 return _IMP_kernel.Restraint_do_create_decomposition(self)
2373 def do_create_current_decomposition(self):
2374 """do_create_current_decomposition(Restraint self) -> IMP::kernel::Restraints"""
2375 return _IMP_kernel.Restraint_do_create_current_decomposition(self)
2377 def do_add_score_and_derivatives(self, *args):
2378 """do_add_score_and_derivatives(Restraint self, ScoreAccumulator sa)"""
2379 return _IMP_kernel.Restraint_do_add_score_and_derivatives(self, *args)
2381 def do_update_dependencies(self):
2382 """do_update_dependencies(Restraint self)"""
2383 return _IMP_kernel.Restraint_do_update_dependencies(self)
2385 def do_get_outputs(self):
2386 """do_get_outputs(Restraint self) -> IMP::kernel::ModelObjectsTemp"""
2387 return _IMP_kernel.Restraint_do_get_outputs(self)
2390 """__str__(Restraint self) -> std::string"""
2391 return _IMP_kernel.Restraint___str__(self)
2394 """__repr__(Restraint self) -> std::string"""
2395 return _IMP_kernel.Restraint___repr__(self)
2398 return _object_cast_to_Restraint(o)
2399 get_from = staticmethod(get_from)
2401 def get_type_name(self):
2402 return self.__class__.__name__
2403 def do_show(self, out):
2405 def get_version_info(self):
2406 if"IMP::kernel" ==
"IMP":
2407 return VersionInfo(
"python",
"0")
2409 return IMP.VersionInfo(
"python",
"0")
2411 return _object_cast_to_Restraint(o)
2412 get_from = staticmethod(get_from)
2414 def __disown__(self):
2416 _IMP_kernel.disown_Restraint(self)
2417 return weakref_proxy(self)
2418 def update_dependencies(self):
2419 """update_dependencies(Restraint self)"""
2420 return _IMP_kernel.Restraint_update_dependencies(self)
2422 def do_get_inputs(self):
2423 """do_get_inputs(Restraint self) -> IMP::kernel::ModelObjectsTemp"""
2424 return _IMP_kernel.Restraint_do_get_inputs(self)
2426 def do_get_interactions(self):
2427 """do_get_interactions(Restraint self) -> IMP::kernel::ModelObjectsTemps"""
2428 return _IMP_kernel.Restraint_do_get_interactions(self)
2430 Restraint_swigregister = _IMP_kernel.Restraint_swigregister
2431 Restraint_swigregister(Restraint)
2434 """Proxy of C++ IMP::kernel::RestraintSet class"""
2435 __swig_setmethods__ = {}
2436 for _s
in [Restraint]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2437 __setattr__ =
lambda self, name, value: _swig_setattr(self, RestraintSet, name, value)
2438 __swig_getmethods__ = {}
2439 for _s
in [Restraint]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2440 __getattr__ =
lambda self, name: _swig_getattr(self, RestraintSet, name)
2441 def __init__(self, *args):
2443 __init__(IMP::kernel::RestraintSet self, Model m, double weight, std::string const & name="RestraintSet %1%") -> RestraintSet
2444 __init__(IMP::kernel::RestraintSet self, Model m, double weight) -> RestraintSet
2445 __init__(IMP::kernel::RestraintSet self, IMP::kernel::RestraintsTemp const & rs, double weight, std::string const & name="RestraintSet %1%") -> RestraintSet
2446 __init__(IMP::kernel::RestraintSet self, IMP::kernel::RestraintsTemp const & rs, double weight) -> RestraintSet
2447 __init__(IMP::kernel::RestraintSet self, double weight, std::string const & name="RestraintSet %1%") -> RestraintSet
2448 __init__(IMP::kernel::RestraintSet self, double weight) -> RestraintSet
2449 __init__(IMP::kernel::RestraintSet self, std::string const & name="RestraintSet %1%") -> RestraintSet
2450 __init__(IMP::kernel::RestraintSet self) -> RestraintSet
2451 __init__(IMP::kernel::RestraintSet self, IMP::kernel::Restraint::ModelInitTag arg2, std::string const & name="RestraintSet %1%") -> RestraintSet
2452 __init__(IMP::kernel::RestraintSet self, IMP::kernel::Restraint::ModelInitTag arg2) -> RestraintSet
2454 this = _IMP_kernel.new_RestraintSet(*args)
2455 try: self.this.append(this)
2456 except: self.this = this
2457 def get_version_info(self):
2458 """get_version_info(RestraintSet self) -> VersionInfo"""
2459 return _IMP_kernel.RestraintSet_get_version_info(self)
2461 __swig_destroy__ = _IMP_kernel.delete_RestraintSet
2462 __del__ =
lambda self :
None;
2463 def remove_restraint(self, *args):
2464 """remove_restraint(RestraintSet self, Restraint d)"""
2465 return _IMP_kernel.RestraintSet_remove_restraint(self, *args)
2467 def remove_restraints(self, *args):
2468 """remove_restraints(RestraintSet self, IMP::kernel::Restraints const & d)"""
2469 return _IMP_kernel.RestraintSet_remove_restraints(self, *args)
2471 def set_restraints(self, *args):
2472 """set_restraints(RestraintSet self, IMP::kernel::Restraints const & ps)"""
2473 return _IMP_kernel.RestraintSet_set_restraints(self, *args)
2475 def set_restraints_order(self, *args):
2476 """set_restraints_order(RestraintSet self, IMP::kernel::Restraints const & objs)"""
2477 return _IMP_kernel.RestraintSet_set_restraints_order(self, *args)
2480 """add_restraint(RestraintSet self, Restraint obj) -> unsigned int"""
2481 return _IMP_kernel.RestraintSet_add_restraint(self, *args)
2484 """add_restraints(RestraintSet self, IMP::kernel::Restraints const & objs)"""
2485 return _IMP_kernel.RestraintSet_add_restraints(self, *args)
2487 def clear_restraints(self):
2488 """clear_restraints(RestraintSet self)"""
2489 return _IMP_kernel.RestraintSet_clear_restraints(self)
2491 def get_number_of_restraints(self):
2492 """get_number_of_restraints(RestraintSet self) -> unsigned int"""
2493 return _IMP_kernel.RestraintSet_get_number_of_restraints(self)
2495 def get_has_restraints(self):
2496 """get_has_restraints(RestraintSet self) -> bool"""
2497 return _IMP_kernel.RestraintSet_get_has_restraints(self)
2499 def get_restraint(self, *args):
2500 """get_restraint(RestraintSet self, unsigned int i) -> Restraint"""
2501 return _IMP_kernel.RestraintSet_get_restraint(self, *args)
2503 def get_restraints(self):
2504 """get_restraints(RestraintSet self) -> IMP::kernel::Restraints"""
2505 return _IMP_kernel.RestraintSet_get_restraints(self)
2507 def reserve_restraints(self, *args):
2508 """reserve_restraints(RestraintSet self, unsigned int sz)"""
2509 return _IMP_kernel.RestraintSet_reserve_restraints(self, *args)
2511 def get_non_sets_and_sets(self):
2512 """get_non_sets_and_sets(RestraintSet self) -> std::pair< IMP::kernel::RestraintsTemp,IMP::kernel::RestraintSetsTemp >"""
2513 return _IMP_kernel.RestraintSet_get_non_sets_and_sets(self)
2515 def do_get_inputs(self):
2516 """do_get_inputs(RestraintSet self) -> IMP::kernel::ModelObjectsTemp"""
2517 return _IMP_kernel.RestraintSet_do_get_inputs(self)
2521 create_scoring_function(RestraintSet self, double weight=1.0, double max=std::numeric_limits< double >::max()) -> ScoringFunction
2522 create_scoring_function(RestraintSet self, double weight=1.0) -> ScoringFunction
2523 create_scoring_function(RestraintSet self) -> ScoringFunction
2525 return _IMP_kernel.RestraintSet_create_scoring_function(self, *args)
2528 """__str__(RestraintSet self) -> std::string"""
2529 return _IMP_kernel.RestraintSet___str__(self)
2532 """__repr__(RestraintSet self) -> std::string"""
2533 return _IMP_kernel.RestraintSet___repr__(self)
2536 return _object_cast_to_RestraintSet(o)
2537 get_from = staticmethod(get_from)
2539 RestraintSet_swigregister = _IMP_kernel.RestraintSet_swigregister
2540 RestraintSet_swigregister(RestraintSet)
2543 def get_restraints(*args):
2544 """get_restraints(IMP::kernel::RestraintsTemp const & rs) -> IMP::kernel::RestraintsTemp"""
2545 return _IMP_kernel.get_restraints(*args)
2546 def _check_particle(p, a):
2547 if (
not p.get_is_active()):
2548 raise ValueError(
"Inactive Particle")
2549 if (type(a)() == a):
2550 raise IndexError(
"Cannot use default Index")
2551 if (
not p.has_attribute(a)):
2552 raise IndexError(
"Particle does not have attribute")
2555 """Proxy of C++ IMP::kernel::Particle class"""
2556 __swig_setmethods__ = {}
2557 for _s
in [ModelObject]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2558 __setattr__ =
lambda self, name, value: _swig_setattr(self, Particle, name, value)
2559 __swig_getmethods__ = {}
2560 for _s
in [ModelObject]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2561 __getattr__ =
lambda self, name: _swig_getattr(self, Particle, name)
2562 def get_version_info(self):
2563 """get_version_info(Particle self) -> VersionInfo"""
2564 return _IMP_kernel.Particle_get_version_info(self)
2566 def do_show(self, *args):
2567 """do_show(Particle self, _ostream out)"""
2568 return _IMP_kernel.Particle_do_show(self, *args)
2570 __swig_destroy__ = _IMP_kernel.delete_Particle
2571 __del__ =
lambda self :
None;
2572 def __init__(self, *args):
2574 __init__(IMP::kernel::Particle self, Model m, std::string name) -> Particle
2575 __init__(IMP::kernel::Particle self, Model m) -> Particle
2577 this = _IMP_kernel.new_Particle(*args)
2578 try: self.this.append(this)
2579 except: self.this = this
2580 def get_float_keys(self):
2581 """get_float_keys(Particle self) -> IMP::kernel::FloatKeys"""
2582 return _IMP_kernel.Particle_get_float_keys(self)
2584 def get_int_keys(self):
2585 """get_int_keys(Particle self) -> IMP::kernel::IntKeys"""
2586 return _IMP_kernel.Particle_get_int_keys(self)
2588 def get_string_keys(self):
2589 """get_string_keys(Particle self) -> IMP::kernel::StringKeys"""
2590 return _IMP_kernel.Particle_get_string_keys(self)
2592 def get_object_keys(self):
2593 """get_object_keys(Particle self) -> IMP::kernel::ObjectKeys"""
2594 return _IMP_kernel.Particle_get_object_keys(self)
2596 def add_cache_attribute(self, *args):
2598 add_cache_attribute(Particle self, FloatKey name, IMP::Float value)
2599 add_cache_attribute(Particle self, IntKey name, IMP::Int value)
2600 add_cache_attribute(Particle self, StringKey name, IMP::String value)
2601 add_cache_attribute(Particle self, ObjectKey name, Object * value)
2602 add_cache_attribute(Particle self, IMP::kernel::WeakObjectKey name, Object * value)
2604 return _IMP_kernel.Particle_add_cache_attribute(self, *args)
2606 def get_weak_object_keys(self):
2607 """get_weak_object_keys(Particle self) -> IMP::kernel::WeakObjectKeys"""
2608 return _IMP_kernel.Particle_get_weak_object_keys(self)
2610 def add_to_derivative(self, *args):
2611 """add_to_derivative(Particle self, FloatKey key, IMP::Float value, DerivativeAccumulator da)"""
2612 return _IMP_kernel.Particle_add_to_derivative(self, *args)
2614 def set_is_optimized(self, *args):
2615 """set_is_optimized(Particle self, FloatKey k, bool tf)"""
2616 return _IMP_kernel.Particle_set_is_optimized(self, *args)
2618 def get_is_optimized(self, *args):
2619 """get_is_optimized(Particle self, FloatKey k) -> bool"""
2620 return _IMP_kernel.Particle_get_is_optimized(self, *args)
2622 def get_derivative(self, *args):
2623 """get_derivative(Particle self, FloatKey name) -> IMP::Float"""
2624 return _IMP_kernel.Particle_get_derivative(self, *args)
2626 def add_attribute(self, *args):
2628 add_attribute(Particle self, FloatKey name, IMP::Float initial_value)
2629 add_attribute(Particle self, IntKey name, IMP::Int initial_value)
2630 add_attribute(Particle self, StringKey name, IMP::String initial_value)
2631 add_attribute(Particle self, ObjectKey name, Object * initial_value)
2632 add_attribute(Particle self, IMP::kernel::WeakObjectKey name, Object * initial_value)
2633 add_attribute(Particle self, FloatKey name, IMP::Float const initial_value, bool optimized)
2634 add_attribute(Particle self, ParticleIndexKey k, Particle v)
2636 return _IMP_kernel.Particle_add_attribute(self, *args)
2638 def has_attribute(self, *args):
2640 has_attribute(Particle self, FloatKey name) -> bool
2641 has_attribute(Particle self, IntKey name) -> bool
2642 has_attribute(Particle self, StringKey name) -> bool
2643 has_attribute(Particle self, ObjectKey name) -> bool
2644 has_attribute(Particle self, IMP::kernel::WeakObjectKey name) -> bool
2645 has_attribute(Particle self, ParticleIndexKey k) -> bool
2647 return _IMP_kernel.Particle_has_attribute(self, *args)
2649 def set_value(self, *args):
2651 set_value(Particle self, FloatKey name, IMP::Float value)
2652 set_value(Particle self, IntKey name, IMP::Int value)
2653 set_value(Particle self, StringKey name, IMP::String value)
2654 set_value(Particle self, ObjectKey name, Object * value)
2655 set_value(Particle self, IMP::kernel::WeakObjectKey name, Object * value)
2656 set_value(Particle self, ParticleIndexKey k, Particle v)
2658 return _IMP_kernel.Particle_set_value(self, *args)
2660 def get_value(self, *args):
2662 get_value(Particle self, FloatKey name) -> IMP::Float
2663 get_value(Particle self, IntKey name) -> IMP::Int
2664 get_value(Particle self, StringKey name) -> IMP::String
2665 get_value(Particle self, ObjectKey name) -> Object
2666 get_value(Particle self, IMP::kernel::WeakObjectKey name) -> Object
2667 get_value(Particle self, ParticleIndexKey k) -> Particle
2669 return _IMP_kernel.Particle_get_value(self, *args)
2671 def remove_attribute(self, *args):
2673 remove_attribute(Particle self, FloatKey name)
2674 remove_attribute(Particle self, IntKey name)
2675 remove_attribute(Particle self, StringKey name)
2676 remove_attribute(Particle self, ObjectKey name)
2677 remove_attribute(Particle self, IMP::kernel::WeakObjectKey name)
2678 remove_attribute(Particle self, ParticleIndexKey k)
2680 return _IMP_kernel.Particle_remove_attribute(self, *args)
2682 def get_particle_keys(self):
2683 """get_particle_keys(Particle self) -> IMP::kernel::ParticleIndexKeys"""
2684 return _IMP_kernel.Particle_get_particle_keys(self)
2686 def get_is_active(self):
2687 """get_is_active(Particle self) -> bool"""
2688 return _IMP_kernel.Particle_get_is_active(self)
2691 """get_index(Particle self) -> IMP::kernel::ParticleIndex"""
2692 return _IMP_kernel.Particle_get_index(self)
2694 def __eq__(self, *args):
2696 __eq__(Particle self, Particle o) -> bool
2697 __eq__(Particle self, Decorator d) -> bool
2699 return _IMP_kernel.Particle___eq__(self, *args)
2701 def __ne__(self, *args):
2703 __ne__(Particle self, Particle o) -> bool
2704 __ne__(Particle self, Decorator d) -> bool
2706 return _IMP_kernel.Particle___ne__(self, *args)
2708 def __le__(self, *args):
2710 __le__(Particle self, Particle o) -> bool
2711 __le__(Particle self, Decorator d) -> bool
2713 return _IMP_kernel.Particle___le__(self, *args)
2715 def __lt__(self, *args):
2717 __lt__(Particle self, Particle o) -> bool
2718 __lt__(Particle self, Decorator d) -> bool
2720 return _IMP_kernel.Particle___lt__(self, *args)
2722 def __ge__(self, *args):
2724 __ge__(Particle self, Particle o) -> bool
2725 __ge__(Particle self, Decorator d) -> bool
2727 return _IMP_kernel.Particle___ge__(self, *args)
2729 def __gt__(self, *args):
2731 __gt__(Particle self, Particle o) -> bool
2732 __gt__(Particle self, Decorator d) -> bool
2734 return _IMP_kernel.Particle___gt__(self, *args)
2737 """__str__(Particle self) -> std::string"""
2738 return _IMP_kernel.Particle___str__(self)
2741 """__repr__(Particle self) -> std::string"""
2742 return _IMP_kernel.Particle___repr__(self)
2745 return _object_cast_to_Particle(o)
2746 get_from = staticmethod(get_from)
2748 Particle_swigregister = _IMP_kernel.Particle_swigregister
2749 Particle_swigregister(Particle)
2751 class _DependencyGraphVertexIndex(_object):
2752 """Proxy of C++ IMP::kernel::DependencyGraphVertexIndex class"""
2753 __swig_setmethods__ = {}
2754 __setattr__ =
lambda self, name, value: _swig_setattr(self, _DependencyGraphVertexIndex, name, value)
2755 __swig_getmethods__ = {}
2756 __getattr__ =
lambda self, name: _swig_getattr(self, _DependencyGraphVertexIndex, name)
2757 __repr__ = _swig_repr
2759 """__init__(IMP::kernel::DependencyGraphVertexIndex self) -> _DependencyGraphVertexIndex"""
2760 this = _IMP_kernel.new__DependencyGraphVertexIndex()
2761 try: self.this.append(this)
2762 except: self.this = this
2763 __swig_destroy__ = _IMP_kernel.delete__DependencyGraphVertexIndex
2764 __del__ =
lambda self :
None;
2765 _DependencyGraphVertexIndex_swigregister = _IMP_kernel._DependencyGraphVertexIndex_swigregister
2766 _DependencyGraphVertexIndex_swigregister(_DependencyGraphVertexIndex)
2769 def get_vertex_index(*args):
2770 """get_vertex_index(IMP::kernel::DependencyGraph const & g) -> _DependencyGraphVertexIndex"""
2771 return _IMP_kernel.get_vertex_index(*args)
2774 """get_dependency_graph(Model m) -> IMP::kernel::DependencyGraph"""
2775 return _IMP_kernel.get_dependency_graph(*args)
2778 """get_pruned_dependency_graph(Model m) -> IMP::kernel::DependencyGraph"""
2779 return _IMP_kernel.get_pruned_dependency_graph(*args)
2781 def get_required_particles(*args):
2783 get_required_particles(ModelObject p, IMP::kernel::ModelObjectsTemp const & all, IMP::kernel::DependencyGraph const & dg,
2784 _DependencyGraphVertexIndex index) -> IMP::kernel::ParticlesTemp
2786 return _IMP_kernel.get_required_particles(*args)
2788 def get_dependent_particles(*args):
2790 get_dependent_particles(ModelObject p, IMP::kernel::ModelObjectsTemp const & all, IMP::kernel::DependencyGraph const & dg,
2791 _DependencyGraphVertexIndex index) -> IMP::kernel::ParticlesTemp
2793 return _IMP_kernel.get_dependent_particles(*args)
2797 get_dependent_restraints(ModelObject p, IMP::kernel::ModelObjectsTemp const & all, IMP::kernel::DependencyGraph const & dg,
2798 _DependencyGraphVertexIndex index) -> IMP::kernel::RestraintsTemp
2800 return _IMP_kernel.get_dependent_restraints(*args)
2804 get_dependent_score_states(ModelObject p, IMP::kernel::ModelObjectsTemp const & all, IMP::kernel::DependencyGraph const & dg,
2805 _DependencyGraphVertexIndex index) -> IMP::kernel::ScoreStatesTemp
2807 return _IMP_kernel.get_dependent_score_states(*args)
2811 get_required_score_states(ModelObject p, IMP::kernel::ModelObjectsTemp const & all, IMP::kernel::DependencyGraph const & dg,
2812 _DependencyGraphVertexIndex index) -> IMP::kernel::ScoreStatesTemp
2813 get_required_score_states(IMP::kernel::ModelObjectsTemp const & irs, IMP::kernel::DependencyGraph const & dg,
2814 _DependencyGraphVertexIndex index) -> IMP::kernel::ScoreStatesTemp
2816 return _IMP_kernel.get_required_score_states(*args)
2819 """set_score_state_update_order(IMP::kernel::DependencyGraph const & dg, _DependencyGraphVertexIndex index)"""
2820 return _IMP_kernel.set_score_state_update_order(*args)
2822 """Proxy of C++ IMP::kernel::ScoringFunction class"""
2823 __swig_setmethods__ = {}
2824 for _s
in [ModelObject]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2825 __setattr__ =
lambda self, name, value: _swig_setattr(self, ScoringFunction, name, value)
2826 __swig_getmethods__ = {}
2827 for _s
in [ModelObject]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2828 __getattr__ =
lambda self, name: _swig_getattr(self, ScoringFunction, name)
2829 def do_add_score_and_derivatives(self, *args):
2830 """do_add_score_and_derivatives(ScoringFunction self, ScoreAccumulator sa, IMP::kernel::ScoreStatesTemp const & ss)"""
2831 return _IMP_kernel.ScoringFunction_do_add_score_and_derivatives(self, *args)
2834 """get_required_score_states(ScoringFunction self) -> IMP::kernel::ScoreStatesTemp"""
2835 return _IMP_kernel.ScoringFunction_get_required_score_states(self)
2837 def get_score_accumulator_if_below(self, *args):
2838 """get_score_accumulator_if_below(ScoringFunction self, bool deriv, double max) -> ScoreAccumulator"""
2839 return _IMP_kernel.ScoringFunction_get_score_accumulator_if_below(self, *args)
2841 def get_score_accumulator_if_good(self, *args):
2842 """get_score_accumulator_if_good(ScoringFunction self, bool deriv) -> ScoreAccumulator"""
2843 return _IMP_kernel.ScoringFunction_get_score_accumulator_if_good(self, *args)
2845 def get_score_accumulator(self, *args):
2846 """get_score_accumulator(ScoringFunction self, bool deriv) -> ScoreAccumulator"""
2847 return _IMP_kernel.ScoringFunction_get_score_accumulator(self, *args)
2849 def __init__(self, *args):
2850 """__init__(IMP::kernel::ScoringFunction self, Model m, std::string name) -> ScoringFunction"""
2851 if self.__class__ == ScoringFunction:
2855 this = _IMP_kernel.new_ScoringFunction(_self, *args)
2856 try: self.this.append(this)
2857 except: self.this = this
2858 if self.__class__ != ScoringFunction:
2860 IMP.base._director_objects.register(self)
2864 def do_get_inputs(self):
2865 """do_get_inputs(ScoringFunction self) -> IMP::kernel::ModelObjectsTemp"""
2866 return _IMP_kernel.ScoringFunction_do_get_inputs(self)
2868 def do_get_outputs(self):
2869 """do_get_outputs(ScoringFunction self) -> IMP::kernel::ModelObjectsTemp"""
2870 return _IMP_kernel.ScoringFunction_do_get_outputs(self)
2872 def do_update_dependencies(self):
2873 """do_update_dependencies(ScoringFunction self)"""
2874 return _IMP_kernel.ScoringFunction_do_update_dependencies(self)
2876 def evaluate_if_good(self, *args):
2877 """evaluate_if_good(ScoringFunction self, bool derivatives) -> double"""
2878 return _IMP_kernel.ScoringFunction_evaluate_if_good(self, *args)
2880 def evaluate(self, *args):
2881 """evaluate(ScoringFunction self, bool derivatives) -> double"""
2882 return _IMP_kernel.ScoringFunction_evaluate(self, *args)
2884 def evaluate_if_below(self, *args):
2885 """evaluate_if_below(ScoringFunction self, bool derivatives, double max) -> double"""
2886 return _IMP_kernel.ScoringFunction_evaluate_if_below(self, *args)
2888 def get_had_good_score(self):
2889 """get_had_good_score(ScoringFunction self) -> bool"""
2890 return _IMP_kernel.ScoringFunction_get_had_good_score(self)
2892 def get_last_score(self):
2893 """get_last_score(ScoringFunction self) -> double"""
2894 return _IMP_kernel.ScoringFunction_get_last_score(self)
2897 """create_restraints(ScoringFunction self) -> IMP::kernel::Restraints"""
2898 return _IMP_kernel.ScoringFunction_create_restraints(self)
2900 def get_score_states(self):
2901 """get_score_states(ScoringFunction self) -> IMP::kernel::ScoreStatesTemp const &"""
2902 return _IMP_kernel.ScoringFunction_get_score_states(self)
2904 def clear_caches(self):
2905 """clear_caches(ScoringFunction self)"""
2906 return _IMP_kernel.ScoringFunction_clear_caches(self)
2909 """__str__(ScoringFunction self) -> std::string"""
2910 return _IMP_kernel.ScoringFunction___str__(self)
2913 """__repr__(ScoringFunction self) -> std::string"""
2914 return _IMP_kernel.ScoringFunction___repr__(self)
2917 return _object_cast_to_ScoringFunction(o)
2918 get_from = staticmethod(get_from)
2920 def get_type_name(self):
2921 return self.__class__.__name__
2922 def do_show(self, out):
2924 def get_version_info(self):
2925 if"IMP::kernel" ==
"IMP":
2926 return VersionInfo(
"python",
"0")
2928 return IMP.VersionInfo(
"python",
"0")
2930 return _object_cast_to_ScoringFunction(o)
2931 get_from = staticmethod(get_from)
2933 __swig_destroy__ = _IMP_kernel.delete_ScoringFunction
2934 __del__ =
lambda self :
None;
2935 def __disown__(self):
2937 _IMP_kernel.disown_ScoringFunction(self)
2938 return weakref_proxy(self)
2939 def update_dependencies(self):
2940 """update_dependencies(ScoringFunction self)"""
2941 return _IMP_kernel.ScoringFunction_update_dependencies(self)
2943 def do_get_interactions(self):
2944 """do_get_interactions(ScoringFunction self) -> IMP::kernel::ModelObjectsTemps"""
2945 return _IMP_kernel.ScoringFunction_do_get_interactions(self)
2947 ScoringFunction_swigregister = _IMP_kernel.ScoringFunction_swigregister
2948 ScoringFunction_swigregister(ScoringFunction)
2952 """create_decomposition(ScoringFunction sf) -> IMP::kernel::ScoringFunctions"""
2953 return _IMP_kernel.create_decomposition(*args)
2954 class _ScoringFunctionAdaptor(IMP.base._InputAdaptor):
2955 """Proxy of C++ IMP::kernel::ScoringFunctionAdaptor class"""
2956 __swig_setmethods__ = {}
2957 for _s
in [IMP.base._InputAdaptor]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2958 __setattr__ =
lambda self, name, value: _swig_setattr(self, _ScoringFunctionAdaptor, name, value)
2959 __swig_getmethods__ = {}
2960 for _s
in [IMP.base._InputAdaptor]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2961 __getattr__ =
lambda self, name: _swig_getattr(self, _ScoringFunctionAdaptor, name)
2962 __repr__ = _swig_repr
2963 def __init__(self, *args):
2965 __init__(IMP::kernel::ScoringFunctionAdaptor self) -> _ScoringFunctionAdaptor
2966 __init__(IMP::kernel::ScoringFunctionAdaptor self, ScoringFunction sf) -> _ScoringFunctionAdaptor
2967 __init__(IMP::kernel::ScoringFunctionAdaptor self, IMP::kernel::RestraintsTemp const & sf) -> _ScoringFunctionAdaptor
2968 __init__(IMP::kernel::ScoringFunctionAdaptor self, IMP::kernel::Restraints const & sf) -> _ScoringFunctionAdaptor
2969 __init__(IMP::kernel::ScoringFunctionAdaptor self, Model sf) -> _ScoringFunctionAdaptor
2970 __init__(IMP::kernel::ScoringFunctionAdaptor self, Restraint sf) -> _ScoringFunctionAdaptor
2972 this = _IMP_kernel.new__ScoringFunctionAdaptor(*args)
2973 try: self.this.append(this)
2974 except: self.this = this
2975 __swig_destroy__ = _IMP_kernel.delete__ScoringFunctionAdaptor
2976 __del__ =
lambda self :
None;
2977 _ScoringFunctionAdaptor_swigregister = _IMP_kernel._ScoringFunctionAdaptor_swigregister
2978 _ScoringFunctionAdaptor_swigregister(_ScoringFunctionAdaptor)
2983 show_restraint_hierarchy(_ScoringFunctionAdaptor rs, _ostream out=std::cout)
2984 show_restraint_hierarchy(_ScoringFunctionAdaptor rs)
2986 return _IMP_kernel.show_restraint_hierarchy(*args)
2988 """Proxy of C++ IMP::kernel::Undecorator class"""
2989 __swig_setmethods__ = {}
2990 for _s
in [
IMP.base.Object]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2991 __setattr__ =
lambda self, name, value: _swig_setattr(self, Undecorator, name, value)
2992 __swig_getmethods__ = {}
2993 for _s
in [
IMP.base.Object]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2994 __getattr__ =
lambda self, name: _swig_getattr(self, Undecorator, name)
2995 def __init__(self, *args):
2996 """__init__(IMP::kernel::Undecorator self, Model m, std::string name) -> Undecorator"""
2997 if self.__class__ == Undecorator:
3001 this = _IMP_kernel.new_Undecorator(_self, *args)
3002 try: self.this.append(this)
3003 except: self.this = this
3004 if self.__class__ != Undecorator:
3006 IMP.base._director_objects.register(self)
3010 def teardown(self, *args):
3011 """teardown(Undecorator self, IMP::kernel::ParticleIndex pi)"""
3012 return _IMP_kernel.Undecorator_teardown(self, *args)
3015 """__str__(Undecorator self) -> std::string"""
3016 return _IMP_kernel.Undecorator___str__(self)
3019 """__repr__(Undecorator self) -> std::string"""
3020 return _IMP_kernel.Undecorator___repr__(self)
3023 return _object_cast_to_Undecorator(o)
3024 get_from = staticmethod(get_from)
3026 def get_type_name(self):
3027 return self.__class__.__name__
3028 def do_show(self, out):
3030 def get_version_info(self):
3031 if"IMP::kernel" ==
"IMP":
3032 return VersionInfo(
"python",
"0")
3034 return IMP.VersionInfo(
"python",
"0")
3036 return _object_cast_to_Undecorator(o)
3037 get_from = staticmethod(get_from)
3039 __swig_destroy__ = _IMP_kernel.delete_Undecorator
3040 __del__ =
lambda self :
None;
3041 def __disown__(self):
3043 _IMP_kernel.disown_Undecorator(self)
3044 return weakref_proxy(self)
3045 Undecorator_swigregister = _IMP_kernel.Undecorator_swigregister
3046 Undecorator_swigregister(Undecorator)
3049 """Proxy of C++ IMP::kernel::RestraintStatistics class"""
3050 __swig_setmethods__ = {}
3051 for _s
in [IMP.base._Value]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
3052 __setattr__ =
lambda self, name, value: _swig_setattr(self, RestraintStatistics, name, value)
3053 __swig_getmethods__ = {}
3054 for _s
in [IMP.base._Value]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
3055 __getattr__ =
lambda self, name: _swig_getattr(self, RestraintStatistics, name)
3056 def __init__(self, *args):
3058 __init__(IMP::kernel::RestraintStatistics self, double i0=double(), double i1=double(), double i2=double(), double i3=double(), double i4=double()) -> RestraintStatistics
3059 __init__(IMP::kernel::RestraintStatistics self, double i0=double(), double i1=double(), double i2=double(), double i3=double()) -> RestraintStatistics
3060 __init__(IMP::kernel::RestraintStatistics self, double i0=double(), double i1=double(), double i2=double()) -> RestraintStatistics
3061 __init__(IMP::kernel::RestraintStatistics self, double i0=double(), double i1=double()) -> RestraintStatistics
3062 __init__(IMP::kernel::RestraintStatistics self, double i0=double()) -> RestraintStatistics
3063 __init__(IMP::kernel::RestraintStatistics self) -> RestraintStatistics
3065 this = _IMP_kernel.new_RestraintStatistics(*args)
3066 try: self.this.append(this)
3067 except: self.this = this
3069 """__hash__(RestraintStatistics self) -> std::size_t"""
3070 return _IMP_kernel.RestraintStatistics___hash__(self)
3072 def __eq__(self, *args):
3073 """__eq__(RestraintStatistics self, RestraintStatistics o) -> bool"""
3074 return _IMP_kernel.RestraintStatistics___eq__(self, *args)
3076 def __ne__(self, *args):
3077 """__ne__(RestraintStatistics self, RestraintStatistics o) -> bool"""
3078 return _IMP_kernel.RestraintStatistics___ne__(self, *args)
3080 def __lt__(self, *args):
3081 """__lt__(RestraintStatistics self, RestraintStatistics o) -> bool"""
3082 return _IMP_kernel.RestraintStatistics___lt__(self, *args)
3084 def __gt__(self, *args):
3085 """__gt__(RestraintStatistics self, RestraintStatistics o) -> bool"""
3086 return _IMP_kernel.RestraintStatistics___gt__(self, *args)
3088 def __ge__(self, *args):
3089 """__ge__(RestraintStatistics self, RestraintStatistics o) -> bool"""
3090 return _IMP_kernel.RestraintStatistics___ge__(self, *args)
3092 def __le__(self, *args):
3093 """__le__(RestraintStatistics self, RestraintStatistics o) -> bool"""
3094 return _IMP_kernel.RestraintStatistics___le__(self, *args)
3096 def show(self, *args):
3098 show(RestraintStatistics self, _ostream out=std::cout)
3099 show(RestraintStatistics self)
3101 return _IMP_kernel.RestraintStatistics_show(self, *args)
3103 def get_minimum_score(self):
3104 """get_minimum_score(RestraintStatistics self) -> double const &"""
3105 return _IMP_kernel.RestraintStatistics_get_minimum_score(self)
3107 def set_minimum_score(self, *args):
3108 """set_minimum_score(RestraintStatistics self, double const & v)"""
3109 return _IMP_kernel.RestraintStatistics_set_minimum_score(self, *args)
3111 def get_maximum_score(self):
3112 """get_maximum_score(RestraintStatistics self) -> double const &"""
3113 return _IMP_kernel.RestraintStatistics_get_maximum_score(self)
3115 def set_maximum_score(self, *args):
3116 """set_maximum_score(RestraintStatistics self, double const & v)"""
3117 return _IMP_kernel.RestraintStatistics_set_maximum_score(self, *args)
3119 def get_average_score(self):
3120 """get_average_score(RestraintStatistics self) -> double const &"""
3121 return _IMP_kernel.RestraintStatistics_get_average_score(self)
3123 def set_average_score(self, *args):
3124 """set_average_score(RestraintStatistics self, double const & v)"""
3125 return _IMP_kernel.RestraintStatistics_set_average_score(self, *args)
3127 def get_last_score(self):
3128 """get_last_score(RestraintStatistics self) -> double const &"""
3129 return _IMP_kernel.RestraintStatistics_get_last_score(self)
3131 def set_last_score(self, *args):
3132 """set_last_score(RestraintStatistics self, double const & v)"""
3133 return _IMP_kernel.RestraintStatistics_set_last_score(self, *args)
3135 def get_average_time(self):
3136 """get_average_time(RestraintStatistics self) -> double const &"""
3137 return _IMP_kernel.RestraintStatistics_get_average_time(self)
3139 def set_average_time(self, *args):
3140 """set_average_time(RestraintStatistics self, double const & v)"""
3141 return _IMP_kernel.RestraintStatistics_set_average_time(self, *args)
3144 """__str__(RestraintStatistics self) -> std::string"""
3145 return _IMP_kernel.RestraintStatistics___str__(self)
3148 """__repr__(RestraintStatistics self) -> std::string"""
3149 return _IMP_kernel.RestraintStatistics___repr__(self)
3151 __swig_destroy__ = _IMP_kernel.delete_RestraintStatistics
3152 __del__ =
lambda self :
None;
3153 RestraintStatistics_swigregister = _IMP_kernel.RestraintStatistics_swigregister
3154 RestraintStatistics_swigregister(RestraintStatistics)
3157 """Proxy of C++ IMP::kernel::Model class"""
3158 __swig_setmethods__ = {}
3159 for _s
in [RestraintSet]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
3160 __setattr__ =
lambda self, name, value: _swig_setattr(self, Model, name, value)
3161 __swig_getmethods__ = {}
3162 for _s
in [RestraintSet]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
3163 __getattr__ =
lambda self, name: _swig_getattr(self, Model, name)
3164 def clear_particle_caches(self, *args):
3165 """clear_particle_caches(Model self, IMP::kernel::ParticleIndex pi)"""
3166 return _IMP_kernel.Model_clear_particle_caches(self, *args)
3168 def __init__(self, name="Model %1%"):
3170 __init__(IMP::kernel::Model self, std::string name="Model %1%") -> Model
3171 __init__(IMP::kernel::Model self) -> Model
3173 this = _IMP_kernel.new_Model(name)
3174 try: self.this.append(this)
3175 except: self.this = this
3177 """add_particle(Model self, std::string name) -> IMP::kernel::ParticleIndex"""
3178 return _IMP_kernel.Model_add_particle(self, *args)
3181 """get_dependency_graph(Model self) -> IMP::kernel::DependencyGraph const &"""
3182 return _IMP_kernel.Model_get_dependency_graph(self)
3184 def get_dependency_graph_vertex_index(self):
3185 """get_dependency_graph_vertex_index(Model self) -> _DependencyGraphVertexIndex"""
3186 return _IMP_kernel.Model_get_dependency_graph_vertex_index(self)
3189 """get_required_score_states(Model self, ModelObject o) -> IMP::kernel::ScoreStatesTemp const &"""
3190 return _IMP_kernel.Model_get_required_score_states(self, *args)
3192 def add_undecorator(self, *args):
3193 """add_undecorator(Model self, IMP::kernel::ParticleIndex pi, Undecorator d)"""
3194 return _IMP_kernel.Model_add_undecorator(self, *args)
3196 def remove_score_state(self, *args):
3197 """remove_score_state(Model self, ScoreState d)"""
3198 return _IMP_kernel.Model_remove_score_state(self, *args)
3200 def remove_score_states(self, *args):
3201 """remove_score_states(Model self, IMP::kernel::ScoreStates const & d)"""
3202 return _IMP_kernel.Model_remove_score_states(self, *args)
3204 def set_score_states(self, *args):
3205 """set_score_states(Model self, IMP::kernel::ScoreStates const & ps)"""
3206 return _IMP_kernel.Model_set_score_states(self, *args)
3208 def set_score_states_order(self, *args):
3209 """set_score_states_order(Model self, IMP::kernel::ScoreStates const & objs)"""
3210 return _IMP_kernel.Model_set_score_states_order(self, *args)
3212 def add_score_state(self, *args):
3213 """add_score_state(Model self, ScoreState obj) -> unsigned int"""
3214 return _IMP_kernel.Model_add_score_state(self, *args)
3216 def add_score_states(self, *args):
3217 """add_score_states(Model self, IMP::kernel::ScoreStates const & objs)"""
3218 return _IMP_kernel.Model_add_score_states(self, *args)
3220 def clear_score_states(self):
3221 """clear_score_states(Model self)"""
3222 return _IMP_kernel.Model_clear_score_states(self)
3224 def get_number_of_score_states(self):
3225 """get_number_of_score_states(Model self) -> unsigned int"""
3226 return _IMP_kernel.Model_get_number_of_score_states(self)
3228 def get_has_score_states(self):
3229 """get_has_score_states(Model self) -> bool"""
3230 return _IMP_kernel.Model_get_has_score_states(self)
3232 def get_score_state(self, *args):
3233 """get_score_state(Model self, unsigned int i) -> ScoreState"""
3234 return _IMP_kernel.Model_get_score_state(self, *args)
3236 def get_score_states(self):
3237 """get_score_states(Model self) -> IMP::kernel::ScoreStates"""
3238 return _IMP_kernel.Model_get_score_states(self)
3240 def reserve_score_states(self, *args):
3241 """reserve_score_states(Model self, unsigned int sz)"""
3242 return _IMP_kernel.Model_reserve_score_states(self, *args)
3244 def get_optimized_particles(self):
3245 """get_optimized_particles(Model self) -> IMP::kernel::ModelObjectsTemp"""
3246 return _IMP_kernel.Model_get_optimized_particles(self)
3248 def get_root_restraint_set(self):
3249 """get_root_restraint_set(Model self) -> RestraintSet"""
3250 return _IMP_kernel.Model_get_root_restraint_set(self)
3252 def get_has_dependencies(self):
3253 """get_has_dependencies(Model self) -> bool"""
3254 return _IMP_kernel.Model_get_has_dependencies(self)
3256 def set_maximum_score(self, *args):
3258 set_maximum_score(Model self, Restraint r, double s)
3259 set_maximum_score(Model self, double s)
3261 return _IMP_kernel.Model_set_maximum_score(self, *args)
3263 def get_maximum_score(self, *args):
3265 get_maximum_score(Model self, Restraint r) -> double
3266 get_maximum_score(Model self) -> double
3268 return _IMP_kernel.Model_get_maximum_score(self, *args)
3270 def evaluate(self, *args):
3272 evaluate(Model self, bool tf, bool warn=True) -> double
3273 evaluate(Model self, bool tf) -> double
3275 return _IMP_kernel.Model_evaluate(self, *args)
3277 def create_model_scoring_function(self):
3278 """create_model_scoring_function(Model self) -> ScoringFunction"""
3279 return _IMP_kernel.Model_create_model_scoring_function(self)
3282 """update(Model self)"""
3283 return _IMP_kernel.Model_update(self)
3285 __swig_destroy__ = _IMP_kernel.delete_Model
3287 """__del__(IMP::kernel::Model self)"""
3289 IMP.base._director_objects.cleanup()
3296 create_scoring_function(Model self, double weight=1.0, double max=NO_MAX) -> ScoringFunction
3297 create_scoring_function(Model self, double weight=1.0) -> ScoringFunction
3298 create_scoring_function(Model self) -> ScoringFunction
3300 return _IMP_kernel.Model_create_scoring_function(self, *args)
3302 def remove_particle(self, *args):
3304 remove_particle(Model self, Particle p)
3305 remove_particle(Model self, IMP::kernel::ParticleIndex pi)
3307 return _IMP_kernel.Model_remove_particle(self, *args)
3309 def clear_all_statistics(self):
3310 """clear_all_statistics(Model self)"""
3311 return _IMP_kernel.Model_clear_all_statistics(self)
3313 def set_gather_statistics(self, *args):
3314 """set_gather_statistics(Model self, bool tf)"""
3315 return _IMP_kernel.Model_set_gather_statistics(self, *args)
3317 def get_gather_statistics(self):
3318 """get_gather_statistics(Model self) -> bool"""
3319 return _IMP_kernel.Model_get_gather_statistics(self)
3321 def show_all_statistics(self, *args):
3323 show_all_statistics(Model self, _ostream out=std::cout)
3324 show_all_statistics(Model self)
3326 return _IMP_kernel.Model_show_all_statistics(self, *args)
3328 def show_restraint_time_statistics(self, *args):
3330 show_restraint_time_statistics(Model self, _ostream out=std::cout)
3331 show_restraint_time_statistics(Model self)
3333 return _IMP_kernel.Model_show_restraint_time_statistics(self, *args)
3335 def show_restraint_score_statistics(self, *args):
3337 show_restraint_score_statistics(Model self, _ostream out=std::cout)
3338 show_restraint_score_statistics(Model self)
3340 return _IMP_kernel.Model_show_restraint_score_statistics(self, *args)
3342 def get_restraint_statistics(self, *args):
3343 """get_restraint_statistics(Model self, Restraint r) -> RestraintStatistics"""
3344 return _IMP_kernel.Model_get_restraint_statistics(self, *args)
3346 def show_score_state_time_statistics(self, *args):
3348 show_score_state_time_statistics(Model self, _ostream out=std::cout)
3349 show_score_state_time_statistics(Model self)
3351 return _IMP_kernel.Model_show_score_state_time_statistics(self, *args)
3353 def add_attribute(self, *args):
3355 add_attribute(Model self, FloatKey attribute_key, IMP::kernel::ParticleIndex particle, IMP::Float value)
3356 add_attribute(Model self, IntKey attribute_key, IMP::kernel::ParticleIndex particle, IMP::Int value)
3357 add_attribute(Model self, IMP::kernel::IntsKey attribute_key, IMP::kernel::ParticleIndex particle, IMP::Ints value)
3358 add_attribute(Model self, StringKey attribute_key, IMP::kernel::ParticleIndex particle, IMP::String value)
3359 add_attribute(Model self, ParticleIndexesKey attribute_key, IMP::kernel::ParticleIndex particle, IMP::kernel::ParticleIndexes value)
3360 add_attribute(Model self, ParticleIndexKey attribute_key, IMP::kernel::ParticleIndex particle, IMP::kernel::ParticleIndex value)
3361 add_attribute(Model self, ObjectKey attribute_key, IMP::kernel::ParticleIndex particle, Object * value)
3362 add_attribute(Model self, IMP::kernel::WeakObjectKey attribute_key, IMP::kernel::ParticleIndex particle, Object * value)
3364 return _IMP_kernel.Model_add_attribute(self, *args)
3366 def remove_attribute(self, *args):
3368 remove_attribute(Model self, FloatKey attribute_key, IMP::kernel::ParticleIndex particle)
3369 remove_attribute(Model self, IntKey attribute_key, IMP::kernel::ParticleIndex particle)
3370 remove_attribute(Model self, IMP::kernel::IntsKey attribute_key, IMP::kernel::ParticleIndex particle)
3371 remove_attribute(Model self, StringKey attribute_key, IMP::kernel::ParticleIndex particle)
3372 remove_attribute(Model self, ParticleIndexesKey attribute_key, IMP::kernel::ParticleIndex particle)
3373 remove_attribute(Model self, ParticleIndexKey attribute_key, IMP::kernel::ParticleIndex particle)
3374 remove_attribute(Model self, ObjectKey attribute_key, IMP::kernel::ParticleIndex particle)
3375 remove_attribute(Model self, IMP::kernel::WeakObjectKey attribute_key, IMP::kernel::ParticleIndex particle)
3377 return _IMP_kernel.Model_remove_attribute(self, *args)
3379 def get_has_attribute(self, *args):
3381 get_has_attribute(Model self, FloatKey attribute_key, IMP::kernel::ParticleIndex particle) -> bool
3382 get_has_attribute(Model self, IntKey attribute_key, IMP::kernel::ParticleIndex particle) -> bool
3383 get_has_attribute(Model self, IMP::kernel::IntsKey attribute_key, IMP::kernel::ParticleIndex particle) -> bool
3384 get_has_attribute(Model self, StringKey attribute_key, IMP::kernel::ParticleIndex particle) -> bool
3385 get_has_attribute(Model self, ParticleIndexesKey attribute_key, IMP::kernel::ParticleIndex particle) -> bool
3386 get_has_attribute(Model self, ParticleIndexKey attribute_key, IMP::kernel::ParticleIndex particle) -> bool
3387 get_has_attribute(Model self, ObjectKey attribute_key, IMP::kernel::ParticleIndex particle) -> bool
3388 get_has_attribute(Model self, IMP::kernel::WeakObjectKey attribute_key, IMP::kernel::ParticleIndex particle) -> bool
3390 return _IMP_kernel.Model_get_has_attribute(self, *args)
3392 def set_attribute(self, *args):
3394 set_attribute(Model self, FloatKey attribute_key, IMP::kernel::ParticleIndex particle, IMP::Float value)
3395 set_attribute(Model self, IntKey attribute_key, IMP::kernel::ParticleIndex particle, IMP::Int value)
3396 set_attribute(Model self, IMP::kernel::IntsKey attribute_key, IMP::kernel::ParticleIndex particle, IMP::Ints value)
3397 set_attribute(Model self, StringKey attribute_key, IMP::kernel::ParticleIndex particle, IMP::String value)
3398 set_attribute(Model self, ParticleIndexesKey attribute_key, IMP::kernel::ParticleIndex particle, IMP::kernel::ParticleIndexes value)
3399 set_attribute(Model self, ParticleIndexKey attribute_key, IMP::kernel::ParticleIndex particle, IMP::kernel::ParticleIndex value)
3400 set_attribute(Model self, ObjectKey attribute_key, IMP::kernel::ParticleIndex particle, Object * value)
3401 set_attribute(Model self, IMP::kernel::WeakObjectKey attribute_key, IMP::kernel::ParticleIndex particle, Object * value)
3403 return _IMP_kernel.Model_set_attribute(self, *args)
3405 def get_attribute(self, *args):
3407 get_attribute(Model self, FloatKey attribute_key, IMP::kernel::ParticleIndex particle) -> IMP::Float
3408 get_attribute(Model self, IntKey attribute_key, IMP::kernel::ParticleIndex particle) -> IMP::Int
3409 get_attribute(Model self, IMP::kernel::IntsKey attribute_key, IMP::kernel::ParticleIndex particle) -> IMP::Ints
3410 get_attribute(Model self, StringKey attribute_key, IMP::kernel::ParticleIndex particle) -> IMP::String
3411 get_attribute(Model self, ParticleIndexesKey attribute_key, IMP::kernel::ParticleIndex particle) -> IMP::kernel::ParticleIndexes
3412 get_attribute(Model self, ParticleIndexKey attribute_key, IMP::kernel::ParticleIndex particle) -> IMP::kernel::ParticleIndex
3413 get_attribute(Model self, ObjectKey attribute_key, IMP::kernel::ParticleIndex particle) -> Object
3414 get_attribute(Model self, IMP::kernel::WeakObjectKey attribute_key, IMP::kernel::ParticleIndex particle) -> Object *
3416 return _IMP_kernel.Model_get_attribute(self, *args)
3418 def add_cache_attribute(self, *args):
3420 add_cache_attribute(Model self, FloatKey attribute_key, IMP::kernel::ParticleIndex particle, IMP::Float value)
3421 add_cache_attribute(Model self, IntKey attribute_key, IMP::kernel::ParticleIndex particle, IMP::Int value)
3422 add_cache_attribute(Model self, IMP::kernel::IntsKey attribute_key, IMP::kernel::ParticleIndex particle, IMP::Ints value)
3423 add_cache_attribute(Model self, StringKey attribute_key, IMP::kernel::ParticleIndex particle, IMP::String value)
3424 add_cache_attribute(Model self, ParticleIndexesKey attribute_key, IMP::kernel::ParticleIndex particle, IMP::kernel::ParticleIndexes value)
3425 add_cache_attribute(Model self, ParticleIndexKey attribute_key, IMP::kernel::ParticleIndex particle, IMP::kernel::ParticleIndex value)
3426 add_cache_attribute(Model self, ObjectKey attribute_key, IMP::kernel::ParticleIndex particle, Object * value)
3427 add_cache_attribute(Model self, IMP::kernel::WeakObjectKey attribute_key, IMP::kernel::ParticleIndex particle, Object * value)
3429 return _IMP_kernel.Model_add_cache_attribute(self, *args)
3431 def set_is_optimized(self, *args):
3432 """set_is_optimized(Model self, FloatKey arg2, IMP::kernel::ParticleIndex arg3, bool arg4)"""
3433 return _IMP_kernel.Model_set_is_optimized(self, *args)
3435 def add_data(self, *args):
3436 """add_data(Model self, IMP::kernel::ModelKey mk, Object o)"""
3437 return _IMP_kernel.Model_add_data(self, *args)
3439 def get_data(self, *args):
3440 """get_data(Model self, IMP::kernel::ModelKey mk) -> Object"""
3441 return _IMP_kernel.Model_get_data(self, *args)
3443 def remove_data(self, *args):
3444 """remove_data(Model self, IMP::kernel::ModelKey mk)"""
3445 return _IMP_kernel.Model_remove_data(self, *args)
3447 def get_has_data(self, *args):
3448 """get_has_data(Model self, IMP::kernel::ModelKey mk) -> bool"""
3449 return _IMP_kernel.Model_get_has_data(self, *args)
3451 def get_number_of_particles(self):
3452 """get_number_of_particles(Model self) -> unsigned int"""
3453 return _IMP_kernel.Model_get_number_of_particles(self)
3456 """get_particles(Model self) -> IMP::kernel::ParticlesTemp"""
3457 return _IMP_kernel.Model_get_particles(self)
3459 def get_particle(self, *args):
3460 """get_particle(Model self, IMP::kernel::ParticleIndex p) -> Particle"""
3461 return _IMP_kernel.Model_get_particle(self, *args)
3463 def get_model_objects(self):
3464 """get_model_objects(Model self) -> IMP::kernel::ModelObjectsTemp"""
3465 return _IMP_kernel.Model_get_model_objects(self)
3468 """__str__(Model self) -> std::string"""
3469 return _IMP_kernel.Model___str__(self)
3472 """__repr__(Model self) -> std::string"""
3473 return _IMP_kernel.Model___repr__(self)
3476 return _object_cast_to_Model(o)
3477 get_from = staticmethod(get_from)
3479 Model_swigregister = _IMP_kernel.Model_swigregister
3480 Model_swigregister(Model)
3483 """Proxy of C++ IMP::kernel::Decorator class"""
3484 __swig_setmethods__ = {}
3485 for _s
in [IMP.base._Value]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
3486 __setattr__ =
lambda self, name, value: _swig_setattr(self, Decorator, name, value)
3487 __swig_getmethods__ = {}
3488 for _s
in [IMP.base._Value]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
3489 __getattr__ =
lambda self, name: _swig_getattr(self, Decorator, name)
3490 __repr__ = _swig_repr
3491 def __init__(self, *args):
3493 __init__(IMP::kernel::Decorator self, Model m, IMP::kernel::ParticleIndex pi) -> Decorator
3494 __init__(IMP::kernel::Decorator self, Particle p) -> Decorator
3495 __init__(IMP::kernel::Decorator self) -> Decorator
3497 this = _IMP_kernel.new_Decorator(*args)
3498 try: self.this.append(this)
3499 except: self.this = this
3500 def get_particle_index(self):
3501 """get_particle_index(Decorator self) -> IMP::kernel::ParticleIndex"""
3502 return _IMP_kernel.Decorator_get_particle_index(self)
3504 def __ne__(self, *args):
3505 """__ne__(Decorator self, Object o) -> bool"""
3506 return _IMP_kernel.Decorator___ne__(self, *args)
3508 def __lt__(self, *args):
3509 """__lt__(Decorator self, Object o) -> bool"""
3510 return _IMP_kernel.Decorator___lt__(self, *args)
3512 def __gt__(self, *args):
3513 """__gt__(Decorator self, Object o) -> bool"""
3514 return _IMP_kernel.Decorator___gt__(self, *args)
3516 def __ge__(self, *args):
3517 """__ge__(Decorator self, Object o) -> bool"""
3518 return _IMP_kernel.Decorator___ge__(self, *args)
3520 def __le__(self, *args):
3521 """__le__(Decorator self, Object o) -> bool"""
3522 return _IMP_kernel.Decorator___le__(self, *args)
3524 def get_particle(self):
3525 """get_particle(Decorator self) -> Particle"""
3526 return _IMP_kernel.Decorator_get_particle(self)
3528 def get_model(self):
3529 """get_model(Decorator self) -> Model"""
3530 return _IMP_kernel.Decorator_get_model(self)
3533 """__hash__(Decorator self) -> std::size_t"""
3534 return _IMP_kernel.Decorator___hash__(self)
3536 def __eq__(self, *args):
3538 __eq__(Decorator self, Object o) -> bool
3539 __eq__(Decorator self, Decorator o) -> bool
3540 __eq__(Decorator self, Particle o) -> bool
3542 return _IMP_kernel.Decorator___eq__(self, *args)
3544 __swig_destroy__ = _IMP_kernel.delete_Decorator
3545 __del__ =
lambda self :
None;
3546 Decorator_swigregister = _IMP_kernel.Decorator_swigregister
3547 Decorator_swigregister(Decorator)
3550 def check_particle(*args):
3551 """check_particle(Particle p)"""
3552 return _IMP_kernel.check_particle(*args)
3554 """Proxy of C++ IMP::kernel::UnaryFunction class"""
3555 __swig_setmethods__ = {}
3556 for _s
in [
IMP.base.Object]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
3557 __setattr__ =
lambda self, name, value: _swig_setattr(self, UnaryFunction, name, value)
3558 __swig_getmethods__ = {}
3559 for _s
in [
IMP.base.Object]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
3560 __getattr__ =
lambda self, name: _swig_getattr(self, UnaryFunction, name)
3561 def __init__(self, name="UnaryFunction%1%"):
3563 __init__(IMP::kernel::UnaryFunction self, std::string name="UnaryFunction%1%") -> UnaryFunction
3564 __init__(IMP::kernel::UnaryFunction self) -> UnaryFunction
3566 if self.__class__ == UnaryFunction:
3570 this = _IMP_kernel.new_UnaryFunction(_self, name)
3571 try: self.this.append(this)
3572 except: self.this = this
3573 if self.__class__ != UnaryFunction:
3575 IMP.base._director_objects.register(self)
3579 def evaluate(self, *args):
3580 """evaluate(UnaryFunction self, double feature) -> double"""
3581 return _IMP_kernel.UnaryFunction_evaluate(self, *args)
3583 def evaluate_with_derivative(self, *args):
3584 """evaluate_with_derivative(UnaryFunction self, double feature) -> IMP::DerivativePair"""
3585 return _IMP_kernel.UnaryFunction_evaluate_with_derivative(self, *args)
3587 __swig_destroy__ = _IMP_kernel.delete_UnaryFunction
3588 __del__ =
lambda self :
None;
3590 """__str__(UnaryFunction self) -> std::string"""
3591 return _IMP_kernel.UnaryFunction___str__(self)
3594 """__repr__(UnaryFunction self) -> std::string"""
3595 return _IMP_kernel.UnaryFunction___repr__(self)
3598 return _object_cast_to_UnaryFunction(o)
3599 get_from = staticmethod(get_from)
3601 def get_type_name(self):
3602 return self.__class__.__name__
3603 def do_show(self, out):
3605 def get_version_info(self):
3606 if"IMP::kernel" ==
"IMP":
3607 return VersionInfo(
"python",
"0")
3609 return IMP.VersionInfo(
"python",
"0")
3611 return _object_cast_to_UnaryFunction(o)
3612 get_from = staticmethod(get_from)
3614 def __disown__(self):
3616 _IMP_kernel.disown_UnaryFunction(self)
3617 return weakref_proxy(self)
3618 UnaryFunction_swigregister = _IMP_kernel.UnaryFunction_swigregister
3619 UnaryFunction_swigregister(UnaryFunction)
3622 """Proxy of C++ IMP::kernel::OptimizerState class"""
3623 __swig_setmethods__ = {}
3624 for _s
in [
IMP.base.Object]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
3625 __setattr__ =
lambda self, name, value: _swig_setattr(self, OptimizerState, name, value)
3626 __swig_getmethods__ = {}
3627 for _s
in [
IMP.base.Object]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
3628 __getattr__ =
lambda self, name: _swig_getattr(self, OptimizerState, name)
3629 def __init__(self, name="OptimizerState %1%"):
3631 __init__(IMP::kernel::OptimizerState self, std::string name="OptimizerState %1%") -> OptimizerState
3632 __init__(IMP::kernel::OptimizerState self) -> OptimizerState
3634 if self.__class__ == OptimizerState:
3638 this = _IMP_kernel.new_OptimizerState(_self, name)
3639 try: self.this.append(this)
3640 except: self.this = this
3641 if self.__class__ != OptimizerState:
3643 IMP.base._director_objects.register(self)
3648 """update(OptimizerState self)"""
3649 return _IMP_kernel.OptimizerState_update(self)
3651 def set_is_optimizing(self, *args):
3652 """set_is_optimizing(OptimizerState self, bool arg0)"""
3653 return _IMP_kernel.OptimizerState_set_is_optimizing(self, *args)
3655 def get_optimizer(self):
3656 """get_optimizer(OptimizerState self) -> Optimizer"""
3657 return _IMP_kernel.OptimizerState_get_optimizer(self)
3659 __swig_destroy__ = _IMP_kernel.delete_OptimizerState
3660 __del__ =
lambda self :
None;
3661 __swig_setmethods__[
"optimizer_"] = _IMP_kernel.OptimizerState_optimizer__set
3662 __swig_getmethods__[
"optimizer_"] = _IMP_kernel.OptimizerState_optimizer__get
3663 if _newclass:optimizer_ = _swig_property(_IMP_kernel.OptimizerState_optimizer__get, _IMP_kernel.OptimizerState_optimizer__set)
3665 """__str__(OptimizerState self) -> std::string"""
3666 return _IMP_kernel.OptimizerState___str__(self)
3669 """__repr__(OptimizerState self) -> std::string"""
3670 return _IMP_kernel.OptimizerState___repr__(self)
3673 return _object_cast_to_OptimizerState(o)
3674 get_from = staticmethod(get_from)
3676 def get_type_name(self):
3677 return self.__class__.__name__
3678 def do_show(self, out):
3680 def get_version_info(self):
3681 if"IMP::kernel" ==
"IMP":
3682 return VersionInfo(
"python",
"0")
3684 return IMP.VersionInfo(
"python",
"0")
3686 return _object_cast_to_OptimizerState(o)
3687 get_from = staticmethod(get_from)
3689 def __disown__(self):
3691 _IMP_kernel.disown_OptimizerState(self)
3692 return weakref_proxy(self)
3693 OptimizerState_swigregister = _IMP_kernel.OptimizerState_swigregister
3694 OptimizerState_swigregister(OptimizerState)
3697 """Proxy of C++ IMP::kernel::Refiner class"""
3698 __swig_setmethods__ = {}
3699 for _s
in [
IMP.base.Object]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
3700 __setattr__ =
lambda self, name, value: _swig_setattr(self, Refiner, name, value)
3701 __swig_getmethods__ = {}
3702 for _s
in [
IMP.base.Object]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
3703 __getattr__ =
lambda self, name: _swig_getattr(self, Refiner, name)
3704 def __init__(self, name="Refiner %1%"):
3706 __init__(IMP::kernel::Refiner self, std::string name="Refiner %1%") -> Refiner
3707 __init__(IMP::kernel::Refiner self) -> Refiner
3709 if self.__class__ == Refiner:
3713 this = _IMP_kernel.new_Refiner(_self, name)
3714 try: self.this.append(this)
3715 except: self.this = this
3716 if self.__class__ != Refiner:
3718 IMP.base._director_objects.register(self)
3722 def get_can_refine(self, *args):
3723 """get_can_refine(Refiner self, Particle arg0) -> bool"""
3724 return _IMP_kernel.Refiner_get_can_refine(self, *args)
3726 def get_refined(self, *args):
3728 get_refined(Refiner self, Particle a) -> IMP::kernel::ParticlesTemp const
3729 get_refined(Refiner self, Particle a, unsigned int i) -> Particle
3731 return _IMP_kernel.Refiner_get_refined(self, *args)
3733 def get_number_of_refined(self, *args):
3734 """get_number_of_refined(Refiner self, Particle a) -> unsigned int"""
3735 return _IMP_kernel.Refiner_get_number_of_refined(self, *args)
3738 """get_input_particles(Refiner self, Particle p) -> IMP::kernel::ParticlesTemp"""
3739 return _IMP_kernel.Refiner_get_input_particles(self, *args)
3742 """get_input_containers(Refiner self, Particle p) -> IMP::kernel::ContainersTemp"""
3743 return _IMP_kernel.Refiner_get_input_containers(self, *args)
3745 def get_inputs(self, *args):
3746 """get_inputs(Refiner self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
3747 return _IMP_kernel.Refiner_get_inputs(self, *args)
3749 def _do_get_inputs(self, *args):
3750 """_do_get_inputs(Refiner self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
3751 return _IMP_kernel.Refiner__do_get_inputs(self, *args)
3754 """__str__(Refiner self) -> std::string"""
3755 return _IMP_kernel.Refiner___str__(self)
3758 """__repr__(Refiner self) -> std::string"""
3759 return _IMP_kernel.Refiner___repr__(self)
3762 return _object_cast_to_Refiner(o)
3763 get_from = staticmethod(get_from)
3765 def get_type_name(self):
3766 return self.__class__.__name__
3767 def do_show(self, out):
3769 def get_version_info(self):
3770 if"IMP::kernel" ==
"IMP":
3771 return VersionInfo(
"python",
"0")
3773 return IMP.VersionInfo(
"python",
"0")
3775 return _object_cast_to_Refiner(o)
3776 get_from = staticmethod(get_from)
3778 __swig_destroy__ = _IMP_kernel.delete_Refiner
3779 __del__ =
lambda self :
None;
3780 def __disown__(self):
3782 _IMP_kernel.disown_Refiner(self)
3783 return weakref_proxy(self)
3784 Refiner_swigregister = _IMP_kernel.Refiner_swigregister
3785 Refiner_swigregister(Refiner)
3788 """Proxy of C++ IMP::kernel::Optimizer class"""
3789 __swig_setmethods__ = {}
3790 for _s
in [
IMP.base.Object]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
3791 __setattr__ =
lambda self, name, value: _swig_setattr(self, Optimizer, name, value)
3792 __swig_getmethods__ = {}
3793 for _s
in [
IMP.base.Object]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
3794 __getattr__ =
lambda self, name: _swig_getattr(self, Optimizer, name)
3795 def __init__(self, *args):
3797 __init__(IMP::kernel::Optimizer self) -> Optimizer
3798 __init__(IMP::kernel::Optimizer self, Model m, std::string name="Optimizer %1%") -> Optimizer
3799 __init__(IMP::kernel::Optimizer self, Model m) -> Optimizer
3801 if self.__class__ == Optimizer:
3805 this = _IMP_kernel.new_Optimizer(_self, *args)
3806 try: self.this.append(this)
3807 except: self.this = this
3808 if self.__class__ != Optimizer:
3810 IMP.base._director_objects.register(self)
3814 def optimize(self, *args):
3815 """optimize(Optimizer self, unsigned int max_steps) -> double"""
3816 return _IMP_kernel.Optimizer_optimize(self, *args)
3818 def set_score_threshold(self, *args):
3819 """set_score_threshold(Optimizer self, double s)"""
3820 return _IMP_kernel.Optimizer_set_score_threshold(self, *args)
3822 def get_score_threshold(self):
3823 """get_score_threshold(Optimizer self) -> double"""
3824 return _IMP_kernel.Optimizer_get_score_threshold(self)
3826 def set_stop_on_good_score(self, *args):
3827 """set_stop_on_good_score(Optimizer self, bool tf)"""
3828 return _IMP_kernel.Optimizer_set_stop_on_good_score(self, *args)
3830 def get_stop_on_good_score(self):
3831 """get_stop_on_good_score(Optimizer self) -> bool"""
3832 return _IMP_kernel.Optimizer_get_stop_on_good_score(self)
3834 def get_last_score(self):
3835 """get_last_score(Optimizer self) -> double"""
3836 return _IMP_kernel.Optimizer_get_last_score(self)
3838 def get_scoring_function(self):
3839 """get_scoring_function(Optimizer self) -> ScoringFunction"""
3840 return _IMP_kernel.Optimizer_get_scoring_function(self)
3842 def get_model(self):
3843 """get_model(Optimizer self) -> Model"""
3844 return _IMP_kernel.Optimizer_get_model(self)
3846 def set_model(self, *args):
3847 """set_model(Optimizer self, Model m)"""
3848 return _IMP_kernel.Optimizer_set_model(self, *args)
3850 def show(self, *args):
3852 show(Optimizer self, _ostream out=std::cout)
3853 show(Optimizer self)
3855 return _IMP_kernel.Optimizer_show(self, *args)
3857 def remove_optimizer_state(self, *args):
3858 """remove_optimizer_state(Optimizer self, OptimizerState d)"""
3859 return _IMP_kernel.Optimizer_remove_optimizer_state(self, *args)
3861 def remove_optimizer_states(self, *args):
3862 """remove_optimizer_states(Optimizer self, IMP::kernel::OptimizerStates const & d)"""
3863 return _IMP_kernel.Optimizer_remove_optimizer_states(self, *args)
3865 def set_optimizer_states(self, *args):
3866 """set_optimizer_states(Optimizer self, IMP::kernel::OptimizerStates const & ps)"""
3867 return _IMP_kernel.Optimizer_set_optimizer_states(self, *args)
3869 def set_optimizer_states_order(self, *args):
3870 """set_optimizer_states_order(Optimizer self, IMP::kernel::OptimizerStates const & objs)"""
3871 return _IMP_kernel.Optimizer_set_optimizer_states_order(self, *args)
3873 def add_optimizer_state(self, *args):
3874 """add_optimizer_state(Optimizer self, OptimizerState obj) -> unsigned int"""
3875 return _IMP_kernel.Optimizer_add_optimizer_state(self, *args)
3877 def add_optimizer_states(self, *args):
3878 """add_optimizer_states(Optimizer self, IMP::kernel::OptimizerStates const & objs)"""
3879 return _IMP_kernel.Optimizer_add_optimizer_states(self, *args)
3881 def clear_optimizer_states(self):
3882 """clear_optimizer_states(Optimizer self)"""
3883 return _IMP_kernel.Optimizer_clear_optimizer_states(self)
3885 def get_number_of_optimizer_states(self):
3886 """get_number_of_optimizer_states(Optimizer self) -> unsigned int"""
3887 return _IMP_kernel.Optimizer_get_number_of_optimizer_states(self)
3889 def get_has_optimizer_states(self):
3890 """get_has_optimizer_states(Optimizer self) -> bool"""
3891 return _IMP_kernel.Optimizer_get_has_optimizer_states(self)
3893 def get_optimizer_state(self, *args):
3894 """get_optimizer_state(Optimizer self, unsigned int i) -> OptimizerState"""
3895 return _IMP_kernel.Optimizer_get_optimizer_state(self, *args)
3897 def get_optimizer_states(self):
3898 """get_optimizer_states(Optimizer self) -> IMP::kernel::OptimizerStates"""
3899 return _IMP_kernel.Optimizer_get_optimizer_states(self)
3901 def reserve_optimizer_states(self, *args):
3902 """reserve_optimizer_states(Optimizer self, unsigned int sz)"""
3903 return _IMP_kernel.Optimizer_reserve_optimizer_states(self, *args)
3905 def set_scoring_function(self, *args):
3906 """set_scoring_function(Optimizer self, _ScoringFunctionAdaptor sf)"""
3907 return _IMP_kernel.Optimizer_set_scoring_function(self, *args)
3909 def set_restraints(self, *args):
3910 """set_restraints(Optimizer self, IMP::kernel::RestraintsTemp const & rs)"""
3911 return _IMP_kernel.Optimizer_set_restraints(self, *args)
3913 __swig_destroy__ = _IMP_kernel.delete_Optimizer
3915 """__del__(IMP::kernel::Optimizer self)"""
3917 IMP.base._director_objects.cleanup()
3922 def do_optimize(self, *args):
3923 """do_optimize(Optimizer self, unsigned int ns) -> double"""
3924 return _IMP_kernel.Optimizer_do_optimize(self, *args)
3926 def update_states(self):
3927 """update_states(Optimizer self)"""
3928 return _IMP_kernel.Optimizer_update_states(self)
3930 def get_optimized_attributes(self):
3931 """get_optimized_attributes(Optimizer self) -> IMP::kernel::FloatIndexes"""
3932 return _IMP_kernel.Optimizer_get_optimized_attributes(self)
3934 def _set_value(self, *args):
3935 """_set_value(Optimizer self, FloatIndex fi, double v)"""
3936 return _IMP_kernel.Optimizer__set_value(self, *args)
3938 def _get_value(self, *args):
3939 """_get_value(Optimizer self, FloatIndex fi) -> IMP::Float"""
3940 return _IMP_kernel.Optimizer__get_value(self, *args)
3942 def _get_derivative(self, *args):
3943 """_get_derivative(Optimizer self, FloatIndex fi) -> IMP::Float"""
3944 return _IMP_kernel.Optimizer__get_derivative(self, *args)
3946 def _width(self, *args):
3947 """_width(Optimizer self, FloatKey k) -> double"""
3948 return _IMP_kernel.Optimizer__width(self, *args)
3950 def _set_scaled_value(self, *args):
3951 """_set_scaled_value(Optimizer self, FloatIndex fi, IMP::Float v)"""
3952 return _IMP_kernel.Optimizer__set_scaled_value(self, *args)
3954 def _get_scaled_value(self, *args):
3955 """_get_scaled_value(Optimizer self, FloatIndex fi) -> double"""
3956 return _IMP_kernel.Optimizer__get_scaled_value(self, *args)
3958 def _get_scaled_derivative(self, *args):
3959 """_get_scaled_derivative(Optimizer self, FloatIndex fi) -> double"""
3960 return _IMP_kernel.Optimizer__get_scaled_derivative(self, *args)
3962 def _clear_range_cache(self):
3963 """_clear_range_cache(Optimizer self)"""
3964 return _IMP_kernel.Optimizer__clear_range_cache(self)
3966 def _get_restraints(self):
3967 """_get_restraints(Optimizer self) -> IMP::kernel::Restraints"""
3968 return _IMP_kernel.Optimizer__get_restraints(self)
3971 """__str__(Optimizer self) -> std::string"""
3972 return _IMP_kernel.Optimizer___str__(self)
3975 """__repr__(Optimizer self) -> std::string"""
3976 return _IMP_kernel.Optimizer___repr__(self)
3979 return _object_cast_to_Optimizer(o)
3980 get_from = staticmethod(get_from)
3982 def get_type_name(self):
3983 return self.__class__.__name__
3984 def do_show(self, out):
3986 def get_version_info(self):
3987 if"IMP::kernel" ==
"IMP":
3988 return VersionInfo(
"python",
"0")
3990 return IMP.VersionInfo(
"python",
"0")
3992 return _object_cast_to_Optimizer(o)
3993 get_from = staticmethod(get_from)
3995 def __disown__(self):
3997 _IMP_kernel.disown_Optimizer(self)
3998 return weakref_proxy(self)
3999 Optimizer_swigregister = _IMP_kernel.Optimizer_swigregister
4000 Optimizer_swigregister(Optimizer)
4003 """Proxy of C++ IMP::kernel::ConfigurationSet class"""
4004 __swig_setmethods__ = {}
4005 for _s
in [
IMP.base.Object]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
4006 __setattr__ =
lambda self, name, value: _swig_setattr(self, ConfigurationSet, name, value)
4007 __swig_getmethods__ = {}
4008 for _s
in [
IMP.base.Object]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
4009 __getattr__ =
lambda self, name: _swig_getattr(self, ConfigurationSet, name)
4010 def __init__(self, *args):
4012 __init__(IMP::kernel::ConfigurationSet self, Model m, std::string name="ConfigurationSet %1%") -> ConfigurationSet
4013 __init__(IMP::kernel::ConfigurationSet self, Model m) -> ConfigurationSet
4015 this = _IMP_kernel.new_ConfigurationSet(*args)
4016 try: self.this.append(this)
4017 except: self.this = this
4018 def save_configuration(self):
4019 """save_configuration(ConfigurationSet self)"""
4020 return _IMP_kernel.ConfigurationSet_save_configuration(self)
4022 def get_number_of_configurations(self):
4023 """get_number_of_configurations(ConfigurationSet self) -> unsigned int"""
4024 return _IMP_kernel.ConfigurationSet_get_number_of_configurations(self)
4026 def load_configuration(self, *args):
4027 """load_configuration(ConfigurationSet self, int i)"""
4028 return _IMP_kernel.ConfigurationSet_load_configuration(self, *args)
4030 def remove_configuration(self, *args):
4031 """remove_configuration(ConfigurationSet self, unsigned int i)"""
4032 return _IMP_kernel.ConfigurationSet_remove_configuration(self, *args)
4034 def get_model(self):
4035 """get_model(ConfigurationSet self) -> Model"""
4036 return _IMP_kernel.ConfigurationSet_get_model(self)
4038 def get_version_info(self):
4039 """get_version_info(ConfigurationSet self) -> VersionInfo"""
4040 return _IMP_kernel.ConfigurationSet_get_version_info(self)
4042 __swig_destroy__ = _IMP_kernel.delete_ConfigurationSet
4043 __del__ =
lambda self :
None;
4045 """__str__(ConfigurationSet self) -> std::string"""
4046 return _IMP_kernel.ConfigurationSet___str__(self)
4049 """__repr__(ConfigurationSet self) -> std::string"""
4050 return _IMP_kernel.ConfigurationSet___repr__(self)
4053 return _object_cast_to_ConfigurationSet(o)
4054 get_from = staticmethod(get_from)
4056 ConfigurationSet_swigregister = _IMP_kernel.ConfigurationSet_swigregister
4057 ConfigurationSet_swigregister(ConfigurationSet)
4060 """Proxy of C++ IMP::kernel::SaveToConfigurationSetOptimizerState class"""
4061 __swig_setmethods__ = {}
4062 for _s
in [OptimizerState]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
4063 __setattr__ =
lambda self, name, value: _swig_setattr(self, SaveToConfigurationSetOptimizerState, name, value)
4064 __swig_getmethods__ = {}
4065 for _s
in [OptimizerState]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
4066 __getattr__ =
lambda self, name: _swig_getattr(self, SaveToConfigurationSetOptimizerState, name)
4067 def __init__(self, *args):
4068 """__init__(IMP::kernel::SaveToConfigurationSetOptimizerState self, ConfigurationSet cs, std::string file_name) -> SaveToConfigurationSetOptimizerState"""
4069 this = _IMP_kernel.new_SaveToConfigurationSetOptimizerState(*args)
4070 try: self.this.append(this)
4071 except: self.this = this
4072 def set_skip_steps(self, *args):
4073 """set_skip_steps(SaveToConfigurationSetOptimizerState self, unsigned int k)"""
4074 return _IMP_kernel.SaveToConfigurationSetOptimizerState_set_skip_steps(self, *args)
4076 def set_period(self, *args):
4077 """set_period(SaveToConfigurationSetOptimizerState self, unsigned int p)"""
4078 return _IMP_kernel.SaveToConfigurationSetOptimizerState_set_period(self, *args)
4080 def write(self, *args):
4082 write(SaveToConfigurationSetOptimizerState self, std::string file_name, unsigned int call=0, bool append=False)
4083 write(SaveToConfigurationSetOptimizerState self, std::string file_name, unsigned int call=0)
4084 write(SaveToConfigurationSetOptimizerState self, std::string file_name)
4086 return _IMP_kernel.SaveToConfigurationSetOptimizerState_write(self, *args)
4088 def get_version_info(self):
4089 """get_version_info(SaveToConfigurationSetOptimizerState self) -> VersionInfo"""
4090 return _IMP_kernel.SaveToConfigurationSetOptimizerState_get_version_info(self)
4092 __swig_destroy__ = _IMP_kernel.delete_SaveToConfigurationSetOptimizerState
4093 __del__ =
lambda self :
None;
4095 """__str__(SaveToConfigurationSetOptimizerState self) -> std::string"""
4096 return _IMP_kernel.SaveToConfigurationSetOptimizerState___str__(self)
4099 """__repr__(SaveToConfigurationSetOptimizerState self) -> std::string"""
4100 return _IMP_kernel.SaveToConfigurationSetOptimizerState___repr__(self)
4103 return _object_cast_to_SaveToConfigurationSetOptimizerState(o)
4104 get_from = staticmethod(get_from)
4106 SaveToConfigurationSetOptimizerState_swigregister = _IMP_kernel.SaveToConfigurationSetOptimizerState_swigregister
4107 SaveToConfigurationSetOptimizerState_swigregister(SaveToConfigurationSetOptimizerState)
4110 """Proxy of C++ IMP::kernel::Configuration class"""
4111 __swig_setmethods__ = {}
4112 for _s
in [
IMP.base.Object]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
4113 __setattr__ =
lambda self, name, value: _swig_setattr(self, Configuration, name, value)
4114 __swig_getmethods__ = {}
4115 for _s
in [
IMP.base.Object]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
4116 __getattr__ =
lambda self, name: _swig_getattr(self, Configuration, name)
4117 def __init__(self, *args):
4119 __init__(IMP::kernel::Configuration self, Model m, std::string name="Configuration %1%") -> Configuration
4120 __init__(IMP::kernel::Configuration self, Model m) -> Configuration
4121 __init__(IMP::kernel::Configuration self, Model m, Configuration base, std::string name="Configuration %1%") -> Configuration
4122 __init__(IMP::kernel::Configuration self, Model m, Configuration base) -> Configuration
4124 this = _IMP_kernel.new_Configuration(*args)
4125 try: self.this.append(this)
4126 except: self.this = this
4127 def load_configuration(self):
4128 """load_configuration(Configuration self)"""
4129 return _IMP_kernel.Configuration_load_configuration(self)
4131 def swap_configuration(self):
4132 """swap_configuration(Configuration self)"""
4133 return _IMP_kernel.Configuration_swap_configuration(self)
4135 def get_version_info(self):
4136 """get_version_info(Configuration self) -> VersionInfo"""
4137 return _IMP_kernel.Configuration_get_version_info(self)
4139 def do_show(self, *args):
4140 """do_show(Configuration self, _ostream out)"""
4141 return _IMP_kernel.Configuration_do_show(self, *args)
4143 __swig_destroy__ = _IMP_kernel.delete_Configuration
4144 __del__ =
lambda self :
None;
4146 """__str__(Configuration self) -> std::string"""
4147 return _IMP_kernel.Configuration___str__(self)
4150 """__repr__(Configuration self) -> std::string"""
4151 return _IMP_kernel.Configuration___repr__(self)
4154 return _object_cast_to_Configuration(o)
4155 get_from = staticmethod(get_from)
4157 Configuration_swigregister = _IMP_kernel.Configuration_swigregister
4158 Configuration_swigregister(Configuration)
4161 """Proxy of C++ IMP::kernel::Sampler class"""
4162 __swig_setmethods__ = {}
4163 for _s
in [
IMP.base.Object]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
4164 __setattr__ =
lambda self, name, value: _swig_setattr(self, Sampler, name, value)
4165 __swig_getmethods__ = {}
4166 for _s
in [
IMP.base.Object]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
4167 __getattr__ =
lambda self, name: _swig_getattr(self, Sampler, name)
4168 def __init__(self, *args):
4170 __init__(IMP::kernel::Sampler self, Model m, std::string name="Sampler %1%") -> Sampler
4171 __init__(IMP::kernel::Sampler self, Model m) -> Sampler
4173 if self.__class__ == Sampler:
4177 this = _IMP_kernel.new_Sampler(_self, *args)
4178 try: self.this.append(this)
4179 except: self.this = this
4180 if self.__class__ != Sampler:
4182 IMP.base._director_objects.register(self)
4186 def get_sample(self):
4187 """get_sample(Sampler self) -> ConfigurationSet"""
4188 return _IMP_kernel.Sampler_get_sample(self)
4190 def create_sample(self):
4191 """create_sample(Sampler self) -> ConfigurationSet"""
4192 return _IMP_kernel.Sampler_create_sample(self)
4194 def get_scoring_function(self):
4195 """get_scoring_function(Sampler self) -> ScoringFunction"""
4196 return _IMP_kernel.Sampler_get_scoring_function(self)
4198 def set_scoring_function(self, *args):
4199 """set_scoring_function(Sampler self, _ScoringFunctionAdaptor sf)"""
4200 return _IMP_kernel.Sampler_set_scoring_function(self, *args)
4202 def get_model(self):
4203 """get_model(Sampler self) -> Model"""
4204 return _IMP_kernel.Sampler_get_model(self)
4206 def do_sample(self):
4207 """do_sample(Sampler self) -> ConfigurationSet"""
4208 return _IMP_kernel.Sampler_do_sample(self)
4210 __swig_destroy__ = _IMP_kernel.delete_Sampler
4211 __del__ =
lambda self :
None;
4213 """__str__(Sampler self) -> std::string"""
4214 return _IMP_kernel.Sampler___str__(self)
4217 """__repr__(Sampler self) -> std::string"""
4218 return _IMP_kernel.Sampler___repr__(self)
4221 return _object_cast_to_Sampler(o)
4222 get_from = staticmethod(get_from)
4224 def get_type_name(self):
4225 return self.__class__.__name__
4226 def do_show(self, out):
4228 def get_version_info(self):
4229 if"IMP::kernel" ==
"IMP":
4230 return VersionInfo(
"python",
"0")
4232 return IMP.VersionInfo(
"python",
"0")
4234 return _object_cast_to_Sampler(o)
4235 get_from = staticmethod(get_from)
4237 def __disown__(self):
4239 _IMP_kernel.disown_Sampler(self)
4240 return weakref_proxy(self)
4241 Sampler_swigregister = _IMP_kernel.Sampler_swigregister
4242 Sampler_swigregister(Sampler)
4245 """Proxy of C++ IMP::kernel::PairModifier class"""
4246 __swig_setmethods__ = {}
4247 for _s
in [
IMP.base.Object]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
4248 __setattr__ =
lambda self, name, value: _swig_setattr(self, PairModifier, name, value)
4249 __swig_getmethods__ = {}
4250 for _s
in [
IMP.base.Object]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
4251 __getattr__ =
lambda self, name: _swig_getattr(self, PairModifier, name)
4252 def __init__(self, name="PairModifier %1%"):
4254 __init__(IMP::kernel::PairModifier self, std::string name="PairModifier %1%") -> PairModifier
4255 __init__(IMP::kernel::PairModifier self) -> PairModifier
4257 if self.__class__ == PairModifier:
4261 this = _IMP_kernel.new_PairModifier(_self, name)
4262 try: self.this.append(this)
4263 except: self.this = this
4264 if self.__class__ != PairModifier:
4266 IMP.base._director_objects.register(self)
4270 def apply(self, *args):
4271 """apply(PairModifier self, IMP::kernel::ParticlePair const & arg0)"""
4272 return _IMP_kernel.PairModifier_apply(self, *args)
4274 def apply_index(self, *args):
4275 """apply_index(PairModifier self, Model m, IMP::kernel::ParticleIndexPair const & v)"""
4276 return _IMP_kernel.PairModifier_apply_index(self, *args)
4278 def apply_indexes(self, *args):
4279 """apply_indexes(PairModifier self, Model m, IMP::kernel::ParticleIndexPairs const & o, unsigned int lower_bound, unsigned int upper_bound)"""
4280 return _IMP_kernel.PairModifier_apply_indexes(self, *args)
4283 """get_input_particles(PairModifier self, Particle p) -> IMP::kernel::ParticlesTemp"""
4284 return _IMP_kernel.PairModifier_get_input_particles(self, *args)
4287 """get_input_containers(PairModifier self, Particle p) -> IMP::kernel::ContainersTemp"""
4288 return _IMP_kernel.PairModifier_get_input_containers(self, *args)
4290 def get_inputs(self, *args):
4291 """get_inputs(PairModifier self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
4292 return _IMP_kernel.PairModifier_get_inputs(self, *args)
4294 def _do_get_inputs(self, *args):
4295 """_do_get_inputs(PairModifier self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
4296 return _IMP_kernel.PairModifier__do_get_inputs(self, *args)
4299 """get_output_particles(PairModifier self, Particle p) -> IMP::kernel::ParticlesTemp"""
4300 return _IMP_kernel.PairModifier_get_output_particles(self, *args)
4303 """get_output_containers(PairModifier self, Particle p) -> IMP::kernel::ContainersTemp"""
4304 return _IMP_kernel.PairModifier_get_output_containers(self, *args)
4306 def get_outputs(self, *args):
4307 """get_outputs(PairModifier self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
4308 return _IMP_kernel.PairModifier_get_outputs(self, *args)
4310 def _do_get_outputs(self, *args):
4311 """_do_get_outputs(PairModifier self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
4312 return _IMP_kernel.PairModifier__do_get_outputs(self, *args)
4315 """__str__(PairModifier self) -> std::string"""
4316 return _IMP_kernel.PairModifier___str__(self)
4319 """__repr__(PairModifier self) -> std::string"""
4320 return _IMP_kernel.PairModifier___repr__(self)
4323 return _object_cast_to_PairModifier(o)
4324 get_from = staticmethod(get_from)
4326 def get_type_name(self):
4327 return self.__class__.__name__
4328 def do_show(self, out):
4330 def get_version_info(self):
4331 if"IMP::kernel" ==
"IMP":
4332 return VersionInfo(
"python",
"0")
4334 return IMP.VersionInfo(
"python",
"0")
4336 return _object_cast_to_PairModifier(o)
4337 get_from = staticmethod(get_from)
4339 __swig_destroy__ = _IMP_kernel.delete_PairModifier
4340 __del__ =
lambda self :
None;
4341 def __disown__(self):
4343 _IMP_kernel.disown_PairModifier(self)
4344 return weakref_proxy(self)
4345 PairModifier_swigregister = _IMP_kernel.PairModifier_swigregister
4346 PairModifier_swigregister(PairModifier)
4349 """Proxy of C++ IMP::kernel::PairScore class"""
4350 __swig_setmethods__ = {}
4351 for _s
in [
IMP.base.Object]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
4352 __setattr__ =
lambda self, name, value: _swig_setattr(self, PairScore, name, value)
4353 __swig_getmethods__ = {}
4354 for _s
in [
IMP.base.Object]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
4355 __getattr__ =
lambda self, name: _swig_getattr(self, PairScore, name)
4356 def __init__(self, name="PairScore %1%"):
4358 __init__(IMP::kernel::PairScore self, std::string name="PairScore %1%") -> PairScore
4359 __init__(IMP::kernel::PairScore self) -> PairScore
4361 if self.__class__ == PairScore:
4365 this = _IMP_kernel.new_PairScore(_self, name)
4366 try: self.this.append(this)
4367 except: self.this = this
4368 if self.__class__ != PairScore:
4370 IMP.base._director_objects.register(self)
4374 def evaluate(self, *args):
4375 """evaluate(PairScore self, IMP::kernel::ParticlePair const & vt, DerivativeAccumulator da) -> double"""
4376 return _IMP_kernel.PairScore_evaluate(self, *args)
4378 def evaluate_index(self, *args):
4379 """evaluate_index(PairScore self, Model m, IMP::kernel::ParticleIndexPair const & vt, DerivativeAccumulator da) -> double"""
4380 return _IMP_kernel.PairScore_evaluate_index(self, *args)
4382 def evaluate_indexes(self, *args):
4384 evaluate_indexes(PairScore self, Model m, IMP::kernel::ParticleIndexPairs const & o, DerivativeAccumulator da, unsigned int lower_bound,
4385 unsigned int upper_bound) -> double
4387 return _IMP_kernel.PairScore_evaluate_indexes(self, *args)
4389 def evaluate_if_good_index(self, *args):
4390 """evaluate_if_good_index(PairScore self, Model m, IMP::kernel::ParticleIndexPair const & vt, DerivativeAccumulator da, double max) -> double"""
4391 return _IMP_kernel.PairScore_evaluate_if_good_index(self, *args)
4393 def evaluate_if_good_indexes(self, *args):
4395 evaluate_if_good_indexes(PairScore self, Model m, IMP::kernel::ParticleIndexPairs const & o, DerivativeAccumulator da, double max,
4396 unsigned int lower_bound, unsigned int upper_bound) -> double
4398 return _IMP_kernel.PairScore_evaluate_if_good_indexes(self, *args)
4400 def create_current_decomposition(self, *args):
4401 """create_current_decomposition(PairScore self, Model m, IMP::kernel::ParticleIndexPair const & vt) -> IMP::kernel::Restraints"""
4402 return _IMP_kernel.PairScore_create_current_decomposition(self, *args)
4405 """get_input_particles(PairScore self, Particle p) -> IMP::kernel::ParticlesTemp"""
4406 return _IMP_kernel.PairScore_get_input_particles(self, *args)
4409 """get_input_containers(PairScore self, Particle p) -> IMP::kernel::ContainersTemp"""
4410 return _IMP_kernel.PairScore_get_input_containers(self, *args)
4412 def get_inputs(self, *args):
4413 """get_inputs(PairScore self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
4414 return _IMP_kernel.PairScore_get_inputs(self, *args)
4416 def _do_get_inputs(self, *args):
4417 """_do_get_inputs(PairScore self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
4418 return _IMP_kernel.PairScore__do_get_inputs(self, *args)
4420 def do_create_current_decomposition(self, *args):
4421 """do_create_current_decomposition(PairScore self, Model m, IMP::kernel::ParticleIndexPair const & vt) -> IMP::kernel::Restraints"""
4422 return _IMP_kernel.PairScore_do_create_current_decomposition(self, *args)
4424 __swig_destroy__ = _IMP_kernel.delete_PairScore
4425 __del__ =
lambda self :
None;
4427 """__str__(PairScore self) -> std::string"""
4428 return _IMP_kernel.PairScore___str__(self)
4431 """__repr__(PairScore self) -> std::string"""
4432 return _IMP_kernel.PairScore___repr__(self)
4435 return _object_cast_to_PairScore(o)
4436 get_from = staticmethod(get_from)
4438 def get_type_name(self):
4439 return self.__class__.__name__
4440 def do_show(self, out):
4442 def get_version_info(self):
4443 if"IMP::kernel" ==
"IMP":
4444 return VersionInfo(
"python",
"0")
4446 return IMP.VersionInfo(
"python",
"0")
4448 return _object_cast_to_PairScore(o)
4449 get_from = staticmethod(get_from)
4451 def __disown__(self):
4453 _IMP_kernel.disown_PairScore(self)
4454 return weakref_proxy(self)
4455 PairScore_swigregister = _IMP_kernel.PairScore_swigregister
4456 PairScore_swigregister(PairScore)
4459 """Proxy of C++ IMP::kernel::PairPredicate class"""
4460 __swig_setmethods__ = {}
4461 for _s
in [
IMP.base.Object]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
4462 __setattr__ =
lambda self, name, value: _swig_setattr(self, PairPredicate, name, value)
4463 __swig_getmethods__ = {}
4464 for _s
in [
IMP.base.Object]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
4465 __getattr__ =
lambda self, name: _swig_getattr(self, PairPredicate, name)
4466 def __init__(self, name="PairPredicate %1%"):
4468 __init__(IMP::kernel::PairPredicate self, std::string name="PairPredicate %1%") -> PairPredicate
4469 __init__(IMP::kernel::PairPredicate self) -> PairPredicate
4471 if self.__class__ == PairPredicate:
4475 this = _IMP_kernel.new_PairPredicate(_self, name)
4476 try: self.this.append(this)
4477 except: self.this = this
4478 if self.__class__ != PairPredicate:
4480 IMP.base._director_objects.register(self)
4484 def get_value(self, *args):
4486 get_value(PairPredicate self, IMP::kernel::ParticlePair const & vt) -> int
4487 get_value(PairPredicate self, IMP::kernel::ParticlePairsTemp const & o) -> IMP::Ints
4489 return _IMP_kernel.PairPredicate_get_value(self, *args)
4491 def __call__(self, *args):
4492 """__call__(PairPredicate self, Model m, IMP::kernel::ParticleIndexPair const & vt) -> int"""
4493 return _IMP_kernel.PairPredicate___call__(self, *args)
4495 def get_value_index(self, *args):
4497 get_value_index(PairPredicate self, Model m, IMP::kernel::ParticleIndexPair const & vt) -> int
4498 get_value_index(PairPredicate self, Model m, IMP::kernel::ParticleIndexPairs const & o) -> IMP::Ints
4500 return _IMP_kernel.PairPredicate_get_value_index(self, *args)
4503 """get_input_particles(PairPredicate self, Particle p) -> IMP::kernel::ParticlesTemp"""
4504 return _IMP_kernel.PairPredicate_get_input_particles(self, *args)
4507 """get_input_containers(PairPredicate self, Particle p) -> IMP::kernel::ContainersTemp"""
4508 return _IMP_kernel.PairPredicate_get_input_containers(self, *args)
4510 def get_inputs(self, *args):
4511 """get_inputs(PairPredicate self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
4512 return _IMP_kernel.PairPredicate_get_inputs(self, *args)
4514 def _do_get_inputs(self, *args):
4515 """_do_get_inputs(PairPredicate self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
4516 return _IMP_kernel.PairPredicate__do_get_inputs(self, *args)
4518 __swig_destroy__ = _IMP_kernel.delete_PairPredicate
4519 __del__ =
lambda self :
None;
4521 """__str__(PairPredicate self) -> std::string"""
4522 return _IMP_kernel.PairPredicate___str__(self)
4525 """__repr__(PairPredicate self) -> std::string"""
4526 return _IMP_kernel.PairPredicate___repr__(self)
4529 return _object_cast_to_PairPredicate(o)
4530 get_from = staticmethod(get_from)
4532 def get_type_name(self):
4533 return self.__class__.__name__
4534 def do_show(self, out):
4536 def get_version_info(self):
4537 if"IMP::kernel" ==
"IMP":
4538 return VersionInfo(
"python",
"0")
4540 return IMP.VersionInfo(
"python",
"0")
4542 return _object_cast_to_PairPredicate(o)
4543 get_from = staticmethod(get_from)
4545 def __disown__(self):
4547 _IMP_kernel.disown_PairPredicate(self)
4548 return weakref_proxy(self)
4549 PairPredicate_swigregister = _IMP_kernel.PairPredicate_swigregister
4550 PairPredicate_swigregister(PairPredicate)
4553 """Proxy of C++ IMP::kernel::PairContainer class"""
4554 __swig_setmethods__ = {}
4555 for _s
in [Container]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
4556 __setattr__ =
lambda self, name, value: _swig_setattr(self, PairContainer, name, value)
4557 __swig_getmethods__ = {}
4558 for _s
in [Container]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
4559 __getattr__ =
lambda self, name: _swig_getattr(self, PairContainer, name)
4560 def __init__(self, *args):
4562 __init__(IMP::kernel::PairContainer self, Model m, std::string name="PairContainer %1%") -> PairContainer
4563 __init__(IMP::kernel::PairContainer self, Model m) -> PairContainer
4565 if self.__class__ == PairContainer:
4569 this = _IMP_kernel.new_PairContainer(_self, *args)
4570 try: self.this.append(this)
4571 except: self.this = this
4572 if self.__class__ != PairContainer:
4574 IMP.base._director_objects.register(self)
4578 def apply_generic(self, *args):
4579 """apply_generic(PairContainer self, PairModifier m)"""
4580 return _IMP_kernel.PairContainer_apply_generic(self, *args)
4582 def apply(self, *args):
4583 """apply(PairContainer self, PairModifier sm)"""
4584 return _IMP_kernel.PairContainer_apply(self, *args)
4587 """get_indexes(PairContainer self) -> IMP::kernel::ParticleIndexPairs"""
4588 return _IMP_kernel.PairContainer_get_indexes(self)
4590 def get_range_indexes(self):
4591 """get_range_indexes(PairContainer self) -> IMP::kernel::ParticleIndexPairs"""
4592 return _IMP_kernel.PairContainer_get_range_indexes(self)
4594 def get(self, *args):
4596 get(PairContainer self) -> IMP::kernel::ParticlePairsTemp
4597 get(PairContainer self, unsigned int i) -> IMP::kernel::ParticlePair
4599 return _IMP_kernel.PairContainer_get(self, *args)
4601 def get_number(self):
4602 """get_number(PairContainer self) -> unsigned int"""
4603 return _IMP_kernel.PairContainer_get_number(self)
4605 def get_particle_pairs(self):
4606 """get_particle_pairs(PairContainer self) -> IMP::kernel::ParticlePairsTemp"""
4607 return _IMP_kernel.PairContainer_get_particle_pairs(self)
4609 def get_contains_particle_pair(self, *args):
4610 """get_contains_particle_pair(PairContainer self, IMP::kernel::ParticlePair v) -> bool"""
4611 return _IMP_kernel.PairContainer_get_contains_particle_pair(self, *args)
4613 def get_number_of_particle_pairs(self):
4614 """get_number_of_particle_pairs(PairContainer self) -> unsigned int"""
4615 return _IMP_kernel.PairContainer_get_number_of_particle_pairs(self)
4617 def get_particle_pair(self, *args):
4618 """get_particle_pair(PairContainer self, unsigned int i) -> IMP::kernel::ParticlePair"""
4619 return _IMP_kernel.PairContainer_get_particle_pair(self, *args)
4621 def do_apply(self, *args):
4622 """do_apply(PairContainer self, PairModifier sm)"""
4623 return _IMP_kernel.PairContainer_do_apply(self, *args)
4625 def do_get_provides_access(self):
4626 """do_get_provides_access(PairContainer self) -> bool"""
4627 return _IMP_kernel.PairContainer_do_get_provides_access(self)
4629 __swig_destroy__ = _IMP_kernel.delete_PairContainer
4630 __del__ =
lambda self :
None;
4632 """__str__(PairContainer self) -> std::string"""
4633 return _IMP_kernel.PairContainer___str__(self)
4636 """__repr__(PairContainer self) -> std::string"""
4637 return _IMP_kernel.PairContainer___repr__(self)
4640 return _object_cast_to_PairContainer(o)
4641 get_from = staticmethod(get_from)
4643 def get_type_name(self):
4644 return self.__class__.__name__
4645 def do_show(self, out):
4647 def get_version_info(self):
4648 if"IMP::kernel" ==
"IMP":
4649 return VersionInfo(
"python",
"0")
4651 return IMP.VersionInfo(
"python",
"0")
4653 return _object_cast_to_PairContainer(o)
4654 get_from = staticmethod(get_from)
4656 def __disown__(self):
4658 _IMP_kernel.disown_PairContainer(self)
4659 return weakref_proxy(self)
4660 def update_dependencies(self):
4661 """update_dependencies(PairContainer self)"""
4662 return _IMP_kernel.PairContainer_update_dependencies(self)
4664 def do_get_inputs(self):
4665 """do_get_inputs(PairContainer self) -> IMP::kernel::ModelObjectsTemp"""
4666 return _IMP_kernel.PairContainer_do_get_inputs(self)
4668 def do_get_interactions(self):
4669 """do_get_interactions(PairContainer self) -> IMP::kernel::ModelObjectsTemps"""
4670 return _IMP_kernel.PairContainer_do_get_interactions(self)
4672 def do_before_evaluate(self):
4673 """do_before_evaluate(PairContainer self)"""
4674 return _IMP_kernel.PairContainer_do_before_evaluate(self)
4676 def do_update_dependencies(self):
4677 """do_update_dependencies(PairContainer self)"""
4678 return _IMP_kernel.PairContainer_do_update_dependencies(self)
4680 PairContainer_swigregister = _IMP_kernel.PairContainer_swigregister
4681 PairContainer_swigregister(PairContainer)
4683 class _PairContainerAdaptor(IMP.base._InputAdaptor):
4684 """Proxy of C++ IMP::kernel::PairContainerAdaptor class"""
4685 __swig_setmethods__ = {}
4686 for _s
in [IMP.base._InputAdaptor]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
4687 __setattr__ =
lambda self, name, value: _swig_setattr(self, _PairContainerAdaptor, name, value)
4688 __swig_getmethods__ = {}
4689 for _s
in [IMP.base._InputAdaptor]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
4690 __getattr__ =
lambda self, name: _swig_getattr(self, _PairContainerAdaptor, name)
4691 __repr__ = _swig_repr
4692 def __init__(self, *args):
4694 __init__(IMP::kernel::PairContainerAdaptor self) -> _PairContainerAdaptor
4695 __init__(IMP::kernel::PairContainerAdaptor self, PairContainer c) -> _PairContainerAdaptor
4696 __init__(IMP::kernel::PairContainerAdaptor self, IMP::kernel::ParticlePairsTemp const & t, std::string name="PairContainerAdaptor%1%") -> _PairContainerAdaptor
4697 __init__(IMP::kernel::PairContainerAdaptor self, IMP::kernel::ParticlePairsTemp const & t) -> _PairContainerAdaptor
4699 this = _IMP_kernel.new__PairContainerAdaptor(*args)
4700 try: self.this.append(this)
4701 except: self.this = this
4702 __swig_destroy__ = _IMP_kernel.delete__PairContainerAdaptor
4703 __del__ =
lambda self :
None;
4704 _PairContainerAdaptor_swigregister = _IMP_kernel._PairContainerAdaptor_swigregister
4705 _PairContainerAdaptor_swigregister(_PairContainerAdaptor)
4708 """Proxy of C++ IMP::kernel::QuadModifier class"""
4709 __swig_setmethods__ = {}
4710 for _s
in [
IMP.base.Object]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
4711 __setattr__ =
lambda self, name, value: _swig_setattr(self, QuadModifier, name, value)
4712 __swig_getmethods__ = {}
4713 for _s
in [
IMP.base.Object]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
4714 __getattr__ =
lambda self, name: _swig_getattr(self, QuadModifier, name)
4715 def __init__(self, name="QuadModifier %1%"):
4717 __init__(IMP::kernel::QuadModifier self, std::string name="QuadModifier %1%") -> QuadModifier
4718 __init__(IMP::kernel::QuadModifier self) -> QuadModifier
4720 if self.__class__ == QuadModifier:
4724 this = _IMP_kernel.new_QuadModifier(_self, name)
4725 try: self.this.append(this)
4726 except: self.this = this
4727 if self.__class__ != QuadModifier:
4729 IMP.base._director_objects.register(self)
4733 def apply(self, *args):
4734 """apply(QuadModifier self, IMP::kernel::ParticleQuad const & arg0)"""
4735 return _IMP_kernel.QuadModifier_apply(self, *args)
4737 def apply_index(self, *args):
4738 """apply_index(QuadModifier self, Model m, IMP::kernel::ParticleIndexQuad const & v)"""
4739 return _IMP_kernel.QuadModifier_apply_index(self, *args)
4741 def apply_indexes(self, *args):
4742 """apply_indexes(QuadModifier self, Model m, IMP::kernel::ParticleIndexQuads const & o, unsigned int lower_bound, unsigned int upper_bound)"""
4743 return _IMP_kernel.QuadModifier_apply_indexes(self, *args)
4746 """get_input_particles(QuadModifier self, Particle p) -> IMP::kernel::ParticlesTemp"""
4747 return _IMP_kernel.QuadModifier_get_input_particles(self, *args)
4750 """get_input_containers(QuadModifier self, Particle p) -> IMP::kernel::ContainersTemp"""
4751 return _IMP_kernel.QuadModifier_get_input_containers(self, *args)
4753 def get_inputs(self, *args):
4754 """get_inputs(QuadModifier self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
4755 return _IMP_kernel.QuadModifier_get_inputs(self, *args)
4757 def _do_get_inputs(self, *args):
4758 """_do_get_inputs(QuadModifier self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
4759 return _IMP_kernel.QuadModifier__do_get_inputs(self, *args)
4762 """get_output_particles(QuadModifier self, Particle p) -> IMP::kernel::ParticlesTemp"""
4763 return _IMP_kernel.QuadModifier_get_output_particles(self, *args)
4766 """get_output_containers(QuadModifier self, Particle p) -> IMP::kernel::ContainersTemp"""
4767 return _IMP_kernel.QuadModifier_get_output_containers(self, *args)
4769 def get_outputs(self, *args):
4770 """get_outputs(QuadModifier self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
4771 return _IMP_kernel.QuadModifier_get_outputs(self, *args)
4773 def _do_get_outputs(self, *args):
4774 """_do_get_outputs(QuadModifier self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
4775 return _IMP_kernel.QuadModifier__do_get_outputs(self, *args)
4778 """__str__(QuadModifier self) -> std::string"""
4779 return _IMP_kernel.QuadModifier___str__(self)
4782 """__repr__(QuadModifier self) -> std::string"""
4783 return _IMP_kernel.QuadModifier___repr__(self)
4786 return _object_cast_to_QuadModifier(o)
4787 get_from = staticmethod(get_from)
4789 def get_type_name(self):
4790 return self.__class__.__name__
4791 def do_show(self, out):
4793 def get_version_info(self):
4794 if"IMP::kernel" ==
"IMP":
4795 return VersionInfo(
"python",
"0")
4797 return IMP.VersionInfo(
"python",
"0")
4799 return _object_cast_to_QuadModifier(o)
4800 get_from = staticmethod(get_from)
4802 __swig_destroy__ = _IMP_kernel.delete_QuadModifier
4803 __del__ =
lambda self :
None;
4804 def __disown__(self):
4806 _IMP_kernel.disown_QuadModifier(self)
4807 return weakref_proxy(self)
4808 QuadModifier_swigregister = _IMP_kernel.QuadModifier_swigregister
4809 QuadModifier_swigregister(QuadModifier)
4812 """Proxy of C++ IMP::kernel::QuadScore class"""
4813 __swig_setmethods__ = {}
4814 for _s
in [
IMP.base.Object]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
4815 __setattr__ =
lambda self, name, value: _swig_setattr(self, QuadScore, name, value)
4816 __swig_getmethods__ = {}
4817 for _s
in [
IMP.base.Object]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
4818 __getattr__ =
lambda self, name: _swig_getattr(self, QuadScore, name)
4819 def __init__(self, name="QuadScore %1%"):
4821 __init__(IMP::kernel::QuadScore self, std::string name="QuadScore %1%") -> QuadScore
4822 __init__(IMP::kernel::QuadScore self) -> QuadScore
4824 if self.__class__ == QuadScore:
4828 this = _IMP_kernel.new_QuadScore(_self, name)
4829 try: self.this.append(this)
4830 except: self.this = this
4831 if self.__class__ != QuadScore:
4833 IMP.base._director_objects.register(self)
4837 def evaluate(self, *args):
4838 """evaluate(QuadScore self, IMP::kernel::ParticleQuad const & vt, DerivativeAccumulator da) -> double"""
4839 return _IMP_kernel.QuadScore_evaluate(self, *args)
4841 def evaluate_index(self, *args):
4842 """evaluate_index(QuadScore self, Model m, IMP::kernel::ParticleIndexQuad const & vt, DerivativeAccumulator da) -> double"""
4843 return _IMP_kernel.QuadScore_evaluate_index(self, *args)
4845 def evaluate_indexes(self, *args):
4847 evaluate_indexes(QuadScore self, Model m, IMP::kernel::ParticleIndexQuads const & o, DerivativeAccumulator da, unsigned int lower_bound,
4848 unsigned int upper_bound) -> double
4850 return _IMP_kernel.QuadScore_evaluate_indexes(self, *args)
4852 def evaluate_if_good_index(self, *args):
4853 """evaluate_if_good_index(QuadScore self, Model m, IMP::kernel::ParticleIndexQuad const & vt, DerivativeAccumulator da, double max) -> double"""
4854 return _IMP_kernel.QuadScore_evaluate_if_good_index(self, *args)
4856 def evaluate_if_good_indexes(self, *args):
4858 evaluate_if_good_indexes(QuadScore self, Model m, IMP::kernel::ParticleIndexQuads const & o, DerivativeAccumulator da, double max,
4859 unsigned int lower_bound, unsigned int upper_bound) -> double
4861 return _IMP_kernel.QuadScore_evaluate_if_good_indexes(self, *args)
4863 def create_current_decomposition(self, *args):
4864 """create_current_decomposition(QuadScore self, Model m, IMP::kernel::ParticleIndexQuad const & vt) -> IMP::kernel::Restraints"""
4865 return _IMP_kernel.QuadScore_create_current_decomposition(self, *args)
4868 """get_input_particles(QuadScore self, Particle p) -> IMP::kernel::ParticlesTemp"""
4869 return _IMP_kernel.QuadScore_get_input_particles(self, *args)
4872 """get_input_containers(QuadScore self, Particle p) -> IMP::kernel::ContainersTemp"""
4873 return _IMP_kernel.QuadScore_get_input_containers(self, *args)
4875 def get_inputs(self, *args):
4876 """get_inputs(QuadScore self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
4877 return _IMP_kernel.QuadScore_get_inputs(self, *args)
4879 def _do_get_inputs(self, *args):
4880 """_do_get_inputs(QuadScore self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
4881 return _IMP_kernel.QuadScore__do_get_inputs(self, *args)
4883 def do_create_current_decomposition(self, *args):
4884 """do_create_current_decomposition(QuadScore self, Model m, IMP::kernel::ParticleIndexQuad const & vt) -> IMP::kernel::Restraints"""
4885 return _IMP_kernel.QuadScore_do_create_current_decomposition(self, *args)
4887 __swig_destroy__ = _IMP_kernel.delete_QuadScore
4888 __del__ =
lambda self :
None;
4890 """__str__(QuadScore self) -> std::string"""
4891 return _IMP_kernel.QuadScore___str__(self)
4894 """__repr__(QuadScore self) -> std::string"""
4895 return _IMP_kernel.QuadScore___repr__(self)
4898 return _object_cast_to_QuadScore(o)
4899 get_from = staticmethod(get_from)
4901 def get_type_name(self):
4902 return self.__class__.__name__
4903 def do_show(self, out):
4905 def get_version_info(self):
4906 if"IMP::kernel" ==
"IMP":
4907 return VersionInfo(
"python",
"0")
4909 return IMP.VersionInfo(
"python",
"0")
4911 return _object_cast_to_QuadScore(o)
4912 get_from = staticmethod(get_from)
4914 def __disown__(self):
4916 _IMP_kernel.disown_QuadScore(self)
4917 return weakref_proxy(self)
4918 QuadScore_swigregister = _IMP_kernel.QuadScore_swigregister
4919 QuadScore_swigregister(QuadScore)
4922 """Proxy of C++ IMP::kernel::QuadPredicate class"""
4923 __swig_setmethods__ = {}
4924 for _s
in [
IMP.base.Object]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
4925 __setattr__ =
lambda self, name, value: _swig_setattr(self, QuadPredicate, name, value)
4926 __swig_getmethods__ = {}
4927 for _s
in [
IMP.base.Object]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
4928 __getattr__ =
lambda self, name: _swig_getattr(self, QuadPredicate, name)
4929 def __init__(self, name="QuadPredicate %1%"):
4931 __init__(IMP::kernel::QuadPredicate self, std::string name="QuadPredicate %1%") -> QuadPredicate
4932 __init__(IMP::kernel::QuadPredicate self) -> QuadPredicate
4934 if self.__class__ == QuadPredicate:
4938 this = _IMP_kernel.new_QuadPredicate(_self, name)
4939 try: self.this.append(this)
4940 except: self.this = this
4941 if self.__class__ != QuadPredicate:
4943 IMP.base._director_objects.register(self)
4947 def get_value(self, *args):
4949 get_value(QuadPredicate self, IMP::kernel::ParticleQuad const & vt) -> int
4950 get_value(QuadPredicate self, IMP::kernel::ParticleQuadsTemp const & o) -> IMP::Ints
4952 return _IMP_kernel.QuadPredicate_get_value(self, *args)
4954 def __call__(self, *args):
4955 """__call__(QuadPredicate self, Model m, IMP::kernel::ParticleIndexQuad const & vt) -> int"""
4956 return _IMP_kernel.QuadPredicate___call__(self, *args)
4958 def get_value_index(self, *args):
4960 get_value_index(QuadPredicate self, Model m, IMP::kernel::ParticleIndexQuad const & vt) -> int
4961 get_value_index(QuadPredicate self, Model m, IMP::kernel::ParticleIndexQuads const & o) -> IMP::Ints
4963 return _IMP_kernel.QuadPredicate_get_value_index(self, *args)
4966 """get_input_particles(QuadPredicate self, Particle p) -> IMP::kernel::ParticlesTemp"""
4967 return _IMP_kernel.QuadPredicate_get_input_particles(self, *args)
4970 """get_input_containers(QuadPredicate self, Particle p) -> IMP::kernel::ContainersTemp"""
4971 return _IMP_kernel.QuadPredicate_get_input_containers(self, *args)
4973 def get_inputs(self, *args):
4974 """get_inputs(QuadPredicate self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
4975 return _IMP_kernel.QuadPredicate_get_inputs(self, *args)
4977 def _do_get_inputs(self, *args):
4978 """_do_get_inputs(QuadPredicate self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
4979 return _IMP_kernel.QuadPredicate__do_get_inputs(self, *args)
4981 __swig_destroy__ = _IMP_kernel.delete_QuadPredicate
4982 __del__ =
lambda self :
None;
4984 """__str__(QuadPredicate self) -> std::string"""
4985 return _IMP_kernel.QuadPredicate___str__(self)
4988 """__repr__(QuadPredicate self) -> std::string"""
4989 return _IMP_kernel.QuadPredicate___repr__(self)
4992 return _object_cast_to_QuadPredicate(o)
4993 get_from = staticmethod(get_from)
4995 def get_type_name(self):
4996 return self.__class__.__name__
4997 def do_show(self, out):
4999 def get_version_info(self):
5000 if"IMP::kernel" ==
"IMP":
5001 return VersionInfo(
"python",
"0")
5003 return IMP.VersionInfo(
"python",
"0")
5005 return _object_cast_to_QuadPredicate(o)
5006 get_from = staticmethod(get_from)
5008 def __disown__(self):
5010 _IMP_kernel.disown_QuadPredicate(self)
5011 return weakref_proxy(self)
5012 QuadPredicate_swigregister = _IMP_kernel.QuadPredicate_swigregister
5013 QuadPredicate_swigregister(QuadPredicate)
5016 """Proxy of C++ IMP::kernel::QuadContainer class"""
5017 __swig_setmethods__ = {}
5018 for _s
in [Container]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
5019 __setattr__ =
lambda self, name, value: _swig_setattr(self, QuadContainer, name, value)
5020 __swig_getmethods__ = {}
5021 for _s
in [Container]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
5022 __getattr__ =
lambda self, name: _swig_getattr(self, QuadContainer, name)
5023 def __init__(self, *args):
5025 __init__(IMP::kernel::QuadContainer self, Model m, std::string name="QuadContainer %1%") -> QuadContainer
5026 __init__(IMP::kernel::QuadContainer self, Model m) -> QuadContainer
5028 if self.__class__ == QuadContainer:
5032 this = _IMP_kernel.new_QuadContainer(_self, *args)
5033 try: self.this.append(this)
5034 except: self.this = this
5035 if self.__class__ != QuadContainer:
5037 IMP.base._director_objects.register(self)
5041 def apply_generic(self, *args):
5042 """apply_generic(QuadContainer self, QuadModifier m)"""
5043 return _IMP_kernel.QuadContainer_apply_generic(self, *args)
5045 def apply(self, *args):
5046 """apply(QuadContainer self, QuadModifier sm)"""
5047 return _IMP_kernel.QuadContainer_apply(self, *args)
5050 """get_indexes(QuadContainer self) -> IMP::kernel::ParticleIndexQuads"""
5051 return _IMP_kernel.QuadContainer_get_indexes(self)
5053 def get_range_indexes(self):
5054 """get_range_indexes(QuadContainer self) -> IMP::kernel::ParticleIndexQuads"""
5055 return _IMP_kernel.QuadContainer_get_range_indexes(self)
5057 def get(self, *args):
5059 get(QuadContainer self) -> IMP::kernel::ParticleQuadsTemp
5060 get(QuadContainer self, unsigned int i) -> IMP::kernel::ParticleQuad
5062 return _IMP_kernel.QuadContainer_get(self, *args)
5064 def get_number(self):
5065 """get_number(QuadContainer self) -> unsigned int"""
5066 return _IMP_kernel.QuadContainer_get_number(self)
5068 def get_particle_quads(self):
5069 """get_particle_quads(QuadContainer self) -> IMP::kernel::ParticleQuadsTemp"""
5070 return _IMP_kernel.QuadContainer_get_particle_quads(self)
5072 def get_contains_particle_quad(self, *args):
5073 """get_contains_particle_quad(QuadContainer self, IMP::kernel::ParticleQuad v) -> bool"""
5074 return _IMP_kernel.QuadContainer_get_contains_particle_quad(self, *args)
5076 def get_number_of_particle_quads(self):
5077 """get_number_of_particle_quads(QuadContainer self) -> unsigned int"""
5078 return _IMP_kernel.QuadContainer_get_number_of_particle_quads(self)
5080 def get_particle_quad(self, *args):
5081 """get_particle_quad(QuadContainer self, unsigned int i) -> IMP::kernel::ParticleQuad"""
5082 return _IMP_kernel.QuadContainer_get_particle_quad(self, *args)
5084 def do_apply(self, *args):
5085 """do_apply(QuadContainer self, QuadModifier sm)"""
5086 return _IMP_kernel.QuadContainer_do_apply(self, *args)
5088 def do_get_provides_access(self):
5089 """do_get_provides_access(QuadContainer self) -> bool"""
5090 return _IMP_kernel.QuadContainer_do_get_provides_access(self)
5092 __swig_destroy__ = _IMP_kernel.delete_QuadContainer
5093 __del__ =
lambda self :
None;
5095 """__str__(QuadContainer self) -> std::string"""
5096 return _IMP_kernel.QuadContainer___str__(self)
5099 """__repr__(QuadContainer self) -> std::string"""
5100 return _IMP_kernel.QuadContainer___repr__(self)
5103 return _object_cast_to_QuadContainer(o)
5104 get_from = staticmethod(get_from)
5106 def get_type_name(self):
5107 return self.__class__.__name__
5108 def do_show(self, out):
5110 def get_version_info(self):
5111 if"IMP::kernel" ==
"IMP":
5112 return VersionInfo(
"python",
"0")
5114 return IMP.VersionInfo(
"python",
"0")
5116 return _object_cast_to_QuadContainer(o)
5117 get_from = staticmethod(get_from)
5119 def __disown__(self):
5121 _IMP_kernel.disown_QuadContainer(self)
5122 return weakref_proxy(self)
5123 def update_dependencies(self):
5124 """update_dependencies(QuadContainer self)"""
5125 return _IMP_kernel.QuadContainer_update_dependencies(self)
5127 def do_get_inputs(self):
5128 """do_get_inputs(QuadContainer self) -> IMP::kernel::ModelObjectsTemp"""
5129 return _IMP_kernel.QuadContainer_do_get_inputs(self)
5131 def do_get_interactions(self):
5132 """do_get_interactions(QuadContainer self) -> IMP::kernel::ModelObjectsTemps"""
5133 return _IMP_kernel.QuadContainer_do_get_interactions(self)
5135 def do_before_evaluate(self):
5136 """do_before_evaluate(QuadContainer self)"""
5137 return _IMP_kernel.QuadContainer_do_before_evaluate(self)
5139 def do_update_dependencies(self):
5140 """do_update_dependencies(QuadContainer self)"""
5141 return _IMP_kernel.QuadContainer_do_update_dependencies(self)
5143 QuadContainer_swigregister = _IMP_kernel.QuadContainer_swigregister
5144 QuadContainer_swigregister(QuadContainer)
5146 class _QuadContainerAdaptor(IMP.base._InputAdaptor):
5147 """Proxy of C++ IMP::kernel::QuadContainerAdaptor class"""
5148 __swig_setmethods__ = {}
5149 for _s
in [IMP.base._InputAdaptor]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
5150 __setattr__ =
lambda self, name, value: _swig_setattr(self, _QuadContainerAdaptor, name, value)
5151 __swig_getmethods__ = {}
5152 for _s
in [IMP.base._InputAdaptor]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
5153 __getattr__ =
lambda self, name: _swig_getattr(self, _QuadContainerAdaptor, name)
5154 __repr__ = _swig_repr
5155 def __init__(self, *args):
5157 __init__(IMP::kernel::QuadContainerAdaptor self) -> _QuadContainerAdaptor
5158 __init__(IMP::kernel::QuadContainerAdaptor self, QuadContainer c) -> _QuadContainerAdaptor
5159 __init__(IMP::kernel::QuadContainerAdaptor self, IMP::kernel::ParticleQuadsTemp const & t, std::string name="QuadContainerAdaptor%1%") -> _QuadContainerAdaptor
5160 __init__(IMP::kernel::QuadContainerAdaptor self, IMP::kernel::ParticleQuadsTemp const & t) -> _QuadContainerAdaptor
5162 this = _IMP_kernel.new__QuadContainerAdaptor(*args)
5163 try: self.this.append(this)
5164 except: self.this = this
5165 __swig_destroy__ = _IMP_kernel.delete__QuadContainerAdaptor
5166 __del__ =
lambda self :
None;
5167 _QuadContainerAdaptor_swigregister = _IMP_kernel._QuadContainerAdaptor_swigregister
5168 _QuadContainerAdaptor_swigregister(_QuadContainerAdaptor)
5171 """Proxy of C++ IMP::kernel::SingletonModifier class"""
5172 __swig_setmethods__ = {}
5173 for _s
in [
IMP.base.Object]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
5174 __setattr__ =
lambda self, name, value: _swig_setattr(self, SingletonModifier, name, value)
5175 __swig_getmethods__ = {}
5176 for _s
in [
IMP.base.Object]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
5177 __getattr__ =
lambda self, name: _swig_getattr(self, SingletonModifier, name)
5178 def __init__(self, name="SingletonModifier %1%"):
5180 __init__(IMP::kernel::SingletonModifier self, std::string name="SingletonModifier %1%") -> SingletonModifier
5181 __init__(IMP::kernel::SingletonModifier self) -> SingletonModifier
5183 if self.__class__ == SingletonModifier:
5187 this = _IMP_kernel.new_SingletonModifier(_self, name)
5188 try: self.this.append(this)
5189 except: self.this = this
5190 if self.__class__ != SingletonModifier:
5192 IMP.base._director_objects.register(self)
5196 def apply(self, *args):
5197 """apply(SingletonModifier self, Particle arg0)"""
5198 return _IMP_kernel.SingletonModifier_apply(self, *args)
5200 def apply_index(self, *args):
5201 """apply_index(SingletonModifier self, Model m, IMP::kernel::ParticleIndex v)"""
5202 return _IMP_kernel.SingletonModifier_apply_index(self, *args)
5204 def apply_indexes(self, *args):
5205 """apply_indexes(SingletonModifier self, Model m, IMP::kernel::ParticleIndexes const & o, unsigned int lower_bound, unsigned int upper_bound)"""
5206 return _IMP_kernel.SingletonModifier_apply_indexes(self, *args)
5209 """get_input_particles(SingletonModifier self, Particle p) -> IMP::kernel::ParticlesTemp"""
5210 return _IMP_kernel.SingletonModifier_get_input_particles(self, *args)
5213 """get_input_containers(SingletonModifier self, Particle p) -> IMP::kernel::ContainersTemp"""
5214 return _IMP_kernel.SingletonModifier_get_input_containers(self, *args)
5216 def get_inputs(self, *args):
5217 """get_inputs(SingletonModifier self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
5218 return _IMP_kernel.SingletonModifier_get_inputs(self, *args)
5220 def _do_get_inputs(self, *args):
5221 """_do_get_inputs(SingletonModifier self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
5222 return _IMP_kernel.SingletonModifier__do_get_inputs(self, *args)
5225 """get_output_particles(SingletonModifier self, Particle p) -> IMP::kernel::ParticlesTemp"""
5226 return _IMP_kernel.SingletonModifier_get_output_particles(self, *args)
5229 """get_output_containers(SingletonModifier self, Particle p) -> IMP::kernel::ContainersTemp"""
5230 return _IMP_kernel.SingletonModifier_get_output_containers(self, *args)
5232 def get_outputs(self, *args):
5233 """get_outputs(SingletonModifier self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
5234 return _IMP_kernel.SingletonModifier_get_outputs(self, *args)
5236 def _do_get_outputs(self, *args):
5237 """_do_get_outputs(SingletonModifier self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
5238 return _IMP_kernel.SingletonModifier__do_get_outputs(self, *args)
5241 """__str__(SingletonModifier self) -> std::string"""
5242 return _IMP_kernel.SingletonModifier___str__(self)
5245 """__repr__(SingletonModifier self) -> std::string"""
5246 return _IMP_kernel.SingletonModifier___repr__(self)
5249 return _object_cast_to_SingletonModifier(o)
5250 get_from = staticmethod(get_from)
5252 def get_type_name(self):
5253 return self.__class__.__name__
5254 def do_show(self, out):
5256 def get_version_info(self):
5257 if"IMP::kernel" ==
"IMP":
5258 return VersionInfo(
"python",
"0")
5260 return IMP.VersionInfo(
"python",
"0")
5262 return _object_cast_to_SingletonModifier(o)
5263 get_from = staticmethod(get_from)
5265 __swig_destroy__ = _IMP_kernel.delete_SingletonModifier
5266 __del__ =
lambda self :
None;
5267 def __disown__(self):
5269 _IMP_kernel.disown_SingletonModifier(self)
5270 return weakref_proxy(self)
5271 SingletonModifier_swigregister = _IMP_kernel.SingletonModifier_swigregister
5272 SingletonModifier_swigregister(SingletonModifier)
5275 """Proxy of C++ IMP::kernel::SingletonScore class"""
5276 __swig_setmethods__ = {}
5277 for _s
in [
IMP.base.Object]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
5278 __setattr__ =
lambda self, name, value: _swig_setattr(self, SingletonScore, name, value)
5279 __swig_getmethods__ = {}
5280 for _s
in [
IMP.base.Object]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
5281 __getattr__ =
lambda self, name: _swig_getattr(self, SingletonScore, name)
5282 def __init__(self, name="SingletonScore %1%"):
5284 __init__(IMP::kernel::SingletonScore self, std::string name="SingletonScore %1%") -> SingletonScore
5285 __init__(IMP::kernel::SingletonScore self) -> SingletonScore
5287 if self.__class__ == SingletonScore:
5291 this = _IMP_kernel.new_SingletonScore(_self, name)
5292 try: self.this.append(this)
5293 except: self.this = this
5294 if self.__class__ != SingletonScore:
5296 IMP.base._director_objects.register(self)
5300 def evaluate(self, *args):
5301 """evaluate(SingletonScore self, Particle vt, DerivativeAccumulator da) -> double"""
5302 return _IMP_kernel.SingletonScore_evaluate(self, *args)
5304 def evaluate_index(self, *args):
5305 """evaluate_index(SingletonScore self, Model m, IMP::kernel::ParticleIndex vt, DerivativeAccumulator da) -> double"""
5306 return _IMP_kernel.SingletonScore_evaluate_index(self, *args)
5308 def evaluate_indexes(self, *args):
5310 evaluate_indexes(SingletonScore self, Model m, IMP::kernel::ParticleIndexes const & o, DerivativeAccumulator da, unsigned int lower_bound,
5311 unsigned int upper_bound) -> double
5313 return _IMP_kernel.SingletonScore_evaluate_indexes(self, *args)
5315 def evaluate_if_good_index(self, *args):
5316 """evaluate_if_good_index(SingletonScore self, Model m, IMP::kernel::ParticleIndex vt, DerivativeAccumulator da, double max) -> double"""
5317 return _IMP_kernel.SingletonScore_evaluate_if_good_index(self, *args)
5319 def evaluate_if_good_indexes(self, *args):
5321 evaluate_if_good_indexes(SingletonScore self, Model m, IMP::kernel::ParticleIndexes const & o, DerivativeAccumulator da, double max,
5322 unsigned int lower_bound, unsigned int upper_bound) -> double
5324 return _IMP_kernel.SingletonScore_evaluate_if_good_indexes(self, *args)
5326 def create_current_decomposition(self, *args):
5327 """create_current_decomposition(SingletonScore self, Model m, IMP::kernel::ParticleIndex vt) -> IMP::kernel::Restraints"""
5328 return _IMP_kernel.SingletonScore_create_current_decomposition(self, *args)
5331 """get_input_particles(SingletonScore self, Particle p) -> IMP::kernel::ParticlesTemp"""
5332 return _IMP_kernel.SingletonScore_get_input_particles(self, *args)
5335 """get_input_containers(SingletonScore self, Particle p) -> IMP::kernel::ContainersTemp"""
5336 return _IMP_kernel.SingletonScore_get_input_containers(self, *args)
5338 def get_inputs(self, *args):
5339 """get_inputs(SingletonScore self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
5340 return _IMP_kernel.SingletonScore_get_inputs(self, *args)
5342 def _do_get_inputs(self, *args):
5343 """_do_get_inputs(SingletonScore self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
5344 return _IMP_kernel.SingletonScore__do_get_inputs(self, *args)
5346 def do_create_current_decomposition(self, *args):
5347 """do_create_current_decomposition(SingletonScore self, Model m, IMP::kernel::ParticleIndex vt) -> IMP::kernel::Restraints"""
5348 return _IMP_kernel.SingletonScore_do_create_current_decomposition(self, *args)
5350 __swig_destroy__ = _IMP_kernel.delete_SingletonScore
5351 __del__ =
lambda self :
None;
5353 """__str__(SingletonScore self) -> std::string"""
5354 return _IMP_kernel.SingletonScore___str__(self)
5357 """__repr__(SingletonScore self) -> std::string"""
5358 return _IMP_kernel.SingletonScore___repr__(self)
5361 return _object_cast_to_SingletonScore(o)
5362 get_from = staticmethod(get_from)
5364 def get_type_name(self):
5365 return self.__class__.__name__
5366 def do_show(self, out):
5368 def get_version_info(self):
5369 if"IMP::kernel" ==
"IMP":
5370 return VersionInfo(
"python",
"0")
5372 return IMP.VersionInfo(
"python",
"0")
5374 return _object_cast_to_SingletonScore(o)
5375 get_from = staticmethod(get_from)
5377 def __disown__(self):
5379 _IMP_kernel.disown_SingletonScore(self)
5380 return weakref_proxy(self)
5381 SingletonScore_swigregister = _IMP_kernel.SingletonScore_swigregister
5382 SingletonScore_swigregister(SingletonScore)
5385 """Proxy of C++ IMP::kernel::SingletonPredicate class"""
5386 __swig_setmethods__ = {}
5387 for _s
in [
IMP.base.Object]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
5388 __setattr__ =
lambda self, name, value: _swig_setattr(self, SingletonPredicate, name, value)
5389 __swig_getmethods__ = {}
5390 for _s
in [
IMP.base.Object]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
5391 __getattr__ =
lambda self, name: _swig_getattr(self, SingletonPredicate, name)
5392 def __init__(self, name="SingletonPredicate %1%"):
5394 __init__(IMP::kernel::SingletonPredicate self, std::string name="SingletonPredicate %1%") -> SingletonPredicate
5395 __init__(IMP::kernel::SingletonPredicate self) -> SingletonPredicate
5397 if self.__class__ == SingletonPredicate:
5401 this = _IMP_kernel.new_SingletonPredicate(_self, name)
5402 try: self.this.append(this)
5403 except: self.this = this
5404 if self.__class__ != SingletonPredicate:
5406 IMP.base._director_objects.register(self)
5410 def get_value(self, *args):
5412 get_value(SingletonPredicate self, Particle vt) -> int
5413 get_value(SingletonPredicate self, IMP::kernel::ParticlesTemp const & o) -> IMP::Ints
5415 return _IMP_kernel.SingletonPredicate_get_value(self, *args)
5417 def __call__(self, *args):
5418 """__call__(SingletonPredicate self, Model m, IMP::kernel::ParticleIndex vt) -> int"""
5419 return _IMP_kernel.SingletonPredicate___call__(self, *args)
5421 def get_value_index(self, *args):
5423 get_value_index(SingletonPredicate self, Model m, IMP::kernel::ParticleIndex vt) -> int
5424 get_value_index(SingletonPredicate self, Model m, IMP::kernel::ParticleIndexes const & o) -> IMP::Ints
5426 return _IMP_kernel.SingletonPredicate_get_value_index(self, *args)
5429 """get_input_particles(SingletonPredicate self, Particle p) -> IMP::kernel::ParticlesTemp"""
5430 return _IMP_kernel.SingletonPredicate_get_input_particles(self, *args)
5433 """get_input_containers(SingletonPredicate self, Particle p) -> IMP::kernel::ContainersTemp"""
5434 return _IMP_kernel.SingletonPredicate_get_input_containers(self, *args)
5436 def get_inputs(self, *args):
5437 """get_inputs(SingletonPredicate self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
5438 return _IMP_kernel.SingletonPredicate_get_inputs(self, *args)
5440 def _do_get_inputs(self, *args):
5441 """_do_get_inputs(SingletonPredicate self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
5442 return _IMP_kernel.SingletonPredicate__do_get_inputs(self, *args)
5444 __swig_destroy__ = _IMP_kernel.delete_SingletonPredicate
5445 __del__ =
lambda self :
None;
5447 """__str__(SingletonPredicate self) -> std::string"""
5448 return _IMP_kernel.SingletonPredicate___str__(self)
5451 """__repr__(SingletonPredicate self) -> std::string"""
5452 return _IMP_kernel.SingletonPredicate___repr__(self)
5455 return _object_cast_to_SingletonPredicate(o)
5456 get_from = staticmethod(get_from)
5458 def get_type_name(self):
5459 return self.__class__.__name__
5460 def do_show(self, out):
5462 def get_version_info(self):
5463 if"IMP::kernel" ==
"IMP":
5464 return VersionInfo(
"python",
"0")
5466 return IMP.VersionInfo(
"python",
"0")
5468 return _object_cast_to_SingletonPredicate(o)
5469 get_from = staticmethod(get_from)
5471 def __disown__(self):
5473 _IMP_kernel.disown_SingletonPredicate(self)
5474 return weakref_proxy(self)
5475 SingletonPredicate_swigregister = _IMP_kernel.SingletonPredicate_swigregister
5476 SingletonPredicate_swigregister(SingletonPredicate)
5479 """Proxy of C++ IMP::kernel::SingletonContainer class"""
5480 __swig_setmethods__ = {}
5481 for _s
in [Container]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
5482 __setattr__ =
lambda self, name, value: _swig_setattr(self, SingletonContainer, name, value)
5483 __swig_getmethods__ = {}
5484 for _s
in [Container]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
5485 __getattr__ =
lambda self, name: _swig_getattr(self, SingletonContainer, name)
5486 def __init__(self, *args):
5488 __init__(IMP::kernel::SingletonContainer self, Model m, std::string name="SingletonContainer %1%") -> SingletonContainer
5489 __init__(IMP::kernel::SingletonContainer self, Model m) -> SingletonContainer
5491 if self.__class__ == SingletonContainer:
5495 this = _IMP_kernel.new_SingletonContainer(_self, *args)
5496 try: self.this.append(this)
5497 except: self.this = this
5498 if self.__class__ != SingletonContainer:
5500 IMP.base._director_objects.register(self)
5504 def apply_generic(self, *args):
5505 """apply_generic(SingletonContainer self, SingletonModifier m)"""
5506 return _IMP_kernel.SingletonContainer_apply_generic(self, *args)
5508 def apply(self, *args):
5509 """apply(SingletonContainer self, SingletonModifier sm)"""
5510 return _IMP_kernel.SingletonContainer_apply(self, *args)
5513 """get_indexes(SingletonContainer self) -> IMP::kernel::ParticleIndexes"""
5514 return _IMP_kernel.SingletonContainer_get_indexes(self)
5516 def get_range_indexes(self):
5517 """get_range_indexes(SingletonContainer self) -> IMP::kernel::ParticleIndexes"""
5518 return _IMP_kernel.SingletonContainer_get_range_indexes(self)
5520 def get(self, *args):
5522 get(SingletonContainer self) -> IMP::kernel::ParticlesTemp
5523 get(SingletonContainer self, unsigned int i) -> Particle
5525 return _IMP_kernel.SingletonContainer_get(self, *args)
5527 def get_number(self):
5528 """get_number(SingletonContainer self) -> unsigned int"""
5529 return _IMP_kernel.SingletonContainer_get_number(self)
5532 """get_particles(SingletonContainer self) -> IMP::kernel::ParticlesTemp"""
5533 return _IMP_kernel.SingletonContainer_get_particles(self)
5535 def get_contains_particle(self, *args):
5536 """get_contains_particle(SingletonContainer self, Particle v) -> bool"""
5537 return _IMP_kernel.SingletonContainer_get_contains_particle(self, *args)
5539 def get_number_of_particles(self):
5540 """get_number_of_particles(SingletonContainer self) -> unsigned int"""
5541 return _IMP_kernel.SingletonContainer_get_number_of_particles(self)
5543 def get_particle(self, *args):
5544 """get_particle(SingletonContainer self, unsigned int i) -> Particle"""
5545 return _IMP_kernel.SingletonContainer_get_particle(self, *args)
5547 def do_apply(self, *args):
5548 """do_apply(SingletonContainer self, SingletonModifier sm)"""
5549 return _IMP_kernel.SingletonContainer_do_apply(self, *args)
5551 def do_get_provides_access(self):
5552 """do_get_provides_access(SingletonContainer self) -> bool"""
5553 return _IMP_kernel.SingletonContainer_do_get_provides_access(self)
5555 __swig_destroy__ = _IMP_kernel.delete_SingletonContainer
5556 __del__ =
lambda self :
None;
5558 """__str__(SingletonContainer self) -> std::string"""
5559 return _IMP_kernel.SingletonContainer___str__(self)
5562 """__repr__(SingletonContainer self) -> std::string"""
5563 return _IMP_kernel.SingletonContainer___repr__(self)
5566 return _object_cast_to_SingletonContainer(o)
5567 get_from = staticmethod(get_from)
5569 def get_type_name(self):
5570 return self.__class__.__name__
5571 def do_show(self, out):
5573 def get_version_info(self):
5574 if"IMP::kernel" ==
"IMP":
5575 return VersionInfo(
"python",
"0")
5577 return IMP.VersionInfo(
"python",
"0")
5579 return _object_cast_to_SingletonContainer(o)
5580 get_from = staticmethod(get_from)
5582 def __disown__(self):
5584 _IMP_kernel.disown_SingletonContainer(self)
5585 return weakref_proxy(self)
5586 def update_dependencies(self):
5587 """update_dependencies(SingletonContainer self)"""
5588 return _IMP_kernel.SingletonContainer_update_dependencies(self)
5590 def do_get_inputs(self):
5591 """do_get_inputs(SingletonContainer self) -> IMP::kernel::ModelObjectsTemp"""
5592 return _IMP_kernel.SingletonContainer_do_get_inputs(self)
5594 def do_get_interactions(self):
5595 """do_get_interactions(SingletonContainer self) -> IMP::kernel::ModelObjectsTemps"""
5596 return _IMP_kernel.SingletonContainer_do_get_interactions(self)
5598 def do_before_evaluate(self):
5599 """do_before_evaluate(SingletonContainer self)"""
5600 return _IMP_kernel.SingletonContainer_do_before_evaluate(self)
5602 def do_update_dependencies(self):
5603 """do_update_dependencies(SingletonContainer self)"""
5604 return _IMP_kernel.SingletonContainer_do_update_dependencies(self)
5606 SingletonContainer_swigregister = _IMP_kernel.SingletonContainer_swigregister
5607 SingletonContainer_swigregister(SingletonContainer)
5609 class _SingletonContainerAdaptor(IMP.base._InputAdaptor):
5610 """Proxy of C++ IMP::kernel::SingletonContainerAdaptor class"""
5611 __swig_setmethods__ = {}
5612 for _s
in [IMP.base._InputAdaptor]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
5613 __setattr__ =
lambda self, name, value: _swig_setattr(self, _SingletonContainerAdaptor, name, value)
5614 __swig_getmethods__ = {}
5615 for _s
in [IMP.base._InputAdaptor]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
5616 __getattr__ =
lambda self, name: _swig_getattr(self, _SingletonContainerAdaptor, name)
5617 __repr__ = _swig_repr
5618 def __init__(self, *args):
5620 __init__(IMP::kernel::SingletonContainerAdaptor self) -> _SingletonContainerAdaptor
5621 __init__(IMP::kernel::SingletonContainerAdaptor self, SingletonContainer c) -> _SingletonContainerAdaptor
5622 __init__(IMP::kernel::SingletonContainerAdaptor self, IMP::kernel::ParticlesTemp const & t, std::string name="SingletonContainerAdaptor%1%") -> _SingletonContainerAdaptor
5623 __init__(IMP::kernel::SingletonContainerAdaptor self, IMP::kernel::ParticlesTemp const & t) -> _SingletonContainerAdaptor
5625 this = _IMP_kernel.new__SingletonContainerAdaptor(*args)
5626 try: self.this.append(this)
5627 except: self.this = this
5628 __swig_destroy__ = _IMP_kernel.delete__SingletonContainerAdaptor
5629 __del__ =
lambda self :
None;
5630 _SingletonContainerAdaptor_swigregister = _IMP_kernel._SingletonContainerAdaptor_swigregister
5631 _SingletonContainerAdaptor_swigregister(_SingletonContainerAdaptor)
5634 """Proxy of C++ IMP::kernel::TripletModifier class"""
5635 __swig_setmethods__ = {}
5636 for _s
in [
IMP.base.Object]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
5637 __setattr__ =
lambda self, name, value: _swig_setattr(self, TripletModifier, name, value)
5638 __swig_getmethods__ = {}
5639 for _s
in [
IMP.base.Object]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
5640 __getattr__ =
lambda self, name: _swig_getattr(self, TripletModifier, name)
5641 def __init__(self, name="TripletModifier %1%"):
5643 __init__(IMP::kernel::TripletModifier self, std::string name="TripletModifier %1%") -> TripletModifier
5644 __init__(IMP::kernel::TripletModifier self) -> TripletModifier
5646 if self.__class__ == TripletModifier:
5650 this = _IMP_kernel.new_TripletModifier(_self, name)
5651 try: self.this.append(this)
5652 except: self.this = this
5653 if self.__class__ != TripletModifier:
5655 IMP.base._director_objects.register(self)
5659 def apply(self, *args):
5660 """apply(TripletModifier self, IMP::kernel::ParticleTriplet const & arg0)"""
5661 return _IMP_kernel.TripletModifier_apply(self, *args)
5663 def apply_index(self, *args):
5664 """apply_index(TripletModifier self, Model m, IMP::kernel::ParticleIndexTriplet const & v)"""
5665 return _IMP_kernel.TripletModifier_apply_index(self, *args)
5667 def apply_indexes(self, *args):
5669 apply_indexes(TripletModifier self, Model m, IMP::kernel::ParticleIndexTriplets const & o, unsigned int lower_bound,
5670 unsigned int upper_bound)
5672 return _IMP_kernel.TripletModifier_apply_indexes(self, *args)
5675 """get_input_particles(TripletModifier self, Particle p) -> IMP::kernel::ParticlesTemp"""
5676 return _IMP_kernel.TripletModifier_get_input_particles(self, *args)
5679 """get_input_containers(TripletModifier self, Particle p) -> IMP::kernel::ContainersTemp"""
5680 return _IMP_kernel.TripletModifier_get_input_containers(self, *args)
5682 def get_inputs(self, *args):
5683 """get_inputs(TripletModifier self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
5684 return _IMP_kernel.TripletModifier_get_inputs(self, *args)
5686 def _do_get_inputs(self, *args):
5687 """_do_get_inputs(TripletModifier self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
5688 return _IMP_kernel.TripletModifier__do_get_inputs(self, *args)
5691 """get_output_particles(TripletModifier self, Particle p) -> IMP::kernel::ParticlesTemp"""
5692 return _IMP_kernel.TripletModifier_get_output_particles(self, *args)
5695 """get_output_containers(TripletModifier self, Particle p) -> IMP::kernel::ContainersTemp"""
5696 return _IMP_kernel.TripletModifier_get_output_containers(self, *args)
5698 def get_outputs(self, *args):
5699 """get_outputs(TripletModifier self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
5700 return _IMP_kernel.TripletModifier_get_outputs(self, *args)
5702 def _do_get_outputs(self, *args):
5703 """_do_get_outputs(TripletModifier self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
5704 return _IMP_kernel.TripletModifier__do_get_outputs(self, *args)
5707 """__str__(TripletModifier self) -> std::string"""
5708 return _IMP_kernel.TripletModifier___str__(self)
5711 """__repr__(TripletModifier self) -> std::string"""
5712 return _IMP_kernel.TripletModifier___repr__(self)
5715 return _object_cast_to_TripletModifier(o)
5716 get_from = staticmethod(get_from)
5718 def get_type_name(self):
5719 return self.__class__.__name__
5720 def do_show(self, out):
5722 def get_version_info(self):
5723 if"IMP::kernel" ==
"IMP":
5724 return VersionInfo(
"python",
"0")
5726 return IMP.VersionInfo(
"python",
"0")
5728 return _object_cast_to_TripletModifier(o)
5729 get_from = staticmethod(get_from)
5731 __swig_destroy__ = _IMP_kernel.delete_TripletModifier
5732 __del__ =
lambda self :
None;
5733 def __disown__(self):
5735 _IMP_kernel.disown_TripletModifier(self)
5736 return weakref_proxy(self)
5737 TripletModifier_swigregister = _IMP_kernel.TripletModifier_swigregister
5738 TripletModifier_swigregister(TripletModifier)
5741 """Proxy of C++ IMP::kernel::TripletScore class"""
5742 __swig_setmethods__ = {}
5743 for _s
in [
IMP.base.Object]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
5744 __setattr__ =
lambda self, name, value: _swig_setattr(self, TripletScore, name, value)
5745 __swig_getmethods__ = {}
5746 for _s
in [
IMP.base.Object]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
5747 __getattr__ =
lambda self, name: _swig_getattr(self, TripletScore, name)
5748 def __init__(self, name="TripletScore %1%"):
5750 __init__(IMP::kernel::TripletScore self, std::string name="TripletScore %1%") -> TripletScore
5751 __init__(IMP::kernel::TripletScore self) -> TripletScore
5753 if self.__class__ == TripletScore:
5757 this = _IMP_kernel.new_TripletScore(_self, name)
5758 try: self.this.append(this)
5759 except: self.this = this
5760 if self.__class__ != TripletScore:
5762 IMP.base._director_objects.register(self)
5766 def evaluate(self, *args):
5767 """evaluate(TripletScore self, IMP::kernel::ParticleTriplet const & vt, DerivativeAccumulator da) -> double"""
5768 return _IMP_kernel.TripletScore_evaluate(self, *args)
5770 def evaluate_index(self, *args):
5771 """evaluate_index(TripletScore self, Model m, IMP::kernel::ParticleIndexTriplet const & vt, DerivativeAccumulator da) -> double"""
5772 return _IMP_kernel.TripletScore_evaluate_index(self, *args)
5774 def evaluate_indexes(self, *args):
5776 evaluate_indexes(TripletScore self, Model m, IMP::kernel::ParticleIndexTriplets const & o, DerivativeAccumulator da,
5777 unsigned int lower_bound, unsigned int upper_bound) -> double
5779 return _IMP_kernel.TripletScore_evaluate_indexes(self, *args)
5781 def evaluate_if_good_index(self, *args):
5783 evaluate_if_good_index(TripletScore self, Model m, IMP::kernel::ParticleIndexTriplet const & vt, DerivativeAccumulator da,
5784 double max) -> double
5786 return _IMP_kernel.TripletScore_evaluate_if_good_index(self, *args)
5788 def evaluate_if_good_indexes(self, *args):
5790 evaluate_if_good_indexes(TripletScore self, Model m, IMP::kernel::ParticleIndexTriplets const & o, DerivativeAccumulator da,
5791 double max, unsigned int lower_bound, unsigned int upper_bound) -> double
5793 return _IMP_kernel.TripletScore_evaluate_if_good_indexes(self, *args)
5795 def create_current_decomposition(self, *args):
5796 """create_current_decomposition(TripletScore self, Model m, IMP::kernel::ParticleIndexTriplet const & vt) -> IMP::kernel::Restraints"""
5797 return _IMP_kernel.TripletScore_create_current_decomposition(self, *args)
5800 """get_input_particles(TripletScore self, Particle p) -> IMP::kernel::ParticlesTemp"""
5801 return _IMP_kernel.TripletScore_get_input_particles(self, *args)
5804 """get_input_containers(TripletScore self, Particle p) -> IMP::kernel::ContainersTemp"""
5805 return _IMP_kernel.TripletScore_get_input_containers(self, *args)
5807 def get_inputs(self, *args):
5808 """get_inputs(TripletScore self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
5809 return _IMP_kernel.TripletScore_get_inputs(self, *args)
5811 def _do_get_inputs(self, *args):
5812 """_do_get_inputs(TripletScore self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
5813 return _IMP_kernel.TripletScore__do_get_inputs(self, *args)
5815 def do_create_current_decomposition(self, *args):
5816 """do_create_current_decomposition(TripletScore self, Model m, IMP::kernel::ParticleIndexTriplet const & vt) -> IMP::kernel::Restraints"""
5817 return _IMP_kernel.TripletScore_do_create_current_decomposition(self, *args)
5819 __swig_destroy__ = _IMP_kernel.delete_TripletScore
5820 __del__ =
lambda self :
None;
5822 """__str__(TripletScore self) -> std::string"""
5823 return _IMP_kernel.TripletScore___str__(self)
5826 """__repr__(TripletScore self) -> std::string"""
5827 return _IMP_kernel.TripletScore___repr__(self)
5830 return _object_cast_to_TripletScore(o)
5831 get_from = staticmethod(get_from)
5833 def get_type_name(self):
5834 return self.__class__.__name__
5835 def do_show(self, out):
5837 def get_version_info(self):
5838 if"IMP::kernel" ==
"IMP":
5839 return VersionInfo(
"python",
"0")
5841 return IMP.VersionInfo(
"python",
"0")
5843 return _object_cast_to_TripletScore(o)
5844 get_from = staticmethod(get_from)
5846 def __disown__(self):
5848 _IMP_kernel.disown_TripletScore(self)
5849 return weakref_proxy(self)
5850 TripletScore_swigregister = _IMP_kernel.TripletScore_swigregister
5851 TripletScore_swigregister(TripletScore)
5854 """Proxy of C++ IMP::kernel::TripletPredicate class"""
5855 __swig_setmethods__ = {}
5856 for _s
in [
IMP.base.Object]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
5857 __setattr__ =
lambda self, name, value: _swig_setattr(self, TripletPredicate, name, value)
5858 __swig_getmethods__ = {}
5859 for _s
in [
IMP.base.Object]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
5860 __getattr__ =
lambda self, name: _swig_getattr(self, TripletPredicate, name)
5861 def __init__(self, name="TripletPredicate %1%"):
5863 __init__(IMP::kernel::TripletPredicate self, std::string name="TripletPredicate %1%") -> TripletPredicate
5864 __init__(IMP::kernel::TripletPredicate self) -> TripletPredicate
5866 if self.__class__ == TripletPredicate:
5870 this = _IMP_kernel.new_TripletPredicate(_self, name)
5871 try: self.this.append(this)
5872 except: self.this = this
5873 if self.__class__ != TripletPredicate:
5875 IMP.base._director_objects.register(self)
5879 def get_value(self, *args):
5881 get_value(TripletPredicate self, IMP::kernel::ParticleTriplet const & vt) -> int
5882 get_value(TripletPredicate self, IMP::kernel::ParticleTripletsTemp const & o) -> IMP::Ints
5884 return _IMP_kernel.TripletPredicate_get_value(self, *args)
5886 def __call__(self, *args):
5887 """__call__(TripletPredicate self, Model m, IMP::kernel::ParticleIndexTriplet const & vt) -> int"""
5888 return _IMP_kernel.TripletPredicate___call__(self, *args)
5890 def get_value_index(self, *args):
5892 get_value_index(TripletPredicate self, Model m, IMP::kernel::ParticleIndexTriplet const & vt) -> int
5893 get_value_index(TripletPredicate self, Model m, IMP::kernel::ParticleIndexTriplets const & o) -> IMP::Ints
5895 return _IMP_kernel.TripletPredicate_get_value_index(self, *args)
5898 """get_input_particles(TripletPredicate self, Particle p) -> IMP::kernel::ParticlesTemp"""
5899 return _IMP_kernel.TripletPredicate_get_input_particles(self, *args)
5902 """get_input_containers(TripletPredicate self, Particle p) -> IMP::kernel::ContainersTemp"""
5903 return _IMP_kernel.TripletPredicate_get_input_containers(self, *args)
5905 def get_inputs(self, *args):
5906 """get_inputs(TripletPredicate self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
5907 return _IMP_kernel.TripletPredicate_get_inputs(self, *args)
5909 def _do_get_inputs(self, *args):
5910 """_do_get_inputs(TripletPredicate self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
5911 return _IMP_kernel.TripletPredicate__do_get_inputs(self, *args)
5913 __swig_destroy__ = _IMP_kernel.delete_TripletPredicate
5914 __del__ =
lambda self :
None;
5916 """__str__(TripletPredicate self) -> std::string"""
5917 return _IMP_kernel.TripletPredicate___str__(self)
5920 """__repr__(TripletPredicate self) -> std::string"""
5921 return _IMP_kernel.TripletPredicate___repr__(self)
5924 return _object_cast_to_TripletPredicate(o)
5925 get_from = staticmethod(get_from)
5927 def get_type_name(self):
5928 return self.__class__.__name__
5929 def do_show(self, out):
5931 def get_version_info(self):
5932 if"IMP::kernel" ==
"IMP":
5933 return VersionInfo(
"python",
"0")
5935 return IMP.VersionInfo(
"python",
"0")
5937 return _object_cast_to_TripletPredicate(o)
5938 get_from = staticmethod(get_from)
5940 def __disown__(self):
5942 _IMP_kernel.disown_TripletPredicate(self)
5943 return weakref_proxy(self)
5944 TripletPredicate_swigregister = _IMP_kernel.TripletPredicate_swigregister
5945 TripletPredicate_swigregister(TripletPredicate)
5948 """Proxy of C++ IMP::kernel::TripletContainer class"""
5949 __swig_setmethods__ = {}
5950 for _s
in [Container]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
5951 __setattr__ =
lambda self, name, value: _swig_setattr(self, TripletContainer, name, value)
5952 __swig_getmethods__ = {}
5953 for _s
in [Container]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
5954 __getattr__ =
lambda self, name: _swig_getattr(self, TripletContainer, name)
5955 def __init__(self, *args):
5957 __init__(IMP::kernel::TripletContainer self, Model m, std::string name="TripletContainer %1%") -> TripletContainer
5958 __init__(IMP::kernel::TripletContainer self, Model m) -> TripletContainer
5960 if self.__class__ == TripletContainer:
5964 this = _IMP_kernel.new_TripletContainer(_self, *args)
5965 try: self.this.append(this)
5966 except: self.this = this
5967 if self.__class__ != TripletContainer:
5969 IMP.base._director_objects.register(self)
5973 def apply_generic(self, *args):
5974 """apply_generic(TripletContainer self, TripletModifier m)"""
5975 return _IMP_kernel.TripletContainer_apply_generic(self, *args)
5977 def apply(self, *args):
5978 """apply(TripletContainer self, TripletModifier sm)"""
5979 return _IMP_kernel.TripletContainer_apply(self, *args)
5982 """get_indexes(TripletContainer self) -> IMP::kernel::ParticleIndexTriplets"""
5983 return _IMP_kernel.TripletContainer_get_indexes(self)
5985 def get_range_indexes(self):
5986 """get_range_indexes(TripletContainer self) -> IMP::kernel::ParticleIndexTriplets"""
5987 return _IMP_kernel.TripletContainer_get_range_indexes(self)
5989 def get(self, *args):
5991 get(TripletContainer self) -> IMP::kernel::ParticleTripletsTemp
5992 get(TripletContainer self, unsigned int i) -> IMP::kernel::ParticleTriplet
5994 return _IMP_kernel.TripletContainer_get(self, *args)
5996 def get_number(self):
5997 """get_number(TripletContainer self) -> unsigned int"""
5998 return _IMP_kernel.TripletContainer_get_number(self)
6000 def get_particle_triplets(self):
6001 """get_particle_triplets(TripletContainer self) -> IMP::kernel::ParticleTripletsTemp"""
6002 return _IMP_kernel.TripletContainer_get_particle_triplets(self)
6004 def get_contains_particle_triplet(self, *args):
6005 """get_contains_particle_triplet(TripletContainer self, IMP::kernel::ParticleTriplet v) -> bool"""
6006 return _IMP_kernel.TripletContainer_get_contains_particle_triplet(self, *args)
6008 def get_number_of_particle_triplets(self):
6009 """get_number_of_particle_triplets(TripletContainer self) -> unsigned int"""
6010 return _IMP_kernel.TripletContainer_get_number_of_particle_triplets(self)
6012 def get_particle_triplet(self, *args):
6013 """get_particle_triplet(TripletContainer self, unsigned int i) -> IMP::kernel::ParticleTriplet"""
6014 return _IMP_kernel.TripletContainer_get_particle_triplet(self, *args)
6016 def do_apply(self, *args):
6017 """do_apply(TripletContainer self, TripletModifier sm)"""
6018 return _IMP_kernel.TripletContainer_do_apply(self, *args)
6020 def do_get_provides_access(self):
6021 """do_get_provides_access(TripletContainer self) -> bool"""
6022 return _IMP_kernel.TripletContainer_do_get_provides_access(self)
6024 __swig_destroy__ = _IMP_kernel.delete_TripletContainer
6025 __del__ =
lambda self :
None;
6027 """__str__(TripletContainer self) -> std::string"""
6028 return _IMP_kernel.TripletContainer___str__(self)
6031 """__repr__(TripletContainer self) -> std::string"""
6032 return _IMP_kernel.TripletContainer___repr__(self)
6035 return _object_cast_to_TripletContainer(o)
6036 get_from = staticmethod(get_from)
6038 def get_type_name(self):
6039 return self.__class__.__name__
6040 def do_show(self, out):
6042 def get_version_info(self):
6043 if"IMP::kernel" ==
"IMP":
6044 return VersionInfo(
"python",
"0")
6046 return IMP.VersionInfo(
"python",
"0")
6048 return _object_cast_to_TripletContainer(o)
6049 get_from = staticmethod(get_from)
6051 def __disown__(self):
6053 _IMP_kernel.disown_TripletContainer(self)
6054 return weakref_proxy(self)
6055 def update_dependencies(self):
6056 """update_dependencies(TripletContainer self)"""
6057 return _IMP_kernel.TripletContainer_update_dependencies(self)
6059 def do_get_inputs(self):
6060 """do_get_inputs(TripletContainer self) -> IMP::kernel::ModelObjectsTemp"""
6061 return _IMP_kernel.TripletContainer_do_get_inputs(self)
6063 def do_get_interactions(self):
6064 """do_get_interactions(TripletContainer self) -> IMP::kernel::ModelObjectsTemps"""
6065 return _IMP_kernel.TripletContainer_do_get_interactions(self)
6067 def do_before_evaluate(self):
6068 """do_before_evaluate(TripletContainer self)"""
6069 return _IMP_kernel.TripletContainer_do_before_evaluate(self)
6071 def do_update_dependencies(self):
6072 """do_update_dependencies(TripletContainer self)"""
6073 return _IMP_kernel.TripletContainer_do_update_dependencies(self)
6075 TripletContainer_swigregister = _IMP_kernel.TripletContainer_swigregister
6076 TripletContainer_swigregister(TripletContainer)
6078 class _TripletContainerAdaptor(IMP.base._InputAdaptor):
6079 """Proxy of C++ IMP::kernel::TripletContainerAdaptor class"""
6080 __swig_setmethods__ = {}
6081 for _s
in [IMP.base._InputAdaptor]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
6082 __setattr__ =
lambda self, name, value: _swig_setattr(self, _TripletContainerAdaptor, name, value)
6083 __swig_getmethods__ = {}
6084 for _s
in [IMP.base._InputAdaptor]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
6085 __getattr__ =
lambda self, name: _swig_getattr(self, _TripletContainerAdaptor, name)
6086 __repr__ = _swig_repr
6087 def __init__(self, *args):
6089 __init__(IMP::kernel::TripletContainerAdaptor self) -> _TripletContainerAdaptor
6090 __init__(IMP::kernel::TripletContainerAdaptor self, TripletContainer c) -> _TripletContainerAdaptor
6091 __init__(IMP::kernel::TripletContainerAdaptor self, IMP::kernel::ParticleTripletsTemp const & t, std::string name="TripletContainerAdaptor%1%") -> _TripletContainerAdaptor
6092 __init__(IMP::kernel::TripletContainerAdaptor self, IMP::kernel::ParticleTripletsTemp const & t) -> _TripletContainerAdaptor
6094 this = _IMP_kernel.new__TripletContainerAdaptor(*args)
6095 try: self.this.append(this)
6096 except: self.this = this
6097 __swig_destroy__ = _IMP_kernel.delete__TripletContainerAdaptor
6098 __del__ =
lambda self :
None;
6099 _TripletContainerAdaptor_swigregister = _IMP_kernel._TripletContainerAdaptor_swigregister
6100 _TripletContainerAdaptor_swigregister(_TripletContainerAdaptor)
6104 """write_particles_to_buffer(IMP::kernel::ParticlesTemp const & particles, IMP::kernel::FloatKeys const & keys) -> IMP::base::Vector< char >"""
6105 return _IMP_kernel.write_particles_to_buffer(*args)
6109 read_particles_from_buffer(IMP::base::Vector< char > const & buffer, IMP::kernel::ParticlesTemp const & particles,
6110 IMP::kernel::FloatKeys const & keys)
6112 return _IMP_kernel.read_particles_from_buffer(*args)
6114 """Proxy of C++ IMP::kernel::internal::_ConstRestraint class"""
6115 __swig_setmethods__ = {}
6116 for _s
in [Restraint]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
6117 __setattr__ =
lambda self, name, value: _swig_setattr(self, _ConstRestraint, name, value)
6118 __swig_getmethods__ = {}
6119 for _s
in [Restraint]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
6120 __getattr__ =
lambda self, name: _swig_getattr(self, _ConstRestraint, name)
6121 def __init__(self, *args):
6123 __init__(IMP::kernel::internal::_ConstRestraint self, double v, IMP::kernel::ParticlesTemp const ps) -> _ConstRestraint
6124 __init__(IMP::kernel::internal::_ConstRestraint self, double v) -> _ConstRestraint
6125 __init__(IMP::kernel::internal::_ConstRestraint self, Model m, IMP::kernel::ParticleIndexes const & pis, double v) -> _ConstRestraint
6127 this = _IMP_kernel.new__ConstRestraint(*args)
6128 try: self.this.append(this)
6129 except: self.this = this
6130 def get_value(self):
6131 """get_value(_ConstRestraint self) -> double"""
6132 return _IMP_kernel._ConstRestraint_get_value(self)
6134 def do_create_decomposition(self):
6135 """do_create_decomposition(_ConstRestraint self) -> IMP::kernel::Restraints"""
6136 return _IMP_kernel._ConstRestraint_do_create_decomposition(self)
6139 """get_input_particles(_ConstRestraint self) -> IMP::kernel::ParticlesTemp"""
6140 return _IMP_kernel._ConstRestraint_get_input_particles(self)
6143 """get_input_containers(_ConstRestraint self) -> IMP::kernel::ContainersTemp"""
6144 return _IMP_kernel._ConstRestraint_get_input_containers(self)
6146 def do_get_inputs(self):
6147 """do_get_inputs(_ConstRestraint self) -> IMP::kernel::ModelObjectsTemp"""
6148 return _IMP_kernel._ConstRestraint_do_get_inputs(self)
6150 def get_version_info(self):
6151 """get_version_info(_ConstRestraint self) -> VersionInfo"""
6152 return _IMP_kernel._ConstRestraint_get_version_info(self)
6154 def do_show(self, *args):
6155 """do_show(_ConstRestraint self, _ostream out)"""
6156 return _IMP_kernel._ConstRestraint_do_show(self, *args)
6158 __swig_destroy__ = _IMP_kernel.delete__ConstRestraint
6159 __del__ =
lambda self :
None;
6161 """__str__(_ConstRestraint self) -> std::string"""
6162 return _IMP_kernel._ConstRestraint___str__(self)
6165 """__repr__(_ConstRestraint self) -> std::string"""
6166 return _IMP_kernel._ConstRestraint___repr__(self)
6169 return _object_cast_to__ConstRestraint(o)
6170 get_from = staticmethod(get_from)
6172 _ConstRestraint_swigregister = _IMP_kernel._ConstRestraint_swigregister
6173 _ConstRestraint_swigregister(_ConstRestraint)
6176 """Proxy of C++ IMP::kernel::internal::_ConstSingletonScore class"""
6177 __swig_setmethods__ = {}
6178 for _s
in [SingletonScore]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
6179 __setattr__ =
lambda self, name, value: _swig_setattr(self, _ConstSingletonScore, name, value)
6180 __swig_getmethods__ = {}
6181 for _s
in [SingletonScore]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
6182 __getattr__ =
lambda self, name: _swig_getattr(self, _ConstSingletonScore, name)
6183 __repr__ = _swig_repr
6184 def __init__(self, *args):
6185 """__init__(IMP::kernel::internal::_ConstSingletonScore self, double v) -> _ConstSingletonScore"""
6186 this = _IMP_kernel.new__ConstSingletonScore(*args)
6187 try: self.this.append(this)
6188 except: self.this = this
6190 """get_input_particles(_ConstSingletonScore self, Particle arg2) -> IMP::kernel::ParticlesTemp"""
6191 return _IMP_kernel._ConstSingletonScore_get_input_particles(self, *args)
6194 """get_input_containers(_ConstSingletonScore self, Particle arg2) -> IMP::kernel::ContainersTemp"""
6195 return _IMP_kernel._ConstSingletonScore_get_input_containers(self, *args)
6197 def get_version_info(self):
6198 """get_version_info(_ConstSingletonScore self) -> VersionInfo"""
6199 return _IMP_kernel._ConstSingletonScore_get_version_info(self)
6201 def do_show(self, *args):
6202 """do_show(_ConstSingletonScore self, _ostream out)"""
6203 return _IMP_kernel._ConstSingletonScore_do_show(self, *args)
6205 __swig_destroy__ = _IMP_kernel.delete__ConstSingletonScore
6206 __del__ =
lambda self :
None;
6207 _ConstSingletonScore_swigregister = _IMP_kernel._ConstSingletonScore_swigregister
6208 _ConstSingletonScore_swigregister(_ConstSingletonScore)
6211 """Proxy of C++ IMP::kernel::internal::_ConstPairScore class"""
6212 __swig_setmethods__ = {}
6213 for _s
in [PairScore]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
6214 __setattr__ =
lambda self, name, value: _swig_setattr(self, _ConstPairScore, name, value)
6215 __swig_getmethods__ = {}
6216 for _s
in [PairScore]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
6217 __getattr__ =
lambda self, name: _swig_getattr(self, _ConstPairScore, name)
6218 __repr__ = _swig_repr
6219 def __init__(self, *args):
6220 """__init__(IMP::kernel::internal::_ConstPairScore self, double v) -> _ConstPairScore"""
6221 this = _IMP_kernel.new__ConstPairScore(*args)
6222 try: self.this.append(this)
6223 except: self.this = this
6225 """get_input_particles(_ConstPairScore self, Particle arg2) -> IMP::kernel::ParticlesTemp"""
6226 return _IMP_kernel._ConstPairScore_get_input_particles(self, *args)
6229 """get_input_containers(_ConstPairScore self, Particle arg2) -> IMP::kernel::ContainersTemp"""
6230 return _IMP_kernel._ConstPairScore_get_input_containers(self, *args)
6232 def get_version_info(self):
6233 """get_version_info(_ConstPairScore self) -> VersionInfo"""
6234 return _IMP_kernel._ConstPairScore_get_version_info(self)
6236 def do_show(self, *args):
6237 """do_show(_ConstPairScore self, _ostream out)"""
6238 return _IMP_kernel._ConstPairScore_do_show(self, *args)
6240 __swig_destroy__ = _IMP_kernel.delete__ConstPairScore
6241 __del__ =
lambda self :
None;
6242 _ConstPairScore_swigregister = _IMP_kernel._ConstPairScore_swigregister
6243 _ConstPairScore_swigregister(_ConstPairScore)
6246 """Proxy of C++ IMP::kernel::internal::_TrivialDecorator class"""
6247 __swig_setmethods__ = {}
6248 for _s
in [Decorator]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
6249 __setattr__ =
lambda self, name, value: _swig_setattr(self, _TrivialDecorator, name, value)
6250 __swig_getmethods__ = {}
6251 for _s
in [Decorator]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
6252 __getattr__ =
lambda self, name: _swig_getattr(self, _TrivialDecorator, name)
6253 def __init__(self, *args):
6255 __init__(IMP::kernel::internal::_TrivialDecorator self) -> _TrivialDecorator
6256 __init__(IMP::kernel::internal::_TrivialDecorator self, Model m, IMP::kernel::ParticleIndex id) -> _TrivialDecorator
6257 __init__(IMP::kernel::internal::_TrivialDecorator self, Particle p) -> _TrivialDecorator
6259 this = _IMP_kernel.new__TrivialDecorator(*args)
6260 try: self.this.append(this)
6261 except: self.this = this
6262 def decorate_particle(*args):
6263 """decorate_particle(Particle p) -> _TrivialDecorator"""
6264 return _IMP_kernel._TrivialDecorator_decorate_particle(*args)
6266 if _newclass:decorate_particle = staticmethod(decorate_particle)
6267 __swig_getmethods__[
"decorate_particle"] =
lambda x: decorate_particle
6268 def show(self, *args):
6270 show(_TrivialDecorator self, _ostream out=std::cout)
6271 show(_TrivialDecorator self)
6273 return _IMP_kernel._TrivialDecorator_show(self, *args)
6275 def setup_particle(*args):
6276 """setup_particle(Particle p) -> _TrivialDecorator"""
6277 return _IMP_kernel._TrivialDecorator_setup_particle(*args)
6279 if _newclass:setup_particle = staticmethod(setup_particle)
6280 __swig_getmethods__[
"setup_particle"] =
lambda x: setup_particle
6281 def particle_is_instance(*args):
6282 """particle_is_instance(Particle p) -> bool"""
6283 return _IMP_kernel._TrivialDecorator_particle_is_instance(*args)
6285 if _newclass:particle_is_instance = staticmethod(particle_is_instance)
6286 __swig_getmethods__[
"particle_is_instance"] =
lambda x: particle_is_instance
6287 def add_attribute(self, *args):
6289 add_attribute(_TrivialDecorator self, FloatKey k, IMP::Float v, bool opt)
6290 add_attribute(_TrivialDecorator self, FloatKey a0, IMP::Float a1)
6291 add_attribute(_TrivialDecorator self, IntKey a0, IMP::Int a1)
6292 add_attribute(_TrivialDecorator self, StringKey a0, IMP::String a1)
6293 add_attribute(_TrivialDecorator self, ParticleIndexKey a0, Particle a1)
6294 add_attribute(_TrivialDecorator self, ObjectKey a0, IMP::Object * a1)
6296 return _IMP_kernel._TrivialDecorator_add_attribute(self, *args)
6298 def get_value(self, *args):
6300 get_value(_TrivialDecorator self, FloatKey a0) -> IMP::Float
6301 get_value(_TrivialDecorator self, IntKey a0) -> IMP::Int
6302 get_value(_TrivialDecorator self, StringKey a0) -> IMP::String
6303 get_value(_TrivialDecorator self, ParticleIndexKey a0) -> Particle
6304 get_value(_TrivialDecorator self, ObjectKey a0) -> IMP::Object *
6306 return _IMP_kernel._TrivialDecorator_get_value(self, *args)
6308 def set_value(self, *args):
6310 set_value(_TrivialDecorator self, FloatKey a0, IMP::Float a1)
6311 set_value(_TrivialDecorator self, IntKey a0, IMP::Int a1)
6312 set_value(_TrivialDecorator self, StringKey a0, IMP::String a1)
6313 set_value(_TrivialDecorator self, ParticleIndexKey a0, Particle a1)
6314 set_value(_TrivialDecorator self, ObjectKey a0, IMP::Object * a1)
6316 return _IMP_kernel._TrivialDecorator_set_value(self, *args)
6318 def remove_attribute(self, *args):
6320 remove_attribute(_TrivialDecorator self, FloatKey a0)
6321 remove_attribute(_TrivialDecorator self, IntKey a0)
6322 remove_attribute(_TrivialDecorator self, StringKey a0)
6323 remove_attribute(_TrivialDecorator self, ParticleIndexKey a0)
6324 remove_attribute(_TrivialDecorator self, ObjectKey a0)
6326 return _IMP_kernel._TrivialDecorator_remove_attribute(self, *args)
6328 def has_attribute(self, *args):
6330 has_attribute(_TrivialDecorator self, FloatKey a0) -> bool
6331 has_attribute(_TrivialDecorator self, IntKey a0) -> bool
6332 has_attribute(_TrivialDecorator self, StringKey a0) -> bool
6333 has_attribute(_TrivialDecorator self, ParticleIndexKey a0) -> bool
6334 has_attribute(_TrivialDecorator self, ObjectKey a0) -> bool
6336 return _IMP_kernel._TrivialDecorator_has_attribute(self, *args)
6338 def get_derivative(self, *args):
6339 """get_derivative(_TrivialDecorator self, FloatKey a0) -> double"""
6340 return _IMP_kernel._TrivialDecorator_get_derivative(self, *args)
6343 """get_name(_TrivialDecorator self) -> std::string"""
6344 return _IMP_kernel._TrivialDecorator_get_name(self)
6346 def clear_caches(self):
6347 """clear_caches(_TrivialDecorator self)"""
6348 return _IMP_kernel._TrivialDecorator_clear_caches(self)
6350 def set_name(self, *args):
6351 """set_name(_TrivialDecorator self, std::string a0)"""
6352 return _IMP_kernel._TrivialDecorator_set_name(self, *args)
6355 """set_check_level(_TrivialDecorator self, IMP::base::CheckLevel a0)"""
6356 return _IMP_kernel._TrivialDecorator_set_check_level(self, *args)
6358 def add_to_derivative(self, *args):
6359 """add_to_derivative(_TrivialDecorator self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
6360 return _IMP_kernel._TrivialDecorator_add_to_derivative(self, *args)
6362 def set_is_optimized(self, *args):
6363 """set_is_optimized(_TrivialDecorator self, FloatKey a0, bool a1)"""
6364 return _IMP_kernel._TrivialDecorator_set_is_optimized(self, *args)
6366 def get_is_optimized(self, *args):
6367 """get_is_optimized(_TrivialDecorator self, FloatKey a0) -> bool"""
6368 return _IMP_kernel._TrivialDecorator_get_is_optimized(self, *args)
6371 """get_check_level(_TrivialDecorator self) -> IMP::base::CheckLevel"""
6372 return _IMP_kernel._TrivialDecorator_get_check_level(self)
6374 def __eq__(self, *args):
6376 __eq__(_TrivialDecorator self, _TrivialDecorator o) -> bool
6377 __eq__(_TrivialDecorator self, Particle d) -> bool
6379 return _IMP_kernel._TrivialDecorator___eq__(self, *args)
6381 def __ne__(self, *args):
6383 __ne__(_TrivialDecorator self, _TrivialDecorator o) -> bool
6384 __ne__(_TrivialDecorator self, Particle d) -> bool
6386 return _IMP_kernel._TrivialDecorator___ne__(self, *args)
6388 def __le__(self, *args):
6390 __le__(_TrivialDecorator self, _TrivialDecorator o) -> bool
6391 __le__(_TrivialDecorator self, Particle d) -> bool
6393 return _IMP_kernel._TrivialDecorator___le__(self, *args)
6395 def __lt__(self, *args):
6397 __lt__(_TrivialDecorator self, _TrivialDecorator o) -> bool
6398 __lt__(_TrivialDecorator self, Particle d) -> bool
6400 return _IMP_kernel._TrivialDecorator___lt__(self, *args)
6402 def __ge__(self, *args):
6404 __ge__(_TrivialDecorator self, _TrivialDecorator o) -> bool
6405 __ge__(_TrivialDecorator self, Particle d) -> bool
6407 return _IMP_kernel._TrivialDecorator___ge__(self, *args)
6409 def __gt__(self, *args):
6411 __gt__(_TrivialDecorator self, _TrivialDecorator o) -> bool
6412 __gt__(_TrivialDecorator self, Particle d) -> bool
6414 return _IMP_kernel._TrivialDecorator___gt__(self, *args)
6417 """__str__(_TrivialDecorator self) -> std::string"""
6418 return _IMP_kernel._TrivialDecorator___str__(self)
6421 """__repr__(_TrivialDecorator self) -> std::string"""
6422 return _IMP_kernel._TrivialDecorator___repr__(self)
6424 __swig_destroy__ = _IMP_kernel.delete__TrivialDecorator
6425 __del__ =
lambda self :
None;
6426 _TrivialDecorator_swigregister = _IMP_kernel._TrivialDecorator_swigregister
6427 _TrivialDecorator_swigregister(_TrivialDecorator)
6429 def _TrivialDecorator_decorate_particle(*args):
6430 """_TrivialDecorator_decorate_particle(Particle p) -> _TrivialDecorator"""
6431 return _IMP_kernel._TrivialDecorator_decorate_particle(*args)
6433 def _TrivialDecorator_setup_particle(*args):
6434 """_TrivialDecorator_setup_particle(Particle p) -> _TrivialDecorator"""
6435 return _IMP_kernel._TrivialDecorator_setup_particle(*args)
6437 def _TrivialDecorator_particle_is_instance(*args):
6438 """_TrivialDecorator_particle_is_instance(Particle p) -> bool"""
6439 return _IMP_kernel._TrivialDecorator_particle_is_instance(*args)
6441 class _TrivialDerivedDecorator(_TrivialDecorator):
6442 """Proxy of C++ IMP::kernel::internal::_TrivialDerivedDecorator class"""
6443 __swig_setmethods__ = {}
6444 for _s
in [_TrivialDecorator]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
6445 __setattr__ =
lambda self, name, value: _swig_setattr(self, _TrivialDerivedDecorator, name, value)
6446 __swig_getmethods__ = {}
6447 for _s
in [_TrivialDecorator]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
6448 __getattr__ =
lambda self, name: _swig_getattr(self, _TrivialDerivedDecorator, name)
6449 def __init__(self, *args):
6451 __init__(IMP::kernel::internal::_TrivialDerivedDecorator self) -> _TrivialDerivedDecorator
6452 __init__(IMP::kernel::internal::_TrivialDerivedDecorator self, Model m, IMP::kernel::ParticleIndex id) -> _TrivialDerivedDecorator
6453 __init__(IMP::kernel::internal::_TrivialDerivedDecorator self, Particle p) -> _TrivialDerivedDecorator
6455 this = _IMP_kernel.new__TrivialDerivedDecorator(*args)
6456 try: self.this.append(this)
6457 except: self.this = this
6458 def decorate_particle(*args):
6459 """decorate_particle(Particle p) -> _TrivialDerivedDecorator"""
6460 return _IMP_kernel._TrivialDerivedDecorator_decorate_particle(*args)
6462 if _newclass:decorate_particle = staticmethod(decorate_particle)
6463 __swig_getmethods__[
"decorate_particle"] =
lambda x: decorate_particle
6464 def show(self, *args):
6466 show(_TrivialDerivedDecorator self, _ostream out=std::cout)
6467 show(_TrivialDerivedDecorator self)
6469 return _IMP_kernel._TrivialDerivedDecorator_show(self, *args)
6471 def setup_particle(*args):
6472 """setup_particle(Particle p) -> _TrivialDerivedDecorator"""
6473 return _IMP_kernel._TrivialDerivedDecorator_setup_particle(*args)
6475 if _newclass:setup_particle = staticmethod(setup_particle)
6476 __swig_getmethods__[
"setup_particle"] =
lambda x: setup_particle
6477 def particle_is_instance(*args):
6478 """particle_is_instance(Particle p) -> bool"""
6479 return _IMP_kernel._TrivialDerivedDecorator_particle_is_instance(*args)
6481 if _newclass:particle_is_instance = staticmethod(particle_is_instance)
6482 __swig_getmethods__[
"particle_is_instance"] =
lambda x: particle_is_instance
6483 def add_attribute(self, *args):
6485 add_attribute(_TrivialDerivedDecorator self, FloatKey k, IMP::Float v, bool opt)
6486 add_attribute(_TrivialDerivedDecorator self, FloatKey a0, IMP::Float a1)
6487 add_attribute(_TrivialDerivedDecorator self, IntKey a0, IMP::Int a1)
6488 add_attribute(_TrivialDerivedDecorator self, StringKey a0, IMP::String a1)
6489 add_attribute(_TrivialDerivedDecorator self, ParticleIndexKey a0, Particle a1)
6490 add_attribute(_TrivialDerivedDecorator self, ObjectKey a0, IMP::Object * a1)
6492 return _IMP_kernel._TrivialDerivedDecorator_add_attribute(self, *args)
6494 def get_value(self, *args):
6496 get_value(_TrivialDerivedDecorator self, FloatKey a0) -> IMP::Float
6497 get_value(_TrivialDerivedDecorator self, IntKey a0) -> IMP::Int
6498 get_value(_TrivialDerivedDecorator self, StringKey a0) -> IMP::String
6499 get_value(_TrivialDerivedDecorator self, ParticleIndexKey a0) -> Particle
6500 get_value(_TrivialDerivedDecorator self, ObjectKey a0) -> IMP::Object *
6502 return _IMP_kernel._TrivialDerivedDecorator_get_value(self, *args)
6504 def set_value(self, *args):
6506 set_value(_TrivialDerivedDecorator self, FloatKey a0, IMP::Float a1)
6507 set_value(_TrivialDerivedDecorator self, IntKey a0, IMP::Int a1)
6508 set_value(_TrivialDerivedDecorator self, StringKey a0, IMP::String a1)
6509 set_value(_TrivialDerivedDecorator self, ParticleIndexKey a0, Particle a1)
6510 set_value(_TrivialDerivedDecorator self, ObjectKey a0, IMP::Object * a1)
6512 return _IMP_kernel._TrivialDerivedDecorator_set_value(self, *args)
6514 def remove_attribute(self, *args):
6516 remove_attribute(_TrivialDerivedDecorator self, FloatKey a0)
6517 remove_attribute(_TrivialDerivedDecorator self, IntKey a0)
6518 remove_attribute(_TrivialDerivedDecorator self, StringKey a0)
6519 remove_attribute(_TrivialDerivedDecorator self, ParticleIndexKey a0)
6520 remove_attribute(_TrivialDerivedDecorator self, ObjectKey a0)
6522 return _IMP_kernel._TrivialDerivedDecorator_remove_attribute(self, *args)
6524 def has_attribute(self, *args):
6526 has_attribute(_TrivialDerivedDecorator self, FloatKey a0) -> bool
6527 has_attribute(_TrivialDerivedDecorator self, IntKey a0) -> bool
6528 has_attribute(_TrivialDerivedDecorator self, StringKey a0) -> bool
6529 has_attribute(_TrivialDerivedDecorator self, ParticleIndexKey a0) -> bool
6530 has_attribute(_TrivialDerivedDecorator self, ObjectKey a0) -> bool
6532 return _IMP_kernel._TrivialDerivedDecorator_has_attribute(self, *args)
6534 def get_derivative(self, *args):
6535 """get_derivative(_TrivialDerivedDecorator self, FloatKey a0) -> double"""
6536 return _IMP_kernel._TrivialDerivedDecorator_get_derivative(self, *args)
6539 """get_name(_TrivialDerivedDecorator self) -> std::string"""
6540 return _IMP_kernel._TrivialDerivedDecorator_get_name(self)
6542 def clear_caches(self):
6543 """clear_caches(_TrivialDerivedDecorator self)"""
6544 return _IMP_kernel._TrivialDerivedDecorator_clear_caches(self)
6546 def set_name(self, *args):
6547 """set_name(_TrivialDerivedDecorator self, std::string a0)"""
6548 return _IMP_kernel._TrivialDerivedDecorator_set_name(self, *args)
6551 """set_check_level(_TrivialDerivedDecorator self, IMP::base::CheckLevel a0)"""
6552 return _IMP_kernel._TrivialDerivedDecorator_set_check_level(self, *args)
6554 def add_to_derivative(self, *args):
6555 """add_to_derivative(_TrivialDerivedDecorator self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
6556 return _IMP_kernel._TrivialDerivedDecorator_add_to_derivative(self, *args)
6558 def set_is_optimized(self, *args):
6559 """set_is_optimized(_TrivialDerivedDecorator self, FloatKey a0, bool a1)"""
6560 return _IMP_kernel._TrivialDerivedDecorator_set_is_optimized(self, *args)
6562 def get_is_optimized(self, *args):
6563 """get_is_optimized(_TrivialDerivedDecorator self, FloatKey a0) -> bool"""
6564 return _IMP_kernel._TrivialDerivedDecorator_get_is_optimized(self, *args)
6567 """get_check_level(_TrivialDerivedDecorator self) -> IMP::base::CheckLevel"""
6568 return _IMP_kernel._TrivialDerivedDecorator_get_check_level(self)
6570 def __eq__(self, *args):
6572 __eq__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
6573 __eq__(_TrivialDerivedDecorator self, Particle d) -> bool
6575 return _IMP_kernel._TrivialDerivedDecorator___eq__(self, *args)
6577 def __ne__(self, *args):
6579 __ne__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
6580 __ne__(_TrivialDerivedDecorator self, Particle d) -> bool
6582 return _IMP_kernel._TrivialDerivedDecorator___ne__(self, *args)
6584 def __le__(self, *args):
6586 __le__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
6587 __le__(_TrivialDerivedDecorator self, Particle d) -> bool
6589 return _IMP_kernel._TrivialDerivedDecorator___le__(self, *args)
6591 def __lt__(self, *args):
6593 __lt__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
6594 __lt__(_TrivialDerivedDecorator self, Particle d) -> bool
6596 return _IMP_kernel._TrivialDerivedDecorator___lt__(self, *args)
6598 def __ge__(self, *args):
6600 __ge__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
6601 __ge__(_TrivialDerivedDecorator self, Particle d) -> bool
6603 return _IMP_kernel._TrivialDerivedDecorator___ge__(self, *args)
6605 def __gt__(self, *args):
6607 __gt__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
6608 __gt__(_TrivialDerivedDecorator self, Particle d) -> bool
6610 return _IMP_kernel._TrivialDerivedDecorator___gt__(self, *args)
6613 """__str__(_TrivialDerivedDecorator self) -> std::string"""
6614 return _IMP_kernel._TrivialDerivedDecorator___str__(self)
6617 """__repr__(_TrivialDerivedDecorator self) -> std::string"""
6618 return _IMP_kernel._TrivialDerivedDecorator___repr__(self)
6620 __swig_destroy__ = _IMP_kernel.delete__TrivialDerivedDecorator
6621 __del__ =
lambda self :
None;
6622 _TrivialDerivedDecorator_swigregister = _IMP_kernel._TrivialDerivedDecorator_swigregister
6623 _TrivialDerivedDecorator_swigregister(_TrivialDerivedDecorator)
6625 def _TrivialDerivedDecorator_decorate_particle(*args):
6626 """_TrivialDerivedDecorator_decorate_particle(Particle p) -> _TrivialDerivedDecorator"""
6627 return _IMP_kernel._TrivialDerivedDecorator_decorate_particle(*args)
6629 def _TrivialDerivedDecorator_setup_particle(*args):
6630 """_TrivialDerivedDecorator_setup_particle(Particle p) -> _TrivialDerivedDecorator"""
6631 return _IMP_kernel._TrivialDerivedDecorator_setup_particle(*args)
6633 def _TrivialDerivedDecorator_particle_is_instance(*args):
6634 """_TrivialDerivedDecorator_particle_is_instance(Particle p) -> bool"""
6635 return _IMP_kernel._TrivialDerivedDecorator_particle_is_instance(*args)
6637 class _TrivialTraitsDecorator(
Decorator):
6638 """Proxy of C++ IMP::kernel::internal::_TrivialTraitsDecorator class"""
6639 __swig_setmethods__ = {}
6640 for _s
in [Decorator]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
6641 __setattr__ =
lambda self, name, value: _swig_setattr(self, _TrivialTraitsDecorator, name, value)
6642 __swig_getmethods__ = {}
6643 for _s
in [Decorator]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
6644 __getattr__ =
lambda self, name: _swig_getattr(self, _TrivialTraitsDecorator, name)
6645 def __init__(self, *args):
6647 __init__(IMP::kernel::internal::_TrivialTraitsDecorator self) -> _TrivialTraitsDecorator
6648 __init__(IMP::kernel::internal::_TrivialTraitsDecorator self, Model m, IMP::kernel::ParticleIndex id, StringKey tr) -> _TrivialTraitsDecorator
6649 __init__(IMP::kernel::internal::_TrivialTraitsDecorator self, StringKey tr) -> _TrivialTraitsDecorator
6650 __init__(IMP::kernel::internal::_TrivialTraitsDecorator self, Particle p, StringKey tr=get_default_key()) -> _TrivialTraitsDecorator
6651 __init__(IMP::kernel::internal::_TrivialTraitsDecorator self, Particle p) -> _TrivialTraitsDecorator
6653 this = _IMP_kernel.new__TrivialTraitsDecorator(*args)
6654 try: self.this.append(this)
6655 except: self.this = this
6656 def decorate_particle(*args):
6658 decorate_particle(Particle p, StringKey tr=get_default_key()) -> _TrivialTraitsDecorator
6659 decorate_particle(Particle p) -> _TrivialTraitsDecorator
6661 return _IMP_kernel._TrivialTraitsDecorator_decorate_particle(*args)
6663 if _newclass:decorate_particle = staticmethod(decorate_particle)
6664 __swig_getmethods__[
"decorate_particle"] =
lambda x: decorate_particle
6665 def show(self, *args):
6667 show(_TrivialTraitsDecorator self, _ostream out=std::cout)
6668 show(_TrivialTraitsDecorator self)
6670 return _IMP_kernel._TrivialTraitsDecorator_show(self, *args)
6673 """get_sk(_TrivialTraitsDecorator self) -> StringKey"""
6674 return _IMP_kernel._TrivialTraitsDecorator_get_sk(self)
6676 def get_decorator_traits(self):
6677 """get_decorator_traits(_TrivialTraitsDecorator self) -> StringKey"""
6678 return _IMP_kernel._TrivialTraitsDecorator_get_decorator_traits(self)
6680 def get_default_decorator_traits():
6681 """get_default_decorator_traits() -> StringKey"""
6682 return _IMP_kernel._TrivialTraitsDecorator_get_default_decorator_traits()
6684 if _newclass:get_default_decorator_traits = staticmethod(get_default_decorator_traits)
6685 __swig_getmethods__[
"get_default_decorator_traits"] =
lambda x: get_default_decorator_traits
6686 def setup_particle(*args):
6688 setup_particle(Particle p, StringKey k=get_default_key()) -> _TrivialTraitsDecorator
6689 setup_particle(Particle p) -> _TrivialTraitsDecorator
6691 return _IMP_kernel._TrivialTraitsDecorator_setup_particle(*args)
6693 if _newclass:setup_particle = staticmethod(setup_particle)
6694 __swig_getmethods__[
"setup_particle"] =
lambda x: setup_particle
6695 def particle_is_instance(*args):
6697 particle_is_instance(Particle p, StringKey k=get_default_key()) -> bool
6698 particle_is_instance(Particle p) -> bool
6700 return _IMP_kernel._TrivialTraitsDecorator_particle_is_instance(*args)
6702 if _newclass:particle_is_instance = staticmethod(particle_is_instance)
6703 __swig_getmethods__[
"particle_is_instance"] =
lambda x: particle_is_instance
6704 def get_default_key():
6705 """get_default_key() -> StringKey"""
6706 return _IMP_kernel._TrivialTraitsDecorator_get_default_key()
6708 if _newclass:get_default_key = staticmethod(get_default_key)
6709 __swig_getmethods__[
"get_default_key"] =
lambda x: get_default_key
6710 def add_attribute(self, *args):
6712 add_attribute(_TrivialTraitsDecorator self, FloatKey k, IMP::Float v, bool opt)
6713 add_attribute(_TrivialTraitsDecorator self, FloatKey a0, IMP::Float a1)
6714 add_attribute(_TrivialTraitsDecorator self, IntKey a0, IMP::Int a1)
6715 add_attribute(_TrivialTraitsDecorator self, StringKey a0, IMP::String a1)
6716 add_attribute(_TrivialTraitsDecorator self, ParticleIndexKey a0, Particle a1)
6717 add_attribute(_TrivialTraitsDecorator self, ObjectKey a0, IMP::Object * a1)
6719 return _IMP_kernel._TrivialTraitsDecorator_add_attribute(self, *args)
6721 def get_value(self, *args):
6723 get_value(_TrivialTraitsDecorator self, FloatKey a0) -> IMP::Float
6724 get_value(_TrivialTraitsDecorator self, IntKey a0) -> IMP::Int
6725 get_value(_TrivialTraitsDecorator self, StringKey a0) -> IMP::String
6726 get_value(_TrivialTraitsDecorator self, ParticleIndexKey a0) -> Particle
6727 get_value(_TrivialTraitsDecorator self, ObjectKey a0) -> IMP::Object *
6729 return _IMP_kernel._TrivialTraitsDecorator_get_value(self, *args)
6731 def set_value(self, *args):
6733 set_value(_TrivialTraitsDecorator self, FloatKey a0, IMP::Float a1)
6734 set_value(_TrivialTraitsDecorator self, IntKey a0, IMP::Int a1)
6735 set_value(_TrivialTraitsDecorator self, StringKey a0, IMP::String a1)
6736 set_value(_TrivialTraitsDecorator self, ParticleIndexKey a0, Particle a1)
6737 set_value(_TrivialTraitsDecorator self, ObjectKey a0, IMP::Object * a1)
6739 return _IMP_kernel._TrivialTraitsDecorator_set_value(self, *args)
6741 def remove_attribute(self, *args):
6743 remove_attribute(_TrivialTraitsDecorator self, FloatKey a0)
6744 remove_attribute(_TrivialTraitsDecorator self, IntKey a0)
6745 remove_attribute(_TrivialTraitsDecorator self, StringKey a0)
6746 remove_attribute(_TrivialTraitsDecorator self, ParticleIndexKey a0)
6747 remove_attribute(_TrivialTraitsDecorator self, ObjectKey a0)
6749 return _IMP_kernel._TrivialTraitsDecorator_remove_attribute(self, *args)
6751 def has_attribute(self, *args):
6753 has_attribute(_TrivialTraitsDecorator self, FloatKey a0) -> bool
6754 has_attribute(_TrivialTraitsDecorator self, IntKey a0) -> bool
6755 has_attribute(_TrivialTraitsDecorator self, StringKey a0) -> bool
6756 has_attribute(_TrivialTraitsDecorator self, ParticleIndexKey a0) -> bool
6757 has_attribute(_TrivialTraitsDecorator self, ObjectKey a0) -> bool
6759 return _IMP_kernel._TrivialTraitsDecorator_has_attribute(self, *args)
6761 def get_derivative(self, *args):
6762 """get_derivative(_TrivialTraitsDecorator self, FloatKey a0) -> double"""
6763 return _IMP_kernel._TrivialTraitsDecorator_get_derivative(self, *args)
6766 """get_name(_TrivialTraitsDecorator self) -> std::string"""
6767 return _IMP_kernel._TrivialTraitsDecorator_get_name(self)
6769 def clear_caches(self):
6770 """clear_caches(_TrivialTraitsDecorator self)"""
6771 return _IMP_kernel._TrivialTraitsDecorator_clear_caches(self)
6773 def set_name(self, *args):
6774 """set_name(_TrivialTraitsDecorator self, std::string a0)"""
6775 return _IMP_kernel._TrivialTraitsDecorator_set_name(self, *args)
6778 """set_check_level(_TrivialTraitsDecorator self, IMP::base::CheckLevel a0)"""
6779 return _IMP_kernel._TrivialTraitsDecorator_set_check_level(self, *args)
6781 def add_to_derivative(self, *args):
6782 """add_to_derivative(_TrivialTraitsDecorator self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
6783 return _IMP_kernel._TrivialTraitsDecorator_add_to_derivative(self, *args)
6785 def set_is_optimized(self, *args):
6786 """set_is_optimized(_TrivialTraitsDecorator self, FloatKey a0, bool a1)"""
6787 return _IMP_kernel._TrivialTraitsDecorator_set_is_optimized(self, *args)
6789 def get_is_optimized(self, *args):
6790 """get_is_optimized(_TrivialTraitsDecorator self, FloatKey a0) -> bool"""
6791 return _IMP_kernel._TrivialTraitsDecorator_get_is_optimized(self, *args)
6794 """get_check_level(_TrivialTraitsDecorator self) -> IMP::base::CheckLevel"""
6795 return _IMP_kernel._TrivialTraitsDecorator_get_check_level(self)
6797 def __eq__(self, *args):
6799 __eq__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
6800 __eq__(_TrivialTraitsDecorator self, Particle d) -> bool
6802 return _IMP_kernel._TrivialTraitsDecorator___eq__(self, *args)
6804 def __ne__(self, *args):
6806 __ne__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
6807 __ne__(_TrivialTraitsDecorator self, Particle d) -> bool
6809 return _IMP_kernel._TrivialTraitsDecorator___ne__(self, *args)
6811 def __le__(self, *args):
6813 __le__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
6814 __le__(_TrivialTraitsDecorator self, Particle d) -> bool
6816 return _IMP_kernel._TrivialTraitsDecorator___le__(self, *args)
6818 def __lt__(self, *args):
6820 __lt__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
6821 __lt__(_TrivialTraitsDecorator self, Particle d) -> bool
6823 return _IMP_kernel._TrivialTraitsDecorator___lt__(self, *args)
6825 def __ge__(self, *args):
6827 __ge__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
6828 __ge__(_TrivialTraitsDecorator self, Particle d) -> bool
6830 return _IMP_kernel._TrivialTraitsDecorator___ge__(self, *args)
6832 def __gt__(self, *args):
6834 __gt__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
6835 __gt__(_TrivialTraitsDecorator self, Particle d) -> bool
6837 return _IMP_kernel._TrivialTraitsDecorator___gt__(self, *args)
6840 """__str__(_TrivialTraitsDecorator self) -> std::string"""
6841 return _IMP_kernel._TrivialTraitsDecorator___str__(self)
6844 """__repr__(_TrivialTraitsDecorator self) -> std::string"""
6845 return _IMP_kernel._TrivialTraitsDecorator___repr__(self)
6847 __swig_destroy__ = _IMP_kernel.delete__TrivialTraitsDecorator
6848 __del__ =
lambda self :
None;
6849 _TrivialTraitsDecorator_swigregister = _IMP_kernel._TrivialTraitsDecorator_swigregister
6850 _TrivialTraitsDecorator_swigregister(_TrivialTraitsDecorator)
6852 def _TrivialTraitsDecorator_decorate_particle(*args):
6854 decorate_particle(Particle p, StringKey tr=get_default_key()) -> _TrivialTraitsDecorator
6855 _TrivialTraitsDecorator_decorate_particle(Particle p) -> _TrivialTraitsDecorator
6857 return _IMP_kernel._TrivialTraitsDecorator_decorate_particle(*args)
6859 def _TrivialTraitsDecorator_get_default_decorator_traits():
6860 """_TrivialTraitsDecorator_get_default_decorator_traits() -> StringKey"""
6861 return _IMP_kernel._TrivialTraitsDecorator_get_default_decorator_traits()
6863 def _TrivialTraitsDecorator_setup_particle(*args):
6865 setup_particle(Particle p, StringKey k=get_default_key()) -> _TrivialTraitsDecorator
6866 _TrivialTraitsDecorator_setup_particle(Particle p) -> _TrivialTraitsDecorator
6868 return _IMP_kernel._TrivialTraitsDecorator_setup_particle(*args)
6870 def _TrivialTraitsDecorator_particle_is_instance(*args):
6872 particle_is_instance(Particle p, StringKey k=get_default_key()) -> bool
6873 _TrivialTraitsDecorator_particle_is_instance(Particle p) -> bool
6875 return _IMP_kernel._TrivialTraitsDecorator_particle_is_instance(*args)
6877 def _TrivialTraitsDecorator_get_default_key():
6878 """_TrivialTraitsDecorator_get_default_key() -> StringKey"""
6879 return _IMP_kernel._TrivialTraitsDecorator_get_default_key()
6882 def __lshift__(*args):
6884 __lshift__(_ostream out, _TrivialDecorator n) -> _ostream
6885 __lshift__(_ostream out, _TrivialDerivedDecorator n) -> _ostream
6886 __lshift__(_ostream out, _TrivialTraitsDecorator n) -> _ostream
6888 return _IMP_kernel.__lshift__(*args)
6890 """Proxy of C++ IMP::kernel::internal::_ConstOptimizer class"""
6891 __swig_setmethods__ = {}
6892 for _s
in [Optimizer]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
6893 __setattr__ =
lambda self, name, value: _swig_setattr(self, _ConstOptimizer, name, value)
6894 __swig_getmethods__ = {}
6895 for _s
in [Optimizer]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
6896 __getattr__ =
lambda self, name: _swig_getattr(self, _ConstOptimizer, name)
6897 def __init__(self, *args):
6898 """__init__(IMP::kernel::internal::_ConstOptimizer self, Model m) -> _ConstOptimizer"""
6899 this = _IMP_kernel.new__ConstOptimizer(*args)
6900 try: self.this.append(this)
6901 except: self.this = this
6902 def do_optimize(self, *args):
6903 """do_optimize(_ConstOptimizer self, unsigned int max_steps) -> IMP::Float"""
6904 return _IMP_kernel._ConstOptimizer_do_optimize(self, *args)
6906 def get_version_info(self):
6907 """get_version_info(_ConstOptimizer self) -> VersionInfo"""
6908 return _IMP_kernel._ConstOptimizer_get_version_info(self)
6910 def do_show(self, *args):
6911 """do_show(_ConstOptimizer self, _ostream out)"""
6912 return _IMP_kernel._ConstOptimizer_do_show(self, *args)
6914 __swig_destroy__ = _IMP_kernel.delete__ConstOptimizer
6915 __del__ =
lambda self :
None;
6917 """__str__(_ConstOptimizer self) -> std::string"""
6918 return _IMP_kernel._ConstOptimizer___str__(self)
6921 """__repr__(_ConstOptimizer self) -> std::string"""
6922 return _IMP_kernel._ConstOptimizer___repr__(self)
6925 return _object_cast_to__ConstOptimizer(o)
6926 get_from = staticmethod(get_from)
6928 _ConstOptimizer_swigregister = _IMP_kernel._ConstOptimizer_swigregister
6929 _ConstOptimizer_swigregister(_ConstOptimizer)
6932 def get_particle(*args):
6933 """get_particle(Particle p) -> Particle"""
6934 return _IMP_kernel.get_particle(*args)
6936 def _decorator_test(*args):
6937 """_decorator_test(Particle p)"""
6938 return _IMP_kernel._decorator_test(*args)
6940 def _overloaded_decorator(*args):
6942 _overloaded_decorator(_TrivialDecorator a) -> int
6943 _overloaded_decorator(_TrivialDerivedDecorator a) -> int
6945 return _IMP_kernel._overloaded_decorator(*args)
6947 def _take_particles(*args):
6949 _take_particles(IMP::kernel::Particles const & ps) -> unsigned int
6950 _take_particles(Model m, IMP::kernel::Particles const & ps) -> unsigned int
6951 _take_particles(Model m, IMP::kernel::Particles const & ps, TextOutput out) -> unsigned int
6953 return _IMP_kernel._take_particles(*args)
6955 def _give_particles(*args):
6956 """_give_particles(Model m) -> IMP::kernel::Particles const &"""
6957 return _IMP_kernel._give_particles(*args)
6959 def _pass_particles(*args):
6960 """_pass_particles(IMP::kernel::Particles const & ps) -> IMP::kernel::Particles const &"""
6961 return _IMP_kernel._pass_particles(*args)
6963 def _pass_particle(*args):
6964 """_pass_particle(Particle ps) -> Particle"""
6965 return _IMP_kernel._pass_particle(*args)
6967 def _pass_particle_pair(*args):
6968 """_pass_particle_pair(IMP::kernel::ParticlePair const & pp) -> IMP::kernel::ParticlePair const &"""
6969 return _IMP_kernel._pass_particle_pair(*args)
6971 def _give_particles_copy(*args):
6972 """_give_particles_copy(Model m) -> IMP::kernel::Particles"""
6973 return _IMP_kernel._give_particles_copy(*args)
6975 def _pass_float_keys(*args):
6976 """_pass_float_keys(IMP::kernel::FloatKeys const & input) -> IMP::kernel::FloatKeys"""
6977 return _IMP_kernel._pass_float_keys(*args)
6981 _pass(IMP::kernel::Particles const & p) -> IMP::kernel::Particles const
6982 _pass(IMP::kernel::Restraints const & p) -> IMP::kernel::Restraints const &
6984 return _IMP_kernel._pass(*args)
6986 def _pass_decorators(*args):
6987 """_pass_decorators(IMP::kernel::internal::_TrivialDecorators const & p) -> IMP::kernel::internal::_TrivialDecorators const &"""
6988 return _IMP_kernel._pass_decorators(*args)
6990 def _pass_decorator_traits(*args):
6991 """_pass_decorator_traits(IMP::kernel::internal::_TrivialTraitsDecorators const & p) -> IMP::kernel::internal::_TrivialTraitsDecorators const &"""
6992 return _IMP_kernel._pass_decorator_traits(*args)
6994 def _pass_particle_pairs(*args):
6995 """_pass_particle_pairs(IMP::kernel::ParticlePairsTemp const & p) -> IMP::kernel::ParticlePairsTemp"""
6996 return _IMP_kernel._pass_particle_pairs(*args)
6998 def _pass_particle_index_pairs(*args):
6999 """_pass_particle_index_pairs(IMP::kernel::ParticleIndexPairs const & p) -> IMP::kernel::ParticleIndexPairs"""
7000 return _IMP_kernel._pass_particle_index_pairs(*args)
7002 def _pass_model_objects(*args):
7003 """_pass_model_objects(IMP::kernel::ModelObjectsTemp const & p) -> IMP::kernel::ModelObjectsTemp"""
7004 return _IMP_kernel._pass_model_objects(*args)
7006 def _pass_particles_temps(*args):
7007 """_pass_particles_temps(IMP::kernel::ParticlesTemps const & ps) -> IMP::kernel::ParticlesTemps"""
7008 return _IMP_kernel._pass_particles_temps(*args)
7010 def _test_overload(*args):
7012 _test_overload(IMP::kernel::Particles const & ps) -> int
7013 _test_overload(IMP::kernel::Restraints const & ps) -> int
7015 return _IMP_kernel._test_overload(*args)
7017 def _get_range(*args):
7018 """_get_range(Model m, FloatKey k) -> IMP::FloatRange"""
7019 return _IMP_kernel._get_range(*args)
7021 def _create_particles_from_pdb(*args):
7022 """_create_particles_from_pdb(std::string name, Model m) -> IMP::kernel::ParticlesTemp"""
7023 return _IMP_kernel._create_particles_from_pdb(*args)
7025 """Proxy of C++ IMP::kernel::internal::_LogPairScore class"""
7026 __swig_setmethods__ = {}
7027 for _s
in [PairScore]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
7028 __setattr__ =
lambda self, name, value: _swig_setattr(self, _LogPairScore, name, value)
7029 __swig_getmethods__ = {}
7030 for _s
in [PairScore]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
7031 __getattr__ =
lambda self, name: _swig_getattr(self, _LogPairScore, name)
7032 __repr__ = _swig_repr
7034 """__init__(IMP::kernel::internal::_LogPairScore self) -> _LogPairScore"""
7035 this = _IMP_kernel.new__LogPairScore()
7036 try: self.this.append(this)
7037 except: self.this = this
7038 def do_create_current_decomposition(self, *args):
7039 """do_create_current_decomposition(_LogPairScore self, Model m, IMP::kernel::ParticleIndexPair const & vt) -> IMP::kernel::Restraints"""
7040 return _IMP_kernel._LogPairScore_do_create_current_decomposition(self, *args)
7042 def get_version_info(self):
7043 """get_version_info(_LogPairScore self) -> VersionInfo"""
7044 return _IMP_kernel._LogPairScore_get_version_info(self)
7046 def do_show(self, *args):
7047 """do_show(_LogPairScore self, _ostream out)"""
7048 return _IMP_kernel._LogPairScore_do_show(self, *args)
7050 __swig_destroy__ = _IMP_kernel.delete__LogPairScore
7051 __del__ =
lambda self :
None;
7052 def get_particle_pairs(self):
7053 """get_particle_pairs(_LogPairScore self) -> IMP::kernel::ParticlePairsTemp"""
7054 return _IMP_kernel._LogPairScore_get_particle_pairs(self)
7057 """clear(_LogPairScore self)"""
7058 return _IMP_kernel._LogPairScore_clear(self)
7060 def get_contains(self, *args):
7061 """get_contains(_LogPairScore self, IMP::kernel::ParticlePair const & pp) -> bool"""
7062 return _IMP_kernel._LogPairScore_get_contains(self, *args)
7064 _LogPairScore_swigregister = _IMP_kernel._LogPairScore_swigregister
7065 _LogPairScore_swigregister(_LogPairScore)
7068 """Proxy of C++ IMP::kernel::internal::PythonRestraint class"""
7069 __swig_setmethods__ = {}
7070 for _s
in [Restraint]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
7071 __setattr__ =
lambda self, name, value: _swig_setattr(self, PythonRestraint, name, value)
7072 __swig_getmethods__ = {}
7073 for _s
in [Restraint]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
7074 __getattr__ =
lambda self, name: _swig_getattr(self, PythonRestraint, name)
7075 def __init__(self, *args):
7077 __init__(IMP::kernel::internal::PythonRestraint self, Model m, std::string name="PythonRestraint%1%") -> PythonRestraint
7078 __init__(IMP::kernel::internal::PythonRestraint self, Model m) -> PythonRestraint
7079 __init__(IMP::kernel::internal::PythonRestraint self, std::string name="PythonRestraint%1%") -> PythonRestraint
7080 __init__(IMP::kernel::internal::PythonRestraint self) -> PythonRestraint
7082 if self.__class__ == PythonRestraint:
7086 this = _IMP_kernel.new_PythonRestraint(_self, *args)
7087 try: self.this.append(this)
7088 except: self.this = this
7089 if self.__class__ != PythonRestraint:
7091 IMP.base._director_objects.register(self)
7096 """get_input_particles(PythonRestraint self) -> IMP::kernel::ParticlesTemp"""
7097 return _IMP_kernel.PythonRestraint_get_input_particles(self)
7100 """get_input_containers(PythonRestraint self) -> IMP::kernel::ContainersTemp"""
7101 return _IMP_kernel.PythonRestraint_get_input_containers(self)
7103 def do_get_inputs(self):
7104 """do_get_inputs(PythonRestraint self) -> IMP::kernel::ModelObjectsTemp"""
7105 return _IMP_kernel.PythonRestraint_do_get_inputs(self)
7108 """__str__(PythonRestraint self) -> std::string"""
7109 return _IMP_kernel.PythonRestraint___str__(self)
7112 """__repr__(PythonRestraint self) -> std::string"""
7113 return _IMP_kernel.PythonRestraint___repr__(self)
7116 return _object_cast_to_PythonRestraint(o)
7117 get_from = staticmethod(get_from)
7119 def get_type_name(self):
7120 return self.__class__.__name__
7121 def do_show(self, out):
7123 def get_version_info(self):
7124 if"IMP::kernel::internal" ==
"IMP":
7125 return VersionInfo(
"python",
"0")
7127 return IMP.VersionInfo(
"python",
"0")
7129 return _object_cast_to_PythonRestraint(o)
7130 get_from = staticmethod(get_from)
7132 __swig_destroy__ = _IMP_kernel.delete_PythonRestraint
7133 __del__ =
lambda self :
None;
7134 def __disown__(self):
7136 _IMP_kernel.disown_PythonRestraint(self)
7137 return weakref_proxy(self)
7138 def update_dependencies(self):
7139 """update_dependencies(PythonRestraint self)"""
7140 return _IMP_kernel.PythonRestraint_update_dependencies(self)
7142 def do_get_outputs(self):
7143 """do_get_outputs(PythonRestraint self) -> IMP::kernel::ModelObjectsTemp"""
7144 return _IMP_kernel.PythonRestraint_do_get_outputs(self)
7146 def do_get_interactions(self):
7147 """do_get_interactions(PythonRestraint self) -> IMP::kernel::ModelObjectsTemps"""
7148 return _IMP_kernel.PythonRestraint_do_get_interactions(self)
7150 def do_create_decomposition(self):
7151 """do_create_decomposition(PythonRestraint self) -> IMP::kernel::Restraints"""
7152 return _IMP_kernel.PythonRestraint_do_create_decomposition(self)
7154 def do_create_current_decomposition(self):
7155 """do_create_current_decomposition(PythonRestraint self) -> IMP::kernel::Restraints"""
7156 return _IMP_kernel.PythonRestraint_do_create_current_decomposition(self)
7158 def do_add_score_and_derivatives(self, *args):
7159 """do_add_score_and_derivatives(PythonRestraint self, ScoreAccumulator sa)"""
7160 return _IMP_kernel.PythonRestraint_do_add_score_and_derivatives(self, *args)
7162 def do_update_dependencies(self):
7163 """do_update_dependencies(PythonRestraint self)"""
7164 return _IMP_kernel.PythonRestraint_do_update_dependencies(self)
7166 PythonRestraint_swigregister = _IMP_kernel.PythonRestraint_swigregister
7167 PythonRestraint_swigregister(PythonRestraint)
7170 """Proxy of C++ IMP::kernel::internal::PythonScoreState class"""
7171 __swig_setmethods__ = {}
7172 for _s
in [ScoreState]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
7173 __setattr__ =
lambda self, name, value: _swig_setattr(self, PythonScoreState, name, value)
7174 __swig_getmethods__ = {}
7175 for _s
in [ScoreState]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
7176 __getattr__ =
lambda self, name: _swig_getattr(self, PythonScoreState, name)
7177 def __init__(self, *args):
7179 __init__(IMP::kernel::internal::PythonScoreState self, std::string name="PythonScoreState%1%") -> PythonScoreState
7180 __init__(IMP::kernel::internal::PythonScoreState self) -> PythonScoreState
7181 __init__(IMP::kernel::internal::PythonScoreState self, Model m, std::string name="PythonScoreState%1%") -> PythonScoreState
7182 __init__(IMP::kernel::internal::PythonScoreState self, Model m) -> PythonScoreState
7184 if self.__class__ == PythonScoreState:
7188 this = _IMP_kernel.new_PythonScoreState(_self, *args)
7189 try: self.this.append(this)
7190 except: self.this = this
7191 if self.__class__ != PythonScoreState:
7193 IMP.base._director_objects.register(self)
7198 """get_input_particles(PythonScoreState self) -> IMP::kernel::ParticlesTemp"""
7199 return _IMP_kernel.PythonScoreState_get_input_particles(self)
7202 """get_input_containers(PythonScoreState self) -> IMP::kernel::ContainersTemp"""
7203 return _IMP_kernel.PythonScoreState_get_input_containers(self)
7206 """get_output_particles(PythonScoreState self) -> IMP::kernel::ParticlesTemp"""
7207 return _IMP_kernel.PythonScoreState_get_output_particles(self)
7210 """get_output_containers(PythonScoreState self) -> IMP::kernel::ContainersTemp"""
7211 return _IMP_kernel.PythonScoreState_get_output_containers(self)
7213 def do_get_inputs(self):
7214 """do_get_inputs(PythonScoreState self) -> IMP::kernel::ModelObjectsTemp"""
7215 return _IMP_kernel.PythonScoreState_do_get_inputs(self)
7217 def do_get_outputs(self):
7218 """do_get_outputs(PythonScoreState self) -> IMP::kernel::ModelObjectsTemp"""
7219 return _IMP_kernel.PythonScoreState_do_get_outputs(self)
7222 """__str__(PythonScoreState self) -> std::string"""
7223 return _IMP_kernel.PythonScoreState___str__(self)
7226 """__repr__(PythonScoreState self) -> std::string"""
7227 return _IMP_kernel.PythonScoreState___repr__(self)
7230 return _object_cast_to_PythonScoreState(o)
7231 get_from = staticmethod(get_from)
7233 def get_type_name(self):
7234 return self.__class__.__name__
7235 def do_show(self, out):
7237 def get_version_info(self):
7238 if"IMP::kernel::internal" ==
"IMP":
7239 return VersionInfo(
"python",
"0")
7241 return IMP.VersionInfo(
"python",
"0")
7243 return _object_cast_to_PythonScoreState(o)
7244 get_from = staticmethod(get_from)
7246 __swig_destroy__ = _IMP_kernel.delete_PythonScoreState
7247 __del__ =
lambda self :
None;
7248 def __disown__(self):
7250 _IMP_kernel.disown_PythonScoreState(self)
7251 return weakref_proxy(self)
7252 def update_dependencies(self):
7253 """update_dependencies(PythonScoreState self)"""
7254 return _IMP_kernel.PythonScoreState_update_dependencies(self)
7256 def do_get_interactions(self):
7257 """do_get_interactions(PythonScoreState self) -> IMP::kernel::ModelObjectsTemps"""
7258 return _IMP_kernel.PythonScoreState_do_get_interactions(self)
7260 def do_before_evaluate(self):
7261 """do_before_evaluate(PythonScoreState self)"""
7262 return _IMP_kernel.PythonScoreState_do_before_evaluate(self)
7264 def do_after_evaluate(self, *args):
7265 """do_after_evaluate(PythonScoreState self, DerivativeAccumulator accpt)"""
7266 return _IMP_kernel.PythonScoreState_do_after_evaluate(self, *args)
7268 def do_update_dependencies(self):
7269 """do_update_dependencies(PythonScoreState self)"""
7270 return _IMP_kernel.PythonScoreState_do_update_dependencies(self)
7272 PythonScoreState_swigregister = _IMP_kernel.PythonScoreState_swigregister
7273 PythonScoreState_swigregister(PythonScoreState)
7276 def _overloaded_particles(*args):
7278 _overloaded_particles(Particle arg1)
7279 _overloaded_particles(IMP::kernel::Particles const & arg1)
7280 _overloaded_particles(IMP::kernel::ParticlesTemp const & arg1)
7281 _overloaded_particles(Model arg1, IMP::kernel::ParticleIndexes const & arg2)
7282 _overloaded_particles(IMP::kernel::internal::_TrivialDecorators const & arg1)
7283 _overloaded_particles(_TrivialDecorator arg1)
7285 return _IMP_kernel._overloaded_particles(*args)
7286 class _ImplicitParticles(_object):
7287 """Proxy of C++ IMP::kernel::internal::_ImplicitParticles class"""
7288 __swig_setmethods__ = {}
7289 __setattr__ =
lambda self, name, value: _swig_setattr(self, _ImplicitParticles, name, value)
7290 __swig_getmethods__ = {}
7291 __getattr__ =
lambda self, name: _swig_getattr(self, _ImplicitParticles, name)
7292 __repr__ = _swig_repr
7293 def __init__(self, *args):
7295 __init__(IMP::kernel::internal::_ImplicitParticles self, Particle arg2) -> _ImplicitParticles
7296 __init__(IMP::kernel::internal::_ImplicitParticles self, IMP::kernel::Particles const & arg2) -> _ImplicitParticles
7297 __init__(IMP::kernel::internal::_ImplicitParticles self, IMP::kernel::ParticlesTemp const & arg2) -> _ImplicitParticles
7298 __init__(IMP::kernel::internal::_ImplicitParticles self, Model arg2, IMP::kernel::ParticleIndexes const & arg3) -> _ImplicitParticles
7299 __init__(IMP::kernel::internal::_ImplicitParticles self, IMP::kernel::internal::_TrivialDecorators const & arg2) -> _ImplicitParticles
7300 __init__(IMP::kernel::internal::_ImplicitParticles self, _TrivialDecorator arg2) -> _ImplicitParticles
7302 this = _IMP_kernel.new__ImplicitParticles(*args)
7303 try: self.this.append(this)
7304 except: self.this = this
7305 __swig_destroy__ = _IMP_kernel.delete__ImplicitParticles
7306 __del__ =
lambda self :
None;
7307 _ImplicitParticles_swigregister = _IMP_kernel._ImplicitParticles_swigregister
7308 _ImplicitParticles_swigregister(_ImplicitParticles)
7311 def _implicit_particles(*args):
7312 """_implicit_particles(_ImplicitParticles arg1)"""
7313 return _IMP_kernel._implicit_particles(*args)
7315 """Proxy of C++ IMP::kernel::GenericScopedScoreState<(IMP::kernel::ScoreState)> class"""
7316 __swig_setmethods__ = {}
7317 for _s
in [IMP.base._RAII]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
7318 __setattr__ =
lambda self, name, value: _swig_setattr(self, ScopedScoreState, name, value)
7319 __swig_getmethods__ = {}
7320 for _s
in [IMP.base._RAII]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
7321 __getattr__ =
lambda self, name: _swig_getattr(self, ScopedScoreState, name)
7322 def __init__(self, *args):
7324 __init__(IMP::kernel::GenericScopedScoreState<(IMP::kernel::ScoreState)> self) -> ScopedScoreState
7325 __init__(IMP::kernel::GenericScopedScoreState<(IMP::kernel::ScoreState)> self, ScoreState ss, Model m) -> ScopedScoreState
7327 this = _IMP_kernel.new_ScopedScoreState(*args)
7328 try: self.this.append(this)
7329 except: self.this = this
7330 def set(self, *args):
7331 """set(ScopedScoreState self, ScoreState ss, Model m)"""
7332 return _IMP_kernel.ScopedScoreState_set(self, *args)
7335 """reset(ScopedScoreState self)"""
7336 return _IMP_kernel.ScopedScoreState_reset(self)
7338 __swig_destroy__ = _IMP_kernel.delete_ScopedScoreState
7339 __del__ =
lambda self :
None;
7340 def show(self, *args):
7342 show(ScopedScoreState self, _ostream out=std::cout)
7343 show(ScopedScoreState self)
7345 return _IMP_kernel.ScopedScoreState_show(self, *args)
7347 def get_is_set(self):
7348 """get_is_set(ScopedScoreState self) -> bool"""
7349 return _IMP_kernel.ScopedScoreState_get_is_set(self)
7352 """__str__(ScopedScoreState self) -> std::string"""
7353 return _IMP_kernel.ScopedScoreState___str__(self)
7356 """__repr__(ScopedScoreState self) -> std::string"""
7357 return _IMP_kernel.ScopedScoreState___repr__(self)
7359 ScopedScoreState_swigregister = _IMP_kernel.ScopedScoreState_swigregister
7360 ScopedScoreState_swigregister(ScopedScoreState)
7363 """Proxy of C++ IMP::kernel::GenericScopedRestraint<(IMP::kernel::Restraint)> class"""
7364 __swig_setmethods__ = {}
7365 for _s
in [IMP.base._RAII]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
7366 __setattr__ =
lambda self, name, value: _swig_setattr(self, ScopedRestraint, name, value)
7367 __swig_getmethods__ = {}
7368 for _s
in [IMP.base._RAII]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
7369 __getattr__ =
lambda self, name: _swig_getattr(self, ScopedRestraint, name)
7370 def __init__(self, *args):
7372 __init__(IMP::kernel::GenericScopedRestraint<(IMP::kernel::Restraint)> self) -> ScopedRestraint
7373 __init__(IMP::kernel::GenericScopedRestraint<(IMP::kernel::Restraint)> self, Restraint ss, RestraintSet rs) -> ScopedRestraint
7375 this = _IMP_kernel.new_ScopedRestraint(*args)
7376 try: self.this.append(this)
7377 except: self.this = this
7378 def set(self, *args):
7379 """set(ScopedRestraint self, Restraint ss, RestraintSet rs)"""
7380 return _IMP_kernel.ScopedRestraint_set(self, *args)
7383 """reset(ScopedRestraint self)"""
7384 return _IMP_kernel.ScopedRestraint_reset(self)
7386 __swig_destroy__ = _IMP_kernel.delete_ScopedRestraint
7387 __del__ =
lambda self :
None;
7388 def show(self, *args):
7390 show(ScopedRestraint self, _ostream out=std::cout)
7391 show(ScopedRestraint self)
7393 return _IMP_kernel.ScopedRestraint_show(self, *args)
7395 def get_is_set(self):
7396 """get_is_set(ScopedRestraint self) -> bool"""
7397 return _IMP_kernel.ScopedRestraint_get_is_set(self)
7400 """__str__(ScopedRestraint self) -> std::string"""
7401 return _IMP_kernel.ScopedRestraint___str__(self)
7404 """__repr__(ScopedRestraint self) -> std::string"""
7405 return _IMP_kernel.ScopedRestraint___repr__(self)
7407 ScopedRestraint_swigregister = _IMP_kernel.ScopedRestraint_swigregister
7408 ScopedRestraint_swigregister(ScopedRestraint)
7411 """Proxy of C++ IMP::kernel::GenericScopedRemoveRestraint<(IMP::kernel::Restraint)> class"""
7412 __swig_setmethods__ = {}
7413 for _s
in [IMP.base._RAII]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
7414 __setattr__ =
lambda self, name, value: _swig_setattr(self, ScopedRemoveRestraint, name, value)
7415 __swig_getmethods__ = {}
7416 for _s
in [IMP.base._RAII]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
7417 __getattr__ =
lambda self, name: _swig_getattr(self, ScopedRemoveRestraint, name)
7418 __repr__ = _swig_repr
7419 def __init__(self, *args):
7421 __init__(IMP::kernel::GenericScopedRemoveRestraint<(IMP::kernel::Restraint)> self) -> ScopedRemoveRestraint
7422 __init__(IMP::kernel::GenericScopedRemoveRestraint<(IMP::kernel::Restraint)> self, Restraint ss, RestraintSet rs) -> ScopedRemoveRestraint
7424 this = _IMP_kernel.new_ScopedRemoveRestraint(*args)
7425 try: self.this.append(this)
7426 except: self.this = this
7427 def set(self, *args):
7428 """set(ScopedRemoveRestraint self, Restraint ss, RestraintSet rs)"""
7429 return _IMP_kernel.ScopedRemoveRestraint_set(self, *args)
7432 """reset(ScopedRemoveRestraint self)"""
7433 return _IMP_kernel.ScopedRemoveRestraint_reset(self)
7435 __swig_destroy__ = _IMP_kernel.delete_ScopedRemoveRestraint
7436 __del__ =
lambda self :
None;
7437 def show(self, *args):
7439 show(ScopedRemoveRestraint self, _ostream out=std::cout)
7440 show(ScopedRemoveRestraint self)
7442 return _IMP_kernel.ScopedRemoveRestraint_show(self, *args)
7444 def get_is_set(self):
7445 """get_is_set(ScopedRemoveRestraint self) -> bool"""
7446 return _IMP_kernel.ScopedRemoveRestraint_get_is_set(self)
7448 ScopedRemoveRestraint_swigregister = _IMP_kernel.ScopedRemoveRestraint_swigregister
7449 ScopedRemoveRestraint_swigregister(ScopedRemoveRestraint)
7452 """Proxy of C++ IMP::kernel::GenericScopedRemoveScoreState<(IMP::kernel::ScoreState)> class"""
7453 __swig_setmethods__ = {}
7454 for _s
in [IMP.base._RAII]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
7455 __setattr__ =
lambda self, name, value: _swig_setattr(self, ScopedRemoveScoreState, name, value)
7456 __swig_getmethods__ = {}
7457 for _s
in [IMP.base._RAII]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
7458 __getattr__ =
lambda self, name: _swig_getattr(self, ScopedRemoveScoreState, name)
7459 __repr__ = _swig_repr
7460 def __init__(self, *args):
7462 __init__(IMP::kernel::GenericScopedRemoveScoreState<(IMP::kernel::ScoreState)> self) -> ScopedRemoveScoreState
7463 __init__(IMP::kernel::GenericScopedRemoveScoreState<(IMP::kernel::ScoreState)> self, ScoreState ss, Model rs) -> ScopedRemoveScoreState
7465 this = _IMP_kernel.new_ScopedRemoveScoreState(*args)
7466 try: self.this.append(this)
7467 except: self.this = this
7468 def set(self, *args):
7469 """set(ScopedRemoveScoreState self, ScoreState ss, Model rs)"""
7470 return _IMP_kernel.ScopedRemoveScoreState_set(self, *args)
7473 """reset(ScopedRemoveScoreState self)"""
7474 return _IMP_kernel.ScopedRemoveScoreState_reset(self)
7476 __swig_destroy__ = _IMP_kernel.delete_ScopedRemoveScoreState
7477 __del__ =
lambda self :
None;
7478 def show(self, *args):
7480 show(ScopedRemoveScoreState self, _ostream out=std::cout)
7481 show(ScopedRemoveScoreState self)
7483 return _IMP_kernel.ScopedRemoveScoreState_show(self, *args)
7485 def get_is_set(self):
7486 """get_is_set(ScopedRemoveScoreState self) -> bool"""
7487 return _IMP_kernel.ScopedRemoveScoreState_get_is_set(self)
7489 ScopedRemoveScoreState_swigregister = _IMP_kernel.ScopedRemoveScoreState_swigregister
7490 ScopedRemoveScoreState_swigregister(ScopedRemoveScoreState)
7492 class ScopedSetFloatAttribute(IMP.base._RAII):
7493 """Proxy of C++ IMP::kernel::ScopedSetAttribute<(FloatKey,IMP::Float)> class"""
7494 __swig_setmethods__ = {}
7495 for _s
in [IMP.base._RAII]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
7496 __setattr__ =
lambda self, name, value: _swig_setattr(self, ScopedSetFloatAttribute, name, value)
7497 __swig_getmethods__ = {}
7498 for _s
in [IMP.base._RAII]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
7499 __getattr__ =
lambda self, name: _swig_getattr(self, ScopedSetFloatAttribute, name)
7500 def __init__(self, *args):
7502 __init__(IMP::kernel::ScopedSetAttribute<(FloatKey,IMP::Float)> self) -> ScopedSetFloatAttribute
7503 __init__(IMP::kernel::ScopedSetAttribute<(FloatKey,IMP::Float)> self, Particle p, FloatKey key, double const & value) -> ScopedSetFloatAttribute
7505 this = _IMP_kernel.new_ScopedSetFloatAttribute(*args)
7506 try: self.this.append(this)
7507 except: self.this = this
7508 def set(self, *args):
7509 """set(ScopedSetFloatAttribute self, Particle p, FloatKey key, double const & value)"""
7510 return _IMP_kernel.ScopedSetFloatAttribute_set(self, *args)
7513 """reset(ScopedSetFloatAttribute self)"""
7514 return _IMP_kernel.ScopedSetFloatAttribute_reset(self)
7516 __swig_destroy__ = _IMP_kernel.delete_ScopedSetFloatAttribute
7517 __del__ =
lambda self :
None;
7518 def show(self, *args):
7520 show(ScopedSetFloatAttribute self, _ostream out=std::cout)
7521 show(ScopedSetFloatAttribute self)
7523 return _IMP_kernel.ScopedSetFloatAttribute_show(self, *args)
7526 """__str__(ScopedSetFloatAttribute self) -> std::string"""
7527 return _IMP_kernel.ScopedSetFloatAttribute___str__(self)
7530 """__repr__(ScopedSetFloatAttribute self) -> std::string"""
7531 return _IMP_kernel.ScopedSetFloatAttribute___repr__(self)
7533 ScopedSetFloatAttribute_swigregister = _IMP_kernel.ScopedSetFloatAttribute_swigregister
7534 ScopedSetFloatAttribute_swigregister(ScopedSetFloatAttribute)
7543 get_networkx_graph=IMP.base.get_networkx_graph
7544 show_altgraph=IMP.base.show_altgraph
7545 show_graphviz=IMP.base.show_graphviz
7550 USAGE= IMP.base.USAGE
7551 USAGE_AND_INTERNAL= IMP.base.USAGE_AND_INTERNAL
7552 TERSE= IMP.base.TERSE
7553 SILENT= IMP.base.SILENT
7554 VERBOSE= IMP.base.VERBOSE
7555 WARNING= IMP.base.WARNING
7556 PROGRESS= IMP.base.PROGRESS
7557 MEMORY= IMP.base.MEMORY
7558 create_temporary_file= IMP.base.create_temporary_file
7559 create_temporary_file_name= IMP.base.create_temporary_file_name
7560 random_number_generator= IMP.base.random_number_generator
7561 set_log_level=IMP.base.set_log_level
7562 set_log_timer=IMP.base.set_log_timer
7563 get_log_level=IMP.base.get_log_level
7564 add_to_log= IMP.base.add_to_log
7565 set_check_level= IMP.base.set_check_level
7566 get_check_level= IMP.base.get_check_level
7570 if sys.platform ==
'win32' and 'IMP_LD_PATH' in os.environ:
7571 dirs = os.environ[
'IMP_LD_PATH'].split(
":")
7572 pathcomps = os.environ[
'PATH'].split(
";")
7574 if d
not in pathcomps:
7575 os.environ[
'PATH'] = d +
';' + os.environ[
'PATH']
7577 RestraintBase=Restraint
7578 ScoreStateBase=ScoreState
7579 Restraint=PythonRestraint
7580 ScoreState=PythonScoreState
7591 """Allow applications to easily implement commmands.
7592 Typically, an IMP application will use an instance of this class
7593 to provide a consistent interface to multiple distinct commands
7594 from a single binary, rather than providing a potentially large
7597 Each command is implemented with a Python module of the same name
7598 that can be imported from the module (for example, if module_name
7599 is 'IMP.foo', the 'bar' command is provided by the IMP.foo.bar Python
7600 module, which would usually be found as modules/foo/pyext/src/bar.py).
7601 Each such module should have a docstring (__doc__) and a main() method
7602 that takes no arguments (the module should also call its main() method
7603 if it is run directly, i.e. with something like
7604 'if __name__=="__main__": main()'). The encompassing module
7605 ('IMP.foo' in the example) should define _all_commands as a Python
7606 list of all valid commands.
7608 @param short_help A few words that describe the application.
7609 @param long_help Longer text, used in the 'help' command.
7610 @param module_name Name of the module (e.g. 'IMP.foo') that implements
7614 def __init__(self, short_help, long_help, module_name):
7615 self.short_help = short_help
7616 self.long_help = long_help
7617 self.module_name = module_name
7618 self._all_commands = self.import_module()._all_commands
7619 self._progname = os.path.basename(sys.argv[0])
7622 if len(sys.argv) <= 1:
7623 print self.short_help +
" Use '%s help' for help." % self._progname
7625 command = sys.argv[1]
7626 if command
in (
'help',
'--help',
'-h'):
7627 if len(sys.argv) == 3:
7628 self.show_command_help(sys.argv[2])
7631 elif command ==
'--version':
7633 elif command
in self._all_commands:
7634 self.do_command(command)
7636 self.unknown_command(command)
7638 def import_module(self, mod=None):
7639 modname = self.module_name
7641 modname +=
"." + mod
7642 return __import__(modname, {}, {}, [
''])
7644 def unknown_command(self, command):
7645 print "Unknown command: '%s'" % command
7646 print "Use '%s help' for help." % self._progname
7649 def _get_version(self):
7650 return self.import_module().get_module_version()
7652 def show_version(self):
7653 print self._progname +
' ' + self._get_version()
7655 def show_help(self):
7656 ver = self._get_version()
7657 print "%s, version %s." % (self._progname, ver)
7658 print self.long_help +
"""
7660 This program is part of IMP, the Integrative Modeling Platform,
7661 which is Copyright 2007-2013 IMP Inventors.
7662 For additional information about IMP, see http://salilab.org/imp/
7664 Usage: %s <command> [options] [args]
7666 Commands:""" % self._progname
7667 commands = self._all_commands[:] + [
'help']
7669 cmdlen = max([len(c)
for c
in commands])
7672 doc =
'Get help on using %s.' % self._progname
7674 doc = self.import_module(c).__doc__
or "<no help>"
7675 c +=
' ' * (cmdlen - len(c))
7676 print ' ' + c +
' ' + doc
7678 Use "%s help <command>" for detailed help on any command
7679 or "%s --version" to see the version number.""" % (self._progname,
7682 def do_command(self, command):
7683 mod = self.import_module(command)
7684 sys.argv[0] = self._progname +
' ' + command
7688 def show_command_help(self, command):
7689 if command ==
'help':
7691 elif command
in self._all_commands
or command ==
'help':
7692 mod = self.import_module(command)
7693 sys.argv = [self._progname +
' ' + command,
'--help']
7696 self.unknown_command(command)
7701 """IMP-specific subclass of optparse.OptionParser.
7702 Please use the flags support in IMP.base. See IMP::base::add_string_flag()
7703 and IMP::base::setup_from_argv() for example.
7705 def __init__(self, imp_module=None, version=None, *args, **keys):
7707 if imp_module
is not None:
7708 version =
"%prog " + imp_module.get_module_version()
7710 raise ValueError(
"Must supply either version or "
7711 "imp_module arguments")
7712 optparse.OptionParser.__init__(self, version=version, *args, **keys)
7714 def format_epilog(self, formatter):
7716 return optparse.OptionParser.format_epilog(self, formatter) +
"""
7717 This program is part of IMP, the Integrative Modeling Platform,
7718 which is Copyright 2007-2013 IMP Inventors.
7719 For additional information about IMP, see http://salilab.org/imp/
7723 def get_module_version():
7724 """get_module_version() -> std::string const"""
7725 return _IMP_kernel.get_module_version()
7728 """get_example_path(std::string fname) -> std::string"""
7729 return _IMP_kernel.get_example_path(*args)
7732 """get_data_path(std::string fname) -> std::string"""
7733 return _IMP_kernel.get_data_path(*args)
7734 import _version_check
7735 _version_check.check_version(get_module_version())