core/__init__.py

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



from sys import version_info
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_IMP_core', [dirname(__file__)])
        except ImportError:
            import _IMP_core
            return _IMP_core
        if fp is not None:
            try:
                _mod = imp.load_module('_IMP_core', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _IMP_core = swig_import_helper()
    del swig_import_helper
else:
    import _IMP_core
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_CORE_SwigPyIterator(_object):
    """Proxy of C++ swig::IMP_CORE_SwigPyIterator class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IMP_CORE_SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IMP_CORE_SwigPyIterator, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _IMP_core.delete_IMP_CORE_SwigPyIterator
    __del__ = lambda self : None;
    def value(self):
        """value(IMP_CORE_SwigPyIterator self) -> PyObject *"""
        return _IMP_core.IMP_CORE_SwigPyIterator_value(self)

    def incr(self, n=1):
        """
        incr(IMP_CORE_SwigPyIterator self, size_t n=1) -> IMP_CORE_SwigPyIterator
        incr(IMP_CORE_SwigPyIterator self) -> IMP_CORE_SwigPyIterator
        """
        return _IMP_core.IMP_CORE_SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        """
        decr(IMP_CORE_SwigPyIterator self, size_t n=1) -> IMP_CORE_SwigPyIterator
        decr(IMP_CORE_SwigPyIterator self) -> IMP_CORE_SwigPyIterator
        """
        return _IMP_core.IMP_CORE_SwigPyIterator_decr(self, n)

    def distance(self, *args):
        """distance(IMP_CORE_SwigPyIterator self, IMP_CORE_SwigPyIterator x) -> ptrdiff_t"""
        return _IMP_core.IMP_CORE_SwigPyIterator_distance(self, *args)

    def equal(self, *args):
        """equal(IMP_CORE_SwigPyIterator self, IMP_CORE_SwigPyIterator x) -> bool"""
        return _IMP_core.IMP_CORE_SwigPyIterator_equal(self, *args)

    def copy(self):
        """copy(IMP_CORE_SwigPyIterator self) -> IMP_CORE_SwigPyIterator"""
        return _IMP_core.IMP_CORE_SwigPyIterator_copy(self)

    def next(self):
        """next(IMP_CORE_SwigPyIterator self) -> PyObject *"""
        return _IMP_core.IMP_CORE_SwigPyIterator_next(self)

    def __next__(self):
        """__next__(IMP_CORE_SwigPyIterator self) -> PyObject *"""
        return _IMP_core.IMP_CORE_SwigPyIterator___next__(self)

    def previous(self):
        """previous(IMP_CORE_SwigPyIterator self) -> PyObject *"""
        return _IMP_core.IMP_CORE_SwigPyIterator_previous(self)

    def advance(self, *args):
        """advance(IMP_CORE_SwigPyIterator self, ptrdiff_t n) -> IMP_CORE_SwigPyIterator"""
        return _IMP_core.IMP_CORE_SwigPyIterator_advance(self, *args)

    def __eq__(self, *args):
        """__eq__(IMP_CORE_SwigPyIterator self, IMP_CORE_SwigPyIterator x) -> bool"""
        return _IMP_core.IMP_CORE_SwigPyIterator___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(IMP_CORE_SwigPyIterator self, IMP_CORE_SwigPyIterator x) -> bool"""
        return _IMP_core.IMP_CORE_SwigPyIterator___ne__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(IMP_CORE_SwigPyIterator self, ptrdiff_t n) -> IMP_CORE_SwigPyIterator"""
        return _IMP_core.IMP_CORE_SwigPyIterator___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(IMP_CORE_SwigPyIterator self, ptrdiff_t n) -> IMP_CORE_SwigPyIterator"""
        return _IMP_core.IMP_CORE_SwigPyIterator___isub__(self, *args)

    def __add__(self, *args):
        """__add__(IMP_CORE_SwigPyIterator self, ptrdiff_t n) -> IMP_CORE_SwigPyIterator"""
        return _IMP_core.IMP_CORE_SwigPyIterator___add__(self, *args)

    def __sub__(self, *args):
        """
        __sub__(IMP_CORE_SwigPyIterator self, ptrdiff_t n) -> IMP_CORE_SwigPyIterator
        __sub__(IMP_CORE_SwigPyIterator self, IMP_CORE_SwigPyIterator x) -> ptrdiff_t
        """
        return _IMP_core.IMP_CORE_SwigPyIterator___sub__(self, *args)

    def __iter__(self): return self
IMP_CORE_SwigPyIterator_swigregister = _IMP_core.IMP_CORE_SwigPyIterator_swigregister
IMP_CORE_SwigPyIterator_swigregister(IMP_CORE_SwigPyIterator)

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

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

DEFAULT_CHECK = _IMP_core.DEFAULT_CHECK
NONE = _IMP_core.NONE
USAGE = _IMP_core.USAGE
USAGE_AND_INTERNAL = _IMP_core.USAGE_AND_INTERNAL

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

def get_check_level():
  """get_check_level() -> IMP::base::CheckLevel"""
  return _IMP_core.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_core._ostream_write(self, *args)

_ostream_swigregister = _IMP_core._ostream_swigregister
_ostream_swigregister(_ostream)

IMP_COMPILER_HAS_OVERRIDE = _IMP_core.IMP_COMPILER_HAS_OVERRIDE
IMP_COMPILER_HAS_FINAL = _IMP_core.IMP_COMPILER_HAS_FINAL
import IMP.base
IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_core.IMP_CGAL_HAS_BOOST_FILESYSTEM
IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_core.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS
IMP_CGAL_HAS_BOOST_RANDOM = _IMP_core.IMP_CGAL_HAS_BOOST_RANDOM
IMP_CGAL_HAS_BOOST_SYSTEM = _IMP_core.IMP_CGAL_HAS_BOOST_SYSTEM
import IMP.cgal
IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_core.IMP_ALGEBRA_HAS_IMP_CGAL
IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_core.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM
IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_core.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS
IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_core.IMP_ALGEBRA_HAS_BOOST_RANDOM
IMP_ALGEBRA_HAS_BOOST_SYSTEM = _IMP_core.IMP_ALGEBRA_HAS_BOOST_SYSTEM
IMP_ALGEBRA_HAS_CGAL = _IMP_core.IMP_ALGEBRA_HAS_CGAL
IMP_ALGEBRA_HAS_ANN = _IMP_core.IMP_ALGEBRA_HAS_ANN
import IMP.algebra
IMP_KERNEL_HAS_IMP_CGAL = _IMP_core.IMP_KERNEL_HAS_IMP_CGAL
IMP_KERNEL_HAS_BOOST_PROGRAMOPTIONS = _IMP_core.IMP_KERNEL_HAS_BOOST_PROGRAMOPTIONS
IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_core.IMP_KERNEL_HAS_BOOST_RANDOM
IMP_KERNEL_HAS_BOOST_SYSTEM = _IMP_core.IMP_KERNEL_HAS_BOOST_SYSTEM
IMP_KERNEL_HAS_CGAL = _IMP_core.IMP_KERNEL_HAS_CGAL
import IMP.kernel
IMP_DISPLAY_HAS_IMP_BASE = _IMP_core.IMP_DISPLAY_HAS_IMP_BASE
IMP_DISPLAY_HAS_IMP_CGAL = _IMP_core.IMP_DISPLAY_HAS_IMP_CGAL
IMP_DISPLAY_HAS_BOOST_FILESYSTEM = _IMP_core.IMP_DISPLAY_HAS_BOOST_FILESYSTEM
IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS = _IMP_core.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS
IMP_DISPLAY_HAS_BOOST_RANDOM = _IMP_core.IMP_DISPLAY_HAS_BOOST_RANDOM
IMP_DISPLAY_HAS_BOOST_SYSTEM = _IMP_core.IMP_DISPLAY_HAS_BOOST_SYSTEM
IMP_DISPLAY_HAS_CGAL = _IMP_core.IMP_DISPLAY_HAS_CGAL
import IMP.display
IMP_SCORE_FUNCTOR_HAS_IMP_CGAL = _IMP_core.IMP_SCORE_FUNCTOR_HAS_IMP_CGAL
IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM = _IMP_core.IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM
IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS = _IMP_core.IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS
IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM = _IMP_core.IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM
IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM = _IMP_core.IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM
IMP_SCORE_FUNCTOR_HAS_CGAL = _IMP_core.IMP_SCORE_FUNCTOR_HAS_CGAL
import IMP.score_functor
IMP_CORE_HAS_IMP_BASE = _IMP_core.IMP_CORE_HAS_IMP_BASE
IMP_CORE_HAS_IMP_CGAL = _IMP_core.IMP_CORE_HAS_IMP_CGAL
IMP_CORE_HAS_IMP_KERNEL = _IMP_core.IMP_CORE_HAS_IMP_KERNEL
IMP_CORE_HAS_BOOST_FILESYSTEM = _IMP_core.IMP_CORE_HAS_BOOST_FILESYSTEM
IMP_CORE_HAS_BOOST_PROGRAMOPTIONS = _IMP_core.IMP_CORE_HAS_BOOST_PROGRAMOPTIONS
IMP_CORE_HAS_BOOST_RANDOM = _IMP_core.IMP_CORE_HAS_BOOST_RANDOM
IMP_CORE_HAS_BOOST_SYSTEM = _IMP_core.IMP_CORE_HAS_BOOST_SYSTEM
IMP_CORE_HAS_CGAL = _IMP_core.IMP_CORE_HAS_CGAL
class _OpenCubicSplineBase(IMP.kernel.UnaryFunction):
    """Proxy of C++ IMP::score_functor::ScoreUnaryFunction<(IMP::score_functor::OpenCubicSpline)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.UnaryFunction]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _OpenCubicSplineBase, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.UnaryFunction]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _OpenCubicSplineBase, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(IMP::score_functor::ScoreUnaryFunction<(IMP::score_functor::OpenCubicSpline)> self, IMP::score_functor::OpenCubicSpline const & score, std::string name="UnaryFunction%1%") -> _OpenCubicSplineBase
        __init__(IMP::score_functor::ScoreUnaryFunction<(IMP::score_functor::OpenCubicSpline)> self, IMP::score_functor::OpenCubicSpline const & score) -> _OpenCubicSplineBase
        """
        this = _IMP_core.new__OpenCubicSplineBase(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(_OpenCubicSplineBase self) -> VersionInfo"""
        return _IMP_core._OpenCubicSplineBase_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete__OpenCubicSplineBase
    __del__ = lambda self : None;
_OpenCubicSplineBase_swigregister = _IMP_core._OpenCubicSplineBase_swigregister
_OpenCubicSplineBase_swigregister(_OpenCubicSplineBase)

_object_types.append("MonteCarloMover")


def _object_cast_to_MonteCarloMover(*args):
  """_object_cast_to_MonteCarloMover(Object o) -> MonteCarloMover"""
  return _IMP_core._object_cast_to_MonteCarloMover(*args)
MonteCarloMoverResults=list
_plural_types.append("MonteCarloMoverResults")
_value_types.append("MonteCarloMoverResult")

_object_types.append("Mover")


def _object_cast_to_Mover(*args):
  """_object_cast_to_Mover(Object o) -> Mover"""
  return _IMP_core._object_cast_to_Mover(*args)
_object_types.append("MoverBase")


def _object_cast_to_MoverBase(*args):
  """_object_cast_to_MoverBase(Object o) -> MoverBase"""
  return _IMP_core._object_cast_to_MoverBase(*args)
_object_types.append("AngleRestraint")


def _object_cast_to_AngleRestraint(*args):
  """_object_cast_to_AngleRestraint(Object o) -> AngleRestraint"""
  return _IMP_core._object_cast_to_AngleRestraint(*args)
_object_types.append("AngleTripletScore")


def _object_cast_to_AngleTripletScore(*args):
  """_object_cast_to_AngleTripletScore(Object o) -> AngleTripletScore"""
  return _IMP_core._object_cast_to_AngleTripletScore(*args)
_object_types.append("AttributeSingletonScore")


def _object_cast_to_AttributeSingletonScore(*args):
  """_object_cast_to_AttributeSingletonScore(Object o) -> AttributeSingletonScore"""
  return _IMP_core._object_cast_to_AttributeSingletonScore(*args)
_object_types.append("BallMover")


def _object_cast_to_BallMover(*args):
  """_object_cast_to_BallMover(Object o) -> BallMover"""
  return _IMP_core._object_cast_to_BallMover(*args)
_object_types.append("SerialMover")


def _object_cast_to_SerialMover(*args):
  """_object_cast_to_SerialMover(Object o) -> SerialMover"""
  return _IMP_core._object_cast_to_SerialMover(*args)
_object_types.append("BoundingBox3DSingletonScore")


def _object_cast_to_BoundingBox3DSingletonScore(*args):
  """_object_cast_to_BoundingBox3DSingletonScore(Object o) -> BoundingBox3DSingletonScore"""
  return _IMP_core._object_cast_to_BoundingBox3DSingletonScore(*args)
_object_types.append("BoxSweepClosePairsFinder")


def _object_cast_to_BoxSweepClosePairsFinder(*args):
  """_object_cast_to_BoxSweepClosePairsFinder(Object o) -> BoxSweepClosePairsFinder"""
  return _IMP_core._object_cast_to_BoxSweepClosePairsFinder(*args)
_object_types.append("NearestNeighborsClosePairsFinder")


def _object_cast_to_NearestNeighborsClosePairsFinder(*args):
  """_object_cast_to_NearestNeighborsClosePairsFinder(Object o) -> NearestNeighborsClosePairsFinder"""
  return _IMP_core._object_cast_to_NearestNeighborsClosePairsFinder(*args)
_object_types.append("CentroidOfRefined")


def _object_cast_to_CentroidOfRefined(*args):
  """_object_cast_to_CentroidOfRefined(Object o) -> CentroidOfRefined"""
  return _IMP_core._object_cast_to_CentroidOfRefined(*args)
_object_types.append("ChecksScoreState")


def _object_cast_to_ChecksScoreState(*args):
  """_object_cast_to_ChecksScoreState(Object o) -> ChecksScoreState"""
  return _IMP_core._object_cast_to_ChecksScoreState(*args)
_object_types.append("ChildrenRefiner")


def _object_cast_to_ChildrenRefiner(*args):
  """_object_cast_to_ChildrenRefiner(Object o) -> ChildrenRefiner"""
  return _IMP_core._object_cast_to_ChildrenRefiner(*args)
_object_types.append("ClosePairsFinder")


def _object_cast_to_ClosePairsFinder(*args):
  """_object_cast_to_ClosePairsFinder(Object o) -> ClosePairsFinder"""
  return _IMP_core._object_cast_to_ClosePairsFinder(*args)
_object_types.append("ClosePairsPairScore")


def _object_cast_to_ClosePairsPairScore(*args):
  """_object_cast_to_ClosePairsPairScore(Object o) -> ClosePairsPairScore"""
  return _IMP_core._object_cast_to_ClosePairsPairScore(*args)
_object_types.append("ClosedCubicSpline")


def _object_cast_to_ClosedCubicSpline(*args):
  """_object_cast_to_ClosedCubicSpline(Object o) -> ClosedCubicSpline"""
  return _IMP_core._object_cast_to_ClosedCubicSpline(*args)
_object_types.append("ConjugateGradients")


def _object_cast_to_ConjugateGradients(*args):
  """_object_cast_to_ConjugateGradients(Object o) -> ConjugateGradients"""
  return _IMP_core._object_cast_to_ConjugateGradients(*args)
_object_types.append("ConnectivityRestraint")


def _object_cast_to_ConnectivityRestraint(*args):
  """_object_cast_to_ConnectivityRestraint(Object o) -> ConnectivityRestraint"""
  return _IMP_core._object_cast_to_ConnectivityRestraint(*args)
_object_types.append("ConstantRestraint")


def _object_cast_to_ConstantRestraint(*args):
  """_object_cast_to_ConstantRestraint(Object o) -> ConstantRestraint"""
  return _IMP_core._object_cast_to_ConstantRestraint(*args)
_object_types.append("Cosine")


def _object_cast_to_Cosine(*args):
  """_object_cast_to_Cosine(Object o) -> Cosine"""
  return _IMP_core._object_cast_to_Cosine(*args)
_object_types.append("CoverRefined")


def _object_cast_to_CoverRefined(*args):
  """_object_cast_to_CoverRefined(Object o) -> CoverRefined"""
  return _IMP_core._object_cast_to_CoverRefined(*args)
_object_types.append("DerivativesFromRefined")


def _object_cast_to_DerivativesFromRefined(*args):
  """_object_cast_to_DerivativesFromRefined(Object o) -> DerivativesFromRefined"""
  return _IMP_core._object_cast_to_DerivativesFromRefined(*args)
_object_types.append("DerivativesToRefined")


def _object_cast_to_DerivativesToRefined(*args):
  """_object_cast_to_DerivativesToRefined(Object o) -> DerivativesToRefined"""
  return _IMP_core._object_cast_to_DerivativesToRefined(*args)
_object_types.append("DiameterRestraint")


def _object_cast_to_DiameterRestraint(*args):
  """_object_cast_to_DiameterRestraint(Object o) -> DiameterRestraint"""
  return _IMP_core._object_cast_to_DiameterRestraint(*args)
_object_types.append("DihedralRestraint")


def _object_cast_to_DihedralRestraint(*args):
  """_object_cast_to_DihedralRestraint(Object o) -> DihedralRestraint"""
  return _IMP_core._object_cast_to_DihedralRestraint(*args)
_object_types.append("DistanceRestraint")


def _object_cast_to_DistanceRestraint(*args):
  """_object_cast_to_DistanceRestraint(Object o) -> DistanceRestraint"""
  return _IMP_core._object_cast_to_DistanceRestraint(*args)
_object_types.append("DistanceToSingletonScore")


def _object_cast_to_DistanceToSingletonScore(*args):
  """_object_cast_to_DistanceToSingletonScore(Object o) -> DistanceToSingletonScore"""
  return _IMP_core._object_cast_to_DistanceToSingletonScore(*args)
_object_types.append("ExcludedVolumeRestraint")


def _object_cast_to_ExcludedVolumeRestraint(*args):
  """_object_cast_to_ExcludedVolumeRestraint(Object o) -> ExcludedVolumeRestraint"""
  return _IMP_core._object_cast_to_ExcludedVolumeRestraint(*args)
_object_types.append("FixedRefiner")


def _object_cast_to_FixedRefiner(*args):
  """_object_cast_to_FixedRefiner(Object o) -> FixedRefiner"""
  return _IMP_core._object_cast_to_FixedRefiner(*args)
_object_types.append("GridClosePairsFinder")


def _object_cast_to_GridClosePairsFinder(*args):
  """_object_cast_to_GridClosePairsFinder(Object o) -> GridClosePairsFinder"""
  return _IMP_core._object_cast_to_GridClosePairsFinder(*args)
_object_types.append("Harmonic")


def _object_cast_to_Harmonic(*args):
  """_object_cast_to_Harmonic(Object o) -> Harmonic"""
  return _IMP_core._object_cast_to_Harmonic(*args)
_object_types.append("HarmonicWell")


def _object_cast_to_HarmonicWell(*args):
  """_object_cast_to_HarmonicWell(Object o) -> HarmonicWell"""
  return _IMP_core._object_cast_to_HarmonicWell(*args)
_object_types.append("HarmonicLowerBound")


def _object_cast_to_HarmonicLowerBound(*args):
  """_object_cast_to_HarmonicLowerBound(Object o) -> HarmonicLowerBound"""
  return _IMP_core._object_cast_to_HarmonicLowerBound(*args)
_object_types.append("HarmonicUpperBound")


def _object_cast_to_HarmonicUpperBound(*args):
  """_object_cast_to_HarmonicUpperBound(Object o) -> HarmonicUpperBound"""
  return _IMP_core._object_cast_to_HarmonicUpperBound(*args)
_object_types.append("HarmonicSphereDistancePairScore")


def _object_cast_to_HarmonicSphereDistancePairScore(*args):
  """_object_cast_to_HarmonicSphereDistancePairScore(Object o) -> HarmonicSphereDistancePairScore"""
  return _IMP_core._object_cast_to_HarmonicSphereDistancePairScore(*args)
_object_types.append("HarmonicUpperBoundSphereDistancePairScore")


def _object_cast_to_HarmonicUpperBoundSphereDistancePairScore(*args):
  """_object_cast_to_HarmonicUpperBoundSphereDistancePairScore(Object o) -> HarmonicUpperBoundSphereDistancePairScore"""
  return _IMP_core._object_cast_to_HarmonicUpperBoundSphereDistancePairScore(*args)
_object_types.append("HarmonicUpperBoundSphereDiameterPairScore")


def _object_cast_to_HarmonicUpperBoundSphereDiameterPairScore(*args):
  """_object_cast_to_HarmonicUpperBoundSphereDiameterPairScore(Object o) -> HarmonicUpperBoundSphereDiameterPairScore"""
  return _IMP_core._object_cast_to_HarmonicUpperBoundSphereDiameterPairScore(*args)
_object_types.append("IncrementalScoringFunction")


def _object_cast_to_IncrementalScoringFunction(*args):
  """_object_cast_to_IncrementalScoringFunction(Object o) -> IncrementalScoringFunction"""
  return _IMP_core._object_cast_to_IncrementalScoringFunction(*args)
_object_types.append("KClosePairsPairScore")


def _object_cast_to_KClosePairsPairScore(*args):
  """_object_cast_to_KClosePairsPairScore(Object o) -> KClosePairsPairScore"""
  return _IMP_core._object_cast_to_KClosePairsPairScore(*args)
_object_types.append("LeavesRefiner")


def _object_cast_to_LeavesRefiner(*args):
  """_object_cast_to_LeavesRefiner(Object o) -> LeavesRefiner"""
  return _IMP_core._object_cast_to_LeavesRefiner(*args)
_object_types.append("Linear")


def _object_cast_to_Linear(*args):
  """_object_cast_to_Linear(Object o) -> Linear"""
  return _IMP_core._object_cast_to_Linear(*args)
_object_types.append("MCCGSampler")


def _object_cast_to_MCCGSampler(*args):
  """_object_cast_to_MCCGSampler(Object o) -> MCCGSampler"""
  return _IMP_core._object_cast_to_MCCGSampler(*args)
_object_types.append("MonteCarlo")


def _object_cast_to_MonteCarlo(*args):
  """_object_cast_to_MonteCarlo(Object o) -> MonteCarlo"""
  return _IMP_core._object_cast_to_MonteCarlo(*args)
_object_types.append("MonteCarloWithLocalOptimization")


def _object_cast_to_MonteCarloWithLocalOptimization(*args):
  """_object_cast_to_MonteCarloWithLocalOptimization(Object o) -> MonteCarloWithLocalOptimization"""
  return _IMP_core._object_cast_to_MonteCarloWithLocalOptimization(*args)
_object_types.append("MonteCarloWithBasinHopping")


def _object_cast_to_MonteCarloWithBasinHopping(*args):
  """_object_cast_to_MonteCarloWithBasinHopping(Object o) -> MonteCarloWithBasinHopping"""
  return _IMP_core._object_cast_to_MonteCarloWithBasinHopping(*args)
_object_types.append("MSConnectivityRestraint")


def _object_cast_to_MSConnectivityRestraint(*args):
  """_object_cast_to_MSConnectivityRestraint(Object o) -> MSConnectivityRestraint"""
  return _IMP_core._object_cast_to_MSConnectivityRestraint(*args)
_object_types.append("NormalMover")


def _object_cast_to_NormalMover(*args):
  """_object_cast_to_NormalMover(Object o) -> NormalMover"""
  return _IMP_core._object_cast_to_NormalMover(*args)
_object_types.append("NormalizedSphereDistancePairScore")


def _object_cast_to_NormalizedSphereDistancePairScore(*args):
  """_object_cast_to_NormalizedSphereDistancePairScore(Object o) -> NormalizedSphereDistancePairScore"""
  return _IMP_core._object_cast_to_NormalizedSphereDistancePairScore(*args)
_object_types.append("OpenCubicSpline")


def _object_cast_to_OpenCubicSpline(*args):
  """_object_cast_to_OpenCubicSpline(Object o) -> OpenCubicSpline"""
  return _IMP_core._object_cast_to_OpenCubicSpline(*args)
_object_types.append("PairConstraint")


def _object_cast_to_PairConstraint(*args):
  """_object_cast_to_PairConstraint(Object o) -> PairConstraint"""
  return _IMP_core._object_cast_to_PairConstraint(*args)
_object_types.append("PairRestraint")


def _object_cast_to_PairRestraint(*args):
  """_object_cast_to_PairRestraint(Object o) -> PairRestraint"""
  return _IMP_core._object_cast_to_PairRestraint(*args)
_object_types.append("PeriodicOptimizerState")


def _object_cast_to_PeriodicOptimizerState(*args):
  """_object_cast_to_PeriodicOptimizerState(Object o) -> PeriodicOptimizerState"""
  return _IMP_core._object_cast_to_PeriodicOptimizerState(*args)
_object_types.append("QuadConstraint")


def _object_cast_to_QuadConstraint(*args):
  """_object_cast_to_QuadConstraint(Object o) -> QuadConstraint"""
  return _IMP_core._object_cast_to_QuadConstraint(*args)
_object_types.append("QuadRestraint")


def _object_cast_to_QuadRestraint(*args):
  """_object_cast_to_QuadRestraint(Object o) -> QuadRestraint"""
  return _IMP_core._object_cast_to_QuadRestraint(*args)
_object_types.append("QuadraticClosePairsFinder")


def _object_cast_to_QuadraticClosePairsFinder(*args):
  """_object_cast_to_QuadraticClosePairsFinder(Object o) -> QuadraticClosePairsFinder"""
  return _IMP_core._object_cast_to_QuadraticClosePairsFinder(*args)
_object_types.append("RefinedPairsPairScore")


def _object_cast_to_RefinedPairsPairScore(*args):
  """_object_cast_to_RefinedPairsPairScore(Object o) -> RefinedPairsPairScore"""
  return _IMP_core._object_cast_to_RefinedPairsPairScore(*args)
_object_types.append("RestraintsScoringFunction")


def _object_cast_to_RestraintsScoringFunction(*args):
  """_object_cast_to_RestraintsScoringFunction(Object o) -> RestraintsScoringFunction"""
  return _IMP_core._object_cast_to_RestraintsScoringFunction(*args)
_object_types.append("RigidBodyDistancePairScore")


def _object_cast_to_RigidBodyDistancePairScore(*args):
  """_object_cast_to_RigidBodyDistancePairScore(Object o) -> RigidBodyDistancePairScore"""
  return _IMP_core._object_cast_to_RigidBodyDistancePairScore(*args)
_object_types.append("RigidBodyMover")


def _object_cast_to_RigidBodyMover(*args):
  """_object_cast_to_RigidBodyMover(Object o) -> RigidBodyMover"""
  return _IMP_core._object_cast_to_RigidBodyMover(*args)
_object_types.append("RigidClosePairsFinder")


def _object_cast_to_RigidClosePairsFinder(*args):
  """_object_cast_to_RigidClosePairsFinder(Object o) -> RigidClosePairsFinder"""
  return _IMP_core._object_cast_to_RigidClosePairsFinder(*args)
_object_types.append("RigidMembersRefiner")


def _object_cast_to_RigidMembersRefiner(*args):
  """_object_cast_to_RigidMembersRefiner(Object o) -> RigidMembersRefiner"""
  return _IMP_core._object_cast_to_RigidMembersRefiner(*args)
_object_types.append("SingletonConstraint")


def _object_cast_to_SingletonConstraint(*args):
  """_object_cast_to_SingletonConstraint(Object o) -> SingletonConstraint"""
  return _IMP_core._object_cast_to_SingletonConstraint(*args)
_object_types.append("SingletonRestraint")


def _object_cast_to_SingletonRestraint(*args):
  """_object_cast_to_SingletonRestraint(Object o) -> SingletonRestraint"""
  return _IMP_core._object_cast_to_SingletonRestraint(*args)
_object_types.append("SoftSpherePairScore")


def _object_cast_to_SoftSpherePairScore(*args):
  """_object_cast_to_SoftSpherePairScore(Object o) -> SoftSpherePairScore"""
  return _IMP_core._object_cast_to_SoftSpherePairScore(*args)
_object_types.append("SphereDistancePairScore")


def _object_cast_to_SphereDistancePairScore(*args):
  """_object_cast_to_SphereDistancePairScore(Object o) -> SphereDistancePairScore"""
  return _IMP_core._object_cast_to_SphereDistancePairScore(*args)
_object_types.append("SphereDistanceToSingletonScore")


def _object_cast_to_SphereDistanceToSingletonScore(*args):
  """_object_cast_to_SphereDistanceToSingletonScore(Object o) -> SphereDistanceToSingletonScore"""
  return _IMP_core._object_cast_to_SphereDistanceToSingletonScore(*args)
_object_types.append("SteepestDescent")


def _object_cast_to_SteepestDescent(*args):
  """_object_cast_to_SteepestDescent(Object o) -> SteepestDescent"""
  return _IMP_core._object_cast_to_SteepestDescent(*args)
_object_types.append("TableRefiner")


def _object_cast_to_TableRefiner(*args):
  """_object_cast_to_TableRefiner(Object o) -> TableRefiner"""
  return _IMP_core._object_cast_to_TableRefiner(*args)
_object_types.append("Transform")


def _object_cast_to_Transform(*args):
  """_object_cast_to_Transform(Object o) -> Transform"""
  return _IMP_core._object_cast_to_Transform(*args)
_object_types.append("TransformationAndReflectionSymmetry")


def _object_cast_to_TransformationAndReflectionSymmetry(*args):
  """_object_cast_to_TransformationAndReflectionSymmetry(Object o) -> TransformationAndReflectionSymmetry"""
  return _IMP_core._object_cast_to_TransformationAndReflectionSymmetry(*args)
_object_types.append("TransformationSymmetry")


def _object_cast_to_TransformationSymmetry(*args):
  """_object_cast_to_TransformationSymmetry(Object o) -> TransformationSymmetry"""
  return _IMP_core._object_cast_to_TransformationSymmetry(*args)
_object_types.append("TransformedDistancePairScore")


def _object_cast_to_TransformedDistancePairScore(*args):
  """_object_cast_to_TransformedDistancePairScore(Object o) -> TransformedDistancePairScore"""
  return _IMP_core._object_cast_to_TransformedDistancePairScore(*args)
_object_types.append("TripletConstraint")


def _object_cast_to_TripletConstraint(*args):
  """_object_cast_to_TripletConstraint(Object o) -> TripletConstraint"""
  return _IMP_core._object_cast_to_TripletConstraint(*args)
_object_types.append("TripletRestraint")


def _object_cast_to_TripletRestraint(*args):
  """_object_cast_to_TripletRestraint(Object o) -> TripletRestraint"""
  return _IMP_core._object_cast_to_TripletRestraint(*args)
_object_types.append("TypedPairScore")


def _object_cast_to_TypedPairScore(*args):
  """_object_cast_to_TypedPairScore(Object o) -> TypedPairScore"""
  return _IMP_core._object_cast_to_TypedPairScore(*args)
_object_types.append("VolumeRestraint")


def _object_cast_to_VolumeRestraint(*args):
  """_object_cast_to_VolumeRestraint(Object o) -> VolumeRestraint"""
  return _IMP_core._object_cast_to_VolumeRestraint(*args)
_object_types.append("WeightedSphereDistancePairScore")


def _object_cast_to_WeightedSphereDistancePairScore(*args):
  """_object_cast_to_WeightedSphereDistancePairScore(Object o) -> WeightedSphereDistancePairScore"""
  return _IMP_core._object_cast_to_WeightedSphereDistancePairScore(*args)
_object_types.append("MoveStatisticsScoreState")


def _object_cast_to_MoveStatisticsScoreState(*args):
  """_object_cast_to_MoveStatisticsScoreState(Object o) -> MoveStatisticsScoreState"""
  return _IMP_core._object_cast_to_MoveStatisticsScoreState(*args)
_object_types.append("MinimumRestraint")


def _object_cast_to_MinimumRestraint(*args):
  """_object_cast_to_MinimumRestraint(Object o) -> MinimumRestraint"""
  return _IMP_core._object_cast_to_MinimumRestraint(*args)
_object_types.append("WriteRestraintScoresOptimizerState")


def _object_cast_to_WriteRestraintScoresOptimizerState(*args):
  """_object_cast_to_WriteRestraintScoresOptimizerState(Object o) -> WriteRestraintScoresOptimizerState"""
  return _IMP_core._object_cast_to_WriteRestraintScoresOptimizerState(*args)
_object_types.append("ConstantSingletonPredicate")


def _object_cast_to_ConstantSingletonPredicate(*args):
  """_object_cast_to_ConstantSingletonPredicate(Object o) -> ConstantSingletonPredicate"""
  return _IMP_core._object_cast_to_ConstantSingletonPredicate(*args)
_object_types.append("ConstantPairPredicate")


def _object_cast_to_ConstantPairPredicate(*args):
  """_object_cast_to_ConstantPairPredicate(Object o) -> ConstantPairPredicate"""
  return _IMP_core._object_cast_to_ConstantPairPredicate(*args)
_object_types.append("ConstantTripletPredicate")


def _object_cast_to_ConstantTripletPredicate(*args):
  """_object_cast_to_ConstantTripletPredicate(Object o) -> ConstantTripletPredicate"""
  return _IMP_core._object_cast_to_ConstantTripletPredicate(*args)
_object_types.append("ConstantQuadPredicate")


def _object_cast_to_ConstantQuadPredicate(*args):
  """_object_cast_to_ConstantQuadPredicate(Object o) -> ConstantQuadPredicate"""
  return _IMP_core._object_cast_to_ConstantQuadPredicate(*args)
_object_types.append("CoinFlipSingletonPredicate")


def _object_cast_to_CoinFlipSingletonPredicate(*args):
  """_object_cast_to_CoinFlipSingletonPredicate(Object o) -> CoinFlipSingletonPredicate"""
  return _IMP_core._object_cast_to_CoinFlipSingletonPredicate(*args)
_object_types.append("CoinFlipPairPredicate")


def _object_cast_to_CoinFlipPairPredicate(*args):
  """_object_cast_to_CoinFlipPairPredicate(Object o) -> CoinFlipPairPredicate"""
  return _IMP_core._object_cast_to_CoinFlipPairPredicate(*args)
_object_types.append("CoinFlipTripletPredicate")


def _object_cast_to_CoinFlipTripletPredicate(*args):
  """_object_cast_to_CoinFlipTripletPredicate(Object o) -> CoinFlipTripletPredicate"""
  return _IMP_core._object_cast_to_CoinFlipTripletPredicate(*args)
_object_types.append("CoinFlipQuadPredicate")


def _object_cast_to_CoinFlipQuadPredicate(*args):
  """_object_cast_to_CoinFlipQuadPredicate(Object o) -> CoinFlipQuadPredicate"""
  return _IMP_core._object_cast_to_CoinFlipQuadPredicate(*args)
_object_types.append("UnorderedTypeSingletonPredicate")


def _object_cast_to_UnorderedTypeSingletonPredicate(*args):
  """_object_cast_to_UnorderedTypeSingletonPredicate(Object o) -> UnorderedTypeSingletonPredicate"""
  return _IMP_core._object_cast_to_UnorderedTypeSingletonPredicate(*args)
_object_types.append("UnorderedTypePairPredicate")


def _object_cast_to_UnorderedTypePairPredicate(*args):
  """_object_cast_to_UnorderedTypePairPredicate(Object o) -> UnorderedTypePairPredicate"""
  return _IMP_core._object_cast_to_UnorderedTypePairPredicate(*args)
_object_types.append("UnorderedTypeTripletPredicate")


def _object_cast_to_UnorderedTypeTripletPredicate(*args):
  """_object_cast_to_UnorderedTypeTripletPredicate(Object o) -> UnorderedTypeTripletPredicate"""
  return _IMP_core._object_cast_to_UnorderedTypeTripletPredicate(*args)
_object_types.append("UnorderedTypeQuadPredicate")


def _object_cast_to_UnorderedTypeQuadPredicate(*args):
  """_object_cast_to_UnorderedTypeQuadPredicate(Object o) -> UnorderedTypeQuadPredicate"""
  return _IMP_core._object_cast_to_UnorderedTypeQuadPredicate(*args)
_object_types.append("OrderedTypeSingletonPredicate")


def _object_cast_to_OrderedTypeSingletonPredicate(*args):
  """_object_cast_to_OrderedTypeSingletonPredicate(Object o) -> OrderedTypeSingletonPredicate"""
  return _IMP_core._object_cast_to_OrderedTypeSingletonPredicate(*args)
_object_types.append("OrderedTypePairPredicate")


def _object_cast_to_OrderedTypePairPredicate(*args):
  """_object_cast_to_OrderedTypePairPredicate(Object o) -> OrderedTypePairPredicate"""
  return _IMP_core._object_cast_to_OrderedTypePairPredicate(*args)
_object_types.append("OrderedTypeTripletPredicate")


def _object_cast_to_OrderedTypeTripletPredicate(*args):
  """_object_cast_to_OrderedTypeTripletPredicate(Object o) -> OrderedTypeTripletPredicate"""
  return _IMP_core._object_cast_to_OrderedTypeTripletPredicate(*args)
_object_types.append("OrderedTypeQuadPredicate")


def _object_cast_to_OrderedTypeQuadPredicate(*args):
  """_object_cast_to_OrderedTypeQuadPredicate(Object o) -> OrderedTypeQuadPredicate"""
  return _IMP_core._object_cast_to_OrderedTypeQuadPredicate(*args)
_object_types.append("AllSameSingletonPredicate")


def _object_cast_to_AllSameSingletonPredicate(*args):
  """_object_cast_to_AllSameSingletonPredicate(Object o) -> AllSameSingletonPredicate"""
  return _IMP_core._object_cast_to_AllSameSingletonPredicate(*args)
_object_types.append("AllSamePairPredicate")


def _object_cast_to_AllSamePairPredicate(*args):
  """_object_cast_to_AllSamePairPredicate(Object o) -> AllSamePairPredicate"""
  return _IMP_core._object_cast_to_AllSamePairPredicate(*args)
_object_types.append("AllSameTripletPredicate")


def _object_cast_to_AllSameTripletPredicate(*args):
  """_object_cast_to_AllSameTripletPredicate(Object o) -> AllSameTripletPredicate"""
  return _IMP_core._object_cast_to_AllSameTripletPredicate(*args)
_object_types.append("AllSameQuadPredicate")


def _object_cast_to_AllSameQuadPredicate(*args):
  """_object_cast_to_AllSameQuadPredicate(Object o) -> AllSameQuadPredicate"""
  return _IMP_core._object_cast_to_AllSameQuadPredicate(*args)
def XYZs(l=[]):
    return [XYZ(x) for x in l]
_plural_types.append("XYZs")

_value_types.append("XYZ")

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

_value_types.append("XYZR")

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

_value_types.append("RigidBody")

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

_value_types.append("RigidMember")

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

_value_types.append("NonRigidMember")

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

_value_types.append("Centroid")

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

_value_types.append("Cover")

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

_value_types.append("Reference")

ParticleTypes=list
_plural_types.append("ParticleTypes")
_value_types.append("ParticleType")

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

_value_types.append("Typed")

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

_value_types.append("Hierarchy")

HierarchyCounters=list
_plural_types.append("HierarchyCounters")
_value_types.append("HierarchyCounter")

HierarchyTraitsList=list
_plural_types.append("HierarchyTraitsList")
_value_types.append("HierarchyTraits")

_object_types.append("TruncatedHarmonicBound")


def _object_cast_to_TruncatedHarmonicBound(*args):
  """_object_cast_to_TruncatedHarmonicBound(Object o) -> TruncatedHarmonicBound"""
  return _IMP_core._object_cast_to_TruncatedHarmonicBound(*args)
_object_types.append("TruncatedHarmonicLowerBound")


def _object_cast_to_TruncatedHarmonicLowerBound(*args):
  """_object_cast_to_TruncatedHarmonicLowerBound(Object o) -> TruncatedHarmonicLowerBound"""
  return _IMP_core._object_cast_to_TruncatedHarmonicLowerBound(*args)
_object_types.append("TruncatedHarmonicUpperBound")


def _object_cast_to_TruncatedHarmonicUpperBound(*args):
  """_object_cast_to_TruncatedHarmonicUpperBound(Object o) -> TruncatedHarmonicUpperBound"""
  return _IMP_core._object_cast_to_TruncatedHarmonicUpperBound(*args)
_object_types.append("HarmonicDistancePairScore")


def _object_cast_to_HarmonicDistancePairScore(*args):
  """_object_cast_to_HarmonicDistancePairScore(Object o) -> HarmonicDistancePairScore"""
  return _IMP_core._object_cast_to_HarmonicDistancePairScore(*args)
_object_types.append("DistancePairScore")


def _object_cast_to_DistancePairScore(*args):
  """_object_cast_to_DistancePairScore(Object o) -> DistancePairScore"""
  return _IMP_core._object_cast_to_DistancePairScore(*args)
_object_types.append("XYZRGeometry")


def _object_cast_to_XYZRGeometry(*args):
  """_object_cast_to_XYZRGeometry(Object o) -> XYZRGeometry"""
  return _IMP_core._object_cast_to_XYZRGeometry(*args)
_object_types.append("XYZRsGeometry")


def _object_cast_to_XYZRsGeometry(*args):
  """_object_cast_to_XYZRsGeometry(Object o) -> XYZRsGeometry"""
  return _IMP_core._object_cast_to_XYZRsGeometry(*args)
_object_types.append("XYZDerivativeGeometry")


def _object_cast_to_XYZDerivativeGeometry(*args):
  """_object_cast_to_XYZDerivativeGeometry(Object o) -> XYZDerivativeGeometry"""
  return _IMP_core._object_cast_to_XYZDerivativeGeometry(*args)
_object_types.append("XYZDerivativesGeometry")


def _object_cast_to_XYZDerivativesGeometry(*args):
  """_object_cast_to_XYZDerivativesGeometry(Object o) -> XYZDerivativesGeometry"""
  return _IMP_core._object_cast_to_XYZDerivativesGeometry(*args)
_object_types.append("RigidBodyDerivativeGeometry")


def _object_cast_to_RigidBodyDerivativeGeometry(*args):
  """_object_cast_to_RigidBodyDerivativeGeometry(Object o) -> RigidBodyDerivativeGeometry"""
  return _IMP_core._object_cast_to_RigidBodyDerivativeGeometry(*args)
_object_types.append("RigidBodyDerivativesGeometry")


def _object_cast_to_RigidBodyDerivativesGeometry(*args):
  """_object_cast_to_RigidBodyDerivativesGeometry(Object o) -> RigidBodyDerivativesGeometry"""
  return _IMP_core._object_cast_to_RigidBodyDerivativesGeometry(*args)
_object_types.append("RigidBodyHierarchyGeometry")


def _object_cast_to_RigidBodyHierarchyGeometry(*args):
  """_object_cast_to_RigidBodyHierarchyGeometry(Object o) -> RigidBodyHierarchyGeometry"""
  return _IMP_core._object_cast_to_RigidBodyHierarchyGeometry(*args)
_object_types.append("RigidBodyFrameGeometry")


def _object_cast_to_RigidBodyFrameGeometry(*args):
  """_object_cast_to_RigidBodyFrameGeometry(Object o) -> RigidBodyFrameGeometry"""
  return _IMP_core._object_cast_to_RigidBodyFrameGeometry(*args)
_object_types.append("RigidBodyFramesGeometry")


def _object_cast_to_RigidBodyFramesGeometry(*args):
  """_object_cast_to_RigidBodyFramesGeometry(Object o) -> RigidBodyFramesGeometry"""
  return _IMP_core._object_cast_to_RigidBodyFramesGeometry(*args)
_object_types.append("RigidBodyTorque")


def _object_cast_to_RigidBodyTorque(*args):
  """_object_cast_to_RigidBodyTorque(Object o) -> RigidBodyTorque"""
  return _IMP_core._object_cast_to_RigidBodyTorque(*args)
_object_types.append("EdgePairGeometry")


def _object_cast_to_EdgePairGeometry(*args):
  """_object_cast_to_EdgePairGeometry(Object o) -> EdgePairGeometry"""
  return _IMP_core._object_cast_to_EdgePairGeometry(*args)
_object_types.append("EdgePairsGeometry")


def _object_cast_to_EdgePairsGeometry(*args):
  """_object_cast_to_EdgePairsGeometry(Object o) -> EdgePairsGeometry"""
  return _IMP_core._object_cast_to_EdgePairsGeometry(*args)
class ClosePairsFinder(IMP.base.Object):
    """Proxy of C++ IMP::core::ClosePairsFinder class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ClosePairsFinder, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ClosePairsFinder, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __swig_destroy__ = _IMP_core.delete_ClosePairsFinder
    __del__ = lambda self : None;
    def get_close_pairs(self, *args):
        """
        get_close_pairs(ClosePairsFinder self, IMP::kernel::ParticlesTemp const & pc) -> IMP::kernel::ParticlePairsTemp
        get_close_pairs(ClosePairsFinder self, IMP::kernel::ParticlesTemp const & pca, IMP::kernel::ParticlesTemp const & pcb) -> IMP::kernel::ParticlePairsTemp
        get_close_pairs(ClosePairsFinder self, IMP::algebra::BoundingBox3Ds const & bbs) -> IMP::IntPairs
        get_close_pairs(ClosePairsFinder self, IMP::algebra::BoundingBox3Ds const & bas, IMP::algebra::BoundingBox3Ds const & bbs) -> IMP::IntPairs
        """
        return _IMP_core.ClosePairsFinder_get_close_pairs(self, *args)

    def set_distance(self, *args):
        """set_distance(ClosePairsFinder self, double d)"""
        return _IMP_core.ClosePairsFinder_set_distance(self, *args)

    def get_distance(self):
        """get_distance(ClosePairsFinder self) -> double"""
        return _IMP_core.ClosePairsFinder_get_distance(self)

    def get_input_particles(self, *args):
        """
        get_input_particles(ClosePairsFinder self, IMP::kernel::ParticlesTemp const & ps) -> IMP::kernel::ParticlesTemp
        get_input_particles(ClosePairsFinder self, Particle p) -> IMP::kernel::ParticlesTemp
        """
        return _IMP_core.ClosePairsFinder_get_input_particles(self, *args)

    def get_input_containers(self, *args):
        """
        get_input_containers(ClosePairsFinder self, IMP::kernel::ParticlesTemp const & ps) -> IMP::kernel::ContainersTemp
        get_input_containers(ClosePairsFinder self, Particle p) -> IMP::kernel::ContainersTemp
        """
        return _IMP_core.ClosePairsFinder_get_input_containers(self, *args)

    def get_inputs(self, *args):
        """get_inputs(ClosePairsFinder self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_core.ClosePairsFinder_get_inputs(self, *args)

    def _do_get_inputs(self, *args):
        """_do_get_inputs(ClosePairsFinder self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_core.ClosePairsFinder__do_get_inputs(self, *args)

    def remove_pair_filter(self, *args):
        """remove_pair_filter(ClosePairsFinder self, PairPredicate d)"""
        return _IMP_core.ClosePairsFinder_remove_pair_filter(self, *args)

    def remove_pair_filters(self, *args):
        """remove_pair_filters(ClosePairsFinder self, IMP::kernel::PairPredicates const & d)"""
        return _IMP_core.ClosePairsFinder_remove_pair_filters(self, *args)

    def set_pair_filters(self, *args):
        """set_pair_filters(ClosePairsFinder self, IMP::kernel::PairPredicates const & ps)"""
        return _IMP_core.ClosePairsFinder_set_pair_filters(self, *args)

    def set_pair_filters_order(self, *args):
        """set_pair_filters_order(ClosePairsFinder self, IMP::kernel::PairPredicates const & objs)"""
        return _IMP_core.ClosePairsFinder_set_pair_filters_order(self, *args)

    def add_pair_filter(self, *args):
        """add_pair_filter(ClosePairsFinder self, PairPredicate obj) -> unsigned int"""
        return _IMP_core.ClosePairsFinder_add_pair_filter(self, *args)

    def add_pair_filters(self, *args):
        """add_pair_filters(ClosePairsFinder self, IMP::kernel::PairPredicates const & objs)"""
        return _IMP_core.ClosePairsFinder_add_pair_filters(self, *args)

    def clear_pair_filters(self):
        """clear_pair_filters(ClosePairsFinder self)"""
        return _IMP_core.ClosePairsFinder_clear_pair_filters(self)

    def get_number_of_pair_filters(self):
        """get_number_of_pair_filters(ClosePairsFinder self) -> unsigned int"""
        return _IMP_core.ClosePairsFinder_get_number_of_pair_filters(self)

    def get_has_pair_filters(self):
        """get_has_pair_filters(ClosePairsFinder self) -> bool"""
        return _IMP_core.ClosePairsFinder_get_has_pair_filters(self)

    def get_pair_filter(self, *args):
        """get_pair_filter(ClosePairsFinder self, unsigned int i) -> PairPredicate"""
        return _IMP_core.ClosePairsFinder_get_pair_filter(self, *args)

    def get_pair_filters(self):
        """get_pair_filters(ClosePairsFinder self) -> IMP::kernel::PairPredicates"""
        return _IMP_core.ClosePairsFinder_get_pair_filters(self)

    def reserve_pair_filters(self, *args):
        """reserve_pair_filters(ClosePairsFinder self, unsigned int sz)"""
        return _IMP_core.ClosePairsFinder_reserve_pair_filters(self, *args)

    def __str__(self):
        """__str__(ClosePairsFinder self) -> std::string"""
        return _IMP_core.ClosePairsFinder___str__(self)

    def __repr__(self):
        """__repr__(ClosePairsFinder self) -> std::string"""
        return _IMP_core.ClosePairsFinder___repr__(self)

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

ClosePairsFinder_swigregister = _IMP_core.ClosePairsFinder_swigregister
ClosePairsFinder_swigregister(ClosePairsFinder)

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

    def show(self, *args):
        """
        show(MonteCarloMoverResult self, _ostream out=std::cout)
        show(MonteCarloMoverResult self)
        """
        return _IMP_core.MonteCarloMoverResult_show(self, *args)

    def __eq__(self, *args):
        """__eq__(MonteCarloMoverResult self, MonteCarloMoverResult o) -> bool"""
        return _IMP_core.MonteCarloMoverResult___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(MonteCarloMoverResult self, MonteCarloMoverResult o) -> bool"""
        return _IMP_core.MonteCarloMoverResult___ne__(self, *args)

    def __lt__(self, *args):
        """__lt__(MonteCarloMoverResult self, MonteCarloMoverResult o) -> bool"""
        return _IMP_core.MonteCarloMoverResult___lt__(self, *args)

    def __gt__(self, *args):
        """__gt__(MonteCarloMoverResult self, MonteCarloMoverResult o) -> bool"""
        return _IMP_core.MonteCarloMoverResult___gt__(self, *args)

    def __ge__(self, *args):
        """__ge__(MonteCarloMoverResult self, MonteCarloMoverResult o) -> bool"""
        return _IMP_core.MonteCarloMoverResult___ge__(self, *args)

    def __le__(self, *args):
        """__le__(MonteCarloMoverResult self, MonteCarloMoverResult o) -> bool"""
        return _IMP_core.MonteCarloMoverResult___le__(self, *args)

    def get_moved_particles(self):
        """get_moved_particles(MonteCarloMoverResult self) -> IMP::kernel::ParticleIndexes const &"""
        return _IMP_core.MonteCarloMoverResult_get_moved_particles(self)

    def set_moved_particles(self, *args):
        """set_moved_particles(MonteCarloMoverResult self, IMP::kernel::ParticleIndexes const & v)"""
        return _IMP_core.MonteCarloMoverResult_set_moved_particles(self, *args)

    def get_proposal_ratio(self):
        """get_proposal_ratio(MonteCarloMoverResult self) -> double const &"""
        return _IMP_core.MonteCarloMoverResult_get_proposal_ratio(self)

    def set_proposal_ratio(self, *args):
        """set_proposal_ratio(MonteCarloMoverResult self, double const & v)"""
        return _IMP_core.MonteCarloMoverResult_set_proposal_ratio(self, *args)

    def __str__(self):
        """__str__(MonteCarloMoverResult self) -> std::string"""
        return _IMP_core.MonteCarloMoverResult___str__(self)

    def __repr__(self):
        """__repr__(MonteCarloMoverResult self) -> std::string"""
        return _IMP_core.MonteCarloMoverResult___repr__(self)

    __swig_destroy__ = _IMP_core.delete_MonteCarloMoverResult
    __del__ = lambda self : None;
MonteCarloMoverResult_swigregister = _IMP_core.MonteCarloMoverResult_swigregister
MonteCarloMoverResult_swigregister(MonteCarloMoverResult)

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



    def propose(self):
        """propose(MonteCarloMover self) -> MonteCarloMoverResult"""
        return _IMP_core.MonteCarloMover_propose(self)

    def reject(self):
        """reject(MonteCarloMover self)"""
        return _IMP_core.MonteCarloMover_reject(self)

    def accept(self):
        """accept(MonteCarloMover self)"""
        return _IMP_core.MonteCarloMover_accept(self)

    def get_number_of_proposed(self):
        """get_number_of_proposed(MonteCarloMover self) -> unsigned int"""
        return _IMP_core.MonteCarloMover_get_number_of_proposed(self)

    def get_number_of_accepted(self):
        """get_number_of_accepted(MonteCarloMover self) -> unsigned int"""
        return _IMP_core.MonteCarloMover_get_number_of_accepted(self)

    def reset_statistics(self):
        """reset_statistics(MonteCarloMover self)"""
        return _IMP_core.MonteCarloMover_reset_statistics(self)

    def do_propose(self):
        """do_propose(MonteCarloMover self) -> MonteCarloMoverResult"""
        return _IMP_core.MonteCarloMover_do_propose(self)

    def do_reject(self):
        """do_reject(MonteCarloMover self)"""
        return _IMP_core.MonteCarloMover_do_reject(self)

    def do_accept(self):
        """do_accept(MonteCarloMover self)"""
        return _IMP_core.MonteCarloMover_do_accept(self)

    def do_get_outputs(self):
        """do_get_outputs(MonteCarloMover self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_core.MonteCarloMover_do_get_outputs(self)

    def do_update_dependencies(self):
        """do_update_dependencies(MonteCarloMover self)"""
        return _IMP_core.MonteCarloMover_do_update_dependencies(self)

    def __str__(self):
        """__str__(MonteCarloMover self) -> std::string"""
        return _IMP_core.MonteCarloMover___str__(self)

    def __repr__(self):
        """__repr__(MonteCarloMover self) -> std::string"""
        return _IMP_core.MonteCarloMover___repr__(self)

    def get_from(o):
       return _object_cast_to_MonteCarloMover(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::core" == "IMP":
          return VersionInfo("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_MonteCarloMover(o)
    get_from = staticmethod(get_from)

    __swig_destroy__ = _IMP_core.delete_MonteCarloMover
    __del__ = lambda self : None;
    def __disown__(self):
        self.this.disown()
        _IMP_core.disown_MonteCarloMover(self)
        return weakref_proxy(self)
    def update_dependencies(self):
        """update_dependencies(MonteCarloMover self)"""
        return _IMP_core.MonteCarloMover_update_dependencies(self)

    def do_get_inputs(self):
        """do_get_inputs(MonteCarloMover self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_core.MonteCarloMover_do_get_inputs(self)

    def do_get_interactions(self):
        """do_get_interactions(MonteCarloMover self) -> IMP::kernel::ModelObjectsTemps"""
        return _IMP_core.MonteCarloMover_do_get_interactions(self)

MonteCarloMover_swigregister = _IMP_core.MonteCarloMover_swigregister
MonteCarloMover_swigregister(MonteCarloMover)

class Mover(MonteCarloMover):
    """Proxy of C++ IMP::core::Mover class"""
    __swig_setmethods__ = {}
    for _s in [MonteCarloMover]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Mover, name, value)
    __swig_getmethods__ = {}
    for _s in [MonteCarloMover]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Mover, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    def propose_move(self, *args):
        """propose_move(Mover self, IMP::Float size) -> IMP::kernel::ParticlesTemp"""
        return _IMP_core.Mover_propose_move(self, *args)

    def reset_move(self):
        """reset_move(Mover self)"""
        return _IMP_core.Mover_reset_move(self)

    def get_output_particles(self):
        """get_output_particles(Mover self) -> IMP::kernel::ParticlesTemp"""
        return _IMP_core.Mover_get_output_particles(self)

    def __str__(self):
        """__str__(Mover self) -> std::string"""
        return _IMP_core.Mover___str__(self)

    def __repr__(self):
        """__repr__(Mover self) -> std::string"""
        return _IMP_core.Mover___repr__(self)

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

    __swig_destroy__ = _IMP_core.delete_Mover
    __del__ = lambda self : None;
Mover_swigregister = _IMP_core.Mover_swigregister
Mover_swigregister(Mover)

class MoverBase(Mover):
    """Proxy of C++ IMP::core::MoverBase class"""
    __swig_setmethods__ = {}
    for _s in [Mover]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MoverBase, name, value)
    __swig_getmethods__ = {}
    for _s in [Mover]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MoverBase, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    def __str__(self):
        """__str__(MoverBase self) -> std::string"""
        return _IMP_core.MoverBase___str__(self)

    def __repr__(self):
        """__repr__(MoverBase self) -> std::string"""
        return _IMP_core.MoverBase___repr__(self)

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

    __swig_destroy__ = _IMP_core.delete_MoverBase
    __del__ = lambda self : None;
MoverBase_swigregister = _IMP_core.MoverBase_swigregister
MoverBase_swigregister(MoverBase)

class XYZ(IMP.kernel.Decorator):
    """Proxy of C++ IMP::core::XYZ class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Decorator]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, XYZ, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Decorator]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, XYZ, name)
    def get_coordinate_key(*args):
        """get_coordinate_key(unsigned int i) -> FloatKey"""
        return _IMP_core.XYZ_get_coordinate_key(*args)

    if _newclass:get_coordinate_key = staticmethod(get_coordinate_key)
    __swig_getmethods__["get_coordinate_key"] = lambda x: get_coordinate_key
    def __init__(self, *args): 
        """
        __init__(IMP::core::XYZ self) -> XYZ
        __init__(IMP::core::XYZ self, Model m, IMP::kernel::ParticleIndex id) -> XYZ
        __init__(IMP::core::XYZ self, Particle p) -> XYZ
        """
        this = _IMP_core.new_XYZ(*args)
        try: self.this.append(this)
        except: self.this = this
    def decorate_particle(*args):
        """decorate_particle(Particle p) -> XYZ"""
        return _IMP_core.XYZ_decorate_particle(*args)

    if _newclass:decorate_particle = staticmethod(decorate_particle)
    __swig_getmethods__["decorate_particle"] = lambda x: decorate_particle
    def show(self, *args):
        """
        show(XYZ self, _ostream out=std::cout)
        show(XYZ self)
        """
        return _IMP_core.XYZ_show(self, *args)

    def setup_particle(*args):
        """
        setup_particle(Model m, IMP::kernel::ParticleIndex pi, Vector3D v=IMP::algebra::Vector3D(0,0,0)) -> XYZ
        setup_particle(Model m, IMP::kernel::ParticleIndex pi) -> XYZ
        setup_particle(Particle p, Vector3D v=IMP::algebra::Vector3D(0,0,0)) -> XYZ
        setup_particle(Particle p) -> XYZ
        """
        return _IMP_core.XYZ_setup_particle(*args)

    if _newclass:setup_particle = staticmethod(setup_particle)
    __swig_getmethods__["setup_particle"] = lambda x: setup_particle
    def get_x(self):
        """get_x(XYZ self) -> IMP::Float"""
        return _IMP_core.XYZ_get_x(self)

    def set_x(self, *args):
        """set_x(XYZ self, IMP::Float t)"""
        return _IMP_core.XYZ_set_x(self, *args)

    def get_y(self):
        """get_y(XYZ self) -> IMP::Float"""
        return _IMP_core.XYZ_get_y(self)

    def set_y(self, *args):
        """set_y(XYZ self, IMP::Float t)"""
        return _IMP_core.XYZ_set_y(self, *args)

    def get_z(self):
        """get_z(XYZ self) -> IMP::Float"""
        return _IMP_core.XYZ_get_z(self)

    def set_z(self, *args):
        """set_z(XYZ self, IMP::Float t)"""
        return _IMP_core.XYZ_set_z(self, *args)

    def set_coordinate(self, *args):
        """set_coordinate(XYZ self, unsigned int i, IMP::Float v)"""
        return _IMP_core.XYZ_set_coordinate(self, *args)

    def set_coordinates(self, *args):
        """set_coordinates(XYZ self, Vector3D v)"""
        return _IMP_core.XYZ_set_coordinates(self, *args)

    def get_coordinate(self, *args):
        """get_coordinate(XYZ self, int i) -> IMP::Float"""
        return _IMP_core.XYZ_get_coordinate(self, *args)

    def add_to_derivatives(self, *args):
        """add_to_derivatives(XYZ self, Vector3D v, DerivativeAccumulator d)"""
        return _IMP_core.XYZ_add_to_derivatives(self, *args)

    def get_coordinates_are_optimized(self):
        """get_coordinates_are_optimized(XYZ self) -> bool"""
        return _IMP_core.XYZ_get_coordinates_are_optimized(self)

    def set_coordinates_are_optimized(self, *args):
        """set_coordinates_are_optimized(XYZ self, bool tf)"""
        return _IMP_core.XYZ_set_coordinates_are_optimized(self, *args)

    def get_vector_to(self, *args):
        """get_vector_to(XYZ self, XYZ b) -> Vector3D"""
        return _IMP_core.XYZ_get_vector_to(self, *args)

    def get_coordinates(self):
        """get_coordinates(XYZ self) -> Vector3D"""
        return _IMP_core.XYZ_get_coordinates(self)

    def get_derivatives(self):
        """get_derivatives(XYZ self) -> Vector3D"""
        return _IMP_core.XYZ_get_derivatives(self)

    def particle_is_instance(*args):
        """
        particle_is_instance(Particle p) -> bool
        particle_is_instance(Model m, IMP::kernel::ParticleIndex pi) -> bool
        """
        return _IMP_core.XYZ_particle_is_instance(*args)

    if _newclass:particle_is_instance = staticmethod(particle_is_instance)
    __swig_getmethods__["particle_is_instance"] = lambda x: particle_is_instance
    def get_xyz_keys():
        """get_xyz_keys() -> IMP::kernel::FloatKeys const &"""
        return _IMP_core.XYZ_get_xyz_keys()

    if _newclass:get_xyz_keys = staticmethod(get_xyz_keys)
    __swig_getmethods__["get_xyz_keys"] = lambda x: get_xyz_keys
    def add_attribute(self, *args):
        """
        add_attribute(XYZ self, FloatKey k, IMP::Float v, bool opt)
        add_attribute(XYZ self, FloatKey a0, IMP::Float a1)
        add_attribute(XYZ self, IntKey a0, IMP::Int a1)
        add_attribute(XYZ self, StringKey a0, IMP::String a1)
        add_attribute(XYZ self, ParticleIndexKey a0, Particle a1)
        add_attribute(XYZ self, ObjectKey a0, IMP::Object * a1)
        """
        return _IMP_core.XYZ_add_attribute(self, *args)

    def get_value(self, *args):
        """
        get_value(XYZ self, FloatKey a0) -> IMP::Float
        get_value(XYZ self, IntKey a0) -> IMP::Int
        get_value(XYZ self, StringKey a0) -> IMP::String
        get_value(XYZ self, ParticleIndexKey a0) -> Particle
        get_value(XYZ self, ObjectKey a0) -> IMP::Object *
        """
        return _IMP_core.XYZ_get_value(self, *args)

    def set_value(self, *args):
        """
        set_value(XYZ self, FloatKey a0, IMP::Float a1)
        set_value(XYZ self, IntKey a0, IMP::Int a1)
        set_value(XYZ self, StringKey a0, IMP::String a1)
        set_value(XYZ self, ParticleIndexKey a0, Particle a1)
        set_value(XYZ self, ObjectKey a0, IMP::Object * a1)
        """
        return _IMP_core.XYZ_set_value(self, *args)

    def remove_attribute(self, *args):
        """
        remove_attribute(XYZ self, FloatKey a0)
        remove_attribute(XYZ self, IntKey a0)
        remove_attribute(XYZ self, StringKey a0)
        remove_attribute(XYZ self, ParticleIndexKey a0)
        remove_attribute(XYZ self, ObjectKey a0)
        """
        return _IMP_core.XYZ_remove_attribute(self, *args)

    def has_attribute(self, *args):
        """
        has_attribute(XYZ self, FloatKey a0) -> bool
        has_attribute(XYZ self, IntKey a0) -> bool
        has_attribute(XYZ self, StringKey a0) -> bool
        has_attribute(XYZ self, ParticleIndexKey a0) -> bool
        has_attribute(XYZ self, ObjectKey a0) -> bool
        """
        return _IMP_core.XYZ_has_attribute(self, *args)

    def get_derivative(self, *args):
        """
        get_derivative(XYZ self, int i) -> IMP::Float
        get_derivative(XYZ self, FloatKey a0) -> double
        """
        return _IMP_core.XYZ_get_derivative(self, *args)

    def get_name(self):
        """get_name(XYZ self) -> std::string"""
        return _IMP_core.XYZ_get_name(self)

    def clear_caches(self):
        """clear_caches(XYZ self)"""
        return _IMP_core.XYZ_clear_caches(self)

    def set_name(self, *args):
        """set_name(XYZ self, std::string a0)"""
        return _IMP_core.XYZ_set_name(self, *args)

    def set_check_level(self, *args):
        """set_check_level(XYZ self, IMP::base::CheckLevel a0)"""
        return _IMP_core.XYZ_set_check_level(self, *args)

    def add_to_derivative(self, *args):
        """
        add_to_derivative(XYZ self, int i, IMP::Float v, DerivativeAccumulator d)
        add_to_derivative(XYZ self, FloatKey a0, double a1, DerivativeAccumulator a2)
        """
        return _IMP_core.XYZ_add_to_derivative(self, *args)

    def set_is_optimized(self, *args):
        """set_is_optimized(XYZ self, FloatKey a0, bool a1)"""
        return _IMP_core.XYZ_set_is_optimized(self, *args)

    def get_is_optimized(self, *args):
        """get_is_optimized(XYZ self, FloatKey a0) -> bool"""
        return _IMP_core.XYZ_get_is_optimized(self, *args)

    def get_check_level(self):
        """get_check_level(XYZ self) -> IMP::base::CheckLevel"""
        return _IMP_core.XYZ_get_check_level(self)

    def __eq__(self, *args):
        """
        __eq__(XYZ self, XYZ o) -> bool
        __eq__(XYZ self, Particle d) -> bool
        """
        return _IMP_core.XYZ___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(XYZ self, XYZ o) -> bool
        __ne__(XYZ self, Particle d) -> bool
        """
        return _IMP_core.XYZ___ne__(self, *args)

    def __le__(self, *args):
        """
        __le__(XYZ self, XYZ o) -> bool
        __le__(XYZ self, Particle d) -> bool
        """
        return _IMP_core.XYZ___le__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(XYZ self, XYZ o) -> bool
        __lt__(XYZ self, Particle d) -> bool
        """
        return _IMP_core.XYZ___lt__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(XYZ self, XYZ o) -> bool
        __ge__(XYZ self, Particle d) -> bool
        """
        return _IMP_core.XYZ___ge__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(XYZ self, XYZ o) -> bool
        __gt__(XYZ self, Particle d) -> bool
        """
        return _IMP_core.XYZ___gt__(self, *args)

    def __str__(self):
        """__str__(XYZ self) -> std::string"""
        return _IMP_core.XYZ___str__(self)

    def __repr__(self):
        """__repr__(XYZ self) -> std::string"""
        return _IMP_core.XYZ___repr__(self)

    __swig_destroy__ = _IMP_core.delete_XYZ
    __del__ = lambda self : None;
XYZ_swigregister = _IMP_core.XYZ_swigregister
XYZ_swigregister(XYZ)

def XYZ_get_coordinate_key(*args):
  """XYZ_get_coordinate_key(unsigned int i) -> FloatKey"""
  return _IMP_core.XYZ_get_coordinate_key(*args)

def XYZ_decorate_particle(*args):
  """XYZ_decorate_particle(Particle p) -> XYZ"""
  return _IMP_core.XYZ_decorate_particle(*args)

def XYZ_setup_particle(*args):
  """
    setup_particle(Model m, IMP::kernel::ParticleIndex pi, Vector3D v=IMP::algebra::Vector3D(0,0,0)) -> XYZ
    setup_particle(Model m, IMP::kernel::ParticleIndex pi) -> XYZ
    setup_particle(Particle p, Vector3D v=IMP::algebra::Vector3D(0,0,0)) -> XYZ
    XYZ_setup_particle(Particle p) -> XYZ
    """
  return _IMP_core.XYZ_setup_particle(*args)

def XYZ_particle_is_instance(*args):
  """
    particle_is_instance(Particle p) -> bool
    XYZ_particle_is_instance(Model m, IMP::kernel::ParticleIndex pi) -> bool
    """
  return _IMP_core.XYZ_particle_is_instance(*args)

def XYZ_get_xyz_keys():
  """XYZ_get_xyz_keys() -> IMP::kernel::FloatKeys const &"""
  return _IMP_core.XYZ_get_xyz_keys()


def get_dihedral(*args):
  """get_dihedral(XYZ a, XYZ b, XYZ c, XYZ d) -> double"""
  return _IMP_core.get_dihedral(*args)

def get_vector_d_geometry(*args):
  """get_vector_d_geometry(XYZ d) -> Vector3D"""
  return _IMP_core.get_vector_d_geometry(*args)

def set_vector_d_geometry(*args):
  """set_vector_d_geometry(XYZ d, Vector3D v)"""
  return _IMP_core.set_vector_d_geometry(*args)
class XYZR(XYZ):
    """Proxy of C++ IMP::core::XYZR class"""
    __swig_setmethods__ = {}
    for _s in [XYZ]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, XYZR, name, value)
    __swig_getmethods__ = {}
    for _s in [XYZ]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, XYZR, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::XYZR self) -> XYZR
        __init__(IMP::core::XYZR self, Model m, IMP::kernel::ParticleIndex id) -> XYZR
        __init__(IMP::core::XYZR self, Particle p) -> XYZR
        """
        this = _IMP_core.new_XYZR(*args)
        try: self.this.append(this)
        except: self.this = this
    def decorate_particle(*args):
        """decorate_particle(Particle p) -> XYZR"""
        return _IMP_core.XYZR_decorate_particle(*args)

    if _newclass:decorate_particle = staticmethod(decorate_particle)
    __swig_getmethods__["decorate_particle"] = lambda x: decorate_particle
    def show(self, *args):
        """
        show(XYZR self, _ostream out=std::cout)
        show(XYZR self)
        """
        return _IMP_core.XYZR_show(self, *args)

    def setup_particle(*args):
        """
        setup_particle(Particle p) -> XYZR
        setup_particle(Particle p, IMP::Float radius) -> XYZR
        setup_particle(Particle p, Sphere3D s) -> XYZR
        setup_particle(Model m, IMP::kernel::ParticleIndex pi, Sphere3D s) -> XYZR
        """
        return _IMP_core.XYZR_setup_particle(*args)

    if _newclass:setup_particle = staticmethod(setup_particle)
    __swig_getmethods__["setup_particle"] = lambda x: setup_particle
    def particle_is_instance(*args):
        """particle_is_instance(Particle p) -> bool"""
        return _IMP_core.XYZR_particle_is_instance(*args)

    if _newclass:particle_is_instance = staticmethod(particle_is_instance)
    __swig_getmethods__["particle_is_instance"] = lambda x: particle_is_instance
    def get_radius(self):
        """get_radius(XYZR self) -> double"""
        return _IMP_core.XYZR_get_radius(self)

    def set_radius(self, *args):
        """set_radius(XYZR self, double r)"""
        return _IMP_core.XYZR_set_radius(self, *args)

    def get_sphere(self):
        """get_sphere(XYZR self) -> Sphere3D"""
        return _IMP_core.XYZR_get_sphere(self)

    def set_sphere(self, *args):
        """set_sphere(XYZR self, Sphere3D s)"""
        return _IMP_core.XYZR_set_sphere(self, *args)

    def get_radius_key():
        """get_radius_key() -> FloatKey"""
        return _IMP_core.XYZR_get_radius_key()

    if _newclass:get_radius_key = staticmethod(get_radius_key)
    __swig_getmethods__["get_radius_key"] = lambda x: get_radius_key
    def add_to_radius_derivative(self, *args):
        """add_to_radius_derivative(XYZR self, double v, DerivativeAccumulator d)"""
        return _IMP_core.XYZR_add_to_radius_derivative(self, *args)

    def add_attribute(self, *args):
        """
        add_attribute(XYZR self, FloatKey k, IMP::Float v, bool opt)
        add_attribute(XYZR self, FloatKey a0, IMP::Float a1)
        add_attribute(XYZR self, IntKey a0, IMP::Int a1)
        add_attribute(XYZR self, StringKey a0, IMP::String a1)
        add_attribute(XYZR self, ParticleIndexKey a0, Particle a1)
        add_attribute(XYZR self, ObjectKey a0, IMP::Object * a1)
        """
        return _IMP_core.XYZR_add_attribute(self, *args)

    def get_value(self, *args):
        """
        get_value(XYZR self, FloatKey a0) -> IMP::Float
        get_value(XYZR self, IntKey a0) -> IMP::Int
        get_value(XYZR self, StringKey a0) -> IMP::String
        get_value(XYZR self, ParticleIndexKey a0) -> Particle
        get_value(XYZR self, ObjectKey a0) -> IMP::Object *
        """
        return _IMP_core.XYZR_get_value(self, *args)

    def set_value(self, *args):
        """
        set_value(XYZR self, FloatKey a0, IMP::Float a1)
        set_value(XYZR self, IntKey a0, IMP::Int a1)
        set_value(XYZR self, StringKey a0, IMP::String a1)
        set_value(XYZR self, ParticleIndexKey a0, Particle a1)
        set_value(XYZR self, ObjectKey a0, IMP::Object * a1)
        """
        return _IMP_core.XYZR_set_value(self, *args)

    def remove_attribute(self, *args):
        """
        remove_attribute(XYZR self, FloatKey a0)
        remove_attribute(XYZR self, IntKey a0)
        remove_attribute(XYZR self, StringKey a0)
        remove_attribute(XYZR self, ParticleIndexKey a0)
        remove_attribute(XYZR self, ObjectKey a0)
        """
        return _IMP_core.XYZR_remove_attribute(self, *args)

    def has_attribute(self, *args):
        """
        has_attribute(XYZR self, FloatKey a0) -> bool
        has_attribute(XYZR self, IntKey a0) -> bool
        has_attribute(XYZR self, StringKey a0) -> bool
        has_attribute(XYZR self, ParticleIndexKey a0) -> bool
        has_attribute(XYZR self, ObjectKey a0) -> bool
        """
        return _IMP_core.XYZR_has_attribute(self, *args)

    def get_derivative(self, *args):
        """get_derivative(XYZR self, FloatKey a0) -> double"""
        return _IMP_core.XYZR_get_derivative(self, *args)

    def get_name(self):
        """get_name(XYZR self) -> std::string"""
        return _IMP_core.XYZR_get_name(self)

    def clear_caches(self):
        """clear_caches(XYZR self)"""
        return _IMP_core.XYZR_clear_caches(self)

    def set_name(self, *args):
        """set_name(XYZR self, std::string a0)"""
        return _IMP_core.XYZR_set_name(self, *args)

    def set_check_level(self, *args):
        """set_check_level(XYZR self, IMP::base::CheckLevel a0)"""
        return _IMP_core.XYZR_set_check_level(self, *args)

    def add_to_derivative(self, *args):
        """add_to_derivative(XYZR self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_core.XYZR_add_to_derivative(self, *args)

    def set_is_optimized(self, *args):
        """set_is_optimized(XYZR self, FloatKey a0, bool a1)"""
        return _IMP_core.XYZR_set_is_optimized(self, *args)

    def get_is_optimized(self, *args):
        """get_is_optimized(XYZR self, FloatKey a0) -> bool"""
        return _IMP_core.XYZR_get_is_optimized(self, *args)

    def get_check_level(self):
        """get_check_level(XYZR self) -> IMP::base::CheckLevel"""
        return _IMP_core.XYZR_get_check_level(self)

    def __eq__(self, *args):
        """
        __eq__(XYZR self, XYZR o) -> bool
        __eq__(XYZR self, Particle d) -> bool
        """
        return _IMP_core.XYZR___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(XYZR self, XYZR o) -> bool
        __ne__(XYZR self, Particle d) -> bool
        """
        return _IMP_core.XYZR___ne__(self, *args)

    def __le__(self, *args):
        """
        __le__(XYZR self, XYZR o) -> bool
        __le__(XYZR self, Particle d) -> bool
        """
        return _IMP_core.XYZR___le__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(XYZR self, XYZR o) -> bool
        __lt__(XYZR self, Particle d) -> bool
        """
        return _IMP_core.XYZR___lt__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(XYZR self, XYZR o) -> bool
        __ge__(XYZR self, Particle d) -> bool
        """
        return _IMP_core.XYZR___ge__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(XYZR self, XYZR o) -> bool
        __gt__(XYZR self, Particle d) -> bool
        """
        return _IMP_core.XYZR___gt__(self, *args)

    def __str__(self):
        """__str__(XYZR self) -> std::string"""
        return _IMP_core.XYZR___str__(self)

    def __repr__(self):
        """__repr__(XYZR self) -> std::string"""
        return _IMP_core.XYZR___repr__(self)

    __swig_destroy__ = _IMP_core.delete_XYZR
    __del__ = lambda self : None;
XYZR_swigregister = _IMP_core.XYZR_swigregister
XYZR_swigregister(XYZR)

def XYZR_decorate_particle(*args):
  """XYZR_decorate_particle(Particle p) -> XYZR"""
  return _IMP_core.XYZR_decorate_particle(*args)

def XYZR_setup_particle(*args):
  """
    setup_particle(Particle p) -> XYZR
    setup_particle(Particle p, IMP::Float radius) -> XYZR
    setup_particle(Particle p, Sphere3D s) -> XYZR
    XYZR_setup_particle(Model m, IMP::kernel::ParticleIndex pi, Sphere3D s) -> XYZR
    """
  return _IMP_core.XYZR_setup_particle(*args)

def XYZR_particle_is_instance(*args):
  """XYZR_particle_is_instance(Particle p) -> bool"""
  return _IMP_core.XYZR_particle_is_instance(*args)

def XYZR_get_radius_key():
  """XYZR_get_radius_key() -> FloatKey"""
  return _IMP_core.XYZR_get_radius_key()


def get_distance(*args):
  """
    get_distance(XYZ a, XYZ b) -> double
    get_distance(XYZR a, XYZR b) -> double
    """
  return _IMP_core.get_distance(*args)

def set_enclosing_sphere(*args):
  """
    set_enclosing_sphere(XYZR b, IMP::core::XYZs const & v, double slack=0)
    set_enclosing_sphere(XYZR b, IMP::core::XYZs const & v)
    """
  return _IMP_core.set_enclosing_sphere(*args)

def set_enclosing_radius(*args):
  """set_enclosing_radius(XYZR b, IMP::core::XYZs const & v)"""
  return _IMP_core.set_enclosing_radius(*args)

def get_enclosing_sphere(*args):
  """get_enclosing_sphere(IMP::core::XYZs const & v) -> Sphere3D"""
  return _IMP_core.get_enclosing_sphere(*args)

def create_xyzr_particles(*args):
  """
    create_xyzr_particles(Model m, unsigned int num, IMP::Float radius, IMP::Float box_side=10) -> IMP::core::XYZRs
    create_xyzr_particles(Model m, unsigned int num, IMP::Float radius) -> IMP::core::XYZRs
    """
  return _IMP_core.create_xyzr_particles(*args)

def get_sphere_d_geometry(*args):
  """get_sphere_d_geometry(XYZR d) -> Sphere3D"""
  return _IMP_core.get_sphere_d_geometry(*args)

def set_sphere_d_geometry(*args):
  """set_sphere_d_geometry(XYZR d, Sphere3D v)"""
  return _IMP_core.set_sphere_d_geometry(*args)
class XYZRGeometry(IMP.display.SingletonGeometry):
    """Proxy of C++ IMP::core::XYZRGeometry class"""
    __swig_setmethods__ = {}
    for _s in [IMP.display.SingletonGeometry]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, XYZRGeometry, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.display.SingletonGeometry]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, XYZRGeometry, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::XYZRGeometry self, Particle p) -> XYZRGeometry
        __init__(IMP::core::XYZRGeometry self, XYZR d) -> XYZRGeometry
        """
        this = _IMP_core.new_XYZRGeometry(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(XYZRGeometry self) -> VersionInfo"""
        return _IMP_core.XYZRGeometry_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_XYZRGeometry
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(XYZRGeometry self) -> std::string"""
        return _IMP_core.XYZRGeometry___str__(self)

    def __repr__(self):
        """__repr__(XYZRGeometry self) -> std::string"""
        return _IMP_core.XYZRGeometry___repr__(self)

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

XYZRGeometry_swigregister = _IMP_core.XYZRGeometry_swigregister
XYZRGeometry_swigregister(XYZRGeometry)

class XYZRsGeometry(IMP.display.SingletonsGeometry):
    """Proxy of C++ IMP::core::XYZRsGeometry class"""
    __swig_setmethods__ = {}
    for _s in [IMP.display.SingletonsGeometry]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, XYZRsGeometry, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.display.SingletonsGeometry]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, XYZRsGeometry, name)
    def __init__(self, *args): 
        """__init__(IMP::core::XYZRsGeometry self, SingletonContainer sc) -> XYZRsGeometry"""
        this = _IMP_core.new_XYZRsGeometry(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(XYZRsGeometry self) -> VersionInfo"""
        return _IMP_core.XYZRsGeometry_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_XYZRsGeometry
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(XYZRsGeometry self) -> std::string"""
        return _IMP_core.XYZRsGeometry___str__(self)

    def __repr__(self):
        """__repr__(XYZRsGeometry self) -> std::string"""
        return _IMP_core.XYZRsGeometry___repr__(self)

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

XYZRsGeometry_swigregister = _IMP_core.XYZRsGeometry_swigregister
XYZRsGeometry_swigregister(XYZRsGeometry)

class XYZDerivativeGeometry(IMP.display.SingletonGeometry):
    """Proxy of C++ IMP::core::XYZDerivativeGeometry class"""
    __swig_setmethods__ = {}
    for _s in [IMP.display.SingletonGeometry]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, XYZDerivativeGeometry, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.display.SingletonGeometry]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, XYZDerivativeGeometry, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::XYZDerivativeGeometry self, Particle p) -> XYZDerivativeGeometry
        __init__(IMP::core::XYZDerivativeGeometry self, XYZ d) -> XYZDerivativeGeometry
        """
        this = _IMP_core.new_XYZDerivativeGeometry(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(XYZDerivativeGeometry self) -> VersionInfo"""
        return _IMP_core.XYZDerivativeGeometry_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_XYZDerivativeGeometry
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(XYZDerivativeGeometry self) -> std::string"""
        return _IMP_core.XYZDerivativeGeometry___str__(self)

    def __repr__(self):
        """__repr__(XYZDerivativeGeometry self) -> std::string"""
        return _IMP_core.XYZDerivativeGeometry___repr__(self)

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

XYZDerivativeGeometry_swigregister = _IMP_core.XYZDerivativeGeometry_swigregister
XYZDerivativeGeometry_swigregister(XYZDerivativeGeometry)

class XYZDerivativesGeometry(IMP.display.SingletonsGeometry):
    """Proxy of C++ IMP::core::XYZDerivativesGeometry class"""
    __swig_setmethods__ = {}
    for _s in [IMP.display.SingletonsGeometry]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, XYZDerivativesGeometry, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.display.SingletonsGeometry]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, XYZDerivativesGeometry, name)
    def __init__(self, *args): 
        """__init__(IMP::core::XYZDerivativesGeometry self, SingletonContainer sc) -> XYZDerivativesGeometry"""
        this = _IMP_core.new_XYZDerivativesGeometry(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(XYZDerivativesGeometry self) -> VersionInfo"""
        return _IMP_core.XYZDerivativesGeometry_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_XYZDerivativesGeometry
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(XYZDerivativesGeometry self) -> std::string"""
        return _IMP_core.XYZDerivativesGeometry___str__(self)

    def __repr__(self):
        """__repr__(XYZDerivativesGeometry self) -> std::string"""
        return _IMP_core.XYZDerivativesGeometry___repr__(self)

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

XYZDerivativesGeometry_swigregister = _IMP_core.XYZDerivativesGeometry_swigregister
XYZDerivativesGeometry_swigregister(XYZDerivativesGeometry)

class EdgePairGeometry(IMP.display.PairGeometry):
    """Proxy of C++ IMP::core::EdgePairGeometry class"""
    __swig_setmethods__ = {}
    for _s in [IMP.display.PairGeometry]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, EdgePairGeometry, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.display.PairGeometry]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, EdgePairGeometry, name)
    def __init__(self, *args): 
        """__init__(IMP::core::EdgePairGeometry self, IMP::kernel::ParticlePair const & pp) -> EdgePairGeometry"""
        this = _IMP_core.new_EdgePairGeometry(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(EdgePairGeometry self) -> VersionInfo"""
        return _IMP_core.EdgePairGeometry_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_EdgePairGeometry
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(EdgePairGeometry self) -> std::string"""
        return _IMP_core.EdgePairGeometry___str__(self)

    def __repr__(self):
        """__repr__(EdgePairGeometry self) -> std::string"""
        return _IMP_core.EdgePairGeometry___repr__(self)

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

EdgePairGeometry_swigregister = _IMP_core.EdgePairGeometry_swigregister
EdgePairGeometry_swigregister(EdgePairGeometry)

class EdgePairsGeometry(IMP.display.PairsGeometry):
    """Proxy of C++ IMP::core::EdgePairsGeometry class"""
    __swig_setmethods__ = {}
    for _s in [IMP.display.PairsGeometry]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, EdgePairsGeometry, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.display.PairsGeometry]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, EdgePairsGeometry, name)
    def __init__(self, *args): 
        """__init__(IMP::core::EdgePairsGeometry self, PairContainer sc) -> EdgePairsGeometry"""
        this = _IMP_core.new_EdgePairsGeometry(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(EdgePairsGeometry self) -> VersionInfo"""
        return _IMP_core.EdgePairsGeometry_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_EdgePairsGeometry
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(EdgePairsGeometry self) -> std::string"""
        return _IMP_core.EdgePairsGeometry___str__(self)

    def __repr__(self):
        """__repr__(EdgePairsGeometry self) -> std::string"""
        return _IMP_core.EdgePairsGeometry___repr__(self)

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

EdgePairsGeometry_swigregister = _IMP_core.EdgePairsGeometry_swigregister
EdgePairsGeometry_swigregister(EdgePairsGeometry)

class AngleTripletScore(IMP.kernel.TripletScore):
    """Proxy of C++ IMP::core::AngleTripletScore class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.TripletScore]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AngleTripletScore, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.TripletScore]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AngleTripletScore, name)
    def __init__(self, *args): 
        """__init__(IMP::core::AngleTripletScore self, UnaryFunction f) -> AngleTripletScore"""
        this = _IMP_core.new_AngleTripletScore(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_create_current_decomposition(self, *args):
        """do_create_current_decomposition(AngleTripletScore self, Model m, IMP::kernel::ParticleIndexTriplet const & vt) -> IMP::kernel::Restraints"""
        return _IMP_core.AngleTripletScore_do_create_current_decomposition(self, *args)

    def get_version_info(self):
        """get_version_info(AngleTripletScore self) -> VersionInfo"""
        return _IMP_core.AngleTripletScore_get_version_info(self)

    def do_show(self, *args):
        """do_show(AngleTripletScore self, _ostream out)"""
        return _IMP_core.AngleTripletScore_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_AngleTripletScore
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(AngleTripletScore self) -> std::string"""
        return _IMP_core.AngleTripletScore___str__(self)

    def __repr__(self):
        """__repr__(AngleTripletScore self) -> std::string"""
        return _IMP_core.AngleTripletScore___repr__(self)

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

AngleTripletScore_swigregister = _IMP_core.AngleTripletScore_swigregister
AngleTripletScore_swigregister(AngleTripletScore)

class BallMover(MonteCarloMover):
    """Proxy of C++ IMP::core::BallMover class"""
    __swig_setmethods__ = {}
    for _s in [MonteCarloMover]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BallMover, name, value)
    __swig_getmethods__ = {}
    for _s in [MonteCarloMover]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, BallMover, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::BallMover self, Model m, IMP::kernel::ParticleIndex pi, IMP::kernel::FloatKeys const & vars, double radius) -> BallMover
        __init__(IMP::core::BallMover self, Model m, IMP::kernel::ParticleIndex pi, double radius) -> BallMover
        __init__(IMP::core::BallMover self, IMP::kernel::ParticlesTemp const & sc, IMP::kernel::FloatKeys const & vars, IMP::Float radius) -> BallMover
        __init__(IMP::core::BallMover self, IMP::kernel::ParticlesTemp const & sc, IMP::Float radius) -> BallMover
        """
        this = _IMP_core.new_BallMover(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_radius(self, *args):
        """set_radius(BallMover self, IMP::Float radius)"""
        return _IMP_core.BallMover_set_radius(self, *args)

    def get_radius(self):
        """get_radius(BallMover self) -> IMP::Float"""
        return _IMP_core.BallMover_get_radius(self)

    def get_version_info(self):
        """get_version_info(BallMover self) -> VersionInfo"""
        return _IMP_core.BallMover_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_BallMover
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(BallMover self) -> std::string"""
        return _IMP_core.BallMover___str__(self)

    def __repr__(self):
        """__repr__(BallMover self) -> std::string"""
        return _IMP_core.BallMover___repr__(self)

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

BallMover_swigregister = _IMP_core.BallMover_swigregister
BallMover_swigregister(BallMover)

class SerialMover(MonteCarloMover):
    """Proxy of C++ IMP::core::SerialMover class"""
    __swig_setmethods__ = {}
    for _s in [MonteCarloMover]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SerialMover, name, value)
    __swig_getmethods__ = {}
    for _s in [MonteCarloMover]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SerialMover, name)
    def __init__(self, *args): 
        """__init__(IMP::core::SerialMover self, IMP::core::MonteCarloMoversTemp const & mvs) -> SerialMover"""
        this = _IMP_core.new_SerialMover(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_movers(self):
        """get_movers(SerialMover self) -> IMP::core::MonteCarloMovers const &"""
        return _IMP_core.SerialMover_get_movers(self)

    def get_acceptance_probability(self, *args):
        """get_acceptance_probability(SerialMover self, int i) -> double"""
        return _IMP_core.SerialMover_get_acceptance_probability(self, *args)

    def reset_acceptance_probabilities(self):
        """reset_acceptance_probabilities(SerialMover self)"""
        return _IMP_core.SerialMover_reset_acceptance_probabilities(self)

    def get_number_of_movers(self):
        """get_number_of_movers(SerialMover self) -> unsigned int"""
        return _IMP_core.SerialMover_get_number_of_movers(self)

    def get_version_info(self):
        """get_version_info(SerialMover self) -> VersionInfo"""
        return _IMP_core.SerialMover_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_SerialMover
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(SerialMover self) -> std::string"""
        return _IMP_core.SerialMover___str__(self)

    def __repr__(self):
        """__repr__(SerialMover self) -> std::string"""
        return _IMP_core.SerialMover___repr__(self)

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

SerialMover_swigregister = _IMP_core.SerialMover_swigregister
SerialMover_swigregister(SerialMover)

class BoxSweepClosePairsFinder(ClosePairsFinder):
    """Proxy of C++ IMP::core::BoxSweepClosePairsFinder class"""
    __swig_setmethods__ = {}
    for _s in [ClosePairsFinder]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BoxSweepClosePairsFinder, name, value)
    __swig_getmethods__ = {}
    for _s in [ClosePairsFinder]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, BoxSweepClosePairsFinder, name)
    def __init__(self): 
        """__init__(IMP::core::BoxSweepClosePairsFinder self) -> BoxSweepClosePairsFinder"""
        this = _IMP_core.new_BoxSweepClosePairsFinder()
        try: self.this.append(this)
        except: self.this = this
    def get_close_pairs(self, *args):
        """
        get_close_pairs(BoxSweepClosePairsFinder self, IMP::kernel::ParticlesTemp const & pa) -> IMP::kernel::ParticlePairsTemp
        get_close_pairs(BoxSweepClosePairsFinder self, IMP::kernel::ParticlesTemp const & pa, IMP::kernel::ParticlesTemp const & pb) -> IMP::kernel::ParticlePairsTemp
        get_close_pairs(BoxSweepClosePairsFinder self, IMP::algebra::BoundingBox3Ds const & bbs) -> IMP::IntPairs
        get_close_pairs(BoxSweepClosePairsFinder self, IMP::algebra::BoundingBox3Ds const & bas, IMP::algebra::BoundingBox3Ds const & bbs) -> IMP::IntPairs
        """
        return _IMP_core.BoxSweepClosePairsFinder_get_close_pairs(self, *args)

    def get_version_info(self):
        """get_version_info(BoxSweepClosePairsFinder self) -> VersionInfo"""
        return _IMP_core.BoxSweepClosePairsFinder_get_version_info(self)

    def do_show(self, *args):
        """do_show(BoxSweepClosePairsFinder self, _ostream out)"""
        return _IMP_core.BoxSweepClosePairsFinder_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_BoxSweepClosePairsFinder
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(BoxSweepClosePairsFinder self) -> std::string"""
        return _IMP_core.BoxSweepClosePairsFinder___str__(self)

    def __repr__(self):
        """__repr__(BoxSweepClosePairsFinder self) -> std::string"""
        return _IMP_core.BoxSweepClosePairsFinder___repr__(self)

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

BoxSweepClosePairsFinder_swigregister = _IMP_core.BoxSweepClosePairsFinder_swigregister
BoxSweepClosePairsFinder_swigregister(BoxSweepClosePairsFinder)

class CentroidOfRefined(IMP.kernel.SingletonModifier):
    """Proxy of C++ IMP::core::CentroidOfRefined class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.SingletonModifier]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CentroidOfRefined, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.SingletonModifier]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CentroidOfRefined, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::CentroidOfRefined self, Refiner r, FloatKey weight=FloatKey(), IMP::kernel::FloatKeys ks=IMP::core::XYZ::get_xyz_keys()) -> CentroidOfRefined
        __init__(IMP::core::CentroidOfRefined self, Refiner r, FloatKey weight=FloatKey()) -> CentroidOfRefined
        __init__(IMP::core::CentroidOfRefined self, Refiner r) -> CentroidOfRefined
        """
        this = _IMP_core.new_CentroidOfRefined(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(CentroidOfRefined self) -> VersionInfo"""
        return _IMP_core.CentroidOfRefined_get_version_info(self)

    def do_show(self, *args):
        """do_show(CentroidOfRefined self, _ostream out)"""
        return _IMP_core.CentroidOfRefined_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_CentroidOfRefined
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(CentroidOfRefined self) -> std::string"""
        return _IMP_core.CentroidOfRefined___str__(self)

    def __repr__(self):
        """__repr__(CentroidOfRefined self) -> std::string"""
        return _IMP_core.CentroidOfRefined___repr__(self)

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

CentroidOfRefined_swigregister = _IMP_core.CentroidOfRefined_swigregister
CentroidOfRefined_swigregister(CentroidOfRefined)

class Centroid(XYZ):
    """Proxy of C++ IMP::core::Centroid class"""
    __swig_setmethods__ = {}
    for _s in [XYZ]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Centroid, name, value)
    __swig_getmethods__ = {}
    for _s in [XYZ]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Centroid, name)
    def get_constraint(self):
        """get_constraint(Centroid self) -> Constraint"""
        return _IMP_core.Centroid_get_constraint(self)

    def __init__(self, *args): 
        """
        __init__(IMP::core::Centroid self) -> Centroid
        __init__(IMP::core::Centroid self, Model m, IMP::kernel::ParticleIndex id) -> Centroid
        __init__(IMP::core::Centroid self, Particle p) -> Centroid
        """
        this = _IMP_core.new_Centroid(*args)
        try: self.this.append(this)
        except: self.this = this
    def decorate_particle(*args):
        """decorate_particle(Particle p) -> Centroid"""
        return _IMP_core.Centroid_decorate_particle(*args)

    if _newclass:decorate_particle = staticmethod(decorate_particle)
    __swig_getmethods__["decorate_particle"] = lambda x: decorate_particle
    def show(self, *args):
        """
        show(Centroid self, _ostream out=std::cout)
        show(Centroid self)
        """
        return _IMP_core.Centroid_show(self, *args)

    def setup_particle(*args):
        """
        setup_particle(Particle p, IMP::core::XYZs const & members) -> Centroid
        setup_particle(Particle p, Refiner ref) -> Centroid
        """
        return _IMP_core.Centroid_setup_particle(*args)

    if _newclass:setup_particle = staticmethod(setup_particle)
    __swig_getmethods__["setup_particle"] = lambda x: setup_particle
    __swig_destroy__ = _IMP_core.delete_Centroid
    __del__ = lambda self : None;
    def particle_is_instance(*args):
        """particle_is_instance(Particle p) -> bool"""
        return _IMP_core.Centroid_particle_is_instance(*args)

    if _newclass:particle_is_instance = staticmethod(particle_is_instance)
    __swig_getmethods__["particle_is_instance"] = lambda x: particle_is_instance
    def add_attribute(self, *args):
        """
        add_attribute(Centroid self, FloatKey k, IMP::Float v, bool opt)
        add_attribute(Centroid self, FloatKey a0, IMP::Float a1)
        add_attribute(Centroid self, IntKey a0, IMP::Int a1)
        add_attribute(Centroid self, StringKey a0, IMP::String a1)
        add_attribute(Centroid self, ParticleIndexKey a0, Particle a1)
        add_attribute(Centroid self, ObjectKey a0, IMP::Object * a1)
        """
        return _IMP_core.Centroid_add_attribute(self, *args)

    def get_value(self, *args):
        """
        get_value(Centroid self, FloatKey a0) -> IMP::Float
        get_value(Centroid self, IntKey a0) -> IMP::Int
        get_value(Centroid self, StringKey a0) -> IMP::String
        get_value(Centroid self, ParticleIndexKey a0) -> Particle
        get_value(Centroid self, ObjectKey a0) -> IMP::Object *
        """
        return _IMP_core.Centroid_get_value(self, *args)

    def set_value(self, *args):
        """
        set_value(Centroid self, FloatKey a0, IMP::Float a1)
        set_value(Centroid self, IntKey a0, IMP::Int a1)
        set_value(Centroid self, StringKey a0, IMP::String a1)
        set_value(Centroid self, ParticleIndexKey a0, Particle a1)
        set_value(Centroid self, ObjectKey a0, IMP::Object * a1)
        """
        return _IMP_core.Centroid_set_value(self, *args)

    def remove_attribute(self, *args):
        """
        remove_attribute(Centroid self, FloatKey a0)
        remove_attribute(Centroid self, IntKey a0)
        remove_attribute(Centroid self, StringKey a0)
        remove_attribute(Centroid self, ParticleIndexKey a0)
        remove_attribute(Centroid self, ObjectKey a0)
        """
        return _IMP_core.Centroid_remove_attribute(self, *args)

    def has_attribute(self, *args):
        """
        has_attribute(Centroid self, FloatKey a0) -> bool
        has_attribute(Centroid self, IntKey a0) -> bool
        has_attribute(Centroid self, StringKey a0) -> bool
        has_attribute(Centroid self, ParticleIndexKey a0) -> bool
        has_attribute(Centroid self, ObjectKey a0) -> bool
        """
        return _IMP_core.Centroid_has_attribute(self, *args)

    def get_derivative(self, *args):
        """get_derivative(Centroid self, FloatKey a0) -> double"""
        return _IMP_core.Centroid_get_derivative(self, *args)

    def get_name(self):
        """get_name(Centroid self) -> std::string"""
        return _IMP_core.Centroid_get_name(self)

    def clear_caches(self):
        """clear_caches(Centroid self)"""
        return _IMP_core.Centroid_clear_caches(self)

    def set_name(self, *args):
        """set_name(Centroid self, std::string a0)"""
        return _IMP_core.Centroid_set_name(self, *args)

    def set_check_level(self, *args):
        """set_check_level(Centroid self, IMP::base::CheckLevel a0)"""
        return _IMP_core.Centroid_set_check_level(self, *args)

    def add_to_derivative(self, *args):
        """add_to_derivative(Centroid self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_core.Centroid_add_to_derivative(self, *args)

    def set_is_optimized(self, *args):
        """set_is_optimized(Centroid self, FloatKey a0, bool a1)"""
        return _IMP_core.Centroid_set_is_optimized(self, *args)

    def get_is_optimized(self, *args):
        """get_is_optimized(Centroid self, FloatKey a0) -> bool"""
        return _IMP_core.Centroid_get_is_optimized(self, *args)

    def get_check_level(self):
        """get_check_level(Centroid self) -> IMP::base::CheckLevel"""
        return _IMP_core.Centroid_get_check_level(self)

    def __eq__(self, *args):
        """
        __eq__(Centroid self, Centroid o) -> bool
        __eq__(Centroid self, Particle d) -> bool
        """
        return _IMP_core.Centroid___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(Centroid self, Centroid o) -> bool
        __ne__(Centroid self, Particle d) -> bool
        """
        return _IMP_core.Centroid___ne__(self, *args)

    def __le__(self, *args):
        """
        __le__(Centroid self, Centroid o) -> bool
        __le__(Centroid self, Particle d) -> bool
        """
        return _IMP_core.Centroid___le__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(Centroid self, Centroid o) -> bool
        __lt__(Centroid self, Particle d) -> bool
        """
        return _IMP_core.Centroid___lt__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(Centroid self, Centroid o) -> bool
        __ge__(Centroid self, Particle d) -> bool
        """
        return _IMP_core.Centroid___ge__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(Centroid self, Centroid o) -> bool
        __gt__(Centroid self, Particle d) -> bool
        """
        return _IMP_core.Centroid___gt__(self, *args)

    def __str__(self):
        """__str__(Centroid self) -> std::string"""
        return _IMP_core.Centroid___str__(self)

    def __repr__(self):
        """__repr__(Centroid self) -> std::string"""
        return _IMP_core.Centroid___repr__(self)

Centroid_swigregister = _IMP_core.Centroid_swigregister
Centroid_swigregister(Centroid)

def Centroid_decorate_particle(*args):
  """Centroid_decorate_particle(Particle p) -> Centroid"""
  return _IMP_core.Centroid_decorate_particle(*args)

def Centroid_setup_particle(*args):
  """
    setup_particle(Particle p, IMP::core::XYZs const & members) -> Centroid
    Centroid_setup_particle(Particle p, Refiner ref) -> Centroid
    """
  return _IMP_core.Centroid_setup_particle(*args)

def Centroid_particle_is_instance(*args):
  """Centroid_particle_is_instance(Particle p) -> bool"""
  return _IMP_core.Centroid_particle_is_instance(*args)

class ChecksScoreState(IMP.kernel.ScoreState):
    """Proxy of C++ IMP::core::ChecksScoreState class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.ScoreState]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ChecksScoreState, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.ScoreState]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ChecksScoreState, name)
    def __init__(self, *args): 
        """__init__(IMP::core::ChecksScoreState self, double probability) -> ChecksScoreState"""
        this = _IMP_core.new_ChecksScoreState(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_number_of_checked(self):
        """get_number_of_checked(ChecksScoreState self) -> unsigned int"""
        return _IMP_core.ChecksScoreState_get_number_of_checked(self)

    def get_input_particles(self):
        """get_input_particles(ChecksScoreState self) -> IMP::kernel::ParticlesTemp"""
        return _IMP_core.ChecksScoreState_get_input_particles(self)

    def get_input_containers(self):
        """get_input_containers(ChecksScoreState self) -> IMP::kernel::ContainersTemp"""
        return _IMP_core.ChecksScoreState_get_input_containers(self)

    def do_get_inputs(self):
        """do_get_inputs(ChecksScoreState self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_core.ChecksScoreState_do_get_inputs(self)

    def get_output_particles(self):
        """get_output_particles(ChecksScoreState self) -> IMP::kernel::ParticlesTemp"""
        return _IMP_core.ChecksScoreState_get_output_particles(self)

    def get_output_containers(self):
        """get_output_containers(ChecksScoreState self) -> IMP::kernel::ContainersTemp"""
        return _IMP_core.ChecksScoreState_get_output_containers(self)

    def do_get_outputs(self):
        """do_get_outputs(ChecksScoreState self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_core.ChecksScoreState_do_get_outputs(self)

    def get_version_info(self):
        """get_version_info(ChecksScoreState self) -> VersionInfo"""
        return _IMP_core.ChecksScoreState_get_version_info(self)

    def do_show(self, *args):
        """do_show(ChecksScoreState self, _ostream out)"""
        return _IMP_core.ChecksScoreState_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_ChecksScoreState
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(ChecksScoreState self) -> std::string"""
        return _IMP_core.ChecksScoreState___str__(self)

    def __repr__(self):
        """__repr__(ChecksScoreState self) -> std::string"""
        return _IMP_core.ChecksScoreState___repr__(self)

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

ChecksScoreState_swigregister = _IMP_core.ChecksScoreState_swigregister
ChecksScoreState_swigregister(ChecksScoreState)

class ChildrenRefiner(IMP.kernel.Refiner):
    """Proxy of C++ IMP::core::ChildrenRefiner class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Refiner]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ChildrenRefiner, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Refiner]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ChildrenRefiner, name)
    def __init__(self, *args): 
        """__init__(IMP::core::ChildrenRefiner self, HierarchyTraits tr) -> ChildrenRefiner"""
        this = _IMP_core.new_ChildrenRefiner(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_refined(self, *args):
        """
        get_refined(ChildrenRefiner self, Particle arg2) -> IMP::kernel::ParticlesTemp const
        get_refined(ChildrenRefiner self, Particle arg2, unsigned int arg3) -> Particle
        """
        return _IMP_core.ChildrenRefiner_get_refined(self, *args)

    def get_input_particles(self, *args):
        """get_input_particles(ChildrenRefiner self, Particle arg2) -> IMP::kernel::ParticlesTemp"""
        return _IMP_core.ChildrenRefiner_get_input_particles(self, *args)

    def get_input_containers(self, *args):
        """get_input_containers(ChildrenRefiner self, Particle arg2) -> IMP::kernel::ContainersTemp"""
        return _IMP_core.ChildrenRefiner_get_input_containers(self, *args)

    def get_version_info(self):
        """get_version_info(ChildrenRefiner self) -> VersionInfo"""
        return _IMP_core.ChildrenRefiner_get_version_info(self)

    def do_show(self, *args):
        """do_show(ChildrenRefiner self, _ostream out)"""
        return _IMP_core.ChildrenRefiner_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_ChildrenRefiner
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(ChildrenRefiner self) -> std::string"""
        return _IMP_core.ChildrenRefiner___str__(self)

    def __repr__(self):
        """__repr__(ChildrenRefiner self) -> std::string"""
        return _IMP_core.ChildrenRefiner___repr__(self)

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

ChildrenRefiner_swigregister = _IMP_core.ChildrenRefiner_swigregister
ChildrenRefiner_swigregister(ChildrenRefiner)

class ClosedCubicSpline(IMP.kernel.UnaryFunction):
    """Proxy of C++ IMP::core::ClosedCubicSpline class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.UnaryFunction]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ClosedCubicSpline, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.UnaryFunction]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ClosedCubicSpline, name)
    def __init__(self, *args): 
        """__init__(IMP::core::ClosedCubicSpline self, IMP::Floats const & values, double minrange, double spacing) -> ClosedCubicSpline"""
        this = _IMP_core.new_ClosedCubicSpline(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(ClosedCubicSpline self) -> VersionInfo"""
        return _IMP_core.ClosedCubicSpline_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_ClosedCubicSpline
    __del__ = lambda self : None;
    def do_show(self, *args):
        """do_show(ClosedCubicSpline self, _ostream out)"""
        return _IMP_core.ClosedCubicSpline_do_show(self, *args)

    def __str__(self):
        """__str__(ClosedCubicSpline self) -> std::string"""
        return _IMP_core.ClosedCubicSpline___str__(self)

    def __repr__(self):
        """__repr__(ClosedCubicSpline self) -> std::string"""
        return _IMP_core.ClosedCubicSpline___repr__(self)

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

ClosedCubicSpline_swigregister = _IMP_core.ClosedCubicSpline_swigregister
ClosedCubicSpline_swigregister(ClosedCubicSpline)

class KClosePairsPairScore(IMP.kernel.PairScore):
    """Proxy of C++ IMP::core::KClosePairsPairScore class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.PairScore]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, KClosePairsPairScore, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.PairScore]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, KClosePairsPairScore, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::KClosePairsPairScore self, PairScore f, Refiner r, int k=1) -> KClosePairsPairScore
        __init__(IMP::core::KClosePairsPairScore self, PairScore f, Refiner r) -> KClosePairsPairScore
        """
        this = _IMP_core.new_KClosePairsPairScore(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_close_pairs(self, *args):
        """get_close_pairs(KClosePairsPairScore self, IMP::kernel::ParticlePair const & pp) -> IMP::kernel::ParticlePairsTemp"""
        return _IMP_core.KClosePairsPairScore_get_close_pairs(self, *args)

    def create_current_decomposition(self, *args):
        """create_current_decomposition(KClosePairsPairScore self, Model m, IMP::kernel::ParticleIndexPair const & vt) -> IMP::kernel::Restraints"""
        return _IMP_core.KClosePairsPairScore_create_current_decomposition(self, *args)

    def get_version_info(self):
        """get_version_info(KClosePairsPairScore self) -> VersionInfo"""
        return _IMP_core.KClosePairsPairScore_get_version_info(self)

    def do_show(self, *args):
        """do_show(KClosePairsPairScore self, _ostream out)"""
        return _IMP_core.KClosePairsPairScore_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_KClosePairsPairScore
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(KClosePairsPairScore self) -> std::string"""
        return _IMP_core.KClosePairsPairScore___str__(self)

    def __repr__(self):
        """__repr__(KClosePairsPairScore self) -> std::string"""
        return _IMP_core.KClosePairsPairScore___repr__(self)

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

KClosePairsPairScore_swigregister = _IMP_core.KClosePairsPairScore_swigregister
KClosePairsPairScore_swigregister(KClosePairsPairScore)

class ClosePairsPairScore(IMP.kernel.PairScore):
    """Proxy of C++ IMP::core::ClosePairsPairScore class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.PairScore]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ClosePairsPairScore, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.PairScore]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ClosePairsPairScore, name)
    def __init__(self, *args): 
        """__init__(IMP::core::ClosePairsPairScore self, PairScore f, Refiner r, IMP::Float max_distance) -> ClosePairsPairScore"""
        this = _IMP_core.new_ClosePairsPairScore(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_close_pairs(self, *args):
        """get_close_pairs(ClosePairsPairScore self, IMP::kernel::ParticlePair const & pp) -> IMP::kernel::ParticlePairsTemp"""
        return _IMP_core.ClosePairsPairScore_get_close_pairs(self, *args)

    def create_current_decomposition(self, *args):
        """create_current_decomposition(ClosePairsPairScore self, Model m, IMP::kernel::ParticleIndexPair const & vt) -> IMP::kernel::Restraints"""
        return _IMP_core.ClosePairsPairScore_create_current_decomposition(self, *args)

    def get_version_info(self):
        """get_version_info(ClosePairsPairScore self) -> VersionInfo"""
        return _IMP_core.ClosePairsPairScore_get_version_info(self)

    def do_show(self, *args):
        """do_show(ClosePairsPairScore self, _ostream out)"""
        return _IMP_core.ClosePairsPairScore_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_ClosePairsPairScore
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(ClosePairsPairScore self) -> std::string"""
        return _IMP_core.ClosePairsPairScore___str__(self)

    def __repr__(self):
        """__repr__(ClosePairsPairScore self) -> std::string"""
        return _IMP_core.ClosePairsPairScore___repr__(self)

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

ClosePairsPairScore_swigregister = _IMP_core.ClosePairsPairScore_swigregister
ClosePairsPairScore_swigregister(ClosePairsPairScore)

class ConjugateGradients(IMP.kernel.Optimizer):
    """Proxy of C++ IMP::core::ConjugateGradients class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Optimizer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConjugateGradients, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Optimizer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ConjugateGradients, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::ConjugateGradients self, Model m=nullptr) -> ConjugateGradients
        __init__(IMP::core::ConjugateGradients self) -> ConjugateGradients
        """
        this = _IMP_core.new_ConjugateGradients(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_gradient_threshold(self, *args):
        """set_gradient_threshold(ConjugateGradients self, IMP::Float t)"""
        return _IMP_core.ConjugateGradients_set_gradient_threshold(self, *args)

    def set_threshold(self, *args):
        """set_threshold(ConjugateGradients self, IMP::Float t)"""
        return _IMP_core.ConjugateGradients_set_threshold(self, *args)

    def set_max_change(self, *args):
        """set_max_change(ConjugateGradients self, IMP::Float t)"""
        return _IMP_core.ConjugateGradients_set_max_change(self, *args)

    def do_optimize(self, *args):
        """do_optimize(ConjugateGradients self, unsigned int max_steps) -> IMP::Float"""
        return _IMP_core.ConjugateGradients_do_optimize(self, *args)

    def get_version_info(self):
        """get_version_info(ConjugateGradients self) -> VersionInfo"""
        return _IMP_core.ConjugateGradients_get_version_info(self)

    def do_show(self, *args):
        """do_show(ConjugateGradients self, _ostream out)"""
        return _IMP_core.ConjugateGradients_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_ConjugateGradients
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(ConjugateGradients self) -> std::string"""
        return _IMP_core.ConjugateGradients___str__(self)

    def __repr__(self):
        """__repr__(ConjugateGradients self) -> std::string"""
        return _IMP_core.ConjugateGradients___repr__(self)

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

ConjugateGradients_swigregister = _IMP_core.ConjugateGradients_swigregister
ConjugateGradients_swigregister(ConjugateGradients)

class ConnectivityRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::core::ConnectivityRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConnectivityRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ConnectivityRestraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::ConnectivityRestraint self, PairScore ps, SingletonContainer sc) -> ConnectivityRestraint
        __init__(IMP::core::ConnectivityRestraint self, PairScore ps) -> ConnectivityRestraint
        """
        this = _IMP_core.new_ConnectivityRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def add_particle(self, *args):
        """add_particle(ConnectivityRestraint self, Particle p)"""
        return _IMP_core.ConnectivityRestraint_add_particle(self, *args)

    def add_particles(self, *args):
        """add_particles(ConnectivityRestraint self, IMP::kernel::ParticlesTemp const & ps)"""
        return _IMP_core.ConnectivityRestraint_add_particles(self, *args)

    def set_particles(self, *args):
        """set_particles(ConnectivityRestraint self, IMP::kernel::ParticlesTemp const & ps)"""
        return _IMP_core.ConnectivityRestraint_set_particles(self, *args)

    def get_connected_pairs(self):
        """get_connected_pairs(ConnectivityRestraint self) -> IMP::kernel::ParticlePairsTemp"""
        return _IMP_core.ConnectivityRestraint_get_connected_pairs(self)

    def get_pair_score(self):
        """get_pair_score(ConnectivityRestraint self) -> PairScore"""
        return _IMP_core.ConnectivityRestraint_get_pair_score(self)

    def do_create_current_decomposition(self):
        """do_create_current_decomposition(ConnectivityRestraint self) -> IMP::kernel::Restraints"""
        return _IMP_core.ConnectivityRestraint_do_create_current_decomposition(self)

    def do_get_inputs(self):
        """do_get_inputs(ConnectivityRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_core.ConnectivityRestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(ConnectivityRestraint self) -> VersionInfo"""
        return _IMP_core.ConnectivityRestraint_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_ConnectivityRestraint
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(ConnectivityRestraint self) -> std::string"""
        return _IMP_core.ConnectivityRestraint___str__(self)

    def __repr__(self):
        """__repr__(ConnectivityRestraint self) -> std::string"""
        return _IMP_core.ConnectivityRestraint___repr__(self)

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

ConnectivityRestraint_swigregister = _IMP_core.ConnectivityRestraint_swigregister
ConnectivityRestraint_swigregister(ConnectivityRestraint)

class ConstantRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::core::ConstantRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConstantRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ConstantRestraint, name)
    def __init__(self, *args): 
        """__init__(IMP::core::ConstantRestraint self, IMP::Float v) -> ConstantRestraint"""
        this = _IMP_core.new_ConstantRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_input_particles(self):
        """get_input_particles(ConstantRestraint self) -> IMP::kernel::ParticlesTemp"""
        return _IMP_core.ConstantRestraint_get_input_particles(self)

    def get_input_containers(self):
        """get_input_containers(ConstantRestraint self) -> IMP::kernel::ContainersTemp"""
        return _IMP_core.ConstantRestraint_get_input_containers(self)

    def do_get_inputs(self):
        """do_get_inputs(ConstantRestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_core.ConstantRestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(ConstantRestraint self) -> VersionInfo"""
        return _IMP_core.ConstantRestraint_get_version_info(self)

    def do_show(self, *args):
        """do_show(ConstantRestraint self, _ostream out)"""
        return _IMP_core.ConstantRestraint_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_ConstantRestraint
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(ConstantRestraint self) -> std::string"""
        return _IMP_core.ConstantRestraint___str__(self)

    def __repr__(self):
        """__repr__(ConstantRestraint self) -> std::string"""
        return _IMP_core.ConstantRestraint___repr__(self)

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

ConstantRestraint_swigregister = _IMP_core.ConstantRestraint_swigregister
ConstantRestraint_swigregister(ConstantRestraint)

class Cosine(IMP.kernel.UnaryFunction):
    """Proxy of C++ IMP::core::Cosine class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.UnaryFunction]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Cosine, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.UnaryFunction]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Cosine, name)
    def __init__(self, *args): 
        """__init__(IMP::core::Cosine self, IMP::Float force_constant, int periodicity, IMP::Float phase) -> Cosine"""
        this = _IMP_core.new_Cosine(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(Cosine self) -> VersionInfo"""
        return _IMP_core.Cosine_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_Cosine
    __del__ = lambda self : None;
    def do_show(self, *args):
        """do_show(Cosine self, _ostream out)"""
        return _IMP_core.Cosine_do_show(self, *args)

    def __str__(self):
        """__str__(Cosine self) -> std::string"""
        return _IMP_core.Cosine___str__(self)

    def __repr__(self):
        """__repr__(Cosine self) -> std::string"""
        return _IMP_core.Cosine___repr__(self)

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

Cosine_swigregister = _IMP_core.Cosine_swigregister
Cosine_swigregister(Cosine)

class CoverRefined(IMP.kernel.SingletonModifier):
    """Proxy of C++ IMP::core::CoverRefined class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.SingletonModifier]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CoverRefined, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.SingletonModifier]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CoverRefined, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::CoverRefined self, Refiner ref, IMP::Float slack=0) -> CoverRefined
        __init__(IMP::core::CoverRefined self, Refiner ref) -> CoverRefined
        """
        this = _IMP_core.new_CoverRefined(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_slack(self, *args):
        """set_slack(CoverRefined self, IMP::Float slack)"""
        return _IMP_core.CoverRefined_set_slack(self, *args)

    def get_version_info(self):
        """get_version_info(CoverRefined self) -> VersionInfo"""
        return _IMP_core.CoverRefined_get_version_info(self)

    def do_show(self, *args):
        """do_show(CoverRefined self, _ostream out)"""
        return _IMP_core.CoverRefined_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_CoverRefined
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(CoverRefined self) -> std::string"""
        return _IMP_core.CoverRefined___str__(self)

    def __repr__(self):
        """__repr__(CoverRefined self) -> std::string"""
        return _IMP_core.CoverRefined___repr__(self)

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

CoverRefined_swigregister = _IMP_core.CoverRefined_swigregister
CoverRefined_swigregister(CoverRefined)

class Cover(XYZR):
    """Proxy of C++ IMP::core::Cover class"""
    __swig_setmethods__ = {}
    for _s in [XYZR]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Cover, name, value)
    __swig_getmethods__ = {}
    for _s in [XYZR]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Cover, name)
    def get_constraint(self):
        """get_constraint(Cover self) -> Constraint"""
        return _IMP_core.Cover_get_constraint(self)

    def __init__(self, *args): 
        """
        __init__(IMP::core::Cover self) -> Cover
        __init__(IMP::core::Cover self, Model m, IMP::kernel::ParticleIndex id) -> Cover
        __init__(IMP::core::Cover self, Particle p) -> Cover
        """
        this = _IMP_core.new_Cover(*args)
        try: self.this.append(this)
        except: self.this = this
    def decorate_particle(*args):
        """decorate_particle(Particle p) -> Cover"""
        return _IMP_core.Cover_decorate_particle(*args)

    if _newclass:decorate_particle = staticmethod(decorate_particle)
    __swig_getmethods__["decorate_particle"] = lambda x: decorate_particle
    def show(self, *args):
        """
        show(Cover self, _ostream out=std::cout)
        show(Cover self)
        """
        return _IMP_core.Cover_show(self, *args)

    def setup_particle(*args):
        """
        setup_particle(Particle p, IMP::core::XYZs const & members) -> Cover
        setup_particle(Particle p, Refiner ref) -> Cover
        """
        return _IMP_core.Cover_setup_particle(*args)

    if _newclass:setup_particle = staticmethod(setup_particle)
    __swig_getmethods__["setup_particle"] = lambda x: setup_particle
    __swig_destroy__ = _IMP_core.delete_Cover
    __del__ = lambda self : None;
    def particle_is_instance(*args):
        """particle_is_instance(Particle p) -> bool"""
        return _IMP_core.Cover_particle_is_instance(*args)

    if _newclass:particle_is_instance = staticmethod(particle_is_instance)
    __swig_getmethods__["particle_is_instance"] = lambda x: particle_is_instance
    def add_attribute(self, *args):
        """
        add_attribute(Cover self, FloatKey k, IMP::Float v, bool opt)
        add_attribute(Cover self, FloatKey a0, IMP::Float a1)
        add_attribute(Cover self, IntKey a0, IMP::Int a1)
        add_attribute(Cover self, StringKey a0, IMP::String a1)
        add_attribute(Cover self, ParticleIndexKey a0, Particle a1)
        add_attribute(Cover self, ObjectKey a0, IMP::Object * a1)
        """
        return _IMP_core.Cover_add_attribute(self, *args)

    def get_value(self, *args):
        """
        get_value(Cover self, FloatKey a0) -> IMP::Float
        get_value(Cover self, IntKey a0) -> IMP::Int
        get_value(Cover self, StringKey a0) -> IMP::String
        get_value(Cover self, ParticleIndexKey a0) -> Particle
        get_value(Cover self, ObjectKey a0) -> IMP::Object *
        """
        return _IMP_core.Cover_get_value(self, *args)

    def set_value(self, *args):
        """
        set_value(Cover self, FloatKey a0, IMP::Float a1)
        set_value(Cover self, IntKey a0, IMP::Int a1)
        set_value(Cover self, StringKey a0, IMP::String a1)
        set_value(Cover self, ParticleIndexKey a0, Particle a1)
        set_value(Cover self, ObjectKey a0, IMP::Object * a1)
        """
        return _IMP_core.Cover_set_value(self, *args)

    def remove_attribute(self, *args):
        """
        remove_attribute(Cover self, FloatKey a0)
        remove_attribute(Cover self, IntKey a0)
        remove_attribute(Cover self, StringKey a0)
        remove_attribute(Cover self, ParticleIndexKey a0)
        remove_attribute(Cover self, ObjectKey a0)
        """
        return _IMP_core.Cover_remove_attribute(self, *args)

    def has_attribute(self, *args):
        """
        has_attribute(Cover self, FloatKey a0) -> bool
        has_attribute(Cover self, IntKey a0) -> bool
        has_attribute(Cover self, StringKey a0) -> bool
        has_attribute(Cover self, ParticleIndexKey a0) -> bool
        has_attribute(Cover self, ObjectKey a0) -> bool
        """
        return _IMP_core.Cover_has_attribute(self, *args)

    def get_derivative(self, *args):
        """get_derivative(Cover self, FloatKey a0) -> double"""
        return _IMP_core.Cover_get_derivative(self, *args)

    def get_name(self):
        """get_name(Cover self) -> std::string"""
        return _IMP_core.Cover_get_name(self)

    def clear_caches(self):
        """clear_caches(Cover self)"""
        return _IMP_core.Cover_clear_caches(self)

    def set_name(self, *args):
        """set_name(Cover self, std::string a0)"""
        return _IMP_core.Cover_set_name(self, *args)

    def set_check_level(self, *args):
        """set_check_level(Cover self, IMP::base::CheckLevel a0)"""
        return _IMP_core.Cover_set_check_level(self, *args)

    def add_to_derivative(self, *args):
        """add_to_derivative(Cover self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_core.Cover_add_to_derivative(self, *args)

    def set_is_optimized(self, *args):
        """set_is_optimized(Cover self, FloatKey a0, bool a1)"""
        return _IMP_core.Cover_set_is_optimized(self, *args)

    def get_is_optimized(self, *args):
        """get_is_optimized(Cover self, FloatKey a0) -> bool"""
        return _IMP_core.Cover_get_is_optimized(self, *args)

    def get_check_level(self):
        """get_check_level(Cover self) -> IMP::base::CheckLevel"""
        return _IMP_core.Cover_get_check_level(self)

    def __eq__(self, *args):
        """
        __eq__(Cover self, Cover o) -> bool
        __eq__(Cover self, Particle d) -> bool
        """
        return _IMP_core.Cover___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(Cover self, Cover o) -> bool
        __ne__(Cover self, Particle d) -> bool
        """
        return _IMP_core.Cover___ne__(self, *args)

    def __le__(self, *args):
        """
        __le__(Cover self, Cover o) -> bool
        __le__(Cover self, Particle d) -> bool
        """
        return _IMP_core.Cover___le__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(Cover self, Cover o) -> bool
        __lt__(Cover self, Particle d) -> bool
        """
        return _IMP_core.Cover___lt__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(Cover self, Cover o) -> bool
        __ge__(Cover self, Particle d) -> bool
        """
        return _IMP_core.Cover___ge__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(Cover self, Cover o) -> bool
        __gt__(Cover self, Particle d) -> bool
        """
        return _IMP_core.Cover___gt__(self, *args)

    def __str__(self):
        """__str__(Cover self) -> std::string"""
        return _IMP_core.Cover___str__(self)

    def __repr__(self):
        """__repr__(Cover self) -> std::string"""
        return _IMP_core.Cover___repr__(self)

Cover_swigregister = _IMP_core.Cover_swigregister
Cover_swigregister(Cover)

def Cover_decorate_particle(*args):
  """Cover_decorate_particle(Particle p) -> Cover"""
  return _IMP_core.Cover_decorate_particle(*args)

def Cover_setup_particle(*args):
  """
    setup_particle(Particle p, IMP::core::XYZs const & members) -> Cover
    Cover_setup_particle(Particle p, Refiner ref) -> Cover
    """
  return _IMP_core.Cover_setup_particle(*args)

def Cover_particle_is_instance(*args):
  """Cover_particle_is_instance(Particle p) -> bool"""
  return _IMP_core.Cover_particle_is_instance(*args)

class DerivativesFromRefined(IMP.kernel.SingletonModifier):
    """Proxy of C++ IMP::core::DerivativesFromRefined class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.SingletonModifier]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DerivativesFromRefined, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.SingletonModifier]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DerivativesFromRefined, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::DerivativesFromRefined self, Refiner r, IMP::kernel::FloatKeys ks=IMP::core::XYZ::get_xyz_keys()) -> DerivativesFromRefined
        __init__(IMP::core::DerivativesFromRefined self, Refiner r) -> DerivativesFromRefined
        """
        this = _IMP_core.new_DerivativesFromRefined(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(DerivativesFromRefined self) -> VersionInfo"""
        return _IMP_core.DerivativesFromRefined_get_version_info(self)

    def do_show(self, *args):
        """do_show(DerivativesFromRefined self, _ostream out)"""
        return _IMP_core.DerivativesFromRefined_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_DerivativesFromRefined
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(DerivativesFromRefined self) -> std::string"""
        return _IMP_core.DerivativesFromRefined___str__(self)

    def __repr__(self):
        """__repr__(DerivativesFromRefined self) -> std::string"""
        return _IMP_core.DerivativesFromRefined___repr__(self)

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

DerivativesFromRefined_swigregister = _IMP_core.DerivativesFromRefined_swigregister
DerivativesFromRefined_swigregister(DerivativesFromRefined)

class DerivativesToRefined(IMP.kernel.SingletonModifier):
    """Proxy of C++ IMP::core::DerivativesToRefined class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.SingletonModifier]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DerivativesToRefined, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.SingletonModifier]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DerivativesToRefined, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::DerivativesToRefined self, Refiner r, IMP::kernel::FloatKeys ks=IMP::core::XYZ::get_xyz_keys()) -> DerivativesToRefined
        __init__(IMP::core::DerivativesToRefined self, Refiner r) -> DerivativesToRefined
        """
        this = _IMP_core.new_DerivativesToRefined(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(DerivativesToRefined self) -> VersionInfo"""
        return _IMP_core.DerivativesToRefined_get_version_info(self)

    def do_show(self, *args):
        """do_show(DerivativesToRefined self, _ostream out)"""
        return _IMP_core.DerivativesToRefined_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_DerivativesToRefined
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(DerivativesToRefined self) -> std::string"""
        return _IMP_core.DerivativesToRefined___str__(self)

    def __repr__(self):
        """__repr__(DerivativesToRefined self) -> std::string"""
        return _IMP_core.DerivativesToRefined___repr__(self)

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

DerivativesToRefined_swigregister = _IMP_core.DerivativesToRefined_swigregister
DerivativesToRefined_swigregister(DerivativesToRefined)

class DiameterRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::core::DiameterRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DiameterRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DiameterRestraint, name)
    def __init__(self, *args): 
        """__init__(IMP::core::DiameterRestraint self, UnaryFunction f, SingletonContainer sc, IMP::Float diameter) -> DiameterRestraint"""
        this = _IMP_core.new_DiameterRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_input_particles(self):
        """get_input_particles(DiameterRestraint self) -> IMP::kernel::ParticlesTemp"""
        return _IMP_core.DiameterRestraint_get_input_particles(self)

    def get_input_containers(self):
        """get_input_containers(DiameterRestraint self) -> IMP::kernel::ContainersTemp"""
        return _IMP_core.DiameterRestraint_get_input_containers(self)

    def do_get_inputs(self):
        """do_get_inputs(DiameterRestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_core.DiameterRestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(DiameterRestraint self) -> VersionInfo"""
        return _IMP_core.DiameterRestraint_get_version_info(self)

    def do_show(self, *args):
        """do_show(DiameterRestraint self, _ostream out)"""
        return _IMP_core.DiameterRestraint_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_DiameterRestraint
    __del__ = lambda self : None;
    def do_create_decomposition(self):
        """do_create_decomposition(DiameterRestraint self) -> IMP::kernel::Restraints"""
        return _IMP_core.DiameterRestraint_do_create_decomposition(self)

    def do_create_current_decomposition(self):
        """do_create_current_decomposition(DiameterRestraint self) -> IMP::kernel::Restraints"""
        return _IMP_core.DiameterRestraint_do_create_current_decomposition(self)

    def __str__(self):
        """__str__(DiameterRestraint self) -> std::string"""
        return _IMP_core.DiameterRestraint___str__(self)

    def __repr__(self):
        """__repr__(DiameterRestraint self) -> std::string"""
        return _IMP_core.DiameterRestraint___repr__(self)

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

DiameterRestraint_swigregister = _IMP_core.DiameterRestraint_swigregister
DiameterRestraint_swigregister(DiameterRestraint)

class Transform(IMP.kernel.SingletonModifier):
    """Proxy of C++ IMP::core::Transform class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.SingletonModifier]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Transform, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.SingletonModifier]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Transform, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::Transform self, Transformation3D t, bool ignore_non_xyz=False) -> Transform
        __init__(IMP::core::Transform self, Transformation3D t) -> Transform
        """
        this = _IMP_core.new_Transform(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_input_particles(self, *args):
        """get_input_particles(Transform self, Particle arg2) -> IMP::kernel::ParticlesTemp"""
        return _IMP_core.Transform_get_input_particles(self, *args)

    def get_input_containers(self, *args):
        """get_input_containers(Transform self, Particle arg2) -> IMP::kernel::ContainersTemp"""
        return _IMP_core.Transform_get_input_containers(self, *args)

    def get_output_particles(self, *args):
        """get_output_particles(Transform self, Particle arg2) -> IMP::kernel::ParticlesTemp"""
        return _IMP_core.Transform_get_output_particles(self, *args)

    def get_output_containers(self, *args):
        """get_output_containers(Transform self, Particle arg2) -> IMP::kernel::ContainersTemp"""
        return _IMP_core.Transform_get_output_containers(self, *args)

    def get_version_info(self):
        """get_version_info(Transform self) -> VersionInfo"""
        return _IMP_core.Transform_get_version_info(self)

    def do_show(self, *args):
        """do_show(Transform self, _ostream out)"""
        return _IMP_core.Transform_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_Transform
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(Transform self) -> std::string"""
        return _IMP_core.Transform___str__(self)

    def __repr__(self):
        """__repr__(Transform self) -> std::string"""
        return _IMP_core.Transform___repr__(self)

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

Transform_swigregister = _IMP_core.Transform_swigregister
Transform_swigregister(Transform)

class Reference(IMP.kernel.Decorator):
    """Proxy of C++ IMP::core::Reference class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Decorator]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Reference, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Decorator]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Reference, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::Reference self) -> Reference
        __init__(IMP::core::Reference self, Model m, IMP::kernel::ParticleIndex id) -> Reference
        __init__(IMP::core::Reference self, Particle p) -> Reference
        """
        this = _IMP_core.new_Reference(*args)
        try: self.this.append(this)
        except: self.this = this
    def decorate_particle(*args):
        """decorate_particle(Particle p) -> Reference"""
        return _IMP_core.Reference_decorate_particle(*args)

    if _newclass:decorate_particle = staticmethod(decorate_particle)
    __swig_getmethods__["decorate_particle"] = lambda x: decorate_particle
    def show(self, *args):
        """
        show(Reference self, _ostream out=std::cout)
        show(Reference self)
        """
        return _IMP_core.Reference_show(self, *args)

    def setup_particle(*args):
        """setup_particle(Particle p, Particle ref) -> Reference"""
        return _IMP_core.Reference_setup_particle(*args)

    if _newclass:setup_particle = staticmethod(setup_particle)
    __swig_getmethods__["setup_particle"] = lambda x: setup_particle
    def get_reference_particle(self):
        """get_reference_particle(Reference self) -> Particle"""
        return _IMP_core.Reference_get_reference_particle(self)

    def particle_is_instance(*args):
        """particle_is_instance(Particle p) -> bool"""
        return _IMP_core.Reference_particle_is_instance(*args)

    if _newclass:particle_is_instance = staticmethod(particle_is_instance)
    __swig_getmethods__["particle_is_instance"] = lambda x: particle_is_instance
    def get_reference_key():
        """get_reference_key() -> ParticleIndexKey"""
        return _IMP_core.Reference_get_reference_key()

    if _newclass:get_reference_key = staticmethod(get_reference_key)
    __swig_getmethods__["get_reference_key"] = lambda x: get_reference_key
    def add_attribute(self, *args):
        """
        add_attribute(Reference self, FloatKey k, IMP::Float v, bool opt)
        add_attribute(Reference self, FloatKey a0, IMP::Float a1)
        add_attribute(Reference self, IntKey a0, IMP::Int a1)
        add_attribute(Reference self, StringKey a0, IMP::String a1)
        add_attribute(Reference self, ParticleIndexKey a0, Particle a1)
        add_attribute(Reference self, ObjectKey a0, IMP::Object * a1)
        """
        return _IMP_core.Reference_add_attribute(self, *args)

    def get_value(self, *args):
        """
        get_value(Reference self, FloatKey a0) -> IMP::Float
        get_value(Reference self, IntKey a0) -> IMP::Int
        get_value(Reference self, StringKey a0) -> IMP::String
        get_value(Reference self, ParticleIndexKey a0) -> Particle
        get_value(Reference self, ObjectKey a0) -> IMP::Object *
        """
        return _IMP_core.Reference_get_value(self, *args)

    def set_value(self, *args):
        """
        set_value(Reference self, FloatKey a0, IMP::Float a1)
        set_value(Reference self, IntKey a0, IMP::Int a1)
        set_value(Reference self, StringKey a0, IMP::String a1)
        set_value(Reference self, ParticleIndexKey a0, Particle a1)
        set_value(Reference self, ObjectKey a0, IMP::Object * a1)
        """
        return _IMP_core.Reference_set_value(self, *args)

    def remove_attribute(self, *args):
        """
        remove_attribute(Reference self, FloatKey a0)
        remove_attribute(Reference self, IntKey a0)
        remove_attribute(Reference self, StringKey a0)
        remove_attribute(Reference self, ParticleIndexKey a0)
        remove_attribute(Reference self, ObjectKey a0)
        """
        return _IMP_core.Reference_remove_attribute(self, *args)

    def has_attribute(self, *args):
        """
        has_attribute(Reference self, FloatKey a0) -> bool
        has_attribute(Reference self, IntKey a0) -> bool
        has_attribute(Reference self, StringKey a0) -> bool
        has_attribute(Reference self, ParticleIndexKey a0) -> bool
        has_attribute(Reference self, ObjectKey a0) -> bool
        """
        return _IMP_core.Reference_has_attribute(self, *args)

    def get_derivative(self, *args):
        """get_derivative(Reference self, FloatKey a0) -> double"""
        return _IMP_core.Reference_get_derivative(self, *args)

    def get_name(self):
        """get_name(Reference self) -> std::string"""
        return _IMP_core.Reference_get_name(self)

    def clear_caches(self):
        """clear_caches(Reference self)"""
        return _IMP_core.Reference_clear_caches(self)

    def set_name(self, *args):
        """set_name(Reference self, std::string a0)"""
        return _IMP_core.Reference_set_name(self, *args)

    def set_check_level(self, *args):
        """set_check_level(Reference self, IMP::base::CheckLevel a0)"""
        return _IMP_core.Reference_set_check_level(self, *args)

    def add_to_derivative(self, *args):
        """add_to_derivative(Reference self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_core.Reference_add_to_derivative(self, *args)

    def set_is_optimized(self, *args):
        """set_is_optimized(Reference self, FloatKey a0, bool a1)"""
        return _IMP_core.Reference_set_is_optimized(self, *args)

    def get_is_optimized(self, *args):
        """get_is_optimized(Reference self, FloatKey a0) -> bool"""
        return _IMP_core.Reference_get_is_optimized(self, *args)

    def get_check_level(self):
        """get_check_level(Reference self) -> IMP::base::CheckLevel"""
        return _IMP_core.Reference_get_check_level(self)

    def __eq__(self, *args):
        """
        __eq__(Reference self, Reference o) -> bool
        __eq__(Reference self, Particle d) -> bool
        """
        return _IMP_core.Reference___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(Reference self, Reference o) -> bool
        __ne__(Reference self, Particle d) -> bool
        """
        return _IMP_core.Reference___ne__(self, *args)

    def __le__(self, *args):
        """
        __le__(Reference self, Reference o) -> bool
        __le__(Reference self, Particle d) -> bool
        """
        return _IMP_core.Reference___le__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(Reference self, Reference o) -> bool
        __lt__(Reference self, Particle d) -> bool
        """
        return _IMP_core.Reference___lt__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(Reference self, Reference o) -> bool
        __ge__(Reference self, Particle d) -> bool
        """
        return _IMP_core.Reference___ge__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(Reference self, Reference o) -> bool
        __gt__(Reference self, Particle d) -> bool
        """
        return _IMP_core.Reference___gt__(self, *args)

    def __str__(self):
        """__str__(Reference self) -> std::string"""
        return _IMP_core.Reference___str__(self)

    def __repr__(self):
        """__repr__(Reference self) -> std::string"""
        return _IMP_core.Reference___repr__(self)

    __swig_destroy__ = _IMP_core.delete_Reference
    __del__ = lambda self : None;
Reference_swigregister = _IMP_core.Reference_swigregister
Reference_swigregister(Reference)

def Reference_decorate_particle(*args):
  """Reference_decorate_particle(Particle p) -> Reference"""
  return _IMP_core.Reference_decorate_particle(*args)

def Reference_setup_particle(*args):
  """Reference_setup_particle(Particle p, Particle ref) -> Reference"""
  return _IMP_core.Reference_setup_particle(*args)

def Reference_particle_is_instance(*args):
  """Reference_particle_is_instance(Particle p) -> bool"""
  return _IMP_core.Reference_particle_is_instance(*args)

def Reference_get_reference_key():
  """Reference_get_reference_key() -> ParticleIndexKey"""
  return _IMP_core.Reference_get_reference_key()

class TransformationAndReflectionSymmetry(IMP.kernel.SingletonModifier):
    """Proxy of C++ IMP::core::TransformationAndReflectionSymmetry class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.SingletonModifier]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TransformationAndReflectionSymmetry, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.SingletonModifier]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TransformationAndReflectionSymmetry, name)
    def __init__(self, *args): 
        """__init__(IMP::core::TransformationAndReflectionSymmetry self, Transformation3D t, Reflection3D r) -> TransformationAndReflectionSymmetry"""
        this = _IMP_core.new_TransformationAndReflectionSymmetry(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_input_particles(self, *args):
        """get_input_particles(TransformationAndReflectionSymmetry self, Particle arg2) -> IMP::kernel::ParticlesTemp"""
        return _IMP_core.TransformationAndReflectionSymmetry_get_input_particles(self, *args)

    def get_input_containers(self, *args):
        """get_input_containers(TransformationAndReflectionSymmetry self, Particle arg2) -> IMP::kernel::ContainersTemp"""
        return _IMP_core.TransformationAndReflectionSymmetry_get_input_containers(self, *args)

    def get_output_particles(self, *args):
        """get_output_particles(TransformationAndReflectionSymmetry self, Particle arg2) -> IMP::kernel::ParticlesTemp"""
        return _IMP_core.TransformationAndReflectionSymmetry_get_output_particles(self, *args)

    def get_output_containers(self, *args):
        """get_output_containers(TransformationAndReflectionSymmetry self, Particle arg2) -> IMP::kernel::ContainersTemp"""
        return _IMP_core.TransformationAndReflectionSymmetry_get_output_containers(self, *args)

    def get_version_info(self):
        """get_version_info(TransformationAndReflectionSymmetry self) -> VersionInfo"""
        return _IMP_core.TransformationAndReflectionSymmetry_get_version_info(self)

    def do_show(self, *args):
        """do_show(TransformationAndReflectionSymmetry self, _ostream out)"""
        return _IMP_core.TransformationAndReflectionSymmetry_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_TransformationAndReflectionSymmetry
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(TransformationAndReflectionSymmetry self) -> std::string"""
        return _IMP_core.TransformationAndReflectionSymmetry___str__(self)

    def __repr__(self):
        """__repr__(TransformationAndReflectionSymmetry self) -> std::string"""
        return _IMP_core.TransformationAndReflectionSymmetry___repr__(self)

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

TransformationAndReflectionSymmetry_swigregister = _IMP_core.TransformationAndReflectionSymmetry_swigregister
TransformationAndReflectionSymmetry_swigregister(TransformationAndReflectionSymmetry)

class TransformationSymmetry(IMP.kernel.SingletonModifier):
    """Proxy of C++ IMP::core::TransformationSymmetry class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.SingletonModifier]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TransformationSymmetry, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.SingletonModifier]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TransformationSymmetry, name)
    def __init__(self, *args): 
        """__init__(IMP::core::TransformationSymmetry self, Transformation3D t) -> TransformationSymmetry"""
        this = _IMP_core.new_TransformationSymmetry(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_input_particles(self, *args):
        """get_input_particles(TransformationSymmetry self, Particle arg2) -> IMP::kernel::ParticlesTemp"""
        return _IMP_core.TransformationSymmetry_get_input_particles(self, *args)

    def get_input_containers(self, *args):
        """get_input_containers(TransformationSymmetry self, Particle arg2) -> IMP::kernel::ContainersTemp"""
        return _IMP_core.TransformationSymmetry_get_input_containers(self, *args)

    def get_output_particles(self, *args):
        """get_output_particles(TransformationSymmetry self, Particle arg2) -> IMP::kernel::ParticlesTemp"""
        return _IMP_core.TransformationSymmetry_get_output_particles(self, *args)

    def get_output_containers(self, *args):
        """get_output_containers(TransformationSymmetry self, Particle arg2) -> IMP::kernel::ContainersTemp"""
        return _IMP_core.TransformationSymmetry_get_output_containers(self, *args)

    def get_version_info(self):
        """get_version_info(TransformationSymmetry self) -> VersionInfo"""
        return _IMP_core.TransformationSymmetry_get_version_info(self)

    def do_show(self, *args):
        """do_show(TransformationSymmetry self, _ostream out)"""
        return _IMP_core.TransformationSymmetry_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_TransformationSymmetry
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(TransformationSymmetry self) -> std::string"""
        return _IMP_core.TransformationSymmetry___str__(self)

    def __repr__(self):
        """__repr__(TransformationSymmetry self) -> std::string"""
        return _IMP_core.TransformationSymmetry___repr__(self)

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

TransformationSymmetry_swigregister = _IMP_core.TransformationSymmetry_swigregister
TransformationSymmetry_swigregister(TransformationSymmetry)

class DihedralRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::core::DihedralRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DihedralRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DihedralRestraint, name)
    def __init__(self, *args): 
        """__init__(IMP::core::DihedralRestraint self, UnaryFunction score_func, Particle p1, Particle p2, Particle p3, Particle p4) -> DihedralRestraint"""
        this = _IMP_core.new_DihedralRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_input_particles(self):
        """get_input_particles(DihedralRestraint self) -> IMP::kernel::ParticlesTemp"""
        return _IMP_core.DihedralRestraint_get_input_particles(self)

    def get_input_containers(self):
        """get_input_containers(DihedralRestraint self) -> IMP::kernel::ContainersTemp"""
        return _IMP_core.DihedralRestraint_get_input_containers(self)

    def do_get_inputs(self):
        """do_get_inputs(DihedralRestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_core.DihedralRestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(DihedralRestraint self) -> VersionInfo"""
        return _IMP_core.DihedralRestraint_get_version_info(self)

    def do_show(self, *args):
        """do_show(DihedralRestraint self, _ostream out)"""
        return _IMP_core.DihedralRestraint_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_DihedralRestraint
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(DihedralRestraint self) -> std::string"""
        return _IMP_core.DihedralRestraint___str__(self)

    def __repr__(self):
        """__repr__(DihedralRestraint self) -> std::string"""
        return _IMP_core.DihedralRestraint___repr__(self)

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

DihedralRestraint_swigregister = _IMP_core.DihedralRestraint_swigregister
DihedralRestraint_swigregister(DihedralRestraint)

class DistancePairScore(IMP.kernel.PairScore):
    """Proxy of C++ IMP::core::DistancePairScore class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.PairScore]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DistancePairScore, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.PairScore]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DistancePairScore, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::DistancePairScore self, UnaryFunction uf, std::string name="DistancePairScore%1%") -> DistancePairScore
        __init__(IMP::core::DistancePairScore self, UnaryFunction uf) -> DistancePairScore
        """
        this = _IMP_core.new_DistancePairScore(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_input_particles(self, *args):
        """get_input_particles(DistancePairScore self, Particle arg2) -> IMP::kernel::ParticlesTemp"""
        return _IMP_core.DistancePairScore_get_input_particles(self, *args)

    def get_input_containers(self, *args):
        """get_input_containers(DistancePairScore self, Particle arg2) -> IMP::kernel::ContainersTemp"""
        return _IMP_core.DistancePairScore_get_input_containers(self, *args)

    def get_version_info(self):
        """get_version_info(DistancePairScore self) -> VersionInfo"""
        return _IMP_core.DistancePairScore_get_version_info(self)

    def do_show(self, *args):
        """do_show(DistancePairScore self, _ostream out)"""
        return _IMP_core.DistancePairScore_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_DistancePairScore
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(DistancePairScore self) -> std::string"""
        return _IMP_core.DistancePairScore___str__(self)

    def __repr__(self):
        """__repr__(DistancePairScore self) -> std::string"""
        return _IMP_core.DistancePairScore___repr__(self)

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

DistancePairScore_swigregister = _IMP_core.DistancePairScore_swigregister
DistancePairScore_swigregister(DistancePairScore)

class HarmonicDistancePairScore(IMP.kernel.PairScore):
    """Proxy of C++ IMP::core::HarmonicDistancePairScore class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.PairScore]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HarmonicDistancePairScore, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.PairScore]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, HarmonicDistancePairScore, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::HarmonicDistancePairScore self, double x0, double k, std::string name="HarmonicDistancePairScore%1%") -> HarmonicDistancePairScore
        __init__(IMP::core::HarmonicDistancePairScore self, double x0, double k) -> HarmonicDistancePairScore
        """
        this = _IMP_core.new_HarmonicDistancePairScore(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_input_particles(self, *args):
        """get_input_particles(HarmonicDistancePairScore self, Particle arg2) -> IMP::kernel::ParticlesTemp"""
        return _IMP_core.HarmonicDistancePairScore_get_input_particles(self, *args)

    def get_input_containers(self, *args):
        """get_input_containers(HarmonicDistancePairScore self, Particle arg2) -> IMP::kernel::ContainersTemp"""
        return _IMP_core.HarmonicDistancePairScore_get_input_containers(self, *args)

    def get_version_info(self):
        """get_version_info(HarmonicDistancePairScore self) -> VersionInfo"""
        return _IMP_core.HarmonicDistancePairScore_get_version_info(self)

    def do_show(self, *args):
        """do_show(HarmonicDistancePairScore self, _ostream out)"""
        return _IMP_core.HarmonicDistancePairScore_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_HarmonicDistancePairScore
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(HarmonicDistancePairScore self) -> std::string"""
        return _IMP_core.HarmonicDistancePairScore___str__(self)

    def __repr__(self):
        """__repr__(HarmonicDistancePairScore self) -> std::string"""
        return _IMP_core.HarmonicDistancePairScore___repr__(self)

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

HarmonicDistancePairScore_swigregister = _IMP_core.HarmonicDistancePairScore_swigregister
HarmonicDistancePairScore_swigregister(HarmonicDistancePairScore)

class DistanceRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::core::DistanceRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DistanceRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DistanceRestraint, name)
    def __init__(self, *args): 
        """__init__(IMP::core::DistanceRestraint self, UnaryFunction score_func, Particle a, Particle b) -> DistanceRestraint"""
        this = _IMP_core.new_DistanceRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(DistanceRestraint self) -> VersionInfo"""
        return _IMP_core.DistanceRestraint_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_DistanceRestraint
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(DistanceRestraint self) -> std::string"""
        return _IMP_core.DistanceRestraint___str__(self)

    def __repr__(self):
        """__repr__(DistanceRestraint self) -> std::string"""
        return _IMP_core.DistanceRestraint___repr__(self)

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

DistanceRestraint_swigregister = _IMP_core.DistanceRestraint_swigregister
DistanceRestraint_swigregister(DistanceRestraint)

class SphereDistanceToSingletonScore(IMP.kernel.SingletonScore):
    """Proxy of C++ IMP::core::SphereDistanceToSingletonScore class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.SingletonScore]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SphereDistanceToSingletonScore, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.SingletonScore]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SphereDistanceToSingletonScore, name)
    def __init__(self, *args): 
        """__init__(IMP::core::SphereDistanceToSingletonScore self, UnaryFunction f, Vector3D pt) -> SphereDistanceToSingletonScore"""
        this = _IMP_core.new_SphereDistanceToSingletonScore(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_create_current_decomposition(self, *args):
        """do_create_current_decomposition(SphereDistanceToSingletonScore self, Model m, IMP::kernel::ParticleIndex vt) -> IMP::kernel::Restraints"""
        return _IMP_core.SphereDistanceToSingletonScore_do_create_current_decomposition(self, *args)

    def get_version_info(self):
        """get_version_info(SphereDistanceToSingletonScore self) -> VersionInfo"""
        return _IMP_core.SphereDistanceToSingletonScore_get_version_info(self)

    def do_show(self, *args):
        """do_show(SphereDistanceToSingletonScore self, _ostream out)"""
        return _IMP_core.SphereDistanceToSingletonScore_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_SphereDistanceToSingletonScore
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(SphereDistanceToSingletonScore self) -> std::string"""
        return _IMP_core.SphereDistanceToSingletonScore___str__(self)

    def __repr__(self):
        """__repr__(SphereDistanceToSingletonScore self) -> std::string"""
        return _IMP_core.SphereDistanceToSingletonScore___repr__(self)

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

SphereDistanceToSingletonScore_swigregister = _IMP_core.SphereDistanceToSingletonScore_swigregister
SphereDistanceToSingletonScore_swigregister(SphereDistanceToSingletonScore)

class ExcludedVolumeRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::core::ExcludedVolumeRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ExcludedVolumeRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ExcludedVolumeRestraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::ExcludedVolumeRestraint self, _SingletonContainerAdaptor sc, double k=1, double slack=10, std::string name="ExcludedVolumeRestraint%1%") -> ExcludedVolumeRestraint
        __init__(IMP::core::ExcludedVolumeRestraint self, _SingletonContainerAdaptor sc, double k=1, double slack=10) -> ExcludedVolumeRestraint
        __init__(IMP::core::ExcludedVolumeRestraint self, _SingletonContainerAdaptor sc, double k=1) -> ExcludedVolumeRestraint
        __init__(IMP::core::ExcludedVolumeRestraint self, _SingletonContainerAdaptor sc) -> ExcludedVolumeRestraint
        """
        this = _IMP_core.new_ExcludedVolumeRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_get_inputs(self):
        """do_get_inputs(ExcludedVolumeRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_core.ExcludedVolumeRestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(ExcludedVolumeRestraint self) -> VersionInfo"""
        return _IMP_core.ExcludedVolumeRestraint_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_ExcludedVolumeRestraint
    __del__ = lambda self : None;
    def do_create_decomposition(self):
        """do_create_decomposition(ExcludedVolumeRestraint self) -> IMP::kernel::Restraints"""
        return _IMP_core.ExcludedVolumeRestraint_do_create_decomposition(self)

    def do_create_current_decomposition(self):
        """do_create_current_decomposition(ExcludedVolumeRestraint self) -> IMP::kernel::Restraints"""
        return _IMP_core.ExcludedVolumeRestraint_do_create_current_decomposition(self)

    def get_indexes(self):
        """get_indexes(ExcludedVolumeRestraint self) -> IMP::kernel::ParticleIndexPairs const &"""
        return _IMP_core.ExcludedVolumeRestraint_get_indexes(self)

    def remove_pair_filter(self, *args):
        """remove_pair_filter(ExcludedVolumeRestraint self, PairPredicate d)"""
        return _IMP_core.ExcludedVolumeRestraint_remove_pair_filter(self, *args)

    def remove_pair_filters(self, *args):
        """remove_pair_filters(ExcludedVolumeRestraint self, IMP::kernel::PairPredicates const & d)"""
        return _IMP_core.ExcludedVolumeRestraint_remove_pair_filters(self, *args)

    def set_pair_filters(self, *args):
        """set_pair_filters(ExcludedVolumeRestraint self, IMP::kernel::PairPredicates const & ps)"""
        return _IMP_core.ExcludedVolumeRestraint_set_pair_filters(self, *args)

    def set_pair_filters_order(self, *args):
        """set_pair_filters_order(ExcludedVolumeRestraint self, IMP::kernel::PairPredicates const & objs)"""
        return _IMP_core.ExcludedVolumeRestraint_set_pair_filters_order(self, *args)

    def add_pair_filter(self, *args):
        """add_pair_filter(ExcludedVolumeRestraint self, PairPredicate obj) -> unsigned int"""
        return _IMP_core.ExcludedVolumeRestraint_add_pair_filter(self, *args)

    def add_pair_filters(self, *args):
        """add_pair_filters(ExcludedVolumeRestraint self, IMP::kernel::PairPredicates const & objs)"""
        return _IMP_core.ExcludedVolumeRestraint_add_pair_filters(self, *args)

    def clear_pair_filters(self):
        """clear_pair_filters(ExcludedVolumeRestraint self)"""
        return _IMP_core.ExcludedVolumeRestraint_clear_pair_filters(self)

    def get_number_of_pair_filters(self):
        """get_number_of_pair_filters(ExcludedVolumeRestraint self) -> unsigned int"""
        return _IMP_core.ExcludedVolumeRestraint_get_number_of_pair_filters(self)

    def get_has_pair_filters(self):
        """get_has_pair_filters(ExcludedVolumeRestraint self) -> bool"""
        return _IMP_core.ExcludedVolumeRestraint_get_has_pair_filters(self)

    def get_pair_filter(self, *args):
        """get_pair_filter(ExcludedVolumeRestraint self, unsigned int i) -> PairPredicate"""
        return _IMP_core.ExcludedVolumeRestraint_get_pair_filter(self, *args)

    def get_pair_filters(self):
        """get_pair_filters(ExcludedVolumeRestraint self) -> IMP::kernel::PairPredicates"""
        return _IMP_core.ExcludedVolumeRestraint_get_pair_filters(self)

    def reserve_pair_filters(self, *args):
        """reserve_pair_filters(ExcludedVolumeRestraint self, unsigned int sz)"""
        return _IMP_core.ExcludedVolumeRestraint_reserve_pair_filters(self, *args)

    def __str__(self):
        """__str__(ExcludedVolumeRestraint self) -> std::string"""
        return _IMP_core.ExcludedVolumeRestraint___str__(self)

    def __repr__(self):
        """__repr__(ExcludedVolumeRestraint self) -> std::string"""
        return _IMP_core.ExcludedVolumeRestraint___repr__(self)

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

ExcludedVolumeRestraint_swigregister = _IMP_core.ExcludedVolumeRestraint_swigregister
ExcludedVolumeRestraint_swigregister(ExcludedVolumeRestraint)

class FixedRefiner(IMP.kernel.Refiner):
    """Proxy of C++ IMP::core::FixedRefiner class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Refiner]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FixedRefiner, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Refiner]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FixedRefiner, name)
    def __init__(self, *args): 
        """__init__(IMP::core::FixedRefiner self, IMP::kernel::ParticlesTemp const & ps) -> FixedRefiner"""
        this = _IMP_core.new_FixedRefiner(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_refined(self, *args):
        """
        get_refined(FixedRefiner self, Particle arg2) -> IMP::kernel::ParticlesTemp const
        get_refined(FixedRefiner self, Particle arg2, unsigned int arg3) -> Particle
        """
        return _IMP_core.FixedRefiner_get_refined(self, *args)

    def get_input_particles(self, *args):
        """get_input_particles(FixedRefiner self, Particle arg2) -> IMP::kernel::ParticlesTemp"""
        return _IMP_core.FixedRefiner_get_input_particles(self, *args)

    def get_input_containers(self, *args):
        """get_input_containers(FixedRefiner self, Particle arg2) -> IMP::kernel::ContainersTemp"""
        return _IMP_core.FixedRefiner_get_input_containers(self, *args)

    def get_version_info(self):
        """get_version_info(FixedRefiner self) -> VersionInfo"""
        return _IMP_core.FixedRefiner_get_version_info(self)

    def do_show(self, *args):
        """do_show(FixedRefiner self, _ostream out)"""
        return _IMP_core.FixedRefiner_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_FixedRefiner
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(FixedRefiner self) -> std::string"""
        return _IMP_core.FixedRefiner___str__(self)

    def __repr__(self):
        """__repr__(FixedRefiner self) -> std::string"""
        return _IMP_core.FixedRefiner___repr__(self)

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

FixedRefiner_swigregister = _IMP_core.FixedRefiner_swigregister
FixedRefiner_swigregister(FixedRefiner)

class GridClosePairsFinder(ClosePairsFinder):
    """Proxy of C++ IMP::core::GridClosePairsFinder class"""
    __swig_setmethods__ = {}
    for _s in [ClosePairsFinder]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GridClosePairsFinder, name, value)
    __swig_getmethods__ = {}
    for _s in [ClosePairsFinder]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GridClosePairsFinder, name)
    def __init__(self): 
        """__init__(IMP::core::GridClosePairsFinder self) -> GridClosePairsFinder"""
        this = _IMP_core.new_GridClosePairsFinder()
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(GridClosePairsFinder self) -> VersionInfo"""
        return _IMP_core.GridClosePairsFinder_get_version_info(self)

    def do_show(self, *args):
        """do_show(GridClosePairsFinder self, _ostream out)"""
        return _IMP_core.GridClosePairsFinder_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_GridClosePairsFinder
    __del__ = lambda self : None;
    def get_close_pairs(self, *args):
        """
        get_close_pairs(GridClosePairsFinder self, IMP::kernel::ParticlesTemp const & pa) -> IMP::kernel::ParticlePairsTemp
        get_close_pairs(GridClosePairsFinder self, IMP::kernel::ParticlesTemp const & pa, IMP::kernel::ParticlesTemp const & pb) -> IMP::kernel::ParticlePairsTemp
        get_close_pairs(GridClosePairsFinder self, IMP::algebra::BoundingBox3Ds const & bbs) -> IMP::IntPairs
        get_close_pairs(GridClosePairsFinder self, IMP::algebra::BoundingBox3Ds const & bas, IMP::algebra::BoundingBox3Ds const & bbs) -> IMP::IntPairs
        get_close_pairs(GridClosePairsFinder self, Model m, IMP::kernel::ParticleIndexes const & pc) -> IMP::kernel::ParticleIndexPairs
        get_close_pairs(GridClosePairsFinder self, Model m, IMP::kernel::ParticleIndexes const & pca, IMP::kernel::ParticleIndexes const & pcb) -> IMP::kernel::ParticleIndexPairs
        """
        return _IMP_core.GridClosePairsFinder_get_close_pairs(self, *args)

    def __str__(self):
        """__str__(GridClosePairsFinder self) -> std::string"""
        return _IMP_core.GridClosePairsFinder___str__(self)

    def __repr__(self):
        """__repr__(GridClosePairsFinder self) -> std::string"""
        return _IMP_core.GridClosePairsFinder___repr__(self)

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

GridClosePairsFinder_swigregister = _IMP_core.GridClosePairsFinder_swigregister
GridClosePairsFinder_swigregister(GridClosePairsFinder)

class Harmonic(IMP.kernel.UnaryFunction):
    """Proxy of C++ IMP::core::Harmonic class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.UnaryFunction]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Harmonic, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.UnaryFunction]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Harmonic, name)
    def __init__(self, *args): 
        """__init__(IMP::core::Harmonic self, IMP::Float mean, IMP::Float k) -> Harmonic"""
        this = _IMP_core.new_Harmonic(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(Harmonic self) -> VersionInfo"""
        return _IMP_core.Harmonic_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_Harmonic
    __del__ = lambda self : None;
    def get_mean(self):
        """get_mean(Harmonic self) -> IMP::Float"""
        return _IMP_core.Harmonic_get_mean(self)

    def get_k(self):
        """get_k(Harmonic self) -> IMP::Float"""
        return _IMP_core.Harmonic_get_k(self)

    def set_mean(self, *args):
        """set_mean(Harmonic self, IMP::Float mean)"""
        return _IMP_core.Harmonic_set_mean(self, *args)

    def set_k(self, *args):
        """set_k(Harmonic self, IMP::Float k)"""
        return _IMP_core.Harmonic_set_k(self, *args)

    def get_k_from_standard_deviation(*args):
        """
        get_k_from_standard_deviation(IMP::Float sd, IMP::Float t=297.15) -> IMP::Float
        get_k_from_standard_deviation(IMP::Float sd) -> IMP::Float
        """
        return _IMP_core.Harmonic_get_k_from_standard_deviation(*args)

    if _newclass:get_k_from_standard_deviation = staticmethod(get_k_from_standard_deviation)
    __swig_getmethods__["get_k_from_standard_deviation"] = lambda x: get_k_from_standard_deviation
    def __str__(self):
        """__str__(Harmonic self) -> std::string"""
        return _IMP_core.Harmonic___str__(self)

    def __repr__(self):
        """__repr__(Harmonic self) -> std::string"""
        return _IMP_core.Harmonic___repr__(self)

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

Harmonic_swigregister = _IMP_core.Harmonic_swigregister
Harmonic_swigregister(Harmonic)

def Harmonic_get_k_from_standard_deviation(*args):
  """
    get_k_from_standard_deviation(IMP::Float sd, IMP::Float t=297.15) -> IMP::Float
    Harmonic_get_k_from_standard_deviation(IMP::Float sd) -> IMP::Float
    """
  return _IMP_core.Harmonic_get_k_from_standard_deviation(*args)

class HarmonicWell(IMP.kernel.UnaryFunction):
    """Proxy of C++ IMP::core::HarmonicWell class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.UnaryFunction]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HarmonicWell, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.UnaryFunction]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, HarmonicWell, name)
    def __init__(self, *args): 
        """__init__(IMP::core::HarmonicWell self, IMP::FloatRange const & well, double k) -> HarmonicWell"""
        this = _IMP_core.new_HarmonicWell(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(HarmonicWell self) -> VersionInfo"""
        return _IMP_core.HarmonicWell_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_HarmonicWell
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(HarmonicWell self) -> std::string"""
        return _IMP_core.HarmonicWell___str__(self)

    def __repr__(self):
        """__repr__(HarmonicWell self) -> std::string"""
        return _IMP_core.HarmonicWell___repr__(self)

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

HarmonicWell_swigregister = _IMP_core.HarmonicWell_swigregister
HarmonicWell_swigregister(HarmonicWell)

class HarmonicLowerBound(Harmonic):
    """Proxy of C++ IMP::core::HarmonicLowerBound class"""
    __swig_setmethods__ = {}
    for _s in [Harmonic]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HarmonicLowerBound, name, value)
    __swig_getmethods__ = {}
    for _s in [Harmonic]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, HarmonicLowerBound, name)
    def __init__(self, *args): 
        """__init__(IMP::core::HarmonicLowerBound self, IMP::Float mean, IMP::Float k) -> HarmonicLowerBound"""
        this = _IMP_core.new_HarmonicLowerBound(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _IMP_core.delete_HarmonicLowerBound
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(HarmonicLowerBound self) -> std::string"""
        return _IMP_core.HarmonicLowerBound___str__(self)

    def __repr__(self):
        """__repr__(HarmonicLowerBound self) -> std::string"""
        return _IMP_core.HarmonicLowerBound___repr__(self)

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

HarmonicLowerBound_swigregister = _IMP_core.HarmonicLowerBound_swigregister
HarmonicLowerBound_swigregister(HarmonicLowerBound)

class HarmonicUpperBound(Harmonic):
    """Proxy of C++ IMP::core::HarmonicUpperBound class"""
    __swig_setmethods__ = {}
    for _s in [Harmonic]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HarmonicUpperBound, name, value)
    __swig_getmethods__ = {}
    for _s in [Harmonic]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, HarmonicUpperBound, name)
    def __init__(self, *args): 
        """__init__(IMP::core::HarmonicUpperBound self, IMP::Float mean, IMP::Float k) -> HarmonicUpperBound"""
        this = _IMP_core.new_HarmonicUpperBound(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _IMP_core.delete_HarmonicUpperBound
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(HarmonicUpperBound self) -> std::string"""
        return _IMP_core.HarmonicUpperBound___str__(self)

    def __repr__(self):
        """__repr__(HarmonicUpperBound self) -> std::string"""
        return _IMP_core.HarmonicUpperBound___repr__(self)

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

HarmonicUpperBound_swigregister = _IMP_core.HarmonicUpperBound_swigregister
HarmonicUpperBound_swigregister(HarmonicUpperBound)

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



    def set_is_optimizing(self, *args):
        """set_is_optimizing(PeriodicOptimizerState self, bool tf)"""
        return _IMP_core.PeriodicOptimizerState_set_is_optimizing(self, *args)

    def set_period(self, *args):
        """set_period(PeriodicOptimizerState self, unsigned int p)"""
        return _IMP_core.PeriodicOptimizerState_set_period(self, *args)

    def get_period(self):
        """get_period(PeriodicOptimizerState self) -> unsigned int"""
        return _IMP_core.PeriodicOptimizerState_get_period(self)

    def reset(self):
        """reset(PeriodicOptimizerState self)"""
        return _IMP_core.PeriodicOptimizerState_reset(self)

    def update(self):
        """update(PeriodicOptimizerState self)"""
        return _IMP_core.PeriodicOptimizerState_update(self)

    def update_always(self):
        """update_always(PeriodicOptimizerState self)"""
        return _IMP_core.PeriodicOptimizerState_update_always(self)

    def get_number_of_updates(self):
        """get_number_of_updates(PeriodicOptimizerState self) -> unsigned int"""
        return _IMP_core.PeriodicOptimizerState_get_number_of_updates(self)

    def set_number_of_updates(self, *args):
        """set_number_of_updates(PeriodicOptimizerState self, unsigned int n)"""
        return _IMP_core.PeriodicOptimizerState_set_number_of_updates(self, *args)

    def do_update(self, *args):
        """do_update(PeriodicOptimizerState self, unsigned int call_number)"""
        return _IMP_core.PeriodicOptimizerState_do_update(self, *args)

    def __str__(self):
        """__str__(PeriodicOptimizerState self) -> std::string"""
        return _IMP_core.PeriodicOptimizerState___str__(self)

    def __repr__(self):
        """__repr__(PeriodicOptimizerState self) -> std::string"""
        return _IMP_core.PeriodicOptimizerState___repr__(self)

    def get_from(o):
       return _object_cast_to_PeriodicOptimizerState(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::core" == "IMP":
          return VersionInfo("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_PeriodicOptimizerState(o)
    get_from = staticmethod(get_from)

    __swig_destroy__ = _IMP_core.delete_PeriodicOptimizerState
    __del__ = lambda self : None;
    def __disown__(self):
        self.this.disown()
        _IMP_core.disown_PeriodicOptimizerState(self)
        return weakref_proxy(self)
PeriodicOptimizerState_swigregister = _IMP_core.PeriodicOptimizerState_swigregister
PeriodicOptimizerState_swigregister(PeriodicOptimizerState)

class MSConnectivityRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::core::MSConnectivityRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MSConnectivityRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MSConnectivityRestraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::MSConnectivityRestraint self, PairScore ps, double eps=0.1) -> MSConnectivityRestraint
        __init__(IMP::core::MSConnectivityRestraint self, PairScore ps) -> MSConnectivityRestraint
        """
        this = _IMP_core.new_MSConnectivityRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def add_type(self, *args):
        """add_type(MSConnectivityRestraint self, IMP::kernel::ParticlesTemp const & ps) -> unsigned int"""
        return _IMP_core.MSConnectivityRestraint_add_type(self, *args)

    def add_composite(self, *args):
        """
        add_composite(MSConnectivityRestraint self, IMP::Ints const & components) -> unsigned int
        add_composite(MSConnectivityRestraint self, IMP::Ints const & components, unsigned int parent) -> unsigned int
        """
        return _IMP_core.MSConnectivityRestraint_add_composite(self, *args)

    def get_connected_pairs(self):
        """get_connected_pairs(MSConnectivityRestraint self) -> IMP::kernel::ParticlePairsTemp"""
        return _IMP_core.MSConnectivityRestraint_get_connected_pairs(self)

    def get_pair_score(self):
        """get_pair_score(MSConnectivityRestraint self) -> PairScore"""
        return _IMP_core.MSConnectivityRestraint_get_pair_score(self)

    def do_create_current_decomposition(self):
        """do_create_current_decomposition(MSConnectivityRestraint self) -> IMP::kernel::Restraints"""
        return _IMP_core.MSConnectivityRestraint_do_create_current_decomposition(self)

    def do_get_inputs(self):
        """do_get_inputs(MSConnectivityRestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_core.MSConnectivityRestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(MSConnectivityRestraint self) -> VersionInfo"""
        return _IMP_core.MSConnectivityRestraint_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_MSConnectivityRestraint
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(MSConnectivityRestraint self) -> std::string"""
        return _IMP_core.MSConnectivityRestraint___str__(self)

    def __repr__(self):
        """__repr__(MSConnectivityRestraint self) -> std::string"""
        return _IMP_core.MSConnectivityRestraint___repr__(self)

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

MSConnectivityRestraint_swigregister = _IMP_core.MSConnectivityRestraint_swigregister
MSConnectivityRestraint_swigregister(MSConnectivityRestraint)

class HierarchyTraits(_object):
    """Proxy of C++ IMP::core::HierarchyTraits class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, HierarchyTraits, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, HierarchyTraits, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::HierarchyTraits self) -> HierarchyTraits
        __init__(IMP::core::HierarchyTraits self, std::string name) -> HierarchyTraits
        """
        this = _IMP_core.new_HierarchyTraits(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_children_key(self):
        """get_children_key(HierarchyTraits self) -> ParticleIndexesKey"""
        return _IMP_core.HierarchyTraits_get_children_key(self)

    def get_parent_key(self):
        """get_parent_key(HierarchyTraits self) -> ParticleIndexKey"""
        return _IMP_core.HierarchyTraits_get_parent_key(self)

    def __eq__(self, *args):
        """__eq__(HierarchyTraits self, HierarchyTraits o) -> bool"""
        return _IMP_core.HierarchyTraits___eq__(self, *args)

    def show(self, *args):
        """
        show(HierarchyTraits self, _ostream out=std::cout)
        show(HierarchyTraits self)
        """
        return _IMP_core.HierarchyTraits_show(self, *args)

    def __str__(self):
        """__str__(HierarchyTraits self) -> std::string"""
        return _IMP_core.HierarchyTraits___str__(self)

    def __repr__(self):
        """__repr__(HierarchyTraits self) -> std::string"""
        return _IMP_core.HierarchyTraits___repr__(self)

    __swig_destroy__ = _IMP_core.delete_HierarchyTraits
    __del__ = lambda self : None;
HierarchyTraits_swigregister = _IMP_core.HierarchyTraits_swigregister
HierarchyTraits_swigregister(HierarchyTraits)

class Hierarchy(IMP.kernel.Decorator):
    """Proxy of C++ IMP::core::Hierarchy class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Decorator]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Hierarchy, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Decorator]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Hierarchy, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::Hierarchy self) -> Hierarchy
        __init__(IMP::core::Hierarchy self, Model m, IMP::kernel::ParticleIndex id, HierarchyTraits tr) -> Hierarchy
        __init__(IMP::core::Hierarchy self, HierarchyTraits tr) -> Hierarchy
        __init__(IMP::core::Hierarchy self, Particle p, HierarchyTraits tr=get_default_traits()) -> Hierarchy
        __init__(IMP::core::Hierarchy self, Particle p) -> Hierarchy
        """
        this = _IMP_core.new_Hierarchy(*args)
        try: self.this.append(this)
        except: self.this = this
    def decorate_particle(*args):
        """
        decorate_particle(Particle p, HierarchyTraits tr=get_default_traits()) -> Hierarchy
        decorate_particle(Particle p) -> Hierarchy
        """
        return _IMP_core.Hierarchy_decorate_particle(*args)

    if _newclass:decorate_particle = staticmethod(decorate_particle)
    __swig_getmethods__["decorate_particle"] = lambda x: decorate_particle
    def show(self, *args):
        """
        show(Hierarchy self, _ostream out=std::cout)
        show(Hierarchy self)
        """
        return _IMP_core.Hierarchy_show(self, *args)

    def get_traits(self):
        """get_traits(Hierarchy self) -> HierarchyTraits"""
        return _IMP_core.Hierarchy_get_traits(self)

    def get_decorator_traits(self):
        """get_decorator_traits(Hierarchy self) -> HierarchyTraits"""
        return _IMP_core.Hierarchy_get_decorator_traits(self)

    def get_default_decorator_traits():
        """get_default_decorator_traits() -> HierarchyTraits"""
        return _IMP_core.Hierarchy_get_default_decorator_traits()

    if _newclass:get_default_decorator_traits = staticmethod(get_default_decorator_traits)
    __swig_getmethods__["get_default_decorator_traits"] = lambda x: get_default_decorator_traits
    def setup_particle(*args):
        """
        setup_particle(Particle p, HierarchyTraits traits=Hierarchy::get_default_traits()) -> Hierarchy
        setup_particle(Particle p) -> Hierarchy
        setup_particle(Particle p, IMP::kernel::Particles const & children, HierarchyTraits traits=Hierarchy::get_default_traits()) -> Hierarchy
        setup_particle(Particle p, IMP::kernel::Particles const & children) -> Hierarchy
        """
        return _IMP_core.Hierarchy_setup_particle(*args)

    if _newclass:setup_particle = staticmethod(setup_particle)
    __swig_getmethods__["setup_particle"] = lambda x: setup_particle
    def particle_is_instance(*args):
        """
        particle_is_instance(Particle arg1, HierarchyTraits arg2=Hierarchy::get_default_traits()) -> bool
        particle_is_instance(Particle arg1) -> bool
        """
        return _IMP_core.Hierarchy_particle_is_instance(*args)

    if _newclass:particle_is_instance = staticmethod(particle_is_instance)
    __swig_getmethods__["particle_is_instance"] = lambda x: particle_is_instance
    def get_parent(self):
        """get_parent(Hierarchy self) -> Hierarchy"""
        return _IMP_core.Hierarchy_get_parent(self)

    def get_number_of_children(self):
        """get_number_of_children(Hierarchy self) -> unsigned int"""
        return _IMP_core.Hierarchy_get_number_of_children(self)

    def get_child(self, *args):
        """get_child(Hierarchy self, unsigned int i) -> Hierarchy"""
        return _IMP_core.Hierarchy_get_child(self, *args)

    def get_children(self):
        """get_children(Hierarchy self) -> IMP::core::GenericHierarchies"""
        return _IMP_core.Hierarchy_get_children(self)

    def remove_child(self, *args):
        """
        remove_child(Hierarchy self, unsigned int i)
        remove_child(Hierarchy self, Hierarchy h)
        """
        return _IMP_core.Hierarchy_remove_child(self, *args)

    def clear_children(self):
        """clear_children(Hierarchy self)"""
        return _IMP_core.Hierarchy_clear_children(self)

    def add_child(self, *args):
        """add_child(Hierarchy self, Hierarchy h)"""
        return _IMP_core.Hierarchy_add_child(self, *args)

    def add_child_at(self, *args):
        """add_child_at(Hierarchy self, Hierarchy h, unsigned int pos)"""
        return _IMP_core.Hierarchy_add_child_at(self, *args)

    def get_child_index(self):
        """get_child_index(Hierarchy self) -> int"""
        return _IMP_core.Hierarchy_get_child_index(self)

    def get_default_traits():
        """get_default_traits() -> HierarchyTraits"""
        return _IMP_core.Hierarchy_get_default_traits()

    if _newclass:get_default_traits = staticmethod(get_default_traits)
    __swig_getmethods__["get_default_traits"] = lambda x: get_default_traits
    def add_attribute(self, *args):
        """
        add_attribute(Hierarchy self, FloatKey k, IMP::Float v, bool opt)
        add_attribute(Hierarchy self, FloatKey a0, IMP::Float a1)
        add_attribute(Hierarchy self, IntKey a0, IMP::Int a1)
        add_attribute(Hierarchy self, StringKey a0, IMP::String a1)
        add_attribute(Hierarchy self, ParticleIndexKey a0, Particle a1)
        add_attribute(Hierarchy self, ObjectKey a0, IMP::Object * a1)
        """
        return _IMP_core.Hierarchy_add_attribute(self, *args)

    def get_value(self, *args):
        """
        get_value(Hierarchy self, FloatKey a0) -> IMP::Float
        get_value(Hierarchy self, IntKey a0) -> IMP::Int
        get_value(Hierarchy self, StringKey a0) -> IMP::String
        get_value(Hierarchy self, ParticleIndexKey a0) -> Particle
        get_value(Hierarchy self, ObjectKey a0) -> IMP::Object *
        """
        return _IMP_core.Hierarchy_get_value(self, *args)

    def set_value(self, *args):
        """
        set_value(Hierarchy self, FloatKey a0, IMP::Float a1)
        set_value(Hierarchy self, IntKey a0, IMP::Int a1)
        set_value(Hierarchy self, StringKey a0, IMP::String a1)
        set_value(Hierarchy self, ParticleIndexKey a0, Particle a1)
        set_value(Hierarchy self, ObjectKey a0, IMP::Object * a1)
        """
        return _IMP_core.Hierarchy_set_value(self, *args)

    def remove_attribute(self, *args):
        """
        remove_attribute(Hierarchy self, FloatKey a0)
        remove_attribute(Hierarchy self, IntKey a0)
        remove_attribute(Hierarchy self, StringKey a0)
        remove_attribute(Hierarchy self, ParticleIndexKey a0)
        remove_attribute(Hierarchy self, ObjectKey a0)
        """
        return _IMP_core.Hierarchy_remove_attribute(self, *args)

    def has_attribute(self, *args):
        """
        has_attribute(Hierarchy self, FloatKey a0) -> bool
        has_attribute(Hierarchy self, IntKey a0) -> bool
        has_attribute(Hierarchy self, StringKey a0) -> bool
        has_attribute(Hierarchy self, ParticleIndexKey a0) -> bool
        has_attribute(Hierarchy self, ObjectKey a0) -> bool
        """
        return _IMP_core.Hierarchy_has_attribute(self, *args)

    def get_derivative(self, *args):
        """get_derivative(Hierarchy self, FloatKey a0) -> double"""
        return _IMP_core.Hierarchy_get_derivative(self, *args)

    def get_name(self):
        """get_name(Hierarchy self) -> std::string"""
        return _IMP_core.Hierarchy_get_name(self)

    def clear_caches(self):
        """clear_caches(Hierarchy self)"""
        return _IMP_core.Hierarchy_clear_caches(self)

    def set_name(self, *args):
        """set_name(Hierarchy self, std::string a0)"""
        return _IMP_core.Hierarchy_set_name(self, *args)

    def set_check_level(self, *args):
        """set_check_level(Hierarchy self, IMP::base::CheckLevel a0)"""
        return _IMP_core.Hierarchy_set_check_level(self, *args)

    def add_to_derivative(self, *args):
        """add_to_derivative(Hierarchy self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_core.Hierarchy_add_to_derivative(self, *args)

    def set_is_optimized(self, *args):
        """set_is_optimized(Hierarchy self, FloatKey a0, bool a1)"""
        return _IMP_core.Hierarchy_set_is_optimized(self, *args)

    def get_is_optimized(self, *args):
        """get_is_optimized(Hierarchy self, FloatKey a0) -> bool"""
        return _IMP_core.Hierarchy_get_is_optimized(self, *args)

    def get_check_level(self):
        """get_check_level(Hierarchy self) -> IMP::base::CheckLevel"""
        return _IMP_core.Hierarchy_get_check_level(self)

    def __eq__(self, *args):
        """
        __eq__(Hierarchy self, Hierarchy o) -> bool
        __eq__(Hierarchy self, Particle d) -> bool
        """
        return _IMP_core.Hierarchy___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(Hierarchy self, Hierarchy o) -> bool
        __ne__(Hierarchy self, Particle d) -> bool
        """
        return _IMP_core.Hierarchy___ne__(self, *args)

    def __le__(self, *args):
        """
        __le__(Hierarchy self, Hierarchy o) -> bool
        __le__(Hierarchy self, Particle d) -> bool
        """
        return _IMP_core.Hierarchy___le__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(Hierarchy self, Hierarchy o) -> bool
        __lt__(Hierarchy self, Particle d) -> bool
        """
        return _IMP_core.Hierarchy___lt__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(Hierarchy self, Hierarchy o) -> bool
        __ge__(Hierarchy self, Particle d) -> bool
        """
        return _IMP_core.Hierarchy___ge__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(Hierarchy self, Hierarchy o) -> bool
        __gt__(Hierarchy self, Particle d) -> bool
        """
        return _IMP_core.Hierarchy___gt__(self, *args)

    def __str__(self):
        """__str__(Hierarchy self) -> std::string"""
        return _IMP_core.Hierarchy___str__(self)

    def __repr__(self):
        """__repr__(Hierarchy self) -> std::string"""
        return _IMP_core.Hierarchy___repr__(self)

    __swig_destroy__ = _IMP_core.delete_Hierarchy
    __del__ = lambda self : None;
Hierarchy_swigregister = _IMP_core.Hierarchy_swigregister
Hierarchy_swigregister(Hierarchy)

def Hierarchy_decorate_particle(*args):
  """
    decorate_particle(Particle p, HierarchyTraits tr=get_default_traits()) -> Hierarchy
    Hierarchy_decorate_particle(Particle p) -> Hierarchy
    """
  return _IMP_core.Hierarchy_decorate_particle(*args)

def Hierarchy_get_default_decorator_traits():
  """Hierarchy_get_default_decorator_traits() -> HierarchyTraits"""
  return _IMP_core.Hierarchy_get_default_decorator_traits()

def Hierarchy_setup_particle(*args):
  """
    setup_particle(Particle p, HierarchyTraits traits=Hierarchy::get_default_traits()) -> Hierarchy
    setup_particle(Particle p) -> Hierarchy
    setup_particle(Particle p, IMP::kernel::Particles const & children, HierarchyTraits traits=Hierarchy::get_default_traits()) -> Hierarchy
    Hierarchy_setup_particle(Particle p, IMP::kernel::Particles const & children) -> Hierarchy
    """
  return _IMP_core.Hierarchy_setup_particle(*args)

def Hierarchy_particle_is_instance(*args):
  """
    particle_is_instance(Particle arg1, HierarchyTraits arg2=Hierarchy::get_default_traits()) -> bool
    Hierarchy_particle_is_instance(Particle arg1) -> bool
    """
  return _IMP_core.Hierarchy_particle_is_instance(*args)

def Hierarchy_get_default_traits():
  """Hierarchy_get_default_traits() -> HierarchyTraits"""
  return _IMP_core.Hierarchy_get_default_traits()

class HierarchyVisitor(_object):
    """Proxy of C++ IMP::core::HierarchyVisitor class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, HierarchyVisitor, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, HierarchyVisitor, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def __call__(self, *args):
        """__call__(HierarchyVisitor self, Hierarchy p) -> bool"""
        return _IMP_core.HierarchyVisitor___call__(self, *args)

    __swig_destroy__ = _IMP_core.delete_HierarchyVisitor
    __del__ = lambda self : None;
HierarchyVisitor_swigregister = _IMP_core.HierarchyVisitor_swigregister
HierarchyVisitor_swigregister(HierarchyVisitor)

class ModifierVisitor(HierarchyVisitor):
    """Proxy of C++ IMP::core::ModifierVisitor class"""
    __swig_setmethods__ = {}
    for _s in [HierarchyVisitor]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ModifierVisitor, name, value)
    __swig_getmethods__ = {}
    for _s in [HierarchyVisitor]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ModifierVisitor, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(IMP::core::ModifierVisitor self, SingletonModifier sm) -> ModifierVisitor"""
        this = _IMP_core.new_ModifierVisitor(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _IMP_core.delete_ModifierVisitor
    __del__ = lambda self : None;
ModifierVisitor_swigregister = _IMP_core.ModifierVisitor_swigregister
ModifierVisitor_swigregister(ModifierVisitor)

class HierarchyCounter(HierarchyVisitor):
    """Proxy of C++ IMP::core::HierarchyCounter class"""
    __swig_setmethods__ = {}
    for _s in [HierarchyVisitor]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HierarchyCounter, name, value)
    __swig_getmethods__ = {}
    for _s in [HierarchyVisitor]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, HierarchyCounter, name)
    def __init__(self): 
        """__init__(IMP::core::HierarchyCounter self) -> HierarchyCounter"""
        this = _IMP_core.new_HierarchyCounter()
        try: self.this.append(this)
        except: self.this = this
    def get_count(self):
        """get_count(HierarchyCounter self) -> unsigned int"""
        return _IMP_core.HierarchyCounter_get_count(self)

    def show(self, *args):
        """
        show(HierarchyCounter self, _ostream out=std::cout)
        show(HierarchyCounter self)
        """
        return _IMP_core.HierarchyCounter_show(self, *args)

    def __str__(self):
        """__str__(HierarchyCounter self) -> std::string"""
        return _IMP_core.HierarchyCounter___str__(self)

    def __repr__(self):
        """__repr__(HierarchyCounter self) -> std::string"""
        return _IMP_core.HierarchyCounter___repr__(self)

    __swig_destroy__ = _IMP_core.delete_HierarchyCounter
    __del__ = lambda self : None;
HierarchyCounter_swigregister = _IMP_core.HierarchyCounter_swigregister
HierarchyCounter_swigregister(HierarchyCounter)


def get_leaves(*args):
  """get_leaves(Hierarchy mhd) -> IMP::core::GenericHierarchies"""
  return _IMP_core.get_leaves(*args)

def get_internal(*args):
  """get_internal(Hierarchy mhd) -> IMP::core::GenericHierarchies"""
  return _IMP_core.get_internal(*args)

def get_all_descendants(*args):
  """get_all_descendants(Hierarchy mhd) -> IMP::core::GenericHierarchies"""
  return _IMP_core.get_all_descendants(*args)

def get_root(*args):
  """get_root(Hierarchy h) -> Hierarchy"""
  return _IMP_core.get_root(*args)

def visit_breadth_first(*args):
  """visit_breadth_first(Hierarchy d, HierarchyVisitor f)"""
  return _IMP_core.visit_breadth_first(*args)

def visit_depth_first(*args):
  """visit_depth_first(Hierarchy d, HierarchyVisitor f)"""
  return _IMP_core.visit_depth_first(*args)
class LeavesRefiner(IMP.kernel.Refiner):
    """Proxy of C++ IMP::core::LeavesRefiner class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Refiner]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LeavesRefiner, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Refiner]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, LeavesRefiner, name)
    def __init__(self, *args): 
        """__init__(IMP::core::LeavesRefiner self, HierarchyTraits tr) -> LeavesRefiner"""
        this = _IMP_core.new_LeavesRefiner(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_refined(self, *args):
        """
        get_refined(LeavesRefiner self, Particle arg2) -> IMP::kernel::ParticlesTemp const
        get_refined(LeavesRefiner self, Particle arg2, unsigned int arg3) -> Particle
        """
        return _IMP_core.LeavesRefiner_get_refined(self, *args)

    def get_input_particles(self, *args):
        """get_input_particles(LeavesRefiner self, Particle arg2) -> IMP::kernel::ParticlesTemp"""
        return _IMP_core.LeavesRefiner_get_input_particles(self, *args)

    def get_input_containers(self, *args):
        """get_input_containers(LeavesRefiner self, Particle arg2) -> IMP::kernel::ContainersTemp"""
        return _IMP_core.LeavesRefiner_get_input_containers(self, *args)

    def get_version_info(self):
        """get_version_info(LeavesRefiner self) -> VersionInfo"""
        return _IMP_core.LeavesRefiner_get_version_info(self)

    def do_show(self, *args):
        """do_show(LeavesRefiner self, _ostream out)"""
        return _IMP_core.LeavesRefiner_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_LeavesRefiner
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(LeavesRefiner self) -> std::string"""
        return _IMP_core.LeavesRefiner___str__(self)

    def __repr__(self):
        """__repr__(LeavesRefiner self) -> std::string"""
        return _IMP_core.LeavesRefiner___repr__(self)

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

LeavesRefiner_swigregister = _IMP_core.LeavesRefiner_swigregister
LeavesRefiner_swigregister(LeavesRefiner)

class Linear(IMP.kernel.UnaryFunction):
    """Proxy of C++ IMP::core::Linear class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.UnaryFunction]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Linear, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.UnaryFunction]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Linear, name)
    def __init__(self, *args): 
        """__init__(IMP::core::Linear self, double offset, double slope) -> Linear"""
        this = _IMP_core.new_Linear(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(Linear self) -> VersionInfo"""
        return _IMP_core.Linear_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_Linear
    __del__ = lambda self : None;
    def set_slope(self, *args):
        """set_slope(Linear self, double f)"""
        return _IMP_core.Linear_set_slope(self, *args)

    def set_offset(self, *args):
        """set_offset(Linear self, double f)"""
        return _IMP_core.Linear_set_offset(self, *args)

    def __str__(self):
        """__str__(Linear self) -> std::string"""
        return _IMP_core.Linear___str__(self)

    def __repr__(self):
        """__repr__(Linear self) -> std::string"""
        return _IMP_core.Linear___repr__(self)

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

Linear_swigregister = _IMP_core.Linear_swigregister
Linear_swigregister(Linear)

class IncrementalScoringFunction(IMP.kernel.ScoringFunction):
    """Proxy of C++ IMP::core::IncrementalScoringFunction class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.ScoringFunction]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, IncrementalScoringFunction, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.ScoringFunction]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, IncrementalScoringFunction, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::IncrementalScoringFunction self, IMP::kernel::ParticlesTemp const & to_move, IMP::kernel::RestraintsTemp const & rs, 
            double weight=1.0, double max=NO_MAX, std::string name="IncrementalScoringFunction%1%") -> IncrementalScoringFunction
        __init__(IMP::core::IncrementalScoringFunction self, IMP::kernel::ParticlesTemp const & to_move, IMP::kernel::RestraintsTemp const & rs, 
            double weight=1.0, double max=NO_MAX) -> IncrementalScoringFunction
        __init__(IMP::core::IncrementalScoringFunction self, IMP::kernel::ParticlesTemp const & to_move, IMP::kernel::RestraintsTemp const & rs, 
            double weight=1.0) -> IncrementalScoringFunction
        __init__(IMP::core::IncrementalScoringFunction self, IMP::kernel::ParticlesTemp const & to_move, IMP::kernel::RestraintsTemp const & rs) -> IncrementalScoringFunction
        """
        this = _IMP_core.new_IncrementalScoringFunction(*args)
        try: self.this.append(this)
        except: self.this = this
    def reset_moved_particles(self):
        """reset_moved_particles(IncrementalScoringFunction self)"""
        return _IMP_core.IncrementalScoringFunction_reset_moved_particles(self)

    def set_moved_particles(self, *args):
        """set_moved_particles(IncrementalScoringFunction self, IMP::kernel::ParticleIndexes const & p)"""
        return _IMP_core.IncrementalScoringFunction_set_moved_particles(self, *args)

    def add_close_pair_score(self, *args):
        """
        add_close_pair_score(IncrementalScoringFunction self, PairScore ps, double distance, IMP::kernel::ParticlesTemp const & particles, IMP::kernel::PairPredicates const & filters)
        add_close_pair_score(IncrementalScoringFunction self, PairScore ps, double distance, IMP::kernel::ParticlesTemp const & particles)
        """
        return _IMP_core.IncrementalScoringFunction_add_close_pair_score(self, *args)

    def clear_close_pair_scores(self):
        """clear_close_pair_scores(IncrementalScoringFunction self)"""
        return _IMP_core.IncrementalScoringFunction_clear_close_pair_scores(self)

    def get_movable_particles(self):
        """get_movable_particles(IncrementalScoringFunction self) -> IMP::kernel::ParticleIndexes"""
        return _IMP_core.IncrementalScoringFunction_get_movable_particles(self)

    def do_add_score_and_derivatives(self, *args):
        """do_add_score_and_derivatives(IncrementalScoringFunction self, ScoreAccumulator sa, IMP::kernel::ScoreStatesTemp const & ss)"""
        return _IMP_core.IncrementalScoringFunction_do_add_score_and_derivatives(self, *args)

    def get_required_score_states(self):
        """get_required_score_states(IncrementalScoringFunction self) -> IMP::kernel::ScoreStatesTemp"""
        return _IMP_core.IncrementalScoringFunction_get_required_score_states(self)

    def get_version_info(self):
        """get_version_info(IncrementalScoringFunction self) -> VersionInfo"""
        return _IMP_core.IncrementalScoringFunction_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_IncrementalScoringFunction
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(IncrementalScoringFunction self) -> std::string"""
        return _IMP_core.IncrementalScoringFunction___str__(self)

    def __repr__(self):
        """__repr__(IncrementalScoringFunction self) -> std::string"""
        return _IMP_core.IncrementalScoringFunction___repr__(self)

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

IncrementalScoringFunction_swigregister = _IMP_core.IncrementalScoringFunction_swigregister
IncrementalScoringFunction_swigregister(IncrementalScoringFunction)

IMP_CORE_HAS_MONTE_CARLO_MOVER = _IMP_core.IMP_CORE_HAS_MONTE_CARLO_MOVER
class MonteCarlo(IMP.kernel.Optimizer):
    """Proxy of C++ IMP::core::MonteCarlo class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Optimizer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MonteCarlo, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Optimizer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MonteCarlo, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::MonteCarlo self, Model m=nullptr) -> MonteCarlo
        __init__(IMP::core::MonteCarlo self) -> MonteCarlo
        """
        this = _IMP_core.new_MonteCarlo(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(MonteCarlo self) -> VersionInfo"""
        return _IMP_core.MonteCarlo_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_MonteCarlo
    __del__ = lambda self : None;
    def set_return_best(self, *args):
        """set_return_best(MonteCarlo self, bool tf)"""
        return _IMP_core.MonteCarlo_set_return_best(self, *args)

    def set_kt(self, *args):
        """set_kt(MonteCarlo self, IMP::Float t)"""
        return _IMP_core.MonteCarlo_set_kt(self, *args)

    def get_kt(self):
        """get_kt(MonteCarlo self) -> IMP::Float"""
        return _IMP_core.MonteCarlo_get_kt(self)

    def get_last_accepted_energy(self):
        """get_last_accepted_energy(MonteCarlo self) -> double"""
        return _IMP_core.MonteCarlo_get_last_accepted_energy(self)

    def get_best_accepted_energy(self):
        """get_best_accepted_energy(MonteCarlo self) -> double"""
        return _IMP_core.MonteCarlo_get_best_accepted_energy(self)

    def get_number_of_forward_steps(self):
        """get_number_of_forward_steps(MonteCarlo self) -> unsigned int"""
        return _IMP_core.MonteCarlo_get_number_of_forward_steps(self)

    def get_number_of_upward_steps(self):
        """get_number_of_upward_steps(MonteCarlo self) -> unsigned int"""
        return _IMP_core.MonteCarlo_get_number_of_upward_steps(self)

    def set_maximum_difference(self, *args):
        """set_maximum_difference(MonteCarlo self, double d)"""
        return _IMP_core.MonteCarlo_set_maximum_difference(self, *args)

    def get_maximum_difference(self):
        """get_maximum_difference(MonteCarlo self) -> double"""
        return _IMP_core.MonteCarlo_get_maximum_difference(self)

    def remove_mover(self, *args):
        """remove_mover(MonteCarlo self, MonteCarloMover d)"""
        return _IMP_core.MonteCarlo_remove_mover(self, *args)

    def remove_movers(self, *args):
        """remove_movers(MonteCarlo self, IMP::core::MonteCarloMovers const & d)"""
        return _IMP_core.MonteCarlo_remove_movers(self, *args)

    def set_movers(self, *args):
        """set_movers(MonteCarlo self, IMP::core::MonteCarloMovers const & ps)"""
        return _IMP_core.MonteCarlo_set_movers(self, *args)

    def set_movers_order(self, *args):
        """set_movers_order(MonteCarlo self, IMP::core::MonteCarloMovers const & objs)"""
        return _IMP_core.MonteCarlo_set_movers_order(self, *args)

    def add_mover(self, *args):
        """add_mover(MonteCarlo self, MonteCarloMover obj) -> unsigned int"""
        return _IMP_core.MonteCarlo_add_mover(self, *args)

    def add_movers(self, *args):
        """add_movers(MonteCarlo self, IMP::core::MonteCarloMovers const & objs)"""
        return _IMP_core.MonteCarlo_add_movers(self, *args)

    def clear_movers(self):
        """clear_movers(MonteCarlo self)"""
        return _IMP_core.MonteCarlo_clear_movers(self)

    def get_number_of_movers(self):
        """get_number_of_movers(MonteCarlo self) -> unsigned int"""
        return _IMP_core.MonteCarlo_get_number_of_movers(self)

    def get_has_movers(self):
        """get_has_movers(MonteCarlo self) -> bool"""
        return _IMP_core.MonteCarlo_get_has_movers(self)

    def get_mover(self, *args):
        """get_mover(MonteCarlo self, unsigned int i) -> MonteCarloMover"""
        return _IMP_core.MonteCarlo_get_mover(self, *args)

    def get_movers(self):
        """get_movers(MonteCarlo self) -> IMP::core::MonteCarloMovers"""
        return _IMP_core.MonteCarlo_get_movers(self)

    def reserve_movers(self, *args):
        """reserve_movers(MonteCarlo self, unsigned int sz)"""
        return _IMP_core.MonteCarlo_reserve_movers(self, *args)

    def set_incremental_scoring_function(self, *args):
        """set_incremental_scoring_function(MonteCarlo self, IncrementalScoringFunction isf)"""
        return _IMP_core.MonteCarlo_set_incremental_scoring_function(self, *args)

    def get_use_incremental_scoring_function(self):
        """get_use_incremental_scoring_function(MonteCarlo self) -> bool"""
        return _IMP_core.MonteCarlo_get_use_incremental_scoring_function(self)

    def get_incremental_scoring_function(self):
        """get_incremental_scoring_function(MonteCarlo self) -> IncrementalScoringFunction"""
        return _IMP_core.MonteCarlo_get_incremental_scoring_function(self)

    def __str__(self):
        """__str__(MonteCarlo self) -> std::string"""
        return _IMP_core.MonteCarlo___str__(self)

    def __repr__(self):
        """__repr__(MonteCarlo self) -> std::string"""
        return _IMP_core.MonteCarlo___repr__(self)

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

MonteCarlo_swigregister = _IMP_core.MonteCarlo_swigregister
MonteCarlo_swigregister(MonteCarlo)

class MonteCarloWithLocalOptimization(MonteCarlo):
    """Proxy of C++ IMP::core::MonteCarloWithLocalOptimization class"""
    __swig_setmethods__ = {}
    for _s in [MonteCarlo]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MonteCarloWithLocalOptimization, name, value)
    __swig_getmethods__ = {}
    for _s in [MonteCarlo]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MonteCarloWithLocalOptimization, name)
    def __init__(self, *args): 
        """__init__(IMP::core::MonteCarloWithLocalOptimization self, Optimizer opt, unsigned int steps) -> MonteCarloWithLocalOptimization"""
        this = _IMP_core.new_MonteCarloWithLocalOptimization(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_number_of_steps(self):
        """get_number_of_steps(MonteCarloWithLocalOptimization self) -> unsigned int"""
        return _IMP_core.MonteCarloWithLocalOptimization_get_number_of_steps(self)

    def get_local_optimizer(self):
        """get_local_optimizer(MonteCarloWithLocalOptimization self) -> Optimizer"""
        return _IMP_core.MonteCarloWithLocalOptimization_get_local_optimizer(self)

    __swig_destroy__ = _IMP_core.delete_MonteCarloWithLocalOptimization
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(MonteCarloWithLocalOptimization self) -> std::string"""
        return _IMP_core.MonteCarloWithLocalOptimization___str__(self)

    def __repr__(self):
        """__repr__(MonteCarloWithLocalOptimization self) -> std::string"""
        return _IMP_core.MonteCarloWithLocalOptimization___repr__(self)

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

MonteCarloWithLocalOptimization_swigregister = _IMP_core.MonteCarloWithLocalOptimization_swigregister
MonteCarloWithLocalOptimization_swigregister(MonteCarloWithLocalOptimization)

class MonteCarloWithBasinHopping(MonteCarloWithLocalOptimization):
    """Proxy of C++ IMP::core::MonteCarloWithBasinHopping class"""
    __swig_setmethods__ = {}
    for _s in [MonteCarloWithLocalOptimization]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MonteCarloWithBasinHopping, name, value)
    __swig_getmethods__ = {}
    for _s in [MonteCarloWithLocalOptimization]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MonteCarloWithBasinHopping, name)
    def __init__(self, *args): 
        """__init__(IMP::core::MonteCarloWithBasinHopping self, Optimizer opt, unsigned int ns) -> MonteCarloWithBasinHopping"""
        this = _IMP_core.new_MonteCarloWithBasinHopping(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _IMP_core.delete_MonteCarloWithBasinHopping
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(MonteCarloWithBasinHopping self) -> std::string"""
        return _IMP_core.MonteCarloWithBasinHopping___str__(self)

    def __repr__(self):
        """__repr__(MonteCarloWithBasinHopping self) -> std::string"""
        return _IMP_core.MonteCarloWithBasinHopping___repr__(self)

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

MonteCarloWithBasinHopping_swigregister = _IMP_core.MonteCarloWithBasinHopping_swigregister
MonteCarloWithBasinHopping_swigregister(MonteCarloWithBasinHopping)

class NormalMover(MonteCarloMover):
    """Proxy of C++ IMP::core::NormalMover class"""
    __swig_setmethods__ = {}
    for _s in [MonteCarloMover]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NormalMover, name, value)
    __swig_getmethods__ = {}
    for _s in [MonteCarloMover]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NormalMover, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::NormalMover self, Model m, IMP::kernel::ParticleIndex pi, IMP::kernel::FloatKeys const & vars, double stddev) -> NormalMover
        __init__(IMP::core::NormalMover self, Model m, IMP::kernel::ParticleIndex pi, double stddev) -> NormalMover
        __init__(IMP::core::NormalMover self, IMP::kernel::ParticlesTemp const & sc, IMP::kernel::FloatKeys const & vars, IMP::Float sigma) -> NormalMover
        __init__(IMP::core::NormalMover self, IMP::kernel::ParticlesTemp const & sc, IMP::Float radius) -> NormalMover
        """
        this = _IMP_core.new_NormalMover(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_sigma(self, *args):
        """set_sigma(NormalMover self, IMP::Float sigma)"""
        return _IMP_core.NormalMover_set_sigma(self, *args)

    def get_sigma(self):
        """get_sigma(NormalMover self) -> IMP::Float"""
        return _IMP_core.NormalMover_get_sigma(self)

    def get_version_info(self):
        """get_version_info(NormalMover self) -> VersionInfo"""
        return _IMP_core.NormalMover_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_NormalMover
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(NormalMover self) -> std::string"""
        return _IMP_core.NormalMover___str__(self)

    def __repr__(self):
        """__repr__(NormalMover self) -> std::string"""
        return _IMP_core.NormalMover___repr__(self)

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

NormalMover_swigregister = _IMP_core.NormalMover_swigregister
NormalMover_swigregister(NormalMover)

class OpenCubicSpline(_OpenCubicSplineBase):
    """Proxy of C++ IMP::core::OpenCubicSpline class"""
    __swig_setmethods__ = {}
    for _s in [_OpenCubicSplineBase]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, OpenCubicSpline, name, value)
    __swig_getmethods__ = {}
    for _s in [_OpenCubicSplineBase]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, OpenCubicSpline, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::OpenCubicSpline self, IMP::Floats const & values, IMP::Float minrange, IMP::Float spacing, bool extend=False) -> OpenCubicSpline
        __init__(IMP::core::OpenCubicSpline self, IMP::Floats const & values, IMP::Float minrange, IMP::Float spacing) -> OpenCubicSpline
        """
        this = _IMP_core.new_OpenCubicSpline(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self):
        """__str__(OpenCubicSpline self) -> std::string"""
        return _IMP_core.OpenCubicSpline___str__(self)

    def __repr__(self):
        """__repr__(OpenCubicSpline self) -> std::string"""
        return _IMP_core.OpenCubicSpline___repr__(self)

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

    __swig_destroy__ = _IMP_core.delete_OpenCubicSpline
    __del__ = lambda self : None;
OpenCubicSpline_swigregister = _IMP_core.OpenCubicSpline_swigregister
OpenCubicSpline_swigregister(OpenCubicSpline)

class QuadraticClosePairsFinder(ClosePairsFinder):
    """Proxy of C++ IMP::core::QuadraticClosePairsFinder class"""
    __swig_setmethods__ = {}
    for _s in [ClosePairsFinder]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, QuadraticClosePairsFinder, name, value)
    __swig_getmethods__ = {}
    for _s in [ClosePairsFinder]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, QuadraticClosePairsFinder, name)
    def __init__(self): 
        """__init__(IMP::core::QuadraticClosePairsFinder self) -> QuadraticClosePairsFinder"""
        this = _IMP_core.new_QuadraticClosePairsFinder()
        try: self.this.append(this)
        except: self.this = this
    def get_are_close(self, *args):
        """get_are_close(QuadraticClosePairsFinder self, Particle a, Particle b) -> bool"""
        return _IMP_core.QuadraticClosePairsFinder_get_are_close(self, *args)

    def get_close_pairs(self, *args):
        """
        get_close_pairs(QuadraticClosePairsFinder self, IMP::kernel::ParticlesTemp const & pa) -> IMP::kernel::ParticlePairsTemp
        get_close_pairs(QuadraticClosePairsFinder self, IMP::kernel::ParticlesTemp const & pa, IMP::kernel::ParticlesTemp const & pb) -> IMP::kernel::ParticlePairsTemp
        get_close_pairs(QuadraticClosePairsFinder self, IMP::algebra::BoundingBox3Ds const & bbs) -> IMP::IntPairs
        get_close_pairs(QuadraticClosePairsFinder self, IMP::algebra::BoundingBox3Ds const & bas, IMP::algebra::BoundingBox3Ds const & bbs) -> IMP::IntPairs
        """
        return _IMP_core.QuadraticClosePairsFinder_get_close_pairs(self, *args)

    def get_version_info(self):
        """get_version_info(QuadraticClosePairsFinder self) -> VersionInfo"""
        return _IMP_core.QuadraticClosePairsFinder_get_version_info(self)

    def do_show(self, *args):
        """do_show(QuadraticClosePairsFinder self, _ostream out)"""
        return _IMP_core.QuadraticClosePairsFinder_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_QuadraticClosePairsFinder
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(QuadraticClosePairsFinder self) -> std::string"""
        return _IMP_core.QuadraticClosePairsFinder___str__(self)

    def __repr__(self):
        """__repr__(QuadraticClosePairsFinder self) -> std::string"""
        return _IMP_core.QuadraticClosePairsFinder___repr__(self)

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

QuadraticClosePairsFinder_swigregister = _IMP_core.QuadraticClosePairsFinder_swigregister
QuadraticClosePairsFinder_swigregister(QuadraticClosePairsFinder)

class RefinedPairsPairScore(IMP.kernel.PairScore):
    """Proxy of C++ IMP::core::RefinedPairsPairScore class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.PairScore]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RefinedPairsPairScore, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.PairScore]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RefinedPairsPairScore, name)
    def __init__(self, *args): 
        """__init__(IMP::core::RefinedPairsPairScore self, Refiner r, PairScore f) -> RefinedPairsPairScore"""
        this = _IMP_core.new_RefinedPairsPairScore(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(RefinedPairsPairScore self) -> VersionInfo"""
        return _IMP_core.RefinedPairsPairScore_get_version_info(self)

    def do_show(self, *args):
        """do_show(RefinedPairsPairScore self, _ostream out)"""
        return _IMP_core.RefinedPairsPairScore_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_RefinedPairsPairScore
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(RefinedPairsPairScore self) -> std::string"""
        return _IMP_core.RefinedPairsPairScore___str__(self)

    def __repr__(self):
        """__repr__(RefinedPairsPairScore self) -> std::string"""
        return _IMP_core.RefinedPairsPairScore___repr__(self)

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

RefinedPairsPairScore_swigregister = _IMP_core.RefinedPairsPairScore_swigregister
RefinedPairsPairScore_swigregister(RefinedPairsPairScore)

class RigidBody(XYZ):
    """Proxy of C++ IMP::core::RigidBody class"""
    __swig_setmethods__ = {}
    for _s in [XYZ]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RigidBody, name, value)
    __swig_getmethods__ = {}
    for _s in [XYZ]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RigidBody, name)
    def get_members(self):
        """get_members(RigidBody self) -> IMP::core::RigidMembers"""
        return _IMP_core.RigidBody_get_members(self)

    def get_member_particle_indexes(self):
        """get_member_particle_indexes(RigidBody self) -> IMP::kernel::ParticleIndexes const &"""
        return _IMP_core.RigidBody_get_member_particle_indexes(self)

    def get_body_member_particle_indexes(self):
        """get_body_member_particle_indexes(RigidBody self) -> IMP::kernel::ParticleIndexes const &"""
        return _IMP_core.RigidBody_get_body_member_particle_indexes(self)

    def __init__(self, *args): 
        """
        __init__(IMP::core::RigidBody self) -> RigidBody
        __init__(IMP::core::RigidBody self, Model m, IMP::kernel::ParticleIndex id) -> RigidBody
        __init__(IMP::core::RigidBody self, Particle p) -> RigidBody
        """
        this = _IMP_core.new_RigidBody(*args)
        try: self.this.append(this)
        except: self.this = this
    def decorate_particle(*args):
        """decorate_particle(Particle p) -> RigidBody"""
        return _IMP_core.RigidBody_decorate_particle(*args)

    if _newclass:decorate_particle = staticmethod(decorate_particle)
    __swig_getmethods__["decorate_particle"] = lambda x: decorate_particle
    def show(self, *args):
        """
        show(RigidBody self, _ostream out=std::cout)
        show(RigidBody self)
        """
        return _IMP_core.RigidBody_show(self, *args)

    def setup_particle(*args):
        """
        setup_particle(Particle p, IMP::kernel::ParticlesTemp const & ps) -> RigidBody
        setup_particle(Particle p, ReferenceFrame3D rf) -> RigidBody
        """
        return _IMP_core.RigidBody_setup_particle(*args)

    if _newclass:setup_particle = staticmethod(setup_particle)
    __swig_getmethods__["setup_particle"] = lambda x: setup_particle
    def teardown_particle(*args):
        """teardown_particle(RigidBody rb)"""
        return _IMP_core.RigidBody_teardown_particle(*args)

    if _newclass:teardown_particle = staticmethod(teardown_particle)
    __swig_getmethods__["teardown_particle"] = lambda x: teardown_particle
    __swig_destroy__ = _IMP_core.delete_RigidBody
    __del__ = lambda self : None;
    def particle_is_instance(*args):
        """
        particle_is_instance(Particle p) -> bool
        particle_is_instance(Model m, IMP::kernel::ParticleIndex pi) -> bool
        """
        return _IMP_core.RigidBody_particle_is_instance(*args)

    if _newclass:particle_is_instance = staticmethod(particle_is_instance)
    __swig_getmethods__["particle_is_instance"] = lambda x: particle_is_instance
    def get_coordinates(self):
        """get_coordinates(RigidBody self) -> Vector3D"""
        return _IMP_core.RigidBody_get_coordinates(self)

    def get_reference_frame(self):
        """get_reference_frame(RigidBody self) -> ReferenceFrame3D"""
        return _IMP_core.RigidBody_get_reference_frame(self)

    def set_reference_frame(self, *args):
        """set_reference_frame(RigidBody self, ReferenceFrame3D tr)"""
        return _IMP_core.RigidBody_set_reference_frame(self, *args)

    def set_reference_frame_lazy(self, *args):
        """set_reference_frame_lazy(RigidBody self, ReferenceFrame3D tr)"""
        return _IMP_core.RigidBody_set_reference_frame_lazy(self, *args)

    def set_reference_frame_from_members(self, *args):
        """set_reference_frame_from_members(RigidBody self, IMP::kernel::ParticleIndexes const & members)"""
        return _IMP_core.RigidBody_set_reference_frame_from_members(self, *args)

    def add_to_derivatives(self, *args):
        """
        add_to_derivatives(RigidBody self, Vector3D derivative, Vector3D local_location, DerivativeAccumulator da)
        add_to_derivatives(RigidBody self, Vector3D derivative, Vector3D global_derivative, Vector3D local_location, Rotation3D rot, 
            DerivativeAccumulator da)
        """
        return _IMP_core.RigidBody_add_to_derivatives(self, *args)

    def get_torque(self):
        """get_torque(RigidBody self) -> Vector3D"""
        return _IMP_core.RigidBody_get_torque(self)

    def get_coordinates_are_optimized(self):
        """get_coordinates_are_optimized(RigidBody self) -> bool"""
        return _IMP_core.RigidBody_get_coordinates_are_optimized(self)

    def set_coordinates_are_optimized(self, *args):
        """set_coordinates_are_optimized(RigidBody self, bool tf)"""
        return _IMP_core.RigidBody_set_coordinates_are_optimized(self, *args)

    def normalize_rotation(self):
        """normalize_rotation(RigidBody self)"""
        return _IMP_core.RigidBody_normalize_rotation(self)

    def update_members(self):
        """update_members(RigidBody self)"""
        return _IMP_core.RigidBody_update_members(self)

    def get_rotational_derivatives(self):
        """get_rotational_derivatives(RigidBody self) -> Vector4D"""
        return _IMP_core.RigidBody_get_rotational_derivatives(self)

    def get_number_of_members(self):
        """get_number_of_members(RigidBody self) -> unsigned int"""
        return _IMP_core.RigidBody_get_number_of_members(self)

    def get_member(self, *args):
        """get_member(RigidBody self, unsigned int i) -> RigidMember"""
        return _IMP_core.RigidBody_get_member(self, *args)

    def add_member(self, *args):
        """
        add_member(RigidBody self, Particle p)
        add_member(RigidBody self, IMP::kernel::ParticleIndex p)
        """
        return _IMP_core.RigidBody_add_member(self, *args)

    def add_non_rigid_member(self, *args):
        """add_non_rigid_member(RigidBody self, IMP::kernel::ParticleIndex pi)"""
        return _IMP_core.RigidBody_add_non_rigid_member(self, *args)

    def set_is_rigid_member(self, *args):
        """set_is_rigid_member(RigidBody self, IMP::kernel::ParticleIndex pi, bool tf)"""
        return _IMP_core.RigidBody_set_is_rigid_member(self, *args)

    def add_attribute(self, *args):
        """
        add_attribute(RigidBody self, FloatKey k, IMP::Float v, bool opt)
        add_attribute(RigidBody self, FloatKey a0, IMP::Float a1)
        add_attribute(RigidBody self, IntKey a0, IMP::Int a1)
        add_attribute(RigidBody self, StringKey a0, IMP::String a1)
        add_attribute(RigidBody self, ParticleIndexKey a0, Particle a1)
        add_attribute(RigidBody self, ObjectKey a0, IMP::Object * a1)
        """
        return _IMP_core.RigidBody_add_attribute(self, *args)

    def get_value(self, *args):
        """
        get_value(RigidBody self, FloatKey a0) -> IMP::Float
        get_value(RigidBody self, IntKey a0) -> IMP::Int
        get_value(RigidBody self, StringKey a0) -> IMP::String
        get_value(RigidBody self, ParticleIndexKey a0) -> Particle
        get_value(RigidBody self, ObjectKey a0) -> IMP::Object *
        """
        return _IMP_core.RigidBody_get_value(self, *args)

    def set_value(self, *args):
        """
        set_value(RigidBody self, FloatKey a0, IMP::Float a1)
        set_value(RigidBody self, IntKey a0, IMP::Int a1)
        set_value(RigidBody self, StringKey a0, IMP::String a1)
        set_value(RigidBody self, ParticleIndexKey a0, Particle a1)
        set_value(RigidBody self, ObjectKey a0, IMP::Object * a1)
        """
        return _IMP_core.RigidBody_set_value(self, *args)

    def remove_attribute(self, *args):
        """
        remove_attribute(RigidBody self, FloatKey a0)
        remove_attribute(RigidBody self, IntKey a0)
        remove_attribute(RigidBody self, StringKey a0)
        remove_attribute(RigidBody self, ParticleIndexKey a0)
        remove_attribute(RigidBody self, ObjectKey a0)
        """
        return _IMP_core.RigidBody_remove_attribute(self, *args)

    def has_attribute(self, *args):
        """
        has_attribute(RigidBody self, FloatKey a0) -> bool
        has_attribute(RigidBody self, IntKey a0) -> bool
        has_attribute(RigidBody self, StringKey a0) -> bool
        has_attribute(RigidBody self, ParticleIndexKey a0) -> bool
        has_attribute(RigidBody self, ObjectKey a0) -> bool
        """
        return _IMP_core.RigidBody_has_attribute(self, *args)

    def get_derivative(self, *args):
        """get_derivative(RigidBody self, FloatKey a0) -> double"""
        return _IMP_core.RigidBody_get_derivative(self, *args)

    def get_name(self):
        """get_name(RigidBody self) -> std::string"""
        return _IMP_core.RigidBody_get_name(self)

    def clear_caches(self):
        """clear_caches(RigidBody self)"""
        return _IMP_core.RigidBody_clear_caches(self)

    def set_name(self, *args):
        """set_name(RigidBody self, std::string a0)"""
        return _IMP_core.RigidBody_set_name(self, *args)

    def set_check_level(self, *args):
        """set_check_level(RigidBody self, IMP::base::CheckLevel a0)"""
        return _IMP_core.RigidBody_set_check_level(self, *args)

    def add_to_derivative(self, *args):
        """add_to_derivative(RigidBody self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_core.RigidBody_add_to_derivative(self, *args)

    def set_is_optimized(self, *args):
        """set_is_optimized(RigidBody self, FloatKey a0, bool a1)"""
        return _IMP_core.RigidBody_set_is_optimized(self, *args)

    def get_is_optimized(self, *args):
        """get_is_optimized(RigidBody self, FloatKey a0) -> bool"""
        return _IMP_core.RigidBody_get_is_optimized(self, *args)

    def get_check_level(self):
        """get_check_level(RigidBody self) -> IMP::base::CheckLevel"""
        return _IMP_core.RigidBody_get_check_level(self)

    def __eq__(self, *args):
        """
        __eq__(RigidBody self, RigidBody o) -> bool
        __eq__(RigidBody self, Particle d) -> bool
        """
        return _IMP_core.RigidBody___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(RigidBody self, RigidBody o) -> bool
        __ne__(RigidBody self, Particle d) -> bool
        """
        return _IMP_core.RigidBody___ne__(self, *args)

    def __le__(self, *args):
        """
        __le__(RigidBody self, RigidBody o) -> bool
        __le__(RigidBody self, Particle d) -> bool
        """
        return _IMP_core.RigidBody___le__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(RigidBody self, RigidBody o) -> bool
        __lt__(RigidBody self, Particle d) -> bool
        """
        return _IMP_core.RigidBody___lt__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(RigidBody self, RigidBody o) -> bool
        __ge__(RigidBody self, Particle d) -> bool
        """
        return _IMP_core.RigidBody___ge__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(RigidBody self, RigidBody o) -> bool
        __gt__(RigidBody self, Particle d) -> bool
        """
        return _IMP_core.RigidBody___gt__(self, *args)

    def __str__(self):
        """__str__(RigidBody self) -> std::string"""
        return _IMP_core.RigidBody___str__(self)

    def __repr__(self):
        """__repr__(RigidBody self) -> std::string"""
        return _IMP_core.RigidBody___repr__(self)

RigidBody_swigregister = _IMP_core.RigidBody_swigregister
RigidBody_swigregister(RigidBody)

def RigidBody_decorate_particle(*args):
  """RigidBody_decorate_particle(Particle p) -> RigidBody"""
  return _IMP_core.RigidBody_decorate_particle(*args)

def RigidBody_setup_particle(*args):
  """
    setup_particle(Particle p, IMP::kernel::ParticlesTemp const & ps) -> RigidBody
    RigidBody_setup_particle(Particle p, ReferenceFrame3D rf) -> RigidBody
    """
  return _IMP_core.RigidBody_setup_particle(*args)

def RigidBody_teardown_particle(*args):
  """RigidBody_teardown_particle(RigidBody rb)"""
  return _IMP_core.RigidBody_teardown_particle(*args)

def RigidBody_particle_is_instance(*args):
  """
    particle_is_instance(Particle p) -> bool
    RigidBody_particle_is_instance(Model m, IMP::kernel::ParticleIndex pi) -> bool
    """
  return _IMP_core.RigidBody_particle_is_instance(*args)


def add_rigid_body_cache_key(*args):
  """add_rigid_body_cache_key(ObjectKey k)"""
  return _IMP_core.add_rigid_body_cache_key(*args)
class RigidMember(XYZ):
    """Proxy of C++ IMP::core::RigidMember class"""
    __swig_setmethods__ = {}
    for _s in [XYZ]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RigidMember, name, value)
    __swig_getmethods__ = {}
    for _s in [XYZ]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RigidMember, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::RigidMember self) -> RigidMember
        __init__(IMP::core::RigidMember self, Model m, IMP::kernel::ParticleIndex id) -> RigidMember
        __init__(IMP::core::RigidMember self, Particle p) -> RigidMember
        """
        this = _IMP_core.new_RigidMember(*args)
        try: self.this.append(this)
        except: self.this = this
    def decorate_particle(*args):
        """decorate_particle(Particle p) -> RigidMember"""
        return _IMP_core.RigidMember_decorate_particle(*args)

    if _newclass:decorate_particle = staticmethod(decorate_particle)
    __swig_getmethods__["decorate_particle"] = lambda x: decorate_particle
    def show(self, *args):
        """
        show(RigidMember self, _ostream out=std::cout)
        show(RigidMember self)
        """
        return _IMP_core.RigidMember_show(self, *args)

    def get_rigid_body(self):
        """get_rigid_body(RigidMember self) -> RigidBody"""
        return _IMP_core.RigidMember_get_rigid_body(self)

    def get_internal_coordinates(self):
        """get_internal_coordinates(RigidMember self) -> Vector3D"""
        return _IMP_core.RigidMember_get_internal_coordinates(self)

    def set_internal_coordinates(self, *args):
        """set_internal_coordinates(RigidMember self, Vector3D v)"""
        return _IMP_core.RigidMember_set_internal_coordinates(self, *args)

    def set_internal_transformation(self, *args):
        """set_internal_transformation(RigidMember self, Transformation3D v)"""
        return _IMP_core.RigidMember_set_internal_transformation(self, *args)

    def get_internal_transformation(self):
        """get_internal_transformation(RigidMember self) -> Transformation3D"""
        return _IMP_core.RigidMember_get_internal_transformation(self)

    def set_coordinates(self, *args):
        """
        set_coordinates(RigidMember self, Vector3D center)
        set_coordinates(RigidMember self, Transformation3D tr)
        """
        return _IMP_core.RigidMember_set_coordinates(self, *args)

    __swig_destroy__ = _IMP_core.delete_RigidMember
    __del__ = lambda self : None;
    def particle_is_instance(*args):
        """
        particle_is_instance(Particle p) -> bool
        particle_is_instance(Model m, IMP::kernel::ParticleIndex p) -> bool
        """
        return _IMP_core.RigidMember_particle_is_instance(*args)

    if _newclass:particle_is_instance = staticmethod(particle_is_instance)
    __swig_getmethods__["particle_is_instance"] = lambda x: particle_is_instance
    def get_internal_coordinate_keys():
        """get_internal_coordinate_keys() -> IMP::kernel::FloatKeys"""
        return _IMP_core.RigidMember_get_internal_coordinate_keys()

    if _newclass:get_internal_coordinate_keys = staticmethod(get_internal_coordinate_keys)
    __swig_getmethods__["get_internal_coordinate_keys"] = lambda x: get_internal_coordinate_keys
    def add_attribute(self, *args):
        """
        add_attribute(RigidMember self, FloatKey k, IMP::Float v, bool opt)
        add_attribute(RigidMember self, FloatKey a0, IMP::Float a1)
        add_attribute(RigidMember self, IntKey a0, IMP::Int a1)
        add_attribute(RigidMember self, StringKey a0, IMP::String a1)
        add_attribute(RigidMember self, ParticleIndexKey a0, Particle a1)
        add_attribute(RigidMember self, ObjectKey a0, IMP::Object * a1)
        """
        return _IMP_core.RigidMember_add_attribute(self, *args)

    def get_value(self, *args):
        """
        get_value(RigidMember self, FloatKey a0) -> IMP::Float
        get_value(RigidMember self, IntKey a0) -> IMP::Int
        get_value(RigidMember self, StringKey a0) -> IMP::String
        get_value(RigidMember self, ParticleIndexKey a0) -> Particle
        get_value(RigidMember self, ObjectKey a0) -> IMP::Object *
        """
        return _IMP_core.RigidMember_get_value(self, *args)

    def set_value(self, *args):
        """
        set_value(RigidMember self, FloatKey a0, IMP::Float a1)
        set_value(RigidMember self, IntKey a0, IMP::Int a1)
        set_value(RigidMember self, StringKey a0, IMP::String a1)
        set_value(RigidMember self, ParticleIndexKey a0, Particle a1)
        set_value(RigidMember self, ObjectKey a0, IMP::Object * a1)
        """
        return _IMP_core.RigidMember_set_value(self, *args)

    def remove_attribute(self, *args):
        """
        remove_attribute(RigidMember self, FloatKey a0)
        remove_attribute(RigidMember self, IntKey a0)
        remove_attribute(RigidMember self, StringKey a0)
        remove_attribute(RigidMember self, ParticleIndexKey a0)
        remove_attribute(RigidMember self, ObjectKey a0)
        """
        return _IMP_core.RigidMember_remove_attribute(self, *args)

    def has_attribute(self, *args):
        """
        has_attribute(RigidMember self, FloatKey a0) -> bool
        has_attribute(RigidMember self, IntKey a0) -> bool
        has_attribute(RigidMember self, StringKey a0) -> bool
        has_attribute(RigidMember self, ParticleIndexKey a0) -> bool
        has_attribute(RigidMember self, ObjectKey a0) -> bool
        """
        return _IMP_core.RigidMember_has_attribute(self, *args)

    def get_derivative(self, *args):
        """get_derivative(RigidMember self, FloatKey a0) -> double"""
        return _IMP_core.RigidMember_get_derivative(self, *args)

    def get_name(self):
        """get_name(RigidMember self) -> std::string"""
        return _IMP_core.RigidMember_get_name(self)

    def clear_caches(self):
        """clear_caches(RigidMember self)"""
        return _IMP_core.RigidMember_clear_caches(self)

    def set_name(self, *args):
        """set_name(RigidMember self, std::string a0)"""
        return _IMP_core.RigidMember_set_name(self, *args)

    def set_check_level(self, *args):
        """set_check_level(RigidMember self, IMP::base::CheckLevel a0)"""
        return _IMP_core.RigidMember_set_check_level(self, *args)

    def add_to_derivative(self, *args):
        """add_to_derivative(RigidMember self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_core.RigidMember_add_to_derivative(self, *args)

    def set_is_optimized(self, *args):
        """set_is_optimized(RigidMember self, FloatKey a0, bool a1)"""
        return _IMP_core.RigidMember_set_is_optimized(self, *args)

    def get_is_optimized(self, *args):
        """get_is_optimized(RigidMember self, FloatKey a0) -> bool"""
        return _IMP_core.RigidMember_get_is_optimized(self, *args)

    def get_check_level(self):
        """get_check_level(RigidMember self) -> IMP::base::CheckLevel"""
        return _IMP_core.RigidMember_get_check_level(self)

    def __eq__(self, *args):
        """
        __eq__(RigidMember self, RigidMember o) -> bool
        __eq__(RigidMember self, Particle d) -> bool
        """
        return _IMP_core.RigidMember___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(RigidMember self, RigidMember o) -> bool
        __ne__(RigidMember self, Particle d) -> bool
        """
        return _IMP_core.RigidMember___ne__(self, *args)

    def __le__(self, *args):
        """
        __le__(RigidMember self, RigidMember o) -> bool
        __le__(RigidMember self, Particle d) -> bool
        """
        return _IMP_core.RigidMember___le__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(RigidMember self, RigidMember o) -> bool
        __lt__(RigidMember self, Particle d) -> bool
        """
        return _IMP_core.RigidMember___lt__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(RigidMember self, RigidMember o) -> bool
        __ge__(RigidMember self, Particle d) -> bool
        """
        return _IMP_core.RigidMember___ge__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(RigidMember self, RigidMember o) -> bool
        __gt__(RigidMember self, Particle d) -> bool
        """
        return _IMP_core.RigidMember___gt__(self, *args)

    def __str__(self):
        """__str__(RigidMember self) -> std::string"""
        return _IMP_core.RigidMember___str__(self)

    def __repr__(self):
        """__repr__(RigidMember self) -> std::string"""
        return _IMP_core.RigidMember___repr__(self)

RigidMember_swigregister = _IMP_core.RigidMember_swigregister
RigidMember_swigregister(RigidMember)

def RigidMember_decorate_particle(*args):
  """RigidMember_decorate_particle(Particle p) -> RigidMember"""
  return _IMP_core.RigidMember_decorate_particle(*args)

def RigidMember_particle_is_instance(*args):
  """
    particle_is_instance(Particle p) -> bool
    RigidMember_particle_is_instance(Model m, IMP::kernel::ParticleIndex p) -> bool
    """
  return _IMP_core.RigidMember_particle_is_instance(*args)

def RigidMember_get_internal_coordinate_keys():
  """RigidMember_get_internal_coordinate_keys() -> IMP::kernel::FloatKeys"""
  return _IMP_core.RigidMember_get_internal_coordinate_keys()

class NonRigidMember(XYZ):
    """Proxy of C++ IMP::core::NonRigidMember class"""
    __swig_setmethods__ = {}
    for _s in [XYZ]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NonRigidMember, name, value)
    __swig_getmethods__ = {}
    for _s in [XYZ]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NonRigidMember, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::NonRigidMember self) -> NonRigidMember
        __init__(IMP::core::NonRigidMember self, Model m, IMP::kernel::ParticleIndex id) -> NonRigidMember
        __init__(IMP::core::NonRigidMember self, Particle p) -> NonRigidMember
        """
        this = _IMP_core.new_NonRigidMember(*args)
        try: self.this.append(this)
        except: self.this = this
    def decorate_particle(*args):
        """decorate_particle(Particle p) -> NonRigidMember"""
        return _IMP_core.NonRigidMember_decorate_particle(*args)

    if _newclass:decorate_particle = staticmethod(decorate_particle)
    __swig_getmethods__["decorate_particle"] = lambda x: decorate_particle
    def show(self, *args):
        """
        show(NonRigidMember self, _ostream out=std::cout)
        show(NonRigidMember self)
        """
        return _IMP_core.NonRigidMember_show(self, *args)

    def get_rigid_body(self):
        """get_rigid_body(NonRigidMember self) -> RigidBody"""
        return _IMP_core.NonRigidMember_get_rigid_body(self)

    def get_internal_coordinates(self):
        """get_internal_coordinates(NonRigidMember self) -> Vector3D"""
        return _IMP_core.NonRigidMember_get_internal_coordinates(self)

    def set_internal_coordinates(self, *args):
        """set_internal_coordinates(NonRigidMember self, Vector3D v)"""
        return _IMP_core.NonRigidMember_set_internal_coordinates(self, *args)

    def set_internal_transformation(self, *args):
        """set_internal_transformation(NonRigidMember self, Transformation3D v)"""
        return _IMP_core.NonRigidMember_set_internal_transformation(self, *args)

    def get_internal_transformation(self):
        """get_internal_transformation(NonRigidMember self) -> Transformation3D"""
        return _IMP_core.NonRigidMember_get_internal_transformation(self)

    def set_coordinates(self, *args):
        """
        set_coordinates(NonRigidMember self, Vector3D center)
        set_coordinates(NonRigidMember self, Transformation3D tr)
        """
        return _IMP_core.NonRigidMember_set_coordinates(self, *args)

    __swig_destroy__ = _IMP_core.delete_NonRigidMember
    __del__ = lambda self : None;
    def particle_is_instance(*args):
        """
        particle_is_instance(Particle p) -> bool
        particle_is_instance(Model m, IMP::kernel::ParticleIndex p) -> bool
        """
        return _IMP_core.NonRigidMember_particle_is_instance(*args)

    if _newclass:particle_is_instance = staticmethod(particle_is_instance)
    __swig_getmethods__["particle_is_instance"] = lambda x: particle_is_instance
    def get_internal_coordinate_keys():
        """get_internal_coordinate_keys() -> IMP::kernel::FloatKeys"""
        return _IMP_core.NonRigidMember_get_internal_coordinate_keys()

    if _newclass:get_internal_coordinate_keys = staticmethod(get_internal_coordinate_keys)
    __swig_getmethods__["get_internal_coordinate_keys"] = lambda x: get_internal_coordinate_keys
    def add_attribute(self, *args):
        """
        add_attribute(NonRigidMember self, FloatKey k, IMP::Float v, bool opt)
        add_attribute(NonRigidMember self, FloatKey a0, IMP::Float a1)
        add_attribute(NonRigidMember self, IntKey a0, IMP::Int a1)
        add_attribute(NonRigidMember self, StringKey a0, IMP::String a1)
        add_attribute(NonRigidMember self, ParticleIndexKey a0, Particle a1)
        add_attribute(NonRigidMember self, ObjectKey a0, IMP::Object * a1)
        """
        return _IMP_core.NonRigidMember_add_attribute(self, *args)

    def get_value(self, *args):
        """
        get_value(NonRigidMember self, FloatKey a0) -> IMP::Float
        get_value(NonRigidMember self, IntKey a0) -> IMP::Int
        get_value(NonRigidMember self, StringKey a0) -> IMP::String
        get_value(NonRigidMember self, ParticleIndexKey a0) -> Particle
        get_value(NonRigidMember self, ObjectKey a0) -> IMP::Object *
        """
        return _IMP_core.NonRigidMember_get_value(self, *args)

    def set_value(self, *args):
        """
        set_value(NonRigidMember self, FloatKey a0, IMP::Float a1)
        set_value(NonRigidMember self, IntKey a0, IMP::Int a1)
        set_value(NonRigidMember self, StringKey a0, IMP::String a1)
        set_value(NonRigidMember self, ParticleIndexKey a0, Particle a1)
        set_value(NonRigidMember self, ObjectKey a0, IMP::Object * a1)
        """
        return _IMP_core.NonRigidMember_set_value(self, *args)

    def remove_attribute(self, *args):
        """
        remove_attribute(NonRigidMember self, FloatKey a0)
        remove_attribute(NonRigidMember self, IntKey a0)
        remove_attribute(NonRigidMember self, StringKey a0)
        remove_attribute(NonRigidMember self, ParticleIndexKey a0)
        remove_attribute(NonRigidMember self, ObjectKey a0)
        """
        return _IMP_core.NonRigidMember_remove_attribute(self, *args)

    def has_attribute(self, *args):
        """
        has_attribute(NonRigidMember self, FloatKey a0) -> bool
        has_attribute(NonRigidMember self, IntKey a0) -> bool
        has_attribute(NonRigidMember self, StringKey a0) -> bool
        has_attribute(NonRigidMember self, ParticleIndexKey a0) -> bool
        has_attribute(NonRigidMember self, ObjectKey a0) -> bool
        """
        return _IMP_core.NonRigidMember_has_attribute(self, *args)

    def get_derivative(self, *args):
        """get_derivative(NonRigidMember self, FloatKey a0) -> double"""
        return _IMP_core.NonRigidMember_get_derivative(self, *args)

    def get_name(self):
        """get_name(NonRigidMember self) -> std::string"""
        return _IMP_core.NonRigidMember_get_name(self)

    def clear_caches(self):
        """clear_caches(NonRigidMember self)"""
        return _IMP_core.NonRigidMember_clear_caches(self)

    def set_name(self, *args):
        """set_name(NonRigidMember self, std::string a0)"""
        return _IMP_core.NonRigidMember_set_name(self, *args)

    def set_check_level(self, *args):
        """set_check_level(NonRigidMember self, IMP::base::CheckLevel a0)"""
        return _IMP_core.NonRigidMember_set_check_level(self, *args)

    def add_to_derivative(self, *args):
        """add_to_derivative(NonRigidMember self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_core.NonRigidMember_add_to_derivative(self, *args)

    def set_is_optimized(self, *args):
        """set_is_optimized(NonRigidMember self, FloatKey a0, bool a1)"""
        return _IMP_core.NonRigidMember_set_is_optimized(self, *args)

    def get_is_optimized(self, *args):
        """get_is_optimized(NonRigidMember self, FloatKey a0) -> bool"""
        return _IMP_core.NonRigidMember_get_is_optimized(self, *args)

    def get_check_level(self):
        """get_check_level(NonRigidMember self) -> IMP::base::CheckLevel"""
        return _IMP_core.NonRigidMember_get_check_level(self)

    def __eq__(self, *args):
        """
        __eq__(NonRigidMember self, NonRigidMember o) -> bool
        __eq__(NonRigidMember self, Particle d) -> bool
        """
        return _IMP_core.NonRigidMember___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(NonRigidMember self, NonRigidMember o) -> bool
        __ne__(NonRigidMember self, Particle d) -> bool
        """
        return _IMP_core.NonRigidMember___ne__(self, *args)

    def __le__(self, *args):
        """
        __le__(NonRigidMember self, NonRigidMember o) -> bool
        __le__(NonRigidMember self, Particle d) -> bool
        """
        return _IMP_core.NonRigidMember___le__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(NonRigidMember self, NonRigidMember o) -> bool
        __lt__(NonRigidMember self, Particle d) -> bool
        """
        return _IMP_core.NonRigidMember___lt__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(NonRigidMember self, NonRigidMember o) -> bool
        __ge__(NonRigidMember self, Particle d) -> bool
        """
        return _IMP_core.NonRigidMember___ge__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(NonRigidMember self, NonRigidMember o) -> bool
        __gt__(NonRigidMember self, Particle d) -> bool
        """
        return _IMP_core.NonRigidMember___gt__(self, *args)

    def __str__(self):
        """__str__(NonRigidMember self) -> std::string"""
        return _IMP_core.NonRigidMember___str__(self)

    def __repr__(self):
        """__repr__(NonRigidMember self) -> std::string"""
        return _IMP_core.NonRigidMember___repr__(self)

NonRigidMember_swigregister = _IMP_core.NonRigidMember_swigregister
NonRigidMember_swigregister(NonRigidMember)

def NonRigidMember_decorate_particle(*args):
  """NonRigidMember_decorate_particle(Particle p) -> NonRigidMember"""
  return _IMP_core.NonRigidMember_decorate_particle(*args)

def NonRigidMember_particle_is_instance(*args):
  """
    particle_is_instance(Particle p) -> bool
    NonRigidMember_particle_is_instance(Model m, IMP::kernel::ParticleIndex p) -> bool
    """
  return _IMP_core.NonRigidMember_particle_is_instance(*args)

def NonRigidMember_get_internal_coordinate_keys():
  """NonRigidMember_get_internal_coordinate_keys() -> IMP::kernel::FloatKeys"""
  return _IMP_core.NonRigidMember_get_internal_coordinate_keys()

class RigidMembersRefiner(IMP.kernel.Refiner):
    """Proxy of C++ IMP::core::RigidMembersRefiner class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Refiner]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RigidMembersRefiner, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Refiner]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RigidMembersRefiner, name)
    def __init__(self, name="RigidMembersRefiner%d"): 
        """
        __init__(IMP::core::RigidMembersRefiner self, std::string name="RigidMembersRefiner%d") -> RigidMembersRefiner
        __init__(IMP::core::RigidMembersRefiner self) -> RigidMembersRefiner
        """
        this = _IMP_core.new_RigidMembersRefiner(name)
        try: self.this.append(this)
        except: self.this = this
    def get_refined(self, *args):
        """
        get_refined(RigidMembersRefiner self, Particle arg2, unsigned int arg3) -> Particle
        get_refined(RigidMembersRefiner self, Particle a) -> IMP::kernel::ParticlesTemp const
        """
        return _IMP_core.RigidMembersRefiner_get_refined(self, *args)

    def get_input_particles(self, *args):
        """get_input_particles(RigidMembersRefiner self, Particle arg2) -> IMP::kernel::ParticlesTemp"""
        return _IMP_core.RigidMembersRefiner_get_input_particles(self, *args)

    def get_input_containers(self, *args):
        """get_input_containers(RigidMembersRefiner self, Particle arg2) -> IMP::kernel::ContainersTemp"""
        return _IMP_core.RigidMembersRefiner_get_input_containers(self, *args)

    def get_version_info(self):
        """get_version_info(RigidMembersRefiner self) -> VersionInfo"""
        return _IMP_core.RigidMembersRefiner_get_version_info(self)

    def do_show(self, *args):
        """do_show(RigidMembersRefiner self, _ostream out)"""
        return _IMP_core.RigidMembersRefiner_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_RigidMembersRefiner
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(RigidMembersRefiner self) -> std::string"""
        return _IMP_core.RigidMembersRefiner___str__(self)

    def __repr__(self):
        """__repr__(RigidMembersRefiner self) -> std::string"""
        return _IMP_core.RigidMembersRefiner___repr__(self)

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

RigidMembersRefiner_swigregister = _IMP_core.RigidMembersRefiner_swigregister
RigidMembersRefiner_swigregister(RigidMembersRefiner)


def get_rigid_members_refiner():
  """get_rigid_members_refiner() -> RigidMembersRefiner"""
  return _IMP_core.get_rigid_members_refiner()

def transform(*args):
  """
    transform(XYZ a, Transformation3D tr)
    transform(RigidBody a, Transformation3D tr)
    """
  return _IMP_core.transform(*args)

def get_initial_reference_frame(*args):
  """get_initial_reference_frame(IMP::kernel::ParticlesTemp const & ps) -> ReferenceFrame3D"""
  return _IMP_core.get_initial_reference_frame(*args)

def create_rigid_bodies(*args):
  """
    create_rigid_bodies(Model m, unsigned int n, bool no_members=False) -> IMP::kernel::ParticlesTemp
    create_rigid_bodies(Model m, unsigned int n) -> IMP::kernel::ParticlesTemp
    """
  return _IMP_core.create_rigid_bodies(*args)
class RigidBodyHierarchyGeometry(IMP.display.SingletonGeometry):
    """Proxy of C++ IMP::core::RigidBodyHierarchyGeometry class"""
    __swig_setmethods__ = {}
    for _s in [IMP.display.SingletonGeometry]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RigidBodyHierarchyGeometry, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.display.SingletonGeometry]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RigidBodyHierarchyGeometry, name)
    def __init__(self, *args): 
        """__init__(IMP::core::RigidBodyHierarchyGeometry self, RigidBody rb, IMP::kernel::ParticlesTemp const & constituents) -> RigidBodyHierarchyGeometry"""
        this = _IMP_core.new_RigidBodyHierarchyGeometry(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(RigidBodyHierarchyGeometry self) -> VersionInfo"""
        return _IMP_core.RigidBodyHierarchyGeometry_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_RigidBodyHierarchyGeometry
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(RigidBodyHierarchyGeometry self) -> std::string"""
        return _IMP_core.RigidBodyHierarchyGeometry___str__(self)

    def __repr__(self):
        """__repr__(RigidBodyHierarchyGeometry self) -> std::string"""
        return _IMP_core.RigidBodyHierarchyGeometry___repr__(self)

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

RigidBodyHierarchyGeometry_swigregister = _IMP_core.RigidBodyHierarchyGeometry_swigregister
RigidBodyHierarchyGeometry_swigregister(RigidBodyHierarchyGeometry)

class RigidBodyDerivativeGeometry(IMP.display.SingletonGeometry):
    """Proxy of C++ IMP::core::RigidBodyDerivativeGeometry class"""
    __swig_setmethods__ = {}
    for _s in [IMP.display.SingletonGeometry]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RigidBodyDerivativeGeometry, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.display.SingletonGeometry]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RigidBodyDerivativeGeometry, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::RigidBodyDerivativeGeometry self, Particle p) -> RigidBodyDerivativeGeometry
        __init__(IMP::core::RigidBodyDerivativeGeometry self, RigidBody d) -> RigidBodyDerivativeGeometry
        """
        this = _IMP_core.new_RigidBodyDerivativeGeometry(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(RigidBodyDerivativeGeometry self) -> VersionInfo"""
        return _IMP_core.RigidBodyDerivativeGeometry_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_RigidBodyDerivativeGeometry
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(RigidBodyDerivativeGeometry self) -> std::string"""
        return _IMP_core.RigidBodyDerivativeGeometry___str__(self)

    def __repr__(self):
        """__repr__(RigidBodyDerivativeGeometry self) -> std::string"""
        return _IMP_core.RigidBodyDerivativeGeometry___repr__(self)

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

RigidBodyDerivativeGeometry_swigregister = _IMP_core.RigidBodyDerivativeGeometry_swigregister
RigidBodyDerivativeGeometry_swigregister(RigidBodyDerivativeGeometry)

class RigidBodyDerivativesGeometry(IMP.display.SingletonsGeometry):
    """Proxy of C++ IMP::core::RigidBodyDerivativesGeometry class"""
    __swig_setmethods__ = {}
    for _s in [IMP.display.SingletonsGeometry]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RigidBodyDerivativesGeometry, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.display.SingletonsGeometry]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RigidBodyDerivativesGeometry, name)
    def __init__(self, *args): 
        """__init__(IMP::core::RigidBodyDerivativesGeometry self, SingletonContainer sc) -> RigidBodyDerivativesGeometry"""
        this = _IMP_core.new_RigidBodyDerivativesGeometry(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(RigidBodyDerivativesGeometry self) -> VersionInfo"""
        return _IMP_core.RigidBodyDerivativesGeometry_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_RigidBodyDerivativesGeometry
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(RigidBodyDerivativesGeometry self) -> std::string"""
        return _IMP_core.RigidBodyDerivativesGeometry___str__(self)

    def __repr__(self):
        """__repr__(RigidBodyDerivativesGeometry self) -> std::string"""
        return _IMP_core.RigidBodyDerivativesGeometry___repr__(self)

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

RigidBodyDerivativesGeometry_swigregister = _IMP_core.RigidBodyDerivativesGeometry_swigregister
RigidBodyDerivativesGeometry_swigregister(RigidBodyDerivativesGeometry)

class RigidBodyFrameGeometry(IMP.display.SingletonGeometry):
    """Proxy of C++ IMP::core::RigidBodyFrameGeometry class"""
    __swig_setmethods__ = {}
    for _s in [IMP.display.SingletonGeometry]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RigidBodyFrameGeometry, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.display.SingletonGeometry]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RigidBodyFrameGeometry, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::RigidBodyFrameGeometry self, Particle p) -> RigidBodyFrameGeometry
        __init__(IMP::core::RigidBodyFrameGeometry self, RigidBody d) -> RigidBodyFrameGeometry
        """
        this = _IMP_core.new_RigidBodyFrameGeometry(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(RigidBodyFrameGeometry self) -> VersionInfo"""
        return _IMP_core.RigidBodyFrameGeometry_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_RigidBodyFrameGeometry
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(RigidBodyFrameGeometry self) -> std::string"""
        return _IMP_core.RigidBodyFrameGeometry___str__(self)

    def __repr__(self):
        """__repr__(RigidBodyFrameGeometry self) -> std::string"""
        return _IMP_core.RigidBodyFrameGeometry___repr__(self)

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

RigidBodyFrameGeometry_swigregister = _IMP_core.RigidBodyFrameGeometry_swigregister
RigidBodyFrameGeometry_swigregister(RigidBodyFrameGeometry)

class RigidBodyFramesGeometry(IMP.display.SingletonsGeometry):
    """Proxy of C++ IMP::core::RigidBodyFramesGeometry class"""
    __swig_setmethods__ = {}
    for _s in [IMP.display.SingletonsGeometry]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RigidBodyFramesGeometry, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.display.SingletonsGeometry]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RigidBodyFramesGeometry, name)
    def __init__(self, *args): 
        """__init__(IMP::core::RigidBodyFramesGeometry self, SingletonContainer sc) -> RigidBodyFramesGeometry"""
        this = _IMP_core.new_RigidBodyFramesGeometry(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(RigidBodyFramesGeometry self) -> VersionInfo"""
        return _IMP_core.RigidBodyFramesGeometry_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_RigidBodyFramesGeometry
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(RigidBodyFramesGeometry self) -> std::string"""
        return _IMP_core.RigidBodyFramesGeometry___str__(self)

    def __repr__(self):
        """__repr__(RigidBodyFramesGeometry self) -> std::string"""
        return _IMP_core.RigidBodyFramesGeometry___repr__(self)

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

RigidBodyFramesGeometry_swigregister = _IMP_core.RigidBodyFramesGeometry_swigregister
RigidBodyFramesGeometry_swigregister(RigidBodyFramesGeometry)

class RigidBodyTorque(IMP.display.SegmentGeometry):
    """Proxy of C++ IMP::core::RigidBodyTorque class"""
    __swig_setmethods__ = {}
    for _s in [IMP.display.SegmentGeometry]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RigidBodyTorque, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.display.SegmentGeometry]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RigidBodyTorque, name)
    def __init__(self, *args): 
        """__init__(IMP::core::RigidBodyTorque self, Particle p) -> RigidBodyTorque"""
        this = _IMP_core.new_RigidBodyTorque(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self):
        """__str__(RigidBodyTorque self) -> std::string"""
        return _IMP_core.RigidBodyTorque___str__(self)

    def __repr__(self):
        """__repr__(RigidBodyTorque self) -> std::string"""
        return _IMP_core.RigidBodyTorque___repr__(self)

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

    __swig_destroy__ = _IMP_core.delete_RigidBodyTorque
    __del__ = lambda self : None;
RigidBodyTorque_swigregister = _IMP_core.RigidBodyTorque_swigregister
RigidBodyTorque_swigregister(RigidBodyTorque)

class NearestNeighborsClosePairsFinder(ClosePairsFinder):
    """Proxy of C++ IMP::core::NearestNeighborsClosePairsFinder class"""
    __swig_setmethods__ = {}
    for _s in [ClosePairsFinder]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NearestNeighborsClosePairsFinder, name, value)
    __swig_getmethods__ = {}
    for _s in [ClosePairsFinder]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NearestNeighborsClosePairsFinder, name)
    def __init__(self): 
        """__init__(IMP::core::NearestNeighborsClosePairsFinder self) -> NearestNeighborsClosePairsFinder"""
        this = _IMP_core.new_NearestNeighborsClosePairsFinder()
        try: self.this.append(this)
        except: self.this = this
    def get_close_pairs(self, *args):
        """
        get_close_pairs(NearestNeighborsClosePairsFinder self, IMP::kernel::ParticlesTemp const & pa) -> IMP::kernel::ParticlePairsTemp
        get_close_pairs(NearestNeighborsClosePairsFinder self, IMP::kernel::ParticlesTemp const & pa, IMP::kernel::ParticlesTemp const & pb) -> IMP::kernel::ParticlePairsTemp
        get_close_pairs(NearestNeighborsClosePairsFinder self, IMP::algebra::BoundingBox3Ds const & bbs) -> IMP::IntPairs
        get_close_pairs(NearestNeighborsClosePairsFinder self, IMP::algebra::BoundingBox3Ds const & bas, IMP::algebra::BoundingBox3Ds const & bbs) -> IMP::IntPairs
        """
        return _IMP_core.NearestNeighborsClosePairsFinder_get_close_pairs(self, *args)

    def get_version_info(self):
        """get_version_info(NearestNeighborsClosePairsFinder self) -> VersionInfo"""
        return _IMP_core.NearestNeighborsClosePairsFinder_get_version_info(self)

    def do_show(self, *args):
        """do_show(NearestNeighborsClosePairsFinder self, _ostream out)"""
        return _IMP_core.NearestNeighborsClosePairsFinder_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_NearestNeighborsClosePairsFinder
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(NearestNeighborsClosePairsFinder self) -> std::string"""
        return _IMP_core.NearestNeighborsClosePairsFinder___str__(self)

    def __repr__(self):
        """__repr__(NearestNeighborsClosePairsFinder self) -> std::string"""
        return _IMP_core.NearestNeighborsClosePairsFinder___repr__(self)

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

NearestNeighborsClosePairsFinder_swigregister = _IMP_core.NearestNeighborsClosePairsFinder_swigregister
NearestNeighborsClosePairsFinder_swigregister(NearestNeighborsClosePairsFinder)

class RestraintsScoringFunction(IMP.kernel.ScoringFunction):
    """Proxy of C++ IMP::core::RestraintsScoringFunction class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.ScoringFunction]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RestraintsScoringFunction, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.ScoringFunction]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RestraintsScoringFunction, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::RestraintsScoringFunction self, IMP::kernel::RestraintsTemp const & rs, double weight=1.0, double max=NO_MAX, std::string name="RestraintsScoringFunction%1%") -> RestraintsScoringFunction
        __init__(IMP::core::RestraintsScoringFunction self, IMP::kernel::RestraintsTemp const & rs, double weight=1.0, double max=NO_MAX) -> RestraintsScoringFunction
        __init__(IMP::core::RestraintsScoringFunction self, IMP::kernel::RestraintsTemp const & rs, double weight=1.0) -> RestraintsScoringFunction
        __init__(IMP::core::RestraintsScoringFunction self, IMP::kernel::RestraintsTemp const & rs) -> RestraintsScoringFunction
        __init__(IMP::core::RestraintsScoringFunction self, IMP::kernel::RestraintsTemp const & rs, std::string name) -> RestraintsScoringFunction
        """
        this = _IMP_core.new_RestraintsScoringFunction(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_add_score_and_derivatives(self, *args):
        """do_add_score_and_derivatives(RestraintsScoringFunction self, ScoreAccumulator sa, IMP::kernel::ScoreStatesTemp const & ss)"""
        return _IMP_core.RestraintsScoringFunction_do_add_score_and_derivatives(self, *args)

    def get_required_score_states(self):
        """get_required_score_states(RestraintsScoringFunction self) -> IMP::kernel::ScoreStatesTemp"""
        return _IMP_core.RestraintsScoringFunction_get_required_score_states(self)

    def get_version_info(self):
        """get_version_info(RestraintsScoringFunction self) -> VersionInfo"""
        return _IMP_core.RestraintsScoringFunction_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_RestraintsScoringFunction
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(RestraintsScoringFunction self) -> std::string"""
        return _IMP_core.RestraintsScoringFunction___str__(self)

    def __repr__(self):
        """__repr__(RestraintsScoringFunction self) -> std::string"""
        return _IMP_core.RestraintsScoringFunction___repr__(self)

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

RestraintsScoringFunction_swigregister = _IMP_core.RestraintsScoringFunction_swigregister
RestraintsScoringFunction_swigregister(RestraintsScoringFunction)

class RigidClosePairsFinder(ClosePairsFinder):
    """Proxy of C++ IMP::core::RigidClosePairsFinder class"""
    __swig_setmethods__ = {}
    for _s in [ClosePairsFinder]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RigidClosePairsFinder, name, value)
    __swig_getmethods__ = {}
    for _s in [ClosePairsFinder]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RigidClosePairsFinder, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::RigidClosePairsFinder self, ClosePairsFinder cpf=nullptr) -> RigidClosePairsFinder
        __init__(IMP::core::RigidClosePairsFinder self) -> RigidClosePairsFinder
        """
        this = _IMP_core.new_RigidClosePairsFinder(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_close_pairs(self, *args):
        """
        get_close_pairs(RigidClosePairsFinder self, Particle a, Particle b, IMP::kernel::ParticleIndexes const & pa, IMP::kernel::ParticleIndexes const & pb) -> IMP::kernel::ParticlePairsTemp
        get_close_pairs(RigidClosePairsFinder self, IMP::kernel::ParticlesTemp const & pa) -> IMP::kernel::ParticlePairsTemp
        get_close_pairs(RigidClosePairsFinder self, IMP::kernel::ParticlesTemp const & pa, IMP::kernel::ParticlesTemp const & pb) -> IMP::kernel::ParticlePairsTemp
        get_close_pairs(RigidClosePairsFinder self, IMP::algebra::BoundingBox3Ds const & bbs) -> IMP::IntPairs
        get_close_pairs(RigidClosePairsFinder self, IMP::algebra::BoundingBox3Ds const & bas, IMP::algebra::BoundingBox3Ds const & bbs) -> IMP::IntPairs
        """
        return _IMP_core.RigidClosePairsFinder_get_close_pairs(self, *args)

    def get_version_info(self):
        """get_version_info(RigidClosePairsFinder self) -> VersionInfo"""
        return _IMP_core.RigidClosePairsFinder_get_version_info(self)

    def do_show(self, *args):
        """do_show(RigidClosePairsFinder self, _ostream out)"""
        return _IMP_core.RigidClosePairsFinder_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_RigidClosePairsFinder
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(RigidClosePairsFinder self) -> std::string"""
        return _IMP_core.RigidClosePairsFinder___str__(self)

    def __repr__(self):
        """__repr__(RigidClosePairsFinder self) -> std::string"""
        return _IMP_core.RigidClosePairsFinder___repr__(self)

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

RigidClosePairsFinder_swigregister = _IMP_core.RigidClosePairsFinder_swigregister
RigidClosePairsFinder_swigregister(RigidClosePairsFinder)

class SphereDistancePairScore(IMP.kernel.PairScore):
    """Proxy of C++ IMP::core::SphereDistancePairScore class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.PairScore]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SphereDistancePairScore, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.PairScore]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SphereDistancePairScore, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::SphereDistancePairScore self, UnaryFunction uf, std::string name="SphereDistancePairScore%1%") -> SphereDistancePairScore
        __init__(IMP::core::SphereDistancePairScore self, UnaryFunction uf) -> SphereDistancePairScore
        """
        this = _IMP_core.new_SphereDistancePairScore(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_input_particles(self, *args):
        """get_input_particles(SphereDistancePairScore self, Particle arg2) -> IMP::kernel::ParticlesTemp"""
        return _IMP_core.SphereDistancePairScore_get_input_particles(self, *args)

    def get_input_containers(self, *args):
        """get_input_containers(SphereDistancePairScore self, Particle arg2) -> IMP::kernel::ContainersTemp"""
        return _IMP_core.SphereDistancePairScore_get_input_containers(self, *args)

    def get_version_info(self):
        """get_version_info(SphereDistancePairScore self) -> VersionInfo"""
        return _IMP_core.SphereDistancePairScore_get_version_info(self)

    def do_show(self, *args):
        """do_show(SphereDistancePairScore self, _ostream out)"""
        return _IMP_core.SphereDistancePairScore_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_SphereDistancePairScore
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(SphereDistancePairScore self) -> std::string"""
        return _IMP_core.SphereDistancePairScore___str__(self)

    def __repr__(self):
        """__repr__(SphereDistancePairScore self) -> std::string"""
        return _IMP_core.SphereDistancePairScore___repr__(self)

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

SphereDistancePairScore_swigregister = _IMP_core.SphereDistancePairScore_swigregister
SphereDistancePairScore_swigregister(SphereDistancePairScore)

class HarmonicUpperBoundSphereDistancePairScore(IMP.kernel.PairScore):
    """Proxy of C++ IMP::core::HarmonicUpperBoundSphereDistancePairScore class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.PairScore]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HarmonicUpperBoundSphereDistancePairScore, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.PairScore]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, HarmonicUpperBoundSphereDistancePairScore, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::HarmonicUpperBoundSphereDistancePairScore self, double x0, double k, std::string name="HarmonicUpperBoundSphereDistancePairScore%1%") -> HarmonicUpperBoundSphereDistancePairScore
        __init__(IMP::core::HarmonicUpperBoundSphereDistancePairScore self, double x0, double k) -> HarmonicUpperBoundSphereDistancePairScore
        """
        this = _IMP_core.new_HarmonicUpperBoundSphereDistancePairScore(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_input_particles(self, *args):
        """get_input_particles(HarmonicUpperBoundSphereDistancePairScore self, Particle arg2) -> IMP::kernel::ParticlesTemp"""
        return _IMP_core.HarmonicUpperBoundSphereDistancePairScore_get_input_particles(self, *args)

    def get_input_containers(self, *args):
        """get_input_containers(HarmonicUpperBoundSphereDistancePairScore self, Particle arg2) -> IMP::kernel::ContainersTemp"""
        return _IMP_core.HarmonicUpperBoundSphereDistancePairScore_get_input_containers(self, *args)

    def get_version_info(self):
        """get_version_info(HarmonicUpperBoundSphereDistancePairScore self) -> VersionInfo"""
        return _IMP_core.HarmonicUpperBoundSphereDistancePairScore_get_version_info(self)

    def do_show(self, *args):
        """do_show(HarmonicUpperBoundSphereDistancePairScore self, _ostream out)"""
        return _IMP_core.HarmonicUpperBoundSphereDistancePairScore_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_HarmonicUpperBoundSphereDistancePairScore
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(HarmonicUpperBoundSphereDistancePairScore self) -> std::string"""
        return _IMP_core.HarmonicUpperBoundSphereDistancePairScore___str__(self)

    def __repr__(self):
        """__repr__(HarmonicUpperBoundSphereDistancePairScore self) -> std::string"""
        return _IMP_core.HarmonicUpperBoundSphereDistancePairScore___repr__(self)

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

HarmonicUpperBoundSphereDistancePairScore_swigregister = _IMP_core.HarmonicUpperBoundSphereDistancePairScore_swigregister
HarmonicUpperBoundSphereDistancePairScore_swigregister(HarmonicUpperBoundSphereDistancePairScore)

class HarmonicUpperBoundSphereDiameterPairScore(IMP.kernel.PairScore):
    """Proxy of C++ IMP::core::HarmonicUpperBoundSphereDiameterPairScore class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.PairScore]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HarmonicUpperBoundSphereDiameterPairScore, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.PairScore]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, HarmonicUpperBoundSphereDiameterPairScore, name)
    def __init__(self, *args): 
        """__init__(IMP::core::HarmonicUpperBoundSphereDiameterPairScore self, double d0, double k) -> HarmonicUpperBoundSphereDiameterPairScore"""
        this = _IMP_core.new_HarmonicUpperBoundSphereDiameterPairScore(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_rest_length(self):
        """get_rest_length(HarmonicUpperBoundSphereDiameterPairScore self) -> double"""
        return _IMP_core.HarmonicUpperBoundSphereDiameterPairScore_get_rest_length(self)

    def get_stiffness(self):
        """get_stiffness(HarmonicUpperBoundSphereDiameterPairScore self) -> double"""
        return _IMP_core.HarmonicUpperBoundSphereDiameterPairScore_get_stiffness(self)

    def get_version_info(self):
        """get_version_info(HarmonicUpperBoundSphereDiameterPairScore self) -> VersionInfo"""
        return _IMP_core.HarmonicUpperBoundSphereDiameterPairScore_get_version_info(self)

    def do_show(self, *args):
        """do_show(HarmonicUpperBoundSphereDiameterPairScore self, _ostream out)"""
        return _IMP_core.HarmonicUpperBoundSphereDiameterPairScore_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_HarmonicUpperBoundSphereDiameterPairScore
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(HarmonicUpperBoundSphereDiameterPairScore self) -> std::string"""
        return _IMP_core.HarmonicUpperBoundSphereDiameterPairScore___str__(self)

    def __repr__(self):
        """__repr__(HarmonicUpperBoundSphereDiameterPairScore self) -> std::string"""
        return _IMP_core.HarmonicUpperBoundSphereDiameterPairScore___repr__(self)

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

HarmonicUpperBoundSphereDiameterPairScore_swigregister = _IMP_core.HarmonicUpperBoundSphereDiameterPairScore_swigregister
HarmonicUpperBoundSphereDiameterPairScore_swigregister(HarmonicUpperBoundSphereDiameterPairScore)

class HarmonicSphereDistancePairScore(IMP.kernel.PairScore):
    """Proxy of C++ IMP::core::HarmonicSphereDistancePairScore class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.PairScore]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HarmonicSphereDistancePairScore, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.PairScore]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, HarmonicSphereDistancePairScore, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::HarmonicSphereDistancePairScore self, double x0, double k, std::string name="HarmonicSphereDistancePairScore%1%") -> HarmonicSphereDistancePairScore
        __init__(IMP::core::HarmonicSphereDistancePairScore self, double x0, double k) -> HarmonicSphereDistancePairScore
        """
        this = _IMP_core.new_HarmonicSphereDistancePairScore(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_input_particles(self, *args):
        """get_input_particles(HarmonicSphereDistancePairScore self, Particle arg2) -> IMP::kernel::ParticlesTemp"""
        return _IMP_core.HarmonicSphereDistancePairScore_get_input_particles(self, *args)

    def get_input_containers(self, *args):
        """get_input_containers(HarmonicSphereDistancePairScore self, Particle arg2) -> IMP::kernel::ContainersTemp"""
        return _IMP_core.HarmonicSphereDistancePairScore_get_input_containers(self, *args)

    def get_version_info(self):
        """get_version_info(HarmonicSphereDistancePairScore self) -> VersionInfo"""
        return _IMP_core.HarmonicSphereDistancePairScore_get_version_info(self)

    def do_show(self, *args):
        """do_show(HarmonicSphereDistancePairScore self, _ostream out)"""
        return _IMP_core.HarmonicSphereDistancePairScore_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_HarmonicSphereDistancePairScore
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(HarmonicSphereDistancePairScore self) -> std::string"""
        return _IMP_core.HarmonicSphereDistancePairScore___str__(self)

    def __repr__(self):
        """__repr__(HarmonicSphereDistancePairScore self) -> std::string"""
        return _IMP_core.HarmonicSphereDistancePairScore___repr__(self)

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

HarmonicSphereDistancePairScore_swigregister = _IMP_core.HarmonicSphereDistancePairScore_swigregister
HarmonicSphereDistancePairScore_swigregister(HarmonicSphereDistancePairScore)

class NormalizedSphereDistancePairScore(IMP.kernel.PairScore):
    """Proxy of C++ IMP::core::NormalizedSphereDistancePairScore class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.PairScore]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NormalizedSphereDistancePairScore, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.PairScore]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NormalizedSphereDistancePairScore, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::NormalizedSphereDistancePairScore self, UnaryFunction f, FloatKey radius=FloatKey("radius")) -> NormalizedSphereDistancePairScore
        __init__(IMP::core::NormalizedSphereDistancePairScore self, UnaryFunction f) -> NormalizedSphereDistancePairScore
        """
        this = _IMP_core.new_NormalizedSphereDistancePairScore(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_create_current_decomposition(self, *args):
        """do_create_current_decomposition(NormalizedSphereDistancePairScore self, Model m, IMP::kernel::ParticleIndexPair const & vt) -> IMP::kernel::Restraints"""
        return _IMP_core.NormalizedSphereDistancePairScore_do_create_current_decomposition(self, *args)

    def get_version_info(self):
        """get_version_info(NormalizedSphereDistancePairScore self) -> VersionInfo"""
        return _IMP_core.NormalizedSphereDistancePairScore_get_version_info(self)

    def do_show(self, *args):
        """do_show(NormalizedSphereDistancePairScore self, _ostream out)"""
        return _IMP_core.NormalizedSphereDistancePairScore_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_NormalizedSphereDistancePairScore
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(NormalizedSphereDistancePairScore self) -> std::string"""
        return _IMP_core.NormalizedSphereDistancePairScore___str__(self)

    def __repr__(self):
        """__repr__(NormalizedSphereDistancePairScore self) -> std::string"""
        return _IMP_core.NormalizedSphereDistancePairScore___repr__(self)

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

NormalizedSphereDistancePairScore_swigregister = _IMP_core.NormalizedSphereDistancePairScore_swigregister
NormalizedSphereDistancePairScore_swigregister(NormalizedSphereDistancePairScore)

class WeightedSphereDistancePairScore(IMP.kernel.PairScore):
    """Proxy of C++ IMP::core::WeightedSphereDistancePairScore class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.PairScore]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, WeightedSphereDistancePairScore, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.PairScore]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, WeightedSphereDistancePairScore, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::WeightedSphereDistancePairScore self, UnaryFunction f, FloatKey weight, FloatKey radius=FloatKey("radius")) -> WeightedSphereDistancePairScore
        __init__(IMP::core::WeightedSphereDistancePairScore self, UnaryFunction f, FloatKey weight) -> WeightedSphereDistancePairScore
        """
        this = _IMP_core.new_WeightedSphereDistancePairScore(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_create_current_decomposition(self, *args):
        """do_create_current_decomposition(WeightedSphereDistancePairScore self, Model m, IMP::kernel::ParticleIndexPair const & vt) -> IMP::kernel::Restraints"""
        return _IMP_core.WeightedSphereDistancePairScore_do_create_current_decomposition(self, *args)

    def get_version_info(self):
        """get_version_info(WeightedSphereDistancePairScore self) -> VersionInfo"""
        return _IMP_core.WeightedSphereDistancePairScore_get_version_info(self)

    def do_show(self, *args):
        """do_show(WeightedSphereDistancePairScore self, _ostream out)"""
        return _IMP_core.WeightedSphereDistancePairScore_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_WeightedSphereDistancePairScore
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(WeightedSphereDistancePairScore self) -> std::string"""
        return _IMP_core.WeightedSphereDistancePairScore___str__(self)

    def __repr__(self):
        """__repr__(WeightedSphereDistancePairScore self) -> std::string"""
        return _IMP_core.WeightedSphereDistancePairScore___repr__(self)

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

WeightedSphereDistancePairScore_swigregister = _IMP_core.WeightedSphereDistancePairScore_swigregister
WeightedSphereDistancePairScore_swigregister(WeightedSphereDistancePairScore)

class SoftSpherePairScore(IMP.kernel.PairScore):
    """Proxy of C++ IMP::core::SoftSpherePairScore class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.PairScore]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SoftSpherePairScore, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.PairScore]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SoftSpherePairScore, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::SoftSpherePairScore self, double k, std::string name="SoftSpherePairScore%1%") -> SoftSpherePairScore
        __init__(IMP::core::SoftSpherePairScore self, double k) -> SoftSpherePairScore
        """
        this = _IMP_core.new_SoftSpherePairScore(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_input_particles(self, *args):
        """get_input_particles(SoftSpherePairScore self, Particle arg2) -> IMP::kernel::ParticlesTemp"""
        return _IMP_core.SoftSpherePairScore_get_input_particles(self, *args)

    def get_input_containers(self, *args):
        """get_input_containers(SoftSpherePairScore self, Particle arg2) -> IMP::kernel::ContainersTemp"""
        return _IMP_core.SoftSpherePairScore_get_input_containers(self, *args)

    def get_version_info(self):
        """get_version_info(SoftSpherePairScore self) -> VersionInfo"""
        return _IMP_core.SoftSpherePairScore_get_version_info(self)

    def do_show(self, *args):
        """do_show(SoftSpherePairScore self, _ostream out)"""
        return _IMP_core.SoftSpherePairScore_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_SoftSpherePairScore
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(SoftSpherePairScore self) -> std::string"""
        return _IMP_core.SoftSpherePairScore___str__(self)

    def __repr__(self):
        """__repr__(SoftSpherePairScore self) -> std::string"""
        return _IMP_core.SoftSpherePairScore___repr__(self)

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

SoftSpherePairScore_swigregister = _IMP_core.SoftSpherePairScore_swigregister
SoftSpherePairScore_swigregister(SoftSpherePairScore)

class SteepestDescent(IMP.kernel.Optimizer):
    """Proxy of C++ IMP::core::SteepestDescent class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Optimizer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SteepestDescent, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Optimizer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SteepestDescent, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::SteepestDescent self, Model m=nullptr) -> SteepestDescent
        __init__(IMP::core::SteepestDescent self) -> SteepestDescent
        """
        this = _IMP_core.new_SteepestDescent(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_optimize(self, *args):
        """do_optimize(SteepestDescent self, unsigned int max_steps) -> IMP::Float"""
        return _IMP_core.SteepestDescent_do_optimize(self, *args)

    def get_version_info(self):
        """get_version_info(SteepestDescent self) -> VersionInfo"""
        return _IMP_core.SteepestDescent_get_version_info(self)

    def do_show(self, *args):
        """do_show(SteepestDescent self, _ostream out)"""
        return _IMP_core.SteepestDescent_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_SteepestDescent
    __del__ = lambda self : None;
    def set_threshold(self, *args):
        """set_threshold(SteepestDescent self, IMP::Float t)"""
        return _IMP_core.SteepestDescent_set_threshold(self, *args)

    def set_step_size(self, *args):
        """set_step_size(SteepestDescent self, IMP::Float t)"""
        return _IMP_core.SteepestDescent_set_step_size(self, *args)

    def set_maximum_step_size(self, *args):
        """set_maximum_step_size(SteepestDescent self, IMP::Float t)"""
        return _IMP_core.SteepestDescent_set_maximum_step_size(self, *args)

    def __str__(self):
        """__str__(SteepestDescent self) -> std::string"""
        return _IMP_core.SteepestDescent___str__(self)

    def __repr__(self):
        """__repr__(SteepestDescent self) -> std::string"""
        return _IMP_core.SteepestDescent___repr__(self)

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

SteepestDescent_swigregister = _IMP_core.SteepestDescent_swigregister
SteepestDescent_swigregister(SteepestDescent)

class TransformedDistancePairScore(IMP.kernel.PairScore):
    """Proxy of C++ IMP::core::TransformedDistancePairScore class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.PairScore]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TransformedDistancePairScore, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.PairScore]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TransformedDistancePairScore, name)
    def __init__(self, *args): 
        """__init__(IMP::core::TransformedDistancePairScore self, UnaryFunction f, Transformation3D transformation) -> TransformedDistancePairScore"""
        this = _IMP_core.new_TransformedDistancePairScore(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_transformation(self, *args):
        """set_transformation(TransformedDistancePairScore self, Transformation3D rot)"""
        return _IMP_core.TransformedDistancePairScore_set_transformation(self, *args)

    def do_create_current_decomposition(self, *args):
        """do_create_current_decomposition(TransformedDistancePairScore self, Model m, IMP::kernel::ParticleIndexPair const & vt) -> IMP::kernel::Restraints"""
        return _IMP_core.TransformedDistancePairScore_do_create_current_decomposition(self, *args)

    def get_version_info(self):
        """get_version_info(TransformedDistancePairScore self) -> VersionInfo"""
        return _IMP_core.TransformedDistancePairScore_get_version_info(self)

    def do_show(self, *args):
        """do_show(TransformedDistancePairScore self, _ostream out)"""
        return _IMP_core.TransformedDistancePairScore_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_TransformedDistancePairScore
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(TransformedDistancePairScore self) -> std::string"""
        return _IMP_core.TransformedDistancePairScore___str__(self)

    def __repr__(self):
        """__repr__(TransformedDistancePairScore self) -> std::string"""
        return _IMP_core.TransformedDistancePairScore___repr__(self)

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

TransformedDistancePairScore_swigregister = _IMP_core.TransformedDistancePairScore_swigregister
TransformedDistancePairScore_swigregister(TransformedDistancePairScore)

class TypedPairScore(IMP.kernel.PairScore):
    """Proxy of C++ IMP::core::TypedPairScore class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.PairScore]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TypedPairScore, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.PairScore]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TypedPairScore, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::TypedPairScore self, IntKey typekey, bool allow_invalid_types=True) -> TypedPairScore
        __init__(IMP::core::TypedPairScore self, IntKey typekey) -> TypedPairScore
        """
        this = _IMP_core.new_TypedPairScore(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_particle_type(self, *args):
        """set_particle_type(TypedPairScore self, Particle arg2)"""
        return _IMP_core.TypedPairScore_set_particle_type(self, *args)

    def set_pair_score(self, *args):
        """set_pair_score(TypedPairScore self, PairScore ps, IMP::Int atype, IMP::Int btype)"""
        return _IMP_core.TypedPairScore_set_pair_score(self, *args)

    def get_input_particles(self, *args):
        """get_input_particles(TypedPairScore self, Particle arg2) -> IMP::kernel::ParticlesTemp"""
        return _IMP_core.TypedPairScore_get_input_particles(self, *args)

    def get_input_containers(self, *args):
        """get_input_containers(TypedPairScore self, Particle arg2) -> IMP::kernel::ContainersTemp"""
        return _IMP_core.TypedPairScore_get_input_containers(self, *args)

    def get_version_info(self):
        """get_version_info(TypedPairScore self) -> VersionInfo"""
        return _IMP_core.TypedPairScore_get_version_info(self)

    def do_show(self, *args):
        """do_show(TypedPairScore self, _ostream out)"""
        return _IMP_core.TypedPairScore_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_TypedPairScore
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(TypedPairScore self) -> std::string"""
        return _IMP_core.TypedPairScore___str__(self)

    def __repr__(self):
        """__repr__(TypedPairScore self) -> std::string"""
        return _IMP_core.TypedPairScore___repr__(self)

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

TypedPairScore_swigregister = _IMP_core.TypedPairScore_swigregister
TypedPairScore_swigregister(TypedPairScore)

class RigidBodyDistancePairScore(KClosePairsPairScore):
    """Proxy of C++ IMP::core::RigidBodyDistancePairScore class"""
    __swig_setmethods__ = {}
    for _s in [KClosePairsPairScore]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RigidBodyDistancePairScore, name, value)
    __swig_getmethods__ = {}
    for _s in [KClosePairsPairScore]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RigidBodyDistancePairScore, name)
    def __init__(self, *args): 
        """__init__(IMP::core::RigidBodyDistancePairScore self, PairScore ps, Refiner r) -> RigidBodyDistancePairScore"""
        this = _IMP_core.new_RigidBodyDistancePairScore(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self):
        """__str__(RigidBodyDistancePairScore self) -> std::string"""
        return _IMP_core.RigidBodyDistancePairScore___str__(self)

    def __repr__(self):
        """__repr__(RigidBodyDistancePairScore self) -> std::string"""
        return _IMP_core.RigidBodyDistancePairScore___repr__(self)

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

    __swig_destroy__ = _IMP_core.delete_RigidBodyDistancePairScore
    __del__ = lambda self : None;
RigidBodyDistancePairScore_swigregister = _IMP_core.RigidBodyDistancePairScore_swigregister
RigidBodyDistancePairScore_swigregister(RigidBodyDistancePairScore)

class TableRefiner(IMP.kernel.Refiner):
    """Proxy of C++ IMP::core::TableRefiner class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Refiner]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TableRefiner, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Refiner]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TableRefiner, name)
    def __init__(self): 
        """__init__(IMP::core::TableRefiner self) -> TableRefiner"""
        this = _IMP_core.new_TableRefiner()
        try: self.this.append(this)
        except: self.this = this
    def add_particle(self, *args):
        """add_particle(TableRefiner self, Particle p, IMP::kernel::ParticlesTemp const & ps)"""
        return _IMP_core.TableRefiner_add_particle(self, *args)

    def remove_particle(self, *args):
        """remove_particle(TableRefiner self, Particle p)"""
        return _IMP_core.TableRefiner_remove_particle(self, *args)

    def set_particle(self, *args):
        """set_particle(TableRefiner self, Particle p, IMP::kernel::ParticlesTemp const & ps)"""
        return _IMP_core.TableRefiner_set_particle(self, *args)

    def get_refined(self, *args):
        """
        get_refined(TableRefiner self, Particle arg2) -> IMP::kernel::ParticlesTemp const
        get_refined(TableRefiner self, Particle arg2, unsigned int arg3) -> Particle
        """
        return _IMP_core.TableRefiner_get_refined(self, *args)

    def get_input_particles(self, *args):
        """get_input_particles(TableRefiner self, Particle arg2) -> IMP::kernel::ParticlesTemp"""
        return _IMP_core.TableRefiner_get_input_particles(self, *args)

    def get_input_containers(self, *args):
        """get_input_containers(TableRefiner self, Particle arg2) -> IMP::kernel::ContainersTemp"""
        return _IMP_core.TableRefiner_get_input_containers(self, *args)

    def get_version_info(self):
        """get_version_info(TableRefiner self) -> VersionInfo"""
        return _IMP_core.TableRefiner_get_version_info(self)

    def do_show(self, *args):
        """do_show(TableRefiner self, _ostream out)"""
        return _IMP_core.TableRefiner_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_TableRefiner
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(TableRefiner self) -> std::string"""
        return _IMP_core.TableRefiner___str__(self)

    def __repr__(self):
        """__repr__(TableRefiner self) -> std::string"""
        return _IMP_core.TableRefiner___repr__(self)

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

TableRefiner_swigregister = _IMP_core.TableRefiner_swigregister
TableRefiner_swigregister(TableRefiner)

LOWER = _IMP_core.LOWER
BOTH = _IMP_core.BOTH
UPPER = _IMP_core.UPPER
class MCCGSampler(IMP.kernel.Sampler):
    """Proxy of C++ IMP::core::MCCGSampler class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Sampler]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MCCGSampler, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Sampler]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MCCGSampler, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::MCCGSampler self, Model m, std::string name="MCCG Sampler %1%") -> MCCGSampler
        __init__(IMP::core::MCCGSampler self, Model m) -> MCCGSampler
        """
        this = _IMP_core.new_MCCGSampler(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_bounding_box(self, *args):
        """set_bounding_box(MCCGSampler self, BoundingBox3D bb)"""
        return _IMP_core.MCCGSampler_set_bounding_box(self, *args)

    def set_number_of_attempts(self, *args):
        """set_number_of_attempts(MCCGSampler self, unsigned int att)"""
        return _IMP_core.MCCGSampler_set_number_of_attempts(self, *args)

    def set_number_of_monte_carlo_steps(self, *args):
        """set_number_of_monte_carlo_steps(MCCGSampler self, unsigned int cg)"""
        return _IMP_core.MCCGSampler_set_number_of_monte_carlo_steps(self, *args)

    def set_number_of_conjugate_gradient_steps(self, *args):
        """set_number_of_conjugate_gradient_steps(MCCGSampler self, unsigned int cg)"""
        return _IMP_core.MCCGSampler_set_number_of_conjugate_gradient_steps(self, *args)

    def set_max_monte_carlo_step_size(self, *args):
        """
        set_max_monte_carlo_step_size(MCCGSampler self, double d)
        set_max_monte_carlo_step_size(MCCGSampler self, FloatKey k, double d)
        """
        return _IMP_core.MCCGSampler_set_max_monte_carlo_step_size(self, *args)

    def set_is_refining(self, *args):
        """set_is_refining(MCCGSampler self, bool tf)"""
        return _IMP_core.MCCGSampler_set_is_refining(self, *args)

    def set_local_optimizer(self, *args):
        """set_local_optimizer(MCCGSampler self, Optimizer opt)"""
        return _IMP_core.MCCGSampler_set_local_optimizer(self, *args)

    def set_save_rejected_configurations(self, *args):
        """set_save_rejected_configurations(MCCGSampler self, bool tf)"""
        return _IMP_core.MCCGSampler_set_save_rejected_configurations(self, *args)

    def get_rejected_configurations(self):
        """get_rejected_configurations(MCCGSampler self) -> ConfigurationSet"""
        return _IMP_core.MCCGSampler_get_rejected_configurations(self)

    def remove_optimizer_state(self, *args):
        """remove_optimizer_state(MCCGSampler self, OptimizerState d)"""
        return _IMP_core.MCCGSampler_remove_optimizer_state(self, *args)

    def remove_optimizer_states(self, *args):
        """remove_optimizer_states(MCCGSampler self, IMP::kernel::OptimizerStates const & d)"""
        return _IMP_core.MCCGSampler_remove_optimizer_states(self, *args)

    def set_optimizer_states(self, *args):
        """set_optimizer_states(MCCGSampler self, IMP::kernel::OptimizerStates const & ps)"""
        return _IMP_core.MCCGSampler_set_optimizer_states(self, *args)

    def set_optimizer_states_order(self, *args):
        """set_optimizer_states_order(MCCGSampler self, IMP::kernel::OptimizerStates const & objs)"""
        return _IMP_core.MCCGSampler_set_optimizer_states_order(self, *args)

    def add_optimizer_state(self, *args):
        """add_optimizer_state(MCCGSampler self, OptimizerState obj) -> unsigned int"""
        return _IMP_core.MCCGSampler_add_optimizer_state(self, *args)

    def add_optimizer_states(self, *args):
        """add_optimizer_states(MCCGSampler self, IMP::kernel::OptimizerStates const & objs)"""
        return _IMP_core.MCCGSampler_add_optimizer_states(self, *args)

    def clear_optimizer_states(self):
        """clear_optimizer_states(MCCGSampler self)"""
        return _IMP_core.MCCGSampler_clear_optimizer_states(self)

    def get_number_of_optimizer_states(self):
        """get_number_of_optimizer_states(MCCGSampler self) -> unsigned int"""
        return _IMP_core.MCCGSampler_get_number_of_optimizer_states(self)

    def get_has_optimizer_states(self):
        """get_has_optimizer_states(MCCGSampler self) -> bool"""
        return _IMP_core.MCCGSampler_get_has_optimizer_states(self)

    def get_optimizer_state(self, *args):
        """get_optimizer_state(MCCGSampler self, unsigned int i) -> OptimizerState"""
        return _IMP_core.MCCGSampler_get_optimizer_state(self, *args)

    def get_optimizer_states(self):
        """get_optimizer_states(MCCGSampler self) -> IMP::kernel::OptimizerStates"""
        return _IMP_core.MCCGSampler_get_optimizer_states(self)

    def reserve_optimizer_states(self, *args):
        """reserve_optimizer_states(MCCGSampler self, unsigned int sz)"""
        return _IMP_core.MCCGSampler_reserve_optimizer_states(self, *args)

    def get_version_info(self):
        """get_version_info(MCCGSampler self) -> VersionInfo"""
        return _IMP_core.MCCGSampler_get_version_info(self)

    def do_show(self, *args):
        """do_show(MCCGSampler self, _ostream out)"""
        return _IMP_core.MCCGSampler_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_MCCGSampler
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(MCCGSampler self) -> std::string"""
        return _IMP_core.MCCGSampler___str__(self)

    def __repr__(self):
        """__repr__(MCCGSampler self) -> std::string"""
        return _IMP_core.MCCGSampler___repr__(self)

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

MCCGSampler_swigregister = _IMP_core.MCCGSampler_swigregister
MCCGSampler_swigregister(MCCGSampler)

class MinimumRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::core::MinimumRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MinimumRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MinimumRestraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::MinimumRestraint self, unsigned int num, IMP::kernel::Restraints const & rs=IMP::kernel::Restraints(), std::string name="MinimumRestraint %1%") -> MinimumRestraint
        __init__(IMP::core::MinimumRestraint self, unsigned int num, IMP::kernel::Restraints const & rs=IMP::kernel::Restraints()) -> MinimumRestraint
        __init__(IMP::core::MinimumRestraint self, unsigned int num) -> MinimumRestraint
        """
        this = _IMP_core.new_MinimumRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_get_inputs(self):
        """do_get_inputs(MinimumRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_core.MinimumRestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(MinimumRestraint self) -> VersionInfo"""
        return _IMP_core.MinimumRestraint_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_MinimumRestraint
    __del__ = lambda self : None;
    def remove_restraint(self, *args):
        """remove_restraint(MinimumRestraint self, Restraint d)"""
        return _IMP_core.MinimumRestraint_remove_restraint(self, *args)

    def remove_restraints(self, *args):
        """remove_restraints(MinimumRestraint self, IMP::kernel::Restraints const & d)"""
        return _IMP_core.MinimumRestraint_remove_restraints(self, *args)

    def set_restraints(self, *args):
        """set_restraints(MinimumRestraint self, IMP::kernel::Restraints const & ps)"""
        return _IMP_core.MinimumRestraint_set_restraints(self, *args)

    def set_restraints_order(self, *args):
        """set_restraints_order(MinimumRestraint self, IMP::kernel::Restraints const & objs)"""
        return _IMP_core.MinimumRestraint_set_restraints_order(self, *args)

    def add_restraint(self, *args):
        """add_restraint(MinimumRestraint self, Restraint obj) -> unsigned int"""
        return _IMP_core.MinimumRestraint_add_restraint(self, *args)

    def add_restraints(self, *args):
        """add_restraints(MinimumRestraint self, IMP::kernel::Restraints const & objs)"""
        return _IMP_core.MinimumRestraint_add_restraints(self, *args)

    def clear_restraints(self):
        """clear_restraints(MinimumRestraint self)"""
        return _IMP_core.MinimumRestraint_clear_restraints(self)

    def get_number_of_restraints(self):
        """get_number_of_restraints(MinimumRestraint self) -> unsigned int"""
        return _IMP_core.MinimumRestraint_get_number_of_restraints(self)

    def get_has_restraints(self):
        """get_has_restraints(MinimumRestraint self) -> bool"""
        return _IMP_core.MinimumRestraint_get_has_restraints(self)

    def get_restraint(self, *args):
        """get_restraint(MinimumRestraint self, unsigned int i) -> Restraint"""
        return _IMP_core.MinimumRestraint_get_restraint(self, *args)

    def get_restraints(self):
        """get_restraints(MinimumRestraint self) -> IMP::kernel::Restraints"""
        return _IMP_core.MinimumRestraint_get_restraints(self)

    def reserve_restraints(self, *args):
        """reserve_restraints(MinimumRestraint self, unsigned int sz)"""
        return _IMP_core.MinimumRestraint_reserve_restraints(self, *args)

    def __str__(self):
        """__str__(MinimumRestraint self) -> std::string"""
        return _IMP_core.MinimumRestraint___str__(self)

    def __repr__(self):
        """__repr__(MinimumRestraint self) -> std::string"""
        return _IMP_core.MinimumRestraint___repr__(self)

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

MinimumRestraint_swigregister = _IMP_core.MinimumRestraint_swigregister
MinimumRestraint_swigregister(MinimumRestraint)

class PairRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::core::PairRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PairRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PairRestraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::PairRestraint self, PairScore ss, IMP::kernel::ParticlePair const & vt, std::string name="PairRestraint %1%") -> PairRestraint
        __init__(IMP::core::PairRestraint self, PairScore ss, IMP::kernel::ParticlePair const & vt) -> PairRestraint
        """
        this = _IMP_core.new_PairRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(PairRestraint self) -> VersionInfo"""
        return _IMP_core.PairRestraint_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_PairRestraint
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(PairRestraint self) -> std::string"""
        return _IMP_core.PairRestraint___str__(self)

    def __repr__(self):
        """__repr__(PairRestraint self) -> std::string"""
        return _IMP_core.PairRestraint___repr__(self)

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

PairRestraint_swigregister = _IMP_core.PairRestraint_swigregister
PairRestraint_swigregister(PairRestraint)

class SingletonRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::core::SingletonRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SingletonRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SingletonRestraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::SingletonRestraint self, SingletonScore ss, Particle vt, std::string name="SingletonRestraint %1%") -> SingletonRestraint
        __init__(IMP::core::SingletonRestraint self, SingletonScore ss, Particle vt) -> SingletonRestraint
        """
        this = _IMP_core.new_SingletonRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(SingletonRestraint self) -> VersionInfo"""
        return _IMP_core.SingletonRestraint_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_SingletonRestraint
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(SingletonRestraint self) -> std::string"""
        return _IMP_core.SingletonRestraint___str__(self)

    def __repr__(self):
        """__repr__(SingletonRestraint self) -> std::string"""
        return _IMP_core.SingletonRestraint___repr__(self)

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

SingletonRestraint_swigregister = _IMP_core.SingletonRestraint_swigregister
SingletonRestraint_swigregister(SingletonRestraint)

class TripletRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::core::TripletRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TripletRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TripletRestraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::TripletRestraint self, TripletScore ss, IMP::kernel::ParticleTriplet const & vt, std::string name="TripletRestraint %1%") -> TripletRestraint
        __init__(IMP::core::TripletRestraint self, TripletScore ss, IMP::kernel::ParticleTriplet const & vt) -> TripletRestraint
        """
        this = _IMP_core.new_TripletRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(TripletRestraint self) -> VersionInfo"""
        return _IMP_core.TripletRestraint_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_TripletRestraint
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(TripletRestraint self) -> std::string"""
        return _IMP_core.TripletRestraint___str__(self)

    def __repr__(self):
        """__repr__(TripletRestraint self) -> std::string"""
        return _IMP_core.TripletRestraint___repr__(self)

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

TripletRestraint_swigregister = _IMP_core.TripletRestraint_swigregister
TripletRestraint_swigregister(TripletRestraint)

class QuadRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::core::QuadRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, QuadRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, QuadRestraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::QuadRestraint self, QuadScore ss, IMP::kernel::ParticleQuad const & vt, std::string name="QuadRestraint %1%") -> QuadRestraint
        __init__(IMP::core::QuadRestraint self, QuadScore ss, IMP::kernel::ParticleQuad const & vt) -> QuadRestraint
        """
        this = _IMP_core.new_QuadRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(QuadRestraint self) -> VersionInfo"""
        return _IMP_core.QuadRestraint_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_QuadRestraint
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(QuadRestraint self) -> std::string"""
        return _IMP_core.QuadRestraint___str__(self)

    def __repr__(self):
        """__repr__(QuadRestraint self) -> std::string"""
        return _IMP_core.QuadRestraint___repr__(self)

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

QuadRestraint_swigregister = _IMP_core.QuadRestraint_swigregister
QuadRestraint_swigregister(QuadRestraint)

class SingletonConstraint(IMP.kernel.Constraint):
    """Proxy of C++ IMP::core::SingletonConstraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Constraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SingletonConstraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Constraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SingletonConstraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::SingletonConstraint self, SingletonModifier before, SingletonModifier after, Particle vt, std::string name="SingletonConstraint %1%") -> SingletonConstraint
        __init__(IMP::core::SingletonConstraint self, SingletonModifier before, SingletonModifier after, Particle vt) -> SingletonConstraint
        """
        this = _IMP_core.new_SingletonConstraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(SingletonConstraint self) -> VersionInfo"""
        return _IMP_core.SingletonConstraint_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_SingletonConstraint
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(SingletonConstraint self) -> std::string"""
        return _IMP_core.SingletonConstraint___str__(self)

    def __repr__(self):
        """__repr__(SingletonConstraint self) -> std::string"""
        return _IMP_core.SingletonConstraint___repr__(self)

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

SingletonConstraint_swigregister = _IMP_core.SingletonConstraint_swigregister
SingletonConstraint_swigregister(SingletonConstraint)

class PairConstraint(IMP.kernel.Constraint):
    """Proxy of C++ IMP::core::PairConstraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Constraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PairConstraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Constraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PairConstraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::PairConstraint self, PairModifier before, PairModifier after, IMP::kernel::ParticlePair const & vt, std::string name="PairConstraint %1%") -> PairConstraint
        __init__(IMP::core::PairConstraint self, PairModifier before, PairModifier after, IMP::kernel::ParticlePair const & vt) -> PairConstraint
        """
        this = _IMP_core.new_PairConstraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(PairConstraint self) -> VersionInfo"""
        return _IMP_core.PairConstraint_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_PairConstraint
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(PairConstraint self) -> std::string"""
        return _IMP_core.PairConstraint___str__(self)

    def __repr__(self):
        """__repr__(PairConstraint self) -> std::string"""
        return _IMP_core.PairConstraint___repr__(self)

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

PairConstraint_swigregister = _IMP_core.PairConstraint_swigregister
PairConstraint_swigregister(PairConstraint)

class TripletConstraint(IMP.kernel.Constraint):
    """Proxy of C++ IMP::core::TripletConstraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Constraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TripletConstraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Constraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TripletConstraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::TripletConstraint self, TripletModifier before, TripletModifier after, IMP::kernel::ParticleTriplet const & vt, 
            std::string name="TripletConstraint %1%") -> TripletConstraint
        __init__(IMP::core::TripletConstraint self, TripletModifier before, TripletModifier after, IMP::kernel::ParticleTriplet const & vt) -> TripletConstraint
        """
        this = _IMP_core.new_TripletConstraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(TripletConstraint self) -> VersionInfo"""
        return _IMP_core.TripletConstraint_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_TripletConstraint
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(TripletConstraint self) -> std::string"""
        return _IMP_core.TripletConstraint___str__(self)

    def __repr__(self):
        """__repr__(TripletConstraint self) -> std::string"""
        return _IMP_core.TripletConstraint___repr__(self)

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

TripletConstraint_swigregister = _IMP_core.TripletConstraint_swigregister
TripletConstraint_swigregister(TripletConstraint)

class QuadConstraint(IMP.kernel.Constraint):
    """Proxy of C++ IMP::core::QuadConstraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Constraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, QuadConstraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Constraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, QuadConstraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::QuadConstraint self, QuadModifier before, QuadModifier after, IMP::kernel::ParticleQuad const & vt, std::string name="QuadConstraint %1%") -> QuadConstraint
        __init__(IMP::core::QuadConstraint self, QuadModifier before, QuadModifier after, IMP::kernel::ParticleQuad const & vt) -> QuadConstraint
        """
        this = _IMP_core.new_QuadConstraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(QuadConstraint self) -> VersionInfo"""
        return _IMP_core.QuadConstraint_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_QuadConstraint
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(QuadConstraint self) -> std::string"""
        return _IMP_core.QuadConstraint___str__(self)

    def __repr__(self):
        """__repr__(QuadConstraint self) -> std::string"""
        return _IMP_core.QuadConstraint___repr__(self)

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

QuadConstraint_swigregister = _IMP_core.QuadConstraint_swigregister
QuadConstraint_swigregister(QuadConstraint)

class ConstantSingletonPredicate(IMP.kernel.SingletonPredicate):
    """Proxy of C++ IMP::core::ConstantSingletonPredicate class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.SingletonPredicate]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConstantSingletonPredicate, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.SingletonPredicate]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ConstantSingletonPredicate, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::ConstantSingletonPredicate self, int v, std::string name="ConstSingletonPredicate%1%") -> ConstantSingletonPredicate
        __init__(IMP::core::ConstantSingletonPredicate self, int v) -> ConstantSingletonPredicate
        """
        this = _IMP_core.new_ConstantSingletonPredicate(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_value(self, *args):
        """
        get_value(ConstantSingletonPredicate self, Particle a) -> int
        get_value(ConstantSingletonPredicate self, IMP::kernel::ParticlesTemp const & o) -> IMP::Ints
        """
        return _IMP_core.ConstantSingletonPredicate_get_value(self, *args)

    def get_value_index(self, *args):
        """
        get_value_index(ConstantSingletonPredicate self, Model m, IMP::kernel::ParticleIndex pi) -> int
        get_value_index(ConstantSingletonPredicate self, Model m, IMP::kernel::ParticleIndexes const & o) -> IMP::Ints
        """
        return _IMP_core.ConstantSingletonPredicate_get_value_index(self, *args)

    def get_version_info(self):
        """get_version_info(ConstantSingletonPredicate self) -> VersionInfo"""
        return _IMP_core.ConstantSingletonPredicate_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_ConstantSingletonPredicate
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(ConstantSingletonPredicate self) -> std::string"""
        return _IMP_core.ConstantSingletonPredicate___str__(self)

    def __repr__(self):
        """__repr__(ConstantSingletonPredicate self) -> std::string"""
        return _IMP_core.ConstantSingletonPredicate___repr__(self)

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

ConstantSingletonPredicate_swigregister = _IMP_core.ConstantSingletonPredicate_swigregister
ConstantSingletonPredicate_swigregister(ConstantSingletonPredicate)

class UnorderedTypeSingletonPredicate(IMP.kernel.SingletonPredicate):
    """Proxy of C++ IMP::core::UnorderedTypeSingletonPredicate class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.SingletonPredicate]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, UnorderedTypeSingletonPredicate, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.SingletonPredicate]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, UnorderedTypeSingletonPredicate, name)
    def __init__(self, name="UnorderedTypeSingletonPredicate%1%"): 
        """
        __init__(IMP::core::UnorderedTypeSingletonPredicate self, std::string name="UnorderedTypeSingletonPredicate%1%") -> UnorderedTypeSingletonPredicate
        __init__(IMP::core::UnorderedTypeSingletonPredicate self) -> UnorderedTypeSingletonPredicate
        """
        this = _IMP_core.new_UnorderedTypeSingletonPredicate(name)
        try: self.this.append(this)
        except: self.this = this
    def get_value(self, *args):
        """
        get_value(UnorderedTypeSingletonPredicate self, Particle a) -> int
        get_value(UnorderedTypeSingletonPredicate self, IMP::kernel::ParticlesTemp const & o) -> IMP::Ints
        """
        return _IMP_core.UnorderedTypeSingletonPredicate_get_value(self, *args)

    def get_value_index(self, *args):
        """
        get_value_index(UnorderedTypeSingletonPredicate self, Model m, IMP::kernel::ParticleIndex pi) -> int
        get_value_index(UnorderedTypeSingletonPredicate self, Model m, IMP::kernel::ParticleIndexes const & o) -> IMP::Ints
        """
        return _IMP_core.UnorderedTypeSingletonPredicate_get_value_index(self, *args)

    def get_version_info(self):
        """get_version_info(UnorderedTypeSingletonPredicate self) -> VersionInfo"""
        return _IMP_core.UnorderedTypeSingletonPredicate_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_UnorderedTypeSingletonPredicate
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(UnorderedTypeSingletonPredicate self) -> std::string"""
        return _IMP_core.UnorderedTypeSingletonPredicate___str__(self)

    def __repr__(self):
        """__repr__(UnorderedTypeSingletonPredicate self) -> std::string"""
        return _IMP_core.UnorderedTypeSingletonPredicate___repr__(self)

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

UnorderedTypeSingletonPredicate_swigregister = _IMP_core.UnorderedTypeSingletonPredicate_swigregister
UnorderedTypeSingletonPredicate_swigregister(UnorderedTypeSingletonPredicate)

class OrderedTypeSingletonPredicate(IMP.kernel.SingletonPredicate):
    """Proxy of C++ IMP::core::OrderedTypeSingletonPredicate class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.SingletonPredicate]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, OrderedTypeSingletonPredicate, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.SingletonPredicate]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, OrderedTypeSingletonPredicate, name)
    def __init__(self, name="OrderedTypeSingletonPredicate%1%"): 
        """
        __init__(IMP::core::OrderedTypeSingletonPredicate self, std::string name="OrderedTypeSingletonPredicate%1%") -> OrderedTypeSingletonPredicate
        __init__(IMP::core::OrderedTypeSingletonPredicate self) -> OrderedTypeSingletonPredicate
        """
        this = _IMP_core.new_OrderedTypeSingletonPredicate(name)
        try: self.this.append(this)
        except: self.this = this
    def get_value_index(self, *args):
        """
        get_value_index(OrderedTypeSingletonPredicate self, Model m, IMP::kernel::ParticleIndex pi) -> int
        get_value_index(OrderedTypeSingletonPredicate self, Model m, IMP::kernel::ParticleIndexes const & o) -> IMP::Ints
        """
        return _IMP_core.OrderedTypeSingletonPredicate_get_value_index(self, *args)

    def get_version_info(self):
        """get_version_info(OrderedTypeSingletonPredicate self) -> VersionInfo"""
        return _IMP_core.OrderedTypeSingletonPredicate_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_OrderedTypeSingletonPredicate
    __del__ = lambda self : None;
    def get_value(self, *args):
        """
        get_value(OrderedTypeSingletonPredicate self, Particle a) -> int
        get_value(OrderedTypeSingletonPredicate self, IMP::kernel::ParticlesTemp const & o) -> IMP::Ints
        get_value(OrderedTypeSingletonPredicate self, IMP::core::ParticleTypes const & types) -> int
        """
        return _IMP_core.OrderedTypeSingletonPredicate_get_value(self, *args)

    def __str__(self):
        """__str__(OrderedTypeSingletonPredicate self) -> std::string"""
        return _IMP_core.OrderedTypeSingletonPredicate___str__(self)

    def __repr__(self):
        """__repr__(OrderedTypeSingletonPredicate self) -> std::string"""
        return _IMP_core.OrderedTypeSingletonPredicate___repr__(self)

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

OrderedTypeSingletonPredicate_swigregister = _IMP_core.OrderedTypeSingletonPredicate_swigregister
OrderedTypeSingletonPredicate_swigregister(OrderedTypeSingletonPredicate)

class AllSameSingletonPredicate(IMP.kernel.SingletonPredicate):
    """Proxy of C++ IMP::core::AllSameSingletonPredicate class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.SingletonPredicate]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AllSameSingletonPredicate, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.SingletonPredicate]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AllSameSingletonPredicate, name)
    def __init__(self, name="AllSameSingletonPredicate%1%"): 
        """
        __init__(IMP::core::AllSameSingletonPredicate self, std::string name="AllSameSingletonPredicate%1%") -> AllSameSingletonPredicate
        __init__(IMP::core::AllSameSingletonPredicate self) -> AllSameSingletonPredicate
        """
        this = _IMP_core.new_AllSameSingletonPredicate(name)
        try: self.this.append(this)
        except: self.this = this
    def get_value(self, *args):
        """
        get_value(AllSameSingletonPredicate self, Particle a) -> int
        get_value(AllSameSingletonPredicate self, IMP::kernel::ParticlesTemp const & o) -> IMP::Ints
        """
        return _IMP_core.AllSameSingletonPredicate_get_value(self, *args)

    def get_value_index(self, *args):
        """
        get_value_index(AllSameSingletonPredicate self, Model m, IMP::kernel::ParticleIndex pi) -> int
        get_value_index(AllSameSingletonPredicate self, Model m, IMP::kernel::ParticleIndexes const & o) -> IMP::Ints
        """
        return _IMP_core.AllSameSingletonPredicate_get_value_index(self, *args)

    def get_version_info(self):
        """get_version_info(AllSameSingletonPredicate self) -> VersionInfo"""
        return _IMP_core.AllSameSingletonPredicate_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_AllSameSingletonPredicate
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(AllSameSingletonPredicate self) -> std::string"""
        return _IMP_core.AllSameSingletonPredicate___str__(self)

    def __repr__(self):
        """__repr__(AllSameSingletonPredicate self) -> std::string"""
        return _IMP_core.AllSameSingletonPredicate___repr__(self)

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

AllSameSingletonPredicate_swigregister = _IMP_core.AllSameSingletonPredicate_swigregister
AllSameSingletonPredicate_swigregister(AllSameSingletonPredicate)

class CoinFlipSingletonPredicate(IMP.kernel.SingletonPredicate):
    """Proxy of C++ IMP::core::CoinFlipSingletonPredicate class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.SingletonPredicate]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CoinFlipSingletonPredicate, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.SingletonPredicate]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CoinFlipSingletonPredicate, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::CoinFlipSingletonPredicate self, double p, std::string name="CoinFlipSingletonPredicate%1%") -> CoinFlipSingletonPredicate
        __init__(IMP::core::CoinFlipSingletonPredicate self, double p) -> CoinFlipSingletonPredicate
        """
        this = _IMP_core.new_CoinFlipSingletonPredicate(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_value(self, *args):
        """
        get_value(CoinFlipSingletonPredicate self, Particle a) -> int
        get_value(CoinFlipSingletonPredicate self, IMP::kernel::ParticlesTemp const & o) -> IMP::Ints
        """
        return _IMP_core.CoinFlipSingletonPredicate_get_value(self, *args)

    def get_value_index(self, *args):
        """
        get_value_index(CoinFlipSingletonPredicate self, Model m, IMP::kernel::ParticleIndex pi) -> int
        get_value_index(CoinFlipSingletonPredicate self, Model m, IMP::kernel::ParticleIndexes const & o) -> IMP::Ints
        """
        return _IMP_core.CoinFlipSingletonPredicate_get_value_index(self, *args)

    def get_version_info(self):
        """get_version_info(CoinFlipSingletonPredicate self) -> VersionInfo"""
        return _IMP_core.CoinFlipSingletonPredicate_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_CoinFlipSingletonPredicate
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(CoinFlipSingletonPredicate self) -> std::string"""
        return _IMP_core.CoinFlipSingletonPredicate___str__(self)

    def __repr__(self):
        """__repr__(CoinFlipSingletonPredicate self) -> std::string"""
        return _IMP_core.CoinFlipSingletonPredicate___repr__(self)

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

CoinFlipSingletonPredicate_swigregister = _IMP_core.CoinFlipSingletonPredicate_swigregister
CoinFlipSingletonPredicate_swigregister(CoinFlipSingletonPredicate)

class ConstantPairPredicate(IMP.kernel.PairPredicate):
    """Proxy of C++ IMP::core::ConstantPairPredicate class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.PairPredicate]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConstantPairPredicate, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.PairPredicate]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ConstantPairPredicate, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::ConstantPairPredicate self, int v, std::string name="ConstPairPredicate%1%") -> ConstantPairPredicate
        __init__(IMP::core::ConstantPairPredicate self, int v) -> ConstantPairPredicate
        """
        this = _IMP_core.new_ConstantPairPredicate(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_value(self, *args):
        """
        get_value(ConstantPairPredicate self, IMP::kernel::ParticlePair const & a) -> int
        get_value(ConstantPairPredicate self, IMP::kernel::ParticlePairsTemp const & o) -> IMP::Ints
        """
        return _IMP_core.ConstantPairPredicate_get_value(self, *args)

    def get_value_index(self, *args):
        """
        get_value_index(ConstantPairPredicate self, Model m, IMP::kernel::ParticleIndexPair const & pi) -> int
        get_value_index(ConstantPairPredicate self, Model m, IMP::kernel::ParticleIndexPairs const & o) -> IMP::Ints
        """
        return _IMP_core.ConstantPairPredicate_get_value_index(self, *args)

    def get_version_info(self):
        """get_version_info(ConstantPairPredicate self) -> VersionInfo"""
        return _IMP_core.ConstantPairPredicate_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_ConstantPairPredicate
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(ConstantPairPredicate self) -> std::string"""
        return _IMP_core.ConstantPairPredicate___str__(self)

    def __repr__(self):
        """__repr__(ConstantPairPredicate self) -> std::string"""
        return _IMP_core.ConstantPairPredicate___repr__(self)

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

ConstantPairPredicate_swigregister = _IMP_core.ConstantPairPredicate_swigregister
ConstantPairPredicate_swigregister(ConstantPairPredicate)

class UnorderedTypePairPredicate(IMP.kernel.PairPredicate):
    """Proxy of C++ IMP::core::UnorderedTypePairPredicate class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.PairPredicate]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, UnorderedTypePairPredicate, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.PairPredicate]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, UnorderedTypePairPredicate, name)
    def __init__(self, name="UnorderedTypePairPredicate%1%"): 
        """
        __init__(IMP::core::UnorderedTypePairPredicate self, std::string name="UnorderedTypePairPredicate%1%") -> UnorderedTypePairPredicate
        __init__(IMP::core::UnorderedTypePairPredicate self) -> UnorderedTypePairPredicate
        """
        this = _IMP_core.new_UnorderedTypePairPredicate(name)
        try: self.this.append(this)
        except: self.this = this
    def get_value(self, *args):
        """
        get_value(UnorderedTypePairPredicate self, IMP::kernel::ParticlePair const & a) -> int
        get_value(UnorderedTypePairPredicate self, IMP::kernel::ParticlePairsTemp const & o) -> IMP::Ints
        """
        return _IMP_core.UnorderedTypePairPredicate_get_value(self, *args)

    def get_value_index(self, *args):
        """
        get_value_index(UnorderedTypePairPredicate self, Model m, IMP::kernel::ParticleIndexPair const & pi) -> int
        get_value_index(UnorderedTypePairPredicate self, Model m, IMP::kernel::ParticleIndexPairs const & o) -> IMP::Ints
        """
        return _IMP_core.UnorderedTypePairPredicate_get_value_index(self, *args)

    def get_version_info(self):
        """get_version_info(UnorderedTypePairPredicate self) -> VersionInfo"""
        return _IMP_core.UnorderedTypePairPredicate_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_UnorderedTypePairPredicate
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(UnorderedTypePairPredicate self) -> std::string"""
        return _IMP_core.UnorderedTypePairPredicate___str__(self)

    def __repr__(self):
        """__repr__(UnorderedTypePairPredicate self) -> std::string"""
        return _IMP_core.UnorderedTypePairPredicate___repr__(self)

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

UnorderedTypePairPredicate_swigregister = _IMP_core.UnorderedTypePairPredicate_swigregister
UnorderedTypePairPredicate_swigregister(UnorderedTypePairPredicate)

class OrderedTypePairPredicate(IMP.kernel.PairPredicate):
    """Proxy of C++ IMP::core::OrderedTypePairPredicate class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.PairPredicate]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, OrderedTypePairPredicate, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.PairPredicate]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, OrderedTypePairPredicate, name)
    def __init__(self, name="OrderedTypePairPredicate%1%"): 
        """
        __init__(IMP::core::OrderedTypePairPredicate self, std::string name="OrderedTypePairPredicate%1%") -> OrderedTypePairPredicate
        __init__(IMP::core::OrderedTypePairPredicate self) -> OrderedTypePairPredicate
        """
        this = _IMP_core.new_OrderedTypePairPredicate(name)
        try: self.this.append(this)
        except: self.this = this
    def get_value_index(self, *args):
        """
        get_value_index(OrderedTypePairPredicate self, Model m, IMP::kernel::ParticleIndexPair const & pi) -> int
        get_value_index(OrderedTypePairPredicate self, Model m, IMP::kernel::ParticleIndexPairs const & o) -> IMP::Ints
        """
        return _IMP_core.OrderedTypePairPredicate_get_value_index(self, *args)

    def get_version_info(self):
        """get_version_info(OrderedTypePairPredicate self) -> VersionInfo"""
        return _IMP_core.OrderedTypePairPredicate_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_OrderedTypePairPredicate
    __del__ = lambda self : None;
    def get_value(self, *args):
        """
        get_value(OrderedTypePairPredicate self, IMP::kernel::ParticlePair const & a) -> int
        get_value(OrderedTypePairPredicate self, IMP::kernel::ParticlePairsTemp const & o) -> IMP::Ints
        get_value(OrderedTypePairPredicate self, IMP::core::ParticleTypes const & types) -> int
        """
        return _IMP_core.OrderedTypePairPredicate_get_value(self, *args)

    def __str__(self):
        """__str__(OrderedTypePairPredicate self) -> std::string"""
        return _IMP_core.OrderedTypePairPredicate___str__(self)

    def __repr__(self):
        """__repr__(OrderedTypePairPredicate self) -> std::string"""
        return _IMP_core.OrderedTypePairPredicate___repr__(self)

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

OrderedTypePairPredicate_swigregister = _IMP_core.OrderedTypePairPredicate_swigregister
OrderedTypePairPredicate_swigregister(OrderedTypePairPredicate)

class AllSamePairPredicate(IMP.kernel.PairPredicate):
    """Proxy of C++ IMP::core::AllSamePairPredicate class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.PairPredicate]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AllSamePairPredicate, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.PairPredicate]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AllSamePairPredicate, name)
    def __init__(self, name="AllSamePairPredicate%1%"): 
        """
        __init__(IMP::core::AllSamePairPredicate self, std::string name="AllSamePairPredicate%1%") -> AllSamePairPredicate
        __init__(IMP::core::AllSamePairPredicate self) -> AllSamePairPredicate
        """
        this = _IMP_core.new_AllSamePairPredicate(name)
        try: self.this.append(this)
        except: self.this = this
    def get_value(self, *args):
        """
        get_value(AllSamePairPredicate self, IMP::kernel::ParticlePair const & a) -> int
        get_value(AllSamePairPredicate self, IMP::kernel::ParticlePairsTemp const & o) -> IMP::Ints
        """
        return _IMP_core.AllSamePairPredicate_get_value(self, *args)

    def get_value_index(self, *args):
        """
        get_value_index(AllSamePairPredicate self, Model m, IMP::kernel::ParticleIndexPair const & pi) -> int
        get_value_index(AllSamePairPredicate self, Model m, IMP::kernel::ParticleIndexPairs const & o) -> IMP::Ints
        """
        return _IMP_core.AllSamePairPredicate_get_value_index(self, *args)

    def get_version_info(self):
        """get_version_info(AllSamePairPredicate self) -> VersionInfo"""
        return _IMP_core.AllSamePairPredicate_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_AllSamePairPredicate
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(AllSamePairPredicate self) -> std::string"""
        return _IMP_core.AllSamePairPredicate___str__(self)

    def __repr__(self):
        """__repr__(AllSamePairPredicate self) -> std::string"""
        return _IMP_core.AllSamePairPredicate___repr__(self)

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

AllSamePairPredicate_swigregister = _IMP_core.AllSamePairPredicate_swigregister
AllSamePairPredicate_swigregister(AllSamePairPredicate)

class CoinFlipPairPredicate(IMP.kernel.PairPredicate):
    """Proxy of C++ IMP::core::CoinFlipPairPredicate class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.PairPredicate]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CoinFlipPairPredicate, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.PairPredicate]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CoinFlipPairPredicate, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::CoinFlipPairPredicate self, double p, std::string name="CoinFlipPairPredicate%1%") -> CoinFlipPairPredicate
        __init__(IMP::core::CoinFlipPairPredicate self, double p) -> CoinFlipPairPredicate
        """
        this = _IMP_core.new_CoinFlipPairPredicate(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_value(self, *args):
        """
        get_value(CoinFlipPairPredicate self, IMP::kernel::ParticlePair const & a) -> int
        get_value(CoinFlipPairPredicate self, IMP::kernel::ParticlePairsTemp const & o) -> IMP::Ints
        """
        return _IMP_core.CoinFlipPairPredicate_get_value(self, *args)

    def get_value_index(self, *args):
        """
        get_value_index(CoinFlipPairPredicate self, Model m, IMP::kernel::ParticleIndexPair const & pi) -> int
        get_value_index(CoinFlipPairPredicate self, Model m, IMP::kernel::ParticleIndexPairs const & o) -> IMP::Ints
        """
        return _IMP_core.CoinFlipPairPredicate_get_value_index(self, *args)

    def get_version_info(self):
        """get_version_info(CoinFlipPairPredicate self) -> VersionInfo"""
        return _IMP_core.CoinFlipPairPredicate_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_CoinFlipPairPredicate
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(CoinFlipPairPredicate self) -> std::string"""
        return _IMP_core.CoinFlipPairPredicate___str__(self)

    def __repr__(self):
        """__repr__(CoinFlipPairPredicate self) -> std::string"""
        return _IMP_core.CoinFlipPairPredicate___repr__(self)

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

CoinFlipPairPredicate_swigregister = _IMP_core.CoinFlipPairPredicate_swigregister
CoinFlipPairPredicate_swigregister(CoinFlipPairPredicate)

class ConstantTripletPredicate(IMP.kernel.TripletPredicate):
    """Proxy of C++ IMP::core::ConstantTripletPredicate class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.TripletPredicate]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConstantTripletPredicate, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.TripletPredicate]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ConstantTripletPredicate, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::ConstantTripletPredicate self, int v, std::string name="ConstTripletPredicate%1%") -> ConstantTripletPredicate
        __init__(IMP::core::ConstantTripletPredicate self, int v) -> ConstantTripletPredicate
        """
        this = _IMP_core.new_ConstantTripletPredicate(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_value(self, *args):
        """
        get_value(ConstantTripletPredicate self, IMP::kernel::ParticleTriplet const & a) -> int
        get_value(ConstantTripletPredicate self, IMP::kernel::ParticleTripletsTemp const & o) -> IMP::Ints
        """
        return _IMP_core.ConstantTripletPredicate_get_value(self, *args)

    def get_value_index(self, *args):
        """
        get_value_index(ConstantTripletPredicate self, Model m, IMP::kernel::ParticleIndexTriplet const & pi) -> int
        get_value_index(ConstantTripletPredicate self, Model m, IMP::kernel::ParticleIndexTriplets const & o) -> IMP::Ints
        """
        return _IMP_core.ConstantTripletPredicate_get_value_index(self, *args)

    def get_version_info(self):
        """get_version_info(ConstantTripletPredicate self) -> VersionInfo"""
        return _IMP_core.ConstantTripletPredicate_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_ConstantTripletPredicate
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(ConstantTripletPredicate self) -> std::string"""
        return _IMP_core.ConstantTripletPredicate___str__(self)

    def __repr__(self):
        """__repr__(ConstantTripletPredicate self) -> std::string"""
        return _IMP_core.ConstantTripletPredicate___repr__(self)

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

ConstantTripletPredicate_swigregister = _IMP_core.ConstantTripletPredicate_swigregister
ConstantTripletPredicate_swigregister(ConstantTripletPredicate)

class UnorderedTypeTripletPredicate(IMP.kernel.TripletPredicate):
    """Proxy of C++ IMP::core::UnorderedTypeTripletPredicate class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.TripletPredicate]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, UnorderedTypeTripletPredicate, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.TripletPredicate]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, UnorderedTypeTripletPredicate, name)
    def __init__(self, name="UnorderedTypeTripletPredicate%1%"): 
        """
        __init__(IMP::core::UnorderedTypeTripletPredicate self, std::string name="UnorderedTypeTripletPredicate%1%") -> UnorderedTypeTripletPredicate
        __init__(IMP::core::UnorderedTypeTripletPredicate self) -> UnorderedTypeTripletPredicate
        """
        this = _IMP_core.new_UnorderedTypeTripletPredicate(name)
        try: self.this.append(this)
        except: self.this = this
    def get_value(self, *args):
        """
        get_value(UnorderedTypeTripletPredicate self, IMP::kernel::ParticleTriplet const & a) -> int
        get_value(UnorderedTypeTripletPredicate self, IMP::kernel::ParticleTripletsTemp const & o) -> IMP::Ints
        """
        return _IMP_core.UnorderedTypeTripletPredicate_get_value(self, *args)

    def get_value_index(self, *args):
        """
        get_value_index(UnorderedTypeTripletPredicate self, Model m, IMP::kernel::ParticleIndexTriplet const & pi) -> int
        get_value_index(UnorderedTypeTripletPredicate self, Model m, IMP::kernel::ParticleIndexTriplets const & o) -> IMP::Ints
        """
        return _IMP_core.UnorderedTypeTripletPredicate_get_value_index(self, *args)

    def get_version_info(self):
        """get_version_info(UnorderedTypeTripletPredicate self) -> VersionInfo"""
        return _IMP_core.UnorderedTypeTripletPredicate_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_UnorderedTypeTripletPredicate
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(UnorderedTypeTripletPredicate self) -> std::string"""
        return _IMP_core.UnorderedTypeTripletPredicate___str__(self)

    def __repr__(self):
        """__repr__(UnorderedTypeTripletPredicate self) -> std::string"""
        return _IMP_core.UnorderedTypeTripletPredicate___repr__(self)

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

UnorderedTypeTripletPredicate_swigregister = _IMP_core.UnorderedTypeTripletPredicate_swigregister
UnorderedTypeTripletPredicate_swigregister(UnorderedTypeTripletPredicate)

class OrderedTypeTripletPredicate(IMP.kernel.TripletPredicate):
    """Proxy of C++ IMP::core::OrderedTypeTripletPredicate class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.TripletPredicate]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, OrderedTypeTripletPredicate, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.TripletPredicate]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, OrderedTypeTripletPredicate, name)
    def __init__(self, name="OrderedTypeTripletPredicate%1%"): 
        """
        __init__(IMP::core::OrderedTypeTripletPredicate self, std::string name="OrderedTypeTripletPredicate%1%") -> OrderedTypeTripletPredicate
        __init__(IMP::core::OrderedTypeTripletPredicate self) -> OrderedTypeTripletPredicate
        """
        this = _IMP_core.new_OrderedTypeTripletPredicate(name)
        try: self.this.append(this)
        except: self.this = this
    def get_value_index(self, *args):
        """
        get_value_index(OrderedTypeTripletPredicate self, Model m, IMP::kernel::ParticleIndexTriplet const & pi) -> int
        get_value_index(OrderedTypeTripletPredicate self, Model m, IMP::kernel::ParticleIndexTriplets const & o) -> IMP::Ints
        """
        return _IMP_core.OrderedTypeTripletPredicate_get_value_index(self, *args)

    def get_version_info(self):
        """get_version_info(OrderedTypeTripletPredicate self) -> VersionInfo"""
        return _IMP_core.OrderedTypeTripletPredicate_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_OrderedTypeTripletPredicate
    __del__ = lambda self : None;
    def get_value(self, *args):
        """
        get_value(OrderedTypeTripletPredicate self, IMP::kernel::ParticleTriplet const & a) -> int
        get_value(OrderedTypeTripletPredicate self, IMP::kernel::ParticleTripletsTemp const & o) -> IMP::Ints
        get_value(OrderedTypeTripletPredicate self, IMP::core::ParticleTypes const & types) -> int
        """
        return _IMP_core.OrderedTypeTripletPredicate_get_value(self, *args)

    def __str__(self):
        """__str__(OrderedTypeTripletPredicate self) -> std::string"""
        return _IMP_core.OrderedTypeTripletPredicate___str__(self)

    def __repr__(self):
        """__repr__(OrderedTypeTripletPredicate self) -> std::string"""
        return _IMP_core.OrderedTypeTripletPredicate___repr__(self)

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

OrderedTypeTripletPredicate_swigregister = _IMP_core.OrderedTypeTripletPredicate_swigregister
OrderedTypeTripletPredicate_swigregister(OrderedTypeTripletPredicate)

class AllSameTripletPredicate(IMP.kernel.TripletPredicate):
    """Proxy of C++ IMP::core::AllSameTripletPredicate class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.TripletPredicate]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AllSameTripletPredicate, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.TripletPredicate]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AllSameTripletPredicate, name)
    def __init__(self, name="AllSameTripletPredicate%1%"): 
        """
        __init__(IMP::core::AllSameTripletPredicate self, std::string name="AllSameTripletPredicate%1%") -> AllSameTripletPredicate
        __init__(IMP::core::AllSameTripletPredicate self) -> AllSameTripletPredicate
        """
        this = _IMP_core.new_AllSameTripletPredicate(name)
        try: self.this.append(this)
        except: self.this = this
    def get_value(self, *args):
        """
        get_value(AllSameTripletPredicate self, IMP::kernel::ParticleTriplet const & a) -> int
        get_value(AllSameTripletPredicate self, IMP::kernel::ParticleTripletsTemp const & o) -> IMP::Ints
        """
        return _IMP_core.AllSameTripletPredicate_get_value(self, *args)

    def get_value_index(self, *args):
        """
        get_value_index(AllSameTripletPredicate self, Model m, IMP::kernel::ParticleIndexTriplet const & pi) -> int
        get_value_index(AllSameTripletPredicate self, Model m, IMP::kernel::ParticleIndexTriplets const & o) -> IMP::Ints
        """
        return _IMP_core.AllSameTripletPredicate_get_value_index(self, *args)

    def get_version_info(self):
        """get_version_info(AllSameTripletPredicate self) -> VersionInfo"""
        return _IMP_core.AllSameTripletPredicate_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_AllSameTripletPredicate
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(AllSameTripletPredicate self) -> std::string"""
        return _IMP_core.AllSameTripletPredicate___str__(self)

    def __repr__(self):
        """__repr__(AllSameTripletPredicate self) -> std::string"""
        return _IMP_core.AllSameTripletPredicate___repr__(self)

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

AllSameTripletPredicate_swigregister = _IMP_core.AllSameTripletPredicate_swigregister
AllSameTripletPredicate_swigregister(AllSameTripletPredicate)

class CoinFlipTripletPredicate(IMP.kernel.TripletPredicate):
    """Proxy of C++ IMP::core::CoinFlipTripletPredicate class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.TripletPredicate]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CoinFlipTripletPredicate, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.TripletPredicate]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CoinFlipTripletPredicate, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::CoinFlipTripletPredicate self, double p, std::string name="CoinFlipTripletPredicate%1%") -> CoinFlipTripletPredicate
        __init__(IMP::core::CoinFlipTripletPredicate self, double p) -> CoinFlipTripletPredicate
        """
        this = _IMP_core.new_CoinFlipTripletPredicate(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_value(self, *args):
        """
        get_value(CoinFlipTripletPredicate self, IMP::kernel::ParticleTriplet const & a) -> int
        get_value(CoinFlipTripletPredicate self, IMP::kernel::ParticleTripletsTemp const & o) -> IMP::Ints
        """
        return _IMP_core.CoinFlipTripletPredicate_get_value(self, *args)

    def get_value_index(self, *args):
        """
        get_value_index(CoinFlipTripletPredicate self, Model m, IMP::kernel::ParticleIndexTriplet const & pi) -> int
        get_value_index(CoinFlipTripletPredicate self, Model m, IMP::kernel::ParticleIndexTriplets const & o) -> IMP::Ints
        """
        return _IMP_core.CoinFlipTripletPredicate_get_value_index(self, *args)

    def get_version_info(self):
        """get_version_info(CoinFlipTripletPredicate self) -> VersionInfo"""
        return _IMP_core.CoinFlipTripletPredicate_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_CoinFlipTripletPredicate
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(CoinFlipTripletPredicate self) -> std::string"""
        return _IMP_core.CoinFlipTripletPredicate___str__(self)

    def __repr__(self):
        """__repr__(CoinFlipTripletPredicate self) -> std::string"""
        return _IMP_core.CoinFlipTripletPredicate___repr__(self)

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

CoinFlipTripletPredicate_swigregister = _IMP_core.CoinFlipTripletPredicate_swigregister
CoinFlipTripletPredicate_swigregister(CoinFlipTripletPredicate)

class ConstantQuadPredicate(IMP.kernel.QuadPredicate):
    """Proxy of C++ IMP::core::ConstantQuadPredicate class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.QuadPredicate]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConstantQuadPredicate, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.QuadPredicate]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ConstantQuadPredicate, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::ConstantQuadPredicate self, int v, std::string name="ConstQuadPredicate%1%") -> ConstantQuadPredicate
        __init__(IMP::core::ConstantQuadPredicate self, int v) -> ConstantQuadPredicate
        """
        this = _IMP_core.new_ConstantQuadPredicate(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_value(self, *args):
        """
        get_value(ConstantQuadPredicate self, IMP::kernel::ParticleQuad const & a) -> int
        get_value(ConstantQuadPredicate self, IMP::kernel::ParticleQuadsTemp const & o) -> IMP::Ints
        """
        return _IMP_core.ConstantQuadPredicate_get_value(self, *args)

    def get_value_index(self, *args):
        """
        get_value_index(ConstantQuadPredicate self, Model m, IMP::kernel::ParticleIndexQuad const & pi) -> int
        get_value_index(ConstantQuadPredicate self, Model m, IMP::kernel::ParticleIndexQuads const & o) -> IMP::Ints
        """
        return _IMP_core.ConstantQuadPredicate_get_value_index(self, *args)

    def get_version_info(self):
        """get_version_info(ConstantQuadPredicate self) -> VersionInfo"""
        return _IMP_core.ConstantQuadPredicate_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_ConstantQuadPredicate
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(ConstantQuadPredicate self) -> std::string"""
        return _IMP_core.ConstantQuadPredicate___str__(self)

    def __repr__(self):
        """__repr__(ConstantQuadPredicate self) -> std::string"""
        return _IMP_core.ConstantQuadPredicate___repr__(self)

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

ConstantQuadPredicate_swigregister = _IMP_core.ConstantQuadPredicate_swigregister
ConstantQuadPredicate_swigregister(ConstantQuadPredicate)

class UnorderedTypeQuadPredicate(IMP.kernel.QuadPredicate):
    """Proxy of C++ IMP::core::UnorderedTypeQuadPredicate class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.QuadPredicate]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, UnorderedTypeQuadPredicate, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.QuadPredicate]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, UnorderedTypeQuadPredicate, name)
    def __init__(self, name="UnorderedTypeQuadPredicate%1%"): 
        """
        __init__(IMP::core::UnorderedTypeQuadPredicate self, std::string name="UnorderedTypeQuadPredicate%1%") -> UnorderedTypeQuadPredicate
        __init__(IMP::core::UnorderedTypeQuadPredicate self) -> UnorderedTypeQuadPredicate
        """
        this = _IMP_core.new_UnorderedTypeQuadPredicate(name)
        try: self.this.append(this)
        except: self.this = this
    def get_value(self, *args):
        """
        get_value(UnorderedTypeQuadPredicate self, IMP::kernel::ParticleQuad const & a) -> int
        get_value(UnorderedTypeQuadPredicate self, IMP::kernel::ParticleQuadsTemp const & o) -> IMP::Ints
        """
        return _IMP_core.UnorderedTypeQuadPredicate_get_value(self, *args)

    def get_value_index(self, *args):
        """
        get_value_index(UnorderedTypeQuadPredicate self, Model m, IMP::kernel::ParticleIndexQuad const & pi) -> int
        get_value_index(UnorderedTypeQuadPredicate self, Model m, IMP::kernel::ParticleIndexQuads const & o) -> IMP::Ints
        """
        return _IMP_core.UnorderedTypeQuadPredicate_get_value_index(self, *args)

    def get_version_info(self):
        """get_version_info(UnorderedTypeQuadPredicate self) -> VersionInfo"""
        return _IMP_core.UnorderedTypeQuadPredicate_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_UnorderedTypeQuadPredicate
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(UnorderedTypeQuadPredicate self) -> std::string"""
        return _IMP_core.UnorderedTypeQuadPredicate___str__(self)

    def __repr__(self):
        """__repr__(UnorderedTypeQuadPredicate self) -> std::string"""
        return _IMP_core.UnorderedTypeQuadPredicate___repr__(self)

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

UnorderedTypeQuadPredicate_swigregister = _IMP_core.UnorderedTypeQuadPredicate_swigregister
UnorderedTypeQuadPredicate_swigregister(UnorderedTypeQuadPredicate)

class OrderedTypeQuadPredicate(IMP.kernel.QuadPredicate):
    """Proxy of C++ IMP::core::OrderedTypeQuadPredicate class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.QuadPredicate]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, OrderedTypeQuadPredicate, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.QuadPredicate]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, OrderedTypeQuadPredicate, name)
    def __init__(self, name="OrderedTypeQuadPredicate%1%"): 
        """
        __init__(IMP::core::OrderedTypeQuadPredicate self, std::string name="OrderedTypeQuadPredicate%1%") -> OrderedTypeQuadPredicate
        __init__(IMP::core::OrderedTypeQuadPredicate self) -> OrderedTypeQuadPredicate
        """
        this = _IMP_core.new_OrderedTypeQuadPredicate(name)
        try: self.this.append(this)
        except: self.this = this
    def get_value_index(self, *args):
        """
        get_value_index(OrderedTypeQuadPredicate self, Model m, IMP::kernel::ParticleIndexQuad const & pi) -> int
        get_value_index(OrderedTypeQuadPredicate self, Model m, IMP::kernel::ParticleIndexQuads const & o) -> IMP::Ints
        """
        return _IMP_core.OrderedTypeQuadPredicate_get_value_index(self, *args)

    def get_version_info(self):
        """get_version_info(OrderedTypeQuadPredicate self) -> VersionInfo"""
        return _IMP_core.OrderedTypeQuadPredicate_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_OrderedTypeQuadPredicate
    __del__ = lambda self : None;
    def get_value(self, *args):
        """
        get_value(OrderedTypeQuadPredicate self, IMP::kernel::ParticleQuad const & a) -> int
        get_value(OrderedTypeQuadPredicate self, IMP::kernel::ParticleQuadsTemp const & o) -> IMP::Ints
        get_value(OrderedTypeQuadPredicate self, IMP::core::ParticleTypes const & types) -> int
        """
        return _IMP_core.OrderedTypeQuadPredicate_get_value(self, *args)

    def __str__(self):
        """__str__(OrderedTypeQuadPredicate self) -> std::string"""
        return _IMP_core.OrderedTypeQuadPredicate___str__(self)

    def __repr__(self):
        """__repr__(OrderedTypeQuadPredicate self) -> std::string"""
        return _IMP_core.OrderedTypeQuadPredicate___repr__(self)

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

OrderedTypeQuadPredicate_swigregister = _IMP_core.OrderedTypeQuadPredicate_swigregister
OrderedTypeQuadPredicate_swigregister(OrderedTypeQuadPredicate)

class AllSameQuadPredicate(IMP.kernel.QuadPredicate):
    """Proxy of C++ IMP::core::AllSameQuadPredicate class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.QuadPredicate]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AllSameQuadPredicate, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.QuadPredicate]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AllSameQuadPredicate, name)
    def __init__(self, name="AllSameQuadPredicate%1%"): 
        """
        __init__(IMP::core::AllSameQuadPredicate self, std::string name="AllSameQuadPredicate%1%") -> AllSameQuadPredicate
        __init__(IMP::core::AllSameQuadPredicate self) -> AllSameQuadPredicate
        """
        this = _IMP_core.new_AllSameQuadPredicate(name)
        try: self.this.append(this)
        except: self.this = this
    def get_value(self, *args):
        """
        get_value(AllSameQuadPredicate self, IMP::kernel::ParticleQuad const & a) -> int
        get_value(AllSameQuadPredicate self, IMP::kernel::ParticleQuadsTemp const & o) -> IMP::Ints
        """
        return _IMP_core.AllSameQuadPredicate_get_value(self, *args)

    def get_value_index(self, *args):
        """
        get_value_index(AllSameQuadPredicate self, Model m, IMP::kernel::ParticleIndexQuad const & pi) -> int
        get_value_index(AllSameQuadPredicate self, Model m, IMP::kernel::ParticleIndexQuads const & o) -> IMP::Ints
        """
        return _IMP_core.AllSameQuadPredicate_get_value_index(self, *args)

    def get_version_info(self):
        """get_version_info(AllSameQuadPredicate self) -> VersionInfo"""
        return _IMP_core.AllSameQuadPredicate_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_AllSameQuadPredicate
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(AllSameQuadPredicate self) -> std::string"""
        return _IMP_core.AllSameQuadPredicate___str__(self)

    def __repr__(self):
        """__repr__(AllSameQuadPredicate self) -> std::string"""
        return _IMP_core.AllSameQuadPredicate___repr__(self)

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

AllSameQuadPredicate_swigregister = _IMP_core.AllSameQuadPredicate_swigregister
AllSameQuadPredicate_swigregister(AllSameQuadPredicate)

class CoinFlipQuadPredicate(IMP.kernel.QuadPredicate):
    """Proxy of C++ IMP::core::CoinFlipQuadPredicate class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.QuadPredicate]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CoinFlipQuadPredicate, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.QuadPredicate]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CoinFlipQuadPredicate, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::CoinFlipQuadPredicate self, double p, std::string name="CoinFlipQuadPredicate%1%") -> CoinFlipQuadPredicate
        __init__(IMP::core::CoinFlipQuadPredicate self, double p) -> CoinFlipQuadPredicate
        """
        this = _IMP_core.new_CoinFlipQuadPredicate(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_value(self, *args):
        """
        get_value(CoinFlipQuadPredicate self, IMP::kernel::ParticleQuad const & a) -> int
        get_value(CoinFlipQuadPredicate self, IMP::kernel::ParticleQuadsTemp const & o) -> IMP::Ints
        """
        return _IMP_core.CoinFlipQuadPredicate_get_value(self, *args)

    def get_value_index(self, *args):
        """
        get_value_index(CoinFlipQuadPredicate self, Model m, IMP::kernel::ParticleIndexQuad const & pi) -> int
        get_value_index(CoinFlipQuadPredicate self, Model m, IMP::kernel::ParticleIndexQuads const & o) -> IMP::Ints
        """
        return _IMP_core.CoinFlipQuadPredicate_get_value_index(self, *args)

    def get_version_info(self):
        """get_version_info(CoinFlipQuadPredicate self) -> VersionInfo"""
        return _IMP_core.CoinFlipQuadPredicate_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_CoinFlipQuadPredicate
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(CoinFlipQuadPredicate self) -> std::string"""
        return _IMP_core.CoinFlipQuadPredicate___str__(self)

    def __repr__(self):
        """__repr__(CoinFlipQuadPredicate self) -> std::string"""
        return _IMP_core.CoinFlipQuadPredicate___repr__(self)

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

CoinFlipQuadPredicate_swigregister = _IMP_core.CoinFlipQuadPredicate_swigregister
CoinFlipQuadPredicate_swigregister(CoinFlipQuadPredicate)

class AngleRestraint(TripletRestraint):
    """Proxy of C++ IMP::core::AngleRestraint class"""
    __swig_setmethods__ = {}
    for _s in [TripletRestraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AngleRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [TripletRestraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AngleRestraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::AngleRestraint self, UnaryFunction score_func, Particle p1, Particle p2, Particle p3) -> AngleRestraint
        __init__(IMP::core::AngleRestraint self, UnaryFunction score_func, XYZ p0, XYZ p1, XYZ p2) -> AngleRestraint
        """
        this = _IMP_core.new_AngleRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_show(self, *args):
        """do_show(AngleRestraint self, _ostream out)"""
        return _IMP_core.AngleRestraint_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_AngleRestraint
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(AngleRestraint self) -> std::string"""
        return _IMP_core.AngleRestraint___str__(self)

    def __repr__(self):
        """__repr__(AngleRestraint self) -> std::string"""
        return _IMP_core.AngleRestraint___repr__(self)

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

AngleRestraint_swigregister = _IMP_core.AngleRestraint_swigregister
AngleRestraint_swigregister(AngleRestraint)

class RigidBodyMover(MonteCarloMover):
    """Proxy of C++ IMP::core::RigidBodyMover class"""
    __swig_setmethods__ = {}
    for _s in [MonteCarloMover]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RigidBodyMover, name, value)
    __swig_getmethods__ = {}
    for _s in [MonteCarloMover]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RigidBodyMover, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::RigidBodyMover self, Model m, IMP::kernel::ParticleIndex pi, IMP::Float max_translation, IMP::Float max_rotation) -> RigidBodyMover
        __init__(IMP::core::RigidBodyMover self, RigidBody d, IMP::Float max_translation, IMP::Float max_rotation) -> RigidBodyMover
        """
        this = _IMP_core.new_RigidBodyMover(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_maximum_translation(self, *args):
        """set_maximum_translation(RigidBodyMover self, IMP::Float mt)"""
        return _IMP_core.RigidBodyMover_set_maximum_translation(self, *args)

    def set_maximum_rotation(self, *args):
        """set_maximum_rotation(RigidBodyMover self, IMP::Float mr)"""
        return _IMP_core.RigidBodyMover_set_maximum_rotation(self, *args)

    def get_maximum_translation(self):
        """get_maximum_translation(RigidBodyMover self) -> IMP::Float"""
        return _IMP_core.RigidBodyMover_get_maximum_translation(self)

    def get_maximum_rotation(self):
        """get_maximum_rotation(RigidBodyMover self) -> IMP::Float"""
        return _IMP_core.RigidBodyMover_get_maximum_rotation(self)

    def get_version_info(self):
        """get_version_info(RigidBodyMover self) -> VersionInfo"""
        return _IMP_core.RigidBodyMover_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_RigidBodyMover
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(RigidBodyMover self) -> std::string"""
        return _IMP_core.RigidBodyMover___str__(self)

    def __repr__(self):
        """__repr__(RigidBodyMover self) -> std::string"""
        return _IMP_core.RigidBodyMover___repr__(self)

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

RigidBodyMover_swigregister = _IMP_core.RigidBodyMover_swigregister
RigidBodyMover_swigregister(RigidBodyMover)

class VolumeRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::core::VolumeRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, VolumeRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, VolumeRestraint, name)
    def __init__(self, *args): 
        """__init__(IMP::core::VolumeRestraint self, UnaryFunction f, SingletonContainer sc, double volume) -> VolumeRestraint"""
        this = _IMP_core.new_VolumeRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_input_particles(self):
        """get_input_particles(VolumeRestraint self) -> IMP::kernel::ParticlesTemp"""
        return _IMP_core.VolumeRestraint_get_input_particles(self)

    def get_input_containers(self):
        """get_input_containers(VolumeRestraint self) -> IMP::kernel::ContainersTemp"""
        return _IMP_core.VolumeRestraint_get_input_containers(self)

    def do_get_inputs(self):
        """do_get_inputs(VolumeRestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_core.VolumeRestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(VolumeRestraint self) -> VersionInfo"""
        return _IMP_core.VolumeRestraint_get_version_info(self)

    def do_show(self, *args):
        """do_show(VolumeRestraint self, _ostream out)"""
        return _IMP_core.VolumeRestraint_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_VolumeRestraint
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(VolumeRestraint self) -> std::string"""
        return _IMP_core.VolumeRestraint___str__(self)

    def __repr__(self):
        """__repr__(VolumeRestraint self) -> std::string"""
        return _IMP_core.VolumeRestraint___repr__(self)

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

VolumeRestraint_swigregister = _IMP_core.VolumeRestraint_swigregister
VolumeRestraint_swigregister(VolumeRestraint)


def get_centroid(*args):
  """get_centroid(IMP::core::XYZs const & ps) -> Vector3D"""
  return _IMP_core.get_centroid(*args)

def get_bounding_box(*args):
  """get_bounding_box(IMP::core::XYZRs const & ps) -> BoundingBox3D"""
  return _IMP_core.get_bounding_box(*args)
class MoveStatisticsScoreState(IMP.kernel.ScoreState):
    """Proxy of C++ IMP::core::MoveStatisticsScoreState class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.ScoreState]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MoveStatisticsScoreState, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.ScoreState]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MoveStatisticsScoreState, name)
    def __init__(self, *args): 
        """__init__(IMP::core::MoveStatisticsScoreState self, IMP::kernel::ParticlesTemp const & ps) -> MoveStatisticsScoreState"""
        this = _IMP_core.new_MoveStatisticsScoreState(*args)
        try: self.this.append(this)
        except: self.this = this
    def show_statistics(self, *args):
        """
        show_statistics(MoveStatisticsScoreState self, _ostream out=std::cout)
        show_statistics(MoveStatisticsScoreState self)
        """
        return _IMP_core.MoveStatisticsScoreState_show_statistics(self, *args)

    def reset(self):
        """reset(MoveStatisticsScoreState self)"""
        return _IMP_core.MoveStatisticsScoreState_reset(self)

    def get_input_particles(self):
        """get_input_particles(MoveStatisticsScoreState self) -> IMP::kernel::ParticlesTemp"""
        return _IMP_core.MoveStatisticsScoreState_get_input_particles(self)

    def get_input_containers(self):
        """get_input_containers(MoveStatisticsScoreState self) -> IMP::kernel::ContainersTemp"""
        return _IMP_core.MoveStatisticsScoreState_get_input_containers(self)

    def do_get_inputs(self):
        """do_get_inputs(MoveStatisticsScoreState self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_core.MoveStatisticsScoreState_do_get_inputs(self)

    def get_output_particles(self):
        """get_output_particles(MoveStatisticsScoreState self) -> IMP::kernel::ParticlesTemp"""
        return _IMP_core.MoveStatisticsScoreState_get_output_particles(self)

    def get_output_containers(self):
        """get_output_containers(MoveStatisticsScoreState self) -> IMP::kernel::ContainersTemp"""
        return _IMP_core.MoveStatisticsScoreState_get_output_containers(self)

    def do_get_outputs(self):
        """do_get_outputs(MoveStatisticsScoreState self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_core.MoveStatisticsScoreState_do_get_outputs(self)

    def get_version_info(self):
        """get_version_info(MoveStatisticsScoreState self) -> VersionInfo"""
        return _IMP_core.MoveStatisticsScoreState_get_version_info(self)

    def do_show(self, *args):
        """do_show(MoveStatisticsScoreState self, _ostream out)"""
        return _IMP_core.MoveStatisticsScoreState_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_MoveStatisticsScoreState
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(MoveStatisticsScoreState self) -> std::string"""
        return _IMP_core.MoveStatisticsScoreState___str__(self)

    def __repr__(self):
        """__repr__(MoveStatisticsScoreState self) -> std::string"""
        return _IMP_core.MoveStatisticsScoreState___repr__(self)

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

MoveStatisticsScoreState_swigregister = _IMP_core.MoveStatisticsScoreState_swigregister
MoveStatisticsScoreState_swigregister(MoveStatisticsScoreState)

IMP_PARTICLE_TYPE_INDEX = _IMP_core.IMP_PARTICLE_TYPE_INDEX
class Typed(IMP.kernel.Decorator):
    """Proxy of C++ IMP::core::Typed class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Decorator]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Typed, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Decorator]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Typed, name)
    def get_type_key():
        """get_type_key() -> IntKey"""
        return _IMP_core.Typed_get_type_key()

    if _newclass:get_type_key = staticmethod(get_type_key)
    __swig_getmethods__["get_type_key"] = lambda x: get_type_key
    def __init__(self, *args): 
        """
        __init__(IMP::core::Typed self) -> Typed
        __init__(IMP::core::Typed self, Model m, IMP::kernel::ParticleIndex id) -> Typed
        __init__(IMP::core::Typed self, Particle p) -> Typed
        """
        this = _IMP_core.new_Typed(*args)
        try: self.this.append(this)
        except: self.this = this
    def decorate_particle(*args):
        """decorate_particle(Particle p) -> Typed"""
        return _IMP_core.Typed_decorate_particle(*args)

    if _newclass:decorate_particle = staticmethod(decorate_particle)
    __swig_getmethods__["decorate_particle"] = lambda x: decorate_particle
    def show(self, *args):
        """
        show(Typed self, _ostream out=std::cout)
        show(Typed self)
        """
        return _IMP_core.Typed_show(self, *args)

    def setup_particle(*args):
        """setup_particle(Particle p, ParticleType t) -> Typed"""
        return _IMP_core.Typed_setup_particle(*args)

    if _newclass:setup_particle = staticmethod(setup_particle)
    __swig_getmethods__["setup_particle"] = lambda x: setup_particle
    def particle_is_instance(*args):
        """
        particle_is_instance(Particle p) -> bool
        particle_is_instance(Model m, IMP::kernel::ParticleIndex pi) -> bool
        """
        return _IMP_core.Typed_particle_is_instance(*args)

    if _newclass:particle_is_instance = staticmethod(particle_is_instance)
    __swig_getmethods__["particle_is_instance"] = lambda x: particle_is_instance
    def get_type(self):
        """get_type(Typed self) -> ParticleType"""
        return _IMP_core.Typed_get_type(self)

    def add_attribute(self, *args):
        """
        add_attribute(Typed self, FloatKey k, IMP::Float v, bool opt)
        add_attribute(Typed self, FloatKey a0, IMP::Float a1)
        add_attribute(Typed self, IntKey a0, IMP::Int a1)
        add_attribute(Typed self, StringKey a0, IMP::String a1)
        add_attribute(Typed self, ParticleIndexKey a0, Particle a1)
        add_attribute(Typed self, ObjectKey a0, IMP::Object * a1)
        """
        return _IMP_core.Typed_add_attribute(self, *args)

    def get_value(self, *args):
        """
        get_value(Typed self, FloatKey a0) -> IMP::Float
        get_value(Typed self, IntKey a0) -> IMP::Int
        get_value(Typed self, StringKey a0) -> IMP::String
        get_value(Typed self, ParticleIndexKey a0) -> Particle
        get_value(Typed self, ObjectKey a0) -> IMP::Object *
        """
        return _IMP_core.Typed_get_value(self, *args)

    def set_value(self, *args):
        """
        set_value(Typed self, FloatKey a0, IMP::Float a1)
        set_value(Typed self, IntKey a0, IMP::Int a1)
        set_value(Typed self, StringKey a0, IMP::String a1)
        set_value(Typed self, ParticleIndexKey a0, Particle a1)
        set_value(Typed self, ObjectKey a0, IMP::Object * a1)
        """
        return _IMP_core.Typed_set_value(self, *args)

    def remove_attribute(self, *args):
        """
        remove_attribute(Typed self, FloatKey a0)
        remove_attribute(Typed self, IntKey a0)
        remove_attribute(Typed self, StringKey a0)
        remove_attribute(Typed self, ParticleIndexKey a0)
        remove_attribute(Typed self, ObjectKey a0)
        """
        return _IMP_core.Typed_remove_attribute(self, *args)

    def has_attribute(self, *args):
        """
        has_attribute(Typed self, FloatKey a0) -> bool
        has_attribute(Typed self, IntKey a0) -> bool
        has_attribute(Typed self, StringKey a0) -> bool
        has_attribute(Typed self, ParticleIndexKey a0) -> bool
        has_attribute(Typed self, ObjectKey a0) -> bool
        """
        return _IMP_core.Typed_has_attribute(self, *args)

    def get_derivative(self, *args):
        """get_derivative(Typed self, FloatKey a0) -> double"""
        return _IMP_core.Typed_get_derivative(self, *args)

    def get_name(self):
        """get_name(Typed self) -> std::string"""
        return _IMP_core.Typed_get_name(self)

    def clear_caches(self):
        """clear_caches(Typed self)"""
        return _IMP_core.Typed_clear_caches(self)

    def set_name(self, *args):
        """set_name(Typed self, std::string a0)"""
        return _IMP_core.Typed_set_name(self, *args)

    def set_check_level(self, *args):
        """set_check_level(Typed self, IMP::base::CheckLevel a0)"""
        return _IMP_core.Typed_set_check_level(self, *args)

    def add_to_derivative(self, *args):
        """add_to_derivative(Typed self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_core.Typed_add_to_derivative(self, *args)

    def set_is_optimized(self, *args):
        """set_is_optimized(Typed self, FloatKey a0, bool a1)"""
        return _IMP_core.Typed_set_is_optimized(self, *args)

    def get_is_optimized(self, *args):
        """get_is_optimized(Typed self, FloatKey a0) -> bool"""
        return _IMP_core.Typed_get_is_optimized(self, *args)

    def get_check_level(self):
        """get_check_level(Typed self) -> IMP::base::CheckLevel"""
        return _IMP_core.Typed_get_check_level(self)

    def __eq__(self, *args):
        """
        __eq__(Typed self, Typed o) -> bool
        __eq__(Typed self, Particle d) -> bool
        """
        return _IMP_core.Typed___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(Typed self, Typed o) -> bool
        __ne__(Typed self, Particle d) -> bool
        """
        return _IMP_core.Typed___ne__(self, *args)

    def __le__(self, *args):
        """
        __le__(Typed self, Typed o) -> bool
        __le__(Typed self, Particle d) -> bool
        """
        return _IMP_core.Typed___le__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(Typed self, Typed o) -> bool
        __lt__(Typed self, Particle d) -> bool
        """
        return _IMP_core.Typed___lt__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(Typed self, Typed o) -> bool
        __ge__(Typed self, Particle d) -> bool
        """
        return _IMP_core.Typed___ge__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(Typed self, Typed o) -> bool
        __gt__(Typed self, Particle d) -> bool
        """
        return _IMP_core.Typed___gt__(self, *args)

    def __str__(self):
        """__str__(Typed self) -> std::string"""
        return _IMP_core.Typed___str__(self)

    def __repr__(self):
        """__repr__(Typed self) -> std::string"""
        return _IMP_core.Typed___repr__(self)

    __swig_destroy__ = _IMP_core.delete_Typed
    __del__ = lambda self : None;
Typed_swigregister = _IMP_core.Typed_swigregister
Typed_swigregister(Typed)

def Typed_get_type_key():
  """Typed_get_type_key() -> IntKey"""
  return _IMP_core.Typed_get_type_key()

def Typed_decorate_particle(*args):
  """Typed_decorate_particle(Particle p) -> Typed"""
  return _IMP_core.Typed_decorate_particle(*args)

def Typed_setup_particle(*args):
  """Typed_setup_particle(Particle p, ParticleType t) -> Typed"""
  return _IMP_core.Typed_setup_particle(*args)

def Typed_particle_is_instance(*args):
  """
    particle_is_instance(Particle p) -> bool
    Typed_particle_is_instance(Model m, IMP::kernel::ParticleIndex pi) -> bool
    """
  return _IMP_core.Typed_particle_is_instance(*args)


def __lshift__(*args):
  """
    __lshift__(_ostream out, XYZ n) -> _ostream
    __lshift__(_ostream out, XYZR n) -> _ostream
    __lshift__(_ostream out, Centroid n) -> _ostream
    __lshift__(_ostream out, Cover n) -> _ostream
    __lshift__(_ostream out, Reference n) -> _ostream
    __lshift__(_ostream out, RigidMember n) -> _ostream
    __lshift__(_ostream out, RigidBody n) -> _ostream
    __lshift__(_ostream out, Typed n) -> _ostream
    """
  return _IMP_core.__lshift__(*args)
class WriteRestraintScoresOptimizerState(PeriodicOptimizerState):
    """Proxy of C++ IMP::core::WriteRestraintScoresOptimizerState class"""
    __swig_setmethods__ = {}
    for _s in [PeriodicOptimizerState]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, WriteRestraintScoresOptimizerState, name, value)
    __swig_getmethods__ = {}
    for _s in [PeriodicOptimizerState]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, WriteRestraintScoresOptimizerState, name)
    def __init__(self, *args): 
        """__init__(IMP::core::WriteRestraintScoresOptimizerState self, IMP::kernel::Restraints const & rs, TextOutput out) -> WriteRestraintScoresOptimizerState"""
        this = _IMP_core.new_WriteRestraintScoresOptimizerState(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(WriteRestraintScoresOptimizerState self) -> VersionInfo"""
        return _IMP_core.WriteRestraintScoresOptimizerState_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_WriteRestraintScoresOptimizerState
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(WriteRestraintScoresOptimizerState self) -> std::string"""
        return _IMP_core.WriteRestraintScoresOptimizerState___str__(self)

    def __repr__(self):
        """__repr__(WriteRestraintScoresOptimizerState self) -> std::string"""
        return _IMP_core.WriteRestraintScoresOptimizerState___repr__(self)

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

WriteRestraintScoresOptimizerState_swigregister = _IMP_core.WriteRestraintScoresOptimizerState_swigregister
WriteRestraintScoresOptimizerState_swigregister(WriteRestraintScoresOptimizerState)


def assign_blame(*args):
  """assign_blame(IMP::kernel::RestraintsTemp const & rs, IMP::kernel::ParticlesTemp const & ps, FloatKey attribute)"""
  return _IMP_core.assign_blame(*args)

def create_blame_geometries(*args):
  """
    create_blame_geometries(IMP::kernel::RestraintsTemp const & rs, IMP::kernel::ParticlesTemp const & ps, double max=NO_MAX, 
        std::string name=std::string()) -> IMP::display::Geometries
    create_blame_geometries(IMP::kernel::RestraintsTemp const & rs, IMP::kernel::ParticlesTemp const & ps, double max=NO_MAX) -> IMP::display::Geometries
    create_blame_geometries(IMP::kernel::RestraintsTemp const & rs, IMP::kernel::ParticlesTemp const & ps) -> IMP::display::Geometries
    """
  return _IMP_core.create_blame_geometries(*args)

def get_transformation_aligning_first_to_second(*args):
  """
    get_transformation_aligning_first_to_second(IMP::kernel::ParticlesTemp const & a, IMP::kernel::ParticlesTemp const & b) -> Transformation3D
    get_transformation_aligning_first_to_second(IMP::kernel::ParticlesTemp const & a, IMP::base::Vector< IMP::algebra::VectorD< 3 > > const & b) -> Transformation3D
    get_transformation_aligning_first_to_second(IMP::base::Vector< IMP::algebra::VectorD< 3 > > const & a, IMP::kernel::ParticlesTemp const & b) -> Transformation3D
    """
  return _IMP_core.get_transformation_aligning_first_to_second(*args)
class TruncatedHarmonicLowerBound(IMP.kernel.UnaryFunction):
    """Proxy of C++ IMP::core::TruncatedHarmonic<(IMP::core::LOWER)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.UnaryFunction]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TruncatedHarmonicLowerBound, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.UnaryFunction]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TruncatedHarmonicLowerBound, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::TruncatedHarmonic<(IMP::core::LOWER)> self, IMP::Float center, IMP::Float k, IMP::Float threshold, IMP::Float limit) -> TruncatedHarmonicLowerBound
        __init__(IMP::core::TruncatedHarmonic<(IMP::core::LOWER)> self, IMP::Float center, IMP::Float k, IMP::Float threshold) -> TruncatedHarmonicLowerBound
        """
        this = _IMP_core.new_TruncatedHarmonicLowerBound(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(TruncatedHarmonicLowerBound self) -> VersionInfo"""
        return _IMP_core.TruncatedHarmonicLowerBound_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_TruncatedHarmonicLowerBound
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(TruncatedHarmonicLowerBound self) -> std::string"""
        return _IMP_core.TruncatedHarmonicLowerBound___str__(self)

    def __repr__(self):
        """__repr__(TruncatedHarmonicLowerBound self) -> std::string"""
        return _IMP_core.TruncatedHarmonicLowerBound___repr__(self)

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

TruncatedHarmonicLowerBound_swigregister = _IMP_core.TruncatedHarmonicLowerBound_swigregister
TruncatedHarmonicLowerBound_swigregister(TruncatedHarmonicLowerBound)

class TruncatedHarmonicUpperBound(IMP.kernel.UnaryFunction):
    """Proxy of C++ IMP::core::TruncatedHarmonic<(IMP::core::UPPER)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.UnaryFunction]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TruncatedHarmonicUpperBound, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.UnaryFunction]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TruncatedHarmonicUpperBound, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::TruncatedHarmonic<(IMP::core::UPPER)> self, IMP::Float center, IMP::Float k, IMP::Float threshold, IMP::Float limit) -> TruncatedHarmonicUpperBound
        __init__(IMP::core::TruncatedHarmonic<(IMP::core::UPPER)> self, IMP::Float center, IMP::Float k, IMP::Float threshold) -> TruncatedHarmonicUpperBound
        """
        this = _IMP_core.new_TruncatedHarmonicUpperBound(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(TruncatedHarmonicUpperBound self) -> VersionInfo"""
        return _IMP_core.TruncatedHarmonicUpperBound_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_TruncatedHarmonicUpperBound
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(TruncatedHarmonicUpperBound self) -> std::string"""
        return _IMP_core.TruncatedHarmonicUpperBound___str__(self)

    def __repr__(self):
        """__repr__(TruncatedHarmonicUpperBound self) -> std::string"""
        return _IMP_core.TruncatedHarmonicUpperBound___repr__(self)

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

TruncatedHarmonicUpperBound_swigregister = _IMP_core.TruncatedHarmonicUpperBound_swigregister
TruncatedHarmonicUpperBound_swigregister(TruncatedHarmonicUpperBound)

class TruncatedHarmonicBound(IMP.kernel.UnaryFunction):
    """Proxy of C++ IMP::core::TruncatedHarmonic<(IMP::core::BOTH)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.UnaryFunction]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TruncatedHarmonicBound, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.UnaryFunction]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TruncatedHarmonicBound, name)
    def __init__(self, *args): 
        """
        __init__(IMP::core::TruncatedHarmonic<(IMP::core::BOTH)> self, IMP::Float center, IMP::Float k, IMP::Float threshold, IMP::Float limit) -> TruncatedHarmonicBound
        __init__(IMP::core::TruncatedHarmonic<(IMP::core::BOTH)> self, IMP::Float center, IMP::Float k, IMP::Float threshold) -> TruncatedHarmonicBound
        """
        this = _IMP_core.new_TruncatedHarmonicBound(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(TruncatedHarmonicBound self) -> VersionInfo"""
        return _IMP_core.TruncatedHarmonicBound_get_version_info(self)

    __swig_destroy__ = _IMP_core.delete_TruncatedHarmonicBound
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(TruncatedHarmonicBound self) -> std::string"""
        return _IMP_core.TruncatedHarmonicBound___str__(self)

    def __repr__(self):
        """__repr__(TruncatedHarmonicBound self) -> std::string"""
        return _IMP_core.TruncatedHarmonicBound___repr__(self)

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

TruncatedHarmonicBound_swigregister = _IMP_core.TruncatedHarmonicBound_swigregister
TruncatedHarmonicBound_swigregister(TruncatedHarmonicBound)

class ParticleType(IMP.base._Value):
    """Proxy of C++ IMP::Key<(34897493,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, ParticleType, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base._Value]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ParticleType, name)
    def __init__(self, *args): 
        """
        __init__(IMP::Key<(34897493,true)> self) -> ParticleType
        __init__(IMP::Key<(34897493,true)> self, std::string c) -> ParticleType
        __init__(IMP::Key<(34897493,true)> self, unsigned int i) -> ParticleType
        """
        this = _IMP_core.new_ParticleType(*args)
        try: self.this.append(this)
        except: self.this = this
    def add_key(*args):
        """add_key(std::string sc) -> unsigned int"""
        return _IMP_core.ParticleType_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_core.ParticleType_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(ParticleType self) -> std::string const"""
        return _IMP_core.ParticleType_get_string(self)

    def __eq__(self, *args):
        """__eq__(ParticleType self, ParticleType o) -> bool"""
        return _IMP_core.ParticleType___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(ParticleType self, ParticleType o) -> bool"""
        return _IMP_core.ParticleType___ne__(self, *args)

    def __lt__(self, *args):
        """__lt__(ParticleType self, ParticleType o) -> bool"""
        return _IMP_core.ParticleType___lt__(self, *args)

    def __gt__(self, *args):
        """__gt__(ParticleType self, ParticleType o) -> bool"""
        return _IMP_core.ParticleType___gt__(self, *args)

    def __ge__(self, *args):
        """__ge__(ParticleType self, ParticleType o) -> bool"""
        return _IMP_core.ParticleType___ge__(self, *args)

    def __le__(self, *args):
        """__le__(ParticleType self, ParticleType o) -> bool"""
        return _IMP_core.ParticleType___le__(self, *args)

    def __hash__(self):
        """__hash__(ParticleType self) -> std::size_t"""
        return _IMP_core.ParticleType___hash__(self)

    def show(self, *args):
        """
        show(ParticleType self, _ostream out=std::cout)
        show(ParticleType self)
        """
        return _IMP_core.ParticleType_show(self, *args)

    def add_alias(*args):
        """add_alias(ParticleType old_key, std::string new_name) -> ParticleType"""
        return _IMP_core.ParticleType_add_alias(*args)

    if _newclass:add_alias = staticmethod(add_alias)
    __swig_getmethods__["add_alias"] = lambda x: add_alias
    def get_index(self):
        """get_index(ParticleType self) -> unsigned int"""
        return _IMP_core.ParticleType_get_index(self)

    def show_all(*args):
        """show_all(_ostream out)"""
        return _IMP_core.ParticleType_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_core.ParticleType_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_core.ParticleType_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__(ParticleType self) -> std::string"""
        return _IMP_core.ParticleType___str__(self)

    def __repr__(self):
        """__repr__(ParticleType self) -> std::string"""
        return _IMP_core.ParticleType___repr__(self)

    __swig_destroy__ = _IMP_core.delete_ParticleType
    __del__ = lambda self : None;
ParticleType_swigregister = _IMP_core.ParticleType_swigregister
ParticleType_swigregister(ParticleType)

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

def ParticleType_get_key_exists(*args):
  """ParticleType_get_key_exists(std::string sc) -> bool"""
  return _IMP_core.ParticleType_get_key_exists(*args)

def ParticleType_add_alias(*args):
  """ParticleType_add_alias(ParticleType old_key, std::string new_name) -> ParticleType"""
  return _IMP_core.ParticleType_add_alias(*args)

def ParticleType_show_all(*args):
  """ParticleType_show_all(_ostream out)"""
  return _IMP_core.ParticleType_show_all(*args)

def ParticleType_get_all_strings():
  """ParticleType_get_all_strings() -> IMP::base::Vector< std::string >"""
  return _IMP_core.ParticleType_get_all_strings()

def ParticleType_get_number_unique():
  """ParticleType_get_number_unique() -> unsigned int"""
  return _IMP_core.ParticleType_get_number_unique()

class AttributeSingletonScore(IMP.kernel.SingletonScore):
    """Proxy of C++ IMP::core::GenericAttributeSingletonScore<(UnaryFunction)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.SingletonScore]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AttributeSingletonScore, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.SingletonScore]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AttributeSingletonScore, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(IMP::core::GenericAttributeSingletonScore<(UnaryFunction)> self, UnaryFunction f, FloatKey k) -> AttributeSingletonScore"""
        this = _IMP_core.new_AttributeSingletonScore(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_create_current_decomposition(self, *args):
        """do_create_current_decomposition(AttributeSingletonScore self, Model m, IMP::kernel::ParticleIndex vt) -> IMP::kernel::Restraints"""
        return _IMP_core.AttributeSingletonScore_do_create_current_decomposition(self, *args)

    def get_version_info(self):
        """get_version_info(AttributeSingletonScore self) -> VersionInfo"""
        return _IMP_core.AttributeSingletonScore_get_version_info(self)

    def do_show(self, *args):
        """do_show(AttributeSingletonScore self, _ostream out)"""
        return _IMP_core.AttributeSingletonScore_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_AttributeSingletonScore
    __del__ = lambda self : None;
AttributeSingletonScore_swigregister = _IMP_core.AttributeSingletonScore_swigregister
AttributeSingletonScore_swigregister(AttributeSingletonScore)


def create_attribute_singleton_score(*args):
  """create_attribute_singleton_score(UnaryFunction uf, FloatKey k) -> AttributeSingletonScore"""
  return _IMP_core.create_attribute_singleton_score(*args)
class BoundingBox3DSingletonScore(IMP.kernel.SingletonScore):
    """Proxy of C++ IMP::core::GenericBoundingBox3DSingletonScore<(UnaryFunction)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.SingletonScore]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BoundingBox3DSingletonScore, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.SingletonScore]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, BoundingBox3DSingletonScore, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(IMP::core::GenericBoundingBox3DSingletonScore<(UnaryFunction)> self, UnaryFunction f, BoundingBox3D bb) -> BoundingBox3DSingletonScore"""
        this = _IMP_core.new_BoundingBox3DSingletonScore(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_create_current_decomposition(self, *args):
        """do_create_current_decomposition(BoundingBox3DSingletonScore self, Model m, IMP::kernel::ParticleIndex vt) -> IMP::kernel::Restraints"""
        return _IMP_core.BoundingBox3DSingletonScore_do_create_current_decomposition(self, *args)

    def get_version_info(self):
        """get_version_info(BoundingBox3DSingletonScore self) -> VersionInfo"""
        return _IMP_core.BoundingBox3DSingletonScore_get_version_info(self)

    def do_show(self, *args):
        """do_show(BoundingBox3DSingletonScore self, _ostream out)"""
        return _IMP_core.BoundingBox3DSingletonScore_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_BoundingBox3DSingletonScore
    __del__ = lambda self : None;
BoundingBox3DSingletonScore_swigregister = _IMP_core.BoundingBox3DSingletonScore_swigregister
BoundingBox3DSingletonScore_swigregister(BoundingBox3DSingletonScore)


def create_bounding_box_3d_singleton_score(*args):
  """create_bounding_box_3d_singleton_score(UnaryFunction f, BoundingBox3D bb) -> BoundingBox3DSingletonScore"""
  return _IMP_core.create_bounding_box_3d_singleton_score(*args)
class DistanceToSingletonScore(IMP.kernel.SingletonScore):
    """Proxy of C++ IMP::core::GenericDistanceToSingletonScore<(UnaryFunction)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.SingletonScore]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DistanceToSingletonScore, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.SingletonScore]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DistanceToSingletonScore, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(IMP::core::GenericDistanceToSingletonScore<(UnaryFunction)> self, UnaryFunction f, Vector3D pt) -> DistanceToSingletonScore"""
        this = _IMP_core.new_DistanceToSingletonScore(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_create_current_decomposition(self, *args):
        """do_create_current_decomposition(DistanceToSingletonScore self, Model m, IMP::kernel::ParticleIndex vt) -> IMP::kernel::Restraints"""
        return _IMP_core.DistanceToSingletonScore_do_create_current_decomposition(self, *args)

    def get_version_info(self):
        """get_version_info(DistanceToSingletonScore self) -> VersionInfo"""
        return _IMP_core.DistanceToSingletonScore_get_version_info(self)

    def do_show(self, *args):
        """do_show(DistanceToSingletonScore self, _ostream out)"""
        return _IMP_core.DistanceToSingletonScore_do_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_DistanceToSingletonScore
    __del__ = lambda self : None;
DistanceToSingletonScore_swigregister = _IMP_core.DistanceToSingletonScore_swigregister
DistanceToSingletonScore_swigregister(DistanceToSingletonScore)


def create_distance_to_singleton_score(*args):
  """create_distance_to_singleton_score(UnaryFunction f, Vector3D pt) -> DistanceToSingletonScore"""
  return _IMP_core.create_distance_to_singleton_score(*args)

def get_module_version():
  """get_module_version() -> std::string const"""
  return _IMP_core.get_module_version()

def get_example_path(*args):
  """get_example_path(std::string fname) -> std::string"""
  return _IMP_core.get_example_path(*args)

def get_data_path(*args):
  """get_data_path(std::string fname) -> std::string"""
  return _IMP_core.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.