core/__init__.py

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

# This wrapper is part of IMP,
# Copyright 2007-2015 IMP Inventors. All rights reserved.

from __future__ import print_function, division, absolute_import




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):
        object.__setattr__(self, 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_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

def _swig_getattr(self, class_type, name):
    return _swig_getattr_nondynamic(self, class_type, name, 0)


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



def _swig_setattr_nondynamic_method(set):
    def set_attr(self, name, value):
        if (name == "thisown"):
            return self.this.own(value)
        if hasattr(self, name) or (name == "this"):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add attributes to %s" % self)
    return set_attr


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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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, x):
        """distance(IMP_CORE_SwigPyIterator self, IMP_CORE_SwigPyIterator x) -> ptrdiff_t"""
        return _IMP_core.IMP_CORE_SwigPyIterator_distance(self, x)


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


    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, n):
        """advance(IMP_CORE_SwigPyIterator self, ptrdiff_t n) -> IMP_CORE_SwigPyIterator"""
        return _IMP_core.IMP_CORE_SwigPyIterator_advance(self, n)


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


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


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


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


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


    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_core.IMP_DEBUG_swigconstant(_IMP_core)
IMP_DEBUG = _IMP_core.IMP_DEBUG

_IMP_core.IMP_RELEASE_swigconstant(_IMP_core)
IMP_RELEASE = _IMP_core.IMP_RELEASE

_IMP_core.IMP_SILENT_swigconstant(_IMP_core)
IMP_SILENT = _IMP_core.IMP_SILENT

_IMP_core.IMP_PROGRESS_swigconstant(_IMP_core)
IMP_PROGRESS = _IMP_core.IMP_PROGRESS

_IMP_core.IMP_TERSE_swigconstant(_IMP_core)
IMP_TERSE = _IMP_core.IMP_TERSE

_IMP_core.IMP_VERBOSE_swigconstant(_IMP_core)
IMP_VERBOSE = _IMP_core.IMP_VERBOSE

_IMP_core.IMP_MEMORY_swigconstant(_IMP_core)
IMP_MEMORY = _IMP_core.IMP_MEMORY

_IMP_core.IMP_NONE_swigconstant(_IMP_core)
IMP_NONE = _IMP_core.IMP_NONE

_IMP_core.IMP_USAGE_swigconstant(_IMP_core)
IMP_USAGE = _IMP_core.IMP_USAGE

_IMP_core.IMP_INTERNAL_swigconstant(_IMP_core)
IMP_INTERNAL = _IMP_core.IMP_INTERNAL

_IMP_core.IMP_KERNEL_HAS_LOG4CXX_swigconstant(_IMP_core)
IMP_KERNEL_HAS_LOG4CXX = _IMP_core.IMP_KERNEL_HAS_LOG4CXX

_IMP_core.IMP_COMPILER_HAS_AUTO_swigconstant(_IMP_core)
IMP_COMPILER_HAS_AUTO = _IMP_core.IMP_COMPILER_HAS_AUTO

_IMP_core.IMP_COMPILER_HAS_DEBUG_VECTOR_swigconstant(_IMP_core)
IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_core.IMP_COMPILER_HAS_DEBUG_VECTOR

_IMP_core.IMP_KERNEL_HAS_BOOST_RANDOM_swigconstant(_IMP_core)
IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_core.IMP_KERNEL_HAS_BOOST_RANDOM

_IMP_core.IMP_KERNEL_HAS_GPERFTOOLS_swigconstant(_IMP_core)
IMP_KERNEL_HAS_GPERFTOOLS = _IMP_core.IMP_KERNEL_HAS_GPERFTOOLS

_IMP_core.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER_swigconstant(_IMP_core)
IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER = _IMP_core.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER

_IMP_core.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER_swigconstant(_IMP_core)
IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER = _IMP_core.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER

_IMP_core.IMPKERNEL_SHOW_WARNINGS_swigconstant(_IMP_core)
IMPKERNEL_SHOW_WARNINGS = _IMP_core.IMPKERNEL_SHOW_WARNINGS
import sys
class _DirectorObjects(object):
    """@internal Simple class to keep references to director objects
       to prevent premature deletion."""
    def __init__(self):
        self._objects = []
    def register(self, obj):
        """Take a reference to a director object; will only work for
           refcounted C++ classes"""
        if hasattr(obj, 'get_ref_count'):
            self._objects.append(obj)
    def cleanup(self):
        """Only drop our reference and allow cleanup by Python if no other
           Python references exist (we hold 3 references: one in self._objects,
           one in x, and one in the argument list for getrefcount) *and* no
           other C++ references exist (the Python object always holds one)"""
        objs = [x for x in self._objects if sys.getrefcount(x) > 3 \
                                         or x.get_ref_count() > 1]
        # Do in two steps so the references are kept until the end of the
        # function (deleting references may trigger a fresh call to this method)
        self._objects = objs
    def get_object_count(self):
        """Get number of director objects (useful for testing only)"""
        return len(self._objects)
_director_objects = _DirectorObjects()

class _ostream(object):
    """Proxy of C++ std::ostream class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def write(self, osa_buf):
        """write(_ostream self, char const * osa_buf)"""
        return _IMP_core._ostream_write(self, osa_buf)

_ostream_swigregister = _IMP_core._ostream_swigregister
_ostream_swigregister(_ostream)


_IMP_core.IMP_COMPILER_HAS_OVERRIDE_swigconstant(_IMP_core)
IMP_COMPILER_HAS_OVERRIDE = _IMP_core.IMP_COMPILER_HAS_OVERRIDE

_IMP_core.IMP_COMPILER_HAS_FINAL_swigconstant(_IMP_core)
IMP_COMPILER_HAS_FINAL = _IMP_core.IMP_COMPILER_HAS_FINAL

_IMP_core.IMP_HAS_NOEXCEPT_swigconstant(_IMP_core)
IMP_HAS_NOEXCEPT = _IMP_core.IMP_HAS_NOEXCEPT
import IMP

_IMP_core.IMP_CGAL_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_core)
IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_core.IMP_CGAL_HAS_BOOST_FILESYSTEM

_IMP_core.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_core)
IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_core.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS

_IMP_core.IMP_CGAL_HAS_BOOST_RANDOM_swigconstant(_IMP_core)
IMP_CGAL_HAS_BOOST_RANDOM = _IMP_core.IMP_CGAL_HAS_BOOST_RANDOM

_IMP_core.IMP_CGAL_HAS_BOOST_SYSTEM_swigconstant(_IMP_core)
IMP_CGAL_HAS_BOOST_SYSTEM = _IMP_core.IMP_CGAL_HAS_BOOST_SYSTEM

_IMP_core.IMPCGAL_SHOW_WARNINGS_swigconstant(_IMP_core)
IMPCGAL_SHOW_WARNINGS = _IMP_core.IMPCGAL_SHOW_WARNINGS
import IMP.cgal

_IMP_core.IMP_ALGEBRA_HAS_IMP_CGAL_swigconstant(_IMP_core)
IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_core.IMP_ALGEBRA_HAS_IMP_CGAL

_IMP_core.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_core)
IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_core.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM

_IMP_core.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_core)
IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_core.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS

_IMP_core.IMP_ALGEBRA_HAS_BOOST_RANDOM_swigconstant(_IMP_core)
IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_core.IMP_ALGEBRA_HAS_BOOST_RANDOM

_IMP_core.IMP_ALGEBRA_HAS_BOOST_SYSTEM_swigconstant(_IMP_core)
IMP_ALGEBRA_HAS_BOOST_SYSTEM = _IMP_core.IMP_ALGEBRA_HAS_BOOST_SYSTEM

_IMP_core.IMP_ALGEBRA_HAS_CGAL_swigconstant(_IMP_core)
IMP_ALGEBRA_HAS_CGAL = _IMP_core.IMP_ALGEBRA_HAS_CGAL

_IMP_core.IMP_ALGEBRA_HAS_ANN_swigconstant(_IMP_core)
IMP_ALGEBRA_HAS_ANN = _IMP_core.IMP_ALGEBRA_HAS_ANN

_IMP_core.IMPALGEBRA_SHOW_WARNINGS_swigconstant(_IMP_core)
IMPALGEBRA_SHOW_WARNINGS = _IMP_core.IMPALGEBRA_SHOW_WARNINGS
import IMP.algebra

_IMP_core.IMP_DISPLAY_HAS_IMP_CGAL_swigconstant(_IMP_core)
IMP_DISPLAY_HAS_IMP_CGAL = _IMP_core.IMP_DISPLAY_HAS_IMP_CGAL

_IMP_core.IMP_DISPLAY_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_core)
IMP_DISPLAY_HAS_BOOST_FILESYSTEM = _IMP_core.IMP_DISPLAY_HAS_BOOST_FILESYSTEM

_IMP_core.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_core)
IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS = _IMP_core.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS

_IMP_core.IMP_DISPLAY_HAS_BOOST_RANDOM_swigconstant(_IMP_core)
IMP_DISPLAY_HAS_BOOST_RANDOM = _IMP_core.IMP_DISPLAY_HAS_BOOST_RANDOM

_IMP_core.IMP_DISPLAY_HAS_BOOST_SYSTEM_swigconstant(_IMP_core)
IMP_DISPLAY_HAS_BOOST_SYSTEM = _IMP_core.IMP_DISPLAY_HAS_BOOST_SYSTEM

_IMP_core.IMP_DISPLAY_HAS_CGAL_swigconstant(_IMP_core)
IMP_DISPLAY_HAS_CGAL = _IMP_core.IMP_DISPLAY_HAS_CGAL

_IMP_core.IMPDISPLAY_SHOW_WARNINGS_swigconstant(_IMP_core)
IMPDISPLAY_SHOW_WARNINGS = _IMP_core.IMPDISPLAY_SHOW_WARNINGS
import IMP.display

_IMP_core.IMP_SCORE_FUNCTOR_HAS_IMP_CGAL_swigconstant(_IMP_core)
IMP_SCORE_FUNCTOR_HAS_IMP_CGAL = _IMP_core.IMP_SCORE_FUNCTOR_HAS_IMP_CGAL

_IMP_core.IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_core)
IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM = _IMP_core.IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM

_IMP_core.IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_core)
IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS = _IMP_core.IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS

_IMP_core.IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM_swigconstant(_IMP_core)
IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM = _IMP_core.IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM

_IMP_core.IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM_swigconstant(_IMP_core)
IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM = _IMP_core.IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM

_IMP_core.IMP_SCORE_FUNCTOR_HAS_CGAL_swigconstant(_IMP_core)
IMP_SCORE_FUNCTOR_HAS_CGAL = _IMP_core.IMP_SCORE_FUNCTOR_HAS_CGAL

_IMP_core.IMP_SCORE_FUNCTOR_HAS_HDF5_swigconstant(_IMP_core)
IMP_SCORE_FUNCTOR_HAS_HDF5 = _IMP_core.IMP_SCORE_FUNCTOR_HAS_HDF5

_IMP_core.IMPSCOREFUNCTOR_SHOW_WARNINGS_swigconstant(_IMP_core)
IMPSCOREFUNCTOR_SHOW_WARNINGS = _IMP_core.IMPSCOREFUNCTOR_SHOW_WARNINGS
import IMP.score_functor

_IMP_core.IMP_CORE_HAS_IMP_CGAL_swigconstant(_IMP_core)
IMP_CORE_HAS_IMP_CGAL = _IMP_core.IMP_CORE_HAS_IMP_CGAL

_IMP_core.IMP_CORE_HAS_IMP_KERNEL_swigconstant(_IMP_core)
IMP_CORE_HAS_IMP_KERNEL = _IMP_core.IMP_CORE_HAS_IMP_KERNEL

_IMP_core.IMP_CORE_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_core)
IMP_CORE_HAS_BOOST_FILESYSTEM = _IMP_core.IMP_CORE_HAS_BOOST_FILESYSTEM

_IMP_core.IMP_CORE_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_core)
IMP_CORE_HAS_BOOST_PROGRAMOPTIONS = _IMP_core.IMP_CORE_HAS_BOOST_PROGRAMOPTIONS

_IMP_core.IMP_CORE_HAS_BOOST_RANDOM_swigconstant(_IMP_core)
IMP_CORE_HAS_BOOST_RANDOM = _IMP_core.IMP_CORE_HAS_BOOST_RANDOM

_IMP_core.IMP_CORE_HAS_BOOST_SYSTEM_swigconstant(_IMP_core)
IMP_CORE_HAS_BOOST_SYSTEM = _IMP_core.IMP_CORE_HAS_BOOST_SYSTEM

_IMP_core.IMP_CORE_HAS_CGAL_swigconstant(_IMP_core)
IMP_CORE_HAS_CGAL = _IMP_core.IMP_CORE_HAS_CGAL

_IMP_core.IMP_CORE_HAS_HDF5_swigconstant(_IMP_core)
IMP_CORE_HAS_HDF5 = _IMP_core.IMP_CORE_HAS_HDF5

_IMP_core.IMPCORE_SHOW_WARNINGS_swigconstant(_IMP_core)
IMPCORE_SHOW_WARNINGS = _IMP_core.IMPCORE_SHOW_WARNINGS
class _OpenCubicSplineBase(IMP.UnaryFunction):
    """Proxy of C++ IMP::score_functor::ScoreUnaryFunction<(IMP::score_functor::OpenCubicSpline)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __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) -> _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)

_OpenCubicSplineBase_swigregister = _IMP_core._OpenCubicSplineBase_swigregister
_OpenCubicSplineBase_swigregister(_OpenCubicSplineBase)

_object_types.append("MonteCarloMover")


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

_object_types.append("AngleRestraint")


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


def _object_cast_to_WeightedDerivativesToRefined(o):
    """_object_cast_to_WeightedDerivativesToRefined(Object o) -> IMP::core::WeightedDerivativesToRefined *"""
    return _IMP_core._object_cast_to_WeightedDerivativesToRefined(o)
_object_types.append("DiameterRestraint")


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


def _object_cast_to_NeighborsTable(o):
    """_object_cast_to_NeighborsTable(Object o) -> NeighborsTable"""
    return _IMP_core._object_cast_to_NeighborsTable(o)
_object_types.append("NormalMover")


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


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


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


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


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


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


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


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


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


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


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


def _object_cast_to_RigidBodyAnglePairScore(o):
    """_object_cast_to_RigidBodyAnglePairScore(Object o) -> RigidBodyAnglePairScore"""
    return _IMP_core._object_cast_to_RigidBodyAnglePairScore(o)
_object_types.append("RigidBodyMover")


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


def _object_cast_to_RigidBodyTunneler(o):
    """_object_cast_to_RigidBodyTunneler(Object o) -> RigidBodyTunneler"""
    return _IMP_core._object_cast_to_RigidBodyTunneler(o)
_object_types.append("RigidBodyUmbrella")


def _object_cast_to_RigidBodyUmbrella(o):
    """_object_cast_to_RigidBodyUmbrella(Object o) -> RigidBodyUmbrella"""
    return _IMP_core._object_cast_to_RigidBodyUmbrella(o)
_object_types.append("RigidClosePairsFinder")


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


def _object_cast_to_AllSameQuadPredicate(o):
    """_object_cast_to_AllSameQuadPredicate(Object o) -> AllSameQuadPredicate"""
    return _IMP_core._object_cast_to_AllSameQuadPredicate(o)
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 RigidBodyMembers(l=[]):
    return [RigidBodyMember(x) for x in l]
_plural_types.append("RigidBodyMembers")

_value_types.append("RigidBodyMember")

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

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

_value_types.append("Gaussian")

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(o):
    """_object_cast_to_TruncatedHarmonicBound(Object o) -> TruncatedHarmonicBound"""
    return _IMP_core._object_cast_to_TruncatedHarmonicBound(o)
_object_types.append("TruncatedHarmonicLowerBound")


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


def _object_cast_to_EdgePairsGeometry(o):
    """_object_cast_to_EdgePairsGeometry(Object o) -> EdgePairsGeometry"""
    return _IMP_core._object_cast_to_EdgePairsGeometry(o)
_object_types.append("AttributeSingletonPredicate")


def _object_cast_to_AttributeSingletonPredicate(o):
    """_object_cast_to_AttributeSingletonPredicate(Object o) -> AttributeSingletonPredicate"""
    return _IMP_core._object_cast_to_AttributeSingletonPredicate(o)
_object_types.append("InBoundingBox3DSingletonPredicate")


def _object_cast_to_InBoundingBox3DSingletonPredicate(o):
    """_object_cast_to_InBoundingBox3DSingletonPredicate(Object o) -> InBoundingBox3DSingletonPredicate"""
    return _IMP_core._object_cast_to_InBoundingBox3DSingletonPredicate(o)
_object_types.append("IsCollisionPairPredicate")


def _object_cast_to_IsCollisionPairPredicate(o):
    """_object_cast_to_IsCollisionPairPredicate(Object o) -> IsCollisionPairPredicate"""
    return _IMP_core._object_cast_to_IsCollisionPairPredicate(o)
class ClosePairsFinder(IMP._ParticleInputs, IMP.Object):
    """Proxy of C++ IMP::core::ClosePairsFinder class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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, Model m, IMP::ParticleIndexes const & pc) -> IMP::ParticleIndexPairs
        get_close_pairs(ClosePairsFinder self, Model m, IMP::ParticleIndexes const & pca, IMP::ParticleIndexes const & pcb) -> IMP::ParticleIndexPairs
        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, d):
        """set_distance(ClosePairsFinder self, double d)"""
        return _IMP_core.ClosePairsFinder_set_distance(self, d)


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


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


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


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


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


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


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


    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, i):
        """get_pair_filter(ClosePairsFinder self, unsigned int i) -> PairPredicate"""
        return _IMP_core.ClosePairsFinder_get_pair_filter(self, i)


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


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


    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._Value):
    """Proxy of C++ IMP::core::MonteCarloMoverResult class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::MonteCarloMoverResult self, IMP::ParticleIndexes i0, double i1) -> MonteCarloMoverResult
        __init__(IMP::core::MonteCarloMoverResult self, IMP::ParticleIndexes i0) -> 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)
        show(MonteCarloMoverResult self)
        """
        return _IMP_core.MonteCarloMoverResult_show(self, *args)


    def __cmp__(self, o):
        """__cmp__(MonteCarloMoverResult self, MonteCarloMoverResult o) -> int"""
        return _IMP_core.MonteCarloMoverResult___cmp__(self, o)


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


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


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


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


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


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


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


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


    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, v):
        """set_proposal_ratio(MonteCarloMoverResult self, double const & v)"""
        return _IMP_core.MonteCarloMoverResult_set_proposal_ratio(self, v)


    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.ModelObject):
    """Proxy of C++ IMP::core::MonteCarloMover class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, m, name):
        """__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, m, name)
        try:
            self.this.append(this)
        except:
            self.this = this
        if self.__class__ != MonteCarloMover:
            _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::ModelObjectsTemp"""
        return _IMP_core.MonteCarloMover_do_get_outputs(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(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    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 do_destroy(self):
        """do_destroy(MonteCarloMover self)"""
        return _IMP_core.MonteCarloMover_do_destroy(self)


    def handle_set_has_required_score_states(self, arg0):
        """handle_set_has_required_score_states(MonteCarloMover self, bool arg0)"""
        return _IMP_core.MonteCarloMover_handle_set_has_required_score_states(self, arg0)


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


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

MonteCarloMover_swigregister = _IMP_core.MonteCarloMover_swigregister
MonteCarloMover_swigregister(MonteCarloMover)

class XYZ(IMP.Decorator):
    """Proxy of C++ IMP::core::XYZ class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

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

    get_coordinate_key = staticmethod(get_coordinate_key)

    def __init__(self, *args):
        """
        __init__(IMP::core::XYZ self) -> XYZ
        __init__(IMP::core::XYZ self, Model m, ParticleIndex id) -> XYZ
        __init__(IMP::core::XYZ self, _ParticleAdaptor d) -> XYZ
        """
        this = _IMP_core.new_XYZ(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def show(self, *args):
        """
        show(XYZ self, _ostream out)
        show(XYZ self)
        """
        return _IMP_core.XYZ_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi) -> XYZ
        setup_particle(_ParticleAdaptor decorator) -> XYZ
        setup_particle(Model m, ParticleIndex pi, Vector3D v) -> XYZ
        setup_particle(_ParticleAdaptor decorator, Vector3D v) -> XYZ
        """
        return _IMP_core.XYZ_setup_particle(*args)

    setup_particle = staticmethod(setup_particle)

    def get_x(self):
        """get_x(XYZ self) -> IMP::Float"""
        return _IMP_core.XYZ_get_x(self)


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


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


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


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


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


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


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


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


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


    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, tf):
        """set_coordinates_are_optimized(XYZ self, bool tf)"""
        return _IMP_core.XYZ_set_coordinates_are_optimized(self, tf)


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


    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 get_is_setup(*args):
        """
        get_is_setup(_ParticleAdaptor p) -> bool
        get_is_setup(Model m, ParticleIndex pi) -> bool
        """
        return _IMP_core.XYZ_get_is_setup(*args)

    get_is_setup = staticmethod(get_is_setup)

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

    get_xyz_keys = staticmethod(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, 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) -> 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, 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, a0):
        """set_name(XYZ self, std::string a0)"""
        return _IMP_core.XYZ_set_name(self, a0)


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


    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, a0, a1):
        """set_is_optimized(XYZ self, FloatKey a0, bool a1)"""
        return _IMP_core.XYZ_set_is_optimized(self, a0, a1)


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


    def get_check_level(self):
        """get_check_level(XYZ self) -> IMP::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 __hash__(self):
        """__hash__(XYZ self) -> std::size_t"""
        return _IMP_core.XYZ___hash__(self)


    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(i):
    """XYZ_get_coordinate_key(unsigned int i) -> FloatKey"""
    return _IMP_core.XYZ_get_coordinate_key(i)

def XYZ_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi) -> XYZ
    setup_particle(_ParticleAdaptor decorator) -> XYZ
    setup_particle(Model m, ParticleIndex pi, Vector3D v) -> XYZ
    XYZ_setup_particle(_ParticleAdaptor decorator, Vector3D v) -> XYZ
    """
    return _IMP_core.XYZ_setup_particle(*args)

def XYZ_get_is_setup(*args):
    """
    get_is_setup(_ParticleAdaptor p) -> bool
    XYZ_get_is_setup(Model m, ParticleIndex pi) -> bool
    """
    return _IMP_core.XYZ_get_is_setup(*args)

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


def set_vector_geometry(d, v):
    """set_vector_geometry(XYZ d, Vector3D v)"""
    return _IMP_core.set_vector_geometry(d, v)

def get_vector_geometry(d):
    """get_vector_geometry(XYZ d) -> Vector3D"""
    return _IMP_core.get_vector_geometry(d)

def get_dihedral(a, b, c, d):
    """get_dihedral(XYZ a, XYZ b, XYZ c, XYZ d) -> double"""
    return _IMP_core.get_dihedral(a, b, c, d)
class XYZR(XYZ):
    """Proxy of C++ IMP::core::XYZR class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::XYZR self) -> XYZR
        __init__(IMP::core::XYZR self, Model m, ParticleIndex id) -> XYZR
        __init__(IMP::core::XYZR self, _ParticleAdaptor d) -> XYZR
        """
        this = _IMP_core.new_XYZR(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def show(self, *args):
        """
        show(XYZR self, _ostream out)
        show(XYZR self)
        """
        return _IMP_core.XYZR_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi) -> XYZR
        setup_particle(_ParticleAdaptor decorator) -> XYZR
        setup_particle(Model m, ParticleIndex pi, IMP::Float radius) -> XYZR
        setup_particle(_ParticleAdaptor decorator, IMP::Float radius) -> XYZR
        setup_particle(Model m, ParticleIndex pi, Sphere3D ball) -> XYZR
        setup_particle(_ParticleAdaptor decorator, Sphere3D ball) -> XYZR
        """
        return _IMP_core.XYZR_setup_particle(*args)

    setup_particle = staticmethod(setup_particle)

    def get_is_setup(*args):
        """
        get_is_setup(_ParticleAdaptor p) -> bool
        get_is_setup(Model m, ParticleIndex pi) -> bool
        """
        return _IMP_core.XYZR_get_is_setup(*args)

    get_is_setup = staticmethod(get_is_setup)

    def get_radius(self):
        """get_radius(XYZR self) -> double"""
        return _IMP_core.XYZR_get_radius(self)


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


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


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


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

    get_radius_key = staticmethod(get_radius_key)

    def add_to_radius_derivative(self, v, d):
        """add_to_radius_derivative(XYZR self, double v, DerivativeAccumulator d)"""
        return _IMP_core.XYZR_add_to_radius_derivative(self, v, d)


    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, 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) -> 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, 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, a0):
        """get_derivative(XYZR self, FloatKey a0) -> double"""
        return _IMP_core.XYZR_get_derivative(self, a0)


    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, a0):
        """set_name(XYZR self, std::string a0)"""
        return _IMP_core.XYZR_set_name(self, a0)


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


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


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


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


    def get_check_level(self):
        """get_check_level(XYZR self) -> IMP::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 __hash__(self):
        """__hash__(XYZR self) -> std::size_t"""
        return _IMP_core.XYZR___hash__(self)


    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_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi) -> XYZR
    setup_particle(_ParticleAdaptor decorator) -> XYZR
    setup_particle(Model m, ParticleIndex pi, IMP::Float radius) -> XYZR
    setup_particle(_ParticleAdaptor decorator, IMP::Float radius) -> XYZR
    setup_particle(Model m, ParticleIndex pi, Sphere3D ball) -> XYZR
    XYZR_setup_particle(_ParticleAdaptor decorator, Sphere3D ball) -> XYZR
    """
    return _IMP_core.XYZR_setup_particle(*args)

def XYZR_get_is_setup(*args):
    """
    get_is_setup(_ParticleAdaptor p) -> bool
    XYZR_get_is_setup(Model m, ParticleIndex pi) -> bool
    """
    return _IMP_core.XYZR_get_is_setup(*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(b, v, slack=0):
    """
    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(b, v, slack)

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

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

def create_xyzr_particles(m, num, radius, box_side=10):
    """
    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(m, num, radius, box_side)
class XYZRGeometry(IMP.display.SingletonGeometry):
    """Proxy of C++ IMP::core::XYZRGeometry class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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)


    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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, sc):
        """__init__(IMP::core::XYZRsGeometry self, SingletonContainer sc) -> XYZRsGeometry"""
        this = _IMP_core.new_XYZRsGeometry(sc)
        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)


    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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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)


    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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, sc):
        """__init__(IMP::core::XYZDerivativesGeometry self, SingletonContainer sc) -> XYZDerivativesGeometry"""
        this = _IMP_core.new_XYZDerivativesGeometry(sc)
        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)


    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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, pp):
        """__init__(IMP::core::EdgePairGeometry self, IMP::ParticlePair const & pp) -> EdgePairGeometry"""
        this = _IMP_core.new_EdgePairGeometry(pp)
        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)


    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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, sc):
        """__init__(IMP::core::EdgePairsGeometry self, PairContainer sc) -> EdgePairsGeometry"""
        this = _IMP_core.new_EdgePairsGeometry(sc)
        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)


    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.TripletScore):
    """Proxy of C++ IMP::core::AngleTripletScore class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, f):
        """__init__(IMP::core::AngleTripletScore self, UnaryFunction f) -> AngleTripletScore"""
        this = _IMP_core.new_AngleTripletScore(f)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self, m, pis):
        """do_get_inputs(AngleTripletScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.AngleTripletScore_do_get_inputs(self, m, pis)


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


    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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::BallMover self, Model m, ParticleIndex pi, IMP::FloatKeys const & vars, double radius) -> BallMover
        __init__(IMP::core::BallMover self, Model m, ParticleIndex pi, double radius) -> BallMover
        __init__(IMP::core::BallMover self, IMP::ParticlesTemp const & sc, IMP::FloatKeys const & vars, IMP::Float radius) -> BallMover
        __init__(IMP::core::BallMover self, IMP::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, radius):
        """set_radius(BallMover self, IMP::Float radius)"""
        return _IMP_core.BallMover_set_radius(self, radius)


    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)


    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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, mvs):
        """__init__(IMP::core::SerialMover self, IMP::core::MonteCarloMoversTemp const & mvs) -> SerialMover"""
        this = _IMP_core.new_SerialMover(mvs)
        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_version_info(self):
        """get_version_info(SerialMover self) -> VersionInfo"""
        return _IMP_core.SerialMover_get_version_info(self)


    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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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::algebra::BoundingBox3Ds const & bbs) -> IMP::IntPairs
        get_close_pairs(BoxSweepClosePairsFinder self, IMP::algebra::BoundingBox3Ds const & bas, IMP::algebra::BoundingBox3Ds const & bbs) -> IMP::IntPairs
        get_close_pairs(BoxSweepClosePairsFinder self, Model m, IMP::ParticleIndexes const & pc) -> IMP::ParticleIndexPairs
        get_close_pairs(BoxSweepClosePairsFinder self, Model m, IMP::ParticleIndexes const & pca, IMP::ParticleIndexes const & pcb) -> IMP::ParticleIndexPairs
        """
        return _IMP_core.BoxSweepClosePairsFinder_get_close_pairs(self, *args)


    def do_get_inputs(self, m, pis):
        """do_get_inputs(BoxSweepClosePairsFinder self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.BoxSweepClosePairsFinder_do_get_inputs(self, m, pis)


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


    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.SingletonModifier):
    """Proxy of C++ IMP::core::CentroidOfRefined class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::CentroidOfRefined self, Refiner r, FloatKey weight, IMP::FloatKeys ks) -> CentroidOfRefined
        __init__(IMP::core::CentroidOfRefined self, Refiner r, FloatKey weight) -> 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 do_get_inputs(self, m, pis):
        """do_get_inputs(CentroidOfRefined self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.CentroidOfRefined_do_get_inputs(self, m, pis)


    def do_get_outputs(self, m, pis):
        """do_get_outputs(CentroidOfRefined self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.CentroidOfRefined_do_get_outputs(self, m, pis)


    def get_version_info(self):
        """get_version_info(CentroidOfRefined self) -> VersionInfo"""
        return _IMP_core.CentroidOfRefined_get_version_info(self)


    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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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, ParticleIndex id) -> Centroid
        __init__(IMP::core::Centroid self, _ParticleAdaptor d) -> Centroid
        """
        this = _IMP_core.new_Centroid(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def show(self, *args):
        """
        show(Centroid self, _ostream out)
        show(Centroid self)
        """
        return _IMP_core.Centroid_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi, _ParticleIndexesAdaptor members) -> Centroid
        setup_particle(_ParticleAdaptor decorator, _ParticleIndexesAdaptor members) -> Centroid
        setup_particle(Model m, ParticleIndex pi, Refiner refiner) -> Centroid
        setup_particle(_ParticleAdaptor decorator, Refiner refiner) -> Centroid
        """
        return _IMP_core.Centroid_setup_particle(*args)

    setup_particle = staticmethod(setup_particle)

    def get_is_setup(*args):
        """
        get_is_setup(_ParticleAdaptor p) -> bool
        get_is_setup(Model m, ParticleIndex pi) -> bool
        """
        return _IMP_core.Centroid_get_is_setup(*args)

    get_is_setup = staticmethod(get_is_setup)

    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, 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) -> 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, 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, a0):
        """get_derivative(Centroid self, FloatKey a0) -> double"""
        return _IMP_core.Centroid_get_derivative(self, a0)


    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, a0):
        """set_name(Centroid self, std::string a0)"""
        return _IMP_core.Centroid_set_name(self, a0)


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


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


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


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


    def get_check_level(self):
        """get_check_level(Centroid self) -> IMP::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 __hash__(self):
        """__hash__(Centroid self) -> std::size_t"""
        return _IMP_core.Centroid___hash__(self)


    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)

    __swig_destroy__ = _IMP_core.delete_Centroid
    __del__ = lambda self: None
Centroid_swigregister = _IMP_core.Centroid_swigregister
Centroid_swigregister(Centroid)

def Centroid_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi, _ParticleIndexesAdaptor members) -> Centroid
    setup_particle(_ParticleAdaptor decorator, _ParticleIndexesAdaptor members) -> Centroid
    setup_particle(Model m, ParticleIndex pi, Refiner refiner) -> Centroid
    Centroid_setup_particle(_ParticleAdaptor decorator, Refiner refiner) -> Centroid
    """
    return _IMP_core.Centroid_setup_particle(*args)

def Centroid_get_is_setup(*args):
    """
    get_is_setup(_ParticleAdaptor p) -> bool
    Centroid_get_is_setup(Model m, ParticleIndex pi) -> bool
    """
    return _IMP_core.Centroid_get_is_setup(*args)

class ChecksScoreState(IMP.ScoreState):
    """Proxy of C++ IMP::core::ChecksScoreState class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, m, probability):
        """__init__(IMP::core::ChecksScoreState self, Model m, double probability) -> ChecksScoreState"""
        this = _IMP_core.new_ChecksScoreState(m, probability)
        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 do_before_evaluate(self):
        """do_before_evaluate(ChecksScoreState self)"""
        return _IMP_core.ChecksScoreState_do_before_evaluate(self)


    def do_after_evaluate(self, da):
        """do_after_evaluate(ChecksScoreState self, DerivativeAccumulator da)"""
        return _IMP_core.ChecksScoreState_do_after_evaluate(self, da)


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


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


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


    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.Refiner):
    """Proxy of C++ IMP::core::ChildrenRefiner class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, tr):
        """__init__(IMP::core::ChildrenRefiner self, HierarchyTraits tr) -> ChildrenRefiner"""
        this = _IMP_core.new_ChildrenRefiner(tr)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self, m, pis):
        """do_get_inputs(ChildrenRefiner self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.ChildrenRefiner_do_get_inputs(self, m, pis)


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


    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.UnaryFunction):
    """Proxy of C++ IMP::core::ClosedCubicSpline class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, values, minrange, spacing):
        """__init__(IMP::core::ClosedCubicSpline self, IMP::Floats const & values, double minrange, double spacing) -> ClosedCubicSpline"""
        this = _IMP_core.new_ClosedCubicSpline(values, minrange, spacing)
        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)


    def do_show(self, out):
        """do_show(ClosedCubicSpline self, _ostream out)"""
        return _IMP_core.ClosedCubicSpline_do_show(self, out)


    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.PairScore):
    """Proxy of C++ IMP::core::KClosePairsPairScore class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, f, r, k=1):
        """
        __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(f, r, k)
        try:
            self.this.append(this)
        except:
            self.this = this

    def get_close_pairs(self, pp):
        """get_close_pairs(KClosePairsPairScore self, IMP::ParticlePair const & pp) -> IMP::ParticlePairsTemp"""
        return _IMP_core.KClosePairsPairScore_get_close_pairs(self, pp)


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


    def do_get_inputs(self, m, pis):
        """do_get_inputs(KClosePairsPairScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.KClosePairsPairScore_do_get_inputs(self, m, pis)


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


    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.PairScore):
    """Proxy of C++ IMP::core::ClosePairsPairScore class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, f, r, max_distance):
        """__init__(IMP::core::ClosePairsPairScore self, PairScore f, Refiner r, IMP::Float max_distance) -> ClosePairsPairScore"""
        this = _IMP_core.new_ClosePairsPairScore(f, r, max_distance)
        try:
            self.this.append(this)
        except:
            self.this = this

    def get_close_pairs(self, pp):
        """get_close_pairs(ClosePairsPairScore self, IMP::ParticlePair const & pp) -> IMP::ParticlePairsTemp"""
        return _IMP_core.ClosePairsPairScore_get_close_pairs(self, pp)


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


    def do_get_inputs(self, m, pis):
        """do_get_inputs(ClosePairsPairScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.ClosePairsPairScore_do_get_inputs(self, m, pis)


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


    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.AttributeOptimizer):
    """Proxy of C++ IMP::core::ConjugateGradients class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::ConjugateGradients self, Model m, std::string name) -> ConjugateGradients
        __init__(IMP::core::ConjugateGradients self, Model m) -> ConjugateGradients
        """
        this = _IMP_core.new_ConjugateGradients(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def set_gradient_threshold(self, t):
        """set_gradient_threshold(ConjugateGradients self, IMP::Float t)"""
        return _IMP_core.ConjugateGradients_set_gradient_threshold(self, t)


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


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


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


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


    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.Restraint):
    """Proxy of C++ IMP::core::ConnectivityRestraint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, ps, sc):
        """__init__(IMP::core::ConnectivityRestraint self, PairScore ps, _SingletonContainerAdaptor sc) -> ConnectivityRestraint"""
        this = _IMP_core.new_ConnectivityRestraint(ps, sc)
        try:
            self.this.append(this)
        except:
            self.this = this

    def get_connected_pairs(self):
        """get_connected_pairs(ConnectivityRestraint self) -> IMP::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::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)


    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.Restraint):
    """Proxy of C++ IMP::core::ConstantRestraint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, m, v):
        """__init__(IMP::core::ConstantRestraint self, Model m, IMP::Float v) -> ConstantRestraint"""
        this = _IMP_core.new_ConstantRestraint(m, v)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self):
        """do_get_inputs(ConstantRestraint self) -> IMP::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 __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.UnaryFunction):
    """Proxy of C++ IMP::core::Cosine class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, force_constant, periodicity, phase):
        """__init__(IMP::core::Cosine self, IMP::Float force_constant, int periodicity, IMP::Float phase) -> Cosine"""
        this = _IMP_core.new_Cosine(force_constant, periodicity, phase)
        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)


    def do_show(self, out):
        """do_show(Cosine self, _ostream out)"""
        return _IMP_core.Cosine_do_show(self, out)


    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.SingletonModifier):
    """Proxy of C++ IMP::core::CoverRefined class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, ref, slack=0):
        """
        __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(ref, slack)
        try:
            self.this.append(this)
        except:
            self.this = this

    def set_slack(self, slack):
        """set_slack(CoverRefined self, IMP::Float slack)"""
        return _IMP_core.CoverRefined_set_slack(self, slack)


    def do_get_inputs(self, m, pis):
        """do_get_inputs(CoverRefined self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.CoverRefined_do_get_inputs(self, m, pis)


    def do_get_outputs(self, m, pis):
        """do_get_outputs(CoverRefined self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.CoverRefined_do_get_outputs(self, m, pis)


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


    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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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, ParticleIndex id) -> Cover
        __init__(IMP::core::Cover self, _ParticleAdaptor d) -> Cover
        """
        this = _IMP_core.new_Cover(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def show(self, *args):
        """
        show(Cover self, _ostream out)
        show(Cover self)
        """
        return _IMP_core.Cover_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi, _ParticleIndexesAdaptor members) -> Cover
        setup_particle(_ParticleAdaptor decorator, _ParticleIndexesAdaptor members) -> Cover
        setup_particle(Model m, ParticleIndex pi, Refiner refiner) -> Cover
        setup_particle(_ParticleAdaptor decorator, Refiner refiner) -> Cover
        """
        return _IMP_core.Cover_setup_particle(*args)

    setup_particle = staticmethod(setup_particle)

    def get_is_setup(*args):
        """
        get_is_setup(_ParticleAdaptor p) -> bool
        get_is_setup(Model m, ParticleIndex pi) -> bool
        """
        return _IMP_core.Cover_get_is_setup(*args)

    get_is_setup = staticmethod(get_is_setup)

    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, 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) -> 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, 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, a0):
        """get_derivative(Cover self, FloatKey a0) -> double"""
        return _IMP_core.Cover_get_derivative(self, a0)


    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, a0):
        """set_name(Cover self, std::string a0)"""
        return _IMP_core.Cover_set_name(self, a0)


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


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


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


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


    def get_check_level(self):
        """get_check_level(Cover self) -> IMP::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 __hash__(self):
        """__hash__(Cover self) -> std::size_t"""
        return _IMP_core.Cover___hash__(self)


    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)

    __swig_destroy__ = _IMP_core.delete_Cover
    __del__ = lambda self: None
Cover_swigregister = _IMP_core.Cover_swigregister
Cover_swigregister(Cover)

def Cover_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi, _ParticleIndexesAdaptor members) -> Cover
    setup_particle(_ParticleAdaptor decorator, _ParticleIndexesAdaptor members) -> Cover
    setup_particle(Model m, ParticleIndex pi, Refiner refiner) -> Cover
    Cover_setup_particle(_ParticleAdaptor decorator, Refiner refiner) -> Cover
    """
    return _IMP_core.Cover_setup_particle(*args)

def Cover_get_is_setup(*args):
    """
    get_is_setup(_ParticleAdaptor p) -> bool
    Cover_get_is_setup(Model m, ParticleIndex pi) -> bool
    """
    return _IMP_core.Cover_get_is_setup(*args)

class DerivativesFromRefined(IMP.SingletonModifier):
    """Proxy of C++ IMP::core::DerivativesFromRefined class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::DerivativesFromRefined self, Refiner r, IMP::FloatKeys ks) -> 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 do_get_inputs(self, m, pis):
        """do_get_inputs(DerivativesFromRefined self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.DerivativesFromRefined_do_get_inputs(self, m, pis)


    def do_get_outputs(self, m, pis):
        """do_get_outputs(DerivativesFromRefined self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.DerivativesFromRefined_do_get_outputs(self, m, pis)


    def get_version_info(self):
        """get_version_info(DerivativesFromRefined self) -> VersionInfo"""
        return _IMP_core.DerivativesFromRefined_get_version_info(self)


    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.SingletonModifier):
    """Proxy of C++ IMP::core::DerivativesToRefined class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::DerivativesToRefined self, Refiner r, IMP::FloatKeys ks) -> 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 do_get_inputs(self, m, pis):
        """do_get_inputs(DerivativesToRefined self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.DerivativesToRefined_do_get_inputs(self, m, pis)


    def do_get_outputs(self, m, pis):
        """do_get_outputs(DerivativesToRefined self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.DerivativesToRefined_do_get_outputs(self, m, pis)


    def get_version_info(self):
        """get_version_info(DerivativesToRefined self) -> VersionInfo"""
        return _IMP_core.DerivativesToRefined_get_version_info(self)


    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.Restraint):
    """Proxy of C++ IMP::core::DiameterRestraint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, f, sc, diameter):
        """__init__(IMP::core::DiameterRestraint self, UnaryFunction f, SingletonContainer sc, IMP::Float diameter) -> DiameterRestraint"""
        this = _IMP_core.new_DiameterRestraint(f, sc, diameter)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self):
        """do_get_inputs(DiameterRestraint self) -> IMP::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_create_decomposition(self):
        """do_create_decomposition(DiameterRestraint self) -> IMP::Restraints"""
        return _IMP_core.DiameterRestraint_do_create_decomposition(self)


    def do_create_current_decomposition(self):
        """do_create_current_decomposition(DiameterRestraint self) -> IMP::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.SingletonModifier):
    """Proxy of C++ IMP::core::Transform class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, t, ignore_non_xyz=False):
        """
        __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(t, ignore_non_xyz)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self, m, pis):
        """do_get_inputs(Transform self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.Transform_do_get_inputs(self, m, pis)


    def do_get_outputs(self, m, pis):
        """do_get_outputs(Transform self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.Transform_do_get_outputs(self, m, pis)


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


    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.Decorator):
    """Proxy of C++ IMP::core::Reference class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::Reference self) -> Reference
        __init__(IMP::core::Reference self, Model m, ParticleIndex id) -> Reference
        __init__(IMP::core::Reference self, _ParticleAdaptor d) -> Reference
        """
        this = _IMP_core.new_Reference(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def show(self, *args):
        """
        show(Reference self, _ostream out)
        show(Reference self)
        """
        return _IMP_core.Reference_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi, _ParticleIndexAdaptor reference) -> Reference
        setup_particle(_ParticleAdaptor decorator, _ParticleIndexAdaptor reference) -> Reference
        """
        return _IMP_core.Reference_setup_particle(*args)

    setup_particle = staticmethod(setup_particle)

    def get_reference_particle(self):
        """get_reference_particle(Reference self) -> Particle"""
        return _IMP_core.Reference_get_reference_particle(self)


    def get_is_setup(*args):
        """
        get_is_setup(_ParticleAdaptor p) -> bool
        get_is_setup(Model m, ParticleIndex pi) -> bool
        """
        return _IMP_core.Reference_get_is_setup(*args)

    get_is_setup = staticmethod(get_is_setup)

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

    get_reference_key = staticmethod(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, 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) -> 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, 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, a0):
        """get_derivative(Reference self, FloatKey a0) -> double"""
        return _IMP_core.Reference_get_derivative(self, a0)


    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, a0):
        """set_name(Reference self, std::string a0)"""
        return _IMP_core.Reference_set_name(self, a0)


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


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


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


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


    def get_check_level(self):
        """get_check_level(Reference self) -> IMP::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 __hash__(self):
        """__hash__(Reference self) -> std::size_t"""
        return _IMP_core.Reference___hash__(self)


    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_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi, _ParticleIndexAdaptor reference) -> Reference
    Reference_setup_particle(_ParticleAdaptor decorator, _ParticleIndexAdaptor reference) -> Reference
    """
    return _IMP_core.Reference_setup_particle(*args)

def Reference_get_is_setup(*args):
    """
    get_is_setup(_ParticleAdaptor p) -> bool
    Reference_get_is_setup(Model m, ParticleIndex pi) -> bool
    """
    return _IMP_core.Reference_get_is_setup(*args)

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

class TransformationAndReflectionSymmetry(IMP.SingletonModifier):
    """Proxy of C++ IMP::core::TransformationAndReflectionSymmetry class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, t, r):
        """__init__(IMP::core::TransformationAndReflectionSymmetry self, Transformation3D t, Reflection3D r) -> TransformationAndReflectionSymmetry"""
        this = _IMP_core.new_TransformationAndReflectionSymmetry(t, r)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self, m, pis):
        """do_get_inputs(TransformationAndReflectionSymmetry self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.TransformationAndReflectionSymmetry_do_get_inputs(self, m, pis)


    def do_get_outputs(self, m, pis):
        """do_get_outputs(TransformationAndReflectionSymmetry self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.TransformationAndReflectionSymmetry_do_get_outputs(self, m, pis)


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


    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.SingletonModifier):
    """Proxy of C++ IMP::core::TransformationSymmetry class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, t):
        """__init__(IMP::core::TransformationSymmetry self, Transformation3D t) -> TransformationSymmetry"""
        this = _IMP_core.new_TransformationSymmetry(t)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self, m, pis):
        """do_get_inputs(TransformationSymmetry self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.TransformationSymmetry_do_get_inputs(self, m, pis)


    def do_get_outputs(self, m, pis):
        """do_get_outputs(TransformationSymmetry self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.TransformationSymmetry_do_get_outputs(self, m, pis)


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


    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.Restraint):
    """Proxy of C++ IMP::core::DihedralRestraint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::DihedralRestraint self, Model m, UnaryFunction score_func, _ParticleIndexAdaptor p1, _ParticleIndexAdaptor p2, _ParticleIndexAdaptor p3, _ParticleIndexAdaptor p4) -> DihedralRestraint
        __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 do_get_inputs(self):
        """do_get_inputs(DihedralRestraint self) -> IMP::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 __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.PairScore):
    """Proxy of C++ IMP::core::DistancePairScore class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::DistancePairScore self, UnaryFunction uf, std::string name) -> 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 do_get_inputs(self, m, pis):
        """do_get_inputs(DistancePairScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.DistancePairScore_do_get_inputs(self, m, pis)


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


    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.PairScore):
    """Proxy of C++ IMP::core::HarmonicDistancePairScore class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::HarmonicDistancePairScore self, double x0, double k, std::string name) -> 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 do_get_inputs(self, m, pis):
        """do_get_inputs(HarmonicDistancePairScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.HarmonicDistancePairScore_do_get_inputs(self, m, pis)


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


    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.Restraint):
    """Proxy of C++ IMP::core::DistanceRestraint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::DistanceRestraint self, Model m, UnaryFunction score_func, _ParticleIndexAdaptor a, _ParticleIndexAdaptor b, std::string name) -> DistanceRestraint
        __init__(IMP::core::DistanceRestraint self, Model m, UnaryFunction score_func, _ParticleIndexAdaptor a, _ParticleIndexAdaptor b) -> DistanceRestraint
        __init__(IMP::core::DistanceRestraint self, UnaryFunction score_func, Particle a, Particle b, std::string name) -> DistanceRestraint
        __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)


    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.SingletonScore):
    """Proxy of C++ IMP::core::SphereDistanceToSingletonScore class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, f, pt):
        """__init__(IMP::core::SphereDistanceToSingletonScore self, UnaryFunction f, Vector3D pt) -> SphereDistanceToSingletonScore"""
        this = _IMP_core.new_SphereDistanceToSingletonScore(f, pt)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self, m, pis):
        """do_get_inputs(SphereDistanceToSingletonScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.SphereDistanceToSingletonScore_do_get_inputs(self, m, pis)


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


    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.Restraint):
    """Proxy of C++ IMP::core::ExcludedVolumeRestraint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::ExcludedVolumeRestraint self, _SingletonContainerAdaptor sc, double k=1, double slack=10, std::string name) -> 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)


    def do_create_decomposition(self):
        """do_create_decomposition(ExcludedVolumeRestraint self) -> IMP::Restraints"""
        return _IMP_core.ExcludedVolumeRestraint_do_create_decomposition(self)


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


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


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


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


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


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


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


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


    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, i):
        """get_pair_filter(ExcludedVolumeRestraint self, unsigned int i) -> PairPredicate"""
        return _IMP_core.ExcludedVolumeRestraint_get_pair_filter(self, i)


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


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


    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.Refiner):
    """Proxy of C++ IMP::core::FixedRefiner class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::FixedRefiner self, IMP::ParticlesTemp const & ps) -> FixedRefiner
        __init__(IMP::core::FixedRefiner self, Model m, IMP::ParticleIndexes const & pis) -> FixedRefiner
        """
        this = _IMP_core.new_FixedRefiner(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self, m, pis):
        """do_get_inputs(FixedRefiner self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.FixedRefiner_do_get_inputs(self, m, pis)


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


    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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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_close_pairs(self, *args):
        """
        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::ParticleIndexes const & pc) -> IMP::ParticleIndexPairs
        get_close_pairs(GridClosePairsFinder self, Model m, IMP::ParticleIndexes const & pca, IMP::ParticleIndexes const & pcb) -> IMP::ParticleIndexPairs
        """
        return _IMP_core.GridClosePairsFinder_get_close_pairs(self, *args)


    def do_get_inputs(self, m, pis):
        """do_get_inputs(GridClosePairsFinder self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.GridClosePairsFinder_do_get_inputs(self, m, pis)


    def get_version_info(self):
        """get_version_info(GridClosePairsFinder self) -> VersionInfo"""
        return _IMP_core.GridClosePairsFinder_get_version_info(self)


    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.UnaryFunction):
    """Proxy of C++ IMP::core::Harmonic class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, mean, k):
        """__init__(IMP::core::Harmonic self, IMP::Float mean, IMP::Float k) -> Harmonic"""
        this = _IMP_core.new_Harmonic(mean, k)
        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)


    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, mean):
        """set_mean(Harmonic self, IMP::Float mean)"""
        return _IMP_core.Harmonic_set_mean(self, mean)


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


    def get_k_from_standard_deviation(sd, t=297.15):
        """
        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(sd, t)

    get_k_from_standard_deviation = staticmethod(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(sd, t=297.15):
    """
    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(sd, t)

class HarmonicWell(IMP.UnaryFunction):
    """Proxy of C++ IMP::core::HarmonicWell class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, well, k):
        """__init__(IMP::core::HarmonicWell self, IMP::FloatRange const & well, double k) -> HarmonicWell"""
        this = _IMP_core.new_HarmonicWell(well, k)
        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)


    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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, mean, k):
        """__init__(IMP::core::HarmonicLowerBound self, IMP::Float mean, IMP::Float k) -> HarmonicLowerBound"""
        this = _IMP_core.new_HarmonicLowerBound(mean, k)
        try:
            self.this.append(this)
        except:
            self.this = this

    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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, mean, k):
        """__init__(IMP::core::HarmonicUpperBound self, IMP::Float mean, IMP::Float k) -> HarmonicUpperBound"""
        this = _IMP_core.new_HarmonicUpperBound(mean, k)
        try:
            self.this.append(this)
        except:
            self.this = this

    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 MSConnectivityRestraint(IMP.Restraint):
    """Proxy of C++ IMP::core::MSConnectivityRestraint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, m, ps, eps=0.1):
        """
        __init__(IMP::core::MSConnectivityRestraint self, Model m, PairScore ps, double eps=0.1) -> MSConnectivityRestraint
        __init__(IMP::core::MSConnectivityRestraint self, Model m, PairScore ps) -> MSConnectivityRestraint
        """
        this = _IMP_core.new_MSConnectivityRestraint(m, ps, eps)
        try:
            self.this.append(this)
        except:
            self.this = this

    def add_type(self, ps):
        """add_type(MSConnectivityRestraint self, IMP::ParticlesTemp const & ps) -> unsigned int"""
        return _IMP_core.MSConnectivityRestraint_add_type(self, ps)


    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::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::Restraints"""
        return _IMP_core.MSConnectivityRestraint_do_create_current_decomposition(self)


    def do_get_inputs(self):
        """do_get_inputs(MSConnectivityRestraint self) -> IMP::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)


    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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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, o):
        """__eq__(HierarchyTraits self, HierarchyTraits o) -> bool"""
        return _IMP_core.HierarchyTraits___eq__(self, o)


    def show(self, *args):
        """
        show(HierarchyTraits self, _ostream out)
        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.Decorator):
    """Proxy of C++ IMP::core::Hierarchy class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

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

    get_default_decorator_traits = staticmethod(get_default_decorator_traits)

    def __init__(self, *args):
        """
        __init__(IMP::core::Hierarchy self) -> Hierarchy
        __init__(IMP::core::Hierarchy self, Model m, ParticleIndex id, HierarchyTraits tr) -> Hierarchy
        __init__(IMP::core::Hierarchy self, Model m, ParticleIndex id) -> Hierarchy
        __init__(IMP::core::Hierarchy self, _ParticleAdaptor d, HierarchyTraits tr) -> Hierarchy
        __init__(IMP::core::Hierarchy self, _ParticleAdaptor d) -> Hierarchy
        """
        this = _IMP_core.new_Hierarchy(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def show(self, *args):
        """
        show(Hierarchy self, _ostream out)
        show(Hierarchy self)
        """
        return _IMP_core.Hierarchy_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi, HierarchyTraits tr) -> Hierarchy
        setup_particle(Model m, ParticleIndex pi) -> Hierarchy
        setup_particle(_ParticleAdaptor d, HierarchyTraits tr) -> Hierarchy
        setup_particle(_ParticleAdaptor d) -> Hierarchy
        setup_particle(Model m, ParticleIndex pi, IMP::ParticleIndexes children, HierarchyTraits tr) -> Hierarchy
        setup_particle(Model m, ParticleIndex pi, IMP::ParticleIndexes children) -> Hierarchy
        setup_particle(_ParticleAdaptor d, IMP::ParticleIndexes children, HierarchyTraits tr) -> Hierarchy
        setup_particle(_ParticleAdaptor d, IMP::ParticleIndexes children) -> Hierarchy
        setup_particle(Model m, ParticleIndex pi, IMP::ParticlesTemp children, HierarchyTraits tr) -> Hierarchy
        setup_particle(Model m, ParticleIndex pi, IMP::ParticlesTemp children) -> Hierarchy
        setup_particle(_ParticleAdaptor d, IMP::ParticlesTemp children, HierarchyTraits tr) -> Hierarchy
        setup_particle(_ParticleAdaptor d, IMP::ParticlesTemp children) -> Hierarchy
        """
        return _IMP_core.Hierarchy_setup_particle(*args)

    setup_particle = staticmethod(setup_particle)

    def get_is_setup(*args):
        """
        get_is_setup(_ParticleAdaptor p, HierarchyTraits tr) -> bool
        get_is_setup(_ParticleAdaptor p) -> bool
        get_is_setup(Model arg1, ParticleIndex arg2, HierarchyTraits arg3) -> bool
        get_is_setup(Model arg1, ParticleIndex arg2) -> bool
        """
        return _IMP_core.Hierarchy_get_is_setup(*args)

    get_is_setup = staticmethod(get_is_setup)

    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, i):
        """get_child(Hierarchy self, unsigned int i) -> Hierarchy"""
        return _IMP_core.Hierarchy_get_child(self, i)


    def get_children_indexes(self):
        """get_children_indexes(Hierarchy self) -> IMP::ParticleIndexes"""
        return _IMP_core.Hierarchy_get_children_indexes(self)


    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, h):
        """add_child(Hierarchy self, Hierarchy h)"""
        return _IMP_core.Hierarchy_add_child(self, h)


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


    def get_child_index(self, *args):
        """
        get_child_index(Hierarchy self, unsigned int i) -> ParticleIndex
        get_child_index(Hierarchy self) -> int
        """
        return _IMP_core.Hierarchy_get_child_index(self, *args)


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

    get_default_traits = staticmethod(get_default_traits)

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


    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, 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) -> 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, 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, a0):
        """get_derivative(Hierarchy self, FloatKey a0) -> double"""
        return _IMP_core.Hierarchy_get_derivative(self, a0)


    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, a0):
        """set_name(Hierarchy self, std::string a0)"""
        return _IMP_core.Hierarchy_set_name(self, a0)


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


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


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


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


    def get_check_level(self):
        """get_check_level(Hierarchy self) -> IMP::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 __hash__(self):
        """__hash__(Hierarchy self) -> std::size_t"""
        return _IMP_core.Hierarchy___hash__(self)


    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_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(Model m, ParticleIndex pi, HierarchyTraits tr) -> Hierarchy
    setup_particle(Model m, ParticleIndex pi) -> Hierarchy
    setup_particle(_ParticleAdaptor d, HierarchyTraits tr) -> Hierarchy
    setup_particle(_ParticleAdaptor d) -> Hierarchy
    setup_particle(Model m, ParticleIndex pi, IMP::ParticleIndexes children, HierarchyTraits tr) -> Hierarchy
    setup_particle(Model m, ParticleIndex pi, IMP::ParticleIndexes children) -> Hierarchy
    setup_particle(_ParticleAdaptor d, IMP::ParticleIndexes children, HierarchyTraits tr) -> Hierarchy
    setup_particle(_ParticleAdaptor d, IMP::ParticleIndexes children) -> Hierarchy
    setup_particle(Model m, ParticleIndex pi, IMP::ParticlesTemp children, HierarchyTraits tr) -> Hierarchy
    setup_particle(Model m, ParticleIndex pi, IMP::ParticlesTemp children) -> Hierarchy
    setup_particle(_ParticleAdaptor d, IMP::ParticlesTemp children, HierarchyTraits tr) -> Hierarchy
    Hierarchy_setup_particle(_ParticleAdaptor d, IMP::ParticlesTemp children) -> Hierarchy
    """
    return _IMP_core.Hierarchy_setup_particle(*args)

def Hierarchy_get_is_setup(*args):
    """
    get_is_setup(_ParticleAdaptor p, HierarchyTraits tr) -> bool
    get_is_setup(_ParticleAdaptor p) -> bool
    get_is_setup(Model arg1, ParticleIndex arg2, HierarchyTraits arg3) -> bool
    Hierarchy_get_is_setup(Model arg2, ParticleIndex arg3) -> bool
    """
    return _IMP_core.Hierarchy_get_is_setup(*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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def __call__(self, p):
        """__call__(HierarchyVisitor self, Hierarchy p) -> bool"""
        return _IMP_core.HierarchyVisitor___call__(self, p)

    __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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, sm):
        """__init__(IMP::core::ModifierVisitor self, SingletonModifier sm) -> ModifierVisitor"""
        this = _IMP_core.new_ModifierVisitor(sm)
        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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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)
        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(mhd):
    """get_leaves(Hierarchy mhd) -> IMP::core::GenericHierarchies"""
    return _IMP_core.get_leaves(mhd)

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

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

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

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

def visit_depth_first(d, f):
    """visit_depth_first(Hierarchy d, HierarchyVisitor f)"""
    return _IMP_core.visit_depth_first(d, f)
class LeavesRefiner(IMP.Refiner):
    """Proxy of C++ IMP::core::LeavesRefiner class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, tr):
        """__init__(IMP::core::LeavesRefiner self, HierarchyTraits tr) -> LeavesRefiner"""
        this = _IMP_core.new_LeavesRefiner(tr)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self, m, pis):
        """do_get_inputs(LeavesRefiner self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.LeavesRefiner_do_get_inputs(self, m, pis)


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


    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.UnaryFunction):
    """Proxy of C++ IMP::core::Linear class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, offset, slope):
        """__init__(IMP::core::Linear self, double offset, double slope) -> Linear"""
        this = _IMP_core.new_Linear(offset, slope)
        try:
            self.this.append(this)
        except:
            self.this = this

    def set_slope(self, f):
        """set_slope(Linear self, double f)"""
        return _IMP_core.Linear_set_slope(self, f)


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


    def get_version_info(self):
        """get_version_info(Linear self) -> VersionInfo"""
        return _IMP_core.Linear_get_version_info(self)


    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.ScoringFunction):
    """Proxy of C++ IMP::core::IncrementalScoringFunction class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::IncrementalScoringFunction self, IMP::ParticlesTemp const & to_move, IMP::RestraintsTemp const & rs, double weight=1.0, double max, std::string name) -> IncrementalScoringFunction
        __init__(IMP::core::IncrementalScoringFunction self, IMP::ParticlesTemp const & to_move, IMP::RestraintsTemp const & rs, double weight=1.0, double max) -> IncrementalScoringFunction
        __init__(IMP::core::IncrementalScoringFunction self, IMP::ParticlesTemp const & to_move, IMP::RestraintsTemp const & rs, double weight=1.0) -> IncrementalScoringFunction
        __init__(IMP::core::IncrementalScoringFunction self, IMP::ParticlesTemp const & to_move, IMP::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, p):
        """set_moved_particles(IncrementalScoringFunction self, IMP::ParticleIndexes const & p)"""
        return _IMP_core.IncrementalScoringFunction_set_moved_particles(self, p)


    def add_close_pair_score(self, *args):
        """
        add_close_pair_score(IncrementalScoringFunction self, PairScore ps, double distance, IMP::ParticlesTemp const & particles, IMP::PairPredicates const & filters)
        add_close_pair_score(IncrementalScoringFunction self, PairScore ps, double distance, IMP::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_indexes(self):
        """get_movable_indexes(IncrementalScoringFunction self) -> IMP::ParticleIndexes"""
        return _IMP_core.IncrementalScoringFunction_get_movable_indexes(self)


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


    def do_get_inputs(self):
        """do_get_inputs(IncrementalScoringFunction self) -> IMP::ModelObjectsTemp"""
        return _IMP_core.IncrementalScoringFunction_do_get_inputs(self)


    def handle_set_has_required_score_states(self, arg2):
        """handle_set_has_required_score_states(IncrementalScoringFunction self, bool arg2)"""
        return _IMP_core.IncrementalScoringFunction_handle_set_has_required_score_states(self, arg2)


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


    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.IMP_CORE_HAS_MONTE_CARLO_MOVER_swigconstant(_IMP_core)
IMP_CORE_HAS_MONTE_CARLO_MOVER = _IMP_core.IMP_CORE_HAS_MONTE_CARLO_MOVER
class MonteCarlo(IMP.Optimizer):
    """Proxy of C++ IMP::core::MonteCarlo class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, m):
        """__init__(IMP::core::MonteCarlo self, Model m) -> MonteCarlo"""
        this = _IMP_core.new_MonteCarlo(m)
        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)


    def set_return_best(self, tf):
        """set_return_best(MonteCarlo self, bool tf)"""
        return _IMP_core.MonteCarlo_set_return_best(self, tf)


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


    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_downward_steps(self):
        """get_number_of_downward_steps(MonteCarlo self) -> unsigned int"""
        return _IMP_core.MonteCarlo_get_number_of_downward_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 get_number_of_proposed_steps(self):
        """get_number_of_proposed_steps(MonteCarlo self) -> unsigned int"""
        return _IMP_core.MonteCarlo_get_number_of_proposed_steps(self)


    def get_number_of_accepted_steps(self):
        """get_number_of_accepted_steps(MonteCarlo self) -> unsigned int"""
        return _IMP_core.MonteCarlo_get_number_of_accepted_steps(self)


    def reset_statistics(self):
        """reset_statistics(MonteCarlo self)"""
        return _IMP_core.MonteCarlo_reset_statistics(self)


    def set_score_threshold(self, s):
        """set_score_threshold(MonteCarlo self, double s)"""
        return _IMP_core.MonteCarlo_set_score_threshold(self, s)


    def get_score_threshold(self):
        """get_score_threshold(MonteCarlo self) -> double"""
        return _IMP_core.MonteCarlo_get_score_threshold(self)


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


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


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


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


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


    def set_movers_order(self, objs):
        """set_movers_order(MonteCarlo self, IMP::core::MonteCarloMovers const & objs)"""
        return _IMP_core.MonteCarlo_set_movers_order(self, objs)


    def add_mover(self, obj):
        """add_mover(MonteCarlo self, MonteCarloMover obj) -> unsigned int"""
        return _IMP_core.MonteCarlo_add_mover(self, obj)


    def add_movers(self, objs):
        """add_movers(MonteCarlo self, IMP::core::MonteCarloMovers const & objs)"""
        return _IMP_core.MonteCarlo_add_movers(self, objs)


    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, i):
        """get_mover(MonteCarlo self, unsigned int i) -> MonteCarloMover"""
        return _IMP_core.MonteCarlo_get_mover(self, i)


    def get_movers(self):
        """get_movers(MonteCarlo self) -> IMP::core::MonteCarloMovers"""
        return _IMP_core.MonteCarlo_get_movers(self)


    def reserve_movers(self, sz):
        """reserve_movers(MonteCarlo self, unsigned int sz)"""
        return _IMP_core.MonteCarlo_reserve_movers(self, sz)


    def set_incremental_scoring_function(self, isf):
        """set_incremental_scoring_function(MonteCarlo self, IncrementalScoringFunction isf)"""
        return _IMP_core.MonteCarlo_set_incremental_scoring_function(self, isf)


    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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, opt, steps):
        """__init__(IMP::core::MonteCarloWithLocalOptimization self, Optimizer opt, unsigned int steps) -> MonteCarloWithLocalOptimization"""
        this = _IMP_core.new_MonteCarloWithLocalOptimization(opt, steps)
        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)


    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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, opt, ns):
        """__init__(IMP::core::MonteCarloWithBasinHopping self, Optimizer opt, unsigned int ns) -> MonteCarloWithBasinHopping"""
        this = _IMP_core.new_MonteCarloWithBasinHopping(opt, ns)
        try:
            self.this.append(this)
        except:
            self.this = this

    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 NeighborsTable(IMP.ScoreState):
    """Proxy of C++ IMP::core::NeighborsTable class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::NeighborsTable self, PairContainer input, std::string name) -> NeighborsTable
        __init__(IMP::core::NeighborsTable self, PairContainer input) -> NeighborsTable
        """
        this = _IMP_core.new_NeighborsTable(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def get_neighbors(self, pi):
        """get_neighbors(NeighborsTable self, ParticleIndex pi) -> IMP::ParticleIndexes const &"""
        return _IMP_core.NeighborsTable_get_neighbors(self, pi)


    def get_version_info(self):
        """get_version_info(NeighborsTable self) -> VersionInfo"""
        return _IMP_core.NeighborsTable_get_version_info(self)


    def __str__(self):
        """__str__(NeighborsTable self) -> std::string"""
        return _IMP_core.NeighborsTable___str__(self)


    def __repr__(self):
        """__repr__(NeighborsTable self) -> std::string"""
        return _IMP_core.NeighborsTable___repr__(self)

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

NeighborsTable_swigregister = _IMP_core.NeighborsTable_swigregister
NeighborsTable_swigregister(NeighborsTable)

class NormalMover(MonteCarloMover):
    """Proxy of C++ IMP::core::NormalMover class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::NormalMover self, Model m, ParticleIndex pi, IMP::FloatKeys const & vars, double stddev) -> NormalMover
        __init__(IMP::core::NormalMover self, Model m, ParticleIndex pi, double stddev) -> NormalMover
        __init__(IMP::core::NormalMover self, IMP::ParticlesTemp const & sc, IMP::FloatKeys const & vars, IMP::Float sigma) -> NormalMover
        __init__(IMP::core::NormalMover self, IMP::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, sigma):
        """set_sigma(NormalMover self, IMP::Float sigma)"""
        return _IMP_core.NormalMover_set_sigma(self, sigma)


    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)


    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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, values, minrange, spacing, extend=False):
        """
        __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(values, minrange, spacing, extend)
        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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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
        get_are_close(QuadraticClosePairsFinder self, Model m, ParticleIndex a, ParticleIndex b) -> bool
        """
        return _IMP_core.QuadraticClosePairsFinder_get_are_close(self, *args)


    def get_close_pairs(self, *args):
        """
        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
        get_close_pairs(QuadraticClosePairsFinder self, Model m, IMP::ParticleIndexes const & pc) -> IMP::ParticleIndexPairs
        get_close_pairs(QuadraticClosePairsFinder self, Model m, IMP::ParticleIndexes const & pca, IMP::ParticleIndexes const & pcb) -> IMP::ParticleIndexPairs
        """
        return _IMP_core.QuadraticClosePairsFinder_get_close_pairs(self, *args)


    def do_get_inputs(self, m, pis):
        """do_get_inputs(QuadraticClosePairsFinder self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.QuadraticClosePairsFinder_do_get_inputs(self, m, pis)


    def get_version_info(self):
        """get_version_info(QuadraticClosePairsFinder self) -> VersionInfo"""
        return _IMP_core.QuadraticClosePairsFinder_get_version_info(self)


    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.PairScore):
    """Proxy of C++ IMP::core::RefinedPairsPairScore class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, r, f):
        """__init__(IMP::core::RefinedPairsPairScore self, Refiner r, PairScore f) -> RefinedPairsPairScore"""
        this = _IMP_core.new_RefinedPairsPairScore(r, f)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self, m, pis):
        """do_get_inputs(RefinedPairsPairScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.RefinedPairsPairScore_do_get_inputs(self, m, pis)


    def get_version_info(self):
        """get_version_info(RefinedPairsPairScore self) -> VersionInfo"""
        return _IMP_core.RefinedPairsPairScore_get_version_info(self)


    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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def get_rigid_members(self):
        """get_rigid_members(RigidBody self) -> IMP::core::RigidMembers"""
        return _IMP_core.RigidBody_get_rigid_members(self)


    def get_member_particle_indexes(self):
        """get_member_particle_indexes(RigidBody self) -> IMP::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::ParticleIndexes const &"""
        return _IMP_core.RigidBody_get_body_member_particle_indexes(self)


    def get_member_indexes(self):
        """get_member_indexes(RigidBody self) -> IMP::ParticleIndexes"""
        return _IMP_core.RigidBody_get_member_indexes(self)


    def __init__(self, *args):
        """
        __init__(IMP::core::RigidBody self) -> RigidBody
        __init__(IMP::core::RigidBody self, Model m, ParticleIndex id) -> RigidBody
        __init__(IMP::core::RigidBody self, _ParticleAdaptor d) -> RigidBody
        """
        this = _IMP_core.new_RigidBody(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def show(self, *args):
        """
        show(RigidBody self, _ostream out)
        show(RigidBody self)
        """
        return _IMP_core.RigidBody_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi, _ParticleIndexesAdaptor ps) -> RigidBody
        setup_particle(_ParticleAdaptor decorator, _ParticleIndexesAdaptor ps) -> RigidBody
        setup_particle(Model m, ParticleIndex pi, ReferenceFrame3D rf) -> RigidBody
        setup_particle(_ParticleAdaptor decorator, ReferenceFrame3D rf) -> RigidBody
        """
        return _IMP_core.RigidBody_setup_particle(*args)

    setup_particle = staticmethod(setup_particle)

    def teardown_particle(rb):
        """teardown_particle(RigidBody rb)"""
        return _IMP_core.RigidBody_teardown_particle(rb)

    teardown_particle = staticmethod(teardown_particle)
    __swig_destroy__ = _IMP_core.delete_RigidBody
    __del__ = lambda self: None

    def get_is_setup(*args):
        """
        get_is_setup(_ParticleAdaptor p) -> bool
        get_is_setup(Model m, ParticleIndex pi) -> bool
        """
        return _IMP_core.RigidBody_get_is_setup(*args)

    get_is_setup = staticmethod(get_is_setup)

    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, tr):
        """set_reference_frame(RigidBody self, ReferenceFrame3D tr)"""
        return _IMP_core.RigidBody_set_reference_frame(self, tr)


    def set_reference_frame_lazy(self, tr):
        """set_reference_frame_lazy(RigidBody self, ReferenceFrame3D tr)"""
        return _IMP_core.RigidBody_set_reference_frame_lazy(self, tr)


    def set_reference_frame_from_members(self, members):
        """set_reference_frame_from_members(RigidBody self, IMP::ParticleIndexes const & members)"""
        return _IMP_core.RigidBody_set_reference_frame_from_members(self, members)


    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, tf):
        """set_coordinates_are_optimized(RigidBody self, bool tf)"""
        return _IMP_core.RigidBody_set_coordinates_are_optimized(self, tf)


    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, i):
        """get_member(RigidBody self, unsigned int i) -> RigidMember"""
        return _IMP_core.RigidBody_get_member(self, i)


    def add_member(self, p):
        """add_member(RigidBody self, _ParticleIndexAdaptor p)"""
        return _IMP_core.RigidBody_add_member(self, p)


    def add_non_rigid_member(self, p):
        """add_non_rigid_member(RigidBody self, _ParticleIndexAdaptor p)"""
        return _IMP_core.RigidBody_add_non_rigid_member(self, p)


    def set_is_rigid_member(self, pi, tf):
        """set_is_rigid_member(RigidBody self, ParticleIndex pi, bool tf)"""
        return _IMP_core.RigidBody_set_is_rigid_member(self, pi, tf)


    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, 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) -> 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, 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, a0):
        """get_derivative(RigidBody self, FloatKey a0) -> double"""
        return _IMP_core.RigidBody_get_derivative(self, a0)


    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, a0):
        """set_name(RigidBody self, std::string a0)"""
        return _IMP_core.RigidBody_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(RigidBody self, IMP::CheckLevel a0)"""
        return _IMP_core.RigidBody_set_check_level(self, a0)


    def add_to_derivative(self, a0, a1, a2):
        """add_to_derivative(RigidBody self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_core.RigidBody_add_to_derivative(self, a0, a1, a2)


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(RigidBody self, FloatKey a0, bool a1)"""
        return _IMP_core.RigidBody_set_is_optimized(self, a0, a1)


    def get_is_optimized(self, a0):
        """get_is_optimized(RigidBody self, FloatKey a0) -> bool"""
        return _IMP_core.RigidBody_get_is_optimized(self, a0)


    def get_check_level(self):
        """get_check_level(RigidBody self) -> IMP::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 __hash__(self):
        """__hash__(RigidBody self) -> std::size_t"""
        return _IMP_core.RigidBody___hash__(self)


    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_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi, _ParticleIndexesAdaptor ps) -> RigidBody
    setup_particle(_ParticleAdaptor decorator, _ParticleIndexesAdaptor ps) -> RigidBody
    setup_particle(Model m, ParticleIndex pi, ReferenceFrame3D rf) -> RigidBody
    RigidBody_setup_particle(_ParticleAdaptor decorator, ReferenceFrame3D rf) -> RigidBody
    """
    return _IMP_core.RigidBody_setup_particle(*args)

def RigidBody_teardown_particle(rb):
    """RigidBody_teardown_particle(RigidBody rb)"""
    return _IMP_core.RigidBody_teardown_particle(rb)

def RigidBody_get_is_setup(*args):
    """
    get_is_setup(_ParticleAdaptor p) -> bool
    RigidBody_get_is_setup(Model m, ParticleIndex pi) -> bool
    """
    return _IMP_core.RigidBody_get_is_setup(*args)


def add_rigid_body_cache_key(k):
    """add_rigid_body_cache_key(ObjectKey k)"""
    return _IMP_core.add_rigid_body_cache_key(k)
class RigidBodyMember(XYZ):
    """Proxy of C++ IMP::core::RigidBodyMember class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::RigidBodyMember self) -> RigidBodyMember
        __init__(IMP::core::RigidBodyMember self, Model m, ParticleIndex id) -> RigidBodyMember
        __init__(IMP::core::RigidBodyMember self, _ParticleAdaptor d) -> RigidBodyMember
        """
        this = _IMP_core.new_RigidBodyMember(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def show(self, *args):
        """
        show(RigidBodyMember self, _ostream out)
        show(RigidBodyMember self)
        """
        return _IMP_core.RigidBodyMember_show(self, *args)


    def get_rigid_body(self):
        """get_rigid_body(RigidBodyMember self) -> RigidBody"""
        return _IMP_core.RigidBodyMember_get_rigid_body(self)


    def get_internal_coordinates(self):
        """get_internal_coordinates(RigidBodyMember self) -> Vector3D"""
        return _IMP_core.RigidBodyMember_get_internal_coordinates(self)


    def set_internal_coordinates(self, v):
        """set_internal_coordinates(RigidBodyMember self, Vector3D v)"""
        return _IMP_core.RigidBodyMember_set_internal_coordinates(self, v)


    def set_internal_transformation(self, v):
        """set_internal_transformation(RigidBodyMember self, Transformation3D v)"""
        return _IMP_core.RigidBodyMember_set_internal_transformation(self, v)


    def get_internal_transformation(self):
        """get_internal_transformation(RigidBodyMember self) -> Transformation3D"""
        return _IMP_core.RigidBodyMember_get_internal_transformation(self)

    __swig_destroy__ = _IMP_core.delete_RigidBodyMember
    __del__ = lambda self: None

    def set_coordinates(self, *args):
        """
        set_coordinates(RigidBodyMember self, Vector3D center)
        set_coordinates(RigidBodyMember self, Transformation3D tr)
        """
        return _IMP_core.RigidBodyMember_set_coordinates(self, *args)


    def get_is_setup(*args):
        """
        get_is_setup(_ParticleAdaptor p) -> bool
        get_is_setup(Model m, _ParticleIndexAdaptor p) -> bool
        """
        return _IMP_core.RigidBodyMember_get_is_setup(*args)

    get_is_setup = staticmethod(get_is_setup)

    def get_internal_coordinate_keys():
        """get_internal_coordinate_keys() -> IMP::FloatKeys"""
        return _IMP_core.RigidBodyMember_get_internal_coordinate_keys()

    get_internal_coordinate_keys = staticmethod(get_internal_coordinate_keys)

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


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


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


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


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


    def get_derivative(self, a0):
        """get_derivative(RigidBodyMember self, FloatKey a0) -> double"""
        return _IMP_core.RigidBodyMember_get_derivative(self, a0)


    def get_name(self):
        """get_name(RigidBodyMember self) -> std::string"""
        return _IMP_core.RigidBodyMember_get_name(self)


    def clear_caches(self):
        """clear_caches(RigidBodyMember self)"""
        return _IMP_core.RigidBodyMember_clear_caches(self)


    def set_name(self, a0):
        """set_name(RigidBodyMember self, std::string a0)"""
        return _IMP_core.RigidBodyMember_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(RigidBodyMember self, IMP::CheckLevel a0)"""
        return _IMP_core.RigidBodyMember_set_check_level(self, a0)


    def add_to_derivative(self, a0, a1, a2):
        """add_to_derivative(RigidBodyMember self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_core.RigidBodyMember_add_to_derivative(self, a0, a1, a2)


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(RigidBodyMember self, FloatKey a0, bool a1)"""
        return _IMP_core.RigidBodyMember_set_is_optimized(self, a0, a1)


    def get_is_optimized(self, a0):
        """get_is_optimized(RigidBodyMember self, FloatKey a0) -> bool"""
        return _IMP_core.RigidBodyMember_get_is_optimized(self, a0)


    def get_check_level(self):
        """get_check_level(RigidBodyMember self) -> IMP::CheckLevel"""
        return _IMP_core.RigidBodyMember_get_check_level(self)


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


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


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


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


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


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


    def __hash__(self):
        """__hash__(RigidBodyMember self) -> std::size_t"""
        return _IMP_core.RigidBodyMember___hash__(self)


    def __str__(self):
        """__str__(RigidBodyMember self) -> std::string"""
        return _IMP_core.RigidBodyMember___str__(self)


    def __repr__(self):
        """__repr__(RigidBodyMember self) -> std::string"""
        return _IMP_core.RigidBodyMember___repr__(self)

RigidBodyMember_swigregister = _IMP_core.RigidBodyMember_swigregister
RigidBodyMember_swigregister(RigidBodyMember)

def RigidBodyMember_get_is_setup(*args):
    """
    get_is_setup(_ParticleAdaptor p) -> bool
    RigidBodyMember_get_is_setup(Model m, _ParticleIndexAdaptor p) -> bool
    """
    return _IMP_core.RigidBodyMember_get_is_setup(*args)

def RigidBodyMember_get_internal_coordinate_keys():
    """RigidBodyMember_get_internal_coordinate_keys() -> IMP::FloatKeys"""
    return _IMP_core.RigidBodyMember_get_internal_coordinate_keys()

class RigidMember(RigidBodyMember):
    """Proxy of C++ IMP::core::RigidMember class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::RigidMember self) -> RigidMember
        __init__(IMP::core::RigidMember self, Model m, ParticleIndex id) -> RigidMember
        __init__(IMP::core::RigidMember self, _ParticleAdaptor d) -> RigidMember
        """
        this = _IMP_core.new_RigidMember(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def show(self, *args):
        """
        show(RigidMember self, _ostream out)
        show(RigidMember self)
        """
        return _IMP_core.RigidMember_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_RigidMember
    __del__ = lambda self: None

    def get_is_setup(*args):
        """
        get_is_setup(_ParticleAdaptor p) -> bool
        get_is_setup(Model m, _ParticleIndexAdaptor p) -> bool
        """
        return _IMP_core.RigidMember_get_is_setup(*args)

    get_is_setup = staticmethod(get_is_setup)

    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, 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) -> 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, 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, a0):
        """get_derivative(RigidMember self, FloatKey a0) -> double"""
        return _IMP_core.RigidMember_get_derivative(self, a0)


    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, a0):
        """set_name(RigidMember self, std::string a0)"""
        return _IMP_core.RigidMember_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(RigidMember self, IMP::CheckLevel a0)"""
        return _IMP_core.RigidMember_set_check_level(self, a0)


    def add_to_derivative(self, a0, a1, a2):
        """add_to_derivative(RigidMember self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_core.RigidMember_add_to_derivative(self, a0, a1, a2)


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(RigidMember self, FloatKey a0, bool a1)"""
        return _IMP_core.RigidMember_set_is_optimized(self, a0, a1)


    def get_is_optimized(self, a0):
        """get_is_optimized(RigidMember self, FloatKey a0) -> bool"""
        return _IMP_core.RigidMember_get_is_optimized(self, a0)


    def get_check_level(self):
        """get_check_level(RigidMember self) -> IMP::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 __hash__(self):
        """__hash__(RigidMember self) -> std::size_t"""
        return _IMP_core.RigidMember___hash__(self)


    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_get_is_setup(*args):
    """
    get_is_setup(_ParticleAdaptor p) -> bool
    RigidMember_get_is_setup(Model m, _ParticleIndexAdaptor p) -> bool
    """
    return _IMP_core.RigidMember_get_is_setup(*args)

class NonRigidMember(RigidBodyMember):
    """Proxy of C++ IMP::core::NonRigidMember class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::NonRigidMember self) -> NonRigidMember
        __init__(IMP::core::NonRigidMember self, Model m, ParticleIndex id) -> NonRigidMember
        __init__(IMP::core::NonRigidMember self, _ParticleAdaptor d) -> NonRigidMember
        """
        this = _IMP_core.new_NonRigidMember(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def show(self, *args):
        """
        show(NonRigidMember self, _ostream out)
        show(NonRigidMember self)
        """
        return _IMP_core.NonRigidMember_show(self, *args)

    __swig_destroy__ = _IMP_core.delete_NonRigidMember
    __del__ = lambda self: None

    def get_is_setup(*args):
        """
        get_is_setup(_ParticleAdaptor p) -> bool
        get_is_setup(Model m, ParticleIndex p) -> bool
        """
        return _IMP_core.NonRigidMember_get_is_setup(*args)

    get_is_setup = staticmethod(get_is_setup)

    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, 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) -> 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, 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, a0):
        """get_derivative(NonRigidMember self, FloatKey a0) -> double"""
        return _IMP_core.NonRigidMember_get_derivative(self, a0)


    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, a0):
        """set_name(NonRigidMember self, std::string a0)"""
        return _IMP_core.NonRigidMember_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(NonRigidMember self, IMP::CheckLevel a0)"""
        return _IMP_core.NonRigidMember_set_check_level(self, a0)


    def add_to_derivative(self, a0, a1, a2):
        """add_to_derivative(NonRigidMember self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_core.NonRigidMember_add_to_derivative(self, a0, a1, a2)


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(NonRigidMember self, FloatKey a0, bool a1)"""
        return _IMP_core.NonRigidMember_set_is_optimized(self, a0, a1)


    def get_is_optimized(self, a0):
        """get_is_optimized(NonRigidMember self, FloatKey a0) -> bool"""
        return _IMP_core.NonRigidMember_get_is_optimized(self, a0)


    def get_check_level(self):
        """get_check_level(NonRigidMember self) -> IMP::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 __hash__(self):
        """__hash__(NonRigidMember self) -> std::size_t"""
        return _IMP_core.NonRigidMember___hash__(self)


    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_get_is_setup(*args):
    """
    get_is_setup(_ParticleAdaptor p) -> bool
    NonRigidMember_get_is_setup(Model m, ParticleIndex p) -> bool
    """
    return _IMP_core.NonRigidMember_get_is_setup(*args)

class RigidMembersRefiner(IMP.Refiner):
    """Proxy of C++ IMP::core::RigidMembersRefiner class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::RigidMembersRefiner self, std::string name) -> RigidMembersRefiner
        __init__(IMP::core::RigidMembersRefiner self) -> RigidMembersRefiner
        """
        this = _IMP_core.new_RigidMembersRefiner(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self, m, pis):
        """do_get_inputs(RigidMembersRefiner self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.RigidMembersRefiner_do_get_inputs(self, m, pis)


    def get_version_info(self):
        """get_version_info(RigidMembersRefiner self) -> VersionInfo"""
        return _IMP_core.RigidMembersRefiner_get_version_info(self)


    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(Model m, IMP::ParticleIndexes const & pis) -> ReferenceFrame3D
    get_initial_reference_frame(IMP::ParticlesTemp const & ps) -> ReferenceFrame3D
    """
    return _IMP_core.get_initial_reference_frame(*args)

def create_rigid_bodies(m, n, no_members=False):
    """
    create_rigid_bodies(Model m, unsigned int n, bool no_members=False) -> IMP::ParticlesTemp
    create_rigid_bodies(Model m, unsigned int n) -> IMP::ParticlesTemp
    """
    return _IMP_core.create_rigid_bodies(m, n, no_members)

def show_rigid_body_hierarchy(*args):
    """
    show_rigid_body_hierarchy(RigidBody rb, TextOutput out)
    show_rigid_body_hierarchy(RigidBody rb)
    """
    return _IMP_core.show_rigid_body_hierarchy(*args)

def get_root_rigid_body(m):
    """get_root_rigid_body(RigidMember m) -> ParticleIndex"""
    return _IMP_core.get_root_rigid_body(m)
class RigidBodyHierarchyGeometry(IMP.display.SingletonGeometry):
    """Proxy of C++ IMP::core::RigidBodyHierarchyGeometry class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, rb, constituents):
        """__init__(IMP::core::RigidBodyHierarchyGeometry self, RigidBody rb, IMP::ParticlesTemp const & constituents) -> RigidBodyHierarchyGeometry"""
        this = _IMP_core.new_RigidBodyHierarchyGeometry(rb, constituents)
        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)


    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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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)


    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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, sc):
        """__init__(IMP::core::RigidBodyDerivativesGeometry self, SingletonContainer sc) -> RigidBodyDerivativesGeometry"""
        this = _IMP_core.new_RigidBodyDerivativesGeometry(sc)
        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)


    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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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)


    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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, sc):
        """__init__(IMP::core::RigidBodyFramesGeometry self, SingletonContainer sc) -> RigidBodyFramesGeometry"""
        this = _IMP_core.new_RigidBodyFramesGeometry(sc)
        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)


    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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, p):
        """__init__(IMP::core::RigidBodyTorque self, Particle p) -> RigidBodyTorque"""
        this = _IMP_core.new_RigidBodyTorque(p)
        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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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::algebra::BoundingBox3Ds const & bbs) -> IMP::IntPairs
        get_close_pairs(NearestNeighborsClosePairsFinder self, IMP::algebra::BoundingBox3Ds const & bas, IMP::algebra::BoundingBox3Ds const & bbs) -> IMP::IntPairs
        get_close_pairs(NearestNeighborsClosePairsFinder self, Model m, IMP::ParticleIndexes const & pc) -> IMP::ParticleIndexPairs
        get_close_pairs(NearestNeighborsClosePairsFinder self, Model m, IMP::ParticleIndexes const & pca, IMP::ParticleIndexes const & pcb) -> IMP::ParticleIndexPairs
        """
        return _IMP_core.NearestNeighborsClosePairsFinder_get_close_pairs(self, *args)


    def do_get_inputs(self, m, pis):
        """do_get_inputs(NearestNeighborsClosePairsFinder self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.NearestNeighborsClosePairsFinder_do_get_inputs(self, m, pis)


    def get_version_info(self):
        """get_version_info(NearestNeighborsClosePairsFinder self) -> VersionInfo"""
        return _IMP_core.NearestNeighborsClosePairsFinder_get_version_info(self)


    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.ScoringFunction):
    """Proxy of C++ IMP::core::RestraintsScoringFunction class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::RestraintsScoringFunction self, _RestraintsAdaptor rs, double weight=1.0, double max, std::string name) -> RestraintsScoringFunction
        __init__(IMP::core::RestraintsScoringFunction self, _RestraintsAdaptor rs, double weight=1.0, double max) -> RestraintsScoringFunction
        __init__(IMP::core::RestraintsScoringFunction self, _RestraintsAdaptor rs, double weight=1.0) -> RestraintsScoringFunction
        __init__(IMP::core::RestraintsScoringFunction self, _RestraintsAdaptor rs) -> RestraintsScoringFunction
        __init__(IMP::core::RestraintsScoringFunction self, _RestraintsAdaptor 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, sa, ss):
        """do_add_score_and_derivatives(RestraintsScoringFunction self, ScoreAccumulator sa, IMP::ScoreStatesTemp const & ss)"""
        return _IMP_core.RestraintsScoringFunction_do_add_score_and_derivatives(self, sa, ss)


    def do_get_inputs(self):
        """do_get_inputs(RestraintsScoringFunction self) -> IMP::ModelObjectsTemp"""
        return _IMP_core.RestraintsScoringFunction_do_get_inputs(self)


    def get_version_info(self):
        """get_version_info(RestraintsScoringFunction self) -> VersionInfo"""
        return _IMP_core.RestraintsScoringFunction_get_version_info(self)


    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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, cpf=None):
        """
        __init__(IMP::core::RigidClosePairsFinder self, ClosePairsFinder cpf=None) -> RigidClosePairsFinder
        __init__(IMP::core::RigidClosePairsFinder self) -> RigidClosePairsFinder
        """
        this = _IMP_core.new_RigidClosePairsFinder(cpf)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self, m, pis):
        """do_get_inputs(RigidClosePairsFinder self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.RigidClosePairsFinder_do_get_inputs(self, m, pis)


    def get_close_pairs(self, *args):
        """
        get_close_pairs(RigidClosePairsFinder self, Model m, ParticleIndex a, ParticleIndex b, IMP::ParticleIndexes const & pa, IMP::ParticleIndexes const & pb) -> IMP::ParticleIndexPairs
        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
        get_close_pairs(RigidClosePairsFinder self, Model m, IMP::ParticleIndexes const & pc) -> IMP::ParticleIndexPairs
        get_close_pairs(RigidClosePairsFinder self, Model m, IMP::ParticleIndexes const & pca, IMP::ParticleIndexes const & pcb) -> IMP::ParticleIndexPairs
        """
        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 __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.PairScore):
    """Proxy of C++ IMP::core::SphereDistancePairScore class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::SphereDistancePairScore self, UnaryFunction uf, std::string name) -> 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 do_get_inputs(self, m, pis):
        """do_get_inputs(SphereDistancePairScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.SphereDistancePairScore_do_get_inputs(self, m, pis)


    def get_version_info(self):
        """get_version_info(SphereDistancePairScore self) -> VersionInfo"""
        return _IMP_core.SphereDistancePairScore_get_version_info(self)


    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.PairScore):
    """Proxy of C++ IMP::core::HarmonicUpperBoundSphereDistancePairScore class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::HarmonicUpperBoundSphereDistancePairScore self, double x0, double k, std::string name) -> 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 do_get_inputs(self, m, pis):
        """do_get_inputs(HarmonicUpperBoundSphereDistancePairScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.HarmonicUpperBoundSphereDistancePairScore_do_get_inputs(self, m, pis)


    def get_version_info(self):
        """get_version_info(HarmonicUpperBoundSphereDistancePairScore self) -> VersionInfo"""
        return _IMP_core.HarmonicUpperBoundSphereDistancePairScore_get_version_info(self)


    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.PairScore):
    """Proxy of C++ IMP::core::HarmonicUpperBoundSphereDiameterPairScore class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, d0, k):
        """__init__(IMP::core::HarmonicUpperBoundSphereDiameterPairScore self, double d0, double k) -> HarmonicUpperBoundSphereDiameterPairScore"""
        this = _IMP_core.new_HarmonicUpperBoundSphereDiameterPairScore(d0, k)
        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 do_get_inputs(self, m, pis):
        """do_get_inputs(HarmonicUpperBoundSphereDiameterPairScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.HarmonicUpperBoundSphereDiameterPairScore_do_get_inputs(self, m, pis)


    def get_version_info(self):
        """get_version_info(HarmonicUpperBoundSphereDiameterPairScore self) -> VersionInfo"""
        return _IMP_core.HarmonicUpperBoundSphereDiameterPairScore_get_version_info(self)


    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.PairScore):
    """Proxy of C++ IMP::core::HarmonicSphereDistancePairScore class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::HarmonicSphereDistancePairScore self, double x0, double k, std::string name) -> 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 do_get_inputs(self, m, pis):
        """do_get_inputs(HarmonicSphereDistancePairScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.HarmonicSphereDistancePairScore_do_get_inputs(self, m, pis)


    def get_version_info(self):
        """get_version_info(HarmonicSphereDistancePairScore self) -> VersionInfo"""
        return _IMP_core.HarmonicSphereDistancePairScore_get_version_info(self)


    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.PairScore):
    """Proxy of C++ IMP::core::NormalizedSphereDistancePairScore class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::NormalizedSphereDistancePairScore self, UnaryFunction f, 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_get_inputs(self, m, pis):
        """do_get_inputs(NormalizedSphereDistancePairScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.NormalizedSphereDistancePairScore_do_get_inputs(self, m, pis)


    def get_version_info(self):
        """get_version_info(NormalizedSphereDistancePairScore self) -> VersionInfo"""
        return _IMP_core.NormalizedSphereDistancePairScore_get_version_info(self)


    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.PairScore):
    """Proxy of C++ IMP::core::WeightedSphereDistancePairScore class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::WeightedSphereDistancePairScore self, UnaryFunction f, FloatKey weight, 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_get_inputs(self, m, pis):
        """do_get_inputs(WeightedSphereDistancePairScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.WeightedSphereDistancePairScore_do_get_inputs(self, m, pis)


    def get_version_info(self):
        """get_version_info(WeightedSphereDistancePairScore self) -> VersionInfo"""
        return _IMP_core.WeightedSphereDistancePairScore_get_version_info(self)


    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.PairScore):
    """Proxy of C++ IMP::core::SoftSpherePairScore class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::SoftSpherePairScore self, double k, std::string name) -> 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 do_get_inputs(self, m, pis):
        """do_get_inputs(SoftSpherePairScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.SoftSpherePairScore_do_get_inputs(self, m, pis)


    def get_version_info(self):
        """get_version_info(SoftSpherePairScore self) -> VersionInfo"""
        return _IMP_core.SoftSpherePairScore_get_version_info(self)


    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.AttributeOptimizer):
    """Proxy of C++ IMP::core::SteepestDescent class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::SteepestDescent self, Model m, std::string name) -> SteepestDescent
        __init__(IMP::core::SteepestDescent self, Model m) -> SteepestDescent
        """
        this = _IMP_core.new_SteepestDescent(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_optimize(self, max_steps):
        """do_optimize(SteepestDescent self, unsigned int max_steps) -> IMP::Float"""
        return _IMP_core.SteepestDescent_do_optimize(self, max_steps)


    def get_version_info(self):
        """get_version_info(SteepestDescent self) -> VersionInfo"""
        return _IMP_core.SteepestDescent_get_version_info(self)


    def set_threshold(self, t):
        """set_threshold(SteepestDescent self, IMP::Float t)"""
        return _IMP_core.SteepestDescent_set_threshold(self, t)


    def set_step_size(self, t):
        """set_step_size(SteepestDescent self, IMP::Float t)"""
        return _IMP_core.SteepestDescent_set_step_size(self, t)


    def set_maximum_step_size(self, t):
        """set_maximum_step_size(SteepestDescent self, IMP::Float t)"""
        return _IMP_core.SteepestDescent_set_maximum_step_size(self, t)


    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.PairScore):
    """Proxy of C++ IMP::core::TransformedDistancePairScore class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, f, transformation):
        """__init__(IMP::core::TransformedDistancePairScore self, UnaryFunction f, Transformation3D transformation) -> TransformedDistancePairScore"""
        this = _IMP_core.new_TransformedDistancePairScore(f, transformation)
        try:
            self.this.append(this)
        except:
            self.this = this

    def set_transformation(self, rot):
        """set_transformation(TransformedDistancePairScore self, Transformation3D rot)"""
        return _IMP_core.TransformedDistancePairScore_set_transformation(self, rot)


    def do_get_inputs(self, m, pis):
        """do_get_inputs(TransformedDistancePairScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.TransformedDistancePairScore_do_get_inputs(self, m, pis)


    def get_version_info(self):
        """get_version_info(TransformedDistancePairScore self) -> VersionInfo"""
        return _IMP_core.TransformedDistancePairScore_get_version_info(self)


    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.PairScore):
    """Proxy of C++ IMP::core::TypedPairScore class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, typekey, allow_invalid_types=True):
        """
        __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(typekey, allow_invalid_types)
        try:
            self.this.append(this)
        except:
            self.this = this

    def set_particle_type(self, arg2):
        """set_particle_type(TypedPairScore self, Particle arg2)"""
        return _IMP_core.TypedPairScore_set_particle_type(self, arg2)


    def set_pair_score(self, ps, atype, btype):
        """set_pair_score(TypedPairScore self, PairScore ps, IMP::Int atype, IMP::Int btype)"""
        return _IMP_core.TypedPairScore_set_pair_score(self, ps, atype, btype)


    def do_get_inputs(self, m, pis):
        """do_get_inputs(TypedPairScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.TypedPairScore_do_get_inputs(self, m, pis)


    def get_version_info(self):
        """get_version_info(TypedPairScore self) -> VersionInfo"""
        return _IMP_core.TypedPairScore_get_version_info(self)


    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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, ps, r):
        """__init__(IMP::core::RigidBodyDistancePairScore self, PairScore ps, Refiner r) -> RigidBodyDistancePairScore"""
        this = _IMP_core.new_RigidBodyDistancePairScore(ps, r)
        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 RigidBodyAnglePairScore(IMP.PairScore):
    """Proxy of C++ IMP::core::RigidBodyAnglePairScore class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, f):
        """__init__(IMP::core::RigidBodyAnglePairScore self, UnaryFunction f) -> RigidBodyAnglePairScore"""
        this = _IMP_core.new_RigidBodyAnglePairScore(f)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self, m, pis):
        """do_get_inputs(RigidBodyAnglePairScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.RigidBodyAnglePairScore_do_get_inputs(self, m, pis)


    def get_version_info(self):
        """get_version_info(RigidBodyAnglePairScore self) -> VersionInfo"""
        return _IMP_core.RigidBodyAnglePairScore_get_version_info(self)


    def __str__(self):
        """__str__(RigidBodyAnglePairScore self) -> std::string"""
        return _IMP_core.RigidBodyAnglePairScore___str__(self)


    def __repr__(self):
        """__repr__(RigidBodyAnglePairScore self) -> std::string"""
        return _IMP_core.RigidBodyAnglePairScore___repr__(self)

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

RigidBodyAnglePairScore_swigregister = _IMP_core.RigidBodyAnglePairScore_swigregister
RigidBodyAnglePairScore_swigregister(RigidBodyAnglePairScore)

class TableRefiner(IMP.Refiner):
    """Proxy of C++ IMP::core::TableRefiner class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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, p, ps):
        """add_particle(TableRefiner self, Particle p, IMP::ParticlesTemp const & ps)"""
        return _IMP_core.TableRefiner_add_particle(self, p, ps)


    def remove_particle(self, p):
        """remove_particle(TableRefiner self, Particle p)"""
        return _IMP_core.TableRefiner_remove_particle(self, p)


    def set_particle(self, p, ps):
        """set_particle(TableRefiner self, Particle p, IMP::ParticlesTemp const & ps)"""
        return _IMP_core.TableRefiner_set_particle(self, p, ps)


    def do_get_inputs(self, m, pis):
        """do_get_inputs(TableRefiner self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.TableRefiner_do_get_inputs(self, m, pis)


    def get_version_info(self):
        """get_version_info(TableRefiner self) -> VersionInfo"""
        return _IMP_core.TableRefiner_get_version_info(self)


    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)


_IMP_core.LOWER_swigconstant(_IMP_core)
LOWER = _IMP_core.LOWER

_IMP_core.BOTH_swigconstant(_IMP_core)
BOTH = _IMP_core.BOTH

_IMP_core.UPPER_swigconstant(_IMP_core)
UPPER = _IMP_core.UPPER
class MCCGSampler(IMP.Sampler):
    """Proxy of C++ IMP::core::MCCGSampler class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::MCCGSampler self, Model m, std::string name) -> 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, bb):
        """set_bounding_box(MCCGSampler self, BoundingBox3D bb)"""
        return _IMP_core.MCCGSampler_set_bounding_box(self, bb)


    def set_number_of_attempts(self, att):
        """set_number_of_attempts(MCCGSampler self, unsigned int att)"""
        return _IMP_core.MCCGSampler_set_number_of_attempts(self, att)


    def set_number_of_monte_carlo_steps(self, cg):
        """set_number_of_monte_carlo_steps(MCCGSampler self, unsigned int cg)"""
        return _IMP_core.MCCGSampler_set_number_of_monte_carlo_steps(self, cg)


    def set_number_of_conjugate_gradient_steps(self, cg):
        """set_number_of_conjugate_gradient_steps(MCCGSampler self, unsigned int cg)"""
        return _IMP_core.MCCGSampler_set_number_of_conjugate_gradient_steps(self, cg)


    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, tf):
        """set_is_refining(MCCGSampler self, bool tf)"""
        return _IMP_core.MCCGSampler_set_is_refining(self, tf)


    def set_local_optimizer(self, opt):
        """set_local_optimizer(MCCGSampler self, Optimizer opt)"""
        return _IMP_core.MCCGSampler_set_local_optimizer(self, opt)


    def set_save_rejected_configurations(self, tf):
        """set_save_rejected_configurations(MCCGSampler self, bool tf)"""
        return _IMP_core.MCCGSampler_set_save_rejected_configurations(self, tf)


    def get_rejected_configurations(self):
        """get_rejected_configurations(MCCGSampler self) -> ConfigurationSet"""
        return _IMP_core.MCCGSampler_get_rejected_configurations(self)


    def remove_optimizer_state(self, d):
        """remove_optimizer_state(MCCGSampler self, OptimizerState d)"""
        return _IMP_core.MCCGSampler_remove_optimizer_state(self, d)


    def remove_optimizer_states(self, d):
        """remove_optimizer_states(MCCGSampler self, IMP::OptimizerStates const & d)"""
        return _IMP_core.MCCGSampler_remove_optimizer_states(self, d)


    def set_optimizer_states(self, ps):
        """set_optimizer_states(MCCGSampler self, IMP::OptimizerStates const & ps)"""
        return _IMP_core.MCCGSampler_set_optimizer_states(self, ps)


    def set_optimizer_states_order(self, objs):
        """set_optimizer_states_order(MCCGSampler self, IMP::OptimizerStates const & objs)"""
        return _IMP_core.MCCGSampler_set_optimizer_states_order(self, objs)


    def add_optimizer_state(self, obj):
        """add_optimizer_state(MCCGSampler self, OptimizerState obj) -> unsigned int"""
        return _IMP_core.MCCGSampler_add_optimizer_state(self, obj)


    def add_optimizer_states(self, objs):
        """add_optimizer_states(MCCGSampler self, IMP::OptimizerStates const & objs)"""
        return _IMP_core.MCCGSampler_add_optimizer_states(self, objs)


    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, i):
        """get_optimizer_state(MCCGSampler self, unsigned int i) -> OptimizerState"""
        return _IMP_core.MCCGSampler_get_optimizer_state(self, i)


    def get_optimizer_states(self):
        """get_optimizer_states(MCCGSampler self) -> IMP::OptimizerStates"""
        return _IMP_core.MCCGSampler_get_optimizer_states(self)


    def reserve_optimizer_states(self, sz):
        """reserve_optimizer_states(MCCGSampler self, unsigned int sz)"""
        return _IMP_core.MCCGSampler_reserve_optimizer_states(self, sz)


    def do_sample(self):
        """do_sample(MCCGSampler self) -> ConfigurationSet"""
        return _IMP_core.MCCGSampler_do_sample(self)


    def get_version_info(self):
        """get_version_info(MCCGSampler self) -> VersionInfo"""
        return _IMP_core.MCCGSampler_get_version_info(self)


    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.Restraint):
    """Proxy of C++ IMP::core::MinimumRestraint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::MinimumRestraint self, unsigned int num, IMP::Restraints const & rs, std::string name) -> MinimumRestraint
        __init__(IMP::core::MinimumRestraint self, unsigned int num, IMP::Restraints const & rs) -> 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)


    def remove_restraint(self, d):
        """remove_restraint(MinimumRestraint self, Restraint d)"""
        return _IMP_core.MinimumRestraint_remove_restraint(self, d)


    def remove_restraints(self, d):
        """remove_restraints(MinimumRestraint self, IMP::Restraints const & d)"""
        return _IMP_core.MinimumRestraint_remove_restraints(self, d)


    def set_restraints(self, ps):
        """set_restraints(MinimumRestraint self, IMP::Restraints const & ps)"""
        return _IMP_core.MinimumRestraint_set_restraints(self, ps)


    def set_restraints_order(self, objs):
        """set_restraints_order(MinimumRestraint self, IMP::Restraints const & objs)"""
        return _IMP_core.MinimumRestraint_set_restraints_order(self, objs)


    def add_restraint(self, obj):
        """add_restraint(MinimumRestraint self, Restraint obj) -> unsigned int"""
        return _IMP_core.MinimumRestraint_add_restraint(self, obj)


    def add_restraints(self, objs):
        """add_restraints(MinimumRestraint self, IMP::Restraints const & objs)"""
        return _IMP_core.MinimumRestraint_add_restraints(self, objs)


    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, i):
        """get_restraint(MinimumRestraint self, unsigned int i) -> Restraint"""
        return _IMP_core.MinimumRestraint_get_restraint(self, i)


    def get_restraints(self):
        """get_restraints(MinimumRestraint self) -> IMP::Restraints"""
        return _IMP_core.MinimumRestraint_get_restraints(self)


    def reserve_restraints(self, sz):
        """reserve_restraints(MinimumRestraint self, unsigned int sz)"""
        return _IMP_core.MinimumRestraint_reserve_restraints(self, sz)


    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 Gaussian(RigidBody):
    """Proxy of C++ IMP::core::Gaussian class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::Gaussian self) -> Gaussian
        __init__(IMP::core::Gaussian self, Model m, ParticleIndex id) -> Gaussian
        __init__(IMP::core::Gaussian self, _ParticleAdaptor d) -> Gaussian
        """
        this = _IMP_core.new_Gaussian(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def show(self, *args):
        """
        show(Gaussian self, _ostream out)
        show(Gaussian self)
        """
        return _IMP_core.Gaussian_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi) -> Gaussian
        setup_particle(_ParticleAdaptor decorator) -> Gaussian
        setup_particle(Model m, ParticleIndex pi, Gaussian3D g) -> Gaussian
        setup_particle(_ParticleAdaptor decorator, Gaussian3D g) -> Gaussian
        """
        return _IMP_core.Gaussian_setup_particle(*args)

    setup_particle = staticmethod(setup_particle)

    def get_local_covariance_key():
        """get_local_covariance_key() -> ObjectKey"""
        return _IMP_core.Gaussian_get_local_covariance_key()

    get_local_covariance_key = staticmethod(get_local_covariance_key)

    def get_global_covariance_key():
        """get_global_covariance_key() -> ObjectKey"""
        return _IMP_core.Gaussian_get_global_covariance_key()

    get_global_covariance_key = staticmethod(get_global_covariance_key)

    def get_is_setup(*args):
        """
        get_is_setup(_ParticleAdaptor p) -> bool
        get_is_setup(Model m, ParticleIndex pi) -> bool
        """
        return _IMP_core.Gaussian_get_is_setup(*args)

    get_is_setup = staticmethod(get_is_setup)

    def get_local_covariance(self):
        """get_local_covariance(Gaussian self) -> IMP_Eigen::Matrix3d"""
        return _IMP_core.Gaussian_get_local_covariance(self)


    def get_variances(self):
        """get_variances(Gaussian self) -> Vector3D"""
        return _IMP_core.Gaussian_get_variances(self)


    def get_global_covariance(self):
        """get_global_covariance(Gaussian self) -> IMP_Eigen::Matrix3d"""
        return _IMP_core.Gaussian_get_global_covariance(self)


    def get_gaussian(self):
        """get_gaussian(Gaussian self) -> Gaussian3D"""
        return _IMP_core.Gaussian_get_gaussian(self)


    def set_local_covariance(self, covar):
        """set_local_covariance(Gaussian self, IMP_Eigen::Vector3d const covar)"""
        return _IMP_core.Gaussian_set_local_covariance(self, covar)


    def set_variances(self, v):
        """set_variances(Gaussian self, Vector3D v)"""
        return _IMP_core.Gaussian_set_variances(self, v)


    def set_global_covariance(self, covar):
        """set_global_covariance(Gaussian self, IMP_Eigen::Matrix3d covar)"""
        return _IMP_core.Gaussian_set_global_covariance(self, covar)


    def update_global_covariance(self):
        """update_global_covariance(Gaussian self)"""
        return _IMP_core.Gaussian_update_global_covariance(self)


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


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


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


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


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


    def get_derivative(self, a0):
        """get_derivative(Gaussian self, FloatKey a0) -> double"""
        return _IMP_core.Gaussian_get_derivative(self, a0)


    def get_name(self):
        """get_name(Gaussian self) -> std::string"""
        return _IMP_core.Gaussian_get_name(self)


    def clear_caches(self):
        """clear_caches(Gaussian self)"""
        return _IMP_core.Gaussian_clear_caches(self)


    def set_name(self, a0):
        """set_name(Gaussian self, std::string a0)"""
        return _IMP_core.Gaussian_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(Gaussian self, IMP::CheckLevel a0)"""
        return _IMP_core.Gaussian_set_check_level(self, a0)


    def add_to_derivative(self, a0, a1, a2):
        """add_to_derivative(Gaussian self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_core.Gaussian_add_to_derivative(self, a0, a1, a2)


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(Gaussian self, FloatKey a0, bool a1)"""
        return _IMP_core.Gaussian_set_is_optimized(self, a0, a1)


    def get_is_optimized(self, a0):
        """get_is_optimized(Gaussian self, FloatKey a0) -> bool"""
        return _IMP_core.Gaussian_get_is_optimized(self, a0)


    def get_check_level(self):
        """get_check_level(Gaussian self) -> IMP::CheckLevel"""
        return _IMP_core.Gaussian_get_check_level(self)


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


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


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


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


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


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


    def __hash__(self):
        """__hash__(Gaussian self) -> std::size_t"""
        return _IMP_core.Gaussian___hash__(self)


    def __str__(self):
        """__str__(Gaussian self) -> std::string"""
        return _IMP_core.Gaussian___str__(self)


    def __repr__(self):
        """__repr__(Gaussian self) -> std::string"""
        return _IMP_core.Gaussian___repr__(self)

    __swig_destroy__ = _IMP_core.delete_Gaussian
    __del__ = lambda self: None
Gaussian_swigregister = _IMP_core.Gaussian_swigregister
Gaussian_swigregister(Gaussian)

def Gaussian_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi) -> Gaussian
    setup_particle(_ParticleAdaptor decorator) -> Gaussian
    setup_particle(Model m, ParticleIndex pi, Gaussian3D g) -> Gaussian
    Gaussian_setup_particle(_ParticleAdaptor decorator, Gaussian3D g) -> Gaussian
    """
    return _IMP_core.Gaussian_setup_particle(*args)

def Gaussian_get_local_covariance_key():
    """Gaussian_get_local_covariance_key() -> ObjectKey"""
    return _IMP_core.Gaussian_get_local_covariance_key()

def Gaussian_get_global_covariance_key():
    """Gaussian_get_global_covariance_key() -> ObjectKey"""
    return _IMP_core.Gaussian_get_global_covariance_key()

def Gaussian_get_is_setup(*args):
    """
    get_is_setup(_ParticleAdaptor p) -> bool
    Gaussian_get_is_setup(Model m, ParticleIndex pi) -> bool
    """
    return _IMP_core.Gaussian_get_is_setup(*args)

class PairRestraint(IMP.Restraint):
    """Proxy of C++ IMP::core::PairRestraint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::PairRestraint self, Model m, PairScore ss, IMP::ParticleIndexPair const & vt, std::string name) -> PairRestraint
        __init__(IMP::core::PairRestraint self, Model m, PairScore ss, IMP::ParticleIndexPair const & vt) -> PairRestraint
        __init__(IMP::core::PairRestraint self, PairScore ss, IMP::ParticlePair const & vt, std::string name) -> PairRestraint
        __init__(IMP::core::PairRestraint self, PairScore ss, IMP::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)


    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.Restraint):
    """Proxy of C++ IMP::core::SingletonRestraint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::SingletonRestraint self, Model m, SingletonScore ss, ParticleIndex vt, std::string name) -> SingletonRestraint
        __init__(IMP::core::SingletonRestraint self, Model m, SingletonScore ss, ParticleIndex vt) -> SingletonRestraint
        __init__(IMP::core::SingletonRestraint self, SingletonScore ss, Particle vt, std::string name) -> 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)


    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.Restraint):
    """Proxy of C++ IMP::core::TripletRestraint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::TripletRestraint self, Model m, TripletScore ss, IMP::ParticleIndexTriplet const & vt, std::string name) -> TripletRestraint
        __init__(IMP::core::TripletRestraint self, Model m, TripletScore ss, IMP::ParticleIndexTriplet const & vt) -> TripletRestraint
        __init__(IMP::core::TripletRestraint self, TripletScore ss, IMP::ParticleTriplet const & vt, std::string name) -> TripletRestraint
        __init__(IMP::core::TripletRestraint self, TripletScore ss, IMP::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)


    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.Restraint):
    """Proxy of C++ IMP::core::QuadRestraint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::QuadRestraint self, Model m, QuadScore ss, IMP::ParticleIndexQuad const & vt, std::string name) -> QuadRestraint
        __init__(IMP::core::QuadRestraint self, Model m, QuadScore ss, IMP::ParticleIndexQuad const & vt) -> QuadRestraint
        __init__(IMP::core::QuadRestraint self, QuadScore ss, IMP::ParticleQuad const & vt, std::string name) -> QuadRestraint
        __init__(IMP::core::QuadRestraint self, QuadScore ss, IMP::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)


    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.Constraint):
    """Proxy of C++ IMP::core::SingletonConstraint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::SingletonConstraint self, SingletonModifier before, SingletonModifier after, Particle vt, std::string name) -> SingletonConstraint
        __init__(IMP::core::SingletonConstraint self, SingletonModifier before, SingletonModifier after, Particle vt) -> SingletonConstraint
        __init__(IMP::core::SingletonConstraint self, SingletonModifier before, SingletonModifier after, Model m, ParticleIndex vt, std::string name) -> SingletonConstraint
        __init__(IMP::core::SingletonConstraint self, SingletonModifier before, SingletonModifier after, Model m, ParticleIndex 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)


    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.Constraint):
    """Proxy of C++ IMP::core::PairConstraint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::PairConstraint self, PairModifier before, PairModifier after, IMP::ParticlePair const & vt, std::string name) -> PairConstraint
        __init__(IMP::core::PairConstraint self, PairModifier before, PairModifier after, IMP::ParticlePair const & vt) -> PairConstraint
        __init__(IMP::core::PairConstraint self, PairModifier before, PairModifier after, Model m, IMP::ParticleIndexPair const & vt, std::string name) -> PairConstraint
        __init__(IMP::core::PairConstraint self, PairModifier before, PairModifier after, Model m, IMP::ParticleIndexPair 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)


    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.Constraint):
    """Proxy of C++ IMP::core::TripletConstraint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::TripletConstraint self, TripletModifier before, TripletModifier after, IMP::ParticleTriplet const & vt, std::string name) -> TripletConstraint
        __init__(IMP::core::TripletConstraint self, TripletModifier before, TripletModifier after, IMP::ParticleTriplet const & vt) -> TripletConstraint
        __init__(IMP::core::TripletConstraint self, TripletModifier before, TripletModifier after, Model m, IMP::ParticleIndexTriplet const & vt, std::string name) -> TripletConstraint
        __init__(IMP::core::TripletConstraint self, TripletModifier before, TripletModifier after, Model m, IMP::ParticleIndexTriplet 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)


    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.Constraint):
    """Proxy of C++ IMP::core::QuadConstraint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::QuadConstraint self, QuadModifier before, QuadModifier after, IMP::ParticleQuad const & vt, std::string name) -> QuadConstraint
        __init__(IMP::core::QuadConstraint self, QuadModifier before, QuadModifier after, IMP::ParticleQuad const & vt) -> QuadConstraint
        __init__(IMP::core::QuadConstraint self, QuadModifier before, QuadModifier after, Model m, IMP::ParticleIndexQuad const & vt, std::string name) -> QuadConstraint
        __init__(IMP::core::QuadConstraint self, QuadModifier before, QuadModifier after, Model m, IMP::ParticleIndexQuad 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)


    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.SingletonPredicate):
    """Proxy of C++ IMP::core::ConstantSingletonPredicate class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::ConstantSingletonPredicate self, int v, std::string name) -> 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 do_get_inputs(self, arg2, arg3):
        """do_get_inputs(ConstantSingletonPredicate self, Model arg2, IMP::ParticleIndexes const & arg3) -> IMP::ModelObjectsTemp"""
        return _IMP_core.ConstantSingletonPredicate_do_get_inputs(self, arg2, arg3)


    def get_value(self, *args):
        """
        get_value(ConstantSingletonPredicate self, Particle a) -> int
        get_value(ConstantSingletonPredicate self, IMP::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 arg2, ParticleIndex arg3) -> int
        get_value_index(ConstantSingletonPredicate self, Model m, IMP::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)


    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.SingletonPredicate):
    """Proxy of C++ IMP::core::UnorderedTypeSingletonPredicate class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::UnorderedTypeSingletonPredicate self, std::string name) -> UnorderedTypeSingletonPredicate
        __init__(IMP::core::UnorderedTypeSingletonPredicate self) -> UnorderedTypeSingletonPredicate
        """
        this = _IMP_core.new_UnorderedTypeSingletonPredicate(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self, m, pis):
        """do_get_inputs(UnorderedTypeSingletonPredicate self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.UnorderedTypeSingletonPredicate_do_get_inputs(self, m, pis)


    def get_value(self, *args):
        """
        get_value(UnorderedTypeSingletonPredicate self, Particle a) -> int
        get_value(UnorderedTypeSingletonPredicate self, IMP::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, ParticleIndex pi) -> int
        get_value_index(UnorderedTypeSingletonPredicate self, Model m, IMP::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)


    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.SingletonPredicate):
    """Proxy of C++ IMP::core::OrderedTypeSingletonPredicate class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::OrderedTypeSingletonPredicate self, std::string name) -> OrderedTypeSingletonPredicate
        __init__(IMP::core::OrderedTypeSingletonPredicate self) -> OrderedTypeSingletonPredicate
        """
        this = _IMP_core.new_OrderedTypeSingletonPredicate(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self, m, pis):
        """do_get_inputs(OrderedTypeSingletonPredicate self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.OrderedTypeSingletonPredicate_do_get_inputs(self, m, pis)


    def get_value(self, *args):
        """
        get_value(OrderedTypeSingletonPredicate self, IMP::core::ParticleTypes const & types) -> int
        get_value(OrderedTypeSingletonPredicate self, Particle a) -> int
        get_value(OrderedTypeSingletonPredicate self, IMP::ParticlesTemp const & o) -> IMP::Ints
        """
        return _IMP_core.OrderedTypeSingletonPredicate_get_value(self, *args)


    def get_value_index(self, *args):
        """
        get_value_index(OrderedTypeSingletonPredicate self, Model m, ParticleIndex pi) -> int
        get_value_index(OrderedTypeSingletonPredicate self, Model m, IMP::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)


    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.SingletonPredicate):
    """Proxy of C++ IMP::core::AllSameSingletonPredicate class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::AllSameSingletonPredicate self, std::string name) -> AllSameSingletonPredicate
        __init__(IMP::core::AllSameSingletonPredicate self) -> AllSameSingletonPredicate
        """
        this = _IMP_core.new_AllSameSingletonPredicate(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self, arg2, arg3):
        """do_get_inputs(AllSameSingletonPredicate self, Model arg2, IMP::ParticleIndexes const & arg3) -> IMP::ModelObjectsTemp"""
        return _IMP_core.AllSameSingletonPredicate_do_get_inputs(self, arg2, arg3)


    def get_value(self, *args):
        """
        get_value(AllSameSingletonPredicate self, Particle a) -> int
        get_value(AllSameSingletonPredicate self, IMP::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, ParticleIndex pi) -> int
        get_value_index(AllSameSingletonPredicate self, Model m, IMP::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)


    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.SingletonPredicate):
    """Proxy of C++ IMP::core::CoinFlipSingletonPredicate class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::CoinFlipSingletonPredicate self, double p, std::string name) -> 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 do_get_inputs(self, arg2, arg3):
        """do_get_inputs(CoinFlipSingletonPredicate self, Model arg2, IMP::ParticleIndexes const & arg3) -> IMP::ModelObjectsTemp"""
        return _IMP_core.CoinFlipSingletonPredicate_do_get_inputs(self, arg2, arg3)


    def get_value(self, *args):
        """
        get_value(CoinFlipSingletonPredicate self, Particle a) -> int
        get_value(CoinFlipSingletonPredicate self, IMP::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 arg2, ParticleIndex arg3) -> int
        get_value_index(CoinFlipSingletonPredicate self, Model m, IMP::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)


    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.PairPredicate):
    """Proxy of C++ IMP::core::ConstantPairPredicate class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::ConstantPairPredicate self, int v, std::string name) -> 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 do_get_inputs(self, arg2, arg3):
        """do_get_inputs(ConstantPairPredicate self, Model arg2, IMP::ParticleIndexes const & arg3) -> IMP::ModelObjectsTemp"""
        return _IMP_core.ConstantPairPredicate_do_get_inputs(self, arg2, arg3)


    def get_value(self, *args):
        """
        get_value(ConstantPairPredicate self, IMP::ParticlePair const & a) -> int
        get_value(ConstantPairPredicate self, IMP::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 arg2, IMP::ParticleIndexPair const & arg3) -> int
        get_value_index(ConstantPairPredicate self, Model m, IMP::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)


    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.PairPredicate):
    """Proxy of C++ IMP::core::UnorderedTypePairPredicate class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::UnorderedTypePairPredicate self, std::string name) -> UnorderedTypePairPredicate
        __init__(IMP::core::UnorderedTypePairPredicate self) -> UnorderedTypePairPredicate
        """
        this = _IMP_core.new_UnorderedTypePairPredicate(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self, m, pis):
        """do_get_inputs(UnorderedTypePairPredicate self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.UnorderedTypePairPredicate_do_get_inputs(self, m, pis)


    def get_value(self, *args):
        """
        get_value(UnorderedTypePairPredicate self, IMP::ParticlePair const & a) -> int
        get_value(UnorderedTypePairPredicate self, IMP::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::ParticleIndexPair const & pi) -> int
        get_value_index(UnorderedTypePairPredicate self, Model m, IMP::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)


    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.PairPredicate):
    """Proxy of C++ IMP::core::OrderedTypePairPredicate class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::OrderedTypePairPredicate self, std::string name) -> OrderedTypePairPredicate
        __init__(IMP::core::OrderedTypePairPredicate self) -> OrderedTypePairPredicate
        """
        this = _IMP_core.new_OrderedTypePairPredicate(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self, m, pis):
        """do_get_inputs(OrderedTypePairPredicate self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.OrderedTypePairPredicate_do_get_inputs(self, m, pis)


    def get_value(self, *args):
        """
        get_value(OrderedTypePairPredicate self, IMP::core::ParticleTypes const & types) -> int
        get_value(OrderedTypePairPredicate self, IMP::ParticlePair const & a) -> int
        get_value(OrderedTypePairPredicate self, IMP::ParticlePairsTemp const & o) -> IMP::Ints
        """
        return _IMP_core.OrderedTypePairPredicate_get_value(self, *args)


    def get_value_index(self, *args):
        """
        get_value_index(OrderedTypePairPredicate self, Model m, IMP::ParticleIndexPair const & pi) -> int
        get_value_index(OrderedTypePairPredicate self, Model m, IMP::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)


    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.PairPredicate):
    """Proxy of C++ IMP::core::AllSamePairPredicate class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::AllSamePairPredicate self, std::string name) -> AllSamePairPredicate
        __init__(IMP::core::AllSamePairPredicate self) -> AllSamePairPredicate
        """
        this = _IMP_core.new_AllSamePairPredicate(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self, arg2, arg3):
        """do_get_inputs(AllSamePairPredicate self, Model arg2, IMP::ParticleIndexes const & arg3) -> IMP::ModelObjectsTemp"""
        return _IMP_core.AllSamePairPredicate_do_get_inputs(self, arg2, arg3)


    def get_value(self, *args):
        """
        get_value(AllSamePairPredicate self, IMP::ParticlePair const & a) -> int
        get_value(AllSamePairPredicate self, IMP::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::ParticleIndexPair const & pi) -> int
        get_value_index(AllSamePairPredicate self, Model m, IMP::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)


    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.PairPredicate):
    """Proxy of C++ IMP::core::CoinFlipPairPredicate class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::CoinFlipPairPredicate self, double p, std::string name) -> 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 do_get_inputs(self, arg2, arg3):
        """do_get_inputs(CoinFlipPairPredicate self, Model arg2, IMP::ParticleIndexes const & arg3) -> IMP::ModelObjectsTemp"""
        return _IMP_core.CoinFlipPairPredicate_do_get_inputs(self, arg2, arg3)


    def get_value(self, *args):
        """
        get_value(CoinFlipPairPredicate self, IMP::ParticlePair const & a) -> int
        get_value(CoinFlipPairPredicate self, IMP::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 arg2, IMP::ParticleIndexPair const & arg3) -> int
        get_value_index(CoinFlipPairPredicate self, Model m, IMP::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)


    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.TripletPredicate):
    """Proxy of C++ IMP::core::ConstantTripletPredicate class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::ConstantTripletPredicate self, int v, std::string name) -> 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 do_get_inputs(self, arg2, arg3):
        """do_get_inputs(ConstantTripletPredicate self, Model arg2, IMP::ParticleIndexes const & arg3) -> IMP::ModelObjectsTemp"""
        return _IMP_core.ConstantTripletPredicate_do_get_inputs(self, arg2, arg3)


    def get_value(self, *args):
        """
        get_value(ConstantTripletPredicate self, IMP::ParticleTriplet const & a) -> int
        get_value(ConstantTripletPredicate self, IMP::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 arg2, IMP::ParticleIndexTriplet const & arg3) -> int
        get_value_index(ConstantTripletPredicate self, Model m, IMP::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)


    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.TripletPredicate):
    """Proxy of C++ IMP::core::UnorderedTypeTripletPredicate class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::UnorderedTypeTripletPredicate self, std::string name) -> UnorderedTypeTripletPredicate
        __init__(IMP::core::UnorderedTypeTripletPredicate self) -> UnorderedTypeTripletPredicate
        """
        this = _IMP_core.new_UnorderedTypeTripletPredicate(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self, m, pis):
        """do_get_inputs(UnorderedTypeTripletPredicate self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.UnorderedTypeTripletPredicate_do_get_inputs(self, m, pis)


    def get_value(self, *args):
        """
        get_value(UnorderedTypeTripletPredicate self, IMP::ParticleTriplet const & a) -> int
        get_value(UnorderedTypeTripletPredicate self, IMP::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::ParticleIndexTriplet const & pi) -> int
        get_value_index(UnorderedTypeTripletPredicate self, Model m, IMP::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)


    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.TripletPredicate):
    """Proxy of C++ IMP::core::OrderedTypeTripletPredicate class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::OrderedTypeTripletPredicate self, std::string name) -> OrderedTypeTripletPredicate
        __init__(IMP::core::OrderedTypeTripletPredicate self) -> OrderedTypeTripletPredicate
        """
        this = _IMP_core.new_OrderedTypeTripletPredicate(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self, m, pis):
        """do_get_inputs(OrderedTypeTripletPredicate self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.OrderedTypeTripletPredicate_do_get_inputs(self, m, pis)


    def get_value(self, *args):
        """
        get_value(OrderedTypeTripletPredicate self, IMP::core::ParticleTypes const & types) -> int
        get_value(OrderedTypeTripletPredicate self, IMP::ParticleTriplet const & a) -> int
        get_value(OrderedTypeTripletPredicate self, IMP::ParticleTripletsTemp const & o) -> IMP::Ints
        """
        return _IMP_core.OrderedTypeTripletPredicate_get_value(self, *args)


    def get_value_index(self, *args):
        """
        get_value_index(OrderedTypeTripletPredicate self, Model m, IMP::ParticleIndexTriplet const & pi) -> int
        get_value_index(OrderedTypeTripletPredicate self, Model m, IMP::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)


    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.TripletPredicate):
    """Proxy of C++ IMP::core::AllSameTripletPredicate class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::AllSameTripletPredicate self, std::string name) -> AllSameTripletPredicate
        __init__(IMP::core::AllSameTripletPredicate self) -> AllSameTripletPredicate
        """
        this = _IMP_core.new_AllSameTripletPredicate(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self, arg2, arg3):
        """do_get_inputs(AllSameTripletPredicate self, Model arg2, IMP::ParticleIndexes const & arg3) -> IMP::ModelObjectsTemp"""
        return _IMP_core.AllSameTripletPredicate_do_get_inputs(self, arg2, arg3)


    def get_value(self, *args):
        """
        get_value(AllSameTripletPredicate self, IMP::ParticleTriplet const & a) -> int
        get_value(AllSameTripletPredicate self, IMP::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::ParticleIndexTriplet const & pi) -> int
        get_value_index(AllSameTripletPredicate self, Model m, IMP::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)


    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.TripletPredicate):
    """Proxy of C++ IMP::core::CoinFlipTripletPredicate class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::CoinFlipTripletPredicate self, double p, std::string name) -> 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 do_get_inputs(self, arg2, arg3):
        """do_get_inputs(CoinFlipTripletPredicate self, Model arg2, IMP::ParticleIndexes const & arg3) -> IMP::ModelObjectsTemp"""
        return _IMP_core.CoinFlipTripletPredicate_do_get_inputs(self, arg2, arg3)


    def get_value(self, *args):
        """
        get_value(CoinFlipTripletPredicate self, IMP::ParticleTriplet const & a) -> int
        get_value(CoinFlipTripletPredicate self, IMP::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 arg2, IMP::ParticleIndexTriplet const & arg3) -> int
        get_value_index(CoinFlipTripletPredicate self, Model m, IMP::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)


    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.QuadPredicate):
    """Proxy of C++ IMP::core::ConstantQuadPredicate class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::ConstantQuadPredicate self, int v, std::string name) -> 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 do_get_inputs(self, arg2, arg3):
        """do_get_inputs(ConstantQuadPredicate self, Model arg2, IMP::ParticleIndexes const & arg3) -> IMP::ModelObjectsTemp"""
        return _IMP_core.ConstantQuadPredicate_do_get_inputs(self, arg2, arg3)


    def get_value(self, *args):
        """
        get_value(ConstantQuadPredicate self, IMP::ParticleQuad const & a) -> int
        get_value(ConstantQuadPredicate self, IMP::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 arg2, IMP::ParticleIndexQuad const & arg3) -> int
        get_value_index(ConstantQuadPredicate self, Model m, IMP::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)


    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.QuadPredicate):
    """Proxy of C++ IMP::core::UnorderedTypeQuadPredicate class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::UnorderedTypeQuadPredicate self, std::string name) -> UnorderedTypeQuadPredicate
        __init__(IMP::core::UnorderedTypeQuadPredicate self) -> UnorderedTypeQuadPredicate
        """
        this = _IMP_core.new_UnorderedTypeQuadPredicate(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self, m, pis):
        """do_get_inputs(UnorderedTypeQuadPredicate self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.UnorderedTypeQuadPredicate_do_get_inputs(self, m, pis)


    def get_value(self, *args):
        """
        get_value(UnorderedTypeQuadPredicate self, IMP::ParticleQuad const & a) -> int
        get_value(UnorderedTypeQuadPredicate self, IMP::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::ParticleIndexQuad const & pi) -> int
        get_value_index(UnorderedTypeQuadPredicate self, Model m, IMP::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)


    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.QuadPredicate):
    """Proxy of C++ IMP::core::OrderedTypeQuadPredicate class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::OrderedTypeQuadPredicate self, std::string name) -> OrderedTypeQuadPredicate
        __init__(IMP::core::OrderedTypeQuadPredicate self) -> OrderedTypeQuadPredicate
        """
        this = _IMP_core.new_OrderedTypeQuadPredicate(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self, m, pis):
        """do_get_inputs(OrderedTypeQuadPredicate self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.OrderedTypeQuadPredicate_do_get_inputs(self, m, pis)


    def get_value(self, *args):
        """
        get_value(OrderedTypeQuadPredicate self, IMP::core::ParticleTypes const & types) -> int
        get_value(OrderedTypeQuadPredicate self, IMP::ParticleQuad const & a) -> int
        get_value(OrderedTypeQuadPredicate self, IMP::ParticleQuadsTemp const & o) -> IMP::Ints
        """
        return _IMP_core.OrderedTypeQuadPredicate_get_value(self, *args)


    def get_value_index(self, *args):
        """
        get_value_index(OrderedTypeQuadPredicate self, Model m, IMP::ParticleIndexQuad const & pi) -> int
        get_value_index(OrderedTypeQuadPredicate self, Model m, IMP::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)


    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.QuadPredicate):
    """Proxy of C++ IMP::core::AllSameQuadPredicate class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::AllSameQuadPredicate self, std::string name) -> AllSameQuadPredicate
        __init__(IMP::core::AllSameQuadPredicate self) -> AllSameQuadPredicate
        """
        this = _IMP_core.new_AllSameQuadPredicate(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self, arg2, arg3):
        """do_get_inputs(AllSameQuadPredicate self, Model arg2, IMP::ParticleIndexes const & arg3) -> IMP::ModelObjectsTemp"""
        return _IMP_core.AllSameQuadPredicate_do_get_inputs(self, arg2, arg3)


    def get_value(self, *args):
        """
        get_value(AllSameQuadPredicate self, IMP::ParticleQuad const & a) -> int
        get_value(AllSameQuadPredicate self, IMP::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::ParticleIndexQuad const & pi) -> int
        get_value_index(AllSameQuadPredicate self, Model m, IMP::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)


    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.QuadPredicate):
    """Proxy of C++ IMP::core::CoinFlipQuadPredicate class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::CoinFlipQuadPredicate self, double p, std::string name) -> 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 do_get_inputs(self, arg2, arg3):
        """do_get_inputs(CoinFlipQuadPredicate self, Model arg2, IMP::ParticleIndexes const & arg3) -> IMP::ModelObjectsTemp"""
        return _IMP_core.CoinFlipQuadPredicate_do_get_inputs(self, arg2, arg3)


    def get_value(self, *args):
        """
        get_value(CoinFlipQuadPredicate self, IMP::ParticleQuad const & a) -> int
        get_value(CoinFlipQuadPredicate self, IMP::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 arg2, IMP::ParticleIndexQuad const & arg3) -> int
        get_value_index(CoinFlipQuadPredicate self, Model m, IMP::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)


    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 InBoundingBox3DSingletonPredicate(IMP.SingletonPredicate):
    """Proxy of C++ IMP::core::InBoundingBox3DSingletonPredicate class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::InBoundingBox3DSingletonPredicate self, BoundingBox3D bb, std::string name) -> InBoundingBox3DSingletonPredicate
        __init__(IMP::core::InBoundingBox3DSingletonPredicate self, BoundingBox3D bb) -> InBoundingBox3DSingletonPredicate
        """
        this = _IMP_core.new_InBoundingBox3DSingletonPredicate(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self, m, pi):
        """do_get_inputs(InBoundingBox3DSingletonPredicate self, Model m, IMP::ParticleIndexes const & pi) -> IMP::ModelObjectsTemp"""
        return _IMP_core.InBoundingBox3DSingletonPredicate_do_get_inputs(self, m, pi)


    def get_value(self, *args):
        """
        get_value(InBoundingBox3DSingletonPredicate self, Particle a) -> int
        get_value(InBoundingBox3DSingletonPredicate self, IMP::ParticlesTemp const & o) -> IMP::Ints
        """
        return _IMP_core.InBoundingBox3DSingletonPredicate_get_value(self, *args)


    def get_value_index(self, *args):
        """
        get_value_index(InBoundingBox3DSingletonPredicate self, Model m, ParticleIndex pi) -> int
        get_value_index(InBoundingBox3DSingletonPredicate self, Model m, IMP::ParticleIndexes const & o) -> IMP::Ints
        """
        return _IMP_core.InBoundingBox3DSingletonPredicate_get_value_index(self, *args)


    def get_version_info(self):
        """get_version_info(InBoundingBox3DSingletonPredicate self) -> VersionInfo"""
        return _IMP_core.InBoundingBox3DSingletonPredicate_get_version_info(self)


    def __str__(self):
        """__str__(InBoundingBox3DSingletonPredicate self) -> std::string"""
        return _IMP_core.InBoundingBox3DSingletonPredicate___str__(self)


    def __repr__(self):
        """__repr__(InBoundingBox3DSingletonPredicate self) -> std::string"""
        return _IMP_core.InBoundingBox3DSingletonPredicate___repr__(self)

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

InBoundingBox3DSingletonPredicate_swigregister = _IMP_core.InBoundingBox3DSingletonPredicate_swigregister
InBoundingBox3DSingletonPredicate_swigregister(InBoundingBox3DSingletonPredicate)

class AttributeSingletonPredicate(IMP.SingletonPredicate):
    """Proxy of C++ IMP::core::AttributeSingletonPredicate class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::AttributeSingletonPredicate self, IntKey bb, std::string name) -> AttributeSingletonPredicate
        __init__(IMP::core::AttributeSingletonPredicate self, IntKey bb) -> AttributeSingletonPredicate
        """
        this = _IMP_core.new_AttributeSingletonPredicate(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self, m, pi):
        """do_get_inputs(AttributeSingletonPredicate self, Model m, IMP::ParticleIndexes const & pi) -> IMP::ModelObjectsTemp"""
        return _IMP_core.AttributeSingletonPredicate_do_get_inputs(self, m, pi)


    def get_value(self, *args):
        """
        get_value(AttributeSingletonPredicate self, Particle a) -> int
        get_value(AttributeSingletonPredicate self, IMP::ParticlesTemp const & o) -> IMP::Ints
        """
        return _IMP_core.AttributeSingletonPredicate_get_value(self, *args)


    def get_value_index(self, *args):
        """
        get_value_index(AttributeSingletonPredicate self, Model m, ParticleIndex pi) -> int
        get_value_index(AttributeSingletonPredicate self, Model m, IMP::ParticleIndexes const & o) -> IMP::Ints
        """
        return _IMP_core.AttributeSingletonPredicate_get_value_index(self, *args)


    def get_version_info(self):
        """get_version_info(AttributeSingletonPredicate self) -> VersionInfo"""
        return _IMP_core.AttributeSingletonPredicate_get_version_info(self)


    def __str__(self):
        """__str__(AttributeSingletonPredicate self) -> std::string"""
        return _IMP_core.AttributeSingletonPredicate___str__(self)


    def __repr__(self):
        """__repr__(AttributeSingletonPredicate self) -> std::string"""
        return _IMP_core.AttributeSingletonPredicate___repr__(self)

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

AttributeSingletonPredicate_swigregister = _IMP_core.AttributeSingletonPredicate_swigregister
AttributeSingletonPredicate_swigregister(AttributeSingletonPredicate)

class IsCollisionPairPredicate(IMP.PairPredicate):
    """Proxy of C++ IMP::core::IsCollisionPairPredicate class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::IsCollisionPairPredicate self, std::string name) -> IsCollisionPairPredicate
        __init__(IMP::core::IsCollisionPairPredicate self) -> IsCollisionPairPredicate
        """
        this = _IMP_core.new_IsCollisionPairPredicate(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self, m, pi):
        """do_get_inputs(IsCollisionPairPredicate self, Model m, IMP::ParticleIndexes const & pi) -> IMP::ModelObjectsTemp"""
        return _IMP_core.IsCollisionPairPredicate_do_get_inputs(self, m, pi)


    def get_value(self, *args):
        """
        get_value(IsCollisionPairPredicate self, IMP::ParticlePair const & a) -> int
        get_value(IsCollisionPairPredicate self, IMP::ParticlePairsTemp const & o) -> IMP::Ints
        """
        return _IMP_core.IsCollisionPairPredicate_get_value(self, *args)


    def get_value_index(self, *args):
        """
        get_value_index(IsCollisionPairPredicate self, Model m, IMP::ParticleIndexPair const & pi) -> int
        get_value_index(IsCollisionPairPredicate self, Model m, IMP::ParticleIndexPairs const & o) -> IMP::Ints
        """
        return _IMP_core.IsCollisionPairPredicate_get_value_index(self, *args)


    def get_version_info(self):
        """get_version_info(IsCollisionPairPredicate self) -> VersionInfo"""
        return _IMP_core.IsCollisionPairPredicate_get_version_info(self)


    def __str__(self):
        """__str__(IsCollisionPairPredicate self) -> std::string"""
        return _IMP_core.IsCollisionPairPredicate___str__(self)


    def __repr__(self):
        """__repr__(IsCollisionPairPredicate self) -> std::string"""
        return _IMP_core.IsCollisionPairPredicate___repr__(self)

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

IsCollisionPairPredicate_swigregister = _IMP_core.IsCollisionPairPredicate_swigregister
IsCollisionPairPredicate_swigregister(IsCollisionPairPredicate)

class AngleRestraint(TripletRestraint):
    """Proxy of C++ IMP::core::AngleRestraint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::AngleRestraint self, Model m, UnaryFunction score_func, _ParticleIndexAdaptor p1, _ParticleIndexAdaptor p2, _ParticleIndexAdaptor p3) -> AngleRestraint
        __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 __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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::RigidBodyMover self, Model m, 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, mt):
        """set_maximum_translation(RigidBodyMover self, IMP::Float mt)"""
        return _IMP_core.RigidBodyMover_set_maximum_translation(self, mt)


    def set_maximum_rotation(self, mr):
        """set_maximum_rotation(RigidBodyMover self, IMP::Float mr)"""
        return _IMP_core.RigidBodyMover_set_maximum_rotation(self, mr)


    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)


    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 RigidBodyTunneler(MonteCarloMover):
    """Proxy of C++ IMP::core::RigidBodyTunneler class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, m, pis, ref, k, move_probability=1.):
        """
        __init__(IMP::core::RigidBodyTunneler self, Model m, IMP::ParticleIndexes pis, ParticleIndex ref, double k, double move_probability=1.) -> RigidBodyTunneler
        __init__(IMP::core::RigidBodyTunneler self, Model m, IMP::ParticleIndexes pis, ParticleIndex ref, double k) -> RigidBodyTunneler
        """
        this = _IMP_core.new_RigidBodyTunneler(m, pis, ref, k, move_probability)
        try:
            self.this.append(this)
        except:
            self.this = this

    def add_entry_point(self, fl):
        """add_entry_point(RigidBodyTunneler self, IMP::Floats fl)"""
        return _IMP_core.RigidBodyTunneler_add_entry_point(self, fl)


    def reset_stats(self):
        """reset_stats(RigidBodyTunneler self)"""
        return _IMP_core.RigidBodyTunneler_reset_stats(self)


    def get_number_of_rejected_moves(self):
        """get_number_of_rejected_moves(RigidBodyTunneler self) -> unsigned int"""
        return _IMP_core.RigidBodyTunneler_get_number_of_rejected_moves(self)


    def get_number_of_proposed_moves(self):
        """get_number_of_proposed_moves(RigidBodyTunneler self) -> unsigned int"""
        return _IMP_core.RigidBodyTunneler_get_number_of_proposed_moves(self)


    def get_number_of_impossible_moves(self):
        """get_number_of_impossible_moves(RigidBodyTunneler self) -> unsigned int"""
        return _IMP_core.RigidBodyTunneler_get_number_of_impossible_moves(self)


    def get_number_of_calls(self):
        """get_number_of_calls(RigidBodyTunneler self) -> unsigned int"""
        return _IMP_core.RigidBodyTunneler_get_number_of_calls(self)


    def get_reduced_coordinates(*args):
        """
        get_reduced_coordinates(Model m, ParticleIndex target, ParticleIndex ref) -> IMP::Floats
        get_reduced_coordinates(Model m, ParticleIndex pi) -> IMP::Floats
        """
        return _IMP_core.RigidBodyTunneler_get_reduced_coordinates(*args)

    get_reduced_coordinates = staticmethod(get_reduced_coordinates)

    def set_reduced_coordinates(m, target, ref, coords):
        """set_reduced_coordinates(Model m, ParticleIndex target, ParticleIndex ref, IMP::Floats coords)"""
        return _IMP_core.RigidBodyTunneler_set_reduced_coordinates(m, target, ref, coords)

    set_reduced_coordinates = staticmethod(set_reduced_coordinates)

    def get_version_info(self):
        """get_version_info(RigidBodyTunneler self) -> VersionInfo"""
        return _IMP_core.RigidBodyTunneler_get_version_info(self)


    def __str__(self):
        """__str__(RigidBodyTunneler self) -> std::string"""
        return _IMP_core.RigidBodyTunneler___str__(self)


    def __repr__(self):
        """__repr__(RigidBodyTunneler self) -> std::string"""
        return _IMP_core.RigidBodyTunneler___repr__(self)

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

RigidBodyTunneler_swigregister = _IMP_core.RigidBodyTunneler_swigregister
RigidBodyTunneler_swigregister(RigidBodyTunneler)

def RigidBodyTunneler_get_reduced_coordinates(*args):
    """
    get_reduced_coordinates(Model m, ParticleIndex target, ParticleIndex ref) -> IMP::Floats
    RigidBodyTunneler_get_reduced_coordinates(Model m, ParticleIndex pi) -> IMP::Floats
    """
    return _IMP_core.RigidBodyTunneler_get_reduced_coordinates(*args)

def RigidBodyTunneler_set_reduced_coordinates(m, target, ref, coords):
    """RigidBodyTunneler_set_reduced_coordinates(Model m, ParticleIndex target, ParticleIndex ref, IMP::Floats coords)"""
    return _IMP_core.RigidBodyTunneler_set_reduced_coordinates(m, target, ref, coords)

class RigidBodyUmbrella(IMP.Restraint):
    """Proxy of C++ IMP::core::RigidBodyUmbrella class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::core::RigidBodyUmbrella self, Model m, ParticleIndex pi, ParticleIndex ref, IMP::Floats x0, double alpha, double k, std::string name) -> RigidBodyUmbrella
        __init__(IMP::core::RigidBodyUmbrella self, Model m, ParticleIndex pi, ParticleIndex ref, IMP::Floats x0, double alpha, double k) -> RigidBodyUmbrella
        __init__(IMP::core::RigidBodyUmbrella self, Model m, ParticleIndex pi, ParticleIndex ref, double arg5, IMP::Floats x1, IMP::Floats x2, double alpha, double k, std::string name) -> RigidBodyUmbrella
        __init__(IMP::core::RigidBodyUmbrella self, Model m, ParticleIndex pi, ParticleIndex ref, double arg5, IMP::Floats x1, IMP::Floats x2, double alpha, double k) -> RigidBodyUmbrella
        """
        this = _IMP_core.new_RigidBodyUmbrella(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def set_x0(self, *args):
        """
        set_x0(RigidBodyUmbrella self, IMP::Floats x0)
        set_x0(RigidBodyUmbrella self, double arg2, IMP::Floats x1, IMP::Floats x2)
        """
        return _IMP_core.RigidBodyUmbrella_set_x0(self, *args)


    def get_x0(self):
        """get_x0(RigidBodyUmbrella self) -> IMP::Floats"""
        return _IMP_core.RigidBodyUmbrella_get_x0(self)


    def get_x(self):
        """get_x(RigidBodyUmbrella self) -> IMP::Floats"""
        return _IMP_core.RigidBodyUmbrella_get_x(self)


    def set_alpha(self, alpha):
        """set_alpha(RigidBodyUmbrella self, double alpha)"""
        return _IMP_core.RigidBodyUmbrella_set_alpha(self, alpha)


    def set_k(self, k):
        """set_k(RigidBodyUmbrella self, double k)"""
        return _IMP_core.RigidBodyUmbrella_set_k(self, k)


    def get_version_info(self):
        """get_version_info(RigidBodyUmbrella self) -> VersionInfo"""
        return _IMP_core.RigidBodyUmbrella_get_version_info(self)


    def __str__(self):
        """__str__(RigidBodyUmbrella self) -> std::string"""
        return _IMP_core.RigidBodyUmbrella___str__(self)


    def __repr__(self):
        """__repr__(RigidBodyUmbrella self) -> std::string"""
        return _IMP_core.RigidBodyUmbrella___repr__(self)

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

RigidBodyUmbrella_swigregister = _IMP_core.RigidBodyUmbrella_swigregister
RigidBodyUmbrella_swigregister(RigidBodyUmbrella)

class VolumeRestraint(IMP.Restraint):
    """Proxy of C++ IMP::core::VolumeRestraint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, f, sc, volume):
        """__init__(IMP::core::VolumeRestraint self, UnaryFunction f, SingletonContainer sc, double volume) -> VolumeRestraint"""
        this = _IMP_core.new_VolumeRestraint(f, sc, volume)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self):
        """do_get_inputs(VolumeRestraint self) -> IMP::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 __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(ps):
    """get_centroid(IMP::core::XYZs const & ps) -> Vector3D"""
    return _IMP_core.get_centroid(ps)

def get_bounding_box(ps):
    """get_bounding_box(IMP::core::XYZRs const & ps) -> BoundingBox3D"""
    return _IMP_core.get_bounding_box(ps)
class MoveStatisticsScoreState(IMP.ScoreState):
    """Proxy of C++ IMP::core::MoveStatisticsScoreState class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, ps):
        """__init__(IMP::core::MoveStatisticsScoreState self, IMP::ParticlesTemp const & ps) -> MoveStatisticsScoreState"""
        this = _IMP_core.new_MoveStatisticsScoreState(ps)
        try:
            self.this.append(this)
        except:
            self.this = this

    def show_statistics(self, *args):
        """
        show_statistics(MoveStatisticsScoreState self, _ostream out)
        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 do_before_evaluate(self):
        """do_before_evaluate(MoveStatisticsScoreState self)"""
        return _IMP_core.MoveStatisticsScoreState_do_before_evaluate(self)


    def do_after_evaluate(self, da):
        """do_after_evaluate(MoveStatisticsScoreState self, DerivativeAccumulator da)"""
        return _IMP_core.MoveStatisticsScoreState_do_after_evaluate(self, da)


    def do_get_inputs(self):
        """do_get_inputs(MoveStatisticsScoreState self) -> IMP::ModelObjectsTemp"""
        return _IMP_core.MoveStatisticsScoreState_do_get_inputs(self)


    def do_get_outputs(self):
        """do_get_outputs(MoveStatisticsScoreState self) -> IMP::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 __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_core.IMP_PARTICLE_TYPE_INDEX_swigconstant(_IMP_core)
IMP_PARTICLE_TYPE_INDEX = _IMP_core.IMP_PARTICLE_TYPE_INDEX
class Typed(IMP.Decorator):
    """Proxy of C++ IMP::core::Typed class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def get_type_key():
        """get_type_key() -> IntKey"""
        return _IMP_core.Typed_get_type_key()

    get_type_key = staticmethod(get_type_key)

    def __init__(self, *args):
        """
        __init__(IMP::core::Typed self) -> Typed
        __init__(IMP::core::Typed self, Model m, ParticleIndex id) -> Typed
        __init__(IMP::core::Typed self, _ParticleAdaptor d) -> Typed
        """
        this = _IMP_core.new_Typed(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def show(self, *args):
        """
        show(Typed self, _ostream out)
        show(Typed self)
        """
        return _IMP_core.Typed_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi, ParticleType t) -> Typed
        setup_particle(_ParticleAdaptor decorator, ParticleType t) -> Typed
        """
        return _IMP_core.Typed_setup_particle(*args)

    setup_particle = staticmethod(setup_particle)

    def get_is_setup(*args):
        """
        get_is_setup(_ParticleAdaptor p) -> bool
        get_is_setup(Model m, ParticleIndex pi) -> bool
        """
        return _IMP_core.Typed_get_is_setup(*args)

    get_is_setup = staticmethod(get_is_setup)

    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, 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) -> 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, 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, a0):
        """get_derivative(Typed self, FloatKey a0) -> double"""
        return _IMP_core.Typed_get_derivative(self, a0)


    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, a0):
        """set_name(Typed self, std::string a0)"""
        return _IMP_core.Typed_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(Typed self, IMP::CheckLevel a0)"""
        return _IMP_core.Typed_set_check_level(self, a0)


    def add_to_derivative(self, a0, a1, a2):
        """add_to_derivative(Typed self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_core.Typed_add_to_derivative(self, a0, a1, a2)


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(Typed self, FloatKey a0, bool a1)"""
        return _IMP_core.Typed_set_is_optimized(self, a0, a1)


    def get_is_optimized(self, a0):
        """get_is_optimized(Typed self, FloatKey a0) -> bool"""
        return _IMP_core.Typed_get_is_optimized(self, a0)


    def get_check_level(self):
        """get_check_level(Typed self) -> IMP::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 __hash__(self):
        """__hash__(Typed self) -> std::size_t"""
        return _IMP_core.Typed___hash__(self)


    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_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi, ParticleType t) -> Typed
    Typed_setup_particle(_ParticleAdaptor decorator, ParticleType t) -> Typed
    """
    return _IMP_core.Typed_setup_particle(*args)

def Typed_get_is_setup(*args):
    """
    get_is_setup(_ParticleAdaptor p) -> bool
    Typed_get_is_setup(Model m, ParticleIndex pi) -> bool
    """
    return _IMP_core.Typed_get_is_setup(*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, Gaussian n) -> _ostream
    __lshift__(_ostream out, Typed n) -> _ostream
    """
    return _IMP_core.__lshift__(*args)
class WriteRestraintScoresOptimizerState(IMP.OptimizerState):
    """Proxy of C++ IMP::core::WriteRestraintScoresOptimizerState class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, rs, out):
        """__init__(IMP::core::WriteRestraintScoresOptimizerState self, IMP::Restraints const & rs, TextOutput out) -> WriteRestraintScoresOptimizerState"""
        this = _IMP_core.new_WriteRestraintScoresOptimizerState(rs, out)
        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)


    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(rs, ps, attribute):
    """assign_blame(IMP::RestraintsTemp const & rs, IMP::ParticlesTemp const & ps, FloatKey attribute)"""
    return _IMP_core.assign_blame(rs, ps, attribute)

def create_blame_geometries(*args):
    """
    create_blame_geometries(IMP::RestraintsTemp const & rs, IMP::ParticlesTemp const & ps, double max, std::string name) -> IMP::display::Geometries
    create_blame_geometries(IMP::RestraintsTemp const & rs, IMP::ParticlesTemp const & ps, double max) -> IMP::display::Geometries
    create_blame_geometries(IMP::RestraintsTemp const & rs, IMP::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::ParticlesTemp const & a, IMP::ParticlesTemp const & b) -> Transformation3D
    get_transformation_aligning_first_to_second(IMP::ParticlesTemp const & a, IMP::Vector< IMP::algebra::VectorD< 3 > > const & b) -> Transformation3D
    get_transformation_aligning_first_to_second(IMP::Vector< IMP::algebra::VectorD< 3 > > const & a, IMP::ParticlesTemp const & b) -> Transformation3D
    """
    return _IMP_core.get_transformation_aligning_first_to_second(*args)

def create_restraint(ps, pp):
    """create_restraint(PairScore ps, IMP::ParticlePair pp) -> Restraint"""
    return _IMP_core.create_restraint(ps, pp)
class TruncatedHarmonicLowerBound(IMP.UnaryFunction):
    """Proxy of C++ IMP::core::TruncatedHarmonic<(IMP::core::LOWER)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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)


    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.UnaryFunction):
    """Proxy of C++ IMP::core::TruncatedHarmonic<(IMP::core::UPPER)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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)


    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.UnaryFunction):
    """Proxy of C++ IMP::core::TruncatedHarmonic<(IMP::core::BOTH)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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)


    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._Value):
    """Proxy of C++ IMP::Key<(34897493,true)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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(sc):
        """add_key(std::string sc) -> unsigned int"""
        return _IMP_core.ParticleType_add_key(sc)

    add_key = staticmethod(add_key)

    def get_key_exists(sc):
        """get_key_exists(std::string sc) -> bool"""
        return _IMP_core.ParticleType_get_key_exists(sc)

    get_key_exists = staticmethod(get_key_exists)

    def get_string(self):
        """get_string(ParticleType self) -> std::string const"""
        return _IMP_core.ParticleType_get_string(self)


    def __cmp__(self, o):
        """__cmp__(ParticleType self, ParticleType o) -> int"""
        return _IMP_core.ParticleType___cmp__(self, o)


    def __eq__(self, o):
        """__eq__(ParticleType self, ParticleType o) -> bool"""
        return _IMP_core.ParticleType___eq__(self, o)


    def __ne__(self, o):
        """__ne__(ParticleType self, ParticleType o) -> bool"""
        return _IMP_core.ParticleType___ne__(self, o)


    def __lt__(self, o):
        """__lt__(ParticleType self, ParticleType o) -> bool"""
        return _IMP_core.ParticleType___lt__(self, o)


    def __gt__(self, o):
        """__gt__(ParticleType self, ParticleType o) -> bool"""
        return _IMP_core.ParticleType___gt__(self, o)


    def __ge__(self, o):
        """__ge__(ParticleType self, ParticleType o) -> bool"""
        return _IMP_core.ParticleType___ge__(self, o)


    def __le__(self, o):
        """__le__(ParticleType self, ParticleType o) -> bool"""
        return _IMP_core.ParticleType___le__(self, o)


    def __hash__(self):
        """__hash__(ParticleType self) -> std::size_t"""
        return _IMP_core.ParticleType___hash__(self)


    def show(self, *args):
        """
        show(ParticleType self, _ostream out)
        show(ParticleType self)
        """
        return _IMP_core.ParticleType_show(self, *args)


    def add_alias(old_key, new_name):
        """add_alias(ParticleType old_key, std::string new_name) -> ParticleType"""
        return _IMP_core.ParticleType_add_alias(old_key, new_name)

    add_alias = staticmethod(add_alias)

    def get_index(self):
        """get_index(ParticleType self) -> unsigned int"""
        return _IMP_core.ParticleType_get_index(self)


    def show_all(out):
        """show_all(_ostream out)"""
        return _IMP_core.ParticleType_show_all(out)

    show_all = staticmethod(show_all)

    def get_all_strings():
        """get_all_strings() -> IMP::Vector< std::string >"""
        return _IMP_core.ParticleType_get_all_strings()

    get_all_strings = staticmethod(get_all_strings)

    def get_number_unique():
        """get_number_unique() -> unsigned int"""
        return _IMP_core.ParticleType_get_number_unique()

    get_number_unique = staticmethod(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(sc):
    """ParticleType_add_key(std::string sc) -> unsigned int"""
    return _IMP_core.ParticleType_add_key(sc)

def ParticleType_get_key_exists(sc):
    """ParticleType_get_key_exists(std::string sc) -> bool"""
    return _IMP_core.ParticleType_get_key_exists(sc)

def ParticleType_add_alias(old_key, new_name):
    """ParticleType_add_alias(ParticleType old_key, std::string new_name) -> ParticleType"""
    return _IMP_core.ParticleType_add_alias(old_key, new_name)

def ParticleType_show_all(out):
    """ParticleType_show_all(_ostream out)"""
    return _IMP_core.ParticleType_show_all(out)

def ParticleType_get_all_strings():
    """ParticleType_get_all_strings() -> IMP::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.SingletonScore):
    """Proxy of C++ IMP::core::GenericAttributeSingletonScore<(UnaryFunction)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, f, k):
        """__init__(IMP::core::GenericAttributeSingletonScore<(UnaryFunction)> self, UnaryFunction f, FloatKey k) -> AttributeSingletonScore"""
        this = _IMP_core.new_AttributeSingletonScore(f, k)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self, m, pis):
        """do_get_inputs(AttributeSingletonScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.AttributeSingletonScore_do_get_inputs(self, m, pis)


    def get_version_info(self):
        """get_version_info(AttributeSingletonScore self) -> VersionInfo"""
        return _IMP_core.AttributeSingletonScore_get_version_info(self)

AttributeSingletonScore_swigregister = _IMP_core.AttributeSingletonScore_swigregister
AttributeSingletonScore_swigregister(AttributeSingletonScore)


def create_attribute_singleton_score(uf, k):
    """create_attribute_singleton_score(UnaryFunction uf, FloatKey k) -> AttributeSingletonScore"""
    return _IMP_core.create_attribute_singleton_score(uf, k)
class BoundingBox3DSingletonScore(IMP.SingletonScore):
    """Proxy of C++ IMP::core::GenericBoundingBox3DSingletonScore<(UnaryFunction)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, f, bb):
        """__init__(IMP::core::GenericBoundingBox3DSingletonScore<(UnaryFunction)> self, UnaryFunction f, BoundingBox3D bb) -> BoundingBox3DSingletonScore"""
        this = _IMP_core.new_BoundingBox3DSingletonScore(f, bb)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self, m, pis):
        """do_get_inputs(BoundingBox3DSingletonScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.BoundingBox3DSingletonScore_do_get_inputs(self, m, pis)


    def get_version_info(self):
        """get_version_info(BoundingBox3DSingletonScore self) -> VersionInfo"""
        return _IMP_core.BoundingBox3DSingletonScore_get_version_info(self)

BoundingBox3DSingletonScore_swigregister = _IMP_core.BoundingBox3DSingletonScore_swigregister
BoundingBox3DSingletonScore_swigregister(BoundingBox3DSingletonScore)


def create_bounding_box_3d_singleton_score(f, bb):
    """create_bounding_box_3d_singleton_score(UnaryFunction f, BoundingBox3D bb) -> BoundingBox3DSingletonScore"""
    return _IMP_core.create_bounding_box_3d_singleton_score(f, bb)
class DistanceToSingletonScore(IMP.SingletonScore):
    """Proxy of C++ IMP::core::GenericDistanceToSingletonScore<(UnaryFunction)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, f, pt):
        """__init__(IMP::core::GenericDistanceToSingletonScore<(UnaryFunction)> self, UnaryFunction f, Vector3D pt) -> DistanceToSingletonScore"""
        this = _IMP_core.new_DistanceToSingletonScore(f, pt)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self, m, pis):
        """do_get_inputs(DistanceToSingletonScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.DistanceToSingletonScore_do_get_inputs(self, m, pis)


    def get_version_info(self):
        """get_version_info(DistanceToSingletonScore self) -> VersionInfo"""
        return _IMP_core.DistanceToSingletonScore_get_version_info(self)

DistanceToSingletonScore_swigregister = _IMP_core.DistanceToSingletonScore_swigregister
DistanceToSingletonScore_swigregister(DistanceToSingletonScore)


def create_distance_to_singleton_score(f, pt):
    """create_distance_to_singleton_score(UnaryFunction f, Vector3D pt) -> DistanceToSingletonScore"""
    return _IMP_core.create_distance_to_singleton_score(f, pt)

def get_module_version():
    """get_module_version() -> std::string const"""
    return _IMP_core.get_module_version()

def get_example_path(fname):
    """get_example_path(std::string fname) -> std::string"""
    return _IMP_core.get_example_path(fname)

def get_data_path(fname):
    """get_data_path(std::string fname) -> std::string"""
    return _IMP_core.get_data_path(fname)
from . import _version_check
_version_check.check_version(get_module_version())
__version__ = get_module_version()