kernel/__init__.py

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 2.0.8
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.



from sys import version_info
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_IMP_kernel', [dirname(__file__)])
        except ImportError:
            import _IMP_kernel
            return _IMP_kernel
        if fp is not None:
            try:
                _mod = imp.load_module('_IMP_kernel', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _IMP_kernel = swig_import_helper()
    del swig_import_helper
else:
    import _IMP_kernel
del version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "thisown"): return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

def _swig_setattr(self,class_type,name,value):
    return _swig_setattr_nondynamic(self,class_type,name,value,0)

def _swig_getattr(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError(name)

def _swig_repr(self):
    try: strthis = "proxy of " + self.this.__repr__()
    except: strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0


try:
    import weakref
    weakref_proxy = weakref.proxy
except:
    weakref_proxy = lambda x: x


class IMP_KERNEL_SwigPyIterator(_object):
    """Proxy of C++ swig::IMP_KERNEL_SwigPyIterator class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IMP_KERNEL_SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IMP_KERNEL_SwigPyIterator, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _IMP_kernel.delete_IMP_KERNEL_SwigPyIterator
    __del__ = lambda self : None;
    def value(self):
        """value(IMP_KERNEL_SwigPyIterator self) -> PyObject *"""
        return _IMP_kernel.IMP_KERNEL_SwigPyIterator_value(self)

    def incr(self, n=1):
        """
        incr(IMP_KERNEL_SwigPyIterator self, size_t n=1) -> IMP_KERNEL_SwigPyIterator
        incr(IMP_KERNEL_SwigPyIterator self) -> IMP_KERNEL_SwigPyIterator
        """
        return _IMP_kernel.IMP_KERNEL_SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        """
        decr(IMP_KERNEL_SwigPyIterator self, size_t n=1) -> IMP_KERNEL_SwigPyIterator
        decr(IMP_KERNEL_SwigPyIterator self) -> IMP_KERNEL_SwigPyIterator
        """
        return _IMP_kernel.IMP_KERNEL_SwigPyIterator_decr(self, n)

    def distance(self, *args):
        """distance(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> ptrdiff_t"""
        return _IMP_kernel.IMP_KERNEL_SwigPyIterator_distance(self, *args)

    def equal(self, *args):
        """equal(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> bool"""
        return _IMP_kernel.IMP_KERNEL_SwigPyIterator_equal(self, *args)

    def copy(self):
        """copy(IMP_KERNEL_SwigPyIterator self) -> IMP_KERNEL_SwigPyIterator"""
        return _IMP_kernel.IMP_KERNEL_SwigPyIterator_copy(self)

    def next(self):
        """next(IMP_KERNEL_SwigPyIterator self) -> PyObject *"""
        return _IMP_kernel.IMP_KERNEL_SwigPyIterator_next(self)

    def __next__(self):
        """__next__(IMP_KERNEL_SwigPyIterator self) -> PyObject *"""
        return _IMP_kernel.IMP_KERNEL_SwigPyIterator___next__(self)

    def previous(self):
        """previous(IMP_KERNEL_SwigPyIterator self) -> PyObject *"""
        return _IMP_kernel.IMP_KERNEL_SwigPyIterator_previous(self)

    def advance(self, *args):
        """advance(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator"""
        return _IMP_kernel.IMP_KERNEL_SwigPyIterator_advance(self, *args)

    def __eq__(self, *args):
        """__eq__(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> bool"""
        return _IMP_kernel.IMP_KERNEL_SwigPyIterator___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> bool"""
        return _IMP_kernel.IMP_KERNEL_SwigPyIterator___ne__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator"""
        return _IMP_kernel.IMP_KERNEL_SwigPyIterator___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator"""
        return _IMP_kernel.IMP_KERNEL_SwigPyIterator___isub__(self, *args)

    def __add__(self, *args):
        """__add__(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator"""
        return _IMP_kernel.IMP_KERNEL_SwigPyIterator___add__(self, *args)

    def __sub__(self, *args):
        """
        __sub__(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator
        __sub__(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> ptrdiff_t
        """
        return _IMP_kernel.IMP_KERNEL_SwigPyIterator___sub__(self, *args)

    def __iter__(self): return self
IMP_KERNEL_SwigPyIterator_swigregister = _IMP_kernel.IMP_KERNEL_SwigPyIterator_swigregister
IMP_KERNEL_SwigPyIterator_swigregister(IMP_KERNEL_SwigPyIterator)

_value_types=[]
_object_types=[]
_raii_types=[]
_plural_types=[]

IMP_HAS_DEPRECATED = _IMP_kernel.IMP_HAS_DEPRECATED
IMP_DEBUG = _IMP_kernel.IMP_DEBUG
IMP_RELEASE = _IMP_kernel.IMP_RELEASE
IMP_SILENT = _IMP_kernel.IMP_SILENT
IMP_PROGRESS = _IMP_kernel.IMP_PROGRESS
IMP_TERSE = _IMP_kernel.IMP_TERSE
IMP_VERBOSE = _IMP_kernel.IMP_VERBOSE
IMP_NONE = _IMP_kernel.IMP_NONE
IMP_USAGE = _IMP_kernel.IMP_USAGE
IMP_INTERNAL = _IMP_kernel.IMP_INTERNAL
IMP_COMPILER_HAS_AUTO = _IMP_kernel.IMP_COMPILER_HAS_AUTO
IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_kernel.IMP_COMPILER_HAS_DEBUG_VECTOR
IMP_COMPILER_HAS_NULLPTR = _IMP_kernel.IMP_COMPILER_HAS_NULLPTR
IMP_BASE_HAS_BOOST_RANDOM = _IMP_kernel.IMP_BASE_HAS_BOOST_RANDOM
IMP_BASE_HAS_GPERFTOOLS = _IMP_kernel.IMP_BASE_HAS_GPERFTOOLS
IMP_BASE_HAS_LOG4CXX = _IMP_kernel.IMP_BASE_HAS_LOG4CXX
IMP_BASE_HAS_TCMALLOC_HEAPCHECKER = _IMP_kernel.IMP_BASE_HAS_TCMALLOC_HEAPCHECKER
IMP_BASE_HAS_TCMALLOC_HEAPPROFILER = _IMP_kernel.IMP_BASE_HAS_TCMALLOC_HEAPPROFILER
import sys
class _DirectorObjects(object):
    """@internal Simple class to keep references to director objects
       to prevent premature deletion."""
    def __init__(self):
        self._objects = []
    def register(self, obj):
        """Take a reference to a director object; will only work for
           refcounted C++ classes"""
        if hasattr(obj, 'get_ref_count'):
            self._objects.append(obj)
    def cleanup(self):
        """Only drop our reference and allow cleanup by Python if no other
           Python references exist (we hold 3 references: one in self._objects,
           one in x, and one in the argument list for getrefcount) *and* no
           other C++ references exist (the Python object always holds one)"""
        objs = [x for x in self._objects if sys.getrefcount(x) > 3 \
                                         or x.get_ref_count() > 1]
        
        
        self._objects = objs
    def get_object_count(self):
        """Get number of director objects (useful for testing only)"""
        return len(self._objects)
_director_objects = _DirectorObjects()

DEFAULT_CHECK = _IMP_kernel.DEFAULT_CHECK
NONE = _IMP_kernel.NONE
USAGE = _IMP_kernel.USAGE
USAGE_AND_INTERNAL = _IMP_kernel.USAGE_AND_INTERNAL

def set_check_level(*args):
  """set_check_level(IMP::base::CheckLevel tf)"""
  return _IMP_kernel.set_check_level(*args)

def get_check_level():
  """get_check_level() -> IMP::base::CheckLevel"""
  return _IMP_kernel.get_check_level()
class _ostream(_object):
    """Proxy of C++ std::ostream class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _ostream, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _ostream, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def write(self, *args):
        """write(_ostream self, char const * osa_buf)"""
        return _IMP_kernel._ostream_write(self, *args)

_ostream_swigregister = _IMP_kernel._ostream_swigregister
_ostream_swigregister(_ostream)

IMP_COMPILER_HAS_OVERRIDE = _IMP_kernel.IMP_COMPILER_HAS_OVERRIDE
IMP_COMPILER_HAS_FINAL = _IMP_kernel.IMP_COMPILER_HAS_FINAL
import IMP.base
IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_kernel.IMP_CGAL_HAS_BOOST_FILESYSTEM
IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_kernel.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS
IMP_CGAL_HAS_BOOST_RANDOM = _IMP_kernel.IMP_CGAL_HAS_BOOST_RANDOM
IMP_CGAL_HAS_BOOST_SYSTEM = _IMP_kernel.IMP_CGAL_HAS_BOOST_SYSTEM
import IMP.cgal
IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_kernel.IMP_ALGEBRA_HAS_IMP_CGAL
IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_kernel.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM
IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_kernel.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS
IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_kernel.IMP_ALGEBRA_HAS_BOOST_RANDOM
IMP_ALGEBRA_HAS_BOOST_SYSTEM = _IMP_kernel.IMP_ALGEBRA_HAS_BOOST_SYSTEM
IMP_ALGEBRA_HAS_CGAL = _IMP_kernel.IMP_ALGEBRA_HAS_CGAL
IMP_ALGEBRA_HAS_ANN = _IMP_kernel.IMP_ALGEBRA_HAS_ANN
import IMP.algebra
IMP_KERNEL_HAS_IMP_CGAL = _IMP_kernel.IMP_KERNEL_HAS_IMP_CGAL
IMP_KERNEL_HAS_BOOST_PROGRAMOPTIONS = _IMP_kernel.IMP_KERNEL_HAS_BOOST_PROGRAMOPTIONS
IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_kernel.IMP_KERNEL_HAS_BOOST_RANDOM
IMP_KERNEL_HAS_BOOST_SYSTEM = _IMP_kernel.IMP_KERNEL_HAS_BOOST_SYSTEM
IMP_KERNEL_HAS_CGAL = _IMP_kernel.IMP_KERNEL_HAS_CGAL
import os
i_m_p="IMP_MODULE_PATH"
if i_m_p in os.environ.keys():
  __path__.insert(0, os.environ[i_m_p])

def _forward_add_attribute(self, name, value, opt=None):
    if opt is not None:
        self.get_particle().add_attribute(name, value, opt)
    else:
        self.get_particle().add_attribute(name, value)
def _forward_get_value(self, name):
    self.get_particle().get_value(name)
def _forward_set_value(self, name, value):
    self.get_particle().set_value(name, value)

build="release"

_object_types.append("Constraint")


def _object_cast_to_Constraint(*args):
  """_object_cast_to_Constraint(Object o) -> Constraint"""
  return _IMP_kernel._object_cast_to_Constraint(*args)
_object_types.append("Undecorator")


def _object_cast_to_Undecorator(*args):
  """_object_cast_to_Undecorator(Object o) -> Undecorator"""
  return _IMP_kernel._object_cast_to_Undecorator(*args)
_object_types.append("Container")


def _object_cast_to_Container(*args):
  """_object_cast_to_Container(Object o) -> Container"""
  return _IMP_kernel._object_cast_to_Container(*args)
_object_types.append("Optimizer")


def _object_cast_to_Optimizer(*args):
  """_object_cast_to_Optimizer(Object o) -> Optimizer"""
  return _IMP_kernel._object_cast_to_Optimizer(*args)
_object_types.append("OptimizerState")


def _object_cast_to_OptimizerState(*args):
  """_object_cast_to_OptimizerState(Object o) -> OptimizerState"""
  return _IMP_kernel._object_cast_to_OptimizerState(*args)
_object_types.append("PairContainer")


def _object_cast_to_PairContainer(*args):
  """_object_cast_to_PairContainer(Object o) -> PairContainer"""
  return _IMP_kernel._object_cast_to_PairContainer(*args)
_object_types.append("PairModifier")


def _object_cast_to_PairModifier(*args):
  """_object_cast_to_PairModifier(Object o) -> PairModifier"""
  return _IMP_kernel._object_cast_to_PairModifier(*args)
_object_types.append("PairScore")


def _object_cast_to_PairScore(*args):
  """_object_cast_to_PairScore(Object o) -> PairScore"""
  return _IMP_kernel._object_cast_to_PairScore(*args)
_object_types.append("QuadContainer")


def _object_cast_to_QuadContainer(*args):
  """_object_cast_to_QuadContainer(Object o) -> QuadContainer"""
  return _IMP_kernel._object_cast_to_QuadContainer(*args)
_object_types.append("QuadModifier")


def _object_cast_to_QuadModifier(*args):
  """_object_cast_to_QuadModifier(Object o) -> QuadModifier"""
  return _IMP_kernel._object_cast_to_QuadModifier(*args)
_object_types.append("QuadScore")


def _object_cast_to_QuadScore(*args):
  """_object_cast_to_QuadScore(Object o) -> QuadScore"""
  return _IMP_kernel._object_cast_to_QuadScore(*args)
_object_types.append("Refiner")


def _object_cast_to_Refiner(*args):
  """_object_cast_to_Refiner(Object o) -> Refiner"""
  return _IMP_kernel._object_cast_to_Refiner(*args)
_object_types.append("Restraint")


def _object_cast_to_Restraint(*args):
  """_object_cast_to_Restraint(Object o) -> Restraint"""
  return _IMP_kernel._object_cast_to_Restraint(*args)
_object_types.append("Sampler")


def _object_cast_to_Sampler(*args):
  """_object_cast_to_Sampler(Object o) -> Sampler"""
  return _IMP_kernel._object_cast_to_Sampler(*args)
_object_types.append("ScoreState")


def _object_cast_to_ScoreState(*args):
  """_object_cast_to_ScoreState(Object o) -> ScoreState"""
  return _IMP_kernel._object_cast_to_ScoreState(*args)
_object_types.append("SingletonContainer")


def _object_cast_to_SingletonContainer(*args):
  """_object_cast_to_SingletonContainer(Object o) -> SingletonContainer"""
  return _IMP_kernel._object_cast_to_SingletonContainer(*args)
_object_types.append("SingletonModifier")


def _object_cast_to_SingletonModifier(*args):
  """_object_cast_to_SingletonModifier(Object o) -> SingletonModifier"""
  return _IMP_kernel._object_cast_to_SingletonModifier(*args)
_object_types.append("SingletonScore")


def _object_cast_to_SingletonScore(*args):
  """_object_cast_to_SingletonScore(Object o) -> SingletonScore"""
  return _IMP_kernel._object_cast_to_SingletonScore(*args)
_object_types.append("TripletContainer")


def _object_cast_to_TripletContainer(*args):
  """_object_cast_to_TripletContainer(Object o) -> TripletContainer"""
  return _IMP_kernel._object_cast_to_TripletContainer(*args)
_object_types.append("TripletModifier")


def _object_cast_to_TripletModifier(*args):
  """_object_cast_to_TripletModifier(Object o) -> TripletModifier"""
  return _IMP_kernel._object_cast_to_TripletModifier(*args)
_object_types.append("TripletScore")


def _object_cast_to_TripletScore(*args):
  """_object_cast_to_TripletScore(Object o) -> TripletScore"""
  return _IMP_kernel._object_cast_to_TripletScore(*args)
_object_types.append("UnaryFunction")


def _object_cast_to_UnaryFunction(*args):
  """_object_cast_to_UnaryFunction(Object o) -> UnaryFunction"""
  return _IMP_kernel._object_cast_to_UnaryFunction(*args)
_object_types.append("ConfigurationSet")


def _object_cast_to_ConfigurationSet(*args):
  """_object_cast_to_ConfigurationSet(Object o) -> ConfigurationSet"""
  return _IMP_kernel._object_cast_to_ConfigurationSet(*args)
_object_types.append("Configuration")


def _object_cast_to_Configuration(*args):
  """_object_cast_to_Configuration(Object o) -> Configuration"""
  return _IMP_kernel._object_cast_to_Configuration(*args)
_object_types.append("Model")


def _object_cast_to_Model(*args):
  """_object_cast_to_Model(Object o) -> Model"""
  return _IMP_kernel._object_cast_to_Model(*args)
_object_types.append("Particle")


def _object_cast_to_Particle(*args):
  """_object_cast_to_Particle(Object o) -> Particle"""
  return _IMP_kernel._object_cast_to_Particle(*args)
_object_types.append("PythonRestraint")


def _object_cast_to_PythonRestraint(*args):
  """_object_cast_to_PythonRestraint(Object o) -> PythonRestraint"""
  return _IMP_kernel._object_cast_to_PythonRestraint(*args)
_object_types.append("PythonScoreState")


def _object_cast_to_PythonScoreState(*args):
  """_object_cast_to_PythonScoreState(Object o) -> PythonScoreState"""
  return _IMP_kernel._object_cast_to_PythonScoreState(*args)
_object_types.append("RestraintSet")


def _object_cast_to_RestraintSet(*args):
  """_object_cast_to_RestraintSet(Object o) -> RestraintSet"""
  return _IMP_kernel._object_cast_to_RestraintSet(*args)
ParticlePairsTemp=list
_plural_types.append("ParticlePairsTemp")
_value_types.append("ParticlePair")

ParticleTripletsTemp=list
_plural_types.append("ParticleTripletsTemp")
_value_types.append("ParticleTriplet")

ParticleQuadsTemp=list
_plural_types.append("ParticleQuadsTemp")
_value_types.append("ParticleQuad")

ParticleIndexPairs=list
_plural_types.append("ParticleIndexPairs")
_value_types.append("ParticleIndexPair")

ParticleIndexTriplets=list
_plural_types.append("ParticleIndexTriplets")
_value_types.append("ParticleIndexTriplet")

ParticleIndexQuads=list
_plural_types.append("ParticleIndexQuads")
_value_types.append("ParticleIndexQuad")

_object_types.append("SingletonPredicate")


def _object_cast_to_SingletonPredicate(*args):
  """_object_cast_to_SingletonPredicate(Object o) -> SingletonPredicate"""
  return _IMP_kernel._object_cast_to_SingletonPredicate(*args)
_object_types.append("PairPredicate")


def _object_cast_to_PairPredicate(*args):
  """_object_cast_to_PairPredicate(Object o) -> PairPredicate"""
  return _IMP_kernel._object_cast_to_PairPredicate(*args)
_object_types.append("TripletPredicate")


def _object_cast_to_TripletPredicate(*args):
  """_object_cast_to_TripletPredicate(Object o) -> TripletPredicate"""
  return _IMP_kernel._object_cast_to_TripletPredicate(*args)
_object_types.append("QuadPredicate")


def _object_cast_to_QuadPredicate(*args):
  """_object_cast_to_QuadPredicate(Object o) -> QuadPredicate"""
  return _IMP_kernel._object_cast_to_QuadPredicate(*args)
_object_types.append("SaveToConfigurationSetOptimizerState")


def _object_cast_to_SaveToConfigurationSetOptimizerState(*args):
  """_object_cast_to_SaveToConfigurationSetOptimizerState(Object o) -> SaveToConfigurationSetOptimizerState"""
  return _IMP_kernel._object_cast_to_SaveToConfigurationSetOptimizerState(*args)
EvaluationStates=list
_plural_types.append("EvaluationStates")
_value_types.append("EvaluationState")

ScoreAccumulators=list
_plural_types.append("ScoreAccumulators")
_value_types.append("ScoreAccumulator")

ParticleIndexes=list
_plural_types.append("ParticleIndexes")
_value_types.append("ParticleIndex")

FloatIndexes=list
_plural_types.append("FloatIndexes")
_value_types.append("FloatIndex")

FloatKeys=list
_plural_types.append("FloatKeys")
_value_types.append("FloatKey")

IntKeys=list
_plural_types.append("IntKeys")
_value_types.append("IntKey")

StringKeys=list
_plural_types.append("StringKeys")
_value_types.append("StringKey")

ParticleIndexKeys=list
_plural_types.append("ParticleIndexKeys")
_value_types.append("ParticleIndexKey")

ParticleIndexesKeys=list
_plural_types.append("ParticleIndexesKeys")
_value_types.append("ParticleIndexesKey")

ObjectKeys=list
_plural_types.append("ObjectKeys")
_value_types.append("ObjectKey")

_raii_types.append("ScopedRestraint")

_raii_types.append("ScopedRemoveRestraint")

_raii_types.append("ScopedRemoveScoreState")

_raii_types.append("ScopedScoreState")

_raii_types.append("ScopedSetFloatAttribute")

RestraintStatisticsList=list
_plural_types.append("RestraintStatisticsList")
_value_types.append("RestraintStatistics")

_object_types.append("ScoringFunction")


def _object_cast_to_ScoringFunction(*args):
  """_object_cast_to_ScoringFunction(Object o) -> ScoringFunction"""
  return _IMP_kernel._object_cast_to_ScoringFunction(*args)
_object_types.append("ModelObject")


def _object_cast_to_ModelObject(*args):
  """_object_cast_to_ModelObject(Object o) -> ModelObject"""
  return _IMP_kernel._object_cast_to_ModelObject(*args)
def _TrivialDecorators(l=[]):
    return [_TrivialDecorator(x) for x in l]
_plural_types.append("_TrivialDecorators")

_value_types.append("_TrivialDecorator")

def _TrivialDerivedDecorators(l=[]):
    return [_TrivialDerivedDecorator(x) for x in l]
_plural_types.append("_TrivialDerivedDecorators")

_value_types.append("_TrivialDerivedDecorator")

def _TrivialTraitsDecorators(l=[]):
    return [_TrivialTraitsDecorator(x) for x in l]
_plural_types.append("_TrivialTraitsDecorators")

_value_types.append("_TrivialTraitsDecorator")

_object_types.append("_ConstRestraint")


def _object_cast_to__ConstRestraint(*args):
  """_object_cast_to__ConstRestraint(Object o) -> _ConstRestraint"""
  return _IMP_kernel._object_cast_to__ConstRestraint(*args)
_object_types.append("_ConstOptimizer")


def _object_cast_to__ConstOptimizer(*args):
  """_object_cast_to__ConstOptimizer(Object o) -> _ConstOptimizer"""
  return _IMP_kernel._object_cast_to__ConstOptimizer(*args)
class DependencyGraph(IMP.base.Object):
    """Proxy of C++ IMP::base::internal::BoostDigraph<(IMP::kernel::DependencyGraph,p.IMP::kernel::ModelObject)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DependencyGraph, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DependencyGraph, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(IMP::base::internal::BoostDigraph<(IMP::kernel::DependencyGraph,p.IMP::kernel::ModelObject)> self) -> DependencyGraph"""
        this = _IMP_kernel.new_DependencyGraph()
        try: self.this.append(this)
        except: self.this = this
    def get_graph(self):
        """get_graph(DependencyGraph self) -> IMP::kernel::DependencyGraph const &"""
        return _IMP_kernel.DependencyGraph_get_graph(self)

    def get_vertices(self):
        """get_vertices(DependencyGraph self) -> IMP::base::internal::BoostDigraph< IMP::kernel::DependencyGraph,IMP::kernel::ModelObject * >::VertexDescriptors"""
        return _IMP_kernel.DependencyGraph_get_vertices(self)

    def get_vertex_name(self, *args):
        """get_vertex_name(DependencyGraph self, IMP::base::internal::BoostDigraph< IMP::kernel::DependencyGraph,IMP::kernel::ModelObject * >::VertexDescriptor i) -> ModelObject"""
        return _IMP_kernel.DependencyGraph_get_vertex_name(self, *args)

    def get_in_neighbors(self, *args):
        """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"""
        return _IMP_kernel.DependencyGraph_get_in_neighbors(self, *args)

    def get_out_neighbors(self, *args):
        """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"""
        return _IMP_kernel.DependencyGraph_get_out_neighbors(self, *args)

    def do_show(self, *args):
        """do_show(DependencyGraph self, _ostream out)"""
        return _IMP_kernel.DependencyGraph_do_show(self, *args)

    def show_graphviz(self, *args):
        """
        show_graphviz(DependencyGraph self, _ostream out=std::cout)
        show_graphviz(DependencyGraph self)
        """
        return _IMP_kernel.DependencyGraph_show_graphviz(self, *args)

    def get_graphviz_string(self):
        """get_graphviz_string(DependencyGraph self) -> std::string"""
        return _IMP_kernel.DependencyGraph_get_graphviz_string(self)

    def get_type_name(self):
        """get_type_name(DependencyGraph self) -> std::string"""
        return _IMP_kernel.DependencyGraph_get_type_name(self)

    def add_edge(self, *args):
        """
        add_edge(DependencyGraph self, IMP::base::internal::BoostDigraph< IMP::kernel::DependencyGraph,IMP::kernel::ModelObject * >::VertexDescriptor v0, 
            IMP::base::internal::BoostDigraph< IMP::kernel::DependencyGraph,IMP::kernel::ModelObject * >::VertexDescriptor v1)
        """
        return _IMP_kernel.DependencyGraph_add_edge(self, *args)

    def add_vertex(self, *args):
        """add_vertex(DependencyGraph self, ModelObject l) -> IMP::base::internal::BoostDigraph< IMP::kernel::DependencyGraph,IMP::kernel::ModelObject * >::VertexDescriptor"""
        return _IMP_kernel.DependencyGraph_add_vertex(self, *args)

    def remove_vertex(self, *args):
        """remove_vertex(DependencyGraph self, IMP::base::internal::BoostDigraph< IMP::kernel::DependencyGraph,IMP::kernel::ModelObject * >::VertexDescriptor l)"""
        return _IMP_kernel.DependencyGraph_remove_vertex(self, *args)

    __swig_destroy__ = _IMP_kernel.delete_DependencyGraph
    __del__ = lambda self : None;
DependencyGraph_swigregister = _IMP_kernel.DependencyGraph_swigregister
DependencyGraph_swigregister(DependencyGraph)

_value_types.append("DependencyGraph")

class FloatKey(IMP.base._Value):
    """Proxy of C++ IMP::kernel::Key<(0,true)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base._Value]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FloatKey, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base._Value]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FloatKey, name)
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::Key<(0,true)> self) -> FloatKey
        __init__(IMP::kernel::Key<(0,true)> self, std::string c) -> FloatKey
        __init__(IMP::kernel::Key<(0,true)> self, unsigned int i) -> FloatKey
        """
        this = _IMP_kernel.new_FloatKey(*args)
        try: self.this.append(this)
        except: self.this = this
    def add_key(*args):
        """add_key(std::string sc) -> unsigned int"""
        return _IMP_kernel.FloatKey_add_key(*args)

    if _newclass:add_key = staticmethod(add_key)
    __swig_getmethods__["add_key"] = lambda x: add_key
    def get_key_exists(*args):
        """get_key_exists(std::string sc) -> bool"""
        return _IMP_kernel.FloatKey_get_key_exists(*args)

    if _newclass:get_key_exists = staticmethod(get_key_exists)
    __swig_getmethods__["get_key_exists"] = lambda x: get_key_exists
    def get_string(self):
        """get_string(FloatKey self) -> std::string const"""
        return _IMP_kernel.FloatKey_get_string(self)

    def __eq__(self, *args):
        """__eq__(FloatKey self, FloatKey o) -> bool"""
        return _IMP_kernel.FloatKey___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(FloatKey self, FloatKey o) -> bool"""
        return _IMP_kernel.FloatKey___ne__(self, *args)

    def __lt__(self, *args):
        """__lt__(FloatKey self, FloatKey o) -> bool"""
        return _IMP_kernel.FloatKey___lt__(self, *args)

    def __gt__(self, *args):
        """__gt__(FloatKey self, FloatKey o) -> bool"""
        return _IMP_kernel.FloatKey___gt__(self, *args)

    def __ge__(self, *args):
        """__ge__(FloatKey self, FloatKey o) -> bool"""
        return _IMP_kernel.FloatKey___ge__(self, *args)

    def __le__(self, *args):
        """__le__(FloatKey self, FloatKey o) -> bool"""
        return _IMP_kernel.FloatKey___le__(self, *args)

    def __hash__(self):
        """__hash__(FloatKey self) -> std::size_t"""
        return _IMP_kernel.FloatKey___hash__(self)

    def show(self, *args):
        """
        show(FloatKey self, _ostream out=std::cout)
        show(FloatKey self)
        """
        return _IMP_kernel.FloatKey_show(self, *args)

    def add_alias(*args):
        """add_alias(FloatKey old_key, std::string new_name) -> FloatKey"""
        return _IMP_kernel.FloatKey_add_alias(*args)

    if _newclass:add_alias = staticmethod(add_alias)
    __swig_getmethods__["add_alias"] = lambda x: add_alias
    def get_index(self):
        """get_index(FloatKey self) -> unsigned int"""
        return _IMP_kernel.FloatKey_get_index(self)

    def show_all(*args):
        """show_all(_ostream out)"""
        return _IMP_kernel.FloatKey_show_all(*args)

    if _newclass:show_all = staticmethod(show_all)
    __swig_getmethods__["show_all"] = lambda x: show_all
    def get_all_strings():
        """get_all_strings() -> IMP::base::Vector< std::string >"""
        return _IMP_kernel.FloatKey_get_all_strings()

    if _newclass:get_all_strings = staticmethod(get_all_strings)
    __swig_getmethods__["get_all_strings"] = lambda x: get_all_strings
    def get_number_unique():
        """get_number_unique() -> unsigned int"""
        return _IMP_kernel.FloatKey_get_number_unique()

    if _newclass:get_number_unique = staticmethod(get_number_unique)
    __swig_getmethods__["get_number_unique"] = lambda x: get_number_unique
    def __str__(self):
        """__str__(FloatKey self) -> std::string"""
        return _IMP_kernel.FloatKey___str__(self)

    def __repr__(self):
        """__repr__(FloatKey self) -> std::string"""
        return _IMP_kernel.FloatKey___repr__(self)

    __swig_destroy__ = _IMP_kernel.delete_FloatKey
    __del__ = lambda self : None;
FloatKey_swigregister = _IMP_kernel.FloatKey_swigregister
FloatKey_swigregister(FloatKey)

def FloatKey_add_key(*args):
  """FloatKey_add_key(std::string sc) -> unsigned int"""
  return _IMP_kernel.FloatKey_add_key(*args)

def FloatKey_get_key_exists(*args):
  """FloatKey_get_key_exists(std::string sc) -> bool"""
  return _IMP_kernel.FloatKey_get_key_exists(*args)

def FloatKey_add_alias(*args):
  """FloatKey_add_alias(FloatKey old_key, std::string new_name) -> FloatKey"""
  return _IMP_kernel.FloatKey_add_alias(*args)

def FloatKey_show_all(*args):
  """FloatKey_show_all(_ostream out)"""
  return _IMP_kernel.FloatKey_show_all(*args)

def FloatKey_get_all_strings():
  """FloatKey_get_all_strings() -> IMP::base::Vector< std::string >"""
  return _IMP_kernel.FloatKey_get_all_strings()

def FloatKey_get_number_unique():
  """FloatKey_get_number_unique() -> unsigned int"""
  return _IMP_kernel.FloatKey_get_number_unique()

class IntKey(IMP.base._Value):
    """Proxy of C++ IMP::kernel::Key<(1,true)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base._Value]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, IntKey, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base._Value]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, IntKey, name)
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::Key<(1,true)> self) -> IntKey
        __init__(IMP::kernel::Key<(1,true)> self, std::string c) -> IntKey
        __init__(IMP::kernel::Key<(1,true)> self, unsigned int i) -> IntKey
        """
        this = _IMP_kernel.new_IntKey(*args)
        try: self.this.append(this)
        except: self.this = this
    def add_key(*args):
        """add_key(std::string sc) -> unsigned int"""
        return _IMP_kernel.IntKey_add_key(*args)

    if _newclass:add_key = staticmethod(add_key)
    __swig_getmethods__["add_key"] = lambda x: add_key
    def get_key_exists(*args):
        """get_key_exists(std::string sc) -> bool"""
        return _IMP_kernel.IntKey_get_key_exists(*args)

    if _newclass:get_key_exists = staticmethod(get_key_exists)
    __swig_getmethods__["get_key_exists"] = lambda x: get_key_exists
    def get_string(self):
        """get_string(IntKey self) -> std::string const"""
        return _IMP_kernel.IntKey_get_string(self)

    def __eq__(self, *args):
        """__eq__(IntKey self, IntKey o) -> bool"""
        return _IMP_kernel.IntKey___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(IntKey self, IntKey o) -> bool"""
        return _IMP_kernel.IntKey___ne__(self, *args)

    def __lt__(self, *args):
        """__lt__(IntKey self, IntKey o) -> bool"""
        return _IMP_kernel.IntKey___lt__(self, *args)

    def __gt__(self, *args):
        """__gt__(IntKey self, IntKey o) -> bool"""
        return _IMP_kernel.IntKey___gt__(self, *args)

    def __ge__(self, *args):
        """__ge__(IntKey self, IntKey o) -> bool"""
        return _IMP_kernel.IntKey___ge__(self, *args)

    def __le__(self, *args):
        """__le__(IntKey self, IntKey o) -> bool"""
        return _IMP_kernel.IntKey___le__(self, *args)

    def __hash__(self):
        """__hash__(IntKey self) -> std::size_t"""
        return _IMP_kernel.IntKey___hash__(self)

    def show(self, *args):
        """
        show(IntKey self, _ostream out=std::cout)
        show(IntKey self)
        """
        return _IMP_kernel.IntKey_show(self, *args)

    def add_alias(*args):
        """add_alias(IntKey old_key, std::string new_name) -> IntKey"""
        return _IMP_kernel.IntKey_add_alias(*args)

    if _newclass:add_alias = staticmethod(add_alias)
    __swig_getmethods__["add_alias"] = lambda x: add_alias
    def get_index(self):
        """get_index(IntKey self) -> unsigned int"""
        return _IMP_kernel.IntKey_get_index(self)

    def show_all(*args):
        """show_all(_ostream out)"""
        return _IMP_kernel.IntKey_show_all(*args)

    if _newclass:show_all = staticmethod(show_all)
    __swig_getmethods__["show_all"] = lambda x: show_all
    def get_all_strings():
        """get_all_strings() -> IMP::base::Vector< std::string >"""
        return _IMP_kernel.IntKey_get_all_strings()

    if _newclass:get_all_strings = staticmethod(get_all_strings)
    __swig_getmethods__["get_all_strings"] = lambda x: get_all_strings
    def get_number_unique():
        """get_number_unique() -> unsigned int"""
        return _IMP_kernel.IntKey_get_number_unique()

    if _newclass:get_number_unique = staticmethod(get_number_unique)
    __swig_getmethods__["get_number_unique"] = lambda x: get_number_unique
    def __str__(self):
        """__str__(IntKey self) -> std::string"""
        return _IMP_kernel.IntKey___str__(self)

    def __repr__(self):
        """__repr__(IntKey self) -> std::string"""
        return _IMP_kernel.IntKey___repr__(self)

    __swig_destroy__ = _IMP_kernel.delete_IntKey
    __del__ = lambda self : None;
IntKey_swigregister = _IMP_kernel.IntKey_swigregister
IntKey_swigregister(IntKey)

def IntKey_add_key(*args):
  """IntKey_add_key(std::string sc) -> unsigned int"""
  return _IMP_kernel.IntKey_add_key(*args)

def IntKey_get_key_exists(*args):
  """IntKey_get_key_exists(std::string sc) -> bool"""
  return _IMP_kernel.IntKey_get_key_exists(*args)

def IntKey_add_alias(*args):
  """IntKey_add_alias(IntKey old_key, std::string new_name) -> IntKey"""
  return _IMP_kernel.IntKey_add_alias(*args)

def IntKey_show_all(*args):
  """IntKey_show_all(_ostream out)"""
  return _IMP_kernel.IntKey_show_all(*args)

def IntKey_get_all_strings():
  """IntKey_get_all_strings() -> IMP::base::Vector< std::string >"""
  return _IMP_kernel.IntKey_get_all_strings()

def IntKey_get_number_unique():
  """IntKey_get_number_unique() -> unsigned int"""
  return _IMP_kernel.IntKey_get_number_unique()

class StringKey(IMP.base._Value):
    """Proxy of C++ IMP::kernel::Key<(2,true)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base._Value]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, StringKey, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base._Value]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, StringKey, name)
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::Key<(2,true)> self) -> StringKey
        __init__(IMP::kernel::Key<(2,true)> self, std::string c) -> StringKey
        __init__(IMP::kernel::Key<(2,true)> self, unsigned int i) -> StringKey
        """
        this = _IMP_kernel.new_StringKey(*args)
        try: self.this.append(this)
        except: self.this = this
    def add_key(*args):
        """add_key(std::string sc) -> unsigned int"""
        return _IMP_kernel.StringKey_add_key(*args)

    if _newclass:add_key = staticmethod(add_key)
    __swig_getmethods__["add_key"] = lambda x: add_key
    def get_key_exists(*args):
        """get_key_exists(std::string sc) -> bool"""
        return _IMP_kernel.StringKey_get_key_exists(*args)

    if _newclass:get_key_exists = staticmethod(get_key_exists)
    __swig_getmethods__["get_key_exists"] = lambda x: get_key_exists
    def get_string(self):
        """get_string(StringKey self) -> std::string const"""
        return _IMP_kernel.StringKey_get_string(self)

    def __eq__(self, *args):
        """__eq__(StringKey self, StringKey o) -> bool"""
        return _IMP_kernel.StringKey___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(StringKey self, StringKey o) -> bool"""
        return _IMP_kernel.StringKey___ne__(self, *args)

    def __lt__(self, *args):
        """__lt__(StringKey self, StringKey o) -> bool"""
        return _IMP_kernel.StringKey___lt__(self, *args)

    def __gt__(self, *args):
        """__gt__(StringKey self, StringKey o) -> bool"""
        return _IMP_kernel.StringKey___gt__(self, *args)

    def __ge__(self, *args):
        """__ge__(StringKey self, StringKey o) -> bool"""
        return _IMP_kernel.StringKey___ge__(self, *args)

    def __le__(self, *args):
        """__le__(StringKey self, StringKey o) -> bool"""
        return _IMP_kernel.StringKey___le__(self, *args)

    def __hash__(self):
        """__hash__(StringKey self) -> std::size_t"""
        return _IMP_kernel.StringKey___hash__(self)

    def show(self, *args):
        """
        show(StringKey self, _ostream out=std::cout)
        show(StringKey self)
        """
        return _IMP_kernel.StringKey_show(self, *args)

    def add_alias(*args):
        """add_alias(StringKey old_key, std::string new_name) -> StringKey"""
        return _IMP_kernel.StringKey_add_alias(*args)

    if _newclass:add_alias = staticmethod(add_alias)
    __swig_getmethods__["add_alias"] = lambda x: add_alias
    def get_index(self):
        """get_index(StringKey self) -> unsigned int"""
        return _IMP_kernel.StringKey_get_index(self)

    def show_all(*args):
        """show_all(_ostream out)"""
        return _IMP_kernel.StringKey_show_all(*args)

    if _newclass:show_all = staticmethod(show_all)
    __swig_getmethods__["show_all"] = lambda x: show_all
    def get_all_strings():
        """get_all_strings() -> IMP::base::Vector< std::string >"""
        return _IMP_kernel.StringKey_get_all_strings()

    if _newclass:get_all_strings = staticmethod(get_all_strings)
    __swig_getmethods__["get_all_strings"] = lambda x: get_all_strings
    def get_number_unique():
        """get_number_unique() -> unsigned int"""
        return _IMP_kernel.StringKey_get_number_unique()

    if _newclass:get_number_unique = staticmethod(get_number_unique)
    __swig_getmethods__["get_number_unique"] = lambda x: get_number_unique
    def __str__(self):
        """__str__(StringKey self) -> std::string"""
        return _IMP_kernel.StringKey___str__(self)

    def __repr__(self):
        """__repr__(StringKey self) -> std::string"""
        return _IMP_kernel.StringKey___repr__(self)

    __swig_destroy__ = _IMP_kernel.delete_StringKey
    __del__ = lambda self : None;
StringKey_swigregister = _IMP_kernel.StringKey_swigregister
StringKey_swigregister(StringKey)

def StringKey_add_key(*args):
  """StringKey_add_key(std::string sc) -> unsigned int"""
  return _IMP_kernel.StringKey_add_key(*args)

def StringKey_get_key_exists(*args):
  """StringKey_get_key_exists(std::string sc) -> bool"""
  return _IMP_kernel.StringKey_get_key_exists(*args)

def StringKey_add_alias(*args):
  """StringKey_add_alias(StringKey old_key, std::string new_name) -> StringKey"""
  return _IMP_kernel.StringKey_add_alias(*args)

def StringKey_show_all(*args):
  """StringKey_show_all(_ostream out)"""
  return _IMP_kernel.StringKey_show_all(*args)

def StringKey_get_all_strings():
  """StringKey_get_all_strings() -> IMP::base::Vector< std::string >"""
  return _IMP_kernel.StringKey_get_all_strings()

def StringKey_get_number_unique():
  """StringKey_get_number_unique() -> unsigned int"""
  return _IMP_kernel.StringKey_get_number_unique()

class ParticleIndexKey(IMP.base._Value):
    """Proxy of C++ IMP::kernel::Key<(3,true)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base._Value]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ParticleIndexKey, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base._Value]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ParticleIndexKey, name)
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::Key<(3,true)> self) -> ParticleIndexKey
        __init__(IMP::kernel::Key<(3,true)> self, std::string c) -> ParticleIndexKey
        __init__(IMP::kernel::Key<(3,true)> self, unsigned int i) -> ParticleIndexKey
        """
        this = _IMP_kernel.new_ParticleIndexKey(*args)
        try: self.this.append(this)
        except: self.this = this
    def add_key(*args):
        """add_key(std::string sc) -> unsigned int"""
        return _IMP_kernel.ParticleIndexKey_add_key(*args)

    if _newclass:add_key = staticmethod(add_key)
    __swig_getmethods__["add_key"] = lambda x: add_key
    def get_key_exists(*args):
        """get_key_exists(std::string sc) -> bool"""
        return _IMP_kernel.ParticleIndexKey_get_key_exists(*args)

    if _newclass:get_key_exists = staticmethod(get_key_exists)
    __swig_getmethods__["get_key_exists"] = lambda x: get_key_exists
    def get_string(self):
        """get_string(ParticleIndexKey self) -> std::string const"""
        return _IMP_kernel.ParticleIndexKey_get_string(self)

    def __eq__(self, *args):
        """__eq__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
        return _IMP_kernel.ParticleIndexKey___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
        return _IMP_kernel.ParticleIndexKey___ne__(self, *args)

    def __lt__(self, *args):
        """__lt__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
        return _IMP_kernel.ParticleIndexKey___lt__(self, *args)

    def __gt__(self, *args):
        """__gt__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
        return _IMP_kernel.ParticleIndexKey___gt__(self, *args)

    def __ge__(self, *args):
        """__ge__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
        return _IMP_kernel.ParticleIndexKey___ge__(self, *args)

    def __le__(self, *args):
        """__le__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
        return _IMP_kernel.ParticleIndexKey___le__(self, *args)

    def __hash__(self):
        """__hash__(ParticleIndexKey self) -> std::size_t"""
        return _IMP_kernel.ParticleIndexKey___hash__(self)

    def show(self, *args):
        """
        show(ParticleIndexKey self, _ostream out=std::cout)
        show(ParticleIndexKey self)
        """
        return _IMP_kernel.ParticleIndexKey_show(self, *args)

    def add_alias(*args):
        """add_alias(ParticleIndexKey old_key, std::string new_name) -> ParticleIndexKey"""
        return _IMP_kernel.ParticleIndexKey_add_alias(*args)

    if _newclass:add_alias = staticmethod(add_alias)
    __swig_getmethods__["add_alias"] = lambda x: add_alias
    def get_index(self):
        """get_index(ParticleIndexKey self) -> unsigned int"""
        return _IMP_kernel.ParticleIndexKey_get_index(self)

    def show_all(*args):
        """show_all(_ostream out)"""
        return _IMP_kernel.ParticleIndexKey_show_all(*args)

    if _newclass:show_all = staticmethod(show_all)
    __swig_getmethods__["show_all"] = lambda x: show_all
    def get_all_strings():
        """get_all_strings() -> IMP::base::Vector< std::string >"""
        return _IMP_kernel.ParticleIndexKey_get_all_strings()

    if _newclass:get_all_strings = staticmethod(get_all_strings)
    __swig_getmethods__["get_all_strings"] = lambda x: get_all_strings
    def get_number_unique():
        """get_number_unique() -> unsigned int"""
        return _IMP_kernel.ParticleIndexKey_get_number_unique()

    if _newclass:get_number_unique = staticmethod(get_number_unique)
    __swig_getmethods__["get_number_unique"] = lambda x: get_number_unique
    def __str__(self):
        """__str__(ParticleIndexKey self) -> std::string"""
        return _IMP_kernel.ParticleIndexKey___str__(self)

    def __repr__(self):
        """__repr__(ParticleIndexKey self) -> std::string"""
        return _IMP_kernel.ParticleIndexKey___repr__(self)

    __swig_destroy__ = _IMP_kernel.delete_ParticleIndexKey
    __del__ = lambda self : None;
ParticleIndexKey_swigregister = _IMP_kernel.ParticleIndexKey_swigregister
ParticleIndexKey_swigregister(ParticleIndexKey)

def ParticleIndexKey_add_key(*args):
  """ParticleIndexKey_add_key(std::string sc) -> unsigned int"""
  return _IMP_kernel.ParticleIndexKey_add_key(*args)

def ParticleIndexKey_get_key_exists(*args):
  """ParticleIndexKey_get_key_exists(std::string sc) -> bool"""
  return _IMP_kernel.ParticleIndexKey_get_key_exists(*args)

def ParticleIndexKey_add_alias(*args):
  """ParticleIndexKey_add_alias(ParticleIndexKey old_key, std::string new_name) -> ParticleIndexKey"""
  return _IMP_kernel.ParticleIndexKey_add_alias(*args)

def ParticleIndexKey_show_all(*args):
  """ParticleIndexKey_show_all(_ostream out)"""
  return _IMP_kernel.ParticleIndexKey_show_all(*args)

def ParticleIndexKey_get_all_strings():
  """ParticleIndexKey_get_all_strings() -> IMP::base::Vector< std::string >"""
  return _IMP_kernel.ParticleIndexKey_get_all_strings()

def ParticleIndexKey_get_number_unique():
  """ParticleIndexKey_get_number_unique() -> unsigned int"""
  return _IMP_kernel.ParticleIndexKey_get_number_unique()

class ObjectKey(IMP.base._Value):
    """Proxy of C++ IMP::kernel::Key<(4,true)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base._Value]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ObjectKey, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base._Value]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ObjectKey, name)
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::Key<(4,true)> self) -> ObjectKey
        __init__(IMP::kernel::Key<(4,true)> self, std::string c) -> ObjectKey
        __init__(IMP::kernel::Key<(4,true)> self, unsigned int i) -> ObjectKey
        """
        this = _IMP_kernel.new_ObjectKey(*args)
        try: self.this.append(this)
        except: self.this = this
    def add_key(*args):
        """add_key(std::string sc) -> unsigned int"""
        return _IMP_kernel.ObjectKey_add_key(*args)

    if _newclass:add_key = staticmethod(add_key)
    __swig_getmethods__["add_key"] = lambda x: add_key
    def get_key_exists(*args):
        """get_key_exists(std::string sc) -> bool"""
        return _IMP_kernel.ObjectKey_get_key_exists(*args)

    if _newclass:get_key_exists = staticmethod(get_key_exists)
    __swig_getmethods__["get_key_exists"] = lambda x: get_key_exists
    def get_string(self):
        """get_string(ObjectKey self) -> std::string const"""
        return _IMP_kernel.ObjectKey_get_string(self)

    def __eq__(self, *args):
        """__eq__(ObjectKey self, ObjectKey o) -> bool"""
        return _IMP_kernel.ObjectKey___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(ObjectKey self, ObjectKey o) -> bool"""
        return _IMP_kernel.ObjectKey___ne__(self, *args)

    def __lt__(self, *args):
        """__lt__(ObjectKey self, ObjectKey o) -> bool"""
        return _IMP_kernel.ObjectKey___lt__(self, *args)

    def __gt__(self, *args):
        """__gt__(ObjectKey self, ObjectKey o) -> bool"""
        return _IMP_kernel.ObjectKey___gt__(self, *args)

    def __ge__(self, *args):
        """__ge__(ObjectKey self, ObjectKey o) -> bool"""
        return _IMP_kernel.ObjectKey___ge__(self, *args)

    def __le__(self, *args):
        """__le__(ObjectKey self, ObjectKey o) -> bool"""
        return _IMP_kernel.ObjectKey___le__(self, *args)

    def __hash__(self):
        """__hash__(ObjectKey self) -> std::size_t"""
        return _IMP_kernel.ObjectKey___hash__(self)

    def show(self, *args):
        """
        show(ObjectKey self, _ostream out=std::cout)
        show(ObjectKey self)
        """
        return _IMP_kernel.ObjectKey_show(self, *args)

    def add_alias(*args):
        """add_alias(ObjectKey old_key, std::string new_name) -> ObjectKey"""
        return _IMP_kernel.ObjectKey_add_alias(*args)

    if _newclass:add_alias = staticmethod(add_alias)
    __swig_getmethods__["add_alias"] = lambda x: add_alias
    def get_index(self):
        """get_index(ObjectKey self) -> unsigned int"""
        return _IMP_kernel.ObjectKey_get_index(self)

    def show_all(*args):
        """show_all(_ostream out)"""
        return _IMP_kernel.ObjectKey_show_all(*args)

    if _newclass:show_all = staticmethod(show_all)
    __swig_getmethods__["show_all"] = lambda x: show_all
    def get_all_strings():
        """get_all_strings() -> IMP::base::Vector< std::string >"""
        return _IMP_kernel.ObjectKey_get_all_strings()

    if _newclass:get_all_strings = staticmethod(get_all_strings)
    __swig_getmethods__["get_all_strings"] = lambda x: get_all_strings
    def get_number_unique():
        """get_number_unique() -> unsigned int"""
        return _IMP_kernel.ObjectKey_get_number_unique()

    if _newclass:get_number_unique = staticmethod(get_number_unique)
    __swig_getmethods__["get_number_unique"] = lambda x: get_number_unique
    def __str__(self):
        """__str__(ObjectKey self) -> std::string"""
        return _IMP_kernel.ObjectKey___str__(self)

    def __repr__(self):
        """__repr__(ObjectKey self) -> std::string"""
        return _IMP_kernel.ObjectKey___repr__(self)

    __swig_destroy__ = _IMP_kernel.delete_ObjectKey
    __del__ = lambda self : None;
ObjectKey_swigregister = _IMP_kernel.ObjectKey_swigregister
ObjectKey_swigregister(ObjectKey)

def ObjectKey_add_key(*args):
  """ObjectKey_add_key(std::string sc) -> unsigned int"""
  return _IMP_kernel.ObjectKey_add_key(*args)

def ObjectKey_get_key_exists(*args):
  """ObjectKey_get_key_exists(std::string sc) -> bool"""
  return _IMP_kernel.ObjectKey_get_key_exists(*args)

def ObjectKey_add_alias(*args):
  """ObjectKey_add_alias(ObjectKey old_key, std::string new_name) -> ObjectKey"""
  return _IMP_kernel.ObjectKey_add_alias(*args)

def ObjectKey_show_all(*args):
  """ObjectKey_show_all(_ostream out)"""
  return _IMP_kernel.ObjectKey_show_all(*args)

def ObjectKey_get_all_strings():
  """ObjectKey_get_all_strings() -> IMP::base::Vector< std::string >"""
  return _IMP_kernel.ObjectKey_get_all_strings()

def ObjectKey_get_number_unique():
  """ObjectKey_get_number_unique() -> unsigned int"""
  return _IMP_kernel.ObjectKey_get_number_unique()

class ParticleIndexesKey(IMP.base._Value):
    """Proxy of C++ IMP::kernel::Key<(6,true)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base._Value]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ParticleIndexesKey, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base._Value]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ParticleIndexesKey, name)
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::Key<(6,true)> self) -> ParticleIndexesKey
        __init__(IMP::kernel::Key<(6,true)> self, std::string c) -> ParticleIndexesKey
        __init__(IMP::kernel::Key<(6,true)> self, unsigned int i) -> ParticleIndexesKey
        """
        this = _IMP_kernel.new_ParticleIndexesKey(*args)
        try: self.this.append(this)
        except: self.this = this
    def add_key(*args):
        """add_key(std::string sc) -> unsigned int"""
        return _IMP_kernel.ParticleIndexesKey_add_key(*args)

    if _newclass:add_key = staticmethod(add_key)
    __swig_getmethods__["add_key"] = lambda x: add_key
    def get_key_exists(*args):
        """get_key_exists(std::string sc) -> bool"""
        return _IMP_kernel.ParticleIndexesKey_get_key_exists(*args)

    if _newclass:get_key_exists = staticmethod(get_key_exists)
    __swig_getmethods__["get_key_exists"] = lambda x: get_key_exists
    def get_string(self):
        """get_string(ParticleIndexesKey self) -> std::string const"""
        return _IMP_kernel.ParticleIndexesKey_get_string(self)

    def __eq__(self, *args):
        """__eq__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
        return _IMP_kernel.ParticleIndexesKey___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
        return _IMP_kernel.ParticleIndexesKey___ne__(self, *args)

    def __lt__(self, *args):
        """__lt__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
        return _IMP_kernel.ParticleIndexesKey___lt__(self, *args)

    def __gt__(self, *args):
        """__gt__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
        return _IMP_kernel.ParticleIndexesKey___gt__(self, *args)

    def __ge__(self, *args):
        """__ge__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
        return _IMP_kernel.ParticleIndexesKey___ge__(self, *args)

    def __le__(self, *args):
        """__le__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
        return _IMP_kernel.ParticleIndexesKey___le__(self, *args)

    def __hash__(self):
        """__hash__(ParticleIndexesKey self) -> std::size_t"""
        return _IMP_kernel.ParticleIndexesKey___hash__(self)

    def show(self, *args):
        """
        show(ParticleIndexesKey self, _ostream out=std::cout)
        show(ParticleIndexesKey self)
        """
        return _IMP_kernel.ParticleIndexesKey_show(self, *args)

    def add_alias(*args):
        """add_alias(ParticleIndexesKey old_key, std::string new_name) -> ParticleIndexesKey"""
        return _IMP_kernel.ParticleIndexesKey_add_alias(*args)

    if _newclass:add_alias = staticmethod(add_alias)
    __swig_getmethods__["add_alias"] = lambda x: add_alias
    def get_index(self):
        """get_index(ParticleIndexesKey self) -> unsigned int"""
        return _IMP_kernel.ParticleIndexesKey_get_index(self)

    def show_all(*args):
        """show_all(_ostream out)"""
        return _IMP_kernel.ParticleIndexesKey_show_all(*args)

    if _newclass:show_all = staticmethod(show_all)
    __swig_getmethods__["show_all"] = lambda x: show_all
    def get_all_strings():
        """get_all_strings() -> IMP::base::Vector< std::string >"""
        return _IMP_kernel.ParticleIndexesKey_get_all_strings()

    if _newclass:get_all_strings = staticmethod(get_all_strings)
    __swig_getmethods__["get_all_strings"] = lambda x: get_all_strings
    def get_number_unique():
        """get_number_unique() -> unsigned int"""
        return _IMP_kernel.ParticleIndexesKey_get_number_unique()

    if _newclass:get_number_unique = staticmethod(get_number_unique)
    __swig_getmethods__["get_number_unique"] = lambda x: get_number_unique
    def __str__(self):
        """__str__(ParticleIndexesKey self) -> std::string"""
        return _IMP_kernel.ParticleIndexesKey___str__(self)

    def __repr__(self):
        """__repr__(ParticleIndexesKey self) -> std::string"""
        return _IMP_kernel.ParticleIndexesKey___repr__(self)

    __swig_destroy__ = _IMP_kernel.delete_ParticleIndexesKey
    __del__ = lambda self : None;
ParticleIndexesKey_swigregister = _IMP_kernel.ParticleIndexesKey_swigregister
ParticleIndexesKey_swigregister(ParticleIndexesKey)

def ParticleIndexesKey_add_key(*args):
  """ParticleIndexesKey_add_key(std::string sc) -> unsigned int"""
  return _IMP_kernel.ParticleIndexesKey_add_key(*args)

def ParticleIndexesKey_get_key_exists(*args):
  """ParticleIndexesKey_get_key_exists(std::string sc) -> bool"""
  return _IMP_kernel.ParticleIndexesKey_get_key_exists(*args)

def ParticleIndexesKey_add_alias(*args):
  """ParticleIndexesKey_add_alias(ParticleIndexesKey old_key, std::string new_name) -> ParticleIndexesKey"""
  return _IMP_kernel.ParticleIndexesKey_add_alias(*args)

def ParticleIndexesKey_show_all(*args):
  """ParticleIndexesKey_show_all(_ostream out)"""
  return _IMP_kernel.ParticleIndexesKey_show_all(*args)

def ParticleIndexesKey_get_all_strings():
  """ParticleIndexesKey_get_all_strings() -> IMP::base::Vector< std::string >"""
  return _IMP_kernel.ParticleIndexesKey_get_all_strings()

def ParticleIndexesKey_get_number_unique():
  """ParticleIndexesKey_get_number_unique() -> unsigned int"""
  return _IMP_kernel.ParticleIndexesKey_get_number_unique()

class ParticleIndex(IMP.base._Value):
    """Proxy of C++ IMP::base::Index<(IMP::ParticleIndexTag)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base._Value]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ParticleIndex, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base._Value]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ParticleIndex, name)
    def __init__(self, *args): 
        """
        __init__(IMP::base::Index<(IMP::ParticleIndexTag)> self, int i) -> ParticleIndex
        __init__(IMP::base::Index<(IMP::ParticleIndexTag)> self) -> ParticleIndex
        """
        this = _IMP_kernel.new_ParticleIndex(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_index(self):
        """get_index(ParticleIndex self) -> int"""
        return _IMP_kernel.ParticleIndex_get_index(self)

    def __eq__(self, *args):
        """__eq__(ParticleIndex self, ParticleIndex o) -> bool"""
        return _IMP_kernel.ParticleIndex___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(ParticleIndex self, ParticleIndex o) -> bool"""
        return _IMP_kernel.ParticleIndex___ne__(self, *args)

    def __lt__(self, *args):
        """__lt__(ParticleIndex self, ParticleIndex o) -> bool"""
        return _IMP_kernel.ParticleIndex___lt__(self, *args)

    def __gt__(self, *args):
        """__gt__(ParticleIndex self, ParticleIndex o) -> bool"""
        return _IMP_kernel.ParticleIndex___gt__(self, *args)

    def __ge__(self, *args):
        """__ge__(ParticleIndex self, ParticleIndex o) -> bool"""
        return _IMP_kernel.ParticleIndex___ge__(self, *args)

    def __le__(self, *args):
        """__le__(ParticleIndex self, ParticleIndex o) -> bool"""
        return _IMP_kernel.ParticleIndex___le__(self, *args)

    def show(self, *args):
        """
        show(ParticleIndex self, _ostream out=std::cout)
        show(ParticleIndex self)
        """
        return _IMP_kernel.ParticleIndex_show(self, *args)

    def __hash__(self):
        """__hash__(ParticleIndex self) -> std::size_t"""
        return _IMP_kernel.ParticleIndex___hash__(self)

    def __str__(self):
        """__str__(ParticleIndex self) -> std::string"""
        return _IMP_kernel.ParticleIndex___str__(self)

    def __repr__(self):
        """__repr__(ParticleIndex self) -> std::string"""
        return _IMP_kernel.ParticleIndex___repr__(self)

    __swig_destroy__ = _IMP_kernel.delete_ParticleIndex
    __del__ = lambda self : None;
ParticleIndex_swigregister = _IMP_kernel.ParticleIndex_swigregister
ParticleIndex_swigregister(ParticleIndex)

def ParticlePair(a, b):
  return (a,b)
def ParticleTriplet(a, b, c):
  return (a,b,c)
def ParticleQuad(a, b, c, d):
  return (a,b,c,d)


def get_particles(*args):
  """get_particles(Model * m, ParticleIndexes const & ps) -> ParticlesTemp"""
  return _IMP_kernel.get_particles(*args)

def get_indexes(*args):
  """
    get_indexes(ParticlesTemp const & ps) -> ParticleIndexes
    get_indexes(ParticlePairsTemp const & ps) -> ParticleIndexPairs
    """
  return _IMP_kernel.get_indexes(*args)
class FloatIndex(IMP.base._Value):
    """Proxy of C++ IMP::kernel::FloatIndex class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base._Value]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FloatIndex, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base._Value]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FloatIndex, name)
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::FloatIndex self, ParticleIndex i0=ParticleIndex(), FloatKey i1=FloatKey()) -> FloatIndex
        __init__(IMP::kernel::FloatIndex self, ParticleIndex i0=ParticleIndex()) -> FloatIndex
        __init__(IMP::kernel::FloatIndex self) -> FloatIndex
        """
        this = _IMP_kernel.new_FloatIndex(*args)
        try: self.this.append(this)
        except: self.this = this
    def __hash__(self):
        """__hash__(FloatIndex self) -> std::size_t"""
        return _IMP_kernel.FloatIndex___hash__(self)

    def show(self, *args):
        """
        show(FloatIndex self, _ostream out=std::cout)
        show(FloatIndex self)
        """
        return _IMP_kernel.FloatIndex_show(self, *args)

    def __eq__(self, *args):
        """__eq__(FloatIndex self, FloatIndex o) -> bool"""
        return _IMP_kernel.FloatIndex___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(FloatIndex self, FloatIndex o) -> bool"""
        return _IMP_kernel.FloatIndex___ne__(self, *args)

    def __lt__(self, *args):
        """__lt__(FloatIndex self, FloatIndex o) -> bool"""
        return _IMP_kernel.FloatIndex___lt__(self, *args)

    def __gt__(self, *args):
        """__gt__(FloatIndex self, FloatIndex o) -> bool"""
        return _IMP_kernel.FloatIndex___gt__(self, *args)

    def __ge__(self, *args):
        """__ge__(FloatIndex self, FloatIndex o) -> bool"""
        return _IMP_kernel.FloatIndex___ge__(self, *args)

    def __le__(self, *args):
        """__le__(FloatIndex self, FloatIndex o) -> bool"""
        return _IMP_kernel.FloatIndex___le__(self, *args)

    def get_particle(self):
        """get_particle(FloatIndex self) -> ParticleIndex const &"""
        return _IMP_kernel.FloatIndex_get_particle(self)

    def set_particle(self, *args):
        """set_particle(FloatIndex self, ParticleIndex const & v)"""
        return _IMP_kernel.FloatIndex_set_particle(self, *args)

    def get_key(self):
        """get_key(FloatIndex self) -> FloatKey const &"""
        return _IMP_kernel.FloatIndex_get_key(self)

    def set_key(self, *args):
        """set_key(FloatIndex self, FloatKey const & v)"""
        return _IMP_kernel.FloatIndex_set_key(self, *args)

    def __str__(self):
        """__str__(FloatIndex self) -> std::string"""
        return _IMP_kernel.FloatIndex___str__(self)

    def __repr__(self):
        """__repr__(FloatIndex self) -> std::string"""
        return _IMP_kernel.FloatIndex___repr__(self)

    __swig_destroy__ = _IMP_kernel.delete_FloatIndex
    __del__ = lambda self : None;
FloatIndex_swigregister = _IMP_kernel.FloatIndex_swigregister
FloatIndex_swigregister(FloatIndex)

class _ParticleIndexTag(_object):
    """Proxy of C++ IMP::kernel::ParticleIndexTag class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _ParticleIndexTag, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _ParticleIndexTag, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(IMP::kernel::ParticleIndexTag self) -> _ParticleIndexTag"""
        this = _IMP_kernel.new__ParticleIndexTag()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _IMP_kernel.delete__ParticleIndexTag
    __del__ = lambda self : None;
_ParticleIndexTag_swigregister = _IMP_kernel._ParticleIndexTag_swigregister
_ParticleIndexTag_swigregister(_ParticleIndexTag)

class ModelObject(IMP.base.Object):
    """Proxy of C++ IMP::kernel::ModelObject class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ModelObject, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ModelObject, name)
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::ModelObject self, Model m, std::string name) -> ModelObject
        __init__(IMP::kernel::ModelObject self, std::string name) -> ModelObject
        """
        if self.__class__ == ModelObject:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_ModelObject(_self, *args)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != ModelObject:
            import IMP.base
            IMP.base._director_objects.register(self)



    def set_model(self, *args):
        """set_model(ModelObject self, Model m)"""
        return _IMP_kernel.ModelObject_set_model(self, *args)

    def get_is_part_of_model(self):
        """get_is_part_of_model(ModelObject self) -> bool"""
        return _IMP_kernel.ModelObject_get_is_part_of_model(self)

    def get_model(self):
        """get_model(ModelObject self) -> Model"""
        return _IMP_kernel.ModelObject_get_model(self)

    def get_inputs(self):
        """get_inputs(ModelObject self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.ModelObject_get_inputs(self)

    def get_outputs(self):
        """get_outputs(ModelObject self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.ModelObject_get_outputs(self)

    def get_interactions(self):
        """get_interactions(ModelObject self) -> IMP::kernel::ModelObjectsTemps"""
        return _IMP_kernel.ModelObject_get_interactions(self)

    def update_dependencies(self):
        """update_dependencies(ModelObject self)"""
        return _IMP_kernel.ModelObject_update_dependencies(self)

    def do_get_inputs(self):
        """do_get_inputs(ModelObject self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.ModelObject_do_get_inputs(self)

    def do_get_outputs(self):
        """do_get_outputs(ModelObject self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.ModelObject_do_get_outputs(self)

    def do_get_interactions(self):
        """do_get_interactions(ModelObject self) -> IMP::kernel::ModelObjectsTemps"""
        return _IMP_kernel.ModelObject_do_get_interactions(self)

    __swig_destroy__ = _IMP_kernel.delete_ModelObject
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(ModelObject self) -> std::string"""
        return _IMP_kernel.ModelObject___str__(self)

    def __repr__(self):
        """__repr__(ModelObject self) -> std::string"""
        return _IMP_kernel.ModelObject___repr__(self)

    def get_from(o):
       return _object_cast_to_ModelObject(o)
    get_from = staticmethod(get_from)

    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::kernel" == "IMP":
          return VersionInfo("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_ModelObject(o)
    get_from = staticmethod(get_from)

    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_ModelObject(self)
        return weakref_proxy(self)
ModelObject_swigregister = _IMP_kernel.ModelObject_swigregister
ModelObject_swigregister(ModelObject)
cvar = _IMP_kernel.cvar
NO_MAX = cvar.NO_MAX
BAD_SCORE = cvar.BAD_SCORE


def get_input_particles(*args):
  """get_input_particles(IMP::kernel::ModelObjectsTemp const & mos) -> IMP::kernel::ParticlesTemp"""
  return _IMP_kernel.get_input_particles(*args)

def get_input_containers(*args):
  """get_input_containers(IMP::kernel::ModelObjectsTemp const & mos) -> IMP::kernel::ContainersTemp"""
  return _IMP_kernel.get_input_containers(*args)

def get_output_particles(*args):
  """get_output_particles(IMP::kernel::ModelObjectsTemp const & mos) -> IMP::kernel::ParticlesTemp"""
  return _IMP_kernel.get_output_particles(*args)

def get_output_containers(*args):
  """get_output_containers(IMP::kernel::ModelObjectsTemp const & mos) -> IMP::kernel::ContainersTemp"""
  return _IMP_kernel.get_output_containers(*args)
class DerivativeAccumulator(_object):
    """Proxy of C++ IMP::kernel::DerivativeAccumulator class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DerivativeAccumulator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DerivativeAccumulator, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::DerivativeAccumulator self, double weight=1.0) -> DerivativeAccumulator
        __init__(IMP::kernel::DerivativeAccumulator self) -> DerivativeAccumulator
        __init__(IMP::kernel::DerivativeAccumulator self, DerivativeAccumulator copy, double weight=1.0) -> DerivativeAccumulator
        __init__(IMP::kernel::DerivativeAccumulator self, DerivativeAccumulator copy) -> DerivativeAccumulator
        """
        this = _IMP_kernel.new_DerivativeAccumulator(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(self, *args):
        """__call__(DerivativeAccumulator self, double const value) -> double"""
        return _IMP_kernel.DerivativeAccumulator___call__(self, *args)

    def get_weight(self):
        """get_weight(DerivativeAccumulator self) -> double"""
        return _IMP_kernel.DerivativeAccumulator_get_weight(self)

    def show(self, *args):
        """
        show(DerivativeAccumulator self, _ostream out=std::cout)
        show(DerivativeAccumulator self)
        """
        return _IMP_kernel.DerivativeAccumulator_show(self, *args)

    __swig_destroy__ = _IMP_kernel.delete_DerivativeAccumulator
    __del__ = lambda self : None;
DerivativeAccumulator_swigregister = _IMP_kernel.DerivativeAccumulator_swigregister
DerivativeAccumulator_swigregister(DerivativeAccumulator)

class EvaluationState(_object):
    """Proxy of C++ IMP::kernel::EvaluationState class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, EvaluationState, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, EvaluationState, name)
    __swig_setmethods__["score"] = _IMP_kernel.EvaluationState_score_set
    __swig_getmethods__["score"] = _IMP_kernel.EvaluationState_score_get
    if _newclass:score = _swig_property(_IMP_kernel.EvaluationState_score_get, _IMP_kernel.EvaluationState_score_set)
    __swig_setmethods__["good"] = _IMP_kernel.EvaluationState_good_set
    __swig_getmethods__["good"] = _IMP_kernel.EvaluationState_good_get
    if _newclass:good = _swig_property(_IMP_kernel.EvaluationState_good_get, _IMP_kernel.EvaluationState_good_set)
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::EvaluationState self, double oscore, bool ogood) -> EvaluationState
        __init__(IMP::kernel::EvaluationState self) -> EvaluationState
        """
        this = _IMP_kernel.new_EvaluationState(*args)
        try: self.this.append(this)
        except: self.this = this
    def show(self, *args):
        """
        show(EvaluationState self, _ostream out=std::cout)
        show(EvaluationState self)
        """
        return _IMP_kernel.EvaluationState_show(self, *args)

    def __str__(self):
        """__str__(EvaluationState self) -> std::string"""
        return _IMP_kernel.EvaluationState___str__(self)

    def __repr__(self):
        """__repr__(EvaluationState self) -> std::string"""
        return _IMP_kernel.EvaluationState___repr__(self)

    __swig_destroy__ = _IMP_kernel.delete_EvaluationState
    __del__ = lambda self : None;
EvaluationState_swigregister = _IMP_kernel.EvaluationState_swigregister
EvaluationState_swigregister(EvaluationState)

class ScoreAccumulator(IMP.base._Value):
    """Proxy of C++ IMP::kernel::ScoreAccumulator class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base._Value]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScoreAccumulator, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base._Value]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ScoreAccumulator, name)
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::ScoreAccumulator self) -> ScoreAccumulator
        __init__(IMP::kernel::ScoreAccumulator self, ScoreAccumulator o, Restraint r) -> ScoreAccumulator
        __init__(IMP::kernel::ScoreAccumulator self, ScoreAccumulator o, double weight, double local_max) -> ScoreAccumulator
        """
        this = _IMP_kernel.new_ScoreAccumulator(*args)
        try: self.this.append(this)
        except: self.this = this
    def add_score(self, *args):
        """add_score(ScoreAccumulator self, double score)"""
        return _IMP_kernel.ScoreAccumulator_add_score(self, *args)

    def get_abort_evaluation(self):
        """get_abort_evaluation(ScoreAccumulator self) -> bool"""
        return _IMP_kernel.ScoreAccumulator_get_abort_evaluation(self)

    def get_is_evaluate_if_below(self):
        """get_is_evaluate_if_below(ScoreAccumulator self) -> bool"""
        return _IMP_kernel.ScoreAccumulator_get_is_evaluate_if_below(self)

    def get_is_evaluate_if_good(self):
        """get_is_evaluate_if_good(ScoreAccumulator self) -> bool"""
        return _IMP_kernel.ScoreAccumulator_get_is_evaluate_if_good(self)

    def get_maximum(self):
        """get_maximum(ScoreAccumulator self) -> double"""
        return _IMP_kernel.ScoreAccumulator_get_maximum(self)

    def get_derivative_accumulator(self):
        """get_derivative_accumulator(ScoreAccumulator self) -> DerivativeAccumulator"""
        return _IMP_kernel.ScoreAccumulator_get_derivative_accumulator(self)

    def show(self, *args):
        """
        show(ScoreAccumulator self, _ostream out=std::cout)
        show(ScoreAccumulator self)
        """
        return _IMP_kernel.ScoreAccumulator_show(self, *args)

    def __str__(self):
        """__str__(ScoreAccumulator self) -> std::string"""
        return _IMP_kernel.ScoreAccumulator___str__(self)

    def __repr__(self):
        """__repr__(ScoreAccumulator self) -> std::string"""
        return _IMP_kernel.ScoreAccumulator___repr__(self)

    __swig_destroy__ = _IMP_kernel.delete_ScoreAccumulator
    __del__ = lambda self : None;
ScoreAccumulator_swigregister = _IMP_kernel.ScoreAccumulator_swigregister
ScoreAccumulator_swigregister(ScoreAccumulator)

class ScoreState(ModelObject):
    """Proxy of C++ IMP::kernel::ScoreState class"""
    __swig_setmethods__ = {}
    for _s in [ModelObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScoreState, name, value)
    __swig_getmethods__ = {}
    for _s in [ModelObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ScoreState, name)
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::ScoreState self, std::string name="ScoreState %1%") -> ScoreState
        __init__(IMP::kernel::ScoreState self) -> ScoreState
        __init__(IMP::kernel::ScoreState self, Model m, std::string name="ScoreState %1%") -> ScoreState
        __init__(IMP::kernel::ScoreState self, Model m) -> ScoreState
        """
        if self.__class__ == ScoreState:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_ScoreState(_self, *args)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != ScoreState:
            import IMP.base
            IMP.base._director_objects.register(self)



    def before_evaluate(self):
        """before_evaluate(ScoreState self)"""
        return _IMP_kernel.ScoreState_before_evaluate(self)

    def after_evaluate(self, *args):
        """after_evaluate(ScoreState self, DerivativeAccumulator accpt)"""
        return _IMP_kernel.ScoreState_after_evaluate(self, *args)

    def do_before_evaluate(self):
        """do_before_evaluate(ScoreState self)"""
        return _IMP_kernel.ScoreState_do_before_evaluate(self)

    def do_after_evaluate(self, *args):
        """do_after_evaluate(ScoreState self, DerivativeAccumulator accpt)"""
        return _IMP_kernel.ScoreState_do_after_evaluate(self, *args)

    __swig_destroy__ = _IMP_kernel.delete_ScoreState
    __del__ = lambda self : None;
    def get_input_particles(self):
        """get_input_particles(ScoreState self) -> IMP::kernel::ParticlesTemp"""
        return _IMP_kernel.ScoreState_get_input_particles(self)

    def get_input_containers(self):
        """get_input_containers(ScoreState self) -> IMP::kernel::ContainersTemp"""
        return _IMP_kernel.ScoreState_get_input_containers(self)

    def get_output_particles(self):
        """get_output_particles(ScoreState self) -> IMP::kernel::ParticlesTemp"""
        return _IMP_kernel.ScoreState_get_output_particles(self)

    def get_output_containers(self):
        """get_output_containers(ScoreState self) -> IMP::kernel::ContainersTemp"""
        return _IMP_kernel.ScoreState_get_output_containers(self)

    def do_update_dependencies(self):
        """do_update_dependencies(ScoreState self)"""
        return _IMP_kernel.ScoreState_do_update_dependencies(self)

    def __str__(self):
        """__str__(ScoreState self) -> std::string"""
        return _IMP_kernel.ScoreState___str__(self)

    def __repr__(self):
        """__repr__(ScoreState self) -> std::string"""
        return _IMP_kernel.ScoreState___repr__(self)

    def get_from(o):
       return _object_cast_to_ScoreState(o)
    get_from = staticmethod(get_from)

    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::kernel" == "IMP":
          return VersionInfo("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_ScoreState(o)
    get_from = staticmethod(get_from)

    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_ScoreState(self)
        return weakref_proxy(self)
    def update_dependencies(self):
        """update_dependencies(ScoreState self)"""
        return _IMP_kernel.ScoreState_update_dependencies(self)

    def do_get_inputs(self):
        """do_get_inputs(ScoreState self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.ScoreState_do_get_inputs(self)

    def do_get_outputs(self):
        """do_get_outputs(ScoreState self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.ScoreState_do_get_outputs(self)

    def do_get_interactions(self):
        """do_get_interactions(ScoreState self) -> IMP::kernel::ModelObjectsTemps"""
        return _IMP_kernel.ScoreState_do_get_interactions(self)

ScoreState_swigregister = _IMP_kernel.ScoreState_swigregister
ScoreState_swigregister(ScoreState)


def get_update_order(*args):
  """get_update_order(IMP::kernel::ScoreStatesTemp input) -> IMP::kernel::ScoreStatesTemp"""
  return _IMP_kernel.get_update_order(*args)
class Constraint(ScoreState):
    """Proxy of C++ IMP::kernel::Constraint class"""
    __swig_setmethods__ = {}
    for _s in [ScoreState]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Constraint, name, value)
    __swig_getmethods__ = {}
    for _s in [ScoreState]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Constraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::Constraint self, std::string name="Constraint %1%") -> Constraint
        __init__(IMP::kernel::Constraint self) -> Constraint
        __init__(IMP::kernel::Constraint self, Model m, std::string name="Constraint %1%") -> Constraint
        __init__(IMP::kernel::Constraint self, Model m) -> Constraint
        """
        if self.__class__ == Constraint:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_Constraint(_self, *args)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != Constraint:
            import IMP.base
            IMP.base._director_objects.register(self)



    def do_update_attributes(self):
        """do_update_attributes(Constraint self)"""
        return _IMP_kernel.Constraint_do_update_attributes(self)

    def do_update_derivatives(self, *args):
        """do_update_derivatives(Constraint self, DerivativeAccumulator da)"""
        return _IMP_kernel.Constraint_do_update_derivatives(self, *args)

    def do_before_evaluate(self):
        """do_before_evaluate(Constraint self)"""
        return _IMP_kernel.Constraint_do_before_evaluate(self)

    def do_after_evaluate(self, *args):
        """do_after_evaluate(Constraint self, DerivativeAccumulator da)"""
        return _IMP_kernel.Constraint_do_after_evaluate(self, *args)

    __swig_destroy__ = _IMP_kernel.delete_Constraint
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(Constraint self) -> std::string"""
        return _IMP_kernel.Constraint___str__(self)

    def __repr__(self):
        """__repr__(Constraint self) -> std::string"""
        return _IMP_kernel.Constraint___repr__(self)

    def get_from(o):
       return _object_cast_to_Constraint(o)
    get_from = staticmethod(get_from)

    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::kernel" == "IMP":
          return VersionInfo("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_Constraint(o)
    get_from = staticmethod(get_from)

    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_Constraint(self)
        return weakref_proxy(self)
    def update_dependencies(self):
        """update_dependencies(Constraint self)"""
        return _IMP_kernel.Constraint_update_dependencies(self)

    def do_get_inputs(self):
        """do_get_inputs(Constraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.Constraint_do_get_inputs(self)

    def do_get_outputs(self):
        """do_get_outputs(Constraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.Constraint_do_get_outputs(self)

    def do_get_interactions(self):
        """do_get_interactions(Constraint self) -> IMP::kernel::ModelObjectsTemps"""
        return _IMP_kernel.Constraint_do_get_interactions(self)

    def do_update_dependencies(self):
        """do_update_dependencies(Constraint self)"""
        return _IMP_kernel.Constraint_do_update_dependencies(self)

Constraint_swigregister = _IMP_kernel.Constraint_swigregister
Constraint_swigregister(Constraint)

class Container(ScoreState):
    """Proxy of C++ IMP::kernel::Container class"""
    __swig_setmethods__ = {}
    for _s in [ScoreState]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Container, name, value)
    __swig_getmethods__ = {}
    for _s in [ScoreState]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Container, name)
    def set_is_changed(self, *args):
        """set_is_changed(Container self, bool tf)"""
        return _IMP_kernel.Container_set_is_changed(self, *args)

    def __init__(self, *args): 
        """
        __init__(IMP::kernel::Container self, Model m, std::string name="Container %1%") -> Container
        __init__(IMP::kernel::Container self, Model m) -> Container
        """
        if self.__class__ == Container:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_Container(_self, *args)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != Container:
            import IMP.base
            IMP.base._director_objects.register(self)



    def get_all_possible_indexes(self):
        """get_all_possible_indexes(Container self) -> IMP::kernel::ParticleIndexes"""
        return _IMP_kernel.Container_get_all_possible_indexes(self)

    def get_all_possible_particles(self):
        """get_all_possible_particles(Container self) -> IMP::kernel::ParticlesTemp"""
        return _IMP_kernel.Container_get_all_possible_particles(self)

    def get_is_changed(self):
        """get_is_changed(Container self) -> bool"""
        return _IMP_kernel.Container_get_is_changed(self)

    def do_get_outputs(self):
        """do_get_outputs(Container self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.Container_do_get_outputs(self)

    def do_after_evaluate(self, *args):
        """do_after_evaluate(Container self, DerivativeAccumulator accpt)"""
        return _IMP_kernel.Container_do_after_evaluate(self, *args)

    def get_is_decomposable(self):
        """get_is_decomposable(Container self) -> bool"""
        return _IMP_kernel.Container_get_is_decomposable(self)

    def validate_readable(self):
        """validate_readable(Container self)"""
        return _IMP_kernel.Container_validate_readable(self)

    def validate_writable(self):
        """validate_writable(Container self)"""
        return _IMP_kernel.Container_validate_writable(self)

    def set_is_readable(self, *args):
        """set_is_readable(Container self, bool tf)"""
        return _IMP_kernel.Container_set_is_readable(self, *args)

    def set_is_writable(self, *args):
        """set_is_writable(Container self, bool tf)"""
        return _IMP_kernel.Container_set_is_writable(self, *args)

    __swig_destroy__ = _IMP_kernel.delete_Container
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(Container self) -> std::string"""
        return _IMP_kernel.Container___str__(self)

    def __repr__(self):
        """__repr__(Container self) -> std::string"""
        return _IMP_kernel.Container___repr__(self)

    def get_from(o):
       return _object_cast_to_Container(o)
    get_from = staticmethod(get_from)

    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::kernel" == "IMP":
          return VersionInfo("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_Container(o)
    get_from = staticmethod(get_from)

    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_Container(self)
        return weakref_proxy(self)
    def update_dependencies(self):
        """update_dependencies(Container self)"""
        return _IMP_kernel.Container_update_dependencies(self)

    def do_get_inputs(self):
        """do_get_inputs(Container self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.Container_do_get_inputs(self)

    def do_get_interactions(self):
        """do_get_interactions(Container self) -> IMP::kernel::ModelObjectsTemps"""
        return _IMP_kernel.Container_do_get_interactions(self)

    def do_before_evaluate(self):
        """do_before_evaluate(Container self)"""
        return _IMP_kernel.Container_do_before_evaluate(self)

    def do_update_dependencies(self):
        """do_update_dependencies(Container self)"""
        return _IMP_kernel.Container_do_update_dependencies(self)

Container_swigregister = _IMP_kernel.Container_swigregister
Container_swigregister(Container)

class Restraint(ModelObject):
    """Proxy of C++ IMP::kernel::Restraint class"""
    __swig_setmethods__ = {}
    for _s in [ModelObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Restraint, name, value)
    __swig_getmethods__ = {}
    for _s in [ModelObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Restraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::Restraint self, Model m, std::string name) -> Restraint
        __init__(IMP::kernel::Restraint self, std::string name="Restraint %1%") -> Restraint
        __init__(IMP::kernel::Restraint self) -> Restraint
        """
        if self.__class__ == Restraint:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_Restraint(_self, *args)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != Restraint:
            import IMP.base
            IMP.base._director_objects.register(self)



    def get_score(self):
        """get_score(Restraint self) -> double"""
        return _IMP_kernel.Restraint_get_score(self)

    def evaluate(self, *args):
        """evaluate(Restraint self, bool calc_derivs) -> double"""
        return _IMP_kernel.Restraint_evaluate(self, *args)

    def evaluate_if_good(self, *args):
        """evaluate_if_good(Restraint self, bool calc_derivatives) -> double"""
        return _IMP_kernel.Restraint_evaluate_if_good(self, *args)

    def evaluate_if_below(self, *args):
        """evaluate_if_below(Restraint self, bool calc_derivatives, double max) -> double"""
        return _IMP_kernel.Restraint_evaluate_if_below(self, *args)

    def unprotected_evaluate(self, *args):
        """unprotected_evaluate(Restraint self, DerivativeAccumulator da) -> double"""
        return _IMP_kernel.Restraint_unprotected_evaluate(self, *args)

    def unprotected_evaluate_if_good(self, *args):
        """unprotected_evaluate_if_good(Restraint self, DerivativeAccumulator da, double max) -> double"""
        return _IMP_kernel.Restraint_unprotected_evaluate_if_good(self, *args)

    def unprotected_evaluate_if_below(self, *args):
        """unprotected_evaluate_if_below(Restraint self, DerivativeAccumulator da, double max) -> double"""
        return _IMP_kernel.Restraint_unprotected_evaluate_if_below(self, *args)

    def add_score_and_derivatives(self, *args):
        """add_score_and_derivatives(Restraint self, ScoreAccumulator sa)"""
        return _IMP_kernel.Restraint_add_score_and_derivatives(self, *args)

    def create_decomposition(self):
        """create_decomposition(Restraint self) -> Restraint"""
        return _IMP_kernel.Restraint_create_decomposition(self)

    def create_current_decomposition(self):
        """create_current_decomposition(Restraint self) -> Restraint"""
        return _IMP_kernel.Restraint_create_current_decomposition(self)

    def set_weight(self, *args):
        """set_weight(Restraint self, IMP::Float weight)"""
        return _IMP_kernel.Restraint_set_weight(self, *args)

    def get_weight(self):
        """get_weight(Restraint self) -> IMP::Float"""
        return _IMP_kernel.Restraint_get_weight(self)

    def get_maximum_score(self):
        """get_maximum_score(Restraint self) -> double"""
        return _IMP_kernel.Restraint_get_maximum_score(self)

    def set_maximum_score(self, *args):
        """set_maximum_score(Restraint self, double s)"""
        return _IMP_kernel.Restraint_set_maximum_score(self, *args)

    def create_scoring_function(self, *args):
        """
        create_scoring_function(Restraint self, double weight=1.0, double max=NO_MAX) -> ScoringFunction
        create_scoring_function(Restraint self, double weight=1.0) -> ScoringFunction
        create_scoring_function(Restraint self) -> ScoringFunction
        """
        return _IMP_kernel.Restraint_create_scoring_function(self, *args)

    def set_last_score(self, *args):
        """set_last_score(Restraint self, double s)"""
        return _IMP_kernel.Restraint_set_last_score(self, *args)

    def get_last_score(self):
        """get_last_score(Restraint self) -> double"""
        return _IMP_kernel.Restraint_get_last_score(self)

    def get_was_good(self):
        """get_was_good(Restraint self) -> bool"""
        return _IMP_kernel.Restraint_get_was_good(self)

    def get_input_particles(self):
        """get_input_particles(Restraint self) -> IMP::kernel::ParticlesTemp"""
        return _IMP_kernel.Restraint_get_input_particles(self)

    def get_input_containers(self):
        """get_input_containers(Restraint self) -> IMP::kernel::ContainersTemp"""
        return _IMP_kernel.Restraint_get_input_containers(self)

    __swig_destroy__ = _IMP_kernel.delete_Restraint
    __del__ = lambda self : None;
    def do_create_decomposition(self):
        """do_create_decomposition(Restraint self) -> IMP::kernel::Restraints"""
        return _IMP_kernel.Restraint_do_create_decomposition(self)

    def do_create_current_decomposition(self):
        """do_create_current_decomposition(Restraint self) -> IMP::kernel::Restraints"""
        return _IMP_kernel.Restraint_do_create_current_decomposition(self)

    def do_add_score_and_derivatives(self, *args):
        """do_add_score_and_derivatives(Restraint self, ScoreAccumulator sa)"""
        return _IMP_kernel.Restraint_do_add_score_and_derivatives(self, *args)

    def do_update_dependencies(self):
        """do_update_dependencies(Restraint self)"""
        return _IMP_kernel.Restraint_do_update_dependencies(self)

    def do_get_outputs(self):
        """do_get_outputs(Restraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.Restraint_do_get_outputs(self)

    def __str__(self):
        """__str__(Restraint self) -> std::string"""
        return _IMP_kernel.Restraint___str__(self)

    def __repr__(self):
        """__repr__(Restraint self) -> std::string"""
        return _IMP_kernel.Restraint___repr__(self)

    def get_from(o):
       return _object_cast_to_Restraint(o)
    get_from = staticmethod(get_from)

    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::kernel" == "IMP":
          return VersionInfo("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_Restraint(o)
    get_from = staticmethod(get_from)

    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_Restraint(self)
        return weakref_proxy(self)
    def update_dependencies(self):
        """update_dependencies(Restraint self)"""
        return _IMP_kernel.Restraint_update_dependencies(self)

    def do_get_inputs(self):
        """do_get_inputs(Restraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.Restraint_do_get_inputs(self)

    def do_get_interactions(self):
        """do_get_interactions(Restraint self) -> IMP::kernel::ModelObjectsTemps"""
        return _IMP_kernel.Restraint_do_get_interactions(self)

Restraint_swigregister = _IMP_kernel.Restraint_swigregister
Restraint_swigregister(Restraint)

class RestraintSet(Restraint):
    """Proxy of C++ IMP::kernel::RestraintSet class"""
    __swig_setmethods__ = {}
    for _s in [Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RestraintSet, name, value)
    __swig_getmethods__ = {}
    for _s in [Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RestraintSet, name)
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::RestraintSet self, Model m, double weight, std::string const & name="RestraintSet %1%") -> RestraintSet
        __init__(IMP::kernel::RestraintSet self, Model m, double weight) -> RestraintSet
        __init__(IMP::kernel::RestraintSet self, IMP::kernel::RestraintsTemp const & rs, double weight, std::string const & name="RestraintSet %1%") -> RestraintSet
        __init__(IMP::kernel::RestraintSet self, IMP::kernel::RestraintsTemp const & rs, double weight) -> RestraintSet
        __init__(IMP::kernel::RestraintSet self, double weight, std::string const & name="RestraintSet %1%") -> RestraintSet
        __init__(IMP::kernel::RestraintSet self, double weight) -> RestraintSet
        __init__(IMP::kernel::RestraintSet self, std::string const & name="RestraintSet %1%") -> RestraintSet
        __init__(IMP::kernel::RestraintSet self) -> RestraintSet
        __init__(IMP::kernel::RestraintSet self, IMP::kernel::Restraint::ModelInitTag arg2, std::string const & name="RestraintSet %1%") -> RestraintSet
        __init__(IMP::kernel::RestraintSet self, IMP::kernel::Restraint::ModelInitTag arg2) -> RestraintSet
        """
        this = _IMP_kernel.new_RestraintSet(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(RestraintSet self) -> VersionInfo"""
        return _IMP_kernel.RestraintSet_get_version_info(self)

    __swig_destroy__ = _IMP_kernel.delete_RestraintSet
    __del__ = lambda self : None;
    def remove_restraint(self, *args):
        """remove_restraint(RestraintSet self, Restraint d)"""
        return _IMP_kernel.RestraintSet_remove_restraint(self, *args)

    def remove_restraints(self, *args):
        """remove_restraints(RestraintSet self, IMP::kernel::Restraints const & d)"""
        return _IMP_kernel.RestraintSet_remove_restraints(self, *args)

    def set_restraints(self, *args):
        """set_restraints(RestraintSet self, IMP::kernel::Restraints const & ps)"""
        return _IMP_kernel.RestraintSet_set_restraints(self, *args)

    def set_restraints_order(self, *args):
        """set_restraints_order(RestraintSet self, IMP::kernel::Restraints const & objs)"""
        return _IMP_kernel.RestraintSet_set_restraints_order(self, *args)

    def add_restraint(self, *args):
        """add_restraint(RestraintSet self, Restraint obj) -> unsigned int"""
        return _IMP_kernel.RestraintSet_add_restraint(self, *args)

    def add_restraints(self, *args):
        """add_restraints(RestraintSet self, IMP::kernel::Restraints const & objs)"""
        return _IMP_kernel.RestraintSet_add_restraints(self, *args)

    def clear_restraints(self):
        """clear_restraints(RestraintSet self)"""
        return _IMP_kernel.RestraintSet_clear_restraints(self)

    def get_number_of_restraints(self):
        """get_number_of_restraints(RestraintSet self) -> unsigned int"""
        return _IMP_kernel.RestraintSet_get_number_of_restraints(self)

    def get_has_restraints(self):
        """get_has_restraints(RestraintSet self) -> bool"""
        return _IMP_kernel.RestraintSet_get_has_restraints(self)

    def get_restraint(self, *args):
        """get_restraint(RestraintSet self, unsigned int i) -> Restraint"""
        return _IMP_kernel.RestraintSet_get_restraint(self, *args)

    def get_restraints(self):
        """get_restraints(RestraintSet self) -> IMP::kernel::Restraints"""
        return _IMP_kernel.RestraintSet_get_restraints(self)

    def reserve_restraints(self, *args):
        """reserve_restraints(RestraintSet self, unsigned int sz)"""
        return _IMP_kernel.RestraintSet_reserve_restraints(self, *args)

    def get_non_sets_and_sets(self):
        """get_non_sets_and_sets(RestraintSet self) -> std::pair< IMP::kernel::RestraintsTemp,IMP::kernel::RestraintSetsTemp >"""
        return _IMP_kernel.RestraintSet_get_non_sets_and_sets(self)

    def do_get_inputs(self):
        """do_get_inputs(RestraintSet self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.RestraintSet_do_get_inputs(self)

    def create_scoring_function(self, *args):
        """
        create_scoring_function(RestraintSet self, double weight=1.0, double max=std::numeric_limits< double >::max()) -> ScoringFunction
        create_scoring_function(RestraintSet self, double weight=1.0) -> ScoringFunction
        create_scoring_function(RestraintSet self) -> ScoringFunction
        """
        return _IMP_kernel.RestraintSet_create_scoring_function(self, *args)

    def __str__(self):
        """__str__(RestraintSet self) -> std::string"""
        return _IMP_kernel.RestraintSet___str__(self)

    def __repr__(self):
        """__repr__(RestraintSet self) -> std::string"""
        return _IMP_kernel.RestraintSet___repr__(self)

    def get_from(o):
       return _object_cast_to_RestraintSet(o)
    get_from = staticmethod(get_from)

RestraintSet_swigregister = _IMP_kernel.RestraintSet_swigregister
RestraintSet_swigregister(RestraintSet)


def get_restraints(*args):
  """get_restraints(IMP::kernel::RestraintsTemp const & rs) -> IMP::kernel::RestraintsTemp"""
  return _IMP_kernel.get_restraints(*args)
def _check_particle(p, a):
   if (not p.get_is_active()):
      raise ValueError("Inactive Particle")
   if (type(a)() == a):
      raise IndexError("Cannot use default Index")
   if (not p.has_attribute(a)):
      raise IndexError("Particle does not have attribute")

class Particle(ModelObject):
    """Proxy of C++ IMP::kernel::Particle class"""
    __swig_setmethods__ = {}
    for _s in [ModelObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Particle, name, value)
    __swig_getmethods__ = {}
    for _s in [ModelObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Particle, name)
    def get_version_info(self):
        """get_version_info(Particle self) -> VersionInfo"""
        return _IMP_kernel.Particle_get_version_info(self)

    def do_show(self, *args):
        """do_show(Particle self, _ostream out)"""
        return _IMP_kernel.Particle_do_show(self, *args)

    __swig_destroy__ = _IMP_kernel.delete_Particle
    __del__ = lambda self : None;
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::Particle self, Model m, std::string name) -> Particle
        __init__(IMP::kernel::Particle self, Model m) -> Particle
        """
        this = _IMP_kernel.new_Particle(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_float_keys(self):
        """get_float_keys(Particle self) -> IMP::kernel::FloatKeys"""
        return _IMP_kernel.Particle_get_float_keys(self)

    def get_int_keys(self):
        """get_int_keys(Particle self) -> IMP::kernel::IntKeys"""
        return _IMP_kernel.Particle_get_int_keys(self)

    def get_string_keys(self):
        """get_string_keys(Particle self) -> IMP::kernel::StringKeys"""
        return _IMP_kernel.Particle_get_string_keys(self)

    def get_object_keys(self):
        """get_object_keys(Particle self) -> IMP::kernel::ObjectKeys"""
        return _IMP_kernel.Particle_get_object_keys(self)

    def add_cache_attribute(self, *args):
        """
        add_cache_attribute(Particle self, FloatKey name, IMP::Float value)
        add_cache_attribute(Particle self, IntKey name, IMP::Int value)
        add_cache_attribute(Particle self, StringKey name, IMP::String value)
        add_cache_attribute(Particle self, ObjectKey name, Object * value)
        add_cache_attribute(Particle self, IMP::kernel::WeakObjectKey name, Object * value)
        """
        return _IMP_kernel.Particle_add_cache_attribute(self, *args)

    def get_weak_object_keys(self):
        """get_weak_object_keys(Particle self) -> IMP::kernel::WeakObjectKeys"""
        return _IMP_kernel.Particle_get_weak_object_keys(self)

    def add_to_derivative(self, *args):
        """add_to_derivative(Particle self, FloatKey key, IMP::Float value, DerivativeAccumulator da)"""
        return _IMP_kernel.Particle_add_to_derivative(self, *args)

    def set_is_optimized(self, *args):
        """set_is_optimized(Particle self, FloatKey k, bool tf)"""
        return _IMP_kernel.Particle_set_is_optimized(self, *args)

    def get_is_optimized(self, *args):
        """get_is_optimized(Particle self, FloatKey k) -> bool"""
        return _IMP_kernel.Particle_get_is_optimized(self, *args)

    def get_derivative(self, *args):
        """get_derivative(Particle self, FloatKey name) -> IMP::Float"""
        return _IMP_kernel.Particle_get_derivative(self, *args)

    def add_attribute(self, *args):
        """
        add_attribute(Particle self, FloatKey name, IMP::Float initial_value)
        add_attribute(Particle self, IntKey name, IMP::Int initial_value)
        add_attribute(Particle self, StringKey name, IMP::String initial_value)
        add_attribute(Particle self, ObjectKey name, Object * initial_value)
        add_attribute(Particle self, IMP::kernel::WeakObjectKey name, Object * initial_value)
        add_attribute(Particle self, FloatKey name, IMP::Float const initial_value, bool optimized)
        add_attribute(Particle self, ParticleIndexKey k, Particle v)
        """
        return _IMP_kernel.Particle_add_attribute(self, *args)

    def has_attribute(self, *args):
        """
        has_attribute(Particle self, FloatKey name) -> bool
        has_attribute(Particle self, IntKey name) -> bool
        has_attribute(Particle self, StringKey name) -> bool
        has_attribute(Particle self, ObjectKey name) -> bool
        has_attribute(Particle self, IMP::kernel::WeakObjectKey name) -> bool
        has_attribute(Particle self, ParticleIndexKey k) -> bool
        """
        return _IMP_kernel.Particle_has_attribute(self, *args)

    def set_value(self, *args):
        """
        set_value(Particle self, FloatKey name, IMP::Float value)
        set_value(Particle self, IntKey name, IMP::Int value)
        set_value(Particle self, StringKey name, IMP::String value)
        set_value(Particle self, ObjectKey name, Object * value)
        set_value(Particle self, IMP::kernel::WeakObjectKey name, Object * value)
        set_value(Particle self, ParticleIndexKey k, Particle v)
        """
        return _IMP_kernel.Particle_set_value(self, *args)

    def get_value(self, *args):
        """
        get_value(Particle self, FloatKey name) -> IMP::Float
        get_value(Particle self, IntKey name) -> IMP::Int
        get_value(Particle self, StringKey name) -> IMP::String
        get_value(Particle self, ObjectKey name) -> Object
        get_value(Particle self, IMP::kernel::WeakObjectKey name) -> Object
        get_value(Particle self, ParticleIndexKey k) -> Particle
        """
        return _IMP_kernel.Particle_get_value(self, *args)

    def remove_attribute(self, *args):
        """
        remove_attribute(Particle self, FloatKey name)
        remove_attribute(Particle self, IntKey name)
        remove_attribute(Particle self, StringKey name)
        remove_attribute(Particle self, ObjectKey name)
        remove_attribute(Particle self, IMP::kernel::WeakObjectKey name)
        remove_attribute(Particle self, ParticleIndexKey k)
        """
        return _IMP_kernel.Particle_remove_attribute(self, *args)

    def get_particle_keys(self):
        """get_particle_keys(Particle self) -> IMP::kernel::ParticleIndexKeys"""
        return _IMP_kernel.Particle_get_particle_keys(self)

    def get_is_active(self):
        """get_is_active(Particle self) -> bool"""
        return _IMP_kernel.Particle_get_is_active(self)

    def get_index(self):
        """get_index(Particle self) -> IMP::kernel::ParticleIndex"""
        return _IMP_kernel.Particle_get_index(self)

    def __eq__(self, *args):
        """
        __eq__(Particle self, Particle o) -> bool
        __eq__(Particle self, Decorator d) -> bool
        """
        return _IMP_kernel.Particle___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(Particle self, Particle o) -> bool
        __ne__(Particle self, Decorator d) -> bool
        """
        return _IMP_kernel.Particle___ne__(self, *args)

    def __le__(self, *args):
        """
        __le__(Particle self, Particle o) -> bool
        __le__(Particle self, Decorator d) -> bool
        """
        return _IMP_kernel.Particle___le__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(Particle self, Particle o) -> bool
        __lt__(Particle self, Decorator d) -> bool
        """
        return _IMP_kernel.Particle___lt__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(Particle self, Particle o) -> bool
        __ge__(Particle self, Decorator d) -> bool
        """
        return _IMP_kernel.Particle___ge__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(Particle self, Particle o) -> bool
        __gt__(Particle self, Decorator d) -> bool
        """
        return _IMP_kernel.Particle___gt__(self, *args)

    def __str__(self):
        """__str__(Particle self) -> std::string"""
        return _IMP_kernel.Particle___str__(self)

    def __repr__(self):
        """__repr__(Particle self) -> std::string"""
        return _IMP_kernel.Particle___repr__(self)

    def get_from(o):
       return _object_cast_to_Particle(o)
    get_from = staticmethod(get_from)

Particle_swigregister = _IMP_kernel.Particle_swigregister
Particle_swigregister(Particle)

class _DependencyGraphVertexIndex(_object):
    """Proxy of C++ IMP::kernel::DependencyGraphVertexIndex class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _DependencyGraphVertexIndex, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _DependencyGraphVertexIndex, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(IMP::kernel::DependencyGraphVertexIndex self) -> _DependencyGraphVertexIndex"""
        this = _IMP_kernel.new__DependencyGraphVertexIndex()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _IMP_kernel.delete__DependencyGraphVertexIndex
    __del__ = lambda self : None;
_DependencyGraphVertexIndex_swigregister = _IMP_kernel._DependencyGraphVertexIndex_swigregister
_DependencyGraphVertexIndex_swigregister(_DependencyGraphVertexIndex)


def get_vertex_index(*args):
  """get_vertex_index(IMP::kernel::DependencyGraph const & g) -> _DependencyGraphVertexIndex"""
  return _IMP_kernel.get_vertex_index(*args)

def get_dependency_graph(*args):
  """get_dependency_graph(Model m) -> IMP::kernel::DependencyGraph"""
  return _IMP_kernel.get_dependency_graph(*args)

def get_pruned_dependency_graph(*args):
  """get_pruned_dependency_graph(Model m) -> IMP::kernel::DependencyGraph"""
  return _IMP_kernel.get_pruned_dependency_graph(*args)

def get_required_particles(*args):
  """
    get_required_particles(ModelObject p, IMP::kernel::ModelObjectsTemp const & all, IMP::kernel::DependencyGraph const & dg, 
        _DependencyGraphVertexIndex index) -> IMP::kernel::ParticlesTemp
    """
  return _IMP_kernel.get_required_particles(*args)

def get_dependent_particles(*args):
  """
    get_dependent_particles(ModelObject p, IMP::kernel::ModelObjectsTemp const & all, IMP::kernel::DependencyGraph const & dg, 
        _DependencyGraphVertexIndex index) -> IMP::kernel::ParticlesTemp
    """
  return _IMP_kernel.get_dependent_particles(*args)

def get_dependent_restraints(*args):
  """
    get_dependent_restraints(ModelObject p, IMP::kernel::ModelObjectsTemp const & all, IMP::kernel::DependencyGraph const & dg, 
        _DependencyGraphVertexIndex index) -> IMP::kernel::RestraintsTemp
    """
  return _IMP_kernel.get_dependent_restraints(*args)

def get_dependent_score_states(*args):
  """
    get_dependent_score_states(ModelObject p, IMP::kernel::ModelObjectsTemp const & all, IMP::kernel::DependencyGraph const & dg, 
        _DependencyGraphVertexIndex index) -> IMP::kernel::ScoreStatesTemp
    """
  return _IMP_kernel.get_dependent_score_states(*args)

def get_required_score_states(*args):
  """
    get_required_score_states(ModelObject p, IMP::kernel::ModelObjectsTemp const & all, IMP::kernel::DependencyGraph const & dg, 
        _DependencyGraphVertexIndex index) -> IMP::kernel::ScoreStatesTemp
    get_required_score_states(IMP::kernel::ModelObjectsTemp const & irs, IMP::kernel::DependencyGraph const & dg, 
        _DependencyGraphVertexIndex index) -> IMP::kernel::ScoreStatesTemp
    """
  return _IMP_kernel.get_required_score_states(*args)

def set_score_state_update_order(*args):
  """set_score_state_update_order(IMP::kernel::DependencyGraph const & dg, _DependencyGraphVertexIndex index)"""
  return _IMP_kernel.set_score_state_update_order(*args)
class ScoringFunction(ModelObject):
    """Proxy of C++ IMP::kernel::ScoringFunction class"""
    __swig_setmethods__ = {}
    for _s in [ModelObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScoringFunction, name, value)
    __swig_getmethods__ = {}
    for _s in [ModelObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ScoringFunction, name)
    def do_add_score_and_derivatives(self, *args):
        """do_add_score_and_derivatives(ScoringFunction self, ScoreAccumulator sa, IMP::kernel::ScoreStatesTemp const & ss)"""
        return _IMP_kernel.ScoringFunction_do_add_score_and_derivatives(self, *args)

    def get_required_score_states(self):
        """get_required_score_states(ScoringFunction self) -> IMP::kernel::ScoreStatesTemp"""
        return _IMP_kernel.ScoringFunction_get_required_score_states(self)

    def get_score_accumulator_if_below(self, *args):
        """get_score_accumulator_if_below(ScoringFunction self, bool deriv, double max) -> ScoreAccumulator"""
        return _IMP_kernel.ScoringFunction_get_score_accumulator_if_below(self, *args)

    def get_score_accumulator_if_good(self, *args):
        """get_score_accumulator_if_good(ScoringFunction self, bool deriv) -> ScoreAccumulator"""
        return _IMP_kernel.ScoringFunction_get_score_accumulator_if_good(self, *args)

    def get_score_accumulator(self, *args):
        """get_score_accumulator(ScoringFunction self, bool deriv) -> ScoreAccumulator"""
        return _IMP_kernel.ScoringFunction_get_score_accumulator(self, *args)

    def __init__(self, *args): 
        """__init__(IMP::kernel::ScoringFunction self, Model m, std::string name) -> ScoringFunction"""
        if self.__class__ == ScoringFunction:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_ScoringFunction(_self, *args)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != ScoringFunction:
            import IMP.base
            IMP.base._director_objects.register(self)



    def do_get_inputs(self):
        """do_get_inputs(ScoringFunction self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.ScoringFunction_do_get_inputs(self)

    def do_get_outputs(self):
        """do_get_outputs(ScoringFunction self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.ScoringFunction_do_get_outputs(self)

    def do_update_dependencies(self):
        """do_update_dependencies(ScoringFunction self)"""
        return _IMP_kernel.ScoringFunction_do_update_dependencies(self)

    def evaluate_if_good(self, *args):
        """evaluate_if_good(ScoringFunction self, bool derivatives) -> double"""
        return _IMP_kernel.ScoringFunction_evaluate_if_good(self, *args)

    def evaluate(self, *args):
        """evaluate(ScoringFunction self, bool derivatives) -> double"""
        return _IMP_kernel.ScoringFunction_evaluate(self, *args)

    def evaluate_if_below(self, *args):
        """evaluate_if_below(ScoringFunction self, bool derivatives, double max) -> double"""
        return _IMP_kernel.ScoringFunction_evaluate_if_below(self, *args)

    def get_had_good_score(self):
        """get_had_good_score(ScoringFunction self) -> bool"""
        return _IMP_kernel.ScoringFunction_get_had_good_score(self)

    def get_last_score(self):
        """get_last_score(ScoringFunction self) -> double"""
        return _IMP_kernel.ScoringFunction_get_last_score(self)

    def create_restraints(self):
        """create_restraints(ScoringFunction self) -> IMP::kernel::Restraints"""
        return _IMP_kernel.ScoringFunction_create_restraints(self)

    def get_score_states(self):
        """get_score_states(ScoringFunction self) -> IMP::kernel::ScoreStatesTemp const &"""
        return _IMP_kernel.ScoringFunction_get_score_states(self)

    def clear_caches(self):
        """clear_caches(ScoringFunction self)"""
        return _IMP_kernel.ScoringFunction_clear_caches(self)

    def __str__(self):
        """__str__(ScoringFunction self) -> std::string"""
        return _IMP_kernel.ScoringFunction___str__(self)

    def __repr__(self):
        """__repr__(ScoringFunction self) -> std::string"""
        return _IMP_kernel.ScoringFunction___repr__(self)

    def get_from(o):
       return _object_cast_to_ScoringFunction(o)
    get_from = staticmethod(get_from)

    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::kernel" == "IMP":
          return VersionInfo("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_ScoringFunction(o)
    get_from = staticmethod(get_from)

    __swig_destroy__ = _IMP_kernel.delete_ScoringFunction
    __del__ = lambda self : None;
    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_ScoringFunction(self)
        return weakref_proxy(self)
    def update_dependencies(self):
        """update_dependencies(ScoringFunction self)"""
        return _IMP_kernel.ScoringFunction_update_dependencies(self)

    def do_get_interactions(self):
        """do_get_interactions(ScoringFunction self) -> IMP::kernel::ModelObjectsTemps"""
        return _IMP_kernel.ScoringFunction_do_get_interactions(self)

ScoringFunction_swigregister = _IMP_kernel.ScoringFunction_swigregister
ScoringFunction_swigregister(ScoringFunction)


def create_decomposition(*args):
  """create_decomposition(ScoringFunction sf) -> IMP::kernel::ScoringFunctions"""
  return _IMP_kernel.create_decomposition(*args)
class _ScoringFunctionAdaptor(IMP.base._InputAdaptor):
    """Proxy of C++ IMP::kernel::ScoringFunctionAdaptor class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base._InputAdaptor]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _ScoringFunctionAdaptor, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base._InputAdaptor]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _ScoringFunctionAdaptor, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::ScoringFunctionAdaptor self) -> _ScoringFunctionAdaptor
        __init__(IMP::kernel::ScoringFunctionAdaptor self, ScoringFunction sf) -> _ScoringFunctionAdaptor
        __init__(IMP::kernel::ScoringFunctionAdaptor self, IMP::kernel::RestraintsTemp const & sf) -> _ScoringFunctionAdaptor
        __init__(IMP::kernel::ScoringFunctionAdaptor self, IMP::kernel::Restraints const & sf) -> _ScoringFunctionAdaptor
        __init__(IMP::kernel::ScoringFunctionAdaptor self, Model sf) -> _ScoringFunctionAdaptor
        __init__(IMP::kernel::ScoringFunctionAdaptor self, Restraint sf) -> _ScoringFunctionAdaptor
        """
        this = _IMP_kernel.new__ScoringFunctionAdaptor(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _IMP_kernel.delete__ScoringFunctionAdaptor
    __del__ = lambda self : None;
_ScoringFunctionAdaptor_swigregister = _IMP_kernel._ScoringFunctionAdaptor_swigregister
_ScoringFunctionAdaptor_swigregister(_ScoringFunctionAdaptor)


def show_restraint_hierarchy(*args):
  """
    show_restraint_hierarchy(_ScoringFunctionAdaptor rs, _ostream out=std::cout)
    show_restraint_hierarchy(_ScoringFunctionAdaptor rs)
    """
  return _IMP_kernel.show_restraint_hierarchy(*args)
class Undecorator(IMP.base.Object):
    """Proxy of C++ IMP::kernel::Undecorator class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Undecorator, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Undecorator, name)
    def __init__(self, *args): 
        """__init__(IMP::kernel::Undecorator self, Model m, std::string name) -> Undecorator"""
        if self.__class__ == Undecorator:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_Undecorator(_self, *args)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != Undecorator:
            import IMP.base
            IMP.base._director_objects.register(self)



    def teardown(self, *args):
        """teardown(Undecorator self, IMP::kernel::ParticleIndex pi)"""
        return _IMP_kernel.Undecorator_teardown(self, *args)

    def __str__(self):
        """__str__(Undecorator self) -> std::string"""
        return _IMP_kernel.Undecorator___str__(self)

    def __repr__(self):
        """__repr__(Undecorator self) -> std::string"""
        return _IMP_kernel.Undecorator___repr__(self)

    def get_from(o):
       return _object_cast_to_Undecorator(o)
    get_from = staticmethod(get_from)

    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::kernel" == "IMP":
          return VersionInfo("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_Undecorator(o)
    get_from = staticmethod(get_from)

    __swig_destroy__ = _IMP_kernel.delete_Undecorator
    __del__ = lambda self : None;
    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_Undecorator(self)
        return weakref_proxy(self)
Undecorator_swigregister = _IMP_kernel.Undecorator_swigregister
Undecorator_swigregister(Undecorator)

class RestraintStatistics(IMP.base._Value):
    """Proxy of C++ IMP::kernel::RestraintStatistics class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base._Value]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RestraintStatistics, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base._Value]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RestraintStatistics, name)
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::RestraintStatistics self, double i0=double(), double i1=double(), double i2=double(), double i3=double(), double i4=double()) -> RestraintStatistics
        __init__(IMP::kernel::RestraintStatistics self, double i0=double(), double i1=double(), double i2=double(), double i3=double()) -> RestraintStatistics
        __init__(IMP::kernel::RestraintStatistics self, double i0=double(), double i1=double(), double i2=double()) -> RestraintStatistics
        __init__(IMP::kernel::RestraintStatistics self, double i0=double(), double i1=double()) -> RestraintStatistics
        __init__(IMP::kernel::RestraintStatistics self, double i0=double()) -> RestraintStatistics
        __init__(IMP::kernel::RestraintStatistics self) -> RestraintStatistics
        """
        this = _IMP_kernel.new_RestraintStatistics(*args)
        try: self.this.append(this)
        except: self.this = this
    def __hash__(self):
        """__hash__(RestraintStatistics self) -> std::size_t"""
        return _IMP_kernel.RestraintStatistics___hash__(self)

    def __eq__(self, *args):
        """__eq__(RestraintStatistics self, RestraintStatistics o) -> bool"""
        return _IMP_kernel.RestraintStatistics___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(RestraintStatistics self, RestraintStatistics o) -> bool"""
        return _IMP_kernel.RestraintStatistics___ne__(self, *args)

    def __lt__(self, *args):
        """__lt__(RestraintStatistics self, RestraintStatistics o) -> bool"""
        return _IMP_kernel.RestraintStatistics___lt__(self, *args)

    def __gt__(self, *args):
        """__gt__(RestraintStatistics self, RestraintStatistics o) -> bool"""
        return _IMP_kernel.RestraintStatistics___gt__(self, *args)

    def __ge__(self, *args):
        """__ge__(RestraintStatistics self, RestraintStatistics o) -> bool"""
        return _IMP_kernel.RestraintStatistics___ge__(self, *args)

    def __le__(self, *args):
        """__le__(RestraintStatistics self, RestraintStatistics o) -> bool"""
        return _IMP_kernel.RestraintStatistics___le__(self, *args)

    def show(self, *args):
        """
        show(RestraintStatistics self, _ostream out=std::cout)
        show(RestraintStatistics self)
        """
        return _IMP_kernel.RestraintStatistics_show(self, *args)

    def get_minimum_score(self):
        """get_minimum_score(RestraintStatistics self) -> double const &"""
        return _IMP_kernel.RestraintStatistics_get_minimum_score(self)

    def set_minimum_score(self, *args):
        """set_minimum_score(RestraintStatistics self, double const & v)"""
        return _IMP_kernel.RestraintStatistics_set_minimum_score(self, *args)

    def get_maximum_score(self):
        """get_maximum_score(RestraintStatistics self) -> double const &"""
        return _IMP_kernel.RestraintStatistics_get_maximum_score(self)

    def set_maximum_score(self, *args):
        """set_maximum_score(RestraintStatistics self, double const & v)"""
        return _IMP_kernel.RestraintStatistics_set_maximum_score(self, *args)

    def get_average_score(self):
        """get_average_score(RestraintStatistics self) -> double const &"""
        return _IMP_kernel.RestraintStatistics_get_average_score(self)

    def set_average_score(self, *args):
        """set_average_score(RestraintStatistics self, double const & v)"""
        return _IMP_kernel.RestraintStatistics_set_average_score(self, *args)

    def get_last_score(self):
        """get_last_score(RestraintStatistics self) -> double const &"""
        return _IMP_kernel.RestraintStatistics_get_last_score(self)

    def set_last_score(self, *args):
        """set_last_score(RestraintStatistics self, double const & v)"""
        return _IMP_kernel.RestraintStatistics_set_last_score(self, *args)

    def get_average_time(self):
        """get_average_time(RestraintStatistics self) -> double const &"""
        return _IMP_kernel.RestraintStatistics_get_average_time(self)

    def set_average_time(self, *args):
        """set_average_time(RestraintStatistics self, double const & v)"""
        return _IMP_kernel.RestraintStatistics_set_average_time(self, *args)

    def __str__(self):
        """__str__(RestraintStatistics self) -> std::string"""
        return _IMP_kernel.RestraintStatistics___str__(self)

    def __repr__(self):
        """__repr__(RestraintStatistics self) -> std::string"""
        return _IMP_kernel.RestraintStatistics___repr__(self)

    __swig_destroy__ = _IMP_kernel.delete_RestraintStatistics
    __del__ = lambda self : None;
RestraintStatistics_swigregister = _IMP_kernel.RestraintStatistics_swigregister
RestraintStatistics_swigregister(RestraintStatistics)

class Model(RestraintSet):
    """Proxy of C++ IMP::kernel::Model class"""
    __swig_setmethods__ = {}
    for _s in [RestraintSet]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Model, name, value)
    __swig_getmethods__ = {}
    for _s in [RestraintSet]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Model, name)
    def clear_particle_caches(self, *args):
        """clear_particle_caches(Model self, IMP::kernel::ParticleIndex pi)"""
        return _IMP_kernel.Model_clear_particle_caches(self, *args)

    def __init__(self, name="Model %1%"): 
        """
        __init__(IMP::kernel::Model self, std::string name="Model %1%") -> Model
        __init__(IMP::kernel::Model self) -> Model
        """
        this = _IMP_kernel.new_Model(name)
        try: self.this.append(this)
        except: self.this = this
    def add_particle(self, *args):
        """add_particle(Model self, std::string name) -> IMP::kernel::ParticleIndex"""
        return _IMP_kernel.Model_add_particle(self, *args)

    def get_dependency_graph(self):
        """get_dependency_graph(Model self) -> IMP::kernel::DependencyGraph const &"""
        return _IMP_kernel.Model_get_dependency_graph(self)

    def get_dependency_graph_vertex_index(self):
        """get_dependency_graph_vertex_index(Model self) -> _DependencyGraphVertexIndex"""
        return _IMP_kernel.Model_get_dependency_graph_vertex_index(self)

    def get_required_score_states(self, *args):
        """get_required_score_states(Model self, ModelObject o) -> IMP::kernel::ScoreStatesTemp const &"""
        return _IMP_kernel.Model_get_required_score_states(self, *args)

    def add_undecorator(self, *args):
        """add_undecorator(Model self, IMP::kernel::ParticleIndex pi, Undecorator d)"""
        return _IMP_kernel.Model_add_undecorator(self, *args)

    def remove_score_state(self, *args):
        """remove_score_state(Model self, ScoreState d)"""
        return _IMP_kernel.Model_remove_score_state(self, *args)

    def remove_score_states(self, *args):
        """remove_score_states(Model self, IMP::kernel::ScoreStates const & d)"""
        return _IMP_kernel.Model_remove_score_states(self, *args)

    def set_score_states(self, *args):
        """set_score_states(Model self, IMP::kernel::ScoreStates const & ps)"""
        return _IMP_kernel.Model_set_score_states(self, *args)

    def set_score_states_order(self, *args):
        """set_score_states_order(Model self, IMP::kernel::ScoreStates const & objs)"""
        return _IMP_kernel.Model_set_score_states_order(self, *args)

    def add_score_state(self, *args):
        """add_score_state(Model self, ScoreState obj) -> unsigned int"""
        return _IMP_kernel.Model_add_score_state(self, *args)

    def add_score_states(self, *args):
        """add_score_states(Model self, IMP::kernel::ScoreStates const & objs)"""
        return _IMP_kernel.Model_add_score_states(self, *args)

    def clear_score_states(self):
        """clear_score_states(Model self)"""
        return _IMP_kernel.Model_clear_score_states(self)

    def get_number_of_score_states(self):
        """get_number_of_score_states(Model self) -> unsigned int"""
        return _IMP_kernel.Model_get_number_of_score_states(self)

    def get_has_score_states(self):
        """get_has_score_states(Model self) -> bool"""
        return _IMP_kernel.Model_get_has_score_states(self)

    def get_score_state(self, *args):
        """get_score_state(Model self, unsigned int i) -> ScoreState"""
        return _IMP_kernel.Model_get_score_state(self, *args)

    def get_score_states(self):
        """get_score_states(Model self) -> IMP::kernel::ScoreStates"""
        return _IMP_kernel.Model_get_score_states(self)

    def reserve_score_states(self, *args):
        """reserve_score_states(Model self, unsigned int sz)"""
        return _IMP_kernel.Model_reserve_score_states(self, *args)

    def get_optimized_particles(self):
        """get_optimized_particles(Model self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.Model_get_optimized_particles(self)

    def get_root_restraint_set(self):
        """get_root_restraint_set(Model self) -> RestraintSet"""
        return _IMP_kernel.Model_get_root_restraint_set(self)

    def get_has_dependencies(self):
        """get_has_dependencies(Model self) -> bool"""
        return _IMP_kernel.Model_get_has_dependencies(self)

    def set_maximum_score(self, *args):
        """
        set_maximum_score(Model self, Restraint r, double s)
        set_maximum_score(Model self, double s)
        """
        return _IMP_kernel.Model_set_maximum_score(self, *args)

    def get_maximum_score(self, *args):
        """
        get_maximum_score(Model self, Restraint r) -> double
        get_maximum_score(Model self) -> double
        """
        return _IMP_kernel.Model_get_maximum_score(self, *args)

    def evaluate(self, *args):
        """
        evaluate(Model self, bool tf, bool warn=True) -> double
        evaluate(Model self, bool tf) -> double
        """
        return _IMP_kernel.Model_evaluate(self, *args)

    def create_model_scoring_function(self):
        """create_model_scoring_function(Model self) -> ScoringFunction"""
        return _IMP_kernel.Model_create_model_scoring_function(self)

    def update(self):
        """update(Model self)"""
        return _IMP_kernel.Model_update(self)

    __swig_destroy__ = _IMP_kernel.delete_Model
    def __del__(self):
        """__del__(IMP::kernel::Model self)"""
        import IMP.base
        IMP.base._director_objects.cleanup()


        pass

    def create_scoring_function(self, *args):
        """
        create_scoring_function(Model self, double weight=1.0, double max=NO_MAX) -> ScoringFunction
        create_scoring_function(Model self, double weight=1.0) -> ScoringFunction
        create_scoring_function(Model self) -> ScoringFunction
        """
        return _IMP_kernel.Model_create_scoring_function(self, *args)

    def remove_particle(self, *args):
        """
        remove_particle(Model self, Particle p)
        remove_particle(Model self, IMP::kernel::ParticleIndex pi)
        """
        return _IMP_kernel.Model_remove_particle(self, *args)

    def clear_all_statistics(self):
        """clear_all_statistics(Model self)"""
        return _IMP_kernel.Model_clear_all_statistics(self)

    def set_gather_statistics(self, *args):
        """set_gather_statistics(Model self, bool tf)"""
        return _IMP_kernel.Model_set_gather_statistics(self, *args)

    def get_gather_statistics(self):
        """get_gather_statistics(Model self) -> bool"""
        return _IMP_kernel.Model_get_gather_statistics(self)

    def show_all_statistics(self, *args):
        """
        show_all_statistics(Model self, _ostream out=std::cout)
        show_all_statistics(Model self)
        """
        return _IMP_kernel.Model_show_all_statistics(self, *args)

    def show_restraint_time_statistics(self, *args):
        """
        show_restraint_time_statistics(Model self, _ostream out=std::cout)
        show_restraint_time_statistics(Model self)
        """
        return _IMP_kernel.Model_show_restraint_time_statistics(self, *args)

    def show_restraint_score_statistics(self, *args):
        """
        show_restraint_score_statistics(Model self, _ostream out=std::cout)
        show_restraint_score_statistics(Model self)
        """
        return _IMP_kernel.Model_show_restraint_score_statistics(self, *args)

    def get_restraint_statistics(self, *args):
        """get_restraint_statistics(Model self, Restraint r) -> RestraintStatistics"""
        return _IMP_kernel.Model_get_restraint_statistics(self, *args)

    def show_score_state_time_statistics(self, *args):
        """
        show_score_state_time_statistics(Model self, _ostream out=std::cout)
        show_score_state_time_statistics(Model self)
        """
        return _IMP_kernel.Model_show_score_state_time_statistics(self, *args)

    def add_attribute(self, *args):
        """
        add_attribute(Model self, FloatKey attribute_key, IMP::kernel::ParticleIndex particle, IMP::Float value)
        add_attribute(Model self, IntKey attribute_key, IMP::kernel::ParticleIndex particle, IMP::Int value)
        add_attribute(Model self, IMP::kernel::IntsKey attribute_key, IMP::kernel::ParticleIndex particle, IMP::Ints value)
        add_attribute(Model self, StringKey attribute_key, IMP::kernel::ParticleIndex particle, IMP::String value)
        add_attribute(Model self, ParticleIndexesKey attribute_key, IMP::kernel::ParticleIndex particle, IMP::kernel::ParticleIndexes value)
        add_attribute(Model self, ParticleIndexKey attribute_key, IMP::kernel::ParticleIndex particle, IMP::kernel::ParticleIndex value)
        add_attribute(Model self, ObjectKey attribute_key, IMP::kernel::ParticleIndex particle, Object * value)
        add_attribute(Model self, IMP::kernel::WeakObjectKey attribute_key, IMP::kernel::ParticleIndex particle, Object * value)
        """
        return _IMP_kernel.Model_add_attribute(self, *args)

    def remove_attribute(self, *args):
        """
        remove_attribute(Model self, FloatKey attribute_key, IMP::kernel::ParticleIndex particle)
        remove_attribute(Model self, IntKey attribute_key, IMP::kernel::ParticleIndex particle)
        remove_attribute(Model self, IMP::kernel::IntsKey attribute_key, IMP::kernel::ParticleIndex particle)
        remove_attribute(Model self, StringKey attribute_key, IMP::kernel::ParticleIndex particle)
        remove_attribute(Model self, ParticleIndexesKey attribute_key, IMP::kernel::ParticleIndex particle)
        remove_attribute(Model self, ParticleIndexKey attribute_key, IMP::kernel::ParticleIndex particle)
        remove_attribute(Model self, ObjectKey attribute_key, IMP::kernel::ParticleIndex particle)
        remove_attribute(Model self, IMP::kernel::WeakObjectKey attribute_key, IMP::kernel::ParticleIndex particle)
        """
        return _IMP_kernel.Model_remove_attribute(self, *args)

    def get_has_attribute(self, *args):
        """
        get_has_attribute(Model self, FloatKey attribute_key, IMP::kernel::ParticleIndex particle) -> bool
        get_has_attribute(Model self, IntKey attribute_key, IMP::kernel::ParticleIndex particle) -> bool
        get_has_attribute(Model self, IMP::kernel::IntsKey attribute_key, IMP::kernel::ParticleIndex particle) -> bool
        get_has_attribute(Model self, StringKey attribute_key, IMP::kernel::ParticleIndex particle) -> bool
        get_has_attribute(Model self, ParticleIndexesKey attribute_key, IMP::kernel::ParticleIndex particle) -> bool
        get_has_attribute(Model self, ParticleIndexKey attribute_key, IMP::kernel::ParticleIndex particle) -> bool
        get_has_attribute(Model self, ObjectKey attribute_key, IMP::kernel::ParticleIndex particle) -> bool
        get_has_attribute(Model self, IMP::kernel::WeakObjectKey attribute_key, IMP::kernel::ParticleIndex particle) -> bool
        """
        return _IMP_kernel.Model_get_has_attribute(self, *args)

    def set_attribute(self, *args):
        """
        set_attribute(Model self, FloatKey attribute_key, IMP::kernel::ParticleIndex particle, IMP::Float value)
        set_attribute(Model self, IntKey attribute_key, IMP::kernel::ParticleIndex particle, IMP::Int value)
        set_attribute(Model self, IMP::kernel::IntsKey attribute_key, IMP::kernel::ParticleIndex particle, IMP::Ints value)
        set_attribute(Model self, StringKey attribute_key, IMP::kernel::ParticleIndex particle, IMP::String value)
        set_attribute(Model self, ParticleIndexesKey attribute_key, IMP::kernel::ParticleIndex particle, IMP::kernel::ParticleIndexes value)
        set_attribute(Model self, ParticleIndexKey attribute_key, IMP::kernel::ParticleIndex particle, IMP::kernel::ParticleIndex value)
        set_attribute(Model self, ObjectKey attribute_key, IMP::kernel::ParticleIndex particle, Object * value)
        set_attribute(Model self, IMP::kernel::WeakObjectKey attribute_key, IMP::kernel::ParticleIndex particle, Object * value)
        """
        return _IMP_kernel.Model_set_attribute(self, *args)

    def get_attribute(self, *args):
        """
        get_attribute(Model self, FloatKey attribute_key, IMP::kernel::ParticleIndex particle) -> IMP::Float
        get_attribute(Model self, IntKey attribute_key, IMP::kernel::ParticleIndex particle) -> IMP::Int
        get_attribute(Model self, IMP::kernel::IntsKey attribute_key, IMP::kernel::ParticleIndex particle) -> IMP::Ints
        get_attribute(Model self, StringKey attribute_key, IMP::kernel::ParticleIndex particle) -> IMP::String
        get_attribute(Model self, ParticleIndexesKey attribute_key, IMP::kernel::ParticleIndex particle) -> IMP::kernel::ParticleIndexes
        get_attribute(Model self, ParticleIndexKey attribute_key, IMP::kernel::ParticleIndex particle) -> IMP::kernel::ParticleIndex
        get_attribute(Model self, ObjectKey attribute_key, IMP::kernel::ParticleIndex particle) -> Object
        get_attribute(Model self, IMP::kernel::WeakObjectKey attribute_key, IMP::kernel::ParticleIndex particle) -> Object *
        """
        return _IMP_kernel.Model_get_attribute(self, *args)

    def add_cache_attribute(self, *args):
        """
        add_cache_attribute(Model self, FloatKey attribute_key, IMP::kernel::ParticleIndex particle, IMP::Float value)
        add_cache_attribute(Model self, IntKey attribute_key, IMP::kernel::ParticleIndex particle, IMP::Int value)
        add_cache_attribute(Model self, IMP::kernel::IntsKey attribute_key, IMP::kernel::ParticleIndex particle, IMP::Ints value)
        add_cache_attribute(Model self, StringKey attribute_key, IMP::kernel::ParticleIndex particle, IMP::String value)
        add_cache_attribute(Model self, ParticleIndexesKey attribute_key, IMP::kernel::ParticleIndex particle, IMP::kernel::ParticleIndexes value)
        add_cache_attribute(Model self, ParticleIndexKey attribute_key, IMP::kernel::ParticleIndex particle, IMP::kernel::ParticleIndex value)
        add_cache_attribute(Model self, ObjectKey attribute_key, IMP::kernel::ParticleIndex particle, Object * value)
        add_cache_attribute(Model self, IMP::kernel::WeakObjectKey attribute_key, IMP::kernel::ParticleIndex particle, Object * value)
        """
        return _IMP_kernel.Model_add_cache_attribute(self, *args)

    def set_is_optimized(self, *args):
        """set_is_optimized(Model self, FloatKey arg2, IMP::kernel::ParticleIndex arg3, bool arg4)"""
        return _IMP_kernel.Model_set_is_optimized(self, *args)

    def add_data(self, *args):
        """add_data(Model self, IMP::kernel::ModelKey mk, Object o)"""
        return _IMP_kernel.Model_add_data(self, *args)

    def get_data(self, *args):
        """get_data(Model self, IMP::kernel::ModelKey mk) -> Object"""
        return _IMP_kernel.Model_get_data(self, *args)

    def remove_data(self, *args):
        """remove_data(Model self, IMP::kernel::ModelKey mk)"""
        return _IMP_kernel.Model_remove_data(self, *args)

    def get_has_data(self, *args):
        """get_has_data(Model self, IMP::kernel::ModelKey mk) -> bool"""
        return _IMP_kernel.Model_get_has_data(self, *args)

    def get_number_of_particles(self):
        """get_number_of_particles(Model self) -> unsigned int"""
        return _IMP_kernel.Model_get_number_of_particles(self)

    def get_particles(self):
        """get_particles(Model self) -> IMP::kernel::ParticlesTemp"""
        return _IMP_kernel.Model_get_particles(self)

    def get_particle(self, *args):
        """get_particle(Model self, IMP::kernel::ParticleIndex p) -> Particle"""
        return _IMP_kernel.Model_get_particle(self, *args)

    def get_model_objects(self):
        """get_model_objects(Model self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.Model_get_model_objects(self)

    def __str__(self):
        """__str__(Model self) -> std::string"""
        return _IMP_kernel.Model___str__(self)

    def __repr__(self):
        """__repr__(Model self) -> std::string"""
        return _IMP_kernel.Model___repr__(self)

    def get_from(o):
       return _object_cast_to_Model(o)
    get_from = staticmethod(get_from)

Model_swigregister = _IMP_kernel.Model_swigregister
Model_swigregister(Model)

class Decorator(IMP.base._Value):
    """Proxy of C++ IMP::kernel::Decorator class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base._Value]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Decorator, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base._Value]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Decorator, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::Decorator self, Model m, IMP::kernel::ParticleIndex pi) -> Decorator
        __init__(IMP::kernel::Decorator self, Particle p) -> Decorator
        __init__(IMP::kernel::Decorator self) -> Decorator
        """
        this = _IMP_kernel.new_Decorator(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_particle_index(self):
        """get_particle_index(Decorator self) -> IMP::kernel::ParticleIndex"""
        return _IMP_kernel.Decorator_get_particle_index(self)

    def __ne__(self, *args):
        """__ne__(Decorator self, Object o) -> bool"""
        return _IMP_kernel.Decorator___ne__(self, *args)

    def __lt__(self, *args):
        """__lt__(Decorator self, Object o) -> bool"""
        return _IMP_kernel.Decorator___lt__(self, *args)

    def __gt__(self, *args):
        """__gt__(Decorator self, Object o) -> bool"""
        return _IMP_kernel.Decorator___gt__(self, *args)

    def __ge__(self, *args):
        """__ge__(Decorator self, Object o) -> bool"""
        return _IMP_kernel.Decorator___ge__(self, *args)

    def __le__(self, *args):
        """__le__(Decorator self, Object o) -> bool"""
        return _IMP_kernel.Decorator___le__(self, *args)

    def get_particle(self):
        """get_particle(Decorator self) -> Particle"""
        return _IMP_kernel.Decorator_get_particle(self)

    def get_model(self):
        """get_model(Decorator self) -> Model"""
        return _IMP_kernel.Decorator_get_model(self)

    def __hash__(self):
        """__hash__(Decorator self) -> std::size_t"""
        return _IMP_kernel.Decorator___hash__(self)

    def __eq__(self, *args):
        """
        __eq__(Decorator self, Object o) -> bool
        __eq__(Decorator self, Decorator o) -> bool
        __eq__(Decorator self, Particle o) -> bool
        """
        return _IMP_kernel.Decorator___eq__(self, *args)

    __swig_destroy__ = _IMP_kernel.delete_Decorator
    __del__ = lambda self : None;
Decorator_swigregister = _IMP_kernel.Decorator_swigregister
Decorator_swigregister(Decorator)


def check_particle(*args):
  """check_particle(Particle p)"""
  return _IMP_kernel.check_particle(*args)
class UnaryFunction(IMP.base.Object):
    """Proxy of C++ IMP::kernel::UnaryFunction class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, UnaryFunction, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, UnaryFunction, name)
    def __init__(self, name="UnaryFunction%1%"): 
        """
        __init__(IMP::kernel::UnaryFunction self, std::string name="UnaryFunction%1%") -> UnaryFunction
        __init__(IMP::kernel::UnaryFunction self) -> UnaryFunction
        """
        if self.__class__ == UnaryFunction:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_UnaryFunction(_self, name)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != UnaryFunction:
            import IMP.base
            IMP.base._director_objects.register(self)



    def evaluate(self, *args):
        """evaluate(UnaryFunction self, double feature) -> double"""
        return _IMP_kernel.UnaryFunction_evaluate(self, *args)

    def evaluate_with_derivative(self, *args):
        """evaluate_with_derivative(UnaryFunction self, double feature) -> IMP::DerivativePair"""
        return _IMP_kernel.UnaryFunction_evaluate_with_derivative(self, *args)

    __swig_destroy__ = _IMP_kernel.delete_UnaryFunction
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(UnaryFunction self) -> std::string"""
        return _IMP_kernel.UnaryFunction___str__(self)

    def __repr__(self):
        """__repr__(UnaryFunction self) -> std::string"""
        return _IMP_kernel.UnaryFunction___repr__(self)

    def get_from(o):
       return _object_cast_to_UnaryFunction(o)
    get_from = staticmethod(get_from)

    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::kernel" == "IMP":
          return VersionInfo("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_UnaryFunction(o)
    get_from = staticmethod(get_from)

    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_UnaryFunction(self)
        return weakref_proxy(self)
UnaryFunction_swigregister = _IMP_kernel.UnaryFunction_swigregister
UnaryFunction_swigregister(UnaryFunction)

class OptimizerState(IMP.base.Object):
    """Proxy of C++ IMP::kernel::OptimizerState class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, OptimizerState, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, OptimizerState, name)
    def __init__(self, name="OptimizerState %1%"): 
        """
        __init__(IMP::kernel::OptimizerState self, std::string name="OptimizerState %1%") -> OptimizerState
        __init__(IMP::kernel::OptimizerState self) -> OptimizerState
        """
        if self.__class__ == OptimizerState:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_OptimizerState(_self, name)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != OptimizerState:
            import IMP.base
            IMP.base._director_objects.register(self)



    def update(self):
        """update(OptimizerState self)"""
        return _IMP_kernel.OptimizerState_update(self)

    def set_is_optimizing(self, *args):
        """set_is_optimizing(OptimizerState self, bool arg0)"""
        return _IMP_kernel.OptimizerState_set_is_optimizing(self, *args)

    def get_optimizer(self):
        """get_optimizer(OptimizerState self) -> Optimizer"""
        return _IMP_kernel.OptimizerState_get_optimizer(self)

    __swig_destroy__ = _IMP_kernel.delete_OptimizerState
    __del__ = lambda self : None;
    __swig_setmethods__["optimizer_"] = _IMP_kernel.OptimizerState_optimizer__set
    __swig_getmethods__["optimizer_"] = _IMP_kernel.OptimizerState_optimizer__get
    if _newclass:optimizer_ = _swig_property(_IMP_kernel.OptimizerState_optimizer__get, _IMP_kernel.OptimizerState_optimizer__set)
    def __str__(self):
        """__str__(OptimizerState self) -> std::string"""
        return _IMP_kernel.OptimizerState___str__(self)

    def __repr__(self):
        """__repr__(OptimizerState self) -> std::string"""
        return _IMP_kernel.OptimizerState___repr__(self)

    def get_from(o):
       return _object_cast_to_OptimizerState(o)
    get_from = staticmethod(get_from)

    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::kernel" == "IMP":
          return VersionInfo("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_OptimizerState(o)
    get_from = staticmethod(get_from)

    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_OptimizerState(self)
        return weakref_proxy(self)
OptimizerState_swigregister = _IMP_kernel.OptimizerState_swigregister
OptimizerState_swigregister(OptimizerState)

class Refiner(IMP.base.Object):
    """Proxy of C++ IMP::kernel::Refiner class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Refiner, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Refiner, name)
    def __init__(self, name="Refiner %1%"): 
        """
        __init__(IMP::kernel::Refiner self, std::string name="Refiner %1%") -> Refiner
        __init__(IMP::kernel::Refiner self) -> Refiner
        """
        if self.__class__ == Refiner:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_Refiner(_self, name)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != Refiner:
            import IMP.base
            IMP.base._director_objects.register(self)



    def get_can_refine(self, *args):
        """get_can_refine(Refiner self, Particle arg0) -> bool"""
        return _IMP_kernel.Refiner_get_can_refine(self, *args)

    def get_refined(self, *args):
        """
        get_refined(Refiner self, Particle a) -> IMP::kernel::ParticlesTemp const
        get_refined(Refiner self, Particle a, unsigned int i) -> Particle
        """
        return _IMP_kernel.Refiner_get_refined(self, *args)

    def get_number_of_refined(self, *args):
        """get_number_of_refined(Refiner self, Particle a) -> unsigned int"""
        return _IMP_kernel.Refiner_get_number_of_refined(self, *args)

    def get_input_particles(self, *args):
        """get_input_particles(Refiner self, Particle p) -> IMP::kernel::ParticlesTemp"""
        return _IMP_kernel.Refiner_get_input_particles(self, *args)

    def get_input_containers(self, *args):
        """get_input_containers(Refiner self, Particle p) -> IMP::kernel::ContainersTemp"""
        return _IMP_kernel.Refiner_get_input_containers(self, *args)

    def get_inputs(self, *args):
        """get_inputs(Refiner self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.Refiner_get_inputs(self, *args)

    def _do_get_inputs(self, *args):
        """_do_get_inputs(Refiner self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.Refiner__do_get_inputs(self, *args)

    def __str__(self):
        """__str__(Refiner self) -> std::string"""
        return _IMP_kernel.Refiner___str__(self)

    def __repr__(self):
        """__repr__(Refiner self) -> std::string"""
        return _IMP_kernel.Refiner___repr__(self)

    def get_from(o):
       return _object_cast_to_Refiner(o)
    get_from = staticmethod(get_from)

    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::kernel" == "IMP":
          return VersionInfo("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_Refiner(o)
    get_from = staticmethod(get_from)

    __swig_destroy__ = _IMP_kernel.delete_Refiner
    __del__ = lambda self : None;
    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_Refiner(self)
        return weakref_proxy(self)
Refiner_swigregister = _IMP_kernel.Refiner_swigregister
Refiner_swigregister(Refiner)

class Optimizer(IMP.base.Object):
    """Proxy of C++ IMP::kernel::Optimizer class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Optimizer, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Optimizer, name)
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::Optimizer self) -> Optimizer
        __init__(IMP::kernel::Optimizer self, Model m, std::string name="Optimizer %1%") -> Optimizer
        __init__(IMP::kernel::Optimizer self, Model m) -> Optimizer
        """
        if self.__class__ == Optimizer:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_Optimizer(_self, *args)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != Optimizer:
            import IMP.base
            IMP.base._director_objects.register(self)



    def optimize(self, *args):
        """optimize(Optimizer self, unsigned int max_steps) -> double"""
        return _IMP_kernel.Optimizer_optimize(self, *args)

    def set_score_threshold(self, *args):
        """set_score_threshold(Optimizer self, double s)"""
        return _IMP_kernel.Optimizer_set_score_threshold(self, *args)

    def get_score_threshold(self):
        """get_score_threshold(Optimizer self) -> double"""
        return _IMP_kernel.Optimizer_get_score_threshold(self)

    def set_stop_on_good_score(self, *args):
        """set_stop_on_good_score(Optimizer self, bool tf)"""
        return _IMP_kernel.Optimizer_set_stop_on_good_score(self, *args)

    def get_stop_on_good_score(self):
        """get_stop_on_good_score(Optimizer self) -> bool"""
        return _IMP_kernel.Optimizer_get_stop_on_good_score(self)

    def get_last_score(self):
        """get_last_score(Optimizer self) -> double"""
        return _IMP_kernel.Optimizer_get_last_score(self)

    def get_scoring_function(self):
        """get_scoring_function(Optimizer self) -> ScoringFunction"""
        return _IMP_kernel.Optimizer_get_scoring_function(self)

    def get_model(self):
        """get_model(Optimizer self) -> Model"""
        return _IMP_kernel.Optimizer_get_model(self)

    def set_model(self, *args):
        """set_model(Optimizer self, Model m)"""
        return _IMP_kernel.Optimizer_set_model(self, *args)

    def show(self, *args):
        """
        show(Optimizer self, _ostream out=std::cout)
        show(Optimizer self)
        """
        return _IMP_kernel.Optimizer_show(self, *args)

    def remove_optimizer_state(self, *args):
        """remove_optimizer_state(Optimizer self, OptimizerState d)"""
        return _IMP_kernel.Optimizer_remove_optimizer_state(self, *args)

    def remove_optimizer_states(self, *args):
        """remove_optimizer_states(Optimizer self, IMP::kernel::OptimizerStates const & d)"""
        return _IMP_kernel.Optimizer_remove_optimizer_states(self, *args)

    def set_optimizer_states(self, *args):
        """set_optimizer_states(Optimizer self, IMP::kernel::OptimizerStates const & ps)"""
        return _IMP_kernel.Optimizer_set_optimizer_states(self, *args)

    def set_optimizer_states_order(self, *args):
        """set_optimizer_states_order(Optimizer self, IMP::kernel::OptimizerStates const & objs)"""
        return _IMP_kernel.Optimizer_set_optimizer_states_order(self, *args)

    def add_optimizer_state(self, *args):
        """add_optimizer_state(Optimizer self, OptimizerState obj) -> unsigned int"""
        return _IMP_kernel.Optimizer_add_optimizer_state(self, *args)

    def add_optimizer_states(self, *args):
        """add_optimizer_states(Optimizer self, IMP::kernel::OptimizerStates const & objs)"""
        return _IMP_kernel.Optimizer_add_optimizer_states(self, *args)

    def clear_optimizer_states(self):
        """clear_optimizer_states(Optimizer self)"""
        return _IMP_kernel.Optimizer_clear_optimizer_states(self)

    def get_number_of_optimizer_states(self):
        """get_number_of_optimizer_states(Optimizer self) -> unsigned int"""
        return _IMP_kernel.Optimizer_get_number_of_optimizer_states(self)

    def get_has_optimizer_states(self):
        """get_has_optimizer_states(Optimizer self) -> bool"""
        return _IMP_kernel.Optimizer_get_has_optimizer_states(self)

    def get_optimizer_state(self, *args):
        """get_optimizer_state(Optimizer self, unsigned int i) -> OptimizerState"""
        return _IMP_kernel.Optimizer_get_optimizer_state(self, *args)

    def get_optimizer_states(self):
        """get_optimizer_states(Optimizer self) -> IMP::kernel::OptimizerStates"""
        return _IMP_kernel.Optimizer_get_optimizer_states(self)

    def reserve_optimizer_states(self, *args):
        """reserve_optimizer_states(Optimizer self, unsigned int sz)"""
        return _IMP_kernel.Optimizer_reserve_optimizer_states(self, *args)

    def set_scoring_function(self, *args):
        """set_scoring_function(Optimizer self, _ScoringFunctionAdaptor sf)"""
        return _IMP_kernel.Optimizer_set_scoring_function(self, *args)

    def set_restraints(self, *args):
        """set_restraints(Optimizer self, IMP::kernel::RestraintsTemp const & rs)"""
        return _IMP_kernel.Optimizer_set_restraints(self, *args)

    __swig_destroy__ = _IMP_kernel.delete_Optimizer
    def __del__(self):
        """__del__(IMP::kernel::Optimizer self)"""
        import IMP.base
        IMP.base._director_objects.cleanup()


        pass

    def do_optimize(self, *args):
        """do_optimize(Optimizer self, unsigned int ns) -> double"""
        return _IMP_kernel.Optimizer_do_optimize(self, *args)

    def update_states(self):
        """update_states(Optimizer self)"""
        return _IMP_kernel.Optimizer_update_states(self)

    def get_optimized_attributes(self):
        """get_optimized_attributes(Optimizer self) -> IMP::kernel::FloatIndexes"""
        return _IMP_kernel.Optimizer_get_optimized_attributes(self)

    def _set_value(self, *args):
        """_set_value(Optimizer self, FloatIndex fi, double v)"""
        return _IMP_kernel.Optimizer__set_value(self, *args)

    def _get_value(self, *args):
        """_get_value(Optimizer self, FloatIndex fi) -> IMP::Float"""
        return _IMP_kernel.Optimizer__get_value(self, *args)

    def _get_derivative(self, *args):
        """_get_derivative(Optimizer self, FloatIndex fi) -> IMP::Float"""
        return _IMP_kernel.Optimizer__get_derivative(self, *args)

    def _width(self, *args):
        """_width(Optimizer self, FloatKey k) -> double"""
        return _IMP_kernel.Optimizer__width(self, *args)

    def _set_scaled_value(self, *args):
        """_set_scaled_value(Optimizer self, FloatIndex fi, IMP::Float v)"""
        return _IMP_kernel.Optimizer__set_scaled_value(self, *args)

    def _get_scaled_value(self, *args):
        """_get_scaled_value(Optimizer self, FloatIndex fi) -> double"""
        return _IMP_kernel.Optimizer__get_scaled_value(self, *args)

    def _get_scaled_derivative(self, *args):
        """_get_scaled_derivative(Optimizer self, FloatIndex fi) -> double"""
        return _IMP_kernel.Optimizer__get_scaled_derivative(self, *args)

    def _clear_range_cache(self):
        """_clear_range_cache(Optimizer self)"""
        return _IMP_kernel.Optimizer__clear_range_cache(self)

    def _get_restraints(self):
        """_get_restraints(Optimizer self) -> IMP::kernel::Restraints"""
        return _IMP_kernel.Optimizer__get_restraints(self)

    def __str__(self):
        """__str__(Optimizer self) -> std::string"""
        return _IMP_kernel.Optimizer___str__(self)

    def __repr__(self):
        """__repr__(Optimizer self) -> std::string"""
        return _IMP_kernel.Optimizer___repr__(self)

    def get_from(o):
       return _object_cast_to_Optimizer(o)
    get_from = staticmethod(get_from)

    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::kernel" == "IMP":
          return VersionInfo("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_Optimizer(o)
    get_from = staticmethod(get_from)

    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_Optimizer(self)
        return weakref_proxy(self)
Optimizer_swigregister = _IMP_kernel.Optimizer_swigregister
Optimizer_swigregister(Optimizer)

class ConfigurationSet(IMP.base.Object):
    """Proxy of C++ IMP::kernel::ConfigurationSet class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConfigurationSet, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ConfigurationSet, name)
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::ConfigurationSet self, Model m, std::string name="ConfigurationSet %1%") -> ConfigurationSet
        __init__(IMP::kernel::ConfigurationSet self, Model m) -> ConfigurationSet
        """
        this = _IMP_kernel.new_ConfigurationSet(*args)
        try: self.this.append(this)
        except: self.this = this
    def save_configuration(self):
        """save_configuration(ConfigurationSet self)"""
        return _IMP_kernel.ConfigurationSet_save_configuration(self)

    def get_number_of_configurations(self):
        """get_number_of_configurations(ConfigurationSet self) -> unsigned int"""
        return _IMP_kernel.ConfigurationSet_get_number_of_configurations(self)

    def load_configuration(self, *args):
        """load_configuration(ConfigurationSet self, int i)"""
        return _IMP_kernel.ConfigurationSet_load_configuration(self, *args)

    def remove_configuration(self, *args):
        """remove_configuration(ConfigurationSet self, unsigned int i)"""
        return _IMP_kernel.ConfigurationSet_remove_configuration(self, *args)

    def get_model(self):
        """get_model(ConfigurationSet self) -> Model"""
        return _IMP_kernel.ConfigurationSet_get_model(self)

    def get_version_info(self):
        """get_version_info(ConfigurationSet self) -> VersionInfo"""
        return _IMP_kernel.ConfigurationSet_get_version_info(self)

    __swig_destroy__ = _IMP_kernel.delete_ConfigurationSet
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(ConfigurationSet self) -> std::string"""
        return _IMP_kernel.ConfigurationSet___str__(self)

    def __repr__(self):
        """__repr__(ConfigurationSet self) -> std::string"""
        return _IMP_kernel.ConfigurationSet___repr__(self)

    def get_from(o):
       return _object_cast_to_ConfigurationSet(o)
    get_from = staticmethod(get_from)

ConfigurationSet_swigregister = _IMP_kernel.ConfigurationSet_swigregister
ConfigurationSet_swigregister(ConfigurationSet)

class SaveToConfigurationSetOptimizerState(OptimizerState):
    """Proxy of C++ IMP::kernel::SaveToConfigurationSetOptimizerState class"""
    __swig_setmethods__ = {}
    for _s in [OptimizerState]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SaveToConfigurationSetOptimizerState, name, value)
    __swig_getmethods__ = {}
    for _s in [OptimizerState]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SaveToConfigurationSetOptimizerState, name)
    def __init__(self, *args): 
        """__init__(IMP::kernel::SaveToConfigurationSetOptimizerState self, ConfigurationSet cs, std::string file_name) -> SaveToConfigurationSetOptimizerState"""
        this = _IMP_kernel.new_SaveToConfigurationSetOptimizerState(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_skip_steps(self, *args):
        """set_skip_steps(SaveToConfigurationSetOptimizerState self, unsigned int k)"""
        return _IMP_kernel.SaveToConfigurationSetOptimizerState_set_skip_steps(self, *args)

    def set_period(self, *args):
        """set_period(SaveToConfigurationSetOptimizerState self, unsigned int p)"""
        return _IMP_kernel.SaveToConfigurationSetOptimizerState_set_period(self, *args)

    def write(self, *args):
        """
        write(SaveToConfigurationSetOptimizerState self, std::string file_name, unsigned int call=0, bool append=False)
        write(SaveToConfigurationSetOptimizerState self, std::string file_name, unsigned int call=0)
        write(SaveToConfigurationSetOptimizerState self, std::string file_name)
        """
        return _IMP_kernel.SaveToConfigurationSetOptimizerState_write(self, *args)

    def get_version_info(self):
        """get_version_info(SaveToConfigurationSetOptimizerState self) -> VersionInfo"""
        return _IMP_kernel.SaveToConfigurationSetOptimizerState_get_version_info(self)

    __swig_destroy__ = _IMP_kernel.delete_SaveToConfigurationSetOptimizerState
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(SaveToConfigurationSetOptimizerState self) -> std::string"""
        return _IMP_kernel.SaveToConfigurationSetOptimizerState___str__(self)

    def __repr__(self):
        """__repr__(SaveToConfigurationSetOptimizerState self) -> std::string"""
        return _IMP_kernel.SaveToConfigurationSetOptimizerState___repr__(self)

    def get_from(o):
       return _object_cast_to_SaveToConfigurationSetOptimizerState(o)
    get_from = staticmethod(get_from)

SaveToConfigurationSetOptimizerState_swigregister = _IMP_kernel.SaveToConfigurationSetOptimizerState_swigregister
SaveToConfigurationSetOptimizerState_swigregister(SaveToConfigurationSetOptimizerState)

class Configuration(IMP.base.Object):
    """Proxy of C++ IMP::kernel::Configuration class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Configuration, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Configuration, name)
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::Configuration self, Model m, std::string name="Configuration %1%") -> Configuration
        __init__(IMP::kernel::Configuration self, Model m) -> Configuration
        __init__(IMP::kernel::Configuration self, Model m, Configuration base, std::string name="Configuration %1%") -> Configuration
        __init__(IMP::kernel::Configuration self, Model m, Configuration base) -> Configuration
        """
        this = _IMP_kernel.new_Configuration(*args)
        try: self.this.append(this)
        except: self.this = this
    def load_configuration(self):
        """load_configuration(Configuration self)"""
        return _IMP_kernel.Configuration_load_configuration(self)

    def swap_configuration(self):
        """swap_configuration(Configuration self)"""
        return _IMP_kernel.Configuration_swap_configuration(self)

    def get_version_info(self):
        """get_version_info(Configuration self) -> VersionInfo"""
        return _IMP_kernel.Configuration_get_version_info(self)

    def do_show(self, *args):
        """do_show(Configuration self, _ostream out)"""
        return _IMP_kernel.Configuration_do_show(self, *args)

    __swig_destroy__ = _IMP_kernel.delete_Configuration
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(Configuration self) -> std::string"""
        return _IMP_kernel.Configuration___str__(self)

    def __repr__(self):
        """__repr__(Configuration self) -> std::string"""
        return _IMP_kernel.Configuration___repr__(self)

    def get_from(o):
       return _object_cast_to_Configuration(o)
    get_from = staticmethod(get_from)

Configuration_swigregister = _IMP_kernel.Configuration_swigregister
Configuration_swigregister(Configuration)

class Sampler(IMP.base.Object):
    """Proxy of C++ IMP::kernel::Sampler class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Sampler, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Sampler, name)
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::Sampler self, Model m, std::string name="Sampler %1%") -> Sampler
        __init__(IMP::kernel::Sampler self, Model m) -> Sampler
        """
        if self.__class__ == Sampler:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_Sampler(_self, *args)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != Sampler:
            import IMP.base
            IMP.base._director_objects.register(self)



    def get_sample(self):
        """get_sample(Sampler self) -> ConfigurationSet"""
        return _IMP_kernel.Sampler_get_sample(self)

    def create_sample(self):
        """create_sample(Sampler self) -> ConfigurationSet"""
        return _IMP_kernel.Sampler_create_sample(self)

    def get_scoring_function(self):
        """get_scoring_function(Sampler self) -> ScoringFunction"""
        return _IMP_kernel.Sampler_get_scoring_function(self)

    def set_scoring_function(self, *args):
        """set_scoring_function(Sampler self, _ScoringFunctionAdaptor sf)"""
        return _IMP_kernel.Sampler_set_scoring_function(self, *args)

    def get_model(self):
        """get_model(Sampler self) -> Model"""
        return _IMP_kernel.Sampler_get_model(self)

    def do_sample(self):
        """do_sample(Sampler self) -> ConfigurationSet"""
        return _IMP_kernel.Sampler_do_sample(self)

    __swig_destroy__ = _IMP_kernel.delete_Sampler
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(Sampler self) -> std::string"""
        return _IMP_kernel.Sampler___str__(self)

    def __repr__(self):
        """__repr__(Sampler self) -> std::string"""
        return _IMP_kernel.Sampler___repr__(self)

    def get_from(o):
       return _object_cast_to_Sampler(o)
    get_from = staticmethod(get_from)

    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::kernel" == "IMP":
          return VersionInfo("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_Sampler(o)
    get_from = staticmethod(get_from)

    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_Sampler(self)
        return weakref_proxy(self)
Sampler_swigregister = _IMP_kernel.Sampler_swigregister
Sampler_swigregister(Sampler)

class PairModifier(IMP.base.Object):
    """Proxy of C++ IMP::kernel::PairModifier class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PairModifier, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PairModifier, name)
    def __init__(self, name="PairModifier %1%"): 
        """
        __init__(IMP::kernel::PairModifier self, std::string name="PairModifier %1%") -> PairModifier
        __init__(IMP::kernel::PairModifier self) -> PairModifier
        """
        if self.__class__ == PairModifier:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_PairModifier(_self, name)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != PairModifier:
            import IMP.base
            IMP.base._director_objects.register(self)



    def apply(self, *args):
        """apply(PairModifier self, IMP::kernel::ParticlePair const & arg0)"""
        return _IMP_kernel.PairModifier_apply(self, *args)

    def apply_index(self, *args):
        """apply_index(PairModifier self, Model m, IMP::kernel::ParticleIndexPair const & v)"""
        return _IMP_kernel.PairModifier_apply_index(self, *args)

    def apply_indexes(self, *args):
        """apply_indexes(PairModifier self, Model m, IMP::kernel::ParticleIndexPairs const & o, unsigned int lower_bound, unsigned int upper_bound)"""
        return _IMP_kernel.PairModifier_apply_indexes(self, *args)

    def get_input_particles(self, *args):
        """get_input_particles(PairModifier self, Particle p) -> IMP::kernel::ParticlesTemp"""
        return _IMP_kernel.PairModifier_get_input_particles(self, *args)

    def get_input_containers(self, *args):
        """get_input_containers(PairModifier self, Particle p) -> IMP::kernel::ContainersTemp"""
        return _IMP_kernel.PairModifier_get_input_containers(self, *args)

    def get_inputs(self, *args):
        """get_inputs(PairModifier self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.PairModifier_get_inputs(self, *args)

    def _do_get_inputs(self, *args):
        """_do_get_inputs(PairModifier self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.PairModifier__do_get_inputs(self, *args)

    def get_output_particles(self, *args):
        """get_output_particles(PairModifier self, Particle p) -> IMP::kernel::ParticlesTemp"""
        return _IMP_kernel.PairModifier_get_output_particles(self, *args)

    def get_output_containers(self, *args):
        """get_output_containers(PairModifier self, Particle p) -> IMP::kernel::ContainersTemp"""
        return _IMP_kernel.PairModifier_get_output_containers(self, *args)

    def get_outputs(self, *args):
        """get_outputs(PairModifier self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.PairModifier_get_outputs(self, *args)

    def _do_get_outputs(self, *args):
        """_do_get_outputs(PairModifier self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.PairModifier__do_get_outputs(self, *args)

    def __str__(self):
        """__str__(PairModifier self) -> std::string"""
        return _IMP_kernel.PairModifier___str__(self)

    def __repr__(self):
        """__repr__(PairModifier self) -> std::string"""
        return _IMP_kernel.PairModifier___repr__(self)

    def get_from(o):
       return _object_cast_to_PairModifier(o)
    get_from = staticmethod(get_from)

    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::kernel" == "IMP":
          return VersionInfo("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_PairModifier(o)
    get_from = staticmethod(get_from)

    __swig_destroy__ = _IMP_kernel.delete_PairModifier
    __del__ = lambda self : None;
    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_PairModifier(self)
        return weakref_proxy(self)
PairModifier_swigregister = _IMP_kernel.PairModifier_swigregister
PairModifier_swigregister(PairModifier)

class PairScore(IMP.base.Object):
    """Proxy of C++ IMP::kernel::PairScore class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PairScore, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PairScore, name)
    def __init__(self, name="PairScore %1%"): 
        """
        __init__(IMP::kernel::PairScore self, std::string name="PairScore %1%") -> PairScore
        __init__(IMP::kernel::PairScore self) -> PairScore
        """
        if self.__class__ == PairScore:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_PairScore(_self, name)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != PairScore:
            import IMP.base
            IMP.base._director_objects.register(self)



    def evaluate(self, *args):
        """evaluate(PairScore self, IMP::kernel::ParticlePair const & vt, DerivativeAccumulator da) -> double"""
        return _IMP_kernel.PairScore_evaluate(self, *args)

    def evaluate_index(self, *args):
        """evaluate_index(PairScore self, Model m, IMP::kernel::ParticleIndexPair const & vt, DerivativeAccumulator da) -> double"""
        return _IMP_kernel.PairScore_evaluate_index(self, *args)

    def evaluate_indexes(self, *args):
        """
        evaluate_indexes(PairScore self, Model m, IMP::kernel::ParticleIndexPairs const & o, DerivativeAccumulator da, unsigned int lower_bound, 
            unsigned int upper_bound) -> double
        """
        return _IMP_kernel.PairScore_evaluate_indexes(self, *args)

    def evaluate_if_good_index(self, *args):
        """evaluate_if_good_index(PairScore self, Model m, IMP::kernel::ParticleIndexPair const & vt, DerivativeAccumulator da, double max) -> double"""
        return _IMP_kernel.PairScore_evaluate_if_good_index(self, *args)

    def evaluate_if_good_indexes(self, *args):
        """
        evaluate_if_good_indexes(PairScore self, Model m, IMP::kernel::ParticleIndexPairs const & o, DerivativeAccumulator da, double max, 
            unsigned int lower_bound, unsigned int upper_bound) -> double
        """
        return _IMP_kernel.PairScore_evaluate_if_good_indexes(self, *args)

    def create_current_decomposition(self, *args):
        """create_current_decomposition(PairScore self, Model m, IMP::kernel::ParticleIndexPair const & vt) -> IMP::kernel::Restraints"""
        return _IMP_kernel.PairScore_create_current_decomposition(self, *args)

    def get_input_particles(self, *args):
        """get_input_particles(PairScore self, Particle p) -> IMP::kernel::ParticlesTemp"""
        return _IMP_kernel.PairScore_get_input_particles(self, *args)

    def get_input_containers(self, *args):
        """get_input_containers(PairScore self, Particle p) -> IMP::kernel::ContainersTemp"""
        return _IMP_kernel.PairScore_get_input_containers(self, *args)

    def get_inputs(self, *args):
        """get_inputs(PairScore self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.PairScore_get_inputs(self, *args)

    def _do_get_inputs(self, *args):
        """_do_get_inputs(PairScore self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.PairScore__do_get_inputs(self, *args)

    def do_create_current_decomposition(self, *args):
        """do_create_current_decomposition(PairScore self, Model m, IMP::kernel::ParticleIndexPair const & vt) -> IMP::kernel::Restraints"""
        return _IMP_kernel.PairScore_do_create_current_decomposition(self, *args)

    __swig_destroy__ = _IMP_kernel.delete_PairScore
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(PairScore self) -> std::string"""
        return _IMP_kernel.PairScore___str__(self)

    def __repr__(self):
        """__repr__(PairScore self) -> std::string"""
        return _IMP_kernel.PairScore___repr__(self)

    def get_from(o):
       return _object_cast_to_PairScore(o)
    get_from = staticmethod(get_from)

    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::kernel" == "IMP":
          return VersionInfo("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_PairScore(o)
    get_from = staticmethod(get_from)

    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_PairScore(self)
        return weakref_proxy(self)
PairScore_swigregister = _IMP_kernel.PairScore_swigregister
PairScore_swigregister(PairScore)

class PairPredicate(IMP.base.Object):
    """Proxy of C++ IMP::kernel::PairPredicate class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PairPredicate, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PairPredicate, name)
    def __init__(self, name="PairPredicate %1%"): 
        """
        __init__(IMP::kernel::PairPredicate self, std::string name="PairPredicate %1%") -> PairPredicate
        __init__(IMP::kernel::PairPredicate self) -> PairPredicate
        """
        if self.__class__ == PairPredicate:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_PairPredicate(_self, name)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != PairPredicate:
            import IMP.base
            IMP.base._director_objects.register(self)



    def get_value(self, *args):
        """
        get_value(PairPredicate self, IMP::kernel::ParticlePair const & vt) -> int
        get_value(PairPredicate self, IMP::kernel::ParticlePairsTemp const & o) -> IMP::Ints
        """
        return _IMP_kernel.PairPredicate_get_value(self, *args)

    def __call__(self, *args):
        """__call__(PairPredicate self, Model m, IMP::kernel::ParticleIndexPair const & vt) -> int"""
        return _IMP_kernel.PairPredicate___call__(self, *args)

    def get_value_index(self, *args):
        """
        get_value_index(PairPredicate self, Model m, IMP::kernel::ParticleIndexPair const & vt) -> int
        get_value_index(PairPredicate self, Model m, IMP::kernel::ParticleIndexPairs const & o) -> IMP::Ints
        """
        return _IMP_kernel.PairPredicate_get_value_index(self, *args)

    def get_input_particles(self, *args):
        """get_input_particles(PairPredicate self, Particle p) -> IMP::kernel::ParticlesTemp"""
        return _IMP_kernel.PairPredicate_get_input_particles(self, *args)

    def get_input_containers(self, *args):
        """get_input_containers(PairPredicate self, Particle p) -> IMP::kernel::ContainersTemp"""
        return _IMP_kernel.PairPredicate_get_input_containers(self, *args)

    def get_inputs(self, *args):
        """get_inputs(PairPredicate self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.PairPredicate_get_inputs(self, *args)

    def _do_get_inputs(self, *args):
        """_do_get_inputs(PairPredicate self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.PairPredicate__do_get_inputs(self, *args)

    __swig_destroy__ = _IMP_kernel.delete_PairPredicate
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(PairPredicate self) -> std::string"""
        return _IMP_kernel.PairPredicate___str__(self)

    def __repr__(self):
        """__repr__(PairPredicate self) -> std::string"""
        return _IMP_kernel.PairPredicate___repr__(self)

    def get_from(o):
       return _object_cast_to_PairPredicate(o)
    get_from = staticmethod(get_from)

    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::kernel" == "IMP":
          return VersionInfo("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_PairPredicate(o)
    get_from = staticmethod(get_from)

    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_PairPredicate(self)
        return weakref_proxy(self)
PairPredicate_swigregister = _IMP_kernel.PairPredicate_swigregister
PairPredicate_swigregister(PairPredicate)

class PairContainer(Container):
    """Proxy of C++ IMP::kernel::PairContainer class"""
    __swig_setmethods__ = {}
    for _s in [Container]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PairContainer, name, value)
    __swig_getmethods__ = {}
    for _s in [Container]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PairContainer, name)
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::PairContainer self, Model m, std::string name="PairContainer %1%") -> PairContainer
        __init__(IMP::kernel::PairContainer self, Model m) -> PairContainer
        """
        if self.__class__ == PairContainer:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_PairContainer(_self, *args)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != PairContainer:
            import IMP.base
            IMP.base._director_objects.register(self)



    def apply_generic(self, *args):
        """apply_generic(PairContainer self, PairModifier m)"""
        return _IMP_kernel.PairContainer_apply_generic(self, *args)

    def apply(self, *args):
        """apply(PairContainer self, PairModifier sm)"""
        return _IMP_kernel.PairContainer_apply(self, *args)

    def get_indexes(self):
        """get_indexes(PairContainer self) -> IMP::kernel::ParticleIndexPairs"""
        return _IMP_kernel.PairContainer_get_indexes(self)

    def get_range_indexes(self):
        """get_range_indexes(PairContainer self) -> IMP::kernel::ParticleIndexPairs"""
        return _IMP_kernel.PairContainer_get_range_indexes(self)

    def get(self, *args):
        """
        get(PairContainer self) -> IMP::kernel::ParticlePairsTemp
        get(PairContainer self, unsigned int i) -> IMP::kernel::ParticlePair
        """
        return _IMP_kernel.PairContainer_get(self, *args)

    def get_number(self):
        """get_number(PairContainer self) -> unsigned int"""
        return _IMP_kernel.PairContainer_get_number(self)

    def get_particle_pairs(self):
        """get_particle_pairs(PairContainer self) -> IMP::kernel::ParticlePairsTemp"""
        return _IMP_kernel.PairContainer_get_particle_pairs(self)

    def get_contains_particle_pair(self, *args):
        """get_contains_particle_pair(PairContainer self, IMP::kernel::ParticlePair v) -> bool"""
        return _IMP_kernel.PairContainer_get_contains_particle_pair(self, *args)

    def get_number_of_particle_pairs(self):
        """get_number_of_particle_pairs(PairContainer self) -> unsigned int"""
        return _IMP_kernel.PairContainer_get_number_of_particle_pairs(self)

    def get_particle_pair(self, *args):
        """get_particle_pair(PairContainer self, unsigned int i) -> IMP::kernel::ParticlePair"""
        return _IMP_kernel.PairContainer_get_particle_pair(self, *args)

    def do_apply(self, *args):
        """do_apply(PairContainer self, PairModifier sm)"""
        return _IMP_kernel.PairContainer_do_apply(self, *args)

    def do_get_provides_access(self):
        """do_get_provides_access(PairContainer self) -> bool"""
        return _IMP_kernel.PairContainer_do_get_provides_access(self)

    __swig_destroy__ = _IMP_kernel.delete_PairContainer
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(PairContainer self) -> std::string"""
        return _IMP_kernel.PairContainer___str__(self)

    def __repr__(self):
        """__repr__(PairContainer self) -> std::string"""
        return _IMP_kernel.PairContainer___repr__(self)

    def get_from(o):
       return _object_cast_to_PairContainer(o)
    get_from = staticmethod(get_from)

    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::kernel" == "IMP":
          return VersionInfo("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_PairContainer(o)
    get_from = staticmethod(get_from)

    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_PairContainer(self)
        return weakref_proxy(self)
    def update_dependencies(self):
        """update_dependencies(PairContainer self)"""
        return _IMP_kernel.PairContainer_update_dependencies(self)

    def do_get_inputs(self):
        """do_get_inputs(PairContainer self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.PairContainer_do_get_inputs(self)

    def do_get_interactions(self):
        """do_get_interactions(PairContainer self) -> IMP::kernel::ModelObjectsTemps"""
        return _IMP_kernel.PairContainer_do_get_interactions(self)

    def do_before_evaluate(self):
        """do_before_evaluate(PairContainer self)"""
        return _IMP_kernel.PairContainer_do_before_evaluate(self)

    def do_update_dependencies(self):
        """do_update_dependencies(PairContainer self)"""
        return _IMP_kernel.PairContainer_do_update_dependencies(self)

PairContainer_swigregister = _IMP_kernel.PairContainer_swigregister
PairContainer_swigregister(PairContainer)

class _PairContainerAdaptor(IMP.base._InputAdaptor):
    """Proxy of C++ IMP::kernel::PairContainerAdaptor class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base._InputAdaptor]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _PairContainerAdaptor, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base._InputAdaptor]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _PairContainerAdaptor, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::PairContainerAdaptor self) -> _PairContainerAdaptor
        __init__(IMP::kernel::PairContainerAdaptor self, PairContainer c) -> _PairContainerAdaptor
        __init__(IMP::kernel::PairContainerAdaptor self, IMP::kernel::ParticlePairsTemp const & t, std::string name="PairContainerAdaptor%1%") -> _PairContainerAdaptor
        __init__(IMP::kernel::PairContainerAdaptor self, IMP::kernel::ParticlePairsTemp const & t) -> _PairContainerAdaptor
        """
        this = _IMP_kernel.new__PairContainerAdaptor(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _IMP_kernel.delete__PairContainerAdaptor
    __del__ = lambda self : None;
_PairContainerAdaptor_swigregister = _IMP_kernel._PairContainerAdaptor_swigregister
_PairContainerAdaptor_swigregister(_PairContainerAdaptor)

class QuadModifier(IMP.base.Object):
    """Proxy of C++ IMP::kernel::QuadModifier class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, QuadModifier, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, QuadModifier, name)
    def __init__(self, name="QuadModifier %1%"): 
        """
        __init__(IMP::kernel::QuadModifier self, std::string name="QuadModifier %1%") -> QuadModifier
        __init__(IMP::kernel::QuadModifier self) -> QuadModifier
        """
        if self.__class__ == QuadModifier:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_QuadModifier(_self, name)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != QuadModifier:
            import IMP.base
            IMP.base._director_objects.register(self)



    def apply(self, *args):
        """apply(QuadModifier self, IMP::kernel::ParticleQuad const & arg0)"""
        return _IMP_kernel.QuadModifier_apply(self, *args)

    def apply_index(self, *args):
        """apply_index(QuadModifier self, Model m, IMP::kernel::ParticleIndexQuad const & v)"""
        return _IMP_kernel.QuadModifier_apply_index(self, *args)

    def apply_indexes(self, *args):
        """apply_indexes(QuadModifier self, Model m, IMP::kernel::ParticleIndexQuads const & o, unsigned int lower_bound, unsigned int upper_bound)"""
        return _IMP_kernel.QuadModifier_apply_indexes(self, *args)

    def get_input_particles(self, *args):
        """get_input_particles(QuadModifier self, Particle p) -> IMP::kernel::ParticlesTemp"""
        return _IMP_kernel.QuadModifier_get_input_particles(self, *args)

    def get_input_containers(self, *args):
        """get_input_containers(QuadModifier self, Particle p) -> IMP::kernel::ContainersTemp"""
        return _IMP_kernel.QuadModifier_get_input_containers(self, *args)

    def get_inputs(self, *args):
        """get_inputs(QuadModifier self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.QuadModifier_get_inputs(self, *args)

    def _do_get_inputs(self, *args):
        """_do_get_inputs(QuadModifier self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.QuadModifier__do_get_inputs(self, *args)

    def get_output_particles(self, *args):
        """get_output_particles(QuadModifier self, Particle p) -> IMP::kernel::ParticlesTemp"""
        return _IMP_kernel.QuadModifier_get_output_particles(self, *args)

    def get_output_containers(self, *args):
        """get_output_containers(QuadModifier self, Particle p) -> IMP::kernel::ContainersTemp"""
        return _IMP_kernel.QuadModifier_get_output_containers(self, *args)

    def get_outputs(self, *args):
        """get_outputs(QuadModifier self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.QuadModifier_get_outputs(self, *args)

    def _do_get_outputs(self, *args):
        """_do_get_outputs(QuadModifier self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.QuadModifier__do_get_outputs(self, *args)

    def __str__(self):
        """__str__(QuadModifier self) -> std::string"""
        return _IMP_kernel.QuadModifier___str__(self)

    def __repr__(self):
        """__repr__(QuadModifier self) -> std::string"""
        return _IMP_kernel.QuadModifier___repr__(self)

    def get_from(o):
       return _object_cast_to_QuadModifier(o)
    get_from = staticmethod(get_from)

    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::kernel" == "IMP":
          return VersionInfo("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_QuadModifier(o)
    get_from = staticmethod(get_from)

    __swig_destroy__ = _IMP_kernel.delete_QuadModifier
    __del__ = lambda self : None;
    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_QuadModifier(self)
        return weakref_proxy(self)
QuadModifier_swigregister = _IMP_kernel.QuadModifier_swigregister
QuadModifier_swigregister(QuadModifier)

class QuadScore(IMP.base.Object):
    """Proxy of C++ IMP::kernel::QuadScore class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, QuadScore, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, QuadScore, name)
    def __init__(self, name="QuadScore %1%"): 
        """
        __init__(IMP::kernel::QuadScore self, std::string name="QuadScore %1%") -> QuadScore
        __init__(IMP::kernel::QuadScore self) -> QuadScore
        """
        if self.__class__ == QuadScore:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_QuadScore(_self, name)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != QuadScore:
            import IMP.base
            IMP.base._director_objects.register(self)



    def evaluate(self, *args):
        """evaluate(QuadScore self, IMP::kernel::ParticleQuad const & vt, DerivativeAccumulator da) -> double"""
        return _IMP_kernel.QuadScore_evaluate(self, *args)

    def evaluate_index(self, *args):
        """evaluate_index(QuadScore self, Model m, IMP::kernel::ParticleIndexQuad const & vt, DerivativeAccumulator da) -> double"""
        return _IMP_kernel.QuadScore_evaluate_index(self, *args)

    def evaluate_indexes(self, *args):
        """
        evaluate_indexes(QuadScore self, Model m, IMP::kernel::ParticleIndexQuads const & o, DerivativeAccumulator da, unsigned int lower_bound, 
            unsigned int upper_bound) -> double
        """
        return _IMP_kernel.QuadScore_evaluate_indexes(self, *args)

    def evaluate_if_good_index(self, *args):
        """evaluate_if_good_index(QuadScore self, Model m, IMP::kernel::ParticleIndexQuad const & vt, DerivativeAccumulator da, double max) -> double"""
        return _IMP_kernel.QuadScore_evaluate_if_good_index(self, *args)

    def evaluate_if_good_indexes(self, *args):
        """
        evaluate_if_good_indexes(QuadScore self, Model m, IMP::kernel::ParticleIndexQuads const & o, DerivativeAccumulator da, double max, 
            unsigned int lower_bound, unsigned int upper_bound) -> double
        """
        return _IMP_kernel.QuadScore_evaluate_if_good_indexes(self, *args)

    def create_current_decomposition(self, *args):
        """create_current_decomposition(QuadScore self, Model m, IMP::kernel::ParticleIndexQuad const & vt) -> IMP::kernel::Restraints"""
        return _IMP_kernel.QuadScore_create_current_decomposition(self, *args)

    def get_input_particles(self, *args):
        """get_input_particles(QuadScore self, Particle p) -> IMP::kernel::ParticlesTemp"""
        return _IMP_kernel.QuadScore_get_input_particles(self, *args)

    def get_input_containers(self, *args):
        """get_input_containers(QuadScore self, Particle p) -> IMP::kernel::ContainersTemp"""
        return _IMP_kernel.QuadScore_get_input_containers(self, *args)

    def get_inputs(self, *args):
        """get_inputs(QuadScore self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.QuadScore_get_inputs(self, *args)

    def _do_get_inputs(self, *args):
        """_do_get_inputs(QuadScore self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.QuadScore__do_get_inputs(self, *args)

    def do_create_current_decomposition(self, *args):
        """do_create_current_decomposition(QuadScore self, Model m, IMP::kernel::ParticleIndexQuad const & vt) -> IMP::kernel::Restraints"""
        return _IMP_kernel.QuadScore_do_create_current_decomposition(self, *args)

    __swig_destroy__ = _IMP_kernel.delete_QuadScore
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(QuadScore self) -> std::string"""
        return _IMP_kernel.QuadScore___str__(self)

    def __repr__(self):
        """__repr__(QuadScore self) -> std::string"""
        return _IMP_kernel.QuadScore___repr__(self)

    def get_from(o):
       return _object_cast_to_QuadScore(o)
    get_from = staticmethod(get_from)

    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::kernel" == "IMP":
          return VersionInfo("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_QuadScore(o)
    get_from = staticmethod(get_from)

    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_QuadScore(self)
        return weakref_proxy(self)
QuadScore_swigregister = _IMP_kernel.QuadScore_swigregister
QuadScore_swigregister(QuadScore)

class QuadPredicate(IMP.base.Object):
    """Proxy of C++ IMP::kernel::QuadPredicate class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, QuadPredicate, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, QuadPredicate, name)
    def __init__(self, name="QuadPredicate %1%"): 
        """
        __init__(IMP::kernel::QuadPredicate self, std::string name="QuadPredicate %1%") -> QuadPredicate
        __init__(IMP::kernel::QuadPredicate self) -> QuadPredicate
        """
        if self.__class__ == QuadPredicate:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_QuadPredicate(_self, name)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != QuadPredicate:
            import IMP.base
            IMP.base._director_objects.register(self)



    def get_value(self, *args):
        """
        get_value(QuadPredicate self, IMP::kernel::ParticleQuad const & vt) -> int
        get_value(QuadPredicate self, IMP::kernel::ParticleQuadsTemp const & o) -> IMP::Ints
        """
        return _IMP_kernel.QuadPredicate_get_value(self, *args)

    def __call__(self, *args):
        """__call__(QuadPredicate self, Model m, IMP::kernel::ParticleIndexQuad const & vt) -> int"""
        return _IMP_kernel.QuadPredicate___call__(self, *args)

    def get_value_index(self, *args):
        """
        get_value_index(QuadPredicate self, Model m, IMP::kernel::ParticleIndexQuad const & vt) -> int
        get_value_index(QuadPredicate self, Model m, IMP::kernel::ParticleIndexQuads const & o) -> IMP::Ints
        """
        return _IMP_kernel.QuadPredicate_get_value_index(self, *args)

    def get_input_particles(self, *args):
        """get_input_particles(QuadPredicate self, Particle p) -> IMP::kernel::ParticlesTemp"""
        return _IMP_kernel.QuadPredicate_get_input_particles(self, *args)

    def get_input_containers(self, *args):
        """get_input_containers(QuadPredicate self, Particle p) -> IMP::kernel::ContainersTemp"""
        return _IMP_kernel.QuadPredicate_get_input_containers(self, *args)

    def get_inputs(self, *args):
        """get_inputs(QuadPredicate self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.QuadPredicate_get_inputs(self, *args)

    def _do_get_inputs(self, *args):
        """_do_get_inputs(QuadPredicate self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.QuadPredicate__do_get_inputs(self, *args)

    __swig_destroy__ = _IMP_kernel.delete_QuadPredicate
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(QuadPredicate self) -> std::string"""
        return _IMP_kernel.QuadPredicate___str__(self)

    def __repr__(self):
        """__repr__(QuadPredicate self) -> std::string"""
        return _IMP_kernel.QuadPredicate___repr__(self)

    def get_from(o):
       return _object_cast_to_QuadPredicate(o)
    get_from = staticmethod(get_from)

    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::kernel" == "IMP":
          return VersionInfo("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_QuadPredicate(o)
    get_from = staticmethod(get_from)

    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_QuadPredicate(self)
        return weakref_proxy(self)
QuadPredicate_swigregister = _IMP_kernel.QuadPredicate_swigregister
QuadPredicate_swigregister(QuadPredicate)

class QuadContainer(Container):
    """Proxy of C++ IMP::kernel::QuadContainer class"""
    __swig_setmethods__ = {}
    for _s in [Container]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, QuadContainer, name, value)
    __swig_getmethods__ = {}
    for _s in [Container]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, QuadContainer, name)
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::QuadContainer self, Model m, std::string name="QuadContainer %1%") -> QuadContainer
        __init__(IMP::kernel::QuadContainer self, Model m) -> QuadContainer
        """
        if self.__class__ == QuadContainer:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_QuadContainer(_self, *args)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != QuadContainer:
            import IMP.base
            IMP.base._director_objects.register(self)



    def apply_generic(self, *args):
        """apply_generic(QuadContainer self, QuadModifier m)"""
        return _IMP_kernel.QuadContainer_apply_generic(self, *args)

    def apply(self, *args):
        """apply(QuadContainer self, QuadModifier sm)"""
        return _IMP_kernel.QuadContainer_apply(self, *args)

    def get_indexes(self):
        """get_indexes(QuadContainer self) -> IMP::kernel::ParticleIndexQuads"""
        return _IMP_kernel.QuadContainer_get_indexes(self)

    def get_range_indexes(self):
        """get_range_indexes(QuadContainer self) -> IMP::kernel::ParticleIndexQuads"""
        return _IMP_kernel.QuadContainer_get_range_indexes(self)

    def get(self, *args):
        """
        get(QuadContainer self) -> IMP::kernel::ParticleQuadsTemp
        get(QuadContainer self, unsigned int i) -> IMP::kernel::ParticleQuad
        """
        return _IMP_kernel.QuadContainer_get(self, *args)

    def get_number(self):
        """get_number(QuadContainer self) -> unsigned int"""
        return _IMP_kernel.QuadContainer_get_number(self)

    def get_particle_quads(self):
        """get_particle_quads(QuadContainer self) -> IMP::kernel::ParticleQuadsTemp"""
        return _IMP_kernel.QuadContainer_get_particle_quads(self)

    def get_contains_particle_quad(self, *args):
        """get_contains_particle_quad(QuadContainer self, IMP::kernel::ParticleQuad v) -> bool"""
        return _IMP_kernel.QuadContainer_get_contains_particle_quad(self, *args)

    def get_number_of_particle_quads(self):
        """get_number_of_particle_quads(QuadContainer self) -> unsigned int"""
        return _IMP_kernel.QuadContainer_get_number_of_particle_quads(self)

    def get_particle_quad(self, *args):
        """get_particle_quad(QuadContainer self, unsigned int i) -> IMP::kernel::ParticleQuad"""
        return _IMP_kernel.QuadContainer_get_particle_quad(self, *args)

    def do_apply(self, *args):
        """do_apply(QuadContainer self, QuadModifier sm)"""
        return _IMP_kernel.QuadContainer_do_apply(self, *args)

    def do_get_provides_access(self):
        """do_get_provides_access(QuadContainer self) -> bool"""
        return _IMP_kernel.QuadContainer_do_get_provides_access(self)

    __swig_destroy__ = _IMP_kernel.delete_QuadContainer
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(QuadContainer self) -> std::string"""
        return _IMP_kernel.QuadContainer___str__(self)

    def __repr__(self):
        """__repr__(QuadContainer self) -> std::string"""
        return _IMP_kernel.QuadContainer___repr__(self)

    def get_from(o):
       return _object_cast_to_QuadContainer(o)
    get_from = staticmethod(get_from)

    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::kernel" == "IMP":
          return VersionInfo("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_QuadContainer(o)
    get_from = staticmethod(get_from)

    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_QuadContainer(self)
        return weakref_proxy(self)
    def update_dependencies(self):
        """update_dependencies(QuadContainer self)"""
        return _IMP_kernel.QuadContainer_update_dependencies(self)

    def do_get_inputs(self):
        """do_get_inputs(QuadContainer self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.QuadContainer_do_get_inputs(self)

    def do_get_interactions(self):
        """do_get_interactions(QuadContainer self) -> IMP::kernel::ModelObjectsTemps"""
        return _IMP_kernel.QuadContainer_do_get_interactions(self)

    def do_before_evaluate(self):
        """do_before_evaluate(QuadContainer self)"""
        return _IMP_kernel.QuadContainer_do_before_evaluate(self)

    def do_update_dependencies(self):
        """do_update_dependencies(QuadContainer self)"""
        return _IMP_kernel.QuadContainer_do_update_dependencies(self)

QuadContainer_swigregister = _IMP_kernel.QuadContainer_swigregister
QuadContainer_swigregister(QuadContainer)

class _QuadContainerAdaptor(IMP.base._InputAdaptor):
    """Proxy of C++ IMP::kernel::QuadContainerAdaptor class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base._InputAdaptor]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _QuadContainerAdaptor, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base._InputAdaptor]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _QuadContainerAdaptor, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::QuadContainerAdaptor self) -> _QuadContainerAdaptor
        __init__(IMP::kernel::QuadContainerAdaptor self, QuadContainer c) -> _QuadContainerAdaptor
        __init__(IMP::kernel::QuadContainerAdaptor self, IMP::kernel::ParticleQuadsTemp const & t, std::string name="QuadContainerAdaptor%1%") -> _QuadContainerAdaptor
        __init__(IMP::kernel::QuadContainerAdaptor self, IMP::kernel::ParticleQuadsTemp const & t) -> _QuadContainerAdaptor
        """
        this = _IMP_kernel.new__QuadContainerAdaptor(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _IMP_kernel.delete__QuadContainerAdaptor
    __del__ = lambda self : None;
_QuadContainerAdaptor_swigregister = _IMP_kernel._QuadContainerAdaptor_swigregister
_QuadContainerAdaptor_swigregister(_QuadContainerAdaptor)

class SingletonModifier(IMP.base.Object):
    """Proxy of C++ IMP::kernel::SingletonModifier class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SingletonModifier, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SingletonModifier, name)
    def __init__(self, name="SingletonModifier %1%"): 
        """
        __init__(IMP::kernel::SingletonModifier self, std::string name="SingletonModifier %1%") -> SingletonModifier
        __init__(IMP::kernel::SingletonModifier self) -> SingletonModifier
        """
        if self.__class__ == SingletonModifier:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_SingletonModifier(_self, name)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != SingletonModifier:
            import IMP.base
            IMP.base._director_objects.register(self)



    def apply(self, *args):
        """apply(SingletonModifier self, Particle arg0)"""
        return _IMP_kernel.SingletonModifier_apply(self, *args)

    def apply_index(self, *args):
        """apply_index(SingletonModifier self, Model m, IMP::kernel::ParticleIndex v)"""
        return _IMP_kernel.SingletonModifier_apply_index(self, *args)

    def apply_indexes(self, *args):
        """apply_indexes(SingletonModifier self, Model m, IMP::kernel::ParticleIndexes const & o, unsigned int lower_bound, unsigned int upper_bound)"""
        return _IMP_kernel.SingletonModifier_apply_indexes(self, *args)

    def get_input_particles(self, *args):
        """get_input_particles(SingletonModifier self, Particle p) -> IMP::kernel::ParticlesTemp"""
        return _IMP_kernel.SingletonModifier_get_input_particles(self, *args)

    def get_input_containers(self, *args):
        """get_input_containers(SingletonModifier self, Particle p) -> IMP::kernel::ContainersTemp"""
        return _IMP_kernel.SingletonModifier_get_input_containers(self, *args)

    def get_inputs(self, *args):
        """get_inputs(SingletonModifier self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.SingletonModifier_get_inputs(self, *args)

    def _do_get_inputs(self, *args):
        """_do_get_inputs(SingletonModifier self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.SingletonModifier__do_get_inputs(self, *args)

    def get_output_particles(self, *args):
        """get_output_particles(SingletonModifier self, Particle p) -> IMP::kernel::ParticlesTemp"""
        return _IMP_kernel.SingletonModifier_get_output_particles(self, *args)

    def get_output_containers(self, *args):
        """get_output_containers(SingletonModifier self, Particle p) -> IMP::kernel::ContainersTemp"""
        return _IMP_kernel.SingletonModifier_get_output_containers(self, *args)

    def get_outputs(self, *args):
        """get_outputs(SingletonModifier self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.SingletonModifier_get_outputs(self, *args)

    def _do_get_outputs(self, *args):
        """_do_get_outputs(SingletonModifier self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.SingletonModifier__do_get_outputs(self, *args)

    def __str__(self):
        """__str__(SingletonModifier self) -> std::string"""
        return _IMP_kernel.SingletonModifier___str__(self)

    def __repr__(self):
        """__repr__(SingletonModifier self) -> std::string"""
        return _IMP_kernel.SingletonModifier___repr__(self)

    def get_from(o):
       return _object_cast_to_SingletonModifier(o)
    get_from = staticmethod(get_from)

    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::kernel" == "IMP":
          return VersionInfo("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_SingletonModifier(o)
    get_from = staticmethod(get_from)

    __swig_destroy__ = _IMP_kernel.delete_SingletonModifier
    __del__ = lambda self : None;
    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_SingletonModifier(self)
        return weakref_proxy(self)
SingletonModifier_swigregister = _IMP_kernel.SingletonModifier_swigregister
SingletonModifier_swigregister(SingletonModifier)

class SingletonScore(IMP.base.Object):
    """Proxy of C++ IMP::kernel::SingletonScore class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SingletonScore, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SingletonScore, name)
    def __init__(self, name="SingletonScore %1%"): 
        """
        __init__(IMP::kernel::SingletonScore self, std::string name="SingletonScore %1%") -> SingletonScore
        __init__(IMP::kernel::SingletonScore self) -> SingletonScore
        """
        if self.__class__ == SingletonScore:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_SingletonScore(_self, name)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != SingletonScore:
            import IMP.base
            IMP.base._director_objects.register(self)



    def evaluate(self, *args):
        """evaluate(SingletonScore self, Particle vt, DerivativeAccumulator da) -> double"""
        return _IMP_kernel.SingletonScore_evaluate(self, *args)

    def evaluate_index(self, *args):
        """evaluate_index(SingletonScore self, Model m, IMP::kernel::ParticleIndex vt, DerivativeAccumulator da) -> double"""
        return _IMP_kernel.SingletonScore_evaluate_index(self, *args)

    def evaluate_indexes(self, *args):
        """
        evaluate_indexes(SingletonScore self, Model m, IMP::kernel::ParticleIndexes const & o, DerivativeAccumulator da, unsigned int lower_bound, 
            unsigned int upper_bound) -> double
        """
        return _IMP_kernel.SingletonScore_evaluate_indexes(self, *args)

    def evaluate_if_good_index(self, *args):
        """evaluate_if_good_index(SingletonScore self, Model m, IMP::kernel::ParticleIndex vt, DerivativeAccumulator da, double max) -> double"""
        return _IMP_kernel.SingletonScore_evaluate_if_good_index(self, *args)

    def evaluate_if_good_indexes(self, *args):
        """
        evaluate_if_good_indexes(SingletonScore self, Model m, IMP::kernel::ParticleIndexes const & o, DerivativeAccumulator da, double max, 
            unsigned int lower_bound, unsigned int upper_bound) -> double
        """
        return _IMP_kernel.SingletonScore_evaluate_if_good_indexes(self, *args)

    def create_current_decomposition(self, *args):
        """create_current_decomposition(SingletonScore self, Model m, IMP::kernel::ParticleIndex vt) -> IMP::kernel::Restraints"""
        return _IMP_kernel.SingletonScore_create_current_decomposition(self, *args)

    def get_input_particles(self, *args):
        """get_input_particles(SingletonScore self, Particle p) -> IMP::kernel::ParticlesTemp"""
        return _IMP_kernel.SingletonScore_get_input_particles(self, *args)

    def get_input_containers(self, *args):
        """get_input_containers(SingletonScore self, Particle p) -> IMP::kernel::ContainersTemp"""
        return _IMP_kernel.SingletonScore_get_input_containers(self, *args)

    def get_inputs(self, *args):
        """get_inputs(SingletonScore self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.SingletonScore_get_inputs(self, *args)

    def _do_get_inputs(self, *args):
        """_do_get_inputs(SingletonScore self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.SingletonScore__do_get_inputs(self, *args)

    def do_create_current_decomposition(self, *args):
        """do_create_current_decomposition(SingletonScore self, Model m, IMP::kernel::ParticleIndex vt) -> IMP::kernel::Restraints"""
        return _IMP_kernel.SingletonScore_do_create_current_decomposition(self, *args)

    __swig_destroy__ = _IMP_kernel.delete_SingletonScore
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(SingletonScore self) -> std::string"""
        return _IMP_kernel.SingletonScore___str__(self)

    def __repr__(self):
        """__repr__(SingletonScore self) -> std::string"""
        return _IMP_kernel.SingletonScore___repr__(self)

    def get_from(o):
       return _object_cast_to_SingletonScore(o)
    get_from = staticmethod(get_from)

    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::kernel" == "IMP":
          return VersionInfo("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_SingletonScore(o)
    get_from = staticmethod(get_from)

    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_SingletonScore(self)
        return weakref_proxy(self)
SingletonScore_swigregister = _IMP_kernel.SingletonScore_swigregister
SingletonScore_swigregister(SingletonScore)

class SingletonPredicate(IMP.base.Object):
    """Proxy of C++ IMP::kernel::SingletonPredicate class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SingletonPredicate, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SingletonPredicate, name)
    def __init__(self, name="SingletonPredicate %1%"): 
        """
        __init__(IMP::kernel::SingletonPredicate self, std::string name="SingletonPredicate %1%") -> SingletonPredicate
        __init__(IMP::kernel::SingletonPredicate self) -> SingletonPredicate
        """
        if self.__class__ == SingletonPredicate:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_SingletonPredicate(_self, name)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != SingletonPredicate:
            import IMP.base
            IMP.base._director_objects.register(self)



    def get_value(self, *args):
        """
        get_value(SingletonPredicate self, Particle vt) -> int
        get_value(SingletonPredicate self, IMP::kernel::ParticlesTemp const & o) -> IMP::Ints
        """
        return _IMP_kernel.SingletonPredicate_get_value(self, *args)

    def __call__(self, *args):
        """__call__(SingletonPredicate self, Model m, IMP::kernel::ParticleIndex vt) -> int"""
        return _IMP_kernel.SingletonPredicate___call__(self, *args)

    def get_value_index(self, *args):
        """
        get_value_index(SingletonPredicate self, Model m, IMP::kernel::ParticleIndex vt) -> int
        get_value_index(SingletonPredicate self, Model m, IMP::kernel::ParticleIndexes const & o) -> IMP::Ints
        """
        return _IMP_kernel.SingletonPredicate_get_value_index(self, *args)

    def get_input_particles(self, *args):
        """get_input_particles(SingletonPredicate self, Particle p) -> IMP::kernel::ParticlesTemp"""
        return _IMP_kernel.SingletonPredicate_get_input_particles(self, *args)

    def get_input_containers(self, *args):
        """get_input_containers(SingletonPredicate self, Particle p) -> IMP::kernel::ContainersTemp"""
        return _IMP_kernel.SingletonPredicate_get_input_containers(self, *args)

    def get_inputs(self, *args):
        """get_inputs(SingletonPredicate self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.SingletonPredicate_get_inputs(self, *args)

    def _do_get_inputs(self, *args):
        """_do_get_inputs(SingletonPredicate self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.SingletonPredicate__do_get_inputs(self, *args)

    __swig_destroy__ = _IMP_kernel.delete_SingletonPredicate
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(SingletonPredicate self) -> std::string"""
        return _IMP_kernel.SingletonPredicate___str__(self)

    def __repr__(self):
        """__repr__(SingletonPredicate self) -> std::string"""
        return _IMP_kernel.SingletonPredicate___repr__(self)

    def get_from(o):
       return _object_cast_to_SingletonPredicate(o)
    get_from = staticmethod(get_from)

    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::kernel" == "IMP":
          return VersionInfo("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_SingletonPredicate(o)
    get_from = staticmethod(get_from)

    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_SingletonPredicate(self)
        return weakref_proxy(self)
SingletonPredicate_swigregister = _IMP_kernel.SingletonPredicate_swigregister
SingletonPredicate_swigregister(SingletonPredicate)

class SingletonContainer(Container):
    """Proxy of C++ IMP::kernel::SingletonContainer class"""
    __swig_setmethods__ = {}
    for _s in [Container]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SingletonContainer, name, value)
    __swig_getmethods__ = {}
    for _s in [Container]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SingletonContainer, name)
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::SingletonContainer self, Model m, std::string name="SingletonContainer %1%") -> SingletonContainer
        __init__(IMP::kernel::SingletonContainer self, Model m) -> SingletonContainer
        """
        if self.__class__ == SingletonContainer:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_SingletonContainer(_self, *args)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != SingletonContainer:
            import IMP.base
            IMP.base._director_objects.register(self)



    def apply_generic(self, *args):
        """apply_generic(SingletonContainer self, SingletonModifier m)"""
        return _IMP_kernel.SingletonContainer_apply_generic(self, *args)

    def apply(self, *args):
        """apply(SingletonContainer self, SingletonModifier sm)"""
        return _IMP_kernel.SingletonContainer_apply(self, *args)

    def get_indexes(self):
        """get_indexes(SingletonContainer self) -> IMP::kernel::ParticleIndexes"""
        return _IMP_kernel.SingletonContainer_get_indexes(self)

    def get_range_indexes(self):
        """get_range_indexes(SingletonContainer self) -> IMP::kernel::ParticleIndexes"""
        return _IMP_kernel.SingletonContainer_get_range_indexes(self)

    def get(self, *args):
        """
        get(SingletonContainer self) -> IMP::kernel::ParticlesTemp
        get(SingletonContainer self, unsigned int i) -> Particle
        """
        return _IMP_kernel.SingletonContainer_get(self, *args)

    def get_number(self):
        """get_number(SingletonContainer self) -> unsigned int"""
        return _IMP_kernel.SingletonContainer_get_number(self)

    def get_particles(self):
        """get_particles(SingletonContainer self) -> IMP::kernel::ParticlesTemp"""
        return _IMP_kernel.SingletonContainer_get_particles(self)

    def get_contains_particle(self, *args):
        """get_contains_particle(SingletonContainer self, Particle v) -> bool"""
        return _IMP_kernel.SingletonContainer_get_contains_particle(self, *args)

    def get_number_of_particles(self):
        """get_number_of_particles(SingletonContainer self) -> unsigned int"""
        return _IMP_kernel.SingletonContainer_get_number_of_particles(self)

    def get_particle(self, *args):
        """get_particle(SingletonContainer self, unsigned int i) -> Particle"""
        return _IMP_kernel.SingletonContainer_get_particle(self, *args)

    def do_apply(self, *args):
        """do_apply(SingletonContainer self, SingletonModifier sm)"""
        return _IMP_kernel.SingletonContainer_do_apply(self, *args)

    def do_get_provides_access(self):
        """do_get_provides_access(SingletonContainer self) -> bool"""
        return _IMP_kernel.SingletonContainer_do_get_provides_access(self)

    __swig_destroy__ = _IMP_kernel.delete_SingletonContainer
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(SingletonContainer self) -> std::string"""
        return _IMP_kernel.SingletonContainer___str__(self)

    def __repr__(self):
        """__repr__(SingletonContainer self) -> std::string"""
        return _IMP_kernel.SingletonContainer___repr__(self)

    def get_from(o):
       return _object_cast_to_SingletonContainer(o)
    get_from = staticmethod(get_from)

    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::kernel" == "IMP":
          return VersionInfo("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_SingletonContainer(o)
    get_from = staticmethod(get_from)

    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_SingletonContainer(self)
        return weakref_proxy(self)
    def update_dependencies(self):
        """update_dependencies(SingletonContainer self)"""
        return _IMP_kernel.SingletonContainer_update_dependencies(self)

    def do_get_inputs(self):
        """do_get_inputs(SingletonContainer self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.SingletonContainer_do_get_inputs(self)

    def do_get_interactions(self):
        """do_get_interactions(SingletonContainer self) -> IMP::kernel::ModelObjectsTemps"""
        return _IMP_kernel.SingletonContainer_do_get_interactions(self)

    def do_before_evaluate(self):
        """do_before_evaluate(SingletonContainer self)"""
        return _IMP_kernel.SingletonContainer_do_before_evaluate(self)

    def do_update_dependencies(self):
        """do_update_dependencies(SingletonContainer self)"""
        return _IMP_kernel.SingletonContainer_do_update_dependencies(self)

SingletonContainer_swigregister = _IMP_kernel.SingletonContainer_swigregister
SingletonContainer_swigregister(SingletonContainer)

class _SingletonContainerAdaptor(IMP.base._InputAdaptor):
    """Proxy of C++ IMP::kernel::SingletonContainerAdaptor class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base._InputAdaptor]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _SingletonContainerAdaptor, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base._InputAdaptor]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _SingletonContainerAdaptor, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::SingletonContainerAdaptor self) -> _SingletonContainerAdaptor
        __init__(IMP::kernel::SingletonContainerAdaptor self, SingletonContainer c) -> _SingletonContainerAdaptor
        __init__(IMP::kernel::SingletonContainerAdaptor self, IMP::kernel::ParticlesTemp const & t, std::string name="SingletonContainerAdaptor%1%") -> _SingletonContainerAdaptor
        __init__(IMP::kernel::SingletonContainerAdaptor self, IMP::kernel::ParticlesTemp const & t) -> _SingletonContainerAdaptor
        """
        this = _IMP_kernel.new__SingletonContainerAdaptor(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _IMP_kernel.delete__SingletonContainerAdaptor
    __del__ = lambda self : None;
_SingletonContainerAdaptor_swigregister = _IMP_kernel._SingletonContainerAdaptor_swigregister
_SingletonContainerAdaptor_swigregister(_SingletonContainerAdaptor)

class TripletModifier(IMP.base.Object):
    """Proxy of C++ IMP::kernel::TripletModifier class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TripletModifier, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TripletModifier, name)
    def __init__(self, name="TripletModifier %1%"): 
        """
        __init__(IMP::kernel::TripletModifier self, std::string name="TripletModifier %1%") -> TripletModifier
        __init__(IMP::kernel::TripletModifier self) -> TripletModifier
        """
        if self.__class__ == TripletModifier:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_TripletModifier(_self, name)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != TripletModifier:
            import IMP.base
            IMP.base._director_objects.register(self)



    def apply(self, *args):
        """apply(TripletModifier self, IMP::kernel::ParticleTriplet const & arg0)"""
        return _IMP_kernel.TripletModifier_apply(self, *args)

    def apply_index(self, *args):
        """apply_index(TripletModifier self, Model m, IMP::kernel::ParticleIndexTriplet const & v)"""
        return _IMP_kernel.TripletModifier_apply_index(self, *args)

    def apply_indexes(self, *args):
        """
        apply_indexes(TripletModifier self, Model m, IMP::kernel::ParticleIndexTriplets const & o, unsigned int lower_bound, 
            unsigned int upper_bound)
        """
        return _IMP_kernel.TripletModifier_apply_indexes(self, *args)

    def get_input_particles(self, *args):
        """get_input_particles(TripletModifier self, Particle p) -> IMP::kernel::ParticlesTemp"""
        return _IMP_kernel.TripletModifier_get_input_particles(self, *args)

    def get_input_containers(self, *args):
        """get_input_containers(TripletModifier self, Particle p) -> IMP::kernel::ContainersTemp"""
        return _IMP_kernel.TripletModifier_get_input_containers(self, *args)

    def get_inputs(self, *args):
        """get_inputs(TripletModifier self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.TripletModifier_get_inputs(self, *args)

    def _do_get_inputs(self, *args):
        """_do_get_inputs(TripletModifier self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.TripletModifier__do_get_inputs(self, *args)

    def get_output_particles(self, *args):
        """get_output_particles(TripletModifier self, Particle p) -> IMP::kernel::ParticlesTemp"""
        return _IMP_kernel.TripletModifier_get_output_particles(self, *args)

    def get_output_containers(self, *args):
        """get_output_containers(TripletModifier self, Particle p) -> IMP::kernel::ContainersTemp"""
        return _IMP_kernel.TripletModifier_get_output_containers(self, *args)

    def get_outputs(self, *args):
        """get_outputs(TripletModifier self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.TripletModifier_get_outputs(self, *args)

    def _do_get_outputs(self, *args):
        """_do_get_outputs(TripletModifier self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.TripletModifier__do_get_outputs(self, *args)

    def __str__(self):
        """__str__(TripletModifier self) -> std::string"""
        return _IMP_kernel.TripletModifier___str__(self)

    def __repr__(self):
        """__repr__(TripletModifier self) -> std::string"""
        return _IMP_kernel.TripletModifier___repr__(self)

    def get_from(o):
       return _object_cast_to_TripletModifier(o)
    get_from = staticmethod(get_from)

    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::kernel" == "IMP":
          return VersionInfo("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_TripletModifier(o)
    get_from = staticmethod(get_from)

    __swig_destroy__ = _IMP_kernel.delete_TripletModifier
    __del__ = lambda self : None;
    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_TripletModifier(self)
        return weakref_proxy(self)
TripletModifier_swigregister = _IMP_kernel.TripletModifier_swigregister
TripletModifier_swigregister(TripletModifier)

class TripletScore(IMP.base.Object):
    """Proxy of C++ IMP::kernel::TripletScore class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TripletScore, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TripletScore, name)
    def __init__(self, name="TripletScore %1%"): 
        """
        __init__(IMP::kernel::TripletScore self, std::string name="TripletScore %1%") -> TripletScore
        __init__(IMP::kernel::TripletScore self) -> TripletScore
        """
        if self.__class__ == TripletScore:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_TripletScore(_self, name)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != TripletScore:
            import IMP.base
            IMP.base._director_objects.register(self)



    def evaluate(self, *args):
        """evaluate(TripletScore self, IMP::kernel::ParticleTriplet const & vt, DerivativeAccumulator da) -> double"""
        return _IMP_kernel.TripletScore_evaluate(self, *args)

    def evaluate_index(self, *args):
        """evaluate_index(TripletScore self, Model m, IMP::kernel::ParticleIndexTriplet const & vt, DerivativeAccumulator da) -> double"""
        return _IMP_kernel.TripletScore_evaluate_index(self, *args)

    def evaluate_indexes(self, *args):
        """
        evaluate_indexes(TripletScore self, Model m, IMP::kernel::ParticleIndexTriplets const & o, DerivativeAccumulator da, 
            unsigned int lower_bound, unsigned int upper_bound) -> double
        """
        return _IMP_kernel.TripletScore_evaluate_indexes(self, *args)

    def evaluate_if_good_index(self, *args):
        """
        evaluate_if_good_index(TripletScore self, Model m, IMP::kernel::ParticleIndexTriplet const & vt, DerivativeAccumulator da, 
            double max) -> double
        """
        return _IMP_kernel.TripletScore_evaluate_if_good_index(self, *args)

    def evaluate_if_good_indexes(self, *args):
        """
        evaluate_if_good_indexes(TripletScore self, Model m, IMP::kernel::ParticleIndexTriplets const & o, DerivativeAccumulator da, 
            double max, unsigned int lower_bound, unsigned int upper_bound) -> double
        """
        return _IMP_kernel.TripletScore_evaluate_if_good_indexes(self, *args)

    def create_current_decomposition(self, *args):
        """create_current_decomposition(TripletScore self, Model m, IMP::kernel::ParticleIndexTriplet const & vt) -> IMP::kernel::Restraints"""
        return _IMP_kernel.TripletScore_create_current_decomposition(self, *args)

    def get_input_particles(self, *args):
        """get_input_particles(TripletScore self, Particle p) -> IMP::kernel::ParticlesTemp"""
        return _IMP_kernel.TripletScore_get_input_particles(self, *args)

    def get_input_containers(self, *args):
        """get_input_containers(TripletScore self, Particle p) -> IMP::kernel::ContainersTemp"""
        return _IMP_kernel.TripletScore_get_input_containers(self, *args)

    def get_inputs(self, *args):
        """get_inputs(TripletScore self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.TripletScore_get_inputs(self, *args)

    def _do_get_inputs(self, *args):
        """_do_get_inputs(TripletScore self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.TripletScore__do_get_inputs(self, *args)

    def do_create_current_decomposition(self, *args):
        """do_create_current_decomposition(TripletScore self, Model m, IMP::kernel::ParticleIndexTriplet const & vt) -> IMP::kernel::Restraints"""
        return _IMP_kernel.TripletScore_do_create_current_decomposition(self, *args)

    __swig_destroy__ = _IMP_kernel.delete_TripletScore
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(TripletScore self) -> std::string"""
        return _IMP_kernel.TripletScore___str__(self)

    def __repr__(self):
        """__repr__(TripletScore self) -> std::string"""
        return _IMP_kernel.TripletScore___repr__(self)

    def get_from(o):
       return _object_cast_to_TripletScore(o)
    get_from = staticmethod(get_from)

    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::kernel" == "IMP":
          return VersionInfo("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_TripletScore(o)
    get_from = staticmethod(get_from)

    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_TripletScore(self)
        return weakref_proxy(self)
TripletScore_swigregister = _IMP_kernel.TripletScore_swigregister
TripletScore_swigregister(TripletScore)

class TripletPredicate(IMP.base.Object):
    """Proxy of C++ IMP::kernel::TripletPredicate class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TripletPredicate, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TripletPredicate, name)
    def __init__(self, name="TripletPredicate %1%"): 
        """
        __init__(IMP::kernel::TripletPredicate self, std::string name="TripletPredicate %1%") -> TripletPredicate
        __init__(IMP::kernel::TripletPredicate self) -> TripletPredicate
        """
        if self.__class__ == TripletPredicate:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_TripletPredicate(_self, name)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != TripletPredicate:
            import IMP.base
            IMP.base._director_objects.register(self)



    def get_value(self, *args):
        """
        get_value(TripletPredicate self, IMP::kernel::ParticleTriplet const & vt) -> int
        get_value(TripletPredicate self, IMP::kernel::ParticleTripletsTemp const & o) -> IMP::Ints
        """
        return _IMP_kernel.TripletPredicate_get_value(self, *args)

    def __call__(self, *args):
        """__call__(TripletPredicate self, Model m, IMP::kernel::ParticleIndexTriplet const & vt) -> int"""
        return _IMP_kernel.TripletPredicate___call__(self, *args)

    def get_value_index(self, *args):
        """
        get_value_index(TripletPredicate self, Model m, IMP::kernel::ParticleIndexTriplet const & vt) -> int
        get_value_index(TripletPredicate self, Model m, IMP::kernel::ParticleIndexTriplets const & o) -> IMP::Ints
        """
        return _IMP_kernel.TripletPredicate_get_value_index(self, *args)

    def get_input_particles(self, *args):
        """get_input_particles(TripletPredicate self, Particle p) -> IMP::kernel::ParticlesTemp"""
        return _IMP_kernel.TripletPredicate_get_input_particles(self, *args)

    def get_input_containers(self, *args):
        """get_input_containers(TripletPredicate self, Particle p) -> IMP::kernel::ContainersTemp"""
        return _IMP_kernel.TripletPredicate_get_input_containers(self, *args)

    def get_inputs(self, *args):
        """get_inputs(TripletPredicate self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.TripletPredicate_get_inputs(self, *args)

    def _do_get_inputs(self, *args):
        """_do_get_inputs(TripletPredicate self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.TripletPredicate__do_get_inputs(self, *args)

    __swig_destroy__ = _IMP_kernel.delete_TripletPredicate
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(TripletPredicate self) -> std::string"""
        return _IMP_kernel.TripletPredicate___str__(self)

    def __repr__(self):
        """__repr__(TripletPredicate self) -> std::string"""
        return _IMP_kernel.TripletPredicate___repr__(self)

    def get_from(o):
       return _object_cast_to_TripletPredicate(o)
    get_from = staticmethod(get_from)

    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::kernel" == "IMP":
          return VersionInfo("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_TripletPredicate(o)
    get_from = staticmethod(get_from)

    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_TripletPredicate(self)
        return weakref_proxy(self)
TripletPredicate_swigregister = _IMP_kernel.TripletPredicate_swigregister
TripletPredicate_swigregister(TripletPredicate)

class TripletContainer(Container):
    """Proxy of C++ IMP::kernel::TripletContainer class"""
    __swig_setmethods__ = {}
    for _s in [Container]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TripletContainer, name, value)
    __swig_getmethods__ = {}
    for _s in [Container]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TripletContainer, name)
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::TripletContainer self, Model m, std::string name="TripletContainer %1%") -> TripletContainer
        __init__(IMP::kernel::TripletContainer self, Model m) -> TripletContainer
        """
        if self.__class__ == TripletContainer:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_TripletContainer(_self, *args)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != TripletContainer:
            import IMP.base
            IMP.base._director_objects.register(self)



    def apply_generic(self, *args):
        """apply_generic(TripletContainer self, TripletModifier m)"""
        return _IMP_kernel.TripletContainer_apply_generic(self, *args)

    def apply(self, *args):
        """apply(TripletContainer self, TripletModifier sm)"""
        return _IMP_kernel.TripletContainer_apply(self, *args)

    def get_indexes(self):
        """get_indexes(TripletContainer self) -> IMP::kernel::ParticleIndexTriplets"""
        return _IMP_kernel.TripletContainer_get_indexes(self)

    def get_range_indexes(self):
        """get_range_indexes(TripletContainer self) -> IMP::kernel::ParticleIndexTriplets"""
        return _IMP_kernel.TripletContainer_get_range_indexes(self)

    def get(self, *args):
        """
        get(TripletContainer self) -> IMP::kernel::ParticleTripletsTemp
        get(TripletContainer self, unsigned int i) -> IMP::kernel::ParticleTriplet
        """
        return _IMP_kernel.TripletContainer_get(self, *args)

    def get_number(self):
        """get_number(TripletContainer self) -> unsigned int"""
        return _IMP_kernel.TripletContainer_get_number(self)

    def get_particle_triplets(self):
        """get_particle_triplets(TripletContainer self) -> IMP::kernel::ParticleTripletsTemp"""
        return _IMP_kernel.TripletContainer_get_particle_triplets(self)

    def get_contains_particle_triplet(self, *args):
        """get_contains_particle_triplet(TripletContainer self, IMP::kernel::ParticleTriplet v) -> bool"""
        return _IMP_kernel.TripletContainer_get_contains_particle_triplet(self, *args)

    def get_number_of_particle_triplets(self):
        """get_number_of_particle_triplets(TripletContainer self) -> unsigned int"""
        return _IMP_kernel.TripletContainer_get_number_of_particle_triplets(self)

    def get_particle_triplet(self, *args):
        """get_particle_triplet(TripletContainer self, unsigned int i) -> IMP::kernel::ParticleTriplet"""
        return _IMP_kernel.TripletContainer_get_particle_triplet(self, *args)

    def do_apply(self, *args):
        """do_apply(TripletContainer self, TripletModifier sm)"""
        return _IMP_kernel.TripletContainer_do_apply(self, *args)

    def do_get_provides_access(self):
        """do_get_provides_access(TripletContainer self) -> bool"""
        return _IMP_kernel.TripletContainer_do_get_provides_access(self)

    __swig_destroy__ = _IMP_kernel.delete_TripletContainer
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(TripletContainer self) -> std::string"""
        return _IMP_kernel.TripletContainer___str__(self)

    def __repr__(self):
        """__repr__(TripletContainer self) -> std::string"""
        return _IMP_kernel.TripletContainer___repr__(self)

    def get_from(o):
       return _object_cast_to_TripletContainer(o)
    get_from = staticmethod(get_from)

    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::kernel" == "IMP":
          return VersionInfo("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_TripletContainer(o)
    get_from = staticmethod(get_from)

    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_TripletContainer(self)
        return weakref_proxy(self)
    def update_dependencies(self):
        """update_dependencies(TripletContainer self)"""
        return _IMP_kernel.TripletContainer_update_dependencies(self)

    def do_get_inputs(self):
        """do_get_inputs(TripletContainer self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.TripletContainer_do_get_inputs(self)

    def do_get_interactions(self):
        """do_get_interactions(TripletContainer self) -> IMP::kernel::ModelObjectsTemps"""
        return _IMP_kernel.TripletContainer_do_get_interactions(self)

    def do_before_evaluate(self):
        """do_before_evaluate(TripletContainer self)"""
        return _IMP_kernel.TripletContainer_do_before_evaluate(self)

    def do_update_dependencies(self):
        """do_update_dependencies(TripletContainer self)"""
        return _IMP_kernel.TripletContainer_do_update_dependencies(self)

TripletContainer_swigregister = _IMP_kernel.TripletContainer_swigregister
TripletContainer_swigregister(TripletContainer)

class _TripletContainerAdaptor(IMP.base._InputAdaptor):
    """Proxy of C++ IMP::kernel::TripletContainerAdaptor class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base._InputAdaptor]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _TripletContainerAdaptor, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base._InputAdaptor]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _TripletContainerAdaptor, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::TripletContainerAdaptor self) -> _TripletContainerAdaptor
        __init__(IMP::kernel::TripletContainerAdaptor self, TripletContainer c) -> _TripletContainerAdaptor
        __init__(IMP::kernel::TripletContainerAdaptor self, IMP::kernel::ParticleTripletsTemp const & t, std::string name="TripletContainerAdaptor%1%") -> _TripletContainerAdaptor
        __init__(IMP::kernel::TripletContainerAdaptor self, IMP::kernel::ParticleTripletsTemp const & t) -> _TripletContainerAdaptor
        """
        this = _IMP_kernel.new__TripletContainerAdaptor(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _IMP_kernel.delete__TripletContainerAdaptor
    __del__ = lambda self : None;
_TripletContainerAdaptor_swigregister = _IMP_kernel._TripletContainerAdaptor_swigregister
_TripletContainerAdaptor_swigregister(_TripletContainerAdaptor)


def write_particles_to_buffer(*args):
  """write_particles_to_buffer(IMP::kernel::ParticlesTemp const & particles, IMP::kernel::FloatKeys const & keys) -> IMP::base::Vector< char >"""
  return _IMP_kernel.write_particles_to_buffer(*args)

def read_particles_from_buffer(*args):
  """
    read_particles_from_buffer(IMP::base::Vector< char > const & buffer, IMP::kernel::ParticlesTemp const & particles, 
        IMP::kernel::FloatKeys const & keys)
    """
  return _IMP_kernel.read_particles_from_buffer(*args)
class _ConstRestraint(Restraint):
    """Proxy of C++ IMP::kernel::internal::_ConstRestraint class"""
    __swig_setmethods__ = {}
    for _s in [Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _ConstRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _ConstRestraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::internal::_ConstRestraint self, double v, IMP::kernel::ParticlesTemp const ps) -> _ConstRestraint
        __init__(IMP::kernel::internal::_ConstRestraint self, double v) -> _ConstRestraint
        __init__(IMP::kernel::internal::_ConstRestraint self, Model m, IMP::kernel::ParticleIndexes const & pis, double v) -> _ConstRestraint
        """
        this = _IMP_kernel.new__ConstRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_value(self):
        """get_value(_ConstRestraint self) -> double"""
        return _IMP_kernel._ConstRestraint_get_value(self)

    def do_create_decomposition(self):
        """do_create_decomposition(_ConstRestraint self) -> IMP::kernel::Restraints"""
        return _IMP_kernel._ConstRestraint_do_create_decomposition(self)

    def get_input_particles(self):
        """get_input_particles(_ConstRestraint self) -> IMP::kernel::ParticlesTemp"""
        return _IMP_kernel._ConstRestraint_get_input_particles(self)

    def get_input_containers(self):
        """get_input_containers(_ConstRestraint self) -> IMP::kernel::ContainersTemp"""
        return _IMP_kernel._ConstRestraint_get_input_containers(self)

    def do_get_inputs(self):
        """do_get_inputs(_ConstRestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel._ConstRestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(_ConstRestraint self) -> VersionInfo"""
        return _IMP_kernel._ConstRestraint_get_version_info(self)

    def do_show(self, *args):
        """do_show(_ConstRestraint self, _ostream out)"""
        return _IMP_kernel._ConstRestraint_do_show(self, *args)

    __swig_destroy__ = _IMP_kernel.delete__ConstRestraint
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(_ConstRestraint self) -> std::string"""
        return _IMP_kernel._ConstRestraint___str__(self)

    def __repr__(self):
        """__repr__(_ConstRestraint self) -> std::string"""
        return _IMP_kernel._ConstRestraint___repr__(self)

    def get_from(o):
       return _object_cast_to__ConstRestraint(o)
    get_from = staticmethod(get_from)

_ConstRestraint_swigregister = _IMP_kernel._ConstRestraint_swigregister
_ConstRestraint_swigregister(_ConstRestraint)

class _ConstSingletonScore(SingletonScore):
    """Proxy of C++ IMP::kernel::internal::_ConstSingletonScore class"""
    __swig_setmethods__ = {}
    for _s in [SingletonScore]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _ConstSingletonScore, name, value)
    __swig_getmethods__ = {}
    for _s in [SingletonScore]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _ConstSingletonScore, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(IMP::kernel::internal::_ConstSingletonScore self, double v) -> _ConstSingletonScore"""
        this = _IMP_kernel.new__ConstSingletonScore(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_input_particles(self, *args):
        """get_input_particles(_ConstSingletonScore self, Particle arg2) -> IMP::kernel::ParticlesTemp"""
        return _IMP_kernel._ConstSingletonScore_get_input_particles(self, *args)

    def get_input_containers(self, *args):
        """get_input_containers(_ConstSingletonScore self, Particle arg2) -> IMP::kernel::ContainersTemp"""
        return _IMP_kernel._ConstSingletonScore_get_input_containers(self, *args)

    def get_version_info(self):
        """get_version_info(_ConstSingletonScore self) -> VersionInfo"""
        return _IMP_kernel._ConstSingletonScore_get_version_info(self)

    def do_show(self, *args):
        """do_show(_ConstSingletonScore self, _ostream out)"""
        return _IMP_kernel._ConstSingletonScore_do_show(self, *args)

    __swig_destroy__ = _IMP_kernel.delete__ConstSingletonScore
    __del__ = lambda self : None;
_ConstSingletonScore_swigregister = _IMP_kernel._ConstSingletonScore_swigregister
_ConstSingletonScore_swigregister(_ConstSingletonScore)

class _ConstPairScore(PairScore):
    """Proxy of C++ IMP::kernel::internal::_ConstPairScore class"""
    __swig_setmethods__ = {}
    for _s in [PairScore]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _ConstPairScore, name, value)
    __swig_getmethods__ = {}
    for _s in [PairScore]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _ConstPairScore, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(IMP::kernel::internal::_ConstPairScore self, double v) -> _ConstPairScore"""
        this = _IMP_kernel.new__ConstPairScore(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_input_particles(self, *args):
        """get_input_particles(_ConstPairScore self, Particle arg2) -> IMP::kernel::ParticlesTemp"""
        return _IMP_kernel._ConstPairScore_get_input_particles(self, *args)

    def get_input_containers(self, *args):
        """get_input_containers(_ConstPairScore self, Particle arg2) -> IMP::kernel::ContainersTemp"""
        return _IMP_kernel._ConstPairScore_get_input_containers(self, *args)

    def get_version_info(self):
        """get_version_info(_ConstPairScore self) -> VersionInfo"""
        return _IMP_kernel._ConstPairScore_get_version_info(self)

    def do_show(self, *args):
        """do_show(_ConstPairScore self, _ostream out)"""
        return _IMP_kernel._ConstPairScore_do_show(self, *args)

    __swig_destroy__ = _IMP_kernel.delete__ConstPairScore
    __del__ = lambda self : None;
_ConstPairScore_swigregister = _IMP_kernel._ConstPairScore_swigregister
_ConstPairScore_swigregister(_ConstPairScore)

class _TrivialDecorator(Decorator):
    """Proxy of C++ IMP::kernel::internal::_TrivialDecorator class"""
    __swig_setmethods__ = {}
    for _s in [Decorator]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _TrivialDecorator, name, value)
    __swig_getmethods__ = {}
    for _s in [Decorator]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _TrivialDecorator, name)
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::internal::_TrivialDecorator self) -> _TrivialDecorator
        __init__(IMP::kernel::internal::_TrivialDecorator self, Model m, IMP::kernel::ParticleIndex id) -> _TrivialDecorator
        __init__(IMP::kernel::internal::_TrivialDecorator self, Particle p) -> _TrivialDecorator
        """
        this = _IMP_kernel.new__TrivialDecorator(*args)
        try: self.this.append(this)
        except: self.this = this
    def decorate_particle(*args):
        """decorate_particle(Particle p) -> _TrivialDecorator"""
        return _IMP_kernel._TrivialDecorator_decorate_particle(*args)

    if _newclass:decorate_particle = staticmethod(decorate_particle)
    __swig_getmethods__["decorate_particle"] = lambda x: decorate_particle
    def show(self, *args):
        """
        show(_TrivialDecorator self, _ostream out=std::cout)
        show(_TrivialDecorator self)
        """
        return _IMP_kernel._TrivialDecorator_show(self, *args)

    def setup_particle(*args):
        """setup_particle(Particle p) -> _TrivialDecorator"""
        return _IMP_kernel._TrivialDecorator_setup_particle(*args)

    if _newclass:setup_particle = staticmethod(setup_particle)
    __swig_getmethods__["setup_particle"] = lambda x: setup_particle
    def particle_is_instance(*args):
        """particle_is_instance(Particle p) -> bool"""
        return _IMP_kernel._TrivialDecorator_particle_is_instance(*args)

    if _newclass:particle_is_instance = staticmethod(particle_is_instance)
    __swig_getmethods__["particle_is_instance"] = lambda x: particle_is_instance
    def add_attribute(self, *args):
        """
        add_attribute(_TrivialDecorator self, FloatKey k, IMP::Float v, bool opt)
        add_attribute(_TrivialDecorator self, FloatKey a0, IMP::Float a1)
        add_attribute(_TrivialDecorator self, IntKey a0, IMP::Int a1)
        add_attribute(_TrivialDecorator self, StringKey a0, IMP::String a1)
        add_attribute(_TrivialDecorator self, ParticleIndexKey a0, Particle a1)
        add_attribute(_TrivialDecorator self, ObjectKey a0, IMP::Object * a1)
        """
        return _IMP_kernel._TrivialDecorator_add_attribute(self, *args)

    def get_value(self, *args):
        """
        get_value(_TrivialDecorator self, FloatKey a0) -> IMP::Float
        get_value(_TrivialDecorator self, IntKey a0) -> IMP::Int
        get_value(_TrivialDecorator self, StringKey a0) -> IMP::String
        get_value(_TrivialDecorator self, ParticleIndexKey a0) -> Particle
        get_value(_TrivialDecorator self, ObjectKey a0) -> IMP::Object *
        """
        return _IMP_kernel._TrivialDecorator_get_value(self, *args)

    def set_value(self, *args):
        """
        set_value(_TrivialDecorator self, FloatKey a0, IMP::Float a1)
        set_value(_TrivialDecorator self, IntKey a0, IMP::Int a1)
        set_value(_TrivialDecorator self, StringKey a0, IMP::String a1)
        set_value(_TrivialDecorator self, ParticleIndexKey a0, Particle a1)
        set_value(_TrivialDecorator self, ObjectKey a0, IMP::Object * a1)
        """
        return _IMP_kernel._TrivialDecorator_set_value(self, *args)

    def remove_attribute(self, *args):
        """
        remove_attribute(_TrivialDecorator self, FloatKey a0)
        remove_attribute(_TrivialDecorator self, IntKey a0)
        remove_attribute(_TrivialDecorator self, StringKey a0)
        remove_attribute(_TrivialDecorator self, ParticleIndexKey a0)
        remove_attribute(_TrivialDecorator self, ObjectKey a0)
        """
        return _IMP_kernel._TrivialDecorator_remove_attribute(self, *args)

    def has_attribute(self, *args):
        """
        has_attribute(_TrivialDecorator self, FloatKey a0) -> bool
        has_attribute(_TrivialDecorator self, IntKey a0) -> bool
        has_attribute(_TrivialDecorator self, StringKey a0) -> bool
        has_attribute(_TrivialDecorator self, ParticleIndexKey a0) -> bool
        has_attribute(_TrivialDecorator self, ObjectKey a0) -> bool
        """
        return _IMP_kernel._TrivialDecorator_has_attribute(self, *args)

    def get_derivative(self, *args):
        """get_derivative(_TrivialDecorator self, FloatKey a0) -> double"""
        return _IMP_kernel._TrivialDecorator_get_derivative(self, *args)

    def get_name(self):
        """get_name(_TrivialDecorator self) -> std::string"""
        return _IMP_kernel._TrivialDecorator_get_name(self)

    def clear_caches(self):
        """clear_caches(_TrivialDecorator self)"""
        return _IMP_kernel._TrivialDecorator_clear_caches(self)

    def set_name(self, *args):
        """set_name(_TrivialDecorator self, std::string a0)"""
        return _IMP_kernel._TrivialDecorator_set_name(self, *args)

    def set_check_level(self, *args):
        """set_check_level(_TrivialDecorator self, IMP::base::CheckLevel a0)"""
        return _IMP_kernel._TrivialDecorator_set_check_level(self, *args)

    def add_to_derivative(self, *args):
        """add_to_derivative(_TrivialDecorator self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_kernel._TrivialDecorator_add_to_derivative(self, *args)

    def set_is_optimized(self, *args):
        """set_is_optimized(_TrivialDecorator self, FloatKey a0, bool a1)"""
        return _IMP_kernel._TrivialDecorator_set_is_optimized(self, *args)

    def get_is_optimized(self, *args):
        """get_is_optimized(_TrivialDecorator self, FloatKey a0) -> bool"""
        return _IMP_kernel._TrivialDecorator_get_is_optimized(self, *args)

    def get_check_level(self):
        """get_check_level(_TrivialDecorator self) -> IMP::base::CheckLevel"""
        return _IMP_kernel._TrivialDecorator_get_check_level(self)

    def __eq__(self, *args):
        """
        __eq__(_TrivialDecorator self, _TrivialDecorator o) -> bool
        __eq__(_TrivialDecorator self, Particle d) -> bool
        """
        return _IMP_kernel._TrivialDecorator___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(_TrivialDecorator self, _TrivialDecorator o) -> bool
        __ne__(_TrivialDecorator self, Particle d) -> bool
        """
        return _IMP_kernel._TrivialDecorator___ne__(self, *args)

    def __le__(self, *args):
        """
        __le__(_TrivialDecorator self, _TrivialDecorator o) -> bool
        __le__(_TrivialDecorator self, Particle d) -> bool
        """
        return _IMP_kernel._TrivialDecorator___le__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(_TrivialDecorator self, _TrivialDecorator o) -> bool
        __lt__(_TrivialDecorator self, Particle d) -> bool
        """
        return _IMP_kernel._TrivialDecorator___lt__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(_TrivialDecorator self, _TrivialDecorator o) -> bool
        __ge__(_TrivialDecorator self, Particle d) -> bool
        """
        return _IMP_kernel._TrivialDecorator___ge__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(_TrivialDecorator self, _TrivialDecorator o) -> bool
        __gt__(_TrivialDecorator self, Particle d) -> bool
        """
        return _IMP_kernel._TrivialDecorator___gt__(self, *args)

    def __str__(self):
        """__str__(_TrivialDecorator self) -> std::string"""
        return _IMP_kernel._TrivialDecorator___str__(self)

    def __repr__(self):
        """__repr__(_TrivialDecorator self) -> std::string"""
        return _IMP_kernel._TrivialDecorator___repr__(self)

    __swig_destroy__ = _IMP_kernel.delete__TrivialDecorator
    __del__ = lambda self : None;
_TrivialDecorator_swigregister = _IMP_kernel._TrivialDecorator_swigregister
_TrivialDecorator_swigregister(_TrivialDecorator)

def _TrivialDecorator_decorate_particle(*args):
  """_TrivialDecorator_decorate_particle(Particle p) -> _TrivialDecorator"""
  return _IMP_kernel._TrivialDecorator_decorate_particle(*args)

def _TrivialDecorator_setup_particle(*args):
  """_TrivialDecorator_setup_particle(Particle p) -> _TrivialDecorator"""
  return _IMP_kernel._TrivialDecorator_setup_particle(*args)

def _TrivialDecorator_particle_is_instance(*args):
  """_TrivialDecorator_particle_is_instance(Particle p) -> bool"""
  return _IMP_kernel._TrivialDecorator_particle_is_instance(*args)

class _TrivialDerivedDecorator(_TrivialDecorator):
    """Proxy of C++ IMP::kernel::internal::_TrivialDerivedDecorator class"""
    __swig_setmethods__ = {}
    for _s in [_TrivialDecorator]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _TrivialDerivedDecorator, name, value)
    __swig_getmethods__ = {}
    for _s in [_TrivialDecorator]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _TrivialDerivedDecorator, name)
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::internal::_TrivialDerivedDecorator self) -> _TrivialDerivedDecorator
        __init__(IMP::kernel::internal::_TrivialDerivedDecorator self, Model m, IMP::kernel::ParticleIndex id) -> _TrivialDerivedDecorator
        __init__(IMP::kernel::internal::_TrivialDerivedDecorator self, Particle p) -> _TrivialDerivedDecorator
        """
        this = _IMP_kernel.new__TrivialDerivedDecorator(*args)
        try: self.this.append(this)
        except: self.this = this
    def decorate_particle(*args):
        """decorate_particle(Particle p) -> _TrivialDerivedDecorator"""
        return _IMP_kernel._TrivialDerivedDecorator_decorate_particle(*args)

    if _newclass:decorate_particle = staticmethod(decorate_particle)
    __swig_getmethods__["decorate_particle"] = lambda x: decorate_particle
    def show(self, *args):
        """
        show(_TrivialDerivedDecorator self, _ostream out=std::cout)
        show(_TrivialDerivedDecorator self)
        """
        return _IMP_kernel._TrivialDerivedDecorator_show(self, *args)

    def setup_particle(*args):
        """setup_particle(Particle p) -> _TrivialDerivedDecorator"""
        return _IMP_kernel._TrivialDerivedDecorator_setup_particle(*args)

    if _newclass:setup_particle = staticmethod(setup_particle)
    __swig_getmethods__["setup_particle"] = lambda x: setup_particle
    def particle_is_instance(*args):
        """particle_is_instance(Particle p) -> bool"""
        return _IMP_kernel._TrivialDerivedDecorator_particle_is_instance(*args)

    if _newclass:particle_is_instance = staticmethod(particle_is_instance)
    __swig_getmethods__["particle_is_instance"] = lambda x: particle_is_instance
    def add_attribute(self, *args):
        """
        add_attribute(_TrivialDerivedDecorator self, FloatKey k, IMP::Float v, bool opt)
        add_attribute(_TrivialDerivedDecorator self, FloatKey a0, IMP::Float a1)
        add_attribute(_TrivialDerivedDecorator self, IntKey a0, IMP::Int a1)
        add_attribute(_TrivialDerivedDecorator self, StringKey a0, IMP::String a1)
        add_attribute(_TrivialDerivedDecorator self, ParticleIndexKey a0, Particle a1)
        add_attribute(_TrivialDerivedDecorator self, ObjectKey a0, IMP::Object * a1)
        """
        return _IMP_kernel._TrivialDerivedDecorator_add_attribute(self, *args)

    def get_value(self, *args):
        """
        get_value(_TrivialDerivedDecorator self, FloatKey a0) -> IMP::Float
        get_value(_TrivialDerivedDecorator self, IntKey a0) -> IMP::Int
        get_value(_TrivialDerivedDecorator self, StringKey a0) -> IMP::String
        get_value(_TrivialDerivedDecorator self, ParticleIndexKey a0) -> Particle
        get_value(_TrivialDerivedDecorator self, ObjectKey a0) -> IMP::Object *
        """
        return _IMP_kernel._TrivialDerivedDecorator_get_value(self, *args)

    def set_value(self, *args):
        """
        set_value(_TrivialDerivedDecorator self, FloatKey a0, IMP::Float a1)
        set_value(_TrivialDerivedDecorator self, IntKey a0, IMP::Int a1)
        set_value(_TrivialDerivedDecorator self, StringKey a0, IMP::String a1)
        set_value(_TrivialDerivedDecorator self, ParticleIndexKey a0, Particle a1)
        set_value(_TrivialDerivedDecorator self, ObjectKey a0, IMP::Object * a1)
        """
        return _IMP_kernel._TrivialDerivedDecorator_set_value(self, *args)

    def remove_attribute(self, *args):
        """
        remove_attribute(_TrivialDerivedDecorator self, FloatKey a0)
        remove_attribute(_TrivialDerivedDecorator self, IntKey a0)
        remove_attribute(_TrivialDerivedDecorator self, StringKey a0)
        remove_attribute(_TrivialDerivedDecorator self, ParticleIndexKey a0)
        remove_attribute(_TrivialDerivedDecorator self, ObjectKey a0)
        """
        return _IMP_kernel._TrivialDerivedDecorator_remove_attribute(self, *args)

    def has_attribute(self, *args):
        """
        has_attribute(_TrivialDerivedDecorator self, FloatKey a0) -> bool
        has_attribute(_TrivialDerivedDecorator self, IntKey a0) -> bool
        has_attribute(_TrivialDerivedDecorator self, StringKey a0) -> bool
        has_attribute(_TrivialDerivedDecorator self, ParticleIndexKey a0) -> bool
        has_attribute(_TrivialDerivedDecorator self, ObjectKey a0) -> bool
        """
        return _IMP_kernel._TrivialDerivedDecorator_has_attribute(self, *args)

    def get_derivative(self, *args):
        """get_derivative(_TrivialDerivedDecorator self, FloatKey a0) -> double"""
        return _IMP_kernel._TrivialDerivedDecorator_get_derivative(self, *args)

    def get_name(self):
        """get_name(_TrivialDerivedDecorator self) -> std::string"""
        return _IMP_kernel._TrivialDerivedDecorator_get_name(self)

    def clear_caches(self):
        """clear_caches(_TrivialDerivedDecorator self)"""
        return _IMP_kernel._TrivialDerivedDecorator_clear_caches(self)

    def set_name(self, *args):
        """set_name(_TrivialDerivedDecorator self, std::string a0)"""
        return _IMP_kernel._TrivialDerivedDecorator_set_name(self, *args)

    def set_check_level(self, *args):
        """set_check_level(_TrivialDerivedDecorator self, IMP::base::CheckLevel a0)"""
        return _IMP_kernel._TrivialDerivedDecorator_set_check_level(self, *args)

    def add_to_derivative(self, *args):
        """add_to_derivative(_TrivialDerivedDecorator self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_kernel._TrivialDerivedDecorator_add_to_derivative(self, *args)

    def set_is_optimized(self, *args):
        """set_is_optimized(_TrivialDerivedDecorator self, FloatKey a0, bool a1)"""
        return _IMP_kernel._TrivialDerivedDecorator_set_is_optimized(self, *args)

    def get_is_optimized(self, *args):
        """get_is_optimized(_TrivialDerivedDecorator self, FloatKey a0) -> bool"""
        return _IMP_kernel._TrivialDerivedDecorator_get_is_optimized(self, *args)

    def get_check_level(self):
        """get_check_level(_TrivialDerivedDecorator self) -> IMP::base::CheckLevel"""
        return _IMP_kernel._TrivialDerivedDecorator_get_check_level(self)

    def __eq__(self, *args):
        """
        __eq__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
        __eq__(_TrivialDerivedDecorator self, Particle d) -> bool
        """
        return _IMP_kernel._TrivialDerivedDecorator___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
        __ne__(_TrivialDerivedDecorator self, Particle d) -> bool
        """
        return _IMP_kernel._TrivialDerivedDecorator___ne__(self, *args)

    def __le__(self, *args):
        """
        __le__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
        __le__(_TrivialDerivedDecorator self, Particle d) -> bool
        """
        return _IMP_kernel._TrivialDerivedDecorator___le__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
        __lt__(_TrivialDerivedDecorator self, Particle d) -> bool
        """
        return _IMP_kernel._TrivialDerivedDecorator___lt__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
        __ge__(_TrivialDerivedDecorator self, Particle d) -> bool
        """
        return _IMP_kernel._TrivialDerivedDecorator___ge__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
        __gt__(_TrivialDerivedDecorator self, Particle d) -> bool
        """
        return _IMP_kernel._TrivialDerivedDecorator___gt__(self, *args)

    def __str__(self):
        """__str__(_TrivialDerivedDecorator self) -> std::string"""
        return _IMP_kernel._TrivialDerivedDecorator___str__(self)

    def __repr__(self):
        """__repr__(_TrivialDerivedDecorator self) -> std::string"""
        return _IMP_kernel._TrivialDerivedDecorator___repr__(self)

    __swig_destroy__ = _IMP_kernel.delete__TrivialDerivedDecorator
    __del__ = lambda self : None;
_TrivialDerivedDecorator_swigregister = _IMP_kernel._TrivialDerivedDecorator_swigregister
_TrivialDerivedDecorator_swigregister(_TrivialDerivedDecorator)

def _TrivialDerivedDecorator_decorate_particle(*args):
  """_TrivialDerivedDecorator_decorate_particle(Particle p) -> _TrivialDerivedDecorator"""
  return _IMP_kernel._TrivialDerivedDecorator_decorate_particle(*args)

def _TrivialDerivedDecorator_setup_particle(*args):
  """_TrivialDerivedDecorator_setup_particle(Particle p) -> _TrivialDerivedDecorator"""
  return _IMP_kernel._TrivialDerivedDecorator_setup_particle(*args)

def _TrivialDerivedDecorator_particle_is_instance(*args):
  """_TrivialDerivedDecorator_particle_is_instance(Particle p) -> bool"""
  return _IMP_kernel._TrivialDerivedDecorator_particle_is_instance(*args)

class _TrivialTraitsDecorator(Decorator):
    """Proxy of C++ IMP::kernel::internal::_TrivialTraitsDecorator class"""
    __swig_setmethods__ = {}
    for _s in [Decorator]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _TrivialTraitsDecorator, name, value)
    __swig_getmethods__ = {}
    for _s in [Decorator]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _TrivialTraitsDecorator, name)
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::internal::_TrivialTraitsDecorator self) -> _TrivialTraitsDecorator
        __init__(IMP::kernel::internal::_TrivialTraitsDecorator self, Model m, IMP::kernel::ParticleIndex id, StringKey tr) -> _TrivialTraitsDecorator
        __init__(IMP::kernel::internal::_TrivialTraitsDecorator self, StringKey tr) -> _TrivialTraitsDecorator
        __init__(IMP::kernel::internal::_TrivialTraitsDecorator self, Particle p, StringKey tr=get_default_key()) -> _TrivialTraitsDecorator
        __init__(IMP::kernel::internal::_TrivialTraitsDecorator self, Particle p) -> _TrivialTraitsDecorator
        """
        this = _IMP_kernel.new__TrivialTraitsDecorator(*args)
        try: self.this.append(this)
        except: self.this = this
    def decorate_particle(*args):
        """
        decorate_particle(Particle p, StringKey tr=get_default_key()) -> _TrivialTraitsDecorator
        decorate_particle(Particle p) -> _TrivialTraitsDecorator
        """
        return _IMP_kernel._TrivialTraitsDecorator_decorate_particle(*args)

    if _newclass:decorate_particle = staticmethod(decorate_particle)
    __swig_getmethods__["decorate_particle"] = lambda x: decorate_particle
    def show(self, *args):
        """
        show(_TrivialTraitsDecorator self, _ostream out=std::cout)
        show(_TrivialTraitsDecorator self)
        """
        return _IMP_kernel._TrivialTraitsDecorator_show(self, *args)

    def get_sk(self):
        """get_sk(_TrivialTraitsDecorator self) -> StringKey"""
        return _IMP_kernel._TrivialTraitsDecorator_get_sk(self)

    def get_decorator_traits(self):
        """get_decorator_traits(_TrivialTraitsDecorator self) -> StringKey"""
        return _IMP_kernel._TrivialTraitsDecorator_get_decorator_traits(self)

    def get_default_decorator_traits():
        """get_default_decorator_traits() -> StringKey"""
        return _IMP_kernel._TrivialTraitsDecorator_get_default_decorator_traits()

    if _newclass:get_default_decorator_traits = staticmethod(get_default_decorator_traits)
    __swig_getmethods__["get_default_decorator_traits"] = lambda x: get_default_decorator_traits
    def setup_particle(*args):
        """
        setup_particle(Particle p, StringKey k=get_default_key()) -> _TrivialTraitsDecorator
        setup_particle(Particle p) -> _TrivialTraitsDecorator
        """
        return _IMP_kernel._TrivialTraitsDecorator_setup_particle(*args)

    if _newclass:setup_particle = staticmethod(setup_particle)
    __swig_getmethods__["setup_particle"] = lambda x: setup_particle
    def particle_is_instance(*args):
        """
        particle_is_instance(Particle p, StringKey k=get_default_key()) -> bool
        particle_is_instance(Particle p) -> bool
        """
        return _IMP_kernel._TrivialTraitsDecorator_particle_is_instance(*args)

    if _newclass:particle_is_instance = staticmethod(particle_is_instance)
    __swig_getmethods__["particle_is_instance"] = lambda x: particle_is_instance
    def get_default_key():
        """get_default_key() -> StringKey"""
        return _IMP_kernel._TrivialTraitsDecorator_get_default_key()

    if _newclass:get_default_key = staticmethod(get_default_key)
    __swig_getmethods__["get_default_key"] = lambda x: get_default_key
    def add_attribute(self, *args):
        """
        add_attribute(_TrivialTraitsDecorator self, FloatKey k, IMP::Float v, bool opt)
        add_attribute(_TrivialTraitsDecorator self, FloatKey a0, IMP::Float a1)
        add_attribute(_TrivialTraitsDecorator self, IntKey a0, IMP::Int a1)
        add_attribute(_TrivialTraitsDecorator self, StringKey a0, IMP::String a1)
        add_attribute(_TrivialTraitsDecorator self, ParticleIndexKey a0, Particle a1)
        add_attribute(_TrivialTraitsDecorator self, ObjectKey a0, IMP::Object * a1)
        """
        return _IMP_kernel._TrivialTraitsDecorator_add_attribute(self, *args)

    def get_value(self, *args):
        """
        get_value(_TrivialTraitsDecorator self, FloatKey a0) -> IMP::Float
        get_value(_TrivialTraitsDecorator self, IntKey a0) -> IMP::Int
        get_value(_TrivialTraitsDecorator self, StringKey a0) -> IMP::String
        get_value(_TrivialTraitsDecorator self, ParticleIndexKey a0) -> Particle
        get_value(_TrivialTraitsDecorator self, ObjectKey a0) -> IMP::Object *
        """
        return _IMP_kernel._TrivialTraitsDecorator_get_value(self, *args)

    def set_value(self, *args):
        """
        set_value(_TrivialTraitsDecorator self, FloatKey a0, IMP::Float a1)
        set_value(_TrivialTraitsDecorator self, IntKey a0, IMP::Int a1)
        set_value(_TrivialTraitsDecorator self, StringKey a0, IMP::String a1)
        set_value(_TrivialTraitsDecorator self, ParticleIndexKey a0, Particle a1)
        set_value(_TrivialTraitsDecorator self, ObjectKey a0, IMP::Object * a1)
        """
        return _IMP_kernel._TrivialTraitsDecorator_set_value(self, *args)

    def remove_attribute(self, *args):
        """
        remove_attribute(_TrivialTraitsDecorator self, FloatKey a0)
        remove_attribute(_TrivialTraitsDecorator self, IntKey a0)
        remove_attribute(_TrivialTraitsDecorator self, StringKey a0)
        remove_attribute(_TrivialTraitsDecorator self, ParticleIndexKey a0)
        remove_attribute(_TrivialTraitsDecorator self, ObjectKey a0)
        """
        return _IMP_kernel._TrivialTraitsDecorator_remove_attribute(self, *args)

    def has_attribute(self, *args):
        """
        has_attribute(_TrivialTraitsDecorator self, FloatKey a0) -> bool
        has_attribute(_TrivialTraitsDecorator self, IntKey a0) -> bool
        has_attribute(_TrivialTraitsDecorator self, StringKey a0) -> bool
        has_attribute(_TrivialTraitsDecorator self, ParticleIndexKey a0) -> bool
        has_attribute(_TrivialTraitsDecorator self, ObjectKey a0) -> bool
        """
        return _IMP_kernel._TrivialTraitsDecorator_has_attribute(self, *args)

    def get_derivative(self, *args):
        """get_derivative(_TrivialTraitsDecorator self, FloatKey a0) -> double"""
        return _IMP_kernel._TrivialTraitsDecorator_get_derivative(self, *args)

    def get_name(self):
        """get_name(_TrivialTraitsDecorator self) -> std::string"""
        return _IMP_kernel._TrivialTraitsDecorator_get_name(self)

    def clear_caches(self):
        """clear_caches(_TrivialTraitsDecorator self)"""
        return _IMP_kernel._TrivialTraitsDecorator_clear_caches(self)

    def set_name(self, *args):
        """set_name(_TrivialTraitsDecorator self, std::string a0)"""
        return _IMP_kernel._TrivialTraitsDecorator_set_name(self, *args)

    def set_check_level(self, *args):
        """set_check_level(_TrivialTraitsDecorator self, IMP::base::CheckLevel a0)"""
        return _IMP_kernel._TrivialTraitsDecorator_set_check_level(self, *args)

    def add_to_derivative(self, *args):
        """add_to_derivative(_TrivialTraitsDecorator self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_kernel._TrivialTraitsDecorator_add_to_derivative(self, *args)

    def set_is_optimized(self, *args):
        """set_is_optimized(_TrivialTraitsDecorator self, FloatKey a0, bool a1)"""
        return _IMP_kernel._TrivialTraitsDecorator_set_is_optimized(self, *args)

    def get_is_optimized(self, *args):
        """get_is_optimized(_TrivialTraitsDecorator self, FloatKey a0) -> bool"""
        return _IMP_kernel._TrivialTraitsDecorator_get_is_optimized(self, *args)

    def get_check_level(self):
        """get_check_level(_TrivialTraitsDecorator self) -> IMP::base::CheckLevel"""
        return _IMP_kernel._TrivialTraitsDecorator_get_check_level(self)

    def __eq__(self, *args):
        """
        __eq__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
        __eq__(_TrivialTraitsDecorator self, Particle d) -> bool
        """
        return _IMP_kernel._TrivialTraitsDecorator___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
        __ne__(_TrivialTraitsDecorator self, Particle d) -> bool
        """
        return _IMP_kernel._TrivialTraitsDecorator___ne__(self, *args)

    def __le__(self, *args):
        """
        __le__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
        __le__(_TrivialTraitsDecorator self, Particle d) -> bool
        """
        return _IMP_kernel._TrivialTraitsDecorator___le__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
        __lt__(_TrivialTraitsDecorator self, Particle d) -> bool
        """
        return _IMP_kernel._TrivialTraitsDecorator___lt__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
        __ge__(_TrivialTraitsDecorator self, Particle d) -> bool
        """
        return _IMP_kernel._TrivialTraitsDecorator___ge__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
        __gt__(_TrivialTraitsDecorator self, Particle d) -> bool
        """
        return _IMP_kernel._TrivialTraitsDecorator___gt__(self, *args)

    def __str__(self):
        """__str__(_TrivialTraitsDecorator self) -> std::string"""
        return _IMP_kernel._TrivialTraitsDecorator___str__(self)

    def __repr__(self):
        """__repr__(_TrivialTraitsDecorator self) -> std::string"""
        return _IMP_kernel._TrivialTraitsDecorator___repr__(self)

    __swig_destroy__ = _IMP_kernel.delete__TrivialTraitsDecorator
    __del__ = lambda self : None;
_TrivialTraitsDecorator_swigregister = _IMP_kernel._TrivialTraitsDecorator_swigregister
_TrivialTraitsDecorator_swigregister(_TrivialTraitsDecorator)

def _TrivialTraitsDecorator_decorate_particle(*args):
  """
    decorate_particle(Particle p, StringKey tr=get_default_key()) -> _TrivialTraitsDecorator
    _TrivialTraitsDecorator_decorate_particle(Particle p) -> _TrivialTraitsDecorator
    """
  return _IMP_kernel._TrivialTraitsDecorator_decorate_particle(*args)

def _TrivialTraitsDecorator_get_default_decorator_traits():
  """_TrivialTraitsDecorator_get_default_decorator_traits() -> StringKey"""
  return _IMP_kernel._TrivialTraitsDecorator_get_default_decorator_traits()

def _TrivialTraitsDecorator_setup_particle(*args):
  """
    setup_particle(Particle p, StringKey k=get_default_key()) -> _TrivialTraitsDecorator
    _TrivialTraitsDecorator_setup_particle(Particle p) -> _TrivialTraitsDecorator
    """
  return _IMP_kernel._TrivialTraitsDecorator_setup_particle(*args)

def _TrivialTraitsDecorator_particle_is_instance(*args):
  """
    particle_is_instance(Particle p, StringKey k=get_default_key()) -> bool
    _TrivialTraitsDecorator_particle_is_instance(Particle p) -> bool
    """
  return _IMP_kernel._TrivialTraitsDecorator_particle_is_instance(*args)

def _TrivialTraitsDecorator_get_default_key():
  """_TrivialTraitsDecorator_get_default_key() -> StringKey"""
  return _IMP_kernel._TrivialTraitsDecorator_get_default_key()


def __lshift__(*args):
  """
    __lshift__(_ostream out, _TrivialDecorator n) -> _ostream
    __lshift__(_ostream out, _TrivialDerivedDecorator n) -> _ostream
    __lshift__(_ostream out, _TrivialTraitsDecorator n) -> _ostream
    """
  return _IMP_kernel.__lshift__(*args)
class _ConstOptimizer(Optimizer):
    """Proxy of C++ IMP::kernel::internal::_ConstOptimizer class"""
    __swig_setmethods__ = {}
    for _s in [Optimizer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _ConstOptimizer, name, value)
    __swig_getmethods__ = {}
    for _s in [Optimizer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _ConstOptimizer, name)
    def __init__(self, *args): 
        """__init__(IMP::kernel::internal::_ConstOptimizer self, Model m) -> _ConstOptimizer"""
        this = _IMP_kernel.new__ConstOptimizer(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_optimize(self, *args):
        """do_optimize(_ConstOptimizer self, unsigned int max_steps) -> IMP::Float"""
        return _IMP_kernel._ConstOptimizer_do_optimize(self, *args)

    def get_version_info(self):
        """get_version_info(_ConstOptimizer self) -> VersionInfo"""
        return _IMP_kernel._ConstOptimizer_get_version_info(self)

    def do_show(self, *args):
        """do_show(_ConstOptimizer self, _ostream out)"""
        return _IMP_kernel._ConstOptimizer_do_show(self, *args)

    __swig_destroy__ = _IMP_kernel.delete__ConstOptimizer
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(_ConstOptimizer self) -> std::string"""
        return _IMP_kernel._ConstOptimizer___str__(self)

    def __repr__(self):
        """__repr__(_ConstOptimizer self) -> std::string"""
        return _IMP_kernel._ConstOptimizer___repr__(self)

    def get_from(o):
       return _object_cast_to__ConstOptimizer(o)
    get_from = staticmethod(get_from)

_ConstOptimizer_swigregister = _IMP_kernel._ConstOptimizer_swigregister
_ConstOptimizer_swigregister(_ConstOptimizer)


def get_particle(*args):
  """get_particle(Particle p) -> Particle"""
  return _IMP_kernel.get_particle(*args)

def _decorator_test(*args):
  """_decorator_test(Particle p)"""
  return _IMP_kernel._decorator_test(*args)

def _overloaded_decorator(*args):
  """
    _overloaded_decorator(_TrivialDecorator a) -> int
    _overloaded_decorator(_TrivialDerivedDecorator a) -> int
    """
  return _IMP_kernel._overloaded_decorator(*args)

def _take_particles(*args):
  """
    _take_particles(IMP::kernel::Particles const & ps) -> unsigned int
    _take_particles(Model m, IMP::kernel::Particles const & ps) -> unsigned int
    _take_particles(Model m, IMP::kernel::Particles const & ps, TextOutput out) -> unsigned int
    """
  return _IMP_kernel._take_particles(*args)

def _give_particles(*args):
  """_give_particles(Model m) -> IMP::kernel::Particles const &"""
  return _IMP_kernel._give_particles(*args)

def _pass_particles(*args):
  """_pass_particles(IMP::kernel::Particles const & ps) -> IMP::kernel::Particles const &"""
  return _IMP_kernel._pass_particles(*args)

def _pass_particle(*args):
  """_pass_particle(Particle ps) -> Particle"""
  return _IMP_kernel._pass_particle(*args)

def _pass_particle_pair(*args):
  """_pass_particle_pair(IMP::kernel::ParticlePair const & pp) -> IMP::kernel::ParticlePair const &"""
  return _IMP_kernel._pass_particle_pair(*args)

def _give_particles_copy(*args):
  """_give_particles_copy(Model m) -> IMP::kernel::Particles"""
  return _IMP_kernel._give_particles_copy(*args)

def _pass_float_keys(*args):
  """_pass_float_keys(IMP::kernel::FloatKeys const & input) -> IMP::kernel::FloatKeys"""
  return _IMP_kernel._pass_float_keys(*args)

def _pass(*args):
  """
    _pass(IMP::kernel::Particles const & p) -> IMP::kernel::Particles const
    _pass(IMP::kernel::Restraints const & p) -> IMP::kernel::Restraints const &
    """
  return _IMP_kernel._pass(*args)

def _pass_decorators(*args):
  """_pass_decorators(IMP::kernel::internal::_TrivialDecorators const & p) -> IMP::kernel::internal::_TrivialDecorators const &"""
  return _IMP_kernel._pass_decorators(*args)

def _pass_decorator_traits(*args):
  """_pass_decorator_traits(IMP::kernel::internal::_TrivialTraitsDecorators const & p) -> IMP::kernel::internal::_TrivialTraitsDecorators const &"""
  return _IMP_kernel._pass_decorator_traits(*args)

def _pass_particle_pairs(*args):
  """_pass_particle_pairs(IMP::kernel::ParticlePairsTemp const & p) -> IMP::kernel::ParticlePairsTemp"""
  return _IMP_kernel._pass_particle_pairs(*args)

def _pass_particle_index_pairs(*args):
  """_pass_particle_index_pairs(IMP::kernel::ParticleIndexPairs const & p) -> IMP::kernel::ParticleIndexPairs"""
  return _IMP_kernel._pass_particle_index_pairs(*args)

def _pass_model_objects(*args):
  """_pass_model_objects(IMP::kernel::ModelObjectsTemp const & p) -> IMP::kernel::ModelObjectsTemp"""
  return _IMP_kernel._pass_model_objects(*args)

def _pass_particles_temps(*args):
  """_pass_particles_temps(IMP::kernel::ParticlesTemps const & ps) -> IMP::kernel::ParticlesTemps"""
  return _IMP_kernel._pass_particles_temps(*args)

def _test_overload(*args):
  """
    _test_overload(IMP::kernel::Particles const & ps) -> int
    _test_overload(IMP::kernel::Restraints const & ps) -> int
    """
  return _IMP_kernel._test_overload(*args)

def _get_range(*args):
  """_get_range(Model m, FloatKey k) -> IMP::FloatRange"""
  return _IMP_kernel._get_range(*args)

def _create_particles_from_pdb(*args):
  """_create_particles_from_pdb(std::string name, Model m) -> IMP::kernel::ParticlesTemp"""
  return _IMP_kernel._create_particles_from_pdb(*args)
class _LogPairScore(PairScore):
    """Proxy of C++ IMP::kernel::internal::_LogPairScore class"""
    __swig_setmethods__ = {}
    for _s in [PairScore]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _LogPairScore, name, value)
    __swig_getmethods__ = {}
    for _s in [PairScore]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _LogPairScore, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(IMP::kernel::internal::_LogPairScore self) -> _LogPairScore"""
        this = _IMP_kernel.new__LogPairScore()
        try: self.this.append(this)
        except: self.this = this
    def do_create_current_decomposition(self, *args):
        """do_create_current_decomposition(_LogPairScore self, Model m, IMP::kernel::ParticleIndexPair const & vt) -> IMP::kernel::Restraints"""
        return _IMP_kernel._LogPairScore_do_create_current_decomposition(self, *args)

    def get_version_info(self):
        """get_version_info(_LogPairScore self) -> VersionInfo"""
        return _IMP_kernel._LogPairScore_get_version_info(self)

    def do_show(self, *args):
        """do_show(_LogPairScore self, _ostream out)"""
        return _IMP_kernel._LogPairScore_do_show(self, *args)

    __swig_destroy__ = _IMP_kernel.delete__LogPairScore
    __del__ = lambda self : None;
    def get_particle_pairs(self):
        """get_particle_pairs(_LogPairScore self) -> IMP::kernel::ParticlePairsTemp"""
        return _IMP_kernel._LogPairScore_get_particle_pairs(self)

    def clear(self):
        """clear(_LogPairScore self)"""
        return _IMP_kernel._LogPairScore_clear(self)

    def get_contains(self, *args):
        """get_contains(_LogPairScore self, IMP::kernel::ParticlePair const & pp) -> bool"""
        return _IMP_kernel._LogPairScore_get_contains(self, *args)

_LogPairScore_swigregister = _IMP_kernel._LogPairScore_swigregister
_LogPairScore_swigregister(_LogPairScore)

class PythonRestraint(Restraint):
    """Proxy of C++ IMP::kernel::internal::PythonRestraint class"""
    __swig_setmethods__ = {}
    for _s in [Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PythonRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PythonRestraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::internal::PythonRestraint self, Model m, std::string name="PythonRestraint%1%") -> PythonRestraint
        __init__(IMP::kernel::internal::PythonRestraint self, Model m) -> PythonRestraint
        __init__(IMP::kernel::internal::PythonRestraint self, std::string name="PythonRestraint%1%") -> PythonRestraint
        __init__(IMP::kernel::internal::PythonRestraint self) -> PythonRestraint
        """
        if self.__class__ == PythonRestraint:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_PythonRestraint(_self, *args)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != PythonRestraint:
            import IMP.base
            IMP.base._director_objects.register(self)



    def get_input_particles(self):
        """get_input_particles(PythonRestraint self) -> IMP::kernel::ParticlesTemp"""
        return _IMP_kernel.PythonRestraint_get_input_particles(self)

    def get_input_containers(self):
        """get_input_containers(PythonRestraint self) -> IMP::kernel::ContainersTemp"""
        return _IMP_kernel.PythonRestraint_get_input_containers(self)

    def do_get_inputs(self):
        """do_get_inputs(PythonRestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.PythonRestraint_do_get_inputs(self)

    def __str__(self):
        """__str__(PythonRestraint self) -> std::string"""
        return _IMP_kernel.PythonRestraint___str__(self)

    def __repr__(self):
        """__repr__(PythonRestraint self) -> std::string"""
        return _IMP_kernel.PythonRestraint___repr__(self)

    def get_from(o):
       return _object_cast_to_PythonRestraint(o)
    get_from = staticmethod(get_from)

    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::kernel::internal" == "IMP":
          return VersionInfo("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_PythonRestraint(o)
    get_from = staticmethod(get_from)

    __swig_destroy__ = _IMP_kernel.delete_PythonRestraint
    __del__ = lambda self : None;
    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_PythonRestraint(self)
        return weakref_proxy(self)
    def update_dependencies(self):
        """update_dependencies(PythonRestraint self)"""
        return _IMP_kernel.PythonRestraint_update_dependencies(self)

    def do_get_outputs(self):
        """do_get_outputs(PythonRestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.PythonRestraint_do_get_outputs(self)

    def do_get_interactions(self):
        """do_get_interactions(PythonRestraint self) -> IMP::kernel::ModelObjectsTemps"""
        return _IMP_kernel.PythonRestraint_do_get_interactions(self)

    def do_create_decomposition(self):
        """do_create_decomposition(PythonRestraint self) -> IMP::kernel::Restraints"""
        return _IMP_kernel.PythonRestraint_do_create_decomposition(self)

    def do_create_current_decomposition(self):
        """do_create_current_decomposition(PythonRestraint self) -> IMP::kernel::Restraints"""
        return _IMP_kernel.PythonRestraint_do_create_current_decomposition(self)

    def do_add_score_and_derivatives(self, *args):
        """do_add_score_and_derivatives(PythonRestraint self, ScoreAccumulator sa)"""
        return _IMP_kernel.PythonRestraint_do_add_score_and_derivatives(self, *args)

    def do_update_dependencies(self):
        """do_update_dependencies(PythonRestraint self)"""
        return _IMP_kernel.PythonRestraint_do_update_dependencies(self)

PythonRestraint_swigregister = _IMP_kernel.PythonRestraint_swigregister
PythonRestraint_swigregister(PythonRestraint)

class PythonScoreState(ScoreState):
    """Proxy of C++ IMP::kernel::internal::PythonScoreState class"""
    __swig_setmethods__ = {}
    for _s in [ScoreState]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PythonScoreState, name, value)
    __swig_getmethods__ = {}
    for _s in [ScoreState]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PythonScoreState, name)
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::internal::PythonScoreState self, std::string name="PythonScoreState%1%") -> PythonScoreState
        __init__(IMP::kernel::internal::PythonScoreState self) -> PythonScoreState
        __init__(IMP::kernel::internal::PythonScoreState self, Model m, std::string name="PythonScoreState%1%") -> PythonScoreState
        __init__(IMP::kernel::internal::PythonScoreState self, Model m) -> PythonScoreState
        """
        if self.__class__ == PythonScoreState:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_PythonScoreState(_self, *args)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != PythonScoreState:
            import IMP.base
            IMP.base._director_objects.register(self)



    def get_input_particles(self):
        """get_input_particles(PythonScoreState self) -> IMP::kernel::ParticlesTemp"""
        return _IMP_kernel.PythonScoreState_get_input_particles(self)

    def get_input_containers(self):
        """get_input_containers(PythonScoreState self) -> IMP::kernel::ContainersTemp"""
        return _IMP_kernel.PythonScoreState_get_input_containers(self)

    def get_output_particles(self):
        """get_output_particles(PythonScoreState self) -> IMP::kernel::ParticlesTemp"""
        return _IMP_kernel.PythonScoreState_get_output_particles(self)

    def get_output_containers(self):
        """get_output_containers(PythonScoreState self) -> IMP::kernel::ContainersTemp"""
        return _IMP_kernel.PythonScoreState_get_output_containers(self)

    def do_get_inputs(self):
        """do_get_inputs(PythonScoreState self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.PythonScoreState_do_get_inputs(self)

    def do_get_outputs(self):
        """do_get_outputs(PythonScoreState self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.PythonScoreState_do_get_outputs(self)

    def __str__(self):
        """__str__(PythonScoreState self) -> std::string"""
        return _IMP_kernel.PythonScoreState___str__(self)

    def __repr__(self):
        """__repr__(PythonScoreState self) -> std::string"""
        return _IMP_kernel.PythonScoreState___repr__(self)

    def get_from(o):
       return _object_cast_to_PythonScoreState(o)
    get_from = staticmethod(get_from)

    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::kernel::internal" == "IMP":
          return VersionInfo("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_PythonScoreState(o)
    get_from = staticmethod(get_from)

    __swig_destroy__ = _IMP_kernel.delete_PythonScoreState
    __del__ = lambda self : None;
    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_PythonScoreState(self)
        return weakref_proxy(self)
    def update_dependencies(self):
        """update_dependencies(PythonScoreState self)"""
        return _IMP_kernel.PythonScoreState_update_dependencies(self)

    def do_get_interactions(self):
        """do_get_interactions(PythonScoreState self) -> IMP::kernel::ModelObjectsTemps"""
        return _IMP_kernel.PythonScoreState_do_get_interactions(self)

    def do_before_evaluate(self):
        """do_before_evaluate(PythonScoreState self)"""
        return _IMP_kernel.PythonScoreState_do_before_evaluate(self)

    def do_after_evaluate(self, *args):
        """do_after_evaluate(PythonScoreState self, DerivativeAccumulator accpt)"""
        return _IMP_kernel.PythonScoreState_do_after_evaluate(self, *args)

    def do_update_dependencies(self):
        """do_update_dependencies(PythonScoreState self)"""
        return _IMP_kernel.PythonScoreState_do_update_dependencies(self)

PythonScoreState_swigregister = _IMP_kernel.PythonScoreState_swigregister
PythonScoreState_swigregister(PythonScoreState)


def _overloaded_particles(*args):
  """
    _overloaded_particles(Particle arg1)
    _overloaded_particles(IMP::kernel::Particles const & arg1)
    _overloaded_particles(IMP::kernel::ParticlesTemp const & arg1)
    _overloaded_particles(Model arg1, IMP::kernel::ParticleIndexes const & arg2)
    _overloaded_particles(IMP::kernel::internal::_TrivialDecorators const & arg1)
    _overloaded_particles(_TrivialDecorator arg1)
    """
  return _IMP_kernel._overloaded_particles(*args)
class _ImplicitParticles(_object):
    """Proxy of C++ IMP::kernel::internal::_ImplicitParticles class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _ImplicitParticles, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _ImplicitParticles, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::internal::_ImplicitParticles self, Particle arg2) -> _ImplicitParticles
        __init__(IMP::kernel::internal::_ImplicitParticles self, IMP::kernel::Particles const & arg2) -> _ImplicitParticles
        __init__(IMP::kernel::internal::_ImplicitParticles self, IMP::kernel::ParticlesTemp const & arg2) -> _ImplicitParticles
        __init__(IMP::kernel::internal::_ImplicitParticles self, Model arg2, IMP::kernel::ParticleIndexes const & arg3) -> _ImplicitParticles
        __init__(IMP::kernel::internal::_ImplicitParticles self, IMP::kernel::internal::_TrivialDecorators const & arg2) -> _ImplicitParticles
        __init__(IMP::kernel::internal::_ImplicitParticles self, _TrivialDecorator arg2) -> _ImplicitParticles
        """
        this = _IMP_kernel.new__ImplicitParticles(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _IMP_kernel.delete__ImplicitParticles
    __del__ = lambda self : None;
_ImplicitParticles_swigregister = _IMP_kernel._ImplicitParticles_swigregister
_ImplicitParticles_swigregister(_ImplicitParticles)


def _implicit_particles(*args):
  """_implicit_particles(_ImplicitParticles arg1)"""
  return _IMP_kernel._implicit_particles(*args)
class ScopedScoreState(IMP.base._RAII):
    """Proxy of C++ IMP::kernel::GenericScopedScoreState<(IMP::kernel::ScoreState)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base._RAII]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScopedScoreState, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base._RAII]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ScopedScoreState, name)
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::GenericScopedScoreState<(IMP::kernel::ScoreState)> self) -> ScopedScoreState
        __init__(IMP::kernel::GenericScopedScoreState<(IMP::kernel::ScoreState)> self, ScoreState ss, Model m) -> ScopedScoreState
        """
        this = _IMP_kernel.new_ScopedScoreState(*args)
        try: self.this.append(this)
        except: self.this = this
    def set(self, *args):
        """set(ScopedScoreState self, ScoreState ss, Model m)"""
        return _IMP_kernel.ScopedScoreState_set(self, *args)

    def reset(self):
        """reset(ScopedScoreState self)"""
        return _IMP_kernel.ScopedScoreState_reset(self)

    __swig_destroy__ = _IMP_kernel.delete_ScopedScoreState
    __del__ = lambda self : None;
    def show(self, *args):
        """
        show(ScopedScoreState self, _ostream out=std::cout)
        show(ScopedScoreState self)
        """
        return _IMP_kernel.ScopedScoreState_show(self, *args)

    def get_is_set(self):
        """get_is_set(ScopedScoreState self) -> bool"""
        return _IMP_kernel.ScopedScoreState_get_is_set(self)

    def __str__(self):
        """__str__(ScopedScoreState self) -> std::string"""
        return _IMP_kernel.ScopedScoreState___str__(self)

    def __repr__(self):
        """__repr__(ScopedScoreState self) -> std::string"""
        return _IMP_kernel.ScopedScoreState___repr__(self)

ScopedScoreState_swigregister = _IMP_kernel.ScopedScoreState_swigregister
ScopedScoreState_swigregister(ScopedScoreState)

class ScopedRestraint(IMP.base._RAII):
    """Proxy of C++ IMP::kernel::GenericScopedRestraint<(IMP::kernel::Restraint)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base._RAII]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScopedRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base._RAII]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ScopedRestraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::GenericScopedRestraint<(IMP::kernel::Restraint)> self) -> ScopedRestraint
        __init__(IMP::kernel::GenericScopedRestraint<(IMP::kernel::Restraint)> self, Restraint ss, RestraintSet rs) -> ScopedRestraint
        """
        this = _IMP_kernel.new_ScopedRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def set(self, *args):
        """set(ScopedRestraint self, Restraint ss, RestraintSet rs)"""
        return _IMP_kernel.ScopedRestraint_set(self, *args)

    def reset(self):
        """reset(ScopedRestraint self)"""
        return _IMP_kernel.ScopedRestraint_reset(self)

    __swig_destroy__ = _IMP_kernel.delete_ScopedRestraint
    __del__ = lambda self : None;
    def show(self, *args):
        """
        show(ScopedRestraint self, _ostream out=std::cout)
        show(ScopedRestraint self)
        """
        return _IMP_kernel.ScopedRestraint_show(self, *args)

    def get_is_set(self):
        """get_is_set(ScopedRestraint self) -> bool"""
        return _IMP_kernel.ScopedRestraint_get_is_set(self)

    def __str__(self):
        """__str__(ScopedRestraint self) -> std::string"""
        return _IMP_kernel.ScopedRestraint___str__(self)

    def __repr__(self):
        """__repr__(ScopedRestraint self) -> std::string"""
        return _IMP_kernel.ScopedRestraint___repr__(self)

ScopedRestraint_swigregister = _IMP_kernel.ScopedRestraint_swigregister
ScopedRestraint_swigregister(ScopedRestraint)

class ScopedRemoveRestraint(IMP.base._RAII):
    """Proxy of C++ IMP::kernel::GenericScopedRemoveRestraint<(IMP::kernel::Restraint)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base._RAII]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScopedRemoveRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base._RAII]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ScopedRemoveRestraint, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::GenericScopedRemoveRestraint<(IMP::kernel::Restraint)> self) -> ScopedRemoveRestraint
        __init__(IMP::kernel::GenericScopedRemoveRestraint<(IMP::kernel::Restraint)> self, Restraint ss, RestraintSet rs) -> ScopedRemoveRestraint
        """
        this = _IMP_kernel.new_ScopedRemoveRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def set(self, *args):
        """set(ScopedRemoveRestraint self, Restraint ss, RestraintSet rs)"""
        return _IMP_kernel.ScopedRemoveRestraint_set(self, *args)

    def reset(self):
        """reset(ScopedRemoveRestraint self)"""
        return _IMP_kernel.ScopedRemoveRestraint_reset(self)

    __swig_destroy__ = _IMP_kernel.delete_ScopedRemoveRestraint
    __del__ = lambda self : None;
    def show(self, *args):
        """
        show(ScopedRemoveRestraint self, _ostream out=std::cout)
        show(ScopedRemoveRestraint self)
        """
        return _IMP_kernel.ScopedRemoveRestraint_show(self, *args)

    def get_is_set(self):
        """get_is_set(ScopedRemoveRestraint self) -> bool"""
        return _IMP_kernel.ScopedRemoveRestraint_get_is_set(self)

ScopedRemoveRestraint_swigregister = _IMP_kernel.ScopedRemoveRestraint_swigregister
ScopedRemoveRestraint_swigregister(ScopedRemoveRestraint)

class ScopedRemoveScoreState(IMP.base._RAII):
    """Proxy of C++ IMP::kernel::GenericScopedRemoveScoreState<(IMP::kernel::ScoreState)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base._RAII]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScopedRemoveScoreState, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base._RAII]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ScopedRemoveScoreState, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::GenericScopedRemoveScoreState<(IMP::kernel::ScoreState)> self) -> ScopedRemoveScoreState
        __init__(IMP::kernel::GenericScopedRemoveScoreState<(IMP::kernel::ScoreState)> self, ScoreState ss, Model rs) -> ScopedRemoveScoreState
        """
        this = _IMP_kernel.new_ScopedRemoveScoreState(*args)
        try: self.this.append(this)
        except: self.this = this
    def set(self, *args):
        """set(ScopedRemoveScoreState self, ScoreState ss, Model rs)"""
        return _IMP_kernel.ScopedRemoveScoreState_set(self, *args)

    def reset(self):
        """reset(ScopedRemoveScoreState self)"""
        return _IMP_kernel.ScopedRemoveScoreState_reset(self)

    __swig_destroy__ = _IMP_kernel.delete_ScopedRemoveScoreState
    __del__ = lambda self : None;
    def show(self, *args):
        """
        show(ScopedRemoveScoreState self, _ostream out=std::cout)
        show(ScopedRemoveScoreState self)
        """
        return _IMP_kernel.ScopedRemoveScoreState_show(self, *args)

    def get_is_set(self):
        """get_is_set(ScopedRemoveScoreState self) -> bool"""
        return _IMP_kernel.ScopedRemoveScoreState_get_is_set(self)

ScopedRemoveScoreState_swigregister = _IMP_kernel.ScopedRemoveScoreState_swigregister
ScopedRemoveScoreState_swigregister(ScopedRemoveScoreState)

class ScopedSetFloatAttribute(IMP.base._RAII):
    """Proxy of C++ IMP::kernel::ScopedSetAttribute<(FloatKey,IMP::Float)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base._RAII]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScopedSetFloatAttribute, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base._RAII]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ScopedSetFloatAttribute, name)
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::ScopedSetAttribute<(FloatKey,IMP::Float)> self) -> ScopedSetFloatAttribute
        __init__(IMP::kernel::ScopedSetAttribute<(FloatKey,IMP::Float)> self, Particle p, FloatKey key, double const & value) -> ScopedSetFloatAttribute
        """
        this = _IMP_kernel.new_ScopedSetFloatAttribute(*args)
        try: self.this.append(this)
        except: self.this = this
    def set(self, *args):
        """set(ScopedSetFloatAttribute self, Particle p, FloatKey key, double const & value)"""
        return _IMP_kernel.ScopedSetFloatAttribute_set(self, *args)

    def reset(self):
        """reset(ScopedSetFloatAttribute self)"""
        return _IMP_kernel.ScopedSetFloatAttribute_reset(self)

    __swig_destroy__ = _IMP_kernel.delete_ScopedSetFloatAttribute
    __del__ = lambda self : None;
    def show(self, *args):
        """
        show(ScopedSetFloatAttribute self, _ostream out=std::cout)
        show(ScopedSetFloatAttribute self)
        """
        return _IMP_kernel.ScopedSetFloatAttribute_show(self, *args)

    def __str__(self):
        """__str__(ScopedSetFloatAttribute self) -> std::string"""
        return _IMP_kernel.ScopedSetFloatAttribute___str__(self)

    def __repr__(self):
        """__repr__(ScopedSetFloatAttribute self) -> std::string"""
        return _IMP_kernel.ScopedSetFloatAttribute___repr__(self)

ScopedSetFloatAttribute_swigregister = _IMP_kernel.ScopedSetFloatAttribute_swigregister
ScopedSetFloatAttribute_swigregister(ScopedSetFloatAttribute)

#used_modules=[]
#def show_used_modules():
#    for m in used_modules:
#        print "%-20s %s" % (m.get_module(), m.get_version())


import IMP.base
get_networkx_graph=IMP.base.get_networkx_graph
show_altgraph=IMP.base.show_altgraph
show_graphviz=IMP.base.show_graphviz
SetLogState= IMP.base.SetLogState
SetLogTarget= IMP.base.SetLogTarget
Object= IMP.base.Object
NONE= IMP.base.NONE
USAGE= IMP.base.USAGE
USAGE_AND_INTERNAL= IMP.base.USAGE_AND_INTERNAL
TERSE= IMP.base.TERSE
SILENT= IMP.base.SILENT
VERBOSE= IMP.base.VERBOSE
WARNING= IMP.base.WARNING
PROGRESS= IMP.base.PROGRESS
MEMORY= IMP.base.MEMORY
create_temporary_file= IMP.base.create_temporary_file
create_temporary_file_name= IMP.base.create_temporary_file_name
random_number_generator= IMP.base.random_number_generator
set_log_level=IMP.base.set_log_level
set_log_timer=IMP.base.set_log_timer
get_log_level=IMP.base.get_log_level
add_to_log= IMP.base.add_to_log
set_check_level= IMP.base.set_check_level
get_check_level= IMP.base.get_check_level

# Ensure that Windows gets the PATH set to include anything in the library
# search path
if sys.platform == 'win32' and 'IMP_LD_PATH' in os.environ:
    dirs = os.environ['IMP_LD_PATH'].split(":")
    pathcomps = os.environ['PATH'].split(";")
    for d in dirs:
        if d not in pathcomps:
            os.environ['PATH'] = d + ';' + os.environ['PATH']

RestraintBase=Restraint
ScoreStateBase=ScoreState
Restraint=PythonRestraint
ScoreState=PythonScoreState
IOException=IMP.base.IOException
ValueException=IMP.base.ValueException
ModelException=IMP.base.ModelException
IOException=IMP.base.IOException
IOException=IMP.base.IOException

import sys
import os

class CommandDispatcher(object):
    """Allow applications to easily implement commmands.
       Typically, an IMP application will use an instance of this class
       to provide a consistent interface to multiple distinct commands
       from a single binary, rather than providing a potentially large
       number of binaries.

       Each command is implemented with a Python module of the same name
       that can be imported from the module (for example, if module_name
       is 'IMP.foo', the 'bar' command is provided by the IMP.foo.bar Python
       module, which would usually be found as modules/foo/pyext/src/bar.py).
       Each such module should have a docstring (__doc__) and a main() method
       that takes no arguments (the module should also call its main() method
       if it is run directly, i.e. with something like
       'if __name__=="__main__": main()'). The encompassing module
       ('IMP.foo' in the example) should define _all_commands as a Python
       list of all valid commands.

       @param short_help A few words that describe the application.
       @param long_help Longer text, used in the 'help' command.
       @param module_name Name of the module (e.g. 'IMP.foo') that implements
                          the commands.
    """

    def __init__(self, short_help, long_help, module_name):
        self.short_help = short_help
        self.long_help = long_help
        self.module_name = module_name
        self._all_commands = self.import_module()._all_commands
        self._progname = os.path.basename(sys.argv[0])

    def main(self):
        if len(sys.argv) <= 1:
            print self.short_help + " Use '%s help' for help." % self._progname
        else:
            command = sys.argv[1]
            if command in ('help', '--help', '-h'):
                if len(sys.argv) == 3:
                    self.show_command_help(sys.argv[2])
                else:
                    self.show_help()
            elif command == '--version':
                self.show_version()
            elif command in self._all_commands:
                self.do_command(command)
            else:
                self.unknown_command(command)

    def import_module(self, mod=None):
        modname = self.module_name
        if mod is not None:
            modname += "." + mod
        return __import__(modname, {}, {}, [''])

    def unknown_command(self, command):
        print "Unknown command: '%s'" % command
        print "Use '%s help' for help." % self._progname
        sys.exit(1)

    def _get_version(self):
        return self.import_module().get_module_version()

    def show_version(self):
        print self._progname + ' ' + self._get_version()

    def show_help(self):
        ver = self._get_version()
        print "%s, version %s." % (self._progname, ver)
        print self.long_help + """

This program is part of IMP, the Integrative Modeling Platform,
which is Copyright 2007-2013 IMP Inventors.
For additional information about IMP, see http://salilab.org/imp/

Usage: %s <command> [options] [args]

Commands:""" % self._progname
        commands = self._all_commands[:] + ['help']
        commands.sort()
        cmdlen = max([len(c) for c in commands])
        for c in commands:
            if c == 'help':
                doc = 'Get help on using %s.' % self._progname
            else:
                doc = self.import_module(c).__doc__ or "<no help>"
            c += ' ' * (cmdlen - len(c))
            print '    ' + c + '  ' + doc
        print """
Use "%s help <command>" for detailed help on any command
 or "%s --version" to see the version number.""" % (self._progname,
                                                    self._progname)

    def do_command(self, command):
        mod = self.import_module(command)
        sys.argv[0] = self._progname + ' ' + command
        del sys.argv[1]
        mod.main()

    def show_command_help(self, command):
        if command == 'help':
            self.show_help()
        elif command in self._all_commands or command == 'help':
            mod = self.import_module(command)
            sys.argv = [self._progname + ' ' + command, '--help']
            mod.main()
        else:
            self.unknown_command(command)


import optparse
class OptionParser(optparse.OptionParser):
    """IMP-specific subclass of optparse.OptionParser.
       Please use the flags support in IMP.base. See IMP::base::add_string_flag()
       and IMP::base::setup_from_argv() for example.
    """
    def __init__(self, imp_module=None, version=None, *args, **keys):
        if version is None:
            if imp_module is not None:
                version = "%prog " + imp_module.get_module_version()
            else:
                raise ValueError("Must supply either version or "
                                 "imp_module arguments")
        optparse.OptionParser.__init__(self, version=version, *args, **keys)

    def format_epilog(self, formatter):
        # Add IMP copyright and help info to epilog
        return optparse.OptionParser.format_epilog(self, formatter) + """
This program is part of IMP, the Integrative Modeling Platform,
which is Copyright 2007-2013 IMP Inventors.
For additional information about IMP, see http://salilab.org/imp/
"""


def get_module_version():
  """get_module_version() -> std::string const"""
  return _IMP_kernel.get_module_version()

def get_example_path(*args):
  """get_example_path(std::string fname) -> std::string"""
  return _IMP_kernel.get_example_path(*args)

def get_data_path(*args):
  """get_data_path(std::string fname) -> std::string"""
  return _IMP_kernel.get_data_path(*args)
import _version_check
_version_check.check_version(get_module_version())

# This file is compatible with both classic and new-style classes.