kernel/__init__.py

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 2.0.11
#
# 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_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_MEMORY = _IMP_kernel.IMP_MEMORY
IMP_NONE = _IMP_kernel.IMP_NONE
IMP_USAGE = _IMP_kernel.IMP_USAGE
IMP_INTERNAL = _IMP_kernel.IMP_INTERNAL
IMP_BASE_HAS_LOG4CXX = _IMP_kernel.IMP_BASE_HAS_LOG4CXX
IMP_COMPILER_HAS_AUTO = _IMP_kernel.IMP_COMPILER_HAS_AUTO
IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_kernel.IMP_COMPILER_HAS_DEBUG_VECTOR
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_TCMALLOC_HEAPCHECKER = _IMP_kernel.IMP_BASE_HAS_TCMALLOC_HEAPCHECKER
IMP_BASE_HAS_TCMALLOC_HEAPPROFILER = _IMP_kernel.IMP_BASE_HAS_TCMALLOC_HEAPPROFILER
IMPBASE_SHOW_WARNINGS = _IMP_kernel.IMPBASE_SHOW_WARNINGS
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
IMP_HAS_NOEXCEPT = _IMP_kernel.IMP_HAS_NOEXCEPT
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
IMPCGAL_SHOW_WARNINGS = _IMP_kernel.IMPCGAL_SHOW_WARNINGS
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
IMPALGEBRA_SHOW_WARNINGS = _IMP_kernel.IMPALGEBRA_SHOW_WARNINGS
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
IMPKERNEL_SHOW_WARNINGS = _IMP_kernel.IMPKERNEL_SHOW_WARNINGS
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("AttributeOptimizer")


def _object_cast_to_AttributeOptimizer(*args):
  """_object_cast_to_AttributeOptimizer(Object o) -> AttributeOptimizer"""
  return _IMP_kernel._object_cast_to_AttributeOptimizer(*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("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")

_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,IMP::kernel::ShowDependencyGraphVertex)> 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,IMP::kernel::ShowDependencyGraphVertex)> 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 *,IMP::kernel::ShowDependencyGraphVertex >::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 *,IMP::kernel::ShowDependencyGraphVertex >::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 *,IMP::kernel::ShowDependencyGraphVertex >::VertexDescriptor v) -> IMP::base::internal::BoostDigraph< IMP::kernel::DependencyGraph,IMP::kernel::ModelObject *,IMP::kernel::ShowDependencyGraphVertex >::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 *,IMP::kernel::ShowDependencyGraphVertex >::VertexDescriptor v) -> IMP::base::internal::BoostDigraph< IMP::kernel::DependencyGraph,IMP::kernel::ModelObject *,IMP::kernel::ShowDependencyGraphVertex >::VertexDescriptors"""
        return _IMP_kernel.DependencyGraph_get_out_neighbors(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 add_edge(self, *args):
        """
        add_edge(DependencyGraph self, IMP::base::internal::BoostDigraph< IMP::kernel::DependencyGraph,IMP::kernel::ModelObject *,IMP::kernel::ShowDependencyGraphVertex >::VertexDescriptor v0, 
            IMP::base::internal::BoostDigraph< IMP::kernel::DependencyGraph,IMP::kernel::ModelObject *,IMP::kernel::ShowDependencyGraphVertex >::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 *,IMP::kernel::ShowDependencyGraphVertex >::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 *,IMP::kernel::ShowDependencyGraphVertex >::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)

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)
    __swig_destroy__ = _IMP_kernel.delete_ModelObject
    __del__ = lambda self : None;
    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 get_has_dependencies(self):
        """get_has_dependencies(ModelObject self) -> bool"""
        return _IMP_kernel.ModelObject_get_has_dependencies(self)

    def set_has_dependencies(self, *args):
        """set_has_dependencies(ModelObject self, bool tf)"""
        return _IMP_kernel.ModelObject_set_has_dependencies(self, *args)

    def set_has_required_score_states(self, *args):
        """set_has_required_score_states(ModelObject self, bool tf)"""
        return _IMP_kernel.ModelObject_set_has_required_score_states(self, *args)

    def get_has_required_score_states(self):
        """get_has_required_score_states(ModelObject self) -> bool"""
        return _IMP_kernel.ModelObject_get_has_required_score_states(self)

    def get_required_score_states(self):
        """get_required_score_states(ModelObject self) -> IMP::kernel::ScoreStatesTemp const &"""
        return _IMP_kernel.ModelObject_get_required_score_states(self)

    def handle_set_has_required_score_states(self, *args):
        """handle_set_has_required_score_states(ModelObject self, bool arg0)"""
        return _IMP_kernel.ModelObject_handle_set_has_required_score_states(self, *args)

    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)

    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 do_set_model(self, *args):
        """do_set_model(ModelObject self, Model arg0)"""
        return _IMP_kernel.ModelObject_do_set_model(self, *args)

    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

class _ParticleInputs(_object):
    """Proxy of C++ IMP::kernel::ParticleInputs class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _ParticleInputs, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _ParticleInputs, name)
    __repr__ = _swig_repr
    def get_inputs(self, *args):
        """get_inputs(_ParticleInputs self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel._ParticleInputs_get_inputs(self, *args)

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

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

    def __init__(self): 
        """__init__(IMP::kernel::ParticleInputs self) -> _ParticleInputs"""
        this = _IMP_kernel.new__ParticleInputs()
        try: self.this.append(this)
        except: self.this = this
_ParticleInputs_swigregister = _IMP_kernel._ParticleInputs_swigregister
_ParticleInputs_swigregister(_ParticleInputs)

class _ParticleOutputs(_object):
    """Proxy of C++ IMP::kernel::ParticleOutputs class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _ParticleOutputs, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _ParticleOutputs, name)
    __repr__ = _swig_repr
    def get_outputs(self, *args):
        """get_outputs(_ParticleOutputs self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel._ParticleOutputs_get_outputs(self, *args)

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

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

    def __init__(self): 
        """__init__(IMP::kernel::ParticleOutputs self) -> _ParticleOutputs"""
        this = _IMP_kernel.new__ParticleOutputs()
        try: self.this.append(this)
        except: self.this = this
_ParticleOutputs_swigregister = _IMP_kernel._ParticleOutputs_swigregister
_ParticleOutputs_swigregister(_ParticleOutputs)


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) -> 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 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 get_has_update_order(self):
        """get_has_update_order(ScoreState self) -> bool"""
        return _IMP_kernel.ScoreState_get_has_update_order(self)

    def get_update_order(self):
        """get_update_order(ScoreState self) -> unsigned int"""
        return _IMP_kernel.ScoreState_get_update_order(self)

    def handle_set_has_required_score_states(self, *args):
        """handle_set_has_required_score_states(ScoreState self, bool tf)"""
        return _IMP_kernel.ScoreState_handle_set_has_required_score_states(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 __init__(self, *args): 
        """
        __init__(IMP::kernel::ScoreState self, Model m, std::string name) -> ScoreState
        __init__(IMP::kernel::ScoreState self, Model m) -> ScoreState
        __init__(IMP::kernel::ScoreState self, std::string name="ScoreState %1%") -> ScoreState
        __init__(IMP::kernel::ScoreState self) -> 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 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 __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 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 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)

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_is_changed(self):
        """get_is_changed(Container self) -> bool"""
        return _IMP_kernel.Container_get_is_changed(self)

    def get_contents_version(self):
        """get_contents_version(Container self) -> int"""
        return _IMP_kernel.Container_get_contents_version(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)

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

    __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 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)

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_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 handle_set_has_required_score_states(self, *args):
        """handle_set_has_required_score_states(Restraint self, bool arg0)"""
        return _IMP_kernel.Restraint_handle_set_has_required_score_states(self, *args)

    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 _RestraintsAdaptor(IMP.base._InputAdaptor):
    """Proxy of C++ IMP::kernel::RestraintsAdaptor class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base._InputAdaptor]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _RestraintsAdaptor, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base._InputAdaptor]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _RestraintsAdaptor, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::RestraintsAdaptor self) -> _RestraintsAdaptor
        __init__(IMP::kernel::RestraintsAdaptor self, IMP::kernel::Restraints const & sf) -> _RestraintsAdaptor
        __init__(IMP::kernel::RestraintsAdaptor self, IMP::kernel::RestraintsTemp const & sf) -> _RestraintsAdaptor
        __init__(IMP::kernel::RestraintsAdaptor self, Restraint sf) -> _RestraintsAdaptor
        __init__(IMP::kernel::RestraintsAdaptor self, Model sf) -> _RestraintsAdaptor
        __init__(IMP::kernel::RestraintsAdaptor self, IMP::kernel::ModelsTemp const & sf) -> _RestraintsAdaptor
        """
        this = _IMP_kernel.new__RestraintsAdaptor(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _IMP_kernel.delete__RestraintsAdaptor
    __del__ = lambda self : None;
_RestraintsAdaptor_swigregister = _IMP_kernel._RestraintsAdaptor_swigregister
_RestraintsAdaptor_swigregister(_RestraintsAdaptor)

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, Model m, std::string const & name="RestraintSet %1%") -> RestraintSet
        __init__(IMP::kernel::RestraintSet self, Model m) -> 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
        """
        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)

    __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 show(self, *args):
        """
        show(Particle self, _ostream out=std::cout)
        show(Particle self)
        """
        return _IMP_kernel.Particle_show(self, *args)

    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 _ParticleAdaptor(IMP.base._InputAdaptor):
    """Proxy of C++ IMP::kernel::ParticleAdaptor class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base._InputAdaptor]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _ParticleAdaptor, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base._InputAdaptor]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _ParticleAdaptor, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::ParticleAdaptor self) -> _ParticleAdaptor
        __init__(IMP::kernel::ParticleAdaptor self, Particle p) -> _ParticleAdaptor
        __init__(IMP::kernel::ParticleAdaptor self, Decorator d) -> _ParticleAdaptor
        """
        this = _IMP_kernel.new__ParticleAdaptor(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_model(self):
        """get_model(_ParticleAdaptor self) -> Model"""
        return _IMP_kernel._ParticleAdaptor_get_model(self)

    def get_particle_index(self):
        """get_particle_index(_ParticleAdaptor self) -> IMP::kernel::ParticleIndex"""
        return _IMP_kernel._ParticleAdaptor_get_particle_index(self)

    __swig_destroy__ = _IMP_kernel.delete__ParticleAdaptor
    __del__ = lambda self : None;
_ParticleAdaptor_swigregister = _IMP_kernel._ParticleAdaptor_swigregister
_ParticleAdaptor_swigregister(_ParticleAdaptor)

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 show_as_graphviz(*args):
  """show_as_graphviz(IMP::kernel::DependencyGraph const & name, TextOutput out)"""
  return _IMP_kernel.show_as_graphviz(*args)

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_required_score_states(*args):
  """
    get_required_score_states(IMP::kernel::ModelObjectsTemp const & mos, IMP::kernel::ScoreStatesTemp exclude=IMP::kernel::ScoreStatesTemp()) -> IMP::kernel::ScoreStatesTemp
    get_required_score_states(IMP::kernel::ModelObjectsTemp const & mos) -> IMP::kernel::ScoreStatesTemp
    get_required_score_states(ModelObject p, IMP::kernel::ModelObjectsTemp const & all, IMP::kernel::DependencyGraph const & dg, 
        _DependencyGraphVertexIndex index) -> IMP::kernel::ScoreStatesTemp
    """
  return _IMP_kernel.get_required_score_states(*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_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_dependent_restraints(*args):
  """
    get_dependent_restraints(ModelObject p, IMP::kernel::ModelObjectsTemp const & all, IMP::kernel::DependencyGraph const & dg, 
        _DependencyGraphVertexIndex index) -> IMP::kernel::RestraintsTemp
    get_dependent_restraints(Model m, IMP::kernel::ParticleIndex pi) -> IMP::kernel::RestraintsTemp
    """
  return _IMP_kernel.get_dependent_restraints(*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_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_outputs(self):
        """do_get_outputs(ScoringFunction self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.ScoringFunction_do_get_outputs(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 __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 handle_set_has_required_score_states(self, *args):
        """handle_set_has_required_score_states(ScoringFunction self, bool arg0)"""
        return _IMP_kernel.ScoringFunction_handle_set_has_required_score_states(self, *args)

    def do_get_inputs(self):
        """do_get_inputs(ScoringFunction self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.ScoringFunction_do_get_inputs(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, Restraint sf) -> _ScoringFunctionAdaptor
        __init__(IMP::kernel::ScoringFunctionAdaptor self, Model 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 Model(IMP.base.Object):
    """Proxy of C++ IMP::kernel::Model class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Model, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Model, name)
    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 clear_particle_caches(self, *args):
        """clear_particle_caches(Model self, IMP::kernel::ParticleIndex pi)"""
        return _IMP_kernel.Model_clear_particle_caches(self, *args)

    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_particle_name(self, *args):
        """get_particle_name(Model self, IMP::kernel::ParticleIndex pi) -> std::string"""
        return _IMP_kernel.Model_get_particle_name(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 update(self):
        """update(Model self)"""
        return _IMP_kernel.Model_update(self)

    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 get_particle(self, *args):
        """get_particle(Model self, IMP::kernel::ParticleIndex p) -> Particle"""
        return _IMP_kernel.Model_get_particle(self, *args)

    def get_has_particle(self, *args):
        """get_has_particle(Model self, IMP::kernel::ParticleIndex p) -> bool"""
        return _IMP_kernel.Model_get_has_particle(self, *args)

    def get_particle_indexes(self):
        """get_particle_indexes(Model self) -> IMP::kernel::ParticleIndexes"""
        return _IMP_kernel.Model_get_particle_indexes(self)

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

    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_version_info(self):
        """get_version_info(Model self) -> VersionInfo"""
        return _IMP_kernel.Model_get_version_info(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_model_scoring_function(self):
        """create_model_scoring_function(Model self) -> ScoringFunction"""
        return _IMP_kernel.Model_create_model_scoring_function(self)

    def add_restraint(self, *args):
        """add_restraint(Model self, Restraint r)"""
        return _IMP_kernel.Model_add_restraint(self, *args)

    def remove_restraint(self, *args):
        """remove_restraint(Model self, Restraint r)"""
        return _IMP_kernel.Model_remove_restraint(self, *args)

    def get_restraints(self):
        """get_restraints(Model self) -> IMP::kernel::RestraintsTemp"""
        return _IMP_kernel.Model_get_restraints(self)

    def create_scoring_function(self):
        """create_scoring_function(Model self) -> ScoringFunction"""
        return _IMP_kernel.Model_create_scoring_function(self)

    def get_number_of_restraints(self):
        """get_number_of_restraints(Model self) -> unsigned int"""
        return _IMP_kernel.Model_get_number_of_restraints(self)

    def get_restraint(self, *args):
        """get_restraint(Model self, unsigned int i) -> Restraint"""
        return _IMP_kernel.Model_get_restraint(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 remove_particle(self, *args):
        """
        remove_particle(Model self, IMP::kernel::ParticleIndex pi)
        remove_particle(Model self, Particle p)
        """
        return _IMP_kernel.Model_remove_particle(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_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 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 __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, _ParticleAdaptor p) -> 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(ModelObject):
    """Proxy of C++ IMP::kernel::OptimizerState class"""
    __swig_setmethods__ = {}
    for _s in [ModelObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, OptimizerState, name, value)
    __swig_getmethods__ = {}
    for _s in [ModelObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, OptimizerState, name)
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::OptimizerState self, Model m, std::string name) -> OptimizerState
        __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, *args)
        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)

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

    def get_period(self):
        """get_period(OptimizerState self) -> unsigned int"""
        return _IMP_kernel.OptimizerState_get_period(self)

    def reset(self):
        """reset(OptimizerState self)"""
        return _IMP_kernel.OptimizerState_reset(self)

    def update_always(self):
        """update_always(OptimizerState self)"""
        return _IMP_kernel.OptimizerState_update_always(self)

    def get_number_of_updates(self):
        """get_number_of_updates(OptimizerState self) -> unsigned int"""
        return _IMP_kernel.OptimizerState_get_number_of_updates(self)

    def set_number_of_updates(self, *args):
        """set_number_of_updates(OptimizerState self, unsigned int n)"""
        return _IMP_kernel.OptimizerState_set_number_of_updates(self, *args)

    __swig_destroy__ = _IMP_kernel.delete_OptimizerState
    __del__ = lambda self : None;
    def do_update(self, *args):
        """do_update(OptimizerState self, unsigned int arg0)"""
        return _IMP_kernel.OptimizerState_do_update(self, *args)

    def do_set_is_optimizing(self, *args):
        """do_set_is_optimizing(OptimizerState self, bool arg0)"""
        return _IMP_kernel.OptimizerState_do_set_is_optimizing(self, *args)

    def do_get_inputs(self):
        """do_get_inputs(OptimizerState self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.OptimizerState_do_get_inputs(self)

    def do_get_outputs(self):
        """do_get_outputs(OptimizerState self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.OptimizerState_do_get_outputs(self)

    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)
    def handle_set_has_required_score_states(self, *args):
        """handle_set_has_required_score_states(OptimizerState self, bool arg0)"""
        return _IMP_kernel.OptimizerState_handle_set_has_required_score_states(self, *args)

    def do_get_interactions(self):
        """do_get_interactions(OptimizerState self) -> IMP::kernel::ModelObjectsTemps"""
        return _IMP_kernel.OptimizerState_do_get_interactions(self)

OptimizerState_swigregister = _IMP_kernel.OptimizerState_swigregister
OptimizerState_swigregister(OptimizerState)

class Refiner(_ParticleInputs,IMP.base.Object):
    """Proxy of C++ IMP::kernel::Refiner class"""
    __swig_setmethods__ = {}
    for _s in [_ParticleInputs,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 [_ParticleInputs,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_indexes(self, *args):
        """get_refined_indexes(Refiner self, Model m, IMP::kernel::ParticleIndex pi) -> IMP::kernel::ParticleIndexes"""
        return _IMP_kernel.Refiner_get_refined_indexes(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 __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)
    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)

Refiner_swigregister = _IMP_kernel.Refiner_swigregister
Refiner_swigregister(Refiner)

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

    def get_optimizer_state_inputs(self):
        """get_optimizer_state_inputs(Optimizer self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.Optimizer_get_optimizer_state_inputs(self)

    def do_get_inputs(self):
        """do_get_inputs(Optimizer self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.Optimizer_do_get_inputs(self)

    def do_get_outputs(self):
        """do_get_outputs(Optimizer self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.Optimizer_do_get_outputs(self)

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

    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 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)

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


        pass

    def get_restraints(self):
        """get_restraints(Optimizer self) -> IMP::kernel::Restraints"""
        return _IMP_kernel.Optimizer_get_restraints(self)

    def __init__(self, *args): 
        """
        __init__(IMP::kernel::Optimizer self, Model m, std::string name="Optimizer %1%") -> Optimizer
        __init__(IMP::kernel::Optimizer self, Model m) -> Optimizer
        __init__(IMP::kernel::Optimizer self) -> 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 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_restraints(self, *args):
        """set_restraints(Optimizer self, IMP::kernel::RestraintsTemp const & rs)"""
        return _IMP_kernel.Optimizer_set_restraints(self, *args)

    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 __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)
    def handle_set_has_required_score_states(self, *args):
        """handle_set_has_required_score_states(Optimizer self, bool arg0)"""
        return _IMP_kernel.Optimizer_handle_set_has_required_score_states(self, *args)

    def do_get_interactions(self):
        """do_get_interactions(Optimizer self) -> IMP::kernel::ModelObjectsTemps"""
        return _IMP_kernel.Optimizer_do_get_interactions(self)

Optimizer_swigregister = _IMP_kernel.Optimizer_swigregister
Optimizer_swigregister(Optimizer)

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



    def get_optimized_attributes(self):
        """get_optimized_attributes(AttributeOptimizer self) -> IMP::kernel::FloatIndexes"""
        return _IMP_kernel.AttributeOptimizer_get_optimized_attributes(self)

    def set_value(self, *args):
        """set_value(AttributeOptimizer self, FloatIndex fi, double v)"""
        return _IMP_kernel.AttributeOptimizer_set_value(self, *args)

    def get_value(self, *args):
        """get_value(AttributeOptimizer self, FloatIndex fi) -> IMP::Float"""
        return _IMP_kernel.AttributeOptimizer_get_value(self, *args)

    def get_derivative(self, *args):
        """get_derivative(AttributeOptimizer self, FloatIndex fi) -> IMP::Float"""
        return _IMP_kernel.AttributeOptimizer_get_derivative(self, *args)

    def get_width(self, *args):
        """get_width(AttributeOptimizer self, FloatKey k) -> double"""
        return _IMP_kernel.AttributeOptimizer_get_width(self, *args)

    def set_scaled_value(self, *args):
        """set_scaled_value(AttributeOptimizer self, FloatIndex fi, IMP::Float v)"""
        return _IMP_kernel.AttributeOptimizer_set_scaled_value(self, *args)

    def get_scaled_value(self, *args):
        """get_scaled_value(AttributeOptimizer self, FloatIndex fi) -> double"""
        return _IMP_kernel.AttributeOptimizer_get_scaled_value(self, *args)

    def get_scaled_derivative(self, *args):
        """get_scaled_derivative(AttributeOptimizer self, FloatIndex fi) -> double"""
        return _IMP_kernel.AttributeOptimizer_get_scaled_derivative(self, *args)

    def clear_range_cache(self):
        """clear_range_cache(AttributeOptimizer self)"""
        return _IMP_kernel.AttributeOptimizer_clear_range_cache(self)

    def __str__(self):
        """__str__(AttributeOptimizer self) -> std::string"""
        return _IMP_kernel.AttributeOptimizer___str__(self)

    def __repr__(self):
        """__repr__(AttributeOptimizer self) -> std::string"""
        return _IMP_kernel.AttributeOptimizer___repr__(self)

    def get_from(o):
       return _object_cast_to_AttributeOptimizer(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_AttributeOptimizer(o)
    get_from = staticmethod(get_from)

    __swig_destroy__ = _IMP_kernel.delete_AttributeOptimizer
    __del__ = lambda self : None;
    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_AttributeOptimizer(self)
        return weakref_proxy(self)
    def handle_set_has_required_score_states(self, *args):
        """handle_set_has_required_score_states(AttributeOptimizer self, bool arg0)"""
        return _IMP_kernel.AttributeOptimizer_handle_set_has_required_score_states(self, *args)

    def do_get_inputs(self):
        """do_get_inputs(AttributeOptimizer self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.AttributeOptimizer_do_get_inputs(self)

    def do_get_outputs(self):
        """do_get_outputs(AttributeOptimizer self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel.AttributeOptimizer_do_get_outputs(self)

    def do_get_interactions(self):
        """do_get_interactions(AttributeOptimizer self) -> IMP::kernel::ModelObjectsTemps"""
        return _IMP_kernel.AttributeOptimizer_do_get_interactions(self)

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

AttributeOptimizer_swigregister = _IMP_kernel.AttributeOptimizer_swigregister
AttributeOptimizer_swigregister(AttributeOptimizer)

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) -> SaveToConfigurationSetOptimizerState"""
        this = _IMP_kernel.new_SaveToConfigurationSetOptimizerState(*args)
        try: self.this.append(this)
        except: self.this = this
    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)

    __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 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 get_sample(self):
        """get_sample(Sampler self) -> ConfigurationSet"""
        return _IMP_kernel.Sampler_get_sample(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(_ParticleInputs,_ParticleOutputs,IMP.base.Object):
    """Proxy of C++ IMP::kernel::PairModifier class"""
    __swig_setmethods__ = {}
    for _s in [_ParticleInputs,_ParticleOutputs,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 [_ParticleInputs,_ParticleOutputs,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 & vt)"""
        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 __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)
    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 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)

PairModifier_swigregister = _IMP_kernel.PairModifier_swigregister
PairModifier_swigregister(PairModifier)

class PairScore(_ParticleInputs,IMP.base.Object):
    """Proxy of C++ IMP::kernel::PairScore class"""
    __swig_setmethods__ = {}
    for _s in [_ParticleInputs,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 [_ParticleInputs,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 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)
    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)

PairScore_swigregister = _IMP_kernel.PairScore_swigregister
PairScore_swigregister(PairScore)

class PairPredicate(_ParticleInputs,IMP.base.Object):
    """Proxy of C++ IMP::kernel::PairPredicate class"""
    __swig_setmethods__ = {}
    for _s in [_ParticleInputs,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 [_ParticleInputs,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)

    __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)
    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)

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 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)

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(_ParticleInputs,_ParticleOutputs,IMP.base.Object):
    """Proxy of C++ IMP::kernel::QuadModifier class"""
    __swig_setmethods__ = {}
    for _s in [_ParticleInputs,_ParticleOutputs,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 [_ParticleInputs,_ParticleOutputs,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 & vt)"""
        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 __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)
    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 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)

QuadModifier_swigregister = _IMP_kernel.QuadModifier_swigregister
QuadModifier_swigregister(QuadModifier)

class QuadScore(_ParticleInputs,IMP.base.Object):
    """Proxy of C++ IMP::kernel::QuadScore class"""
    __swig_setmethods__ = {}
    for _s in [_ParticleInputs,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 [_ParticleInputs,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 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)
    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)

QuadScore_swigregister = _IMP_kernel.QuadScore_swigregister
QuadScore_swigregister(QuadScore)

class QuadPredicate(_ParticleInputs,IMP.base.Object):
    """Proxy of C++ IMP::kernel::QuadPredicate class"""
    __swig_setmethods__ = {}
    for _s in [_ParticleInputs,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 [_ParticleInputs,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)

    __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)
    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)

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 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)

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(_ParticleInputs,_ParticleOutputs,IMP.base.Object):
    """Proxy of C++ IMP::kernel::SingletonModifier class"""
    __swig_setmethods__ = {}
    for _s in [_ParticleInputs,_ParticleOutputs,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 [_ParticleInputs,_ParticleOutputs,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 vt)"""
        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 __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)
    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 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)

SingletonModifier_swigregister = _IMP_kernel.SingletonModifier_swigregister
SingletonModifier_swigregister(SingletonModifier)

class SingletonScore(_ParticleInputs,IMP.base.Object):
    """Proxy of C++ IMP::kernel::SingletonScore class"""
    __swig_setmethods__ = {}
    for _s in [_ParticleInputs,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 [_ParticleInputs,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 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)
    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)

SingletonScore_swigregister = _IMP_kernel.SingletonScore_swigregister
SingletonScore_swigregister(SingletonScore)

class SingletonPredicate(_ParticleInputs,IMP.base.Object):
    """Proxy of C++ IMP::kernel::SingletonPredicate class"""
    __swig_setmethods__ = {}
    for _s in [_ParticleInputs,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 [_ParticleInputs,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)

    __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)
    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)

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 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)

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(_ParticleInputs,_ParticleOutputs,IMP.base.Object):
    """Proxy of C++ IMP::kernel::TripletModifier class"""
    __swig_setmethods__ = {}
    for _s in [_ParticleInputs,_ParticleOutputs,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 [_ParticleInputs,_ParticleOutputs,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 & vt)"""
        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 __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)
    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 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)

TripletModifier_swigregister = _IMP_kernel.TripletModifier_swigregister
TripletModifier_swigregister(TripletModifier)

class TripletScore(_ParticleInputs,IMP.base.Object):
    """Proxy of C++ IMP::kernel::TripletScore class"""
    __swig_setmethods__ = {}
    for _s in [_ParticleInputs,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 [_ParticleInputs,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 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)
    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)

TripletScore_swigregister = _IMP_kernel.TripletScore_swigregister
TripletScore_swigregister(TripletScore)

class TripletPredicate(_ParticleInputs,IMP.base.Object):
    """Proxy of C++ IMP::kernel::TripletPredicate class"""
    __swig_setmethods__ = {}
    for _s in [_ParticleInputs,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 [_ParticleInputs,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)

    __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)
    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)

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 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)

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)

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

def get_indexes(*args):
  """
    get_indexes(IMP::kernel::ParticlesTemp const & ps) -> IMP::kernel::ParticleIndexes
    get_indexes(IMP::kernel::ParticlePairsTemp const & ps) -> IMP::kernel::ParticleIndexPairs
    """
  return _IMP_kernel.get_indexes(*args)
class _ParticleIndexAdaptor(_object):
    """Proxy of C++ IMP::kernel::ParticleIndexAdaptor class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _ParticleIndexAdaptor, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _ParticleIndexAdaptor, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::ParticleIndexAdaptor self, Particle p) -> _ParticleIndexAdaptor
        __init__(IMP::kernel::ParticleIndexAdaptor self, IMP::kernel::ParticleIndex pi) -> _ParticleIndexAdaptor
        __init__(IMP::kernel::ParticleIndexAdaptor self, Decorator d) -> _ParticleIndexAdaptor
        """
        this = _IMP_kernel.new__ParticleIndexAdaptor(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _IMP_kernel.delete__ParticleIndexAdaptor
    __del__ = lambda self : None;
_ParticleIndexAdaptor_swigregister = _IMP_kernel._ParticleIndexAdaptor_swigregister
_ParticleIndexAdaptor_swigregister(_ParticleIndexAdaptor)

class _ParticleIndexesAdaptor(IMP.base._InputAdaptor):
    """Proxy of C++ IMP::kernel::ParticleIndexesAdaptor class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base._InputAdaptor]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _ParticleIndexesAdaptor, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base._InputAdaptor]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _ParticleIndexesAdaptor, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::ParticleIndexesAdaptor self, IMP::kernel::ParticlesTemp const & ps) -> _ParticleIndexesAdaptor
        __init__(IMP::kernel::ParticleIndexesAdaptor self, IMP::kernel::ParticleIndexes const & pi) -> _ParticleIndexesAdaptor
        __init__(IMP::kernel::ParticleIndexesAdaptor self) -> _ParticleIndexesAdaptor
        """
        this = _IMP_kernel.new__ParticleIndexesAdaptor(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _IMP_kernel.delete__ParticleIndexesAdaptor
    __del__ = lambda self : None;
_ParticleIndexesAdaptor_swigregister = _IMP_kernel._ParticleIndexesAdaptor_swigregister
_ParticleIndexesAdaptor_swigregister(_ParticleIndexesAdaptor)

class _ParticleIndexPairsAdaptor(_object):
    """Proxy of C++ IMP::kernel::ParticleIndexPairsAdaptor class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _ParticleIndexPairsAdaptor, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _ParticleIndexPairsAdaptor, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(IMP::kernel::ParticleIndexPairsAdaptor self, IMP::kernel::ParticlePairsTemp const & ps) -> _ParticleIndexPairsAdaptor
        __init__(IMP::kernel::ParticleIndexPairsAdaptor self, IMP::kernel::ParticleIndexPairs const & pi) -> _ParticleIndexPairsAdaptor
        __init__(IMP::kernel::ParticleIndexPairsAdaptor self) -> _ParticleIndexPairsAdaptor
        """
        this = _IMP_kernel.new__ParticleIndexPairsAdaptor(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _IMP_kernel.delete__ParticleIndexPairsAdaptor
    __del__ = lambda self : None;
_ParticleIndexPairsAdaptor_swigregister = _IMP_kernel._ParticleIndexPairsAdaptor_swigregister
_ParticleIndexPairsAdaptor_swigregister(_ParticleIndexPairsAdaptor)

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 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)

    __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 do_get_inputs(self, *args):
        """do_get_inputs(_ConstSingletonScore self, Model arg2, IMP::kernel::ParticleIndexes const & arg3) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel._ConstSingletonScore_do_get_inputs(self, *args)

    def get_version_info(self):
        """get_version_info(_ConstSingletonScore self) -> VersionInfo"""
        return _IMP_kernel._ConstSingletonScore_get_version_info(self)

    __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 do_get_inputs(self, *args):
        """do_get_inputs(_ConstPairScore self, Model arg2, IMP::kernel::ParticleIndexes const & arg3) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel._ConstPairScore_do_get_inputs(self, *args)

    def get_version_info(self):
        """get_version_info(_ConstPairScore self) -> VersionInfo"""
        return _IMP_kernel._ConstPairScore_get_version_info(self)

    __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, _ParticleAdaptor d) -> _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 particle_is_instance(*args):
        """
        particle_is_instance(Particle p) -> bool
        particle_is_instance(Model m, IMP::kernel::ParticleIndex pi) -> 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 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(Model m, IMP::kernel::ParticleIndex pi) -> _TrivialDecorator
        setup_particle(_ParticleAdaptor decorator) -> _TrivialDecorator
        """
        return _IMP_kernel._TrivialDecorator_setup_particle(*args)

    if _newclass:setup_particle = staticmethod(setup_particle)
    __swig_getmethods__["setup_particle"] = lambda x: setup_particle
    def get_is_setup(*args):
        """
        get_is_setup(_ParticleAdaptor p) -> bool
        get_is_setup(Model m, IMP::kernel::ParticleIndex pi) -> bool
        """
        return _IMP_kernel._TrivialDecorator_get_is_setup(*args)

    if _newclass:get_is_setup = staticmethod(get_is_setup)
    __swig_getmethods__["get_is_setup"] = lambda x: get_is_setup
    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_particle_is_instance(*args):
  """
    particle_is_instance(Particle p) -> bool
    _TrivialDecorator_particle_is_instance(Model m, IMP::kernel::ParticleIndex pi) -> bool
    """
  return _IMP_kernel._TrivialDecorator_particle_is_instance(*args)

def _TrivialDecorator_setup_particle(*args):
  """
    setup_particle(Model m, IMP::kernel::ParticleIndex pi) -> _TrivialDecorator
    _TrivialDecorator_setup_particle(_ParticleAdaptor decorator) -> _TrivialDecorator
    """
  return _IMP_kernel._TrivialDecorator_setup_particle(*args)

def _TrivialDecorator_get_is_setup(*args):
  """
    get_is_setup(_ParticleAdaptor p) -> bool
    _TrivialDecorator_get_is_setup(Model m, IMP::kernel::ParticleIndex pi) -> bool
    """
  return _IMP_kernel._TrivialDecorator_get_is_setup(*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, _ParticleAdaptor d) -> _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 particle_is_instance(*args):
        """
        particle_is_instance(Particle p) -> bool
        particle_is_instance(Model m, IMP::kernel::ParticleIndex pi) -> 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 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(Model m, IMP::kernel::ParticleIndex pi) -> _TrivialDerivedDecorator
        setup_particle(_ParticleAdaptor decorator) -> _TrivialDerivedDecorator
        """
        return _IMP_kernel._TrivialDerivedDecorator_setup_particle(*args)

    if _newclass:setup_particle = staticmethod(setup_particle)
    __swig_getmethods__["setup_particle"] = lambda x: setup_particle
    def get_is_setup(*args):
        """
        get_is_setup(_ParticleAdaptor p) -> bool
        get_is_setup(Model m, IMP::kernel::ParticleIndex pi) -> bool
        """
        return _IMP_kernel._TrivialDerivedDecorator_get_is_setup(*args)

    if _newclass:get_is_setup = staticmethod(get_is_setup)
    __swig_getmethods__["get_is_setup"] = lambda x: get_is_setup
    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_particle_is_instance(*args):
  """
    particle_is_instance(Particle p) -> bool
    _TrivialDerivedDecorator_particle_is_instance(Model m, IMP::kernel::ParticleIndex pi) -> bool
    """
  return _IMP_kernel._TrivialDerivedDecorator_particle_is_instance(*args)

def _TrivialDerivedDecorator_setup_particle(*args):
  """
    setup_particle(Model m, IMP::kernel::ParticleIndex pi) -> _TrivialDerivedDecorator
    _TrivialDerivedDecorator_setup_particle(_ParticleAdaptor decorator) -> _TrivialDerivedDecorator
    """
  return _IMP_kernel._TrivialDerivedDecorator_setup_particle(*args)

def _TrivialDerivedDecorator_get_is_setup(*args):
  """
    get_is_setup(_ParticleAdaptor p) -> bool
    _TrivialDerivedDecorator_get_is_setup(Model m, IMP::kernel::ParticleIndex pi) -> bool
    """
  return _IMP_kernel._TrivialDerivedDecorator_get_is_setup(*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 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 __init__(self, *args): 
        """
        __init__(IMP::kernel::internal::_TrivialTraitsDecorator self) -> _TrivialTraitsDecorator
        __init__(IMP::kernel::internal::_TrivialTraitsDecorator self, Model m, ::IMP::kernel::ParticleIndex id, StringKey tr=get_default_key()) -> _TrivialTraitsDecorator
        __init__(IMP::kernel::internal::_TrivialTraitsDecorator self, Model m, ::IMP::kernel::ParticleIndex id) -> _TrivialTraitsDecorator
        __init__(IMP::kernel::internal::_TrivialTraitsDecorator self, _ParticleAdaptor d, StringKey tr=get_default_key()) -> _TrivialTraitsDecorator
        __init__(IMP::kernel::internal::_TrivialTraitsDecorator self, _ParticleAdaptor d) -> _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 particle_is_instance(*args):
        """
        particle_is_instance(Particle p, StringKey tr=get_default_key()) -> bool
        particle_is_instance(Particle p) -> bool
        particle_is_instance(Model m, IMP::kernel::ParticleIndex pi, StringKey tr=get_default_key()) -> bool
        particle_is_instance(Model m, IMP::kernel::ParticleIndex pi) -> 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 show(self, *args):
        """
        show(_TrivialTraitsDecorator self, _ostream out=std::cout)
        show(_TrivialTraitsDecorator self)
        """
        return _IMP_kernel._TrivialTraitsDecorator_show(self, *args)

    def setup_particle(*args):
        """
        setup_particle(Model m, IMP::kernel::ParticleIndex pi, StringKey tr=IMP::kernel::internal::_TrivialTraitsDecorator::get_default_decorator_traits()) -> _TrivialTraitsDecorator
        setup_particle(Model m, IMP::kernel::ParticleIndex pi) -> _TrivialTraitsDecorator
        setup_particle(_ParticleAdaptor d, StringKey tr=IMP::kernel::internal::_TrivialTraitsDecorator::get_default_decorator_traits()) -> _TrivialTraitsDecorator
        setup_particle(_ParticleAdaptor d) -> _TrivialTraitsDecorator
        """
        return _IMP_kernel._TrivialTraitsDecorator_setup_particle(*args)

    if _newclass:setup_particle = staticmethod(setup_particle)
    __swig_getmethods__["setup_particle"] = lambda x: setup_particle
    def get_is_setup(*args):
        """
        get_is_setup(_ParticleAdaptor p, StringKey tr=get_default_key()) -> bool
        get_is_setup(_ParticleAdaptor p) -> bool
        get_is_setup(Model m, IMP::kernel::ParticleIndex pi, StringKey k=get_default_key()) -> bool
        get_is_setup(Model m, IMP::kernel::ParticleIndex pi) -> bool
        """
        return _IMP_kernel._TrivialTraitsDecorator_get_is_setup(*args)

    if _newclass:get_is_setup = staticmethod(get_is_setup)
    __swig_getmethods__["get_is_setup"] = lambda x: get_is_setup
    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_get_default_decorator_traits():
  """_TrivialTraitsDecorator_get_default_decorator_traits() -> StringKey"""
  return _IMP_kernel._TrivialTraitsDecorator_get_default_decorator_traits()

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_particle_is_instance(*args):
  """
    particle_is_instance(Particle p, StringKey tr=get_default_key()) -> bool
    particle_is_instance(Particle p) -> bool
    particle_is_instance(Model m, IMP::kernel::ParticleIndex pi, StringKey tr=get_default_key()) -> bool
    _TrivialTraitsDecorator_particle_is_instance(Model m, IMP::kernel::ParticleIndex pi) -> bool
    """
  return _IMP_kernel._TrivialTraitsDecorator_particle_is_instance(*args)

def _TrivialTraitsDecorator_setup_particle(*args):
  """
    setup_particle(Model m, IMP::kernel::ParticleIndex pi, StringKey tr=IMP::kernel::internal::_TrivialTraitsDecorator::get_default_decorator_traits()) -> _TrivialTraitsDecorator
    setup_particle(Model m, IMP::kernel::ParticleIndex pi) -> _TrivialTraitsDecorator
    setup_particle(_ParticleAdaptor d, StringKey tr=IMP::kernel::internal::_TrivialTraitsDecorator::get_default_decorator_traits()) -> _TrivialTraitsDecorator
    _TrivialTraitsDecorator_setup_particle(_ParticleAdaptor d) -> _TrivialTraitsDecorator
    """
  return _IMP_kernel._TrivialTraitsDecorator_setup_particle(*args)

def _TrivialTraitsDecorator_get_is_setup(*args):
  """
    get_is_setup(_ParticleAdaptor p, StringKey tr=get_default_key()) -> bool
    get_is_setup(_ParticleAdaptor p) -> bool
    get_is_setup(Model m, IMP::kernel::ParticleIndex pi, StringKey k=get_default_key()) -> bool
    _TrivialTraitsDecorator_get_is_setup(Model m, IMP::kernel::ParticleIndex pi) -> bool
    """
  return _IMP_kernel._TrivialTraitsDecorator_get_is_setup(*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)

    __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_get_inputs(self, *args):
        """do_get_inputs(_LogPairScore self, Model arg2, IMP::kernel::ParticleIndexes const & arg3) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_kernel._LogPairScore_do_get_inputs(self, *args)

    def get_version_info(self):
        """get_version_info(_LogPairScore self) -> VersionInfo"""
        return _IMP_kernel._LogPairScore_get_version_info(self)

    __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)


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)

def _take_particle_adaptor(*args):
  """_take_particle_adaptor(_ParticleAdaptor pa) -> IMP::kernel::ParticleIndex"""
  return _IMP_kernel._take_particle_adaptor(*args)

def _take_particle_indexes_adaptor(*args):
  """_take_particle_indexes_adaptor(_ParticleIndexesAdaptor pa) -> IMP::kernel::ParticleIndexes"""
  return _IMP_kernel._take_particle_indexes_adaptor(*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']

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://integrativemodeling.org>.

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
import sys

class OptionParser(optparse.OptionParser):
    """IMP-specific subclass of optparse.OptionParser.
       This adds options common to all IMP applications
       (see IMP::base::setup_from_argv()).
    """

    _use_boost_parser = True

    def __init__(self, *args, **kwargs):
        # Don't add --help or --version options (since the Boost
        # option parser handles those)
        kwargs['add_help_option'] = False
        kwargs['version'] = None
        # Handle old users of IMP.OptionParser that set imp_module
        if 'imp_module' in kwargs:
            del kwargs['imp_module']
        optparse.OptionParser.__init__(self, *args, **kwargs)

    # Don't complain if invalid options are encountered; pass them through
    # unmodified
    def _process_long_opt(self, rargs, values):
        if self._use_boost_parser:
            try:
                optparse.OptionParser._process_long_opt(self, rargs, values)
            except optparse.BadOptionError, err:
                self.largs.append(err.opt_str)
        else:
            optparse.OptionParser._process_long_opt(self, rargs, values)
    def _process_short_opts(self, rargs, values):
        if self._use_boost_parser:
            try:
                optparse.OptionParser._process_short_opts(self, rargs, values)
            except optparse.BadOptionError, err:
                self.largs.append(err.opt_str)
        else:
            optparse.OptionParser._process_short_opts(self, rargs, values)

    def _process_args(self, largs, rargs, values):
        if self._use_boost_parser:
            # If the special argument -- is present, preserve it (by default
            # optparse will remove it). Otherwise, the Boost option parser will
            # not treat positional arguments after -- correctly.
            try:
                dashdash = rargs.index('--')
            except ValueError:
                dashdash = len(rargs)
            saved_args = rargs[dashdash:]
            del rargs[dashdash:]
            optparse.OptionParser._process_args(self, largs, rargs, values)
            rargs.extend(saved_args)
        else:
            optparse.OptionParser._process_args(self, largs, rargs, values)

    def parse_args(self, num_positional=None):
        """Parse the command line and return options and positional arguments.
           This functions in the same way as the method in the base class
           optparse.OptionParser, except that it also processes options common
           to all IMP applications (these are not returned in opts, but can be
           obtained in the usual way, e.g. by calling
           IMP::base::get_string_flag()).
           @param[in] num_positional If a positive integer, exactly that
                      many positional arguments must be specified on the
                      command line; if a negative integer, that many or
                      more must be given; if None, any number of positional
                      arguments can be given.
           @returns   opts, args
        """
        import IMP.base
        # First, parse the command line with optparse
        opts, args = optparse.OptionParser.parse_args(self)
        if not self._use_boost_parser:
            return opts, args
        orig_desc = self.description
        orig_usage = self.usage
        if self.usage:
            usage = self.usage.replace('%prog ', '')
        else:
            usage = ''
        if num_positional is None:
            # If num_positional was not specified, prevent the Boost parser
            # from complaining about the number of positional arguments
            numpos = -1
            args.append('dummy')
        else:
            numpos = num_positional
        try:
            self.usage = self.description = None
            # Pass the rest of the command line to the Boost parser; add the
            # optparse-generated help to that from Boost
            args = IMP.base.setup_from_argv([sys.argv[0]] + args,
                           self.format_help() \
                           + "\nOptions common to all IMP applications:",
                           usage, numpos)
        finally:
            self.description = orig_desc
            self.usage = orig_usage
        if num_positional is None:
            args.pop()
        return opts, args


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.