core/__init__.py

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.7
#
# 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-2021 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_COMPILER_HAS_UNIQUE_PTR_swigconstant(_IMP_core)
IMP_COMPILER_HAS_UNIQUE_PTR = _IMP_core.IMP_COMPILER_HAS_UNIQUE_PTR

_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_NUMPY_swigconstant(_IMP_core)
IMP_KERNEL_HAS_NUMPY = _IMP_core.IMP_KERNEL_HAS_NUMPY

_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

_IMP_core.IMP_C_OPEN_BINARY_swigconstant(_IMP_core)
IMP_C_OPEN_BINARY = _IMP_core.IMP_C_OPEN_BINARY
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.IMP_CGAL_HAS_NUMPY_swigconstant(_IMP_core)
IMP_CGAL_HAS_NUMPY = _IMP_core.IMP_CGAL_HAS_NUMPY

_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_NUMPY_swigconstant(_IMP_core)
IMP_ALGEBRA_HAS_NUMPY = _IMP_core.IMP_ALGEBRA_HAS_NUMPY

_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.IMP_DISPLAY_HAS_NUMPY_swigconstant(_IMP_core)
IMP_DISPLAY_HAS_NUMPY = _IMP_core.IMP_DISPLAY_HAS_NUMPY

_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.IMP_SCORE_FUNCTOR_HAS_NUMPY_swigconstant(_IMP_core)
IMP_SCORE_FUNCTOR_HAS_NUMPY = _IMP_core.IMP_SCORE_FUNCTOR_HAS_NUMPY

_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.IMP_CORE_HAS_NUMPY_swigconstant(_IMP_core)
IMP_CORE_HAS_NUMPY = _IMP_core.IMP_CORE_HAS_NUMPY

_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("SubsetMover")


def _object_cast_to_SubsetMover(o):
    """_object_cast_to_SubsetMover(Object o) -> SubsetMover"""
    return _IMP_core._object_cast_to_SubsetMover(o)

_object_types.append("DirectionMover")


def _object_cast_to_DirectionMover(o):
    """_object_cast_to_DirectionMover(Object o) -> DirectionMover"""
    return _IMP_core._object_cast_to_DirectionMover(o)

_object_types.append("SurfaceMover")


def _object_cast_to_SurfaceMover(o):
    """_object_cast_to_SurfaceMover(Object o) -> SurfaceMover"""
    return _IMP_core._object_cast_to_SurfaceMover(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("BoundingSphere3DSingletonScore")


def _object_cast_to_BoundingSphere3DSingletonScore(o):
    """_object_cast_to_BoundingSphere3DSingletonScore(Object o) -> BoundingSphere3DSingletonScore"""
    return _IMP_core._object_cast_to_BoundingSphere3DSingletonScore(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("HarmonicSurfaceDistancePairScore")


def _object_cast_to_HarmonicSurfaceDistancePairScore(o):
    """_object_cast_to_HarmonicSurfaceDistancePairScore(Object o) -> HarmonicSurfaceDistancePairScore"""
    return _IMP_core._object_cast_to_HarmonicSurfaceDistancePairScore(o)

_object_types.append("HarmonicSurfaceHeightPairScore")


def _object_cast_to_HarmonicSurfaceHeightPairScore(o):
    """_object_cast_to_HarmonicSurfaceHeightPairScore(Object o) -> HarmonicSurfaceHeightPairScore"""
    return _IMP_core._object_cast_to_HarmonicSurfaceHeightPairScore(o)

_object_types.append("HarmonicSurfaceDepthPairScore")


def _object_cast_to_HarmonicSurfaceDepthPairScore(o):
    """_object_cast_to_HarmonicSurfaceDepthPairScore(Object o) -> HarmonicSurfaceDepthPairScore"""
    return _IMP_core._object_cast_to_HarmonicSurfaceDepthPairScore(o)

_object_types.append("WeightedSum")


def _object_cast_to_WeightedSum(o):
    """_object_cast_to_WeightedSum(Object o) -> WeightedSum"""
    return _IMP_core._object_cast_to_WeightedSum(o)

_object_types.append("WeightedSumOfExponential")


def _object_cast_to_WeightedSumOfExponential(o):
    """_object_cast_to_WeightedSumOfExponential(Object o) -> WeightedSumOfExponential"""
    return _IMP_core._object_cast_to_WeightedSumOfExponential(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("LogNormalMover")


def _object_cast_to_LogNormalMover(o):
    """_object_cast_to_LogNormalMover(Object o) -> LogNormalMover"""
    return _IMP_core._object_cast_to_LogNormalMover(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("SoftSubSurfacePairScore")


def _object_cast_to_SoftSubSurfacePairScore(o):
    """_object_cast_to_SoftSubSurfacePairScore(Object o) -> SoftSubSurfacePairScore"""
    return _IMP_core._object_cast_to_SoftSubSurfacePairScore(o)

_object_types.append("SoftSuperSurfacePairScore")


def _object_cast_to_SoftSuperSurfacePairScore(o):
    """_object_cast_to_SoftSuperSurfacePairScore(Object o) -> SoftSuperSurfacePairScore"""
    return _IMP_core._object_cast_to_SoftSuperSurfacePairScore(o)

_object_types.append("SurfaceDistancePairScore")


def _object_cast_to_SurfaceDistancePairScore(o):
    """_object_cast_to_SurfaceDistancePairScore(Object o) -> SurfaceDistancePairScore"""
    return _IMP_core._object_cast_to_SurfaceDistancePairScore(o)

_object_types.append("SurfaceHeightPairScore")


def _object_cast_to_SurfaceHeightPairScore(o):
    """_object_cast_to_SurfaceHeightPairScore(Object o) -> SurfaceHeightPairScore"""
    return _IMP_core._object_cast_to_SurfaceHeightPairScore(o)

_object_types.append("SurfaceDepthPairScore")


def _object_cast_to_SurfaceDepthPairScore(o):
    """_object_cast_to_SurfaceDepthPairScore(Object o) -> SurfaceDepthPairScore"""
    return _IMP_core._object_cast_to_SurfaceDepthPairScore(o)

_object_types.append("SurfaceTetheredChain")


def _object_cast_to_SurfaceTetheredChain(o):
    """_object_cast_to_SurfaceTetheredChain(Object o) -> SurfaceTetheredChain"""
    return _IMP_core._object_cast_to_SurfaceTetheredChain(o)

_object_types.append("SurfaceSymmetryConstraint")


def _object_cast_to_SurfaceSymmetryConstraint(o):
    """_object_cast_to_SurfaceSymmetryConstraint(Object o) -> SurfaceSymmetryConstraint"""
    return _IMP_core._object_cast_to_SurfaceSymmetryConstraint(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("TransformationSymmetryMover")


def _object_cast_to_TransformationSymmetryMover(o):
    """_object_cast_to_TransformationSymmetryMover(Object o) -> TransformationSymmetryMover"""
    return _IMP_core._object_cast_to_TransformationSymmetryMover(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("LateralSurfaceConstraint")


def _object_cast_to_LateralSurfaceConstraint(o):
    """_object_cast_to_LateralSurfaceConstraint(Object o) -> LateralSurfaceConstraint"""
    return _IMP_core._object_cast_to_LateralSurfaceConstraint(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")


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


_value_types.append("Direction")


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


_value_types.append("DirectionAngle")


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


_value_types.append("Surface")


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


_value_types.append("Provenance")


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


_value_types.append("StructureProvenance")


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


_value_types.append("SampleProvenance")


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


_value_types.append("ClusterProvenance")


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


_value_types.append("CombineProvenance")


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


_value_types.append("FilterProvenance")


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


_value_types.append("ScriptProvenance")


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


_value_types.append("SoftwareProvenance")


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


_value_types.append("Provenanced")


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


def _object_cast_to_SurfaceGeometry(o):
    """_object_cast_to_SurfaceGeometry(Object o) -> SurfaceGeometry"""
    return _IMP_core._object_cast_to_SurfaceGeometry(o)

_object_types.append("SurfaceGeometryConstraint")


def _object_cast_to_SurfaceGeometryConstraint(o):
    """_object_cast_to_SurfaceGeometryConstraint(Object o) -> SurfaceGeometryConstraint"""
    return _IMP_core._object_cast_to_SurfaceGeometryConstraint(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)

BinormalTermList=list
_plural_types.append("BinormalTermList")
_value_types.append("BinormalTerm")


_object_types.append("MultipleBinormalRestraint")


def _object_cast_to_MultipleBinormalRestraint(o):
    """_object_cast_to_MultipleBinormalRestraint(Object o) -> MultipleBinormalRestraint"""
    return _IMP_core._object_cast_to_MultipleBinormalRestraint(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)


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

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_MonteCarloMover(o)


    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())
    @staticmethod
    def get_from(o):
       return _object_cast_to_MonteCarloMover(o)

    __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, FloatsKey a0, IMP::Floats a1)
        add_attribute(XYZ self, IntsKey a0, IMP::Ints 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, FloatsKey a0) -> IMP::Floats
        get_value(XYZ self, IntsKey a0) -> IMP::Ints
        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, FloatsKey a0, IMP::Floats a1)
        set_value(XYZ self, IntsKey a0, IMP::Ints 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, FloatsKey a0)
        remove_attribute(XYZ self, IntsKey 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, FloatsKey a0) -> bool
        has_attribute(XYZ self, IntsKey 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, FloatsKey a0, IMP::Floats a1)
        add_attribute(XYZR self, IntsKey a0, IMP::Ints 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, FloatsKey a0) -> IMP::Floats
        get_value(XYZR self, IntsKey a0) -> IMP::Ints
        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, FloatsKey a0, IMP::Floats a1)
        set_value(XYZR self, IntsKey a0, IMP::Ints 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, FloatsKey a0)
        remove_attribute(XYZR self, IntsKey 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, FloatsKey a0) -> bool
        has_attribute(XYZR self, IntsKey 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 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)


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

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)


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

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)


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

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)


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

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)


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

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)


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

EdgePairsGeometry_swigregister = _IMP_core.EdgePairsGeometry_swigregister
EdgePairsGeometry_swigregister(EdgePairsGeometry)

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

    def do_setup_particle(m, pi, v):
        """do_setup_particle(Model m, ParticleIndex pi, Vector3D v)"""
        return _IMP_core.Direction_do_setup_particle(m, pi, v)

    do_setup_particle = staticmethod(do_setup_particle)

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

    def show(self, *args):
        """
        show(Direction self, _ostream out)
        show(Direction self)
        """
        return _IMP_core.Direction_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi, Vector3D v) -> Direction
        setup_particle(_ParticleAdaptor decorator, Vector3D v) -> Direction
        """
        return _IMP_core.Direction_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.Direction_get_is_setup(*args)

    get_is_setup = staticmethod(get_is_setup)

    def get_direction_key(i):
        """get_direction_key(unsigned int i) -> FloatKey"""
        return _IMP_core.Direction_get_direction_key(i)

    get_direction_key = staticmethod(get_direction_key)

    def get_direction_derivative(self, i):
        """get_direction_derivative(Direction self, int i) -> IMP::Float"""
        return _IMP_core.Direction_get_direction_derivative(self, i)


    def get_direction_derivatives(self):
        """get_direction_derivatives(Direction self) -> Vector3D"""
        return _IMP_core.Direction_get_direction_derivatives(self)


    def add_to_direction_derivative(self, i, v, d):
        """add_to_direction_derivative(Direction self, int i, IMP::Float v, DerivativeAccumulator d)"""
        return _IMP_core.Direction_add_to_direction_derivative(self, i, v, d)


    def add_to_direction_derivatives(self, v, d):
        """add_to_direction_derivatives(Direction self, Vector3D v, DerivativeAccumulator d)"""
        return _IMP_core.Direction_add_to_direction_derivatives(self, v, d)


    def get_direction_is_optimized(self):
        """get_direction_is_optimized(Direction self) -> bool"""
        return _IMP_core.Direction_get_direction_is_optimized(self)


    def set_direction_is_optimized(self, tf):
        """set_direction_is_optimized(Direction self, bool tf)"""
        return _IMP_core.Direction_set_direction_is_optimized(self, tf)


    def get_direction(self):
        """get_direction(Direction self) -> Vector3D"""
        return _IMP_core.Direction_get_direction(self)


    def set_direction(self, v):
        """set_direction(Direction self, Vector3D v)"""
        return _IMP_core.Direction_set_direction(self, v)


    def reflect(self):
        """reflect(Direction self)"""
        return _IMP_core.Direction_reflect(self)


    def add_attribute(self, *args):
        """
        add_attribute(Direction self, FloatKey k, IMP::Float v, bool opt)
        add_attribute(Direction self, FloatKey a0, IMP::Float a1)
        add_attribute(Direction self, IntKey a0, IMP::Int a1)
        add_attribute(Direction self, FloatsKey a0, IMP::Floats a1)
        add_attribute(Direction self, IntsKey a0, IMP::Ints a1)
        add_attribute(Direction self, StringKey a0, IMP::String a1)
        add_attribute(Direction self, ParticleIndexKey a0, Particle a1)
        add_attribute(Direction self, ObjectKey a0, Object a1)
        """
        return _IMP_core.Direction_add_attribute(self, *args)


    def get_value(self, *args):
        """
        get_value(Direction self, FloatKey a0) -> IMP::Float
        get_value(Direction self, IntKey a0) -> IMP::Int
        get_value(Direction self, FloatsKey a0) -> IMP::Floats
        get_value(Direction self, IntsKey a0) -> IMP::Ints
        get_value(Direction self, StringKey a0) -> IMP::String
        get_value(Direction self, ParticleIndexKey a0) -> Particle
        get_value(Direction self, ObjectKey a0) -> Object
        """
        return _IMP_core.Direction_get_value(self, *args)


    def set_value(self, *args):
        """
        set_value(Direction self, FloatKey a0, IMP::Float a1)
        set_value(Direction self, IntKey a0, IMP::Int a1)
        set_value(Direction self, FloatsKey a0, IMP::Floats a1)
        set_value(Direction self, IntsKey a0, IMP::Ints a1)
        set_value(Direction self, StringKey a0, IMP::String a1)
        set_value(Direction self, ParticleIndexKey a0, Particle a1)
        set_value(Direction self, ObjectKey a0, Object a1)
        """
        return _IMP_core.Direction_set_value(self, *args)


    def remove_attribute(self, *args):
        """
        remove_attribute(Direction self, FloatKey a0)
        remove_attribute(Direction self, IntKey a0)
        remove_attribute(Direction self, FloatsKey a0)
        remove_attribute(Direction self, IntsKey a0)
        remove_attribute(Direction self, StringKey a0)
        remove_attribute(Direction self, ParticleIndexKey a0)
        remove_attribute(Direction self, ObjectKey a0)
        """
        return _IMP_core.Direction_remove_attribute(self, *args)


    def has_attribute(self, *args):
        """
        has_attribute(Direction self, FloatKey a0) -> bool
        has_attribute(Direction self, IntKey a0) -> bool
        has_attribute(Direction self, FloatsKey a0) -> bool
        has_attribute(Direction self, IntsKey a0) -> bool
        has_attribute(Direction self, StringKey a0) -> bool
        has_attribute(Direction self, ParticleIndexKey a0) -> bool
        has_attribute(Direction self, ObjectKey a0) -> bool
        """
        return _IMP_core.Direction_has_attribute(self, *args)


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


    def get_name(self):
        """get_name(Direction self) -> std::string"""
        return _IMP_core.Direction_get_name(self)


    def clear_caches(self):
        """clear_caches(Direction self)"""
        return _IMP_core.Direction_clear_caches(self)


    def set_name(self, a0):
        """set_name(Direction self, std::string a0)"""
        return _IMP_core.Direction_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(Direction self, IMP::CheckLevel a0)"""
        return _IMP_core.Direction_set_check_level(self, a0)


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


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(Direction self, FloatKey a0, bool a1)"""
        return _IMP_core.Direction_set_is_optimized(self, a0, a1)


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


    def get_check_level(self):
        """get_check_level(Direction self) -> IMP::CheckLevel"""
        return _IMP_core.Direction_get_check_level(self)


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


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


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


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


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


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


    def __hash__(self):
        """__hash__(Direction self) -> std::size_t"""
        return _IMP_core.Direction___hash__(self)


    def __str__(self):
        """__str__(Direction self) -> std::string"""
        return _IMP_core.Direction___str__(self)


    def __repr__(self):
        """__repr__(Direction self) -> std::string"""
        return _IMP_core.Direction___repr__(self)

    __swig_destroy__ = _IMP_core.delete_Direction
    __del__ = lambda self: None
Direction_swigregister = _IMP_core.Direction_swigregister
Direction_swigregister(Direction)

def Direction_do_setup_particle(m, pi, v):
    """Direction_do_setup_particle(Model m, ParticleIndex pi, Vector3D v)"""
    return _IMP_core.Direction_do_setup_particle(m, pi, v)

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

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

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


def get_angle(a, b):
    """get_angle(Direction a, Direction b) -> double"""
    return _IMP_core.get_angle(a, b)
class DirectionAngle(IMP.Decorator):
    """Proxy of C++ IMP::core::DirectionAngle 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::DirectionAngle self) -> DirectionAngle
        __init__(IMP::core::DirectionAngle self, Model m, ParticleIndex id) -> DirectionAngle
        __init__(IMP::core::DirectionAngle self, _ParticleAdaptor d) -> DirectionAngle
        """
        this = _IMP_core.new_DirectionAngle(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def show(self, *args):
        """
        show(DirectionAngle self, _ostream out)
        show(DirectionAngle self)
        """
        return _IMP_core.DirectionAngle_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi, IMP::ParticleIndexPair ds) -> DirectionAngle
        setup_particle(_ParticleAdaptor decorator, IMP::ParticleIndexPair ds) -> DirectionAngle
        setup_particle(Model m, ParticleIndex pi, _ParticleIndexAdaptor d0, _ParticleIndexAdaptor d1) -> DirectionAngle
        setup_particle(_ParticleAdaptor decorator, _ParticleIndexAdaptor d0, _ParticleIndexAdaptor d1) -> DirectionAngle
        """
        return _IMP_core.DirectionAngle_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.DirectionAngle_get_is_setup(*args)

    get_is_setup = staticmethod(get_is_setup)

    def get_angle_key():
        """get_angle_key() -> FloatKey"""
        return _IMP_core.DirectionAngle_get_angle_key()

    get_angle_key = staticmethod(get_angle_key)

    def get_particle_key(i):
        """get_particle_key(unsigned int i) -> ParticleIndexKey"""
        return _IMP_core.DirectionAngle_get_particle_key(i)

    get_particle_key = staticmethod(get_particle_key)

    def get_particle(self, *args):
        """
        get_particle(DirectionAngle self, unsigned int i) -> Particle
        get_particle(DirectionAngle self) -> Particle
        """
        return _IMP_core.DirectionAngle_get_particle(self, *args)


    def get_particle_index(self, *args):
        """
        get_particle_index(DirectionAngle self, unsigned int i) -> ParticleIndex
        get_particle_index(DirectionAngle self) -> ParticleIndex
        """
        return _IMP_core.DirectionAngle_get_particle_index(self, *args)


    def get_angle(self):
        """get_angle(DirectionAngle self) -> IMP::Float"""
        return _IMP_core.DirectionAngle_get_angle(self)


    def get_angle_derivative(self):
        """get_angle_derivative(DirectionAngle self) -> IMP::Float"""
        return _IMP_core.DirectionAngle_get_angle_derivative(self)


    def add_to_angle_derivative(self, v, d):
        """add_to_angle_derivative(DirectionAngle self, IMP::Float v, DerivativeAccumulator d)"""
        return _IMP_core.DirectionAngle_add_to_angle_derivative(self, v, d)


    def add_attribute(self, *args):
        """
        add_attribute(DirectionAngle self, FloatKey k, IMP::Float v, bool opt)
        add_attribute(DirectionAngle self, FloatKey a0, IMP::Float a1)
        add_attribute(DirectionAngle self, IntKey a0, IMP::Int a1)
        add_attribute(DirectionAngle self, FloatsKey a0, IMP::Floats a1)
        add_attribute(DirectionAngle self, IntsKey a0, IMP::Ints a1)
        add_attribute(DirectionAngle self, StringKey a0, IMP::String a1)
        add_attribute(DirectionAngle self, ParticleIndexKey a0, Particle a1)
        add_attribute(DirectionAngle self, ObjectKey a0, Object a1)
        """
        return _IMP_core.DirectionAngle_add_attribute(self, *args)


    def get_value(self, *args):
        """
        get_value(DirectionAngle self, FloatKey a0) -> IMP::Float
        get_value(DirectionAngle self, IntKey a0) -> IMP::Int
        get_value(DirectionAngle self, FloatsKey a0) -> IMP::Floats
        get_value(DirectionAngle self, IntsKey a0) -> IMP::Ints
        get_value(DirectionAngle self, StringKey a0) -> IMP::String
        get_value(DirectionAngle self, ParticleIndexKey a0) -> Particle
        get_value(DirectionAngle self, ObjectKey a0) -> Object
        """
        return _IMP_core.DirectionAngle_get_value(self, *args)


    def set_value(self, *args):
        """
        set_value(DirectionAngle self, FloatKey a0, IMP::Float a1)
        set_value(DirectionAngle self, IntKey a0, IMP::Int a1)
        set_value(DirectionAngle self, FloatsKey a0, IMP::Floats a1)
        set_value(DirectionAngle self, IntsKey a0, IMP::Ints a1)
        set_value(DirectionAngle self, StringKey a0, IMP::String a1)
        set_value(DirectionAngle self, ParticleIndexKey a0, Particle a1)
        set_value(DirectionAngle self, ObjectKey a0, Object a1)
        """
        return _IMP_core.DirectionAngle_set_value(self, *args)


    def remove_attribute(self, *args):
        """
        remove_attribute(DirectionAngle self, FloatKey a0)
        remove_attribute(DirectionAngle self, IntKey a0)
        remove_attribute(DirectionAngle self, FloatsKey a0)
        remove_attribute(DirectionAngle self, IntsKey a0)
        remove_attribute(DirectionAngle self, StringKey a0)
        remove_attribute(DirectionAngle self, ParticleIndexKey a0)
        remove_attribute(DirectionAngle self, ObjectKey a0)
        """
        return _IMP_core.DirectionAngle_remove_attribute(self, *args)


    def has_attribute(self, *args):
        """
        has_attribute(DirectionAngle self, FloatKey a0) -> bool
        has_attribute(DirectionAngle self, IntKey a0) -> bool
        has_attribute(DirectionAngle self, FloatsKey a0) -> bool
        has_attribute(DirectionAngle self, IntsKey a0) -> bool
        has_attribute(DirectionAngle self, StringKey a0) -> bool
        has_attribute(DirectionAngle self, ParticleIndexKey a0) -> bool
        has_attribute(DirectionAngle self, ObjectKey a0) -> bool
        """
        return _IMP_core.DirectionAngle_has_attribute(self, *args)


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


    def get_name(self):
        """get_name(DirectionAngle self) -> std::string"""
        return _IMP_core.DirectionAngle_get_name(self)


    def clear_caches(self):
        """clear_caches(DirectionAngle self)"""
        return _IMP_core.DirectionAngle_clear_caches(self)


    def set_name(self, a0):
        """set_name(DirectionAngle self, std::string a0)"""
        return _IMP_core.DirectionAngle_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(DirectionAngle self, IMP::CheckLevel a0)"""
        return _IMP_core.DirectionAngle_set_check_level(self, a0)


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


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(DirectionAngle self, FloatKey a0, bool a1)"""
        return _IMP_core.DirectionAngle_set_is_optimized(self, a0, a1)


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


    def get_check_level(self):
        """get_check_level(DirectionAngle self) -> IMP::CheckLevel"""
        return _IMP_core.DirectionAngle_get_check_level(self)


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


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


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


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


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


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


    def __hash__(self):
        """__hash__(DirectionAngle self) -> std::size_t"""
        return _IMP_core.DirectionAngle___hash__(self)


    def __str__(self):
        """__str__(DirectionAngle self) -> std::string"""
        return _IMP_core.DirectionAngle___str__(self)


    def __repr__(self):
        """__repr__(DirectionAngle self) -> std::string"""
        return _IMP_core.DirectionAngle___repr__(self)

    __swig_destroy__ = _IMP_core.delete_DirectionAngle
    __del__ = lambda self: None
DirectionAngle_swigregister = _IMP_core.DirectionAngle_swigregister
DirectionAngle_swigregister(DirectionAngle)

def DirectionAngle_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi, IMP::ParticleIndexPair ds) -> DirectionAngle
    setup_particle(_ParticleAdaptor decorator, IMP::ParticleIndexPair ds) -> DirectionAngle
    setup_particle(Model m, ParticleIndex pi, _ParticleIndexAdaptor d0, _ParticleIndexAdaptor d1) -> DirectionAngle
    DirectionAngle_setup_particle(_ParticleAdaptor decorator, _ParticleIndexAdaptor d0, _ParticleIndexAdaptor d1) -> DirectionAngle
    """
    return _IMP_core.DirectionAngle_setup_particle(*args)

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

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

def DirectionAngle_get_particle_key(i):
    """DirectionAngle_get_particle_key(unsigned int i) -> ParticleIndexKey"""
    return _IMP_core.DirectionAngle_get_particle_key(i)

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

    def do_setup_particle(*args):
        """
        do_setup_particle(Model m, ParticleIndex pi, Vector3D center, Vector3D normal)
        do_setup_particle(Model m, ParticleIndex pi, Vector3D center)
        do_setup_particle(Model m, ParticleIndex pi)
        do_setup_particle(Model m, ParticleIndex pi, ReferenceFrame3D rf)
        """
        return _IMP_core.Surface_do_setup_particle(*args)

    do_setup_particle = staticmethod(do_setup_particle)

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

    def show(self, *args):
        """
        show(Surface self, _ostream out)
        show(Surface self)
        """
        return _IMP_core.Surface_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi) -> Surface
        setup_particle(_ParticleAdaptor decorator) -> Surface
        setup_particle(Model m, ParticleIndex pi, ReferenceFrame3D rf) -> Surface
        setup_particle(_ParticleAdaptor decorator, ReferenceFrame3D rf) -> Surface
        setup_particle(Model m, ParticleIndex pi, Vector3D center) -> Surface
        setup_particle(_ParticleAdaptor decorator, Vector3D center) -> Surface
        setup_particle(Model m, ParticleIndex pi, Vector3D center, Vector3D normal) -> Surface
        setup_particle(_ParticleAdaptor decorator, Vector3D center, Vector3D normal) -> Surface
        """
        return _IMP_core.Surface_setup_particle(*args)

    setup_particle = staticmethod(setup_particle)

    def get_normal_x(self):
        """get_normal_x(Surface self) -> IMP::Float"""
        return _IMP_core.Surface_get_normal_x(self)


    def set_normal_x(self, t):
        """set_normal_x(Surface self, IMP::Float t)"""
        return _IMP_core.Surface_set_normal_x(self, t)


    def get_normal_y(self):
        """get_normal_y(Surface self) -> IMP::Float"""
        return _IMP_core.Surface_get_normal_y(self)


    def set_normal_y(self, t):
        """set_normal_y(Surface self, IMP::Float t)"""
        return _IMP_core.Surface_set_normal_y(self, t)


    def get_normal_z(self):
        """get_normal_z(Surface self) -> IMP::Float"""
        return _IMP_core.Surface_get_normal_z(self)


    def set_normal_z(self, t):
        """set_normal_z(Surface self, IMP::Float t)"""
        return _IMP_core.Surface_set_normal_z(self, t)


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

    get_is_setup = staticmethod(get_is_setup)

    def get_normal_key(i):
        """get_normal_key(unsigned int i) -> FloatKey"""
        return _IMP_core.Surface_get_normal_key(i)

    get_normal_key = staticmethod(get_normal_key)

    def get_normal_derivative(self, i):
        """get_normal_derivative(Surface self, int i) -> IMP::Float"""
        return _IMP_core.Surface_get_normal_derivative(self, i)


    def get_normal_derivatives(self):
        """get_normal_derivatives(Surface self) -> Vector3D"""
        return _IMP_core.Surface_get_normal_derivatives(self)


    def add_to_normal_derivative(self, i, v, d):
        """add_to_normal_derivative(Surface self, int i, IMP::Float v, DerivativeAccumulator d)"""
        return _IMP_core.Surface_add_to_normal_derivative(self, i, v, d)


    def add_to_normal_derivatives(self, v, d):
        """add_to_normal_derivatives(Surface self, Vector3D v, DerivativeAccumulator d)"""
        return _IMP_core.Surface_add_to_normal_derivatives(self, v, d)


    def get_normal_is_optimized(self):
        """get_normal_is_optimized(Surface self) -> bool"""
        return _IMP_core.Surface_get_normal_is_optimized(self)


    def set_normal_is_optimized(self, tf):
        """set_normal_is_optimized(Surface self, bool tf)"""
        return _IMP_core.Surface_set_normal_is_optimized(self, tf)


    def get_normal(self):
        """get_normal(Surface self) -> Vector3D"""
        return _IMP_core.Surface_get_normal(self)


    def set_normal(self, normal):
        """set_normal(Surface self, Vector3D normal)"""
        return _IMP_core.Surface_set_normal(self, normal)


    def reflect(self):
        """reflect(Surface self)"""
        return _IMP_core.Surface_reflect(self)


    def get_height(self, v):
        """get_height(Surface self, Vector3D v) -> double"""
        return _IMP_core.Surface_get_height(self, v)


    def get_depth(self, v):
        """get_depth(Surface self, Vector3D v) -> double"""
        return _IMP_core.Surface_get_depth(self, v)


    def get_distance_to(self, v):
        """get_distance_to(Surface self, Vector3D v) -> double"""
        return _IMP_core.Surface_get_distance_to(self, v)


    def get_distance_to_center(self, v):
        """get_distance_to_center(Surface self, Vector3D v) -> double"""
        return _IMP_core.Surface_get_distance_to_center(self, v)


    def set_reference_frame(self, rf):
        """set_reference_frame(Surface self, ReferenceFrame3D rf)"""
        return _IMP_core.Surface_set_reference_frame(self, rf)


    def get_reference_frame(self):
        """get_reference_frame(Surface self) -> ReferenceFrame3D"""
        return _IMP_core.Surface_get_reference_frame(self)


    def get_plane(self):
        """get_plane(Surface self) -> Plane3D"""
        return _IMP_core.Surface_get_plane(self)


    def add_attribute(self, *args):
        """
        add_attribute(Surface self, FloatKey k, IMP::Float v, bool opt)
        add_attribute(Surface self, FloatKey a0, IMP::Float a1)
        add_attribute(Surface self, IntKey a0, IMP::Int a1)
        add_attribute(Surface self, FloatsKey a0, IMP::Floats a1)
        add_attribute(Surface self, IntsKey a0, IMP::Ints a1)
        add_attribute(Surface self, StringKey a0, IMP::String a1)
        add_attribute(Surface self, ParticleIndexKey a0, Particle a1)
        add_attribute(Surface self, ObjectKey a0, Object a1)
        """
        return _IMP_core.Surface_add_attribute(self, *args)


    def get_value(self, *args):
        """
        get_value(Surface self, FloatKey a0) -> IMP::Float
        get_value(Surface self, IntKey a0) -> IMP::Int
        get_value(Surface self, FloatsKey a0) -> IMP::Floats
        get_value(Surface self, IntsKey a0) -> IMP::Ints
        get_value(Surface self, StringKey a0) -> IMP::String
        get_value(Surface self, ParticleIndexKey a0) -> Particle
        get_value(Surface self, ObjectKey a0) -> Object
        """
        return _IMP_core.Surface_get_value(self, *args)


    def set_value(self, *args):
        """
        set_value(Surface self, FloatKey a0, IMP::Float a1)
        set_value(Surface self, IntKey a0, IMP::Int a1)
        set_value(Surface self, FloatsKey a0, IMP::Floats a1)
        set_value(Surface self, IntsKey a0, IMP::Ints a1)
        set_value(Surface self, StringKey a0, IMP::String a1)
        set_value(Surface self, ParticleIndexKey a0, Particle a1)
        set_value(Surface self, ObjectKey a0, Object a1)
        """
        return _IMP_core.Surface_set_value(self, *args)


    def remove_attribute(self, *args):
        """
        remove_attribute(Surface self, FloatKey a0)
        remove_attribute(Surface self, IntKey a0)
        remove_attribute(Surface self, FloatsKey a0)
        remove_attribute(Surface self, IntsKey a0)
        remove_attribute(Surface self, StringKey a0)
        remove_attribute(Surface self, ParticleIndexKey a0)
        remove_attribute(Surface self, ObjectKey a0)
        """
        return _IMP_core.Surface_remove_attribute(self, *args)


    def has_attribute(self, *args):
        """
        has_attribute(Surface self, FloatKey a0) -> bool
        has_attribute(Surface self, IntKey a0) -> bool
        has_attribute(Surface self, FloatsKey a0) -> bool
        has_attribute(Surface self, IntsKey a0) -> bool
        has_attribute(Surface self, StringKey a0) -> bool
        has_attribute(Surface self, ParticleIndexKey a0) -> bool
        has_attribute(Surface self, ObjectKey a0) -> bool
        """
        return _IMP_core.Surface_has_attribute(self, *args)


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


    def get_name(self):
        """get_name(Surface self) -> std::string"""
        return _IMP_core.Surface_get_name(self)


    def clear_caches(self):
        """clear_caches(Surface self)"""
        return _IMP_core.Surface_clear_caches(self)


    def set_name(self, a0):
        """set_name(Surface self, std::string a0)"""
        return _IMP_core.Surface_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(Surface self, IMP::CheckLevel a0)"""
        return _IMP_core.Surface_set_check_level(self, a0)


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


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(Surface self, FloatKey a0, bool a1)"""
        return _IMP_core.Surface_set_is_optimized(self, a0, a1)


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


    def get_check_level(self):
        """get_check_level(Surface self) -> IMP::CheckLevel"""
        return _IMP_core.Surface_get_check_level(self)


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


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


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


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


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


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


    def __hash__(self):
        """__hash__(Surface self) -> std::size_t"""
        return _IMP_core.Surface___hash__(self)


    def __str__(self):
        """__str__(Surface self) -> std::string"""
        return _IMP_core.Surface___str__(self)


    def __repr__(self):
        """__repr__(Surface self) -> std::string"""
        return _IMP_core.Surface___repr__(self)

    __swig_destroy__ = _IMP_core.delete_Surface
    __del__ = lambda self: None
Surface_swigregister = _IMP_core.Surface_swigregister
Surface_swigregister(Surface)

def Surface_do_setup_particle(*args):
    """
    do_setup_particle(Model m, ParticleIndex pi, Vector3D center, Vector3D normal)
    do_setup_particle(Model m, ParticleIndex pi, Vector3D center)
    do_setup_particle(Model m, ParticleIndex pi)
    Surface_do_setup_particle(Model m, ParticleIndex pi, ReferenceFrame3D rf)
    """
    return _IMP_core.Surface_do_setup_particle(*args)

def Surface_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi) -> Surface
    setup_particle(_ParticleAdaptor decorator) -> Surface
    setup_particle(Model m, ParticleIndex pi, ReferenceFrame3D rf) -> Surface
    setup_particle(_ParticleAdaptor decorator, ReferenceFrame3D rf) -> Surface
    setup_particle(Model m, ParticleIndex pi, Vector3D center) -> Surface
    setup_particle(_ParticleAdaptor decorator, Vector3D center) -> Surface
    setup_particle(Model m, ParticleIndex pi, Vector3D center, Vector3D normal) -> Surface
    Surface_setup_particle(_ParticleAdaptor decorator, Vector3D center, Vector3D normal) -> Surface
    """
    return _IMP_core.Surface_setup_particle(*args)

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

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


def get_height(*args):
    """
    get_height(Surface s, XYZR d) -> double
    get_height(Surface s, XYZ d) -> double
    """
    return _IMP_core.get_height(*args)

def get_depth(*args):
    """
    get_depth(Surface s, XYZR d) -> double
    get_depth(Surface s, XYZ d) -> double
    """
    return _IMP_core.get_depth(*args)

def get_distance(*args):
    """
    get_distance(XYZ a, XYZ b) -> double
    get_distance(XYZR a, XYZR b) -> double
    get_distance(Surface s, XYZR d) -> double
    get_distance(Surface s, XYZ d) -> double
    """
    return _IMP_core.get_distance(*args)
class SurfaceGeometry(IMP.display.Geometry):
    """Proxy of C++ IMP::core::SurfaceGeometry 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::SurfaceGeometry self, std::string n) -> SurfaceGeometry
        __init__(IMP::core::SurfaceGeometry self) -> SurfaceGeometry
        __init__(IMP::core::SurfaceGeometry self, Surface s, std::string const n) -> SurfaceGeometry
        __init__(IMP::core::SurfaceGeometry self, Surface s) -> SurfaceGeometry
        __init__(IMP::core::SurfaceGeometry self, Surface s, Color c, std::string n) -> SurfaceGeometry
        __init__(IMP::core::SurfaceGeometry self, Surface s, Color c) -> SurfaceGeometry
        """
        this = _IMP_core.new_SurfaceGeometry(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def get_geometry(self):
        """get_geometry(SurfaceGeometry self) -> Surface"""
        return _IMP_core.SurfaceGeometry_get_geometry(self)


    def set_geometry(self, s):
        """set_geometry(SurfaceGeometry self, Surface s)"""
        return _IMP_core.SurfaceGeometry_set_geometry(self, s)


    def get_version_info(self):
        """get_version_info(SurfaceGeometry self) -> VersionInfo"""
        return _IMP_core.SurfaceGeometry_get_version_info(self)


    def __str__(self):
        """__str__(SurfaceGeometry self) -> std::string"""
        return _IMP_core.SurfaceGeometry___str__(self)


    def __repr__(self):
        """__repr__(SurfaceGeometry self) -> std::string"""
        return _IMP_core.SurfaceGeometry___repr__(self)


    @staticmethod
    def get_from(o):
       return _object_cast_to_SurfaceGeometry(o)

SurfaceGeometry_swigregister = _IMP_core.SurfaceGeometry_swigregister
SurfaceGeometry_swigregister(SurfaceGeometry)


def create_geometry(*args):
    """
    create_geometry(Surface s, std::string name) -> SurfaceGeometry
    create_geometry(Surface s) -> SurfaceGeometry
    """
    return _IMP_core.create_geometry(*args)
class SurfaceGeometryConstraint(IMP.Constraint):
    """Proxy of C++ IMP::core::SurfaceGeometryConstraint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, s, g):
        """__init__(IMP::core::SurfaceGeometryConstraint self, Surface s, SurfaceGeometry g) -> SurfaceGeometryConstraint"""
        this = _IMP_core.new_SurfaceGeometryConstraint(s, g)
        try:
            self.this.append(this)
        except:
            self.this = this

    def get_surface(self):
        """get_surface(SurfaceGeometryConstraint self) -> Surface"""
        return _IMP_core.SurfaceGeometryConstraint_get_surface(self)


    def get_geometry(self):
        """get_geometry(SurfaceGeometryConstraint self) -> SurfaceGeometry"""
        return _IMP_core.SurfaceGeometryConstraint_get_geometry(self)


    def do_get_inputs(self):
        """do_get_inputs(SurfaceGeometryConstraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_core.SurfaceGeometryConstraint_do_get_inputs(self)


    def do_get_outputs(self):
        """do_get_outputs(SurfaceGeometryConstraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_core.SurfaceGeometryConstraint_do_get_outputs(self)


    def get_version_info(self):
        """get_version_info(SurfaceGeometryConstraint self) -> VersionInfo"""
        return _IMP_core.SurfaceGeometryConstraint_get_version_info(self)


    def __str__(self):
        """__str__(SurfaceGeometryConstraint self) -> std::string"""
        return _IMP_core.SurfaceGeometryConstraint___str__(self)


    def __repr__(self):
        """__repr__(SurfaceGeometryConstraint self) -> std::string"""
        return _IMP_core.SurfaceGeometryConstraint___repr__(self)


    @staticmethod
    def get_from(o):
       return _object_cast_to_SurfaceGeometryConstraint(o)

SurfaceGeometryConstraint_swigregister = _IMP_core.SurfaceGeometryConstraint_swigregister
SurfaceGeometryConstraint_swigregister(SurfaceGeometryConstraint)


def get_constrained_surface_geometry(*args):
    """
    get_constrained_surface_geometry(Surface s, std::string name) -> SurfaceGeometry
    get_constrained_surface_geometry(Surface s) -> SurfaceGeometry
    """
    return _IMP_core.get_constrained_surface_geometry(*args)
class LateralSurfaceConstraint(IMP.Constraint):
    """Proxy of C++ IMP::core::LateralSurfaceConstraint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, s, d):
        """__init__(IMP::core::LateralSurfaceConstraint self, Surface s, XYZ d) -> LateralSurfaceConstraint"""
        this = _IMP_core.new_LateralSurfaceConstraint(s, d)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self):
        """do_get_inputs(LateralSurfaceConstraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_core.LateralSurfaceConstraint_do_get_inputs(self)


    def do_get_outputs(self):
        """do_get_outputs(LateralSurfaceConstraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_core.LateralSurfaceConstraint_do_get_outputs(self)


    def get_version_info(self):
        """get_version_info(LateralSurfaceConstraint self) -> VersionInfo"""
        return _IMP_core.LateralSurfaceConstraint_get_version_info(self)


    def __str__(self):
        """__str__(LateralSurfaceConstraint self) -> std::string"""
        return _IMP_core.LateralSurfaceConstraint___str__(self)


    def __repr__(self):
        """__repr__(LateralSurfaceConstraint self) -> std::string"""
        return _IMP_core.LateralSurfaceConstraint___repr__(self)


    @staticmethod
    def get_from(o):
       return _object_cast_to_LateralSurfaceConstraint(o)

LateralSurfaceConstraint_swigregister = _IMP_core.LateralSurfaceConstraint_swigregister
LateralSurfaceConstraint_swigregister(LateralSurfaceConstraint)

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)


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

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, Model m, IMP::ParticleIndexes const & pis, IMP::FloatKeys const & vars, IMP::Float radius) -> BallMover
        __init__(IMP::core::BallMover self, Model m, IMP::ParticleIndexes const & pis, 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)


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

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)


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

SerialMover_swigregister = _IMP_core.SerialMover_swigregister
SerialMover_swigregister(SerialMover)

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

    def __init__(self, mvs, n):
        """__init__(IMP::core::SubsetMover self, IMP::core::MonteCarloMoversTemp const & mvs, unsigned int n) -> SubsetMover"""
        this = _IMP_core.new_SubsetMover(mvs, n)
        try:
            self.this.append(this)
        except:
            self.this = this

    def get_movers(self):
        """get_movers(SubsetMover self) -> IMP::core::MonteCarloMovers const &"""
        return _IMP_core.SubsetMover_get_movers(self)


    def get_subset_size(self):
        """get_subset_size(SubsetMover self) -> unsigned int"""
        return _IMP_core.SubsetMover_get_subset_size(self)


    def get_version_info(self):
        """get_version_info(SubsetMover self) -> VersionInfo"""
        return _IMP_core.SubsetMover_get_version_info(self)


    def __str__(self):
        """__str__(SubsetMover self) -> std::string"""
        return _IMP_core.SubsetMover___str__(self)


    def __repr__(self):
        """__repr__(SubsetMover self) -> std::string"""
        return _IMP_core.SubsetMover___repr__(self)


    @staticmethod
    def get_from(o):
       return _object_cast_to_SubsetMover(o)

SubsetMover_swigregister = _IMP_core.SubsetMover_swigregister
SubsetMover_swigregister(SubsetMover)

class DirectionMover(MonteCarloMover):
    """Proxy of C++ IMP::core::DirectionMover 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::DirectionMover self, Model m, ParticleIndex pi, IMP::Float max_rotation, IMP::Float reflect_probability) -> DirectionMover
        __init__(IMP::core::DirectionMover self, Direction d, IMP::Float max_rotation, IMP::Float reflect_probability) -> DirectionMover
        """
        this = _IMP_core.new_DirectionMover(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def set_maximum_rotation(self, mr):
        """set_maximum_rotation(DirectionMover self, IMP::Float mr)"""
        return _IMP_core.DirectionMover_set_maximum_rotation(self, mr)


    def set_reflect_probability(self, rp):
        """set_reflect_probability(DirectionMover self, IMP::Float rp)"""
        return _IMP_core.DirectionMover_set_reflect_probability(self, rp)


    def get_maximum_rotation(self):
        """get_maximum_rotation(DirectionMover self) -> IMP::Float"""
        return _IMP_core.DirectionMover_get_maximum_rotation(self)


    def get_reflect_probability(self):
        """get_reflect_probability(DirectionMover self) -> IMP::Float"""
        return _IMP_core.DirectionMover_get_reflect_probability(self)


    def get_direction(self):
        """get_direction(DirectionMover self) -> Direction"""
        return _IMP_core.DirectionMover_get_direction(self)


    def get_version_info(self):
        """get_version_info(DirectionMover self) -> VersionInfo"""
        return _IMP_core.DirectionMover_get_version_info(self)


    def __str__(self):
        """__str__(DirectionMover self) -> std::string"""
        return _IMP_core.DirectionMover___str__(self)


    def __repr__(self):
        """__repr__(DirectionMover self) -> std::string"""
        return _IMP_core.DirectionMover___repr__(self)


    @staticmethod
    def get_from(o):
       return _object_cast_to_DirectionMover(o)

DirectionMover_swigregister = _IMP_core.DirectionMover_swigregister
DirectionMover_swigregister(DirectionMover)

class SurfaceMover(MonteCarloMover):
    """Proxy of C++ IMP::core::SurfaceMover 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::SurfaceMover self, Model m, ParticleIndex pi, IMP::Float max_translation, IMP::Float max_rotation, IMP::Float reflect_probability) -> SurfaceMover
        __init__(IMP::core::SurfaceMover self, Surface s, IMP::Float max_translation, IMP::Float max_rotation, IMP::Float reflect_probability) -> SurfaceMover
        """
        this = _IMP_core.new_SurfaceMover(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def set_maximum_translation(self, mt):
        """set_maximum_translation(SurfaceMover self, IMP::Float mt)"""
        return _IMP_core.SurfaceMover_set_maximum_translation(self, mt)


    def set_maximum_rotation(self, mr):
        """set_maximum_rotation(SurfaceMover self, IMP::Float mr)"""
        return _IMP_core.SurfaceMover_set_maximum_rotation(self, mr)


    def set_reflect_probability(self, rp):
        """set_reflect_probability(SurfaceMover self, IMP::Float rp)"""
        return _IMP_core.SurfaceMover_set_reflect_probability(self, rp)


    def get_maximum_translation(self):
        """get_maximum_translation(SurfaceMover self) -> IMP::Float"""
        return _IMP_core.SurfaceMover_get_maximum_translation(self)


    def get_maximum_rotation(self):
        """get_maximum_rotation(SurfaceMover self) -> IMP::Float"""
        return _IMP_core.SurfaceMover_get_maximum_rotation(self)


    def get_reflect_probability(self):
        """get_reflect_probability(SurfaceMover self) -> IMP::Float"""
        return _IMP_core.SurfaceMover_get_reflect_probability(self)


    def get_surface(self):
        """get_surface(SurfaceMover self) -> Surface"""
        return _IMP_core.SurfaceMover_get_surface(self)


    def get_version_info(self):
        """get_version_info(SurfaceMover self) -> VersionInfo"""
        return _IMP_core.SurfaceMover_get_version_info(self)


    def __str__(self):
        """__str__(SurfaceMover self) -> std::string"""
        return _IMP_core.SurfaceMover___str__(self)


    def __repr__(self):
        """__repr__(SurfaceMover self) -> std::string"""
        return _IMP_core.SurfaceMover___repr__(self)


    @staticmethod
    def get_from(o):
       return _object_cast_to_SurfaceMover(o)

SurfaceMover_swigregister = _IMP_core.SurfaceMover_swigregister
SurfaceMover_swigregister(SurfaceMover)

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)


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

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)


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

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, FloatsKey a0, IMP::Floats a1)
        add_attribute(Centroid self, IntsKey a0, IMP::Ints 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, FloatsKey a0) -> IMP::Floats
        get_value(Centroid self, IntsKey a0) -> IMP::Ints
        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, FloatsKey a0, IMP::Floats a1)
        set_value(Centroid self, IntsKey a0, IMP::Ints 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, FloatsKey a0)
        remove_attribute(Centroid self, IntsKey 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, FloatsKey a0) -> bool
        has_attribute(Centroid self, IntsKey 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)


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

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)


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

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)


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

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)


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

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)


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

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)


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

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_index_pairs(self):
        """get_connected_index_pairs(ConnectivityRestraint self) -> IMP::ParticleIndexPairs"""
        return _IMP_core.ConnectivityRestraint_get_connected_index_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)


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

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)


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

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)


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

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)


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

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, FloatsKey a0, IMP::Floats a1)
        add_attribute(Cover self, IntsKey a0, IMP::Ints 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, FloatsKey a0) -> IMP::Floats
        get_value(Cover self, IntsKey a0) -> IMP::Ints
        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, FloatsKey a0, IMP::Floats a1)
        set_value(Cover self, IntsKey a0, IMP::Ints 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, FloatsKey a0)
        remove_attribute(Cover self, IntsKey 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, FloatsKey a0) -> bool
        has_attribute(Cover self, IntsKey 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)


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

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)


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

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)


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

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)


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

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, FloatsKey a0, IMP::Floats a1)
        add_attribute(Reference self, IntsKey a0, IMP::Ints 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, FloatsKey a0) -> IMP::Floats
        get_value(Reference self, IntsKey a0) -> IMP::Ints
        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, FloatsKey a0, IMP::Floats a1)
        set_value(Reference self, IntsKey a0, IMP::Ints 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, FloatsKey a0)
        remove_attribute(Reference self, IntsKey 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, FloatsKey a0) -> bool
        has_attribute(Reference self, IntsKey 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)


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

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, *args):
        """
        __init__(IMP::core::TransformationSymmetry self, Transformation3D t) -> TransformationSymmetry
        __init__(IMP::core::TransformationSymmetry self, ParticleIndex rb_pi) -> TransformationSymmetry
        """
        this = _IMP_core.new_TransformationSymmetry(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def get_transformation(self):
        """get_transformation(TransformationSymmetry self) -> Transformation3D"""
        return _IMP_core.TransformationSymmetry_get_transformation(self)


    def set_transformation(self, t):
        """set_transformation(TransformationSymmetry self, Transformation3D t)"""
        return _IMP_core.TransformationSymmetry_set_transformation(self, t)


    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)


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

TransformationSymmetry_swigregister = _IMP_core.TransformationSymmetry_swigregister
TransformationSymmetry_swigregister(TransformationSymmetry)

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

    def __init__(self, m, symm, pivot, max_translation, max_rotation):
        """__init__(IMP::core::TransformationSymmetryMover self, Model m, TransformationSymmetry symm, ParticleIndex pivot, IMP::Float max_translation, IMP::Float max_rotation) -> TransformationSymmetryMover"""
        this = _IMP_core.new_TransformationSymmetryMover(m, symm, pivot, max_translation, max_rotation)
        try:
            self.this.append(this)
        except:
            self.this = this

    def set_maximum_translation(self, mt):
        """set_maximum_translation(TransformationSymmetryMover self, IMP::Float mt)"""
        return _IMP_core.TransformationSymmetryMover_set_maximum_translation(self, mt)


    def set_maximum_rotation(self, mr):
        """set_maximum_rotation(TransformationSymmetryMover self, IMP::Float mr)"""
        return _IMP_core.TransformationSymmetryMover_set_maximum_rotation(self, mr)


    def get_maximum_translation(self):
        """get_maximum_translation(TransformationSymmetryMover self) -> IMP::Float"""
        return _IMP_core.TransformationSymmetryMover_get_maximum_translation(self)


    def get_maximum_rotation(self):
        """get_maximum_rotation(TransformationSymmetryMover self) -> IMP::Float"""
        return _IMP_core.TransformationSymmetryMover_get_maximum_rotation(self)


    def get_version_info(self):
        """get_version_info(TransformationSymmetryMover self) -> VersionInfo"""
        return _IMP_core.TransformationSymmetryMover_get_version_info(self)


    def __str__(self):
        """__str__(TransformationSymmetryMover self) -> std::string"""
        return _IMP_core.TransformationSymmetryMover___str__(self)


    def __repr__(self):
        """__repr__(TransformationSymmetryMover self) -> std::string"""
        return _IMP_core.TransformationSymmetryMover___repr__(self)


    @staticmethod
    def get_from(o):
       return _object_cast_to_TransformationSymmetryMover(o)

TransformationSymmetryMover_swigregister = _IMP_core.TransformationSymmetryMover_swigregister
TransformationSymmetryMover_swigregister(TransformationSymmetryMover)

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, m, score_func, p1, p2, p3, p4):
        """__init__(IMP::core::DihedralRestraint self, Model m, UnaryFunction score_func, _ParticleIndexAdaptor p1, _ParticleIndexAdaptor p2, _ParticleIndexAdaptor p3, _ParticleIndexAdaptor p4) -> DihedralRestraint"""
        this = _IMP_core.new_DihedralRestraint(m, score_func, p1, p2, p3, p4)
        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)


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

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)


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

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)


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

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


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

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)


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

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)


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

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)


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

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)


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

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)


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

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)


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

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)


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

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)


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

HarmonicUpperBound_swigregister = _IMP_core.HarmonicUpperBound_swigregister
HarmonicUpperBound_swigregister(HarmonicUpperBound)

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

    def __init__(self, funcs, weights):
        """__init__(IMP::core::WeightedSum self, IMP::UnaryFunctions funcs, IMP::Floats weights) -> WeightedSum"""
        this = _IMP_core.new_WeightedSum(funcs, weights)
        try:
            self.this.append(this)
        except:
            self.this = this

    def get_function_number(self):
        """get_function_number(WeightedSum self) -> unsigned int"""
        return _IMP_core.WeightedSum_get_function_number(self)


    def set_weights(self, weights):
        """set_weights(WeightedSum self, IMP::Floats weights)"""
        return _IMP_core.WeightedSum_set_weights(self, weights)


    def get_weights(self):
        """get_weights(WeightedSum self) -> IMP::Floats"""
        return _IMP_core.WeightedSum_get_weights(self)


    def get_weight(self, i):
        """get_weight(WeightedSum self, unsigned int i) -> double"""
        return _IMP_core.WeightedSum_get_weight(self, i)


    def get_function(self, i):
        """get_function(WeightedSum self, unsigned int i) -> UnaryFunction"""
        return _IMP_core.WeightedSum_get_function(self, i)


    def get_version_info(self):
        """get_version_info(WeightedSum self) -> VersionInfo"""
        return _IMP_core.WeightedSum_get_version_info(self)


    def __str__(self):
        """__str__(WeightedSum self) -> std::string"""
        return _IMP_core.WeightedSum___str__(self)


    def __repr__(self):
        """__repr__(WeightedSum self) -> std::string"""
        return _IMP_core.WeightedSum___repr__(self)


    @staticmethod
    def get_from(o):
       return _object_cast_to_WeightedSum(o)

WeightedSum_swigregister = _IMP_core.WeightedSum_swigregister
WeightedSum_swigregister(WeightedSum)

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

    def __init__(self, funcs, weights, denom=1.0):
        """
        __init__(IMP::core::WeightedSumOfExponential self, IMP::UnaryFunctions funcs, IMP::Floats weights, IMP::Float denom=1.0) -> WeightedSumOfExponential
        __init__(IMP::core::WeightedSumOfExponential self, IMP::UnaryFunctions funcs, IMP::Floats weights) -> WeightedSumOfExponential
        """
        this = _IMP_core.new_WeightedSumOfExponential(funcs, weights, denom)
        try:
            self.this.append(this)
        except:
            self.this = this

    def get_function_number(self):
        """get_function_number(WeightedSumOfExponential self) -> unsigned int"""
        return _IMP_core.WeightedSumOfExponential_get_function_number(self)


    def set_weights(self, weights):
        """set_weights(WeightedSumOfExponential self, IMP::Floats weights)"""
        return _IMP_core.WeightedSumOfExponential_set_weights(self, weights)


    def get_weights(self):
        """get_weights(WeightedSumOfExponential self) -> IMP::Floats"""
        return _IMP_core.WeightedSumOfExponential_get_weights(self)


    def get_weight(self, i):
        """get_weight(WeightedSumOfExponential self, unsigned int i) -> double"""
        return _IMP_core.WeightedSumOfExponential_get_weight(self, i)


    def get_function(self, i):
        """get_function(WeightedSumOfExponential self, unsigned int i) -> UnaryFunction"""
        return _IMP_core.WeightedSumOfExponential_get_function(self, i)


    def set_denominator(self, denom):
        """set_denominator(WeightedSumOfExponential self, double denom)"""
        return _IMP_core.WeightedSumOfExponential_set_denominator(self, denom)


    def get_denominator(self):
        """get_denominator(WeightedSumOfExponential self) -> double"""
        return _IMP_core.WeightedSumOfExponential_get_denominator(self)


    def get_version_info(self):
        """get_version_info(WeightedSumOfExponential self) -> VersionInfo"""
        return _IMP_core.WeightedSumOfExponential_get_version_info(self)


    def __str__(self):
        """__str__(WeightedSumOfExponential self) -> std::string"""
        return _IMP_core.WeightedSumOfExponential___str__(self)


    def __repr__(self):
        """__repr__(WeightedSumOfExponential self) -> std::string"""
        return _IMP_core.WeightedSumOfExponential___repr__(self)


    @staticmethod
    def get_from(o):
       return _object_cast_to_WeightedSumOfExponential(o)

WeightedSumOfExponential_swigregister = _IMP_core.WeightedSumOfExponential_swigregister
WeightedSumOfExponential_swigregister(WeightedSumOfExponential)

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)


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

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_changed_key():
        """get_changed_key() -> TriggerKey"""
        return _IMP_core.Hierarchy_get_changed_key()

    get_changed_key = staticmethod(get_changed_key)

    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, FloatsKey a0, IMP::Floats a1)
        add_attribute(Hierarchy self, IntsKey a0, IMP::Ints 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, FloatsKey a0) -> IMP::Floats
        get_value(Hierarchy self, IntsKey a0) -> IMP::Ints
        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, FloatsKey a0, IMP::Floats a1)
        set_value(Hierarchy self, IntsKey a0, IMP::Ints 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, FloatsKey a0)
        remove_attribute(Hierarchy self, IntsKey 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, FloatsKey a0) -> bool
        has_attribute(Hierarchy self, IntsKey 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_changed_key():
    """Hierarchy_get_changed_key() -> TriggerKey"""
    return _IMP_core.Hierarchy_get_changed_key()

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')
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(IMP::core::HierarchyVisitor self) -> HierarchyVisitor"""
        if self.__class__ == HierarchyVisitor:
            _self = None
        else:
            _self = self
        this = _IMP_core.new_HierarchyVisitor(_self, )
        try:
            self.this.append(this)
        except:
            self.this = this

        if self.__class__ != HierarchyVisitor:
            _director_objects.register(self)




    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
    def __disown__(self):
        self.this.disown()
        _IMP_core.disown_HierarchyVisitor(self)
        return weakref_proxy(self)
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)


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

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)


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

Linear_swigregister = _IMP_core.Linear_swigregister
Linear_swigregister(Linear)

class LogNormalMover(MonteCarloMover):
    """Proxy of C++ IMP::core::LogNormalMover 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::LogNormalMover self, Model m, ParticleIndex pi, IMP::FloatKeys const & vars, double stddev) -> LogNormalMover
        __init__(IMP::core::LogNormalMover self, Model m, ParticleIndex pi, double stddev) -> LogNormalMover
        __init__(IMP::core::LogNormalMover self, IMP::ParticlesTemp const & sc, IMP::FloatKeys const & vars, IMP::Float sigma) -> LogNormalMover
        __init__(IMP::core::LogNormalMover self, IMP::ParticlesTemp const & sc, IMP::Float radius) -> LogNormalMover
        """
        this = _IMP_core.new_LogNormalMover(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def set_sigma(self, sigma):
        """set_sigma(LogNormalMover self, IMP::Float sigma)"""
        return _IMP_core.LogNormalMover_set_sigma(self, sigma)


    def get_sigma(self):
        """get_sigma(LogNormalMover self) -> IMP::Float"""
        return _IMP_core.LogNormalMover_get_sigma(self)


    def get_version_info(self):
        """get_version_info(LogNormalMover self) -> VersionInfo"""
        return _IMP_core.LogNormalMover_get_version_info(self)


    def __str__(self):
        """__str__(LogNormalMover self) -> std::string"""
        return _IMP_core.LogNormalMover___str__(self)


    def __repr__(self):
        """__repr__(LogNormalMover self) -> std::string"""
        return _IMP_core.LogNormalMover___repr__(self)


    @staticmethod
    def get_from(o):
       return _object_cast_to_LogNormalMover(o)

LogNormalMover_swigregister = _IMP_core.LogNormalMover_swigregister
LogNormalMover_swigregister(LogNormalMover)

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, Model m, IMP::ParticleIndexes const & to_move, IMP::RestraintsTemp const & rs, double weight=1.0, double max, std::string name) -> IncrementalScoringFunction
        __init__(IMP::core::IncrementalScoringFunction self, Model m, IMP::ParticleIndexes const & to_move, IMP::RestraintsTemp const & rs, double weight=1.0, double max) -> IncrementalScoringFunction
        __init__(IMP::core::IncrementalScoringFunction self, Model m, IMP::ParticleIndexes const & to_move, IMP::RestraintsTemp const & rs, double weight=1.0) -> IncrementalScoringFunction
        __init__(IMP::core::IncrementalScoringFunction self, Model m, IMP::ParticleIndexes 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)


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

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_score_moved(self, mv):
        """set_score_moved(MonteCarlo self, bool mv)"""
        return _IMP_core.MonteCarlo_set_score_moved(self, mv)


    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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_MonteCarlo(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_MonteCarloWithLocalOptimization(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_MonteCarloWithBasinHopping(o)

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)


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

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_NormalMover(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_OpenCubicSpline(o)

    __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_and_filtered(self, *args):
        """
        get_are_close_and_filtered(QuadraticClosePairsFinder self, Particle a, Particle b) -> bool
        get_are_close_and_filtered(QuadraticClosePairsFinder self, Model m, ParticleIndex a, ParticleIndex b) -> bool
        """
        return _IMP_core.QuadraticClosePairsFinder_get_are_close_and_filtered(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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_QuadraticClosePairsFinder(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_RefinedPairsPairScore(o)

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_rotation_keys():
        """get_rotation_keys() -> IMP::FloatKeys"""
        return _IMP_core.RigidBody_get_rotation_keys()

    get_rotation_keys = staticmethod(get_rotation_keys)

    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_rotation(self):
        """get_rotation(RigidBody self) -> Rotation3D"""
        return _IMP_core.RigidBody_get_rotation(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 pull_back_members_adjoints(self, da):
        """pull_back_members_adjoints(RigidBody self, DerivativeAccumulator da)"""
        return _IMP_core.RigidBody_pull_back_members_adjoints(self, da)


    def pull_back_member_adjoints(self, pi, da):
        """pull_back_member_adjoints(RigidBody self, ParticleIndex pi, DerivativeAccumulator da)"""
        return _IMP_core.RigidBody_pull_back_member_adjoints(self, pi, da)


    def pull_back_body_member_adjoints(self, pi, da):
        """pull_back_body_member_adjoints(RigidBody self, ParticleIndex pi, DerivativeAccumulator da)"""
        return _IMP_core.RigidBody_pull_back_body_member_adjoints(self, pi, da)


    def add_to_derivatives(self, *args):
        """
        add_to_derivatives(RigidBody self, Vector3D local_derivative, Vector3D local_location, DerivativeAccumulator da)
        add_to_derivatives(RigidBody self, Vector3D local_derivative, Vector3D global_derivative, Vector3D local_location, Rotation3D rot_local_to_global, DerivativeAccumulator da)
        """
        return _IMP_core.RigidBody_add_to_derivatives(self, *args)


    def add_to_rotational_derivatives(self, *args):
        """
        add_to_rotational_derivatives(RigidBody self, Vector4D other_qderiv, Rotation3D rot_other_to_local, Rotation3D rot_local_to_global, DerivativeAccumulator da)
        add_to_rotational_derivatives(RigidBody self, Vector4D qderiv, DerivativeAccumulator da)
        """
        return _IMP_core.RigidBody_add_to_rotational_derivatives(self, *args)


    def add_to_torque(self, torque_local, da):
        """add_to_torque(RigidBody self, Vector3D torque_local, DerivativeAccumulator da)"""
        return _IMP_core.RigidBody_add_to_torque(self, torque_local, da)


    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) -> RigidBodyMember"""
        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, FloatsKey a0, IMP::Floats a1)
        add_attribute(RigidBody self, IntsKey a0, IMP::Ints 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, FloatsKey a0) -> IMP::Floats
        get_value(RigidBody self, IntsKey a0) -> IMP::Ints
        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, FloatsKey a0, IMP::Floats a1)
        set_value(RigidBody self, IntsKey a0, IMP::Ints 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, FloatsKey a0)
        remove_attribute(RigidBody self, IntsKey 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, FloatsKey a0) -> bool
        has_attribute(RigidBody self, IntsKey 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_get_rotation_keys():
    """RigidBody_get_rotation_keys() -> IMP::FloatKeys"""
    return _IMP_core.RigidBody_get_rotation_keys()

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 get_internal_rotation_keys():
        """get_internal_rotation_keys() -> IMP::FloatKeys"""
        return _IMP_core.RigidBodyMember_get_internal_rotation_keys()

    get_internal_rotation_keys = staticmethod(get_internal_rotation_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, FloatsKey a0, IMP::Floats a1)
        add_attribute(RigidBodyMember self, IntsKey a0, IMP::Ints 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, FloatsKey a0) -> IMP::Floats
        get_value(RigidBodyMember self, IntsKey a0) -> IMP::Ints
        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, FloatsKey a0, IMP::Floats a1)
        set_value(RigidBodyMember self, IntsKey a0, IMP::Ints 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, FloatsKey a0)
        remove_attribute(RigidBodyMember self, IntsKey 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, FloatsKey a0) -> bool
        has_attribute(RigidBodyMember self, IntsKey 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()

def RigidBodyMember_get_internal_rotation_keys():
    """RigidBodyMember_get_internal_rotation_keys() -> IMP::FloatKeys"""
    return _IMP_core.RigidBodyMember_get_internal_rotation_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, FloatsKey a0, IMP::Floats a1)
        add_attribute(RigidMember self, IntsKey a0, IMP::Ints 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, FloatsKey a0) -> IMP::Floats
        get_value(RigidMember self, IntsKey a0) -> IMP::Ints
        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, FloatsKey a0, IMP::Floats a1)
        set_value(RigidMember self, IntsKey a0, IMP::Ints 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, FloatsKey a0)
        remove_attribute(RigidMember self, IntsKey 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, FloatsKey a0) -> bool
        has_attribute(RigidMember self, IntsKey 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_to_internal_derivatives(self, deriv_parent, da):
        """add_to_internal_derivatives(NonRigidMember self, Vector3D deriv_parent, DerivativeAccumulator da)"""
        return _IMP_core.NonRigidMember_add_to_internal_derivatives(self, deriv_parent, da)


    def add_to_internal_rotational_derivatives(self, *args):
        """
        add_to_internal_rotational_derivatives(NonRigidMember self, Vector4D local_qderiv, Rotation3D rot_local_to_parent, Rotation3D rot_parent_to_global, DerivativeAccumulator da)
        add_to_internal_rotational_derivatives(NonRigidMember self, Vector4D qderiv, DerivativeAccumulator da)
        """
        return _IMP_core.NonRigidMember_add_to_internal_rotational_derivatives(self, *args)


    def get_internal_derivatives(self):
        """get_internal_derivatives(NonRigidMember self) -> Vector3D"""
        return _IMP_core.NonRigidMember_get_internal_derivatives(self)


    def get_internal_rotational_derivatives(self):
        """get_internal_rotational_derivatives(NonRigidMember self) -> Vector4D"""
        return _IMP_core.NonRigidMember_get_internal_rotational_derivatives(self)


    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, FloatsKey a0, IMP::Floats a1)
        add_attribute(NonRigidMember self, IntsKey a0, IMP::Ints 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, FloatsKey a0) -> IMP::Floats
        get_value(NonRigidMember self, IntsKey a0) -> IMP::Ints
        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, FloatsKey a0, IMP::Floats a1)
        set_value(NonRigidMember self, IntsKey a0, IMP::Ints 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, FloatsKey a0)
        remove_attribute(NonRigidMember self, IntsKey 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, FloatsKey a0) -> bool
        has_attribute(NonRigidMember self, IntsKey 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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_RigidMembersRefiner(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_RigidBodyHierarchyGeometry(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_RigidBodyDerivativeGeometry(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_RigidBodyDerivativesGeometry(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_RigidBodyFrameGeometry(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_RigidBodyFramesGeometry(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_RigidBodyTorque(o)

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


    @staticmethod
    def get_from(o):
       return _object_cast_to_NearestNeighborsClosePairsFinder(o)

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_add_score_and_derivatives_moved(self, sa, moved_pis, reset_pis, ss):
        """do_add_score_and_derivatives_moved(RestraintsScoringFunction self, ScoreAccumulator sa, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis, IMP::ScoreStatesTemp const & ss)"""
        return _IMP_core.RestraintsScoringFunction_do_add_score_and_derivatives_moved(self, sa, moved_pis, reset_pis, 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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_RestraintsScoringFunction(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_RigidClosePairsFinder(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_SphereDistancePairScore(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_HarmonicUpperBoundSphereDistancePairScore(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_HarmonicUpperBoundSphereDiameterPairScore(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_HarmonicSphereDistancePairScore(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_NormalizedSphereDistancePairScore(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_WeightedSphereDistancePairScore(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_SoftSpherePairScore(o)

SoftSpherePairScore_swigregister = _IMP_core.SoftSpherePairScore_swigregister
SoftSpherePairScore_swigregister(SoftSpherePairScore)

class SurfaceDistancePairScore(IMP.PairScore):
    """Proxy of C++ IMP::core::SurfaceDistancePairScore 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::SurfaceDistancePairScore self, UnaryFunction uf, std::string name) -> SurfaceDistancePairScore
        __init__(IMP::core::SurfaceDistancePairScore self, UnaryFunction uf) -> SurfaceDistancePairScore
        """
        this = _IMP_core.new_SurfaceDistancePairScore(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

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


    def get_version_info(self):
        """get_version_info(SurfaceDistancePairScore self) -> VersionInfo"""
        return _IMP_core.SurfaceDistancePairScore_get_version_info(self)


    def __str__(self):
        """__str__(SurfaceDistancePairScore self) -> std::string"""
        return _IMP_core.SurfaceDistancePairScore___str__(self)


    def __repr__(self):
        """__repr__(SurfaceDistancePairScore self) -> std::string"""
        return _IMP_core.SurfaceDistancePairScore___repr__(self)


    @staticmethod
    def get_from(o):
       return _object_cast_to_SurfaceDistancePairScore(o)

SurfaceDistancePairScore_swigregister = _IMP_core.SurfaceDistancePairScore_swigregister
SurfaceDistancePairScore_swigregister(SurfaceDistancePairScore)

class SurfaceHeightPairScore(IMP.PairScore):
    """Proxy of C++ IMP::core::SurfaceHeightPairScore 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::SurfaceHeightPairScore self, UnaryFunction uf, std::string name) -> SurfaceHeightPairScore
        __init__(IMP::core::SurfaceHeightPairScore self, UnaryFunction uf) -> SurfaceHeightPairScore
        """
        this = _IMP_core.new_SurfaceHeightPairScore(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

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


    def get_version_info(self):
        """get_version_info(SurfaceHeightPairScore self) -> VersionInfo"""
        return _IMP_core.SurfaceHeightPairScore_get_version_info(self)


    def __str__(self):
        """__str__(SurfaceHeightPairScore self) -> std::string"""
        return _IMP_core.SurfaceHeightPairScore___str__(self)


    def __repr__(self):
        """__repr__(SurfaceHeightPairScore self) -> std::string"""
        return _IMP_core.SurfaceHeightPairScore___repr__(self)


    @staticmethod
    def get_from(o):
       return _object_cast_to_SurfaceHeightPairScore(o)

SurfaceHeightPairScore_swigregister = _IMP_core.SurfaceHeightPairScore_swigregister
SurfaceHeightPairScore_swigregister(SurfaceHeightPairScore)

class SurfaceDepthPairScore(IMP.PairScore):
    """Proxy of C++ IMP::core::SurfaceDepthPairScore 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::SurfaceDepthPairScore self, UnaryFunction uf, std::string name) -> SurfaceDepthPairScore
        __init__(IMP::core::SurfaceDepthPairScore self, UnaryFunction uf) -> SurfaceDepthPairScore
        """
        this = _IMP_core.new_SurfaceDepthPairScore(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

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


    def get_version_info(self):
        """get_version_info(SurfaceDepthPairScore self) -> VersionInfo"""
        return _IMP_core.SurfaceDepthPairScore_get_version_info(self)


    def __str__(self):
        """__str__(SurfaceDepthPairScore self) -> std::string"""
        return _IMP_core.SurfaceDepthPairScore___str__(self)


    def __repr__(self):
        """__repr__(SurfaceDepthPairScore self) -> std::string"""
        return _IMP_core.SurfaceDepthPairScore___repr__(self)


    @staticmethod
    def get_from(o):
       return _object_cast_to_SurfaceDepthPairScore(o)

SurfaceDepthPairScore_swigregister = _IMP_core.SurfaceDepthPairScore_swigregister
SurfaceDepthPairScore_swigregister(SurfaceDepthPairScore)

class HarmonicSurfaceDistancePairScore(IMP.PairScore):
    """Proxy of C++ IMP::core::HarmonicSurfaceDistancePairScore 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::HarmonicSurfaceDistancePairScore self, double x0, double k, std::string name) -> HarmonicSurfaceDistancePairScore
        __init__(IMP::core::HarmonicSurfaceDistancePairScore self, double x0, double k) -> HarmonicSurfaceDistancePairScore
        """
        this = _IMP_core.new_HarmonicSurfaceDistancePairScore(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

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


    def get_version_info(self):
        """get_version_info(HarmonicSurfaceDistancePairScore self) -> VersionInfo"""
        return _IMP_core.HarmonicSurfaceDistancePairScore_get_version_info(self)


    def __str__(self):
        """__str__(HarmonicSurfaceDistancePairScore self) -> std::string"""
        return _IMP_core.HarmonicSurfaceDistancePairScore___str__(self)


    def __repr__(self):
        """__repr__(HarmonicSurfaceDistancePairScore self) -> std::string"""
        return _IMP_core.HarmonicSurfaceDistancePairScore___repr__(self)


    @staticmethod
    def get_from(o):
       return _object_cast_to_HarmonicSurfaceDistancePairScore(o)

HarmonicSurfaceDistancePairScore_swigregister = _IMP_core.HarmonicSurfaceDistancePairScore_swigregister
HarmonicSurfaceDistancePairScore_swigregister(HarmonicSurfaceDistancePairScore)

class HarmonicSurfaceHeightPairScore(IMP.PairScore):
    """Proxy of C++ IMP::core::HarmonicSurfaceHeightPairScore 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::HarmonicSurfaceHeightPairScore self, double x0, double k, std::string name) -> HarmonicSurfaceHeightPairScore
        __init__(IMP::core::HarmonicSurfaceHeightPairScore self, double x0, double k) -> HarmonicSurfaceHeightPairScore
        """
        this = _IMP_core.new_HarmonicSurfaceHeightPairScore(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

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


    def get_version_info(self):
        """get_version_info(HarmonicSurfaceHeightPairScore self) -> VersionInfo"""
        return _IMP_core.HarmonicSurfaceHeightPairScore_get_version_info(self)


    def __str__(self):
        """__str__(HarmonicSurfaceHeightPairScore self) -> std::string"""
        return _IMP_core.HarmonicSurfaceHeightPairScore___str__(self)


    def __repr__(self):
        """__repr__(HarmonicSurfaceHeightPairScore self) -> std::string"""
        return _IMP_core.HarmonicSurfaceHeightPairScore___repr__(self)


    @staticmethod
    def get_from(o):
       return _object_cast_to_HarmonicSurfaceHeightPairScore(o)

HarmonicSurfaceHeightPairScore_swigregister = _IMP_core.HarmonicSurfaceHeightPairScore_swigregister
HarmonicSurfaceHeightPairScore_swigregister(HarmonicSurfaceHeightPairScore)

class HarmonicSurfaceDepthPairScore(IMP.PairScore):
    """Proxy of C++ IMP::core::HarmonicSurfaceDepthPairScore 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::HarmonicSurfaceDepthPairScore self, double x0, double k, std::string name) -> HarmonicSurfaceDepthPairScore
        __init__(IMP::core::HarmonicSurfaceDepthPairScore self, double x0, double k) -> HarmonicSurfaceDepthPairScore
        """
        this = _IMP_core.new_HarmonicSurfaceDepthPairScore(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

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


    def get_version_info(self):
        """get_version_info(HarmonicSurfaceDepthPairScore self) -> VersionInfo"""
        return _IMP_core.HarmonicSurfaceDepthPairScore_get_version_info(self)


    def __str__(self):
        """__str__(HarmonicSurfaceDepthPairScore self) -> std::string"""
        return _IMP_core.HarmonicSurfaceDepthPairScore___str__(self)


    def __repr__(self):
        """__repr__(HarmonicSurfaceDepthPairScore self) -> std::string"""
        return _IMP_core.HarmonicSurfaceDepthPairScore___repr__(self)


    @staticmethod
    def get_from(o):
       return _object_cast_to_HarmonicSurfaceDepthPairScore(o)

HarmonicSurfaceDepthPairScore_swigregister = _IMP_core.HarmonicSurfaceDepthPairScore_swigregister
HarmonicSurfaceDepthPairScore_swigregister(HarmonicSurfaceDepthPairScore)

class SoftSuperSurfacePairScore(IMP.PairScore):
    """Proxy of C++ IMP::core::SoftSuperSurfacePairScore 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::SoftSuperSurfacePairScore self, double k, std::string name) -> SoftSuperSurfacePairScore
        __init__(IMP::core::SoftSuperSurfacePairScore self, double k) -> SoftSuperSurfacePairScore
        """
        this = _IMP_core.new_SoftSuperSurfacePairScore(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

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


    def get_version_info(self):
        """get_version_info(SoftSuperSurfacePairScore self) -> VersionInfo"""
        return _IMP_core.SoftSuperSurfacePairScore_get_version_info(self)


    def __str__(self):
        """__str__(SoftSuperSurfacePairScore self) -> std::string"""
        return _IMP_core.SoftSuperSurfacePairScore___str__(self)


    def __repr__(self):
        """__repr__(SoftSuperSurfacePairScore self) -> std::string"""
        return _IMP_core.SoftSuperSurfacePairScore___repr__(self)


    @staticmethod
    def get_from(o):
       return _object_cast_to_SoftSuperSurfacePairScore(o)

SoftSuperSurfacePairScore_swigregister = _IMP_core.SoftSuperSurfacePairScore_swigregister
SoftSuperSurfacePairScore_swigregister(SoftSuperSurfacePairScore)

class SoftSubSurfacePairScore(IMP.PairScore):
    """Proxy of C++ IMP::core::SoftSubSurfacePairScore 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::SoftSubSurfacePairScore self, double k, std::string name) -> SoftSubSurfacePairScore
        __init__(IMP::core::SoftSubSurfacePairScore self, double k) -> SoftSubSurfacePairScore
        """
        this = _IMP_core.new_SoftSubSurfacePairScore(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

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


    def get_version_info(self):
        """get_version_info(SoftSubSurfacePairScore self) -> VersionInfo"""
        return _IMP_core.SoftSubSurfacePairScore_get_version_info(self)


    def __str__(self):
        """__str__(SoftSubSurfacePairScore self) -> std::string"""
        return _IMP_core.SoftSubSurfacePairScore___str__(self)


    def __repr__(self):
        """__repr__(SoftSubSurfacePairScore self) -> std::string"""
        return _IMP_core.SoftSubSurfacePairScore___repr__(self)


    @staticmethod
    def get_from(o):
       return _object_cast_to_SoftSubSurfacePairScore(o)

SoftSubSurfacePairScore_swigregister = _IMP_core.SoftSubSurfacePairScore_swigregister
SoftSubSurfacePairScore_swigregister(SoftSubSurfacePairScore)

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

    def __init__(self, link_num, link_length):
        """__init__(IMP::core::SurfaceTetheredChain self, int link_num, double link_length) -> SurfaceTetheredChain"""
        this = _IMP_core.new_SurfaceTetheredChain(link_num, link_length)
        try:
            self.this.append(this)
        except:
            self.this = this

    def get_version_info(self):
        """get_version_info(SurfaceTetheredChain self) -> VersionInfo"""
        return _IMP_core.SurfaceTetheredChain_get_version_info(self)


    def get_link_number(self):
        """get_link_number(SurfaceTetheredChain self) -> int"""
        return _IMP_core.SurfaceTetheredChain_get_link_number(self)


    def get_link_length(self):
        """get_link_length(SurfaceTetheredChain self) -> double"""
        return _IMP_core.SurfaceTetheredChain_get_link_length(self)


    def set_link_number(self, N):
        """set_link_number(SurfaceTetheredChain self, int N)"""
        return _IMP_core.SurfaceTetheredChain_set_link_number(self, N)


    def set_link_length(self, b):
        """set_link_length(SurfaceTetheredChain self, double b)"""
        return _IMP_core.SurfaceTetheredChain_set_link_length(self, b)


    def get_distance_at_minimum(self):
        """get_distance_at_minimum(SurfaceTetheredChain self) -> double"""
        return _IMP_core.SurfaceTetheredChain_get_distance_at_minimum(self)


    def get_average_distance(self):
        """get_average_distance(SurfaceTetheredChain self) -> double"""
        return _IMP_core.SurfaceTetheredChain_get_average_distance(self)


    def __str__(self):
        """__str__(SurfaceTetheredChain self) -> std::string"""
        return _IMP_core.SurfaceTetheredChain___str__(self)


    def __repr__(self):
        """__repr__(SurfaceTetheredChain self) -> std::string"""
        return _IMP_core.SurfaceTetheredChain___repr__(self)


    @staticmethod
    def get_from(o):
       return _object_cast_to_SurfaceTetheredChain(o)

SurfaceTetheredChain_swigregister = _IMP_core.SurfaceTetheredChain_swigregister
SurfaceTetheredChain_swigregister(SurfaceTetheredChain)

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

    def __init__(self, m, ss, rbs):
        """__init__(IMP::core::SurfaceSymmetryConstraint self, Model m, IMP::ParticleIndexPair const & ss, IMP::ParticleIndexPair const & rbs) -> SurfaceSymmetryConstraint"""
        this = _IMP_core.new_SurfaceSymmetryConstraint(m, ss, rbs)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self):
        """do_get_inputs(SurfaceSymmetryConstraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_core.SurfaceSymmetryConstraint_do_get_inputs(self)


    def do_get_outputs(self):
        """do_get_outputs(SurfaceSymmetryConstraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_core.SurfaceSymmetryConstraint_do_get_outputs(self)


    def get_version_info(self):
        """get_version_info(SurfaceSymmetryConstraint self) -> VersionInfo"""
        return _IMP_core.SurfaceSymmetryConstraint_get_version_info(self)


    def __str__(self):
        """__str__(SurfaceSymmetryConstraint self) -> std::string"""
        return _IMP_core.SurfaceSymmetryConstraint___str__(self)


    def __repr__(self):
        """__repr__(SurfaceSymmetryConstraint self) -> std::string"""
        return _IMP_core.SurfaceSymmetryConstraint___repr__(self)


    @staticmethod
    def get_from(o):
       return _object_cast_to_SurfaceSymmetryConstraint(o)

SurfaceSymmetryConstraint_swigregister = _IMP_core.SurfaceSymmetryConstraint_swigregister
SurfaceSymmetryConstraint_swigregister(SurfaceSymmetryConstraint)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_SteepestDescent(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_TransformedDistancePairScore(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_TypedPairScore(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_RigidBodyDistancePairScore(o)

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


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

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_TableRefiner(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_MCCGSampler(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_MinimumRestraint(o)

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) -> 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) -> 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_gaussian(self, g):
        """set_gaussian(Gaussian self, Gaussian3D g)"""
        return _IMP_core.Gaussian_set_gaussian(self, g)


    def set_local_covariance(self, covar):
        """set_local_covariance(Gaussian self, 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, 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, FloatsKey a0, IMP::Floats a1)
        add_attribute(Gaussian self, IntsKey a0, IMP::Ints 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, FloatsKey a0) -> IMP::Floats
        get_value(Gaussian self, IntsKey a0) -> IMP::Ints
        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, FloatsKey a0, IMP::Floats a1)
        set_value(Gaussian self, IntsKey a0, IMP::Ints 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, FloatsKey a0)
        remove_attribute(Gaussian self, IntsKey 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, FloatsKey a0) -> bool
        has_attribute(Gaussian self, IntsKey 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
        """
        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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_PairRestraint(o)

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


    @staticmethod
    def get_from(o):
       return _object_cast_to_SingletonRestraint(o)

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


    @staticmethod
    def get_from(o):
       return _object_cast_to_TripletRestraint(o)

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


    @staticmethod
    def get_from(o):
       return _object_cast_to_QuadRestraint(o)

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, bool can_skip=False) -> 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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_SingletonConstraint(o)

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, bool can_skip=False) -> 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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_PairConstraint(o)

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, bool can_skip=False) -> 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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_TripletConstraint(o)

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, bool can_skip=False) -> 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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_QuadConstraint(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_ConstantSingletonPredicate(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_UnorderedTypeSingletonPredicate(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_OrderedTypeSingletonPredicate(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_AllSameSingletonPredicate(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_CoinFlipSingletonPredicate(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_ConstantPairPredicate(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_UnorderedTypePairPredicate(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_OrderedTypePairPredicate(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_AllSamePairPredicate(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_CoinFlipPairPredicate(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_ConstantTripletPredicate(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_UnorderedTypeTripletPredicate(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_OrderedTypeTripletPredicate(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_AllSameTripletPredicate(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_CoinFlipTripletPredicate(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_ConstantQuadPredicate(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_UnorderedTypeQuadPredicate(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_OrderedTypeQuadPredicate(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_AllSameQuadPredicate(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_CoinFlipQuadPredicate(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_InBoundingBox3DSingletonPredicate(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_AttributeSingletonPredicate(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_IsCollisionPairPredicate(o)

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, m, score_func, p1, p2, p3):
        """__init__(IMP::core::AngleRestraint self, Model m, UnaryFunction score_func, _ParticleIndexAdaptor p1, _ParticleIndexAdaptor p2, _ParticleIndexAdaptor p3) -> AngleRestraint"""
        this = _IMP_core.new_AngleRestraint(m, score_func, p1, p2, p3)
        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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_AngleRestraint(o)

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, m, pi, max_translation, max_rotation):
        """__init__(IMP::core::RigidBodyMover self, Model m, ParticleIndex pi, IMP::Float max_translation, IMP::Float max_rotation) -> RigidBodyMover"""
        this = _IMP_core.new_RigidBodyMover(m, pi, max_translation, max_rotation)
        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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_RigidBodyMover(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_RigidBodyTunneler(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_RigidBodyUmbrella(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_VolumeRestraint(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_MoveStatisticsScoreState(o)

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 set_type(self, pt):
        """set_type(Typed self, ParticleType pt)"""
        return _IMP_core.Typed_set_type(self, pt)


    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, FloatsKey a0, IMP::Floats a1)
        add_attribute(Typed self, IntsKey a0, IMP::Ints 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, FloatsKey a0) -> IMP::Floats
        get_value(Typed self, IntsKey a0) -> IMP::Ints
        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, FloatsKey a0, IMP::Floats a1)
        set_value(Typed self, IntsKey a0, IMP::Ints 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, FloatsKey a0)
        remove_attribute(Typed self, IntsKey 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, FloatsKey a0) -> bool
        has_attribute(Typed self, IntsKey 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, Direction n) -> _ostream
    __lshift__(_ostream out, DirectionAngle n) -> _ostream
    __lshift__(_ostream out, Surface 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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_WriteRestraintScoresOptimizerState(o)

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

    def __init__(self, m, q1, q2):
        """__init__(IMP::core::MultipleBinormalRestraint self, Model m, IMP::ParticleIndexQuad const & q1, IMP::ParticleIndexQuad const & q2) -> MultipleBinormalRestraint"""
        this = _IMP_core.new_MultipleBinormalRestraint(m, q1, q2)
        try:
            self.this.append(this)
        except:
            self.this = this

    def add_term(self, term):
        """add_term(MultipleBinormalRestraint self, BinormalTerm term)"""
        return _IMP_core.MultipleBinormalRestraint_add_term(self, term)


    def do_get_inputs(self):
        """do_get_inputs(MultipleBinormalRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_core.MultipleBinormalRestraint_do_get_inputs(self)


    def get_version_info(self):
        """get_version_info(MultipleBinormalRestraint self) -> VersionInfo"""
        return _IMP_core.MultipleBinormalRestraint_get_version_info(self)


    def __str__(self):
        """__str__(MultipleBinormalRestraint self) -> std::string"""
        return _IMP_core.MultipleBinormalRestraint___str__(self)


    def __repr__(self):
        """__repr__(MultipleBinormalRestraint self) -> std::string"""
        return _IMP_core.MultipleBinormalRestraint___repr__(self)


    @staticmethod
    def get_from(o):
       return _object_cast_to_MultipleBinormalRestraint(o)

MultipleBinormalRestraint_swigregister = _IMP_core.MultipleBinormalRestraint_swigregister
MultipleBinormalRestraint_swigregister(MultipleBinormalRestraint)

class BinormalTerm(object):
    """Proxy of C++ IMP::core::BinormalTerm 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::BinormalTerm self) -> BinormalTerm"""
        this = _IMP_core.new_BinormalTerm()
        try:
            self.this.append(this)
        except:
            self.this = this

    def set_correlation(self, correlation):
        """set_correlation(BinormalTerm self, double correlation)"""
        return _IMP_core.BinormalTerm_set_correlation(self, correlation)


    def set_weight(self, weight):
        """set_weight(BinormalTerm self, double weight)"""
        return _IMP_core.BinormalTerm_set_weight(self, weight)


    def set_means(self, means):
        """set_means(BinormalTerm self, IMP::FloatPair means)"""
        return _IMP_core.BinormalTerm_set_means(self, means)


    def set_standard_deviations(self, stdevs):
        """set_standard_deviations(BinormalTerm self, IMP::FloatPair stdevs)"""
        return _IMP_core.BinormalTerm_set_standard_deviations(self, stdevs)


    def show(self, *args):
        """
        show(BinormalTerm self, _ostream out)
        show(BinormalTerm self)
        """
        return _IMP_core.BinormalTerm_show(self, *args)


    def __str__(self):
        """__str__(BinormalTerm self) -> std::string"""
        return _IMP_core.BinormalTerm___str__(self)


    def __repr__(self):
        """__repr__(BinormalTerm self) -> std::string"""
        return _IMP_core.BinormalTerm___repr__(self)

    __swig_destroy__ = _IMP_core.delete_BinormalTerm
    __del__ = lambda self: None
BinormalTerm_swigregister = _IMP_core.BinormalTerm_swigregister
BinormalTerm_swigregister(BinormalTerm)

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

    def get_previous(self):
        """get_previous(Provenance self) -> Provenance"""
        return _IMP_core.Provenance_get_previous(self)


    def set_previous(self, p):
        """set_previous(Provenance self, Provenance p)"""
        return _IMP_core.Provenance_set_previous(self, p)


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

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

    get_is_setup = staticmethod(get_is_setup)

    def show(self, *args):
        """
        show(Provenance self, _ostream out)
        show(Provenance self)
        """
        return _IMP_core.Provenance_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi) -> Provenance
        setup_particle(_ParticleAdaptor decorator) -> Provenance
        """
        return _IMP_core.Provenance_setup_particle(*args)

    setup_particle = staticmethod(setup_particle)

    def add_attribute(self, *args):
        """
        add_attribute(Provenance self, FloatKey k, IMP::Float v, bool opt)
        add_attribute(Provenance self, FloatKey a0, IMP::Float a1)
        add_attribute(Provenance self, IntKey a0, IMP::Int a1)
        add_attribute(Provenance self, FloatsKey a0, IMP::Floats a1)
        add_attribute(Provenance self, IntsKey a0, IMP::Ints a1)
        add_attribute(Provenance self, StringKey a0, IMP::String a1)
        add_attribute(Provenance self, ParticleIndexKey a0, Particle a1)
        add_attribute(Provenance self, ObjectKey a0, Object a1)
        """
        return _IMP_core.Provenance_add_attribute(self, *args)


    def get_value(self, *args):
        """
        get_value(Provenance self, FloatKey a0) -> IMP::Float
        get_value(Provenance self, IntKey a0) -> IMP::Int
        get_value(Provenance self, FloatsKey a0) -> IMP::Floats
        get_value(Provenance self, IntsKey a0) -> IMP::Ints
        get_value(Provenance self, StringKey a0) -> IMP::String
        get_value(Provenance self, ParticleIndexKey a0) -> Particle
        get_value(Provenance self, ObjectKey a0) -> Object
        """
        return _IMP_core.Provenance_get_value(self, *args)


    def set_value(self, *args):
        """
        set_value(Provenance self, FloatKey a0, IMP::Float a1)
        set_value(Provenance self, IntKey a0, IMP::Int a1)
        set_value(Provenance self, FloatsKey a0, IMP::Floats a1)
        set_value(Provenance self, IntsKey a0, IMP::Ints a1)
        set_value(Provenance self, StringKey a0, IMP::String a1)
        set_value(Provenance self, ParticleIndexKey a0, Particle a1)
        set_value(Provenance self, ObjectKey a0, Object a1)
        """
        return _IMP_core.Provenance_set_value(self, *args)


    def remove_attribute(self, *args):
        """
        remove_attribute(Provenance self, FloatKey a0)
        remove_attribute(Provenance self, IntKey a0)
        remove_attribute(Provenance self, FloatsKey a0)
        remove_attribute(Provenance self, IntsKey a0)
        remove_attribute(Provenance self, StringKey a0)
        remove_attribute(Provenance self, ParticleIndexKey a0)
        remove_attribute(Provenance self, ObjectKey a0)
        """
        return _IMP_core.Provenance_remove_attribute(self, *args)


    def has_attribute(self, *args):
        """
        has_attribute(Provenance self, FloatKey a0) -> bool
        has_attribute(Provenance self, IntKey a0) -> bool
        has_attribute(Provenance self, FloatsKey a0) -> bool
        has_attribute(Provenance self, IntsKey a0) -> bool
        has_attribute(Provenance self, StringKey a0) -> bool
        has_attribute(Provenance self, ParticleIndexKey a0) -> bool
        has_attribute(Provenance self, ObjectKey a0) -> bool
        """
        return _IMP_core.Provenance_has_attribute(self, *args)


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


    def get_name(self):
        """get_name(Provenance self) -> std::string"""
        return _IMP_core.Provenance_get_name(self)


    def clear_caches(self):
        """clear_caches(Provenance self)"""
        return _IMP_core.Provenance_clear_caches(self)


    def set_name(self, a0):
        """set_name(Provenance self, std::string a0)"""
        return _IMP_core.Provenance_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(Provenance self, IMP::CheckLevel a0)"""
        return _IMP_core.Provenance_set_check_level(self, a0)


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


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(Provenance self, FloatKey a0, bool a1)"""
        return _IMP_core.Provenance_set_is_optimized(self, a0, a1)


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


    def get_check_level(self):
        """get_check_level(Provenance self) -> IMP::CheckLevel"""
        return _IMP_core.Provenance_get_check_level(self)


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


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


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


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


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


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


    def __hash__(self):
        """__hash__(Provenance self) -> std::size_t"""
        return _IMP_core.Provenance___hash__(self)


    def __str__(self):
        """__str__(Provenance self) -> std::string"""
        return _IMP_core.Provenance___str__(self)


    def __repr__(self):
        """__repr__(Provenance self) -> std::string"""
        return _IMP_core.Provenance___repr__(self)

    __swig_destroy__ = _IMP_core.delete_Provenance
    __del__ = lambda self: None
Provenance_swigregister = _IMP_core.Provenance_swigregister
Provenance_swigregister(Provenance)

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

def Provenance_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi) -> Provenance
    Provenance_setup_particle(_ParticleAdaptor decorator) -> Provenance
    """
    return _IMP_core.Provenance_setup_particle(*args)

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

    def set_filename(self, filename):
        """set_filename(StructureProvenance self, std::string filename)"""
        return _IMP_core.StructureProvenance_set_filename(self, filename)


    def get_filename(self):
        """get_filename(StructureProvenance self) -> std::string"""
        return _IMP_core.StructureProvenance_get_filename(self)


    def set_chain_id(self, chain_id):
        """set_chain_id(StructureProvenance self, std::string chain_id)"""
        return _IMP_core.StructureProvenance_set_chain_id(self, chain_id)


    def get_chain_id(self):
        """get_chain_id(StructureProvenance self) -> std::string"""
        return _IMP_core.StructureProvenance_get_chain_id(self)


    def set_residue_offset(self, residue_offset):
        """set_residue_offset(StructureProvenance self, int residue_offset)"""
        return _IMP_core.StructureProvenance_set_residue_offset(self, residue_offset)


    def get_residue_offset(self):
        """get_residue_offset(StructureProvenance self) -> int"""
        return _IMP_core.StructureProvenance_get_residue_offset(self)


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

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

    get_is_setup = staticmethod(get_is_setup)

    def show(self, *args):
        """
        show(StructureProvenance self, _ostream out)
        show(StructureProvenance self)
        """
        return _IMP_core.StructureProvenance_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi, std::string filename, std::string chain_id, int residue_offset) -> StructureProvenance
        setup_particle(_ParticleAdaptor decorator, std::string filename, std::string chain_id, int residue_offset) -> StructureProvenance
        setup_particle(Model m, ParticleIndex pi, std::string filename, std::string chain_id) -> StructureProvenance
        setup_particle(_ParticleAdaptor decorator, std::string filename, std::string chain_id) -> StructureProvenance
        setup_particle(Model m, ParticleIndex pi, StructureProvenance o) -> StructureProvenance
        setup_particle(_ParticleAdaptor decorator, StructureProvenance o) -> StructureProvenance
        """
        return _IMP_core.StructureProvenance_setup_particle(*args)

    setup_particle = staticmethod(setup_particle)

    def add_attribute(self, *args):
        """
        add_attribute(StructureProvenance self, FloatKey k, IMP::Float v, bool opt)
        add_attribute(StructureProvenance self, FloatKey a0, IMP::Float a1)
        add_attribute(StructureProvenance self, IntKey a0, IMP::Int a1)
        add_attribute(StructureProvenance self, FloatsKey a0, IMP::Floats a1)
        add_attribute(StructureProvenance self, IntsKey a0, IMP::Ints a1)
        add_attribute(StructureProvenance self, StringKey a0, IMP::String a1)
        add_attribute(StructureProvenance self, ParticleIndexKey a0, Particle a1)
        add_attribute(StructureProvenance self, ObjectKey a0, Object a1)
        """
        return _IMP_core.StructureProvenance_add_attribute(self, *args)


    def get_value(self, *args):
        """
        get_value(StructureProvenance self, FloatKey a0) -> IMP::Float
        get_value(StructureProvenance self, IntKey a0) -> IMP::Int
        get_value(StructureProvenance self, FloatsKey a0) -> IMP::Floats
        get_value(StructureProvenance self, IntsKey a0) -> IMP::Ints
        get_value(StructureProvenance self, StringKey a0) -> IMP::String
        get_value(StructureProvenance self, ParticleIndexKey a0) -> Particle
        get_value(StructureProvenance self, ObjectKey a0) -> Object
        """
        return _IMP_core.StructureProvenance_get_value(self, *args)


    def set_value(self, *args):
        """
        set_value(StructureProvenance self, FloatKey a0, IMP::Float a1)
        set_value(StructureProvenance self, IntKey a0, IMP::Int a1)
        set_value(StructureProvenance self, FloatsKey a0, IMP::Floats a1)
        set_value(StructureProvenance self, IntsKey a0, IMP::Ints a1)
        set_value(StructureProvenance self, StringKey a0, IMP::String a1)
        set_value(StructureProvenance self, ParticleIndexKey a0, Particle a1)
        set_value(StructureProvenance self, ObjectKey a0, Object a1)
        """
        return _IMP_core.StructureProvenance_set_value(self, *args)


    def remove_attribute(self, *args):
        """
        remove_attribute(StructureProvenance self, FloatKey a0)
        remove_attribute(StructureProvenance self, IntKey a0)
        remove_attribute(StructureProvenance self, FloatsKey a0)
        remove_attribute(StructureProvenance self, IntsKey a0)
        remove_attribute(StructureProvenance self, StringKey a0)
        remove_attribute(StructureProvenance self, ParticleIndexKey a0)
        remove_attribute(StructureProvenance self, ObjectKey a0)
        """
        return _IMP_core.StructureProvenance_remove_attribute(self, *args)


    def has_attribute(self, *args):
        """
        has_attribute(StructureProvenance self, FloatKey a0) -> bool
        has_attribute(StructureProvenance self, IntKey a0) -> bool
        has_attribute(StructureProvenance self, FloatsKey a0) -> bool
        has_attribute(StructureProvenance self, IntsKey a0) -> bool
        has_attribute(StructureProvenance self, StringKey a0) -> bool
        has_attribute(StructureProvenance self, ParticleIndexKey a0) -> bool
        has_attribute(StructureProvenance self, ObjectKey a0) -> bool
        """
        return _IMP_core.StructureProvenance_has_attribute(self, *args)


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


    def get_name(self):
        """get_name(StructureProvenance self) -> std::string"""
        return _IMP_core.StructureProvenance_get_name(self)


    def clear_caches(self):
        """clear_caches(StructureProvenance self)"""
        return _IMP_core.StructureProvenance_clear_caches(self)


    def set_name(self, a0):
        """set_name(StructureProvenance self, std::string a0)"""
        return _IMP_core.StructureProvenance_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(StructureProvenance self, IMP::CheckLevel a0)"""
        return _IMP_core.StructureProvenance_set_check_level(self, a0)


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


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(StructureProvenance self, FloatKey a0, bool a1)"""
        return _IMP_core.StructureProvenance_set_is_optimized(self, a0, a1)


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


    def get_check_level(self):
        """get_check_level(StructureProvenance self) -> IMP::CheckLevel"""
        return _IMP_core.StructureProvenance_get_check_level(self)


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


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


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


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


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


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


    def __hash__(self):
        """__hash__(StructureProvenance self) -> std::size_t"""
        return _IMP_core.StructureProvenance___hash__(self)


    def __str__(self):
        """__str__(StructureProvenance self) -> std::string"""
        return _IMP_core.StructureProvenance___str__(self)


    def __repr__(self):
        """__repr__(StructureProvenance self) -> std::string"""
        return _IMP_core.StructureProvenance___repr__(self)

    __swig_destroy__ = _IMP_core.delete_StructureProvenance
    __del__ = lambda self: None
StructureProvenance_swigregister = _IMP_core.StructureProvenance_swigregister
StructureProvenance_swigregister(StructureProvenance)

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

def StructureProvenance_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi, std::string filename, std::string chain_id, int residue_offset) -> StructureProvenance
    setup_particle(_ParticleAdaptor decorator, std::string filename, std::string chain_id, int residue_offset) -> StructureProvenance
    setup_particle(Model m, ParticleIndex pi, std::string filename, std::string chain_id) -> StructureProvenance
    setup_particle(_ParticleAdaptor decorator, std::string filename, std::string chain_id) -> StructureProvenance
    setup_particle(Model m, ParticleIndex pi, StructureProvenance o) -> StructureProvenance
    StructureProvenance_setup_particle(_ParticleAdaptor decorator, StructureProvenance o) -> StructureProvenance
    """
    return _IMP_core.StructureProvenance_setup_particle(*args)

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

    def set_method(self, method):
        """set_method(SampleProvenance self, std::string method)"""
        return _IMP_core.SampleProvenance_set_method(self, method)


    def get_method(self):
        """get_method(SampleProvenance self) -> std::string"""
        return _IMP_core.SampleProvenance_get_method(self)


    def set_number_of_frames(self, frames):
        """set_number_of_frames(SampleProvenance self, int frames)"""
        return _IMP_core.SampleProvenance_set_number_of_frames(self, frames)


    def get_number_of_frames(self):
        """get_number_of_frames(SampleProvenance self) -> int"""
        return _IMP_core.SampleProvenance_get_number_of_frames(self)


    def set_number_of_iterations(self, iterations):
        """set_number_of_iterations(SampleProvenance self, int iterations)"""
        return _IMP_core.SampleProvenance_set_number_of_iterations(self, iterations)


    def get_number_of_iterations(self):
        """get_number_of_iterations(SampleProvenance self) -> int"""
        return _IMP_core.SampleProvenance_get_number_of_iterations(self)


    def set_number_of_replicas(self, replicas):
        """set_number_of_replicas(SampleProvenance self, int replicas)"""
        return _IMP_core.SampleProvenance_set_number_of_replicas(self, replicas)


    def get_number_of_replicas(self):
        """get_number_of_replicas(SampleProvenance self) -> int"""
        return _IMP_core.SampleProvenance_get_number_of_replicas(self)


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

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

    get_is_setup = staticmethod(get_is_setup)

    def show(self, *args):
        """
        show(SampleProvenance self, _ostream out)
        show(SampleProvenance self)
        """
        return _IMP_core.SampleProvenance_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi, std::string method, int frames, int iterations, int replicas) -> SampleProvenance
        setup_particle(_ParticleAdaptor decorator, std::string method, int frames, int iterations, int replicas) -> SampleProvenance
        setup_particle(Model m, ParticleIndex pi, std::string method, int frames, int iterations) -> SampleProvenance
        setup_particle(_ParticleAdaptor decorator, std::string method, int frames, int iterations) -> SampleProvenance
        setup_particle(Model m, ParticleIndex pi, SampleProvenance o) -> SampleProvenance
        setup_particle(_ParticleAdaptor decorator, SampleProvenance o) -> SampleProvenance
        """
        return _IMP_core.SampleProvenance_setup_particle(*args)

    setup_particle = staticmethod(setup_particle)

    def add_attribute(self, *args):
        """
        add_attribute(SampleProvenance self, FloatKey k, IMP::Float v, bool opt)
        add_attribute(SampleProvenance self, FloatKey a0, IMP::Float a1)
        add_attribute(SampleProvenance self, IntKey a0, IMP::Int a1)
        add_attribute(SampleProvenance self, FloatsKey a0, IMP::Floats a1)
        add_attribute(SampleProvenance self, IntsKey a0, IMP::Ints a1)
        add_attribute(SampleProvenance self, StringKey a0, IMP::String a1)
        add_attribute(SampleProvenance self, ParticleIndexKey a0, Particle a1)
        add_attribute(SampleProvenance self, ObjectKey a0, Object a1)
        """
        return _IMP_core.SampleProvenance_add_attribute(self, *args)


    def get_value(self, *args):
        """
        get_value(SampleProvenance self, FloatKey a0) -> IMP::Float
        get_value(SampleProvenance self, IntKey a0) -> IMP::Int
        get_value(SampleProvenance self, FloatsKey a0) -> IMP::Floats
        get_value(SampleProvenance self, IntsKey a0) -> IMP::Ints
        get_value(SampleProvenance self, StringKey a0) -> IMP::String
        get_value(SampleProvenance self, ParticleIndexKey a0) -> Particle
        get_value(SampleProvenance self, ObjectKey a0) -> Object
        """
        return _IMP_core.SampleProvenance_get_value(self, *args)


    def set_value(self, *args):
        """
        set_value(SampleProvenance self, FloatKey a0, IMP::Float a1)
        set_value(SampleProvenance self, IntKey a0, IMP::Int a1)
        set_value(SampleProvenance self, FloatsKey a0, IMP::Floats a1)
        set_value(SampleProvenance self, IntsKey a0, IMP::Ints a1)
        set_value(SampleProvenance self, StringKey a0, IMP::String a1)
        set_value(SampleProvenance self, ParticleIndexKey a0, Particle a1)
        set_value(SampleProvenance self, ObjectKey a0, Object a1)
        """
        return _IMP_core.SampleProvenance_set_value(self, *args)


    def remove_attribute(self, *args):
        """
        remove_attribute(SampleProvenance self, FloatKey a0)
        remove_attribute(SampleProvenance self, IntKey a0)
        remove_attribute(SampleProvenance self, FloatsKey a0)
        remove_attribute(SampleProvenance self, IntsKey a0)
        remove_attribute(SampleProvenance self, StringKey a0)
        remove_attribute(SampleProvenance self, ParticleIndexKey a0)
        remove_attribute(SampleProvenance self, ObjectKey a0)
        """
        return _IMP_core.SampleProvenance_remove_attribute(self, *args)


    def has_attribute(self, *args):
        """
        has_attribute(SampleProvenance self, FloatKey a0) -> bool
        has_attribute(SampleProvenance self, IntKey a0) -> bool
        has_attribute(SampleProvenance self, FloatsKey a0) -> bool
        has_attribute(SampleProvenance self, IntsKey a0) -> bool
        has_attribute(SampleProvenance self, StringKey a0) -> bool
        has_attribute(SampleProvenance self, ParticleIndexKey a0) -> bool
        has_attribute(SampleProvenance self, ObjectKey a0) -> bool
        """
        return _IMP_core.SampleProvenance_has_attribute(self, *args)


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


    def get_name(self):
        """get_name(SampleProvenance self) -> std::string"""
        return _IMP_core.SampleProvenance_get_name(self)


    def clear_caches(self):
        """clear_caches(SampleProvenance self)"""
        return _IMP_core.SampleProvenance_clear_caches(self)


    def set_name(self, a0):
        """set_name(SampleProvenance self, std::string a0)"""
        return _IMP_core.SampleProvenance_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(SampleProvenance self, IMP::CheckLevel a0)"""
        return _IMP_core.SampleProvenance_set_check_level(self, a0)


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


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(SampleProvenance self, FloatKey a0, bool a1)"""
        return _IMP_core.SampleProvenance_set_is_optimized(self, a0, a1)


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


    def get_check_level(self):
        """get_check_level(SampleProvenance self) -> IMP::CheckLevel"""
        return _IMP_core.SampleProvenance_get_check_level(self)


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


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


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


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


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


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


    def __hash__(self):
        """__hash__(SampleProvenance self) -> std::size_t"""
        return _IMP_core.SampleProvenance___hash__(self)


    def __str__(self):
        """__str__(SampleProvenance self) -> std::string"""
        return _IMP_core.SampleProvenance___str__(self)


    def __repr__(self):
        """__repr__(SampleProvenance self) -> std::string"""
        return _IMP_core.SampleProvenance___repr__(self)

    __swig_destroy__ = _IMP_core.delete_SampleProvenance
    __del__ = lambda self: None
SampleProvenance_swigregister = _IMP_core.SampleProvenance_swigregister
SampleProvenance_swigregister(SampleProvenance)

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

def SampleProvenance_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi, std::string method, int frames, int iterations, int replicas) -> SampleProvenance
    setup_particle(_ParticleAdaptor decorator, std::string method, int frames, int iterations, int replicas) -> SampleProvenance
    setup_particle(Model m, ParticleIndex pi, std::string method, int frames, int iterations) -> SampleProvenance
    setup_particle(_ParticleAdaptor decorator, std::string method, int frames, int iterations) -> SampleProvenance
    setup_particle(Model m, ParticleIndex pi, SampleProvenance o) -> SampleProvenance
    SampleProvenance_setup_particle(_ParticleAdaptor decorator, SampleProvenance o) -> SampleProvenance
    """
    return _IMP_core.SampleProvenance_setup_particle(*args)

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

    def set_number_of_frames(self, frames):
        """set_number_of_frames(CombineProvenance self, int frames)"""
        return _IMP_core.CombineProvenance_set_number_of_frames(self, frames)


    def get_number_of_frames(self):
        """get_number_of_frames(CombineProvenance self) -> int"""
        return _IMP_core.CombineProvenance_get_number_of_frames(self)


    def set_number_of_runs(self, runs):
        """set_number_of_runs(CombineProvenance self, int runs)"""
        return _IMP_core.CombineProvenance_set_number_of_runs(self, runs)


    def get_number_of_runs(self):
        """get_number_of_runs(CombineProvenance self) -> int"""
        return _IMP_core.CombineProvenance_get_number_of_runs(self)


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

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

    get_is_setup = staticmethod(get_is_setup)

    def show(self, *args):
        """
        show(CombineProvenance self, _ostream out)
        show(CombineProvenance self)
        """
        return _IMP_core.CombineProvenance_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi, int runs, int frames) -> CombineProvenance
        setup_particle(_ParticleAdaptor decorator, int runs, int frames) -> CombineProvenance
        setup_particle(Model m, ParticleIndex pi, CombineProvenance o) -> CombineProvenance
        setup_particle(_ParticleAdaptor decorator, CombineProvenance o) -> CombineProvenance
        """
        return _IMP_core.CombineProvenance_setup_particle(*args)

    setup_particle = staticmethod(setup_particle)

    def add_attribute(self, *args):
        """
        add_attribute(CombineProvenance self, FloatKey k, IMP::Float v, bool opt)
        add_attribute(CombineProvenance self, FloatKey a0, IMP::Float a1)
        add_attribute(CombineProvenance self, IntKey a0, IMP::Int a1)
        add_attribute(CombineProvenance self, FloatsKey a0, IMP::Floats a1)
        add_attribute(CombineProvenance self, IntsKey a0, IMP::Ints a1)
        add_attribute(CombineProvenance self, StringKey a0, IMP::String a1)
        add_attribute(CombineProvenance self, ParticleIndexKey a0, Particle a1)
        add_attribute(CombineProvenance self, ObjectKey a0, Object a1)
        """
        return _IMP_core.CombineProvenance_add_attribute(self, *args)


    def get_value(self, *args):
        """
        get_value(CombineProvenance self, FloatKey a0) -> IMP::Float
        get_value(CombineProvenance self, IntKey a0) -> IMP::Int
        get_value(CombineProvenance self, FloatsKey a0) -> IMP::Floats
        get_value(CombineProvenance self, IntsKey a0) -> IMP::Ints
        get_value(CombineProvenance self, StringKey a0) -> IMP::String
        get_value(CombineProvenance self, ParticleIndexKey a0) -> Particle
        get_value(CombineProvenance self, ObjectKey a0) -> Object
        """
        return _IMP_core.CombineProvenance_get_value(self, *args)


    def set_value(self, *args):
        """
        set_value(CombineProvenance self, FloatKey a0, IMP::Float a1)
        set_value(CombineProvenance self, IntKey a0, IMP::Int a1)
        set_value(CombineProvenance self, FloatsKey a0, IMP::Floats a1)
        set_value(CombineProvenance self, IntsKey a0, IMP::Ints a1)
        set_value(CombineProvenance self, StringKey a0, IMP::String a1)
        set_value(CombineProvenance self, ParticleIndexKey a0, Particle a1)
        set_value(CombineProvenance self, ObjectKey a0, Object a1)
        """
        return _IMP_core.CombineProvenance_set_value(self, *args)


    def remove_attribute(self, *args):
        """
        remove_attribute(CombineProvenance self, FloatKey a0)
        remove_attribute(CombineProvenance self, IntKey a0)
        remove_attribute(CombineProvenance self, FloatsKey a0)
        remove_attribute(CombineProvenance self, IntsKey a0)
        remove_attribute(CombineProvenance self, StringKey a0)
        remove_attribute(CombineProvenance self, ParticleIndexKey a0)
        remove_attribute(CombineProvenance self, ObjectKey a0)
        """
        return _IMP_core.CombineProvenance_remove_attribute(self, *args)


    def has_attribute(self, *args):
        """
        has_attribute(CombineProvenance self, FloatKey a0) -> bool
        has_attribute(CombineProvenance self, IntKey a0) -> bool
        has_attribute(CombineProvenance self, FloatsKey a0) -> bool
        has_attribute(CombineProvenance self, IntsKey a0) -> bool
        has_attribute(CombineProvenance self, StringKey a0) -> bool
        has_attribute(CombineProvenance self, ParticleIndexKey a0) -> bool
        has_attribute(CombineProvenance self, ObjectKey a0) -> bool
        """
        return _IMP_core.CombineProvenance_has_attribute(self, *args)


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


    def get_name(self):
        """get_name(CombineProvenance self) -> std::string"""
        return _IMP_core.CombineProvenance_get_name(self)


    def clear_caches(self):
        """clear_caches(CombineProvenance self)"""
        return _IMP_core.CombineProvenance_clear_caches(self)


    def set_name(self, a0):
        """set_name(CombineProvenance self, std::string a0)"""
        return _IMP_core.CombineProvenance_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(CombineProvenance self, IMP::CheckLevel a0)"""
        return _IMP_core.CombineProvenance_set_check_level(self, a0)


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


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(CombineProvenance self, FloatKey a0, bool a1)"""
        return _IMP_core.CombineProvenance_set_is_optimized(self, a0, a1)


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


    def get_check_level(self):
        """get_check_level(CombineProvenance self) -> IMP::CheckLevel"""
        return _IMP_core.CombineProvenance_get_check_level(self)


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


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


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


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


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


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


    def __hash__(self):
        """__hash__(CombineProvenance self) -> std::size_t"""
        return _IMP_core.CombineProvenance___hash__(self)


    def __str__(self):
        """__str__(CombineProvenance self) -> std::string"""
        return _IMP_core.CombineProvenance___str__(self)


    def __repr__(self):
        """__repr__(CombineProvenance self) -> std::string"""
        return _IMP_core.CombineProvenance___repr__(self)

    __swig_destroy__ = _IMP_core.delete_CombineProvenance
    __del__ = lambda self: None
CombineProvenance_swigregister = _IMP_core.CombineProvenance_swigregister
CombineProvenance_swigregister(CombineProvenance)

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

def CombineProvenance_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi, int runs, int frames) -> CombineProvenance
    setup_particle(_ParticleAdaptor decorator, int runs, int frames) -> CombineProvenance
    setup_particle(Model m, ParticleIndex pi, CombineProvenance o) -> CombineProvenance
    CombineProvenance_setup_particle(_ParticleAdaptor decorator, CombineProvenance o) -> CombineProvenance
    """
    return _IMP_core.CombineProvenance_setup_particle(*args)

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

    def set_method(self, method):
        """set_method(FilterProvenance self, std::string method)"""
        return _IMP_core.FilterProvenance_set_method(self, method)


    def get_method(self):
        """get_method(FilterProvenance self) -> std::string"""
        return _IMP_core.FilterProvenance_get_method(self)


    def set_number_of_frames(self, frames):
        """set_number_of_frames(FilterProvenance self, int frames)"""
        return _IMP_core.FilterProvenance_set_number_of_frames(self, frames)


    def get_number_of_frames(self):
        """get_number_of_frames(FilterProvenance self) -> int"""
        return _IMP_core.FilterProvenance_get_number_of_frames(self)


    def set_threshold(self, threshold):
        """set_threshold(FilterProvenance self, double threshold)"""
        return _IMP_core.FilterProvenance_set_threshold(self, threshold)


    def get_threshold(self):
        """get_threshold(FilterProvenance self) -> double"""
        return _IMP_core.FilterProvenance_get_threshold(self)


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

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

    get_is_setup = staticmethod(get_is_setup)

    def show(self, *args):
        """
        show(FilterProvenance self, _ostream out)
        show(FilterProvenance self)
        """
        return _IMP_core.FilterProvenance_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi, std::string method, double threshold, int frames) -> FilterProvenance
        setup_particle(_ParticleAdaptor decorator, std::string method, double threshold, int frames) -> FilterProvenance
        setup_particle(Model m, ParticleIndex pi, FilterProvenance o) -> FilterProvenance
        setup_particle(_ParticleAdaptor decorator, FilterProvenance o) -> FilterProvenance
        """
        return _IMP_core.FilterProvenance_setup_particle(*args)

    setup_particle = staticmethod(setup_particle)

    def add_attribute(self, *args):
        """
        add_attribute(FilterProvenance self, FloatKey k, IMP::Float v, bool opt)
        add_attribute(FilterProvenance self, FloatKey a0, IMP::Float a1)
        add_attribute(FilterProvenance self, IntKey a0, IMP::Int a1)
        add_attribute(FilterProvenance self, FloatsKey a0, IMP::Floats a1)
        add_attribute(FilterProvenance self, IntsKey a0, IMP::Ints a1)
        add_attribute(FilterProvenance self, StringKey a0, IMP::String a1)
        add_attribute(FilterProvenance self, ParticleIndexKey a0, Particle a1)
        add_attribute(FilterProvenance self, ObjectKey a0, Object a1)
        """
        return _IMP_core.FilterProvenance_add_attribute(self, *args)


    def get_value(self, *args):
        """
        get_value(FilterProvenance self, FloatKey a0) -> IMP::Float
        get_value(FilterProvenance self, IntKey a0) -> IMP::Int
        get_value(FilterProvenance self, FloatsKey a0) -> IMP::Floats
        get_value(FilterProvenance self, IntsKey a0) -> IMP::Ints
        get_value(FilterProvenance self, StringKey a0) -> IMP::String
        get_value(FilterProvenance self, ParticleIndexKey a0) -> Particle
        get_value(FilterProvenance self, ObjectKey a0) -> Object
        """
        return _IMP_core.FilterProvenance_get_value(self, *args)


    def set_value(self, *args):
        """
        set_value(FilterProvenance self, FloatKey a0, IMP::Float a1)
        set_value(FilterProvenance self, IntKey a0, IMP::Int a1)
        set_value(FilterProvenance self, FloatsKey a0, IMP::Floats a1)
        set_value(FilterProvenance self, IntsKey a0, IMP::Ints a1)
        set_value(FilterProvenance self, StringKey a0, IMP::String a1)
        set_value(FilterProvenance self, ParticleIndexKey a0, Particle a1)
        set_value(FilterProvenance self, ObjectKey a0, Object a1)
        """
        return _IMP_core.FilterProvenance_set_value(self, *args)


    def remove_attribute(self, *args):
        """
        remove_attribute(FilterProvenance self, FloatKey a0)
        remove_attribute(FilterProvenance self, IntKey a0)
        remove_attribute(FilterProvenance self, FloatsKey a0)
        remove_attribute(FilterProvenance self, IntsKey a0)
        remove_attribute(FilterProvenance self, StringKey a0)
        remove_attribute(FilterProvenance self, ParticleIndexKey a0)
        remove_attribute(FilterProvenance self, ObjectKey a0)
        """
        return _IMP_core.FilterProvenance_remove_attribute(self, *args)


    def has_attribute(self, *args):
        """
        has_attribute(FilterProvenance self, FloatKey a0) -> bool
        has_attribute(FilterProvenance self, IntKey a0) -> bool
        has_attribute(FilterProvenance self, FloatsKey a0) -> bool
        has_attribute(FilterProvenance self, IntsKey a0) -> bool
        has_attribute(FilterProvenance self, StringKey a0) -> bool
        has_attribute(FilterProvenance self, ParticleIndexKey a0) -> bool
        has_attribute(FilterProvenance self, ObjectKey a0) -> bool
        """
        return _IMP_core.FilterProvenance_has_attribute(self, *args)


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


    def get_name(self):
        """get_name(FilterProvenance self) -> std::string"""
        return _IMP_core.FilterProvenance_get_name(self)


    def clear_caches(self):
        """clear_caches(FilterProvenance self)"""
        return _IMP_core.FilterProvenance_clear_caches(self)


    def set_name(self, a0):
        """set_name(FilterProvenance self, std::string a0)"""
        return _IMP_core.FilterProvenance_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(FilterProvenance self, IMP::CheckLevel a0)"""
        return _IMP_core.FilterProvenance_set_check_level(self, a0)


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


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(FilterProvenance self, FloatKey a0, bool a1)"""
        return _IMP_core.FilterProvenance_set_is_optimized(self, a0, a1)


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


    def get_check_level(self):
        """get_check_level(FilterProvenance self) -> IMP::CheckLevel"""
        return _IMP_core.FilterProvenance_get_check_level(self)


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


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


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


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


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


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


    def __hash__(self):
        """__hash__(FilterProvenance self) -> std::size_t"""
        return _IMP_core.FilterProvenance___hash__(self)


    def __str__(self):
        """__str__(FilterProvenance self) -> std::string"""
        return _IMP_core.FilterProvenance___str__(self)


    def __repr__(self):
        """__repr__(FilterProvenance self) -> std::string"""
        return _IMP_core.FilterProvenance___repr__(self)

    __swig_destroy__ = _IMP_core.delete_FilterProvenance
    __del__ = lambda self: None
FilterProvenance_swigregister = _IMP_core.FilterProvenance_swigregister
FilterProvenance_swigregister(FilterProvenance)

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

def FilterProvenance_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi, std::string method, double threshold, int frames) -> FilterProvenance
    setup_particle(_ParticleAdaptor decorator, std::string method, double threshold, int frames) -> FilterProvenance
    setup_particle(Model m, ParticleIndex pi, FilterProvenance o) -> FilterProvenance
    FilterProvenance_setup_particle(_ParticleAdaptor decorator, FilterProvenance o) -> FilterProvenance
    """
    return _IMP_core.FilterProvenance_setup_particle(*args)

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

    def set_number_of_members(self, members):
        """set_number_of_members(ClusterProvenance self, int members)"""
        return _IMP_core.ClusterProvenance_set_number_of_members(self, members)


    def get_number_of_members(self):
        """get_number_of_members(ClusterProvenance self) -> int"""
        return _IMP_core.ClusterProvenance_get_number_of_members(self)


    def set_precision(self, precision):
        """set_precision(ClusterProvenance self, double precision)"""
        return _IMP_core.ClusterProvenance_set_precision(self, precision)


    def get_precision(self):
        """get_precision(ClusterProvenance self) -> double"""
        return _IMP_core.ClusterProvenance_get_precision(self)


    def set_density(self, density):
        """set_density(ClusterProvenance self, std::string density)"""
        return _IMP_core.ClusterProvenance_set_density(self, density)


    def get_density(self):
        """get_density(ClusterProvenance self) -> std::string"""
        return _IMP_core.ClusterProvenance_get_density(self)


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

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

    get_is_setup = staticmethod(get_is_setup)

    def show(self, *args):
        """
        show(ClusterProvenance self, _ostream out)
        show(ClusterProvenance self)
        """
        return _IMP_core.ClusterProvenance_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi, int members) -> ClusterProvenance
        setup_particle(_ParticleAdaptor decorator, int members) -> ClusterProvenance
        setup_particle(Model m, ParticleIndex pi, int members, double precision) -> ClusterProvenance
        setup_particle(_ParticleAdaptor decorator, int members, double precision) -> ClusterProvenance
        setup_particle(Model m, ParticleIndex pi, int members, double precision, std::string density) -> ClusterProvenance
        setup_particle(_ParticleAdaptor decorator, int members, double precision, std::string density) -> ClusterProvenance
        setup_particle(Model m, ParticleIndex pi, ClusterProvenance o) -> ClusterProvenance
        setup_particle(_ParticleAdaptor decorator, ClusterProvenance o) -> ClusterProvenance
        """
        return _IMP_core.ClusterProvenance_setup_particle(*args)

    setup_particle = staticmethod(setup_particle)

    def add_attribute(self, *args):
        """
        add_attribute(ClusterProvenance self, FloatKey k, IMP::Float v, bool opt)
        add_attribute(ClusterProvenance self, FloatKey a0, IMP::Float a1)
        add_attribute(ClusterProvenance self, IntKey a0, IMP::Int a1)
        add_attribute(ClusterProvenance self, FloatsKey a0, IMP::Floats a1)
        add_attribute(ClusterProvenance self, IntsKey a0, IMP::Ints a1)
        add_attribute(ClusterProvenance self, StringKey a0, IMP::String a1)
        add_attribute(ClusterProvenance self, ParticleIndexKey a0, Particle a1)
        add_attribute(ClusterProvenance self, ObjectKey a0, Object a1)
        """
        return _IMP_core.ClusterProvenance_add_attribute(self, *args)


    def get_value(self, *args):
        """
        get_value(ClusterProvenance self, FloatKey a0) -> IMP::Float
        get_value(ClusterProvenance self, IntKey a0) -> IMP::Int
        get_value(ClusterProvenance self, FloatsKey a0) -> IMP::Floats
        get_value(ClusterProvenance self, IntsKey a0) -> IMP::Ints
        get_value(ClusterProvenance self, StringKey a0) -> IMP::String
        get_value(ClusterProvenance self, ParticleIndexKey a0) -> Particle
        get_value(ClusterProvenance self, ObjectKey a0) -> Object
        """
        return _IMP_core.ClusterProvenance_get_value(self, *args)


    def set_value(self, *args):
        """
        set_value(ClusterProvenance self, FloatKey a0, IMP::Float a1)
        set_value(ClusterProvenance self, IntKey a0, IMP::Int a1)
        set_value(ClusterProvenance self, FloatsKey a0, IMP::Floats a1)
        set_value(ClusterProvenance self, IntsKey a0, IMP::Ints a1)
        set_value(ClusterProvenance self, StringKey a0, IMP::String a1)
        set_value(ClusterProvenance self, ParticleIndexKey a0, Particle a1)
        set_value(ClusterProvenance self, ObjectKey a0, Object a1)
        """
        return _IMP_core.ClusterProvenance_set_value(self, *args)


    def remove_attribute(self, *args):
        """
        remove_attribute(ClusterProvenance self, FloatKey a0)
        remove_attribute(ClusterProvenance self, IntKey a0)
        remove_attribute(ClusterProvenance self, FloatsKey a0)
        remove_attribute(ClusterProvenance self, IntsKey a0)
        remove_attribute(ClusterProvenance self, StringKey a0)
        remove_attribute(ClusterProvenance self, ParticleIndexKey a0)
        remove_attribute(ClusterProvenance self, ObjectKey a0)
        """
        return _IMP_core.ClusterProvenance_remove_attribute(self, *args)


    def has_attribute(self, *args):
        """
        has_attribute(ClusterProvenance self, FloatKey a0) -> bool
        has_attribute(ClusterProvenance self, IntKey a0) -> bool
        has_attribute(ClusterProvenance self, FloatsKey a0) -> bool
        has_attribute(ClusterProvenance self, IntsKey a0) -> bool
        has_attribute(ClusterProvenance self, StringKey a0) -> bool
        has_attribute(ClusterProvenance self, ParticleIndexKey a0) -> bool
        has_attribute(ClusterProvenance self, ObjectKey a0) -> bool
        """
        return _IMP_core.ClusterProvenance_has_attribute(self, *args)


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


    def get_name(self):
        """get_name(ClusterProvenance self) -> std::string"""
        return _IMP_core.ClusterProvenance_get_name(self)


    def clear_caches(self):
        """clear_caches(ClusterProvenance self)"""
        return _IMP_core.ClusterProvenance_clear_caches(self)


    def set_name(self, a0):
        """set_name(ClusterProvenance self, std::string a0)"""
        return _IMP_core.ClusterProvenance_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(ClusterProvenance self, IMP::CheckLevel a0)"""
        return _IMP_core.ClusterProvenance_set_check_level(self, a0)


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


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(ClusterProvenance self, FloatKey a0, bool a1)"""
        return _IMP_core.ClusterProvenance_set_is_optimized(self, a0, a1)


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


    def get_check_level(self):
        """get_check_level(ClusterProvenance self) -> IMP::CheckLevel"""
        return _IMP_core.ClusterProvenance_get_check_level(self)


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


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


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


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


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


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


    def __hash__(self):
        """__hash__(ClusterProvenance self) -> std::size_t"""
        return _IMP_core.ClusterProvenance___hash__(self)


    def __str__(self):
        """__str__(ClusterProvenance self) -> std::string"""
        return _IMP_core.ClusterProvenance___str__(self)


    def __repr__(self):
        """__repr__(ClusterProvenance self) -> std::string"""
        return _IMP_core.ClusterProvenance___repr__(self)

    __swig_destroy__ = _IMP_core.delete_ClusterProvenance
    __del__ = lambda self: None
ClusterProvenance_swigregister = _IMP_core.ClusterProvenance_swigregister
ClusterProvenance_swigregister(ClusterProvenance)

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

def ClusterProvenance_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi, int members) -> ClusterProvenance
    setup_particle(_ParticleAdaptor decorator, int members) -> ClusterProvenance
    setup_particle(Model m, ParticleIndex pi, int members, double precision) -> ClusterProvenance
    setup_particle(_ParticleAdaptor decorator, int members, double precision) -> ClusterProvenance
    setup_particle(Model m, ParticleIndex pi, int members, double precision, std::string density) -> ClusterProvenance
    setup_particle(_ParticleAdaptor decorator, int members, double precision, std::string density) -> ClusterProvenance
    setup_particle(Model m, ParticleIndex pi, ClusterProvenance o) -> ClusterProvenance
    ClusterProvenance_setup_particle(_ParticleAdaptor decorator, ClusterProvenance o) -> ClusterProvenance
    """
    return _IMP_core.ClusterProvenance_setup_particle(*args)

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

    def set_filename(self, filename):
        """set_filename(ScriptProvenance self, std::string filename)"""
        return _IMP_core.ScriptProvenance_set_filename(self, filename)


    def get_filename(self):
        """get_filename(ScriptProvenance self) -> std::string"""
        return _IMP_core.ScriptProvenance_get_filename(self)


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

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

    get_is_setup = staticmethod(get_is_setup)

    def show(self, *args):
        """
        show(ScriptProvenance self, _ostream out)
        show(ScriptProvenance self)
        """
        return _IMP_core.ScriptProvenance_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi, std::string filename) -> ScriptProvenance
        setup_particle(_ParticleAdaptor decorator, std::string filename) -> ScriptProvenance
        setup_particle(Model m, ParticleIndex pi, ScriptProvenance o) -> ScriptProvenance
        setup_particle(_ParticleAdaptor decorator, ScriptProvenance o) -> ScriptProvenance
        """
        return _IMP_core.ScriptProvenance_setup_particle(*args)

    setup_particle = staticmethod(setup_particle)

    def add_attribute(self, *args):
        """
        add_attribute(ScriptProvenance self, FloatKey k, IMP::Float v, bool opt)
        add_attribute(ScriptProvenance self, FloatKey a0, IMP::Float a1)
        add_attribute(ScriptProvenance self, IntKey a0, IMP::Int a1)
        add_attribute(ScriptProvenance self, FloatsKey a0, IMP::Floats a1)
        add_attribute(ScriptProvenance self, IntsKey a0, IMP::Ints a1)
        add_attribute(ScriptProvenance self, StringKey a0, IMP::String a1)
        add_attribute(ScriptProvenance self, ParticleIndexKey a0, Particle a1)
        add_attribute(ScriptProvenance self, ObjectKey a0, Object a1)
        """
        return _IMP_core.ScriptProvenance_add_attribute(self, *args)


    def get_value(self, *args):
        """
        get_value(ScriptProvenance self, FloatKey a0) -> IMP::Float
        get_value(ScriptProvenance self, IntKey a0) -> IMP::Int
        get_value(ScriptProvenance self, FloatsKey a0) -> IMP::Floats
        get_value(ScriptProvenance self, IntsKey a0) -> IMP::Ints
        get_value(ScriptProvenance self, StringKey a0) -> IMP::String
        get_value(ScriptProvenance self, ParticleIndexKey a0) -> Particle
        get_value(ScriptProvenance self, ObjectKey a0) -> Object
        """
        return _IMP_core.ScriptProvenance_get_value(self, *args)


    def set_value(self, *args):
        """
        set_value(ScriptProvenance self, FloatKey a0, IMP::Float a1)
        set_value(ScriptProvenance self, IntKey a0, IMP::Int a1)
        set_value(ScriptProvenance self, FloatsKey a0, IMP::Floats a1)
        set_value(ScriptProvenance self, IntsKey a0, IMP::Ints a1)
        set_value(ScriptProvenance self, StringKey a0, IMP::String a1)
        set_value(ScriptProvenance self, ParticleIndexKey a0, Particle a1)
        set_value(ScriptProvenance self, ObjectKey a0, Object a1)
        """
        return _IMP_core.ScriptProvenance_set_value(self, *args)


    def remove_attribute(self, *args):
        """
        remove_attribute(ScriptProvenance self, FloatKey a0)
        remove_attribute(ScriptProvenance self, IntKey a0)
        remove_attribute(ScriptProvenance self, FloatsKey a0)
        remove_attribute(ScriptProvenance self, IntsKey a0)
        remove_attribute(ScriptProvenance self, StringKey a0)
        remove_attribute(ScriptProvenance self, ParticleIndexKey a0)
        remove_attribute(ScriptProvenance self, ObjectKey a0)
        """
        return _IMP_core.ScriptProvenance_remove_attribute(self, *args)


    def has_attribute(self, *args):
        """
        has_attribute(ScriptProvenance self, FloatKey a0) -> bool
        has_attribute(ScriptProvenance self, IntKey a0) -> bool
        has_attribute(ScriptProvenance self, FloatsKey a0) -> bool
        has_attribute(ScriptProvenance self, IntsKey a0) -> bool
        has_attribute(ScriptProvenance self, StringKey a0) -> bool
        has_attribute(ScriptProvenance self, ParticleIndexKey a0) -> bool
        has_attribute(ScriptProvenance self, ObjectKey a0) -> bool
        """
        return _IMP_core.ScriptProvenance_has_attribute(self, *args)


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


    def get_name(self):
        """get_name(ScriptProvenance self) -> std::string"""
        return _IMP_core.ScriptProvenance_get_name(self)


    def clear_caches(self):
        """clear_caches(ScriptProvenance self)"""
        return _IMP_core.ScriptProvenance_clear_caches(self)


    def set_name(self, a0):
        """set_name(ScriptProvenance self, std::string a0)"""
        return _IMP_core.ScriptProvenance_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(ScriptProvenance self, IMP::CheckLevel a0)"""
        return _IMP_core.ScriptProvenance_set_check_level(self, a0)


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


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(ScriptProvenance self, FloatKey a0, bool a1)"""
        return _IMP_core.ScriptProvenance_set_is_optimized(self, a0, a1)


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


    def get_check_level(self):
        """get_check_level(ScriptProvenance self) -> IMP::CheckLevel"""
        return _IMP_core.ScriptProvenance_get_check_level(self)


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


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


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


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


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


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


    def __hash__(self):
        """__hash__(ScriptProvenance self) -> std::size_t"""
        return _IMP_core.ScriptProvenance___hash__(self)


    def __str__(self):
        """__str__(ScriptProvenance self) -> std::string"""
        return _IMP_core.ScriptProvenance___str__(self)


    def __repr__(self):
        """__repr__(ScriptProvenance self) -> std::string"""
        return _IMP_core.ScriptProvenance___repr__(self)

    __swig_destroy__ = _IMP_core.delete_ScriptProvenance
    __del__ = lambda self: None
ScriptProvenance_swigregister = _IMP_core.ScriptProvenance_swigregister
ScriptProvenance_swigregister(ScriptProvenance)

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

def ScriptProvenance_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi, std::string filename) -> ScriptProvenance
    setup_particle(_ParticleAdaptor decorator, std::string filename) -> ScriptProvenance
    setup_particle(Model m, ParticleIndex pi, ScriptProvenance o) -> ScriptProvenance
    ScriptProvenance_setup_particle(_ParticleAdaptor decorator, ScriptProvenance o) -> ScriptProvenance
    """
    return _IMP_core.ScriptProvenance_setup_particle(*args)

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

    def set_software_name(self, name):
        """set_software_name(SoftwareProvenance self, std::string name)"""
        return _IMP_core.SoftwareProvenance_set_software_name(self, name)


    def get_software_name(self):
        """get_software_name(SoftwareProvenance self) -> std::string"""
        return _IMP_core.SoftwareProvenance_get_software_name(self)


    def set_version(self, version):
        """set_version(SoftwareProvenance self, std::string version)"""
        return _IMP_core.SoftwareProvenance_set_version(self, version)


    def get_version(self):
        """get_version(SoftwareProvenance self) -> std::string"""
        return _IMP_core.SoftwareProvenance_get_version(self)


    def set_location(self, location):
        """set_location(SoftwareProvenance self, std::string location)"""
        return _IMP_core.SoftwareProvenance_set_location(self, location)


    def get_location(self):
        """get_location(SoftwareProvenance self) -> std::string"""
        return _IMP_core.SoftwareProvenance_get_location(self)


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

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

    get_is_setup = staticmethod(get_is_setup)

    def show(self, *args):
        """
        show(SoftwareProvenance self, _ostream out)
        show(SoftwareProvenance self)
        """
        return _IMP_core.SoftwareProvenance_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi, std::string name, std::string version, std::string location) -> SoftwareProvenance
        setup_particle(_ParticleAdaptor decorator, std::string name, std::string version, std::string location) -> SoftwareProvenance
        setup_particle(Model m, ParticleIndex pi, SoftwareProvenance o) -> SoftwareProvenance
        setup_particle(_ParticleAdaptor decorator, SoftwareProvenance o) -> SoftwareProvenance
        """
        return _IMP_core.SoftwareProvenance_setup_particle(*args)

    setup_particle = staticmethod(setup_particle)

    def add_attribute(self, *args):
        """
        add_attribute(SoftwareProvenance self, FloatKey k, IMP::Float v, bool opt)
        add_attribute(SoftwareProvenance self, FloatKey a0, IMP::Float a1)
        add_attribute(SoftwareProvenance self, IntKey a0, IMP::Int a1)
        add_attribute(SoftwareProvenance self, FloatsKey a0, IMP::Floats a1)
        add_attribute(SoftwareProvenance self, IntsKey a0, IMP::Ints a1)
        add_attribute(SoftwareProvenance self, StringKey a0, IMP::String a1)
        add_attribute(SoftwareProvenance self, ParticleIndexKey a0, Particle a1)
        add_attribute(SoftwareProvenance self, ObjectKey a0, Object a1)
        """
        return _IMP_core.SoftwareProvenance_add_attribute(self, *args)


    def get_value(self, *args):
        """
        get_value(SoftwareProvenance self, FloatKey a0) -> IMP::Float
        get_value(SoftwareProvenance self, IntKey a0) -> IMP::Int
        get_value(SoftwareProvenance self, FloatsKey a0) -> IMP::Floats
        get_value(SoftwareProvenance self, IntsKey a0) -> IMP::Ints
        get_value(SoftwareProvenance self, StringKey a0) -> IMP::String
        get_value(SoftwareProvenance self, ParticleIndexKey a0) -> Particle
        get_value(SoftwareProvenance self, ObjectKey a0) -> Object
        """
        return _IMP_core.SoftwareProvenance_get_value(self, *args)


    def set_value(self, *args):
        """
        set_value(SoftwareProvenance self, FloatKey a0, IMP::Float a1)
        set_value(SoftwareProvenance self, IntKey a0, IMP::Int a1)
        set_value(SoftwareProvenance self, FloatsKey a0, IMP::Floats a1)
        set_value(SoftwareProvenance self, IntsKey a0, IMP::Ints a1)
        set_value(SoftwareProvenance self, StringKey a0, IMP::String a1)
        set_value(SoftwareProvenance self, ParticleIndexKey a0, Particle a1)
        set_value(SoftwareProvenance self, ObjectKey a0, Object a1)
        """
        return _IMP_core.SoftwareProvenance_set_value(self, *args)


    def remove_attribute(self, *args):
        """
        remove_attribute(SoftwareProvenance self, FloatKey a0)
        remove_attribute(SoftwareProvenance self, IntKey a0)
        remove_attribute(SoftwareProvenance self, FloatsKey a0)
        remove_attribute(SoftwareProvenance self, IntsKey a0)
        remove_attribute(SoftwareProvenance self, StringKey a0)
        remove_attribute(SoftwareProvenance self, ParticleIndexKey a0)
        remove_attribute(SoftwareProvenance self, ObjectKey a0)
        """
        return _IMP_core.SoftwareProvenance_remove_attribute(self, *args)


    def has_attribute(self, *args):
        """
        has_attribute(SoftwareProvenance self, FloatKey a0) -> bool
        has_attribute(SoftwareProvenance self, IntKey a0) -> bool
        has_attribute(SoftwareProvenance self, FloatsKey a0) -> bool
        has_attribute(SoftwareProvenance self, IntsKey a0) -> bool
        has_attribute(SoftwareProvenance self, StringKey a0) -> bool
        has_attribute(SoftwareProvenance self, ParticleIndexKey a0) -> bool
        has_attribute(SoftwareProvenance self, ObjectKey a0) -> bool
        """
        return _IMP_core.SoftwareProvenance_has_attribute(self, *args)


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


    def get_name(self):
        """get_name(SoftwareProvenance self) -> std::string"""
        return _IMP_core.SoftwareProvenance_get_name(self)


    def clear_caches(self):
        """clear_caches(SoftwareProvenance self)"""
        return _IMP_core.SoftwareProvenance_clear_caches(self)


    def set_name(self, a0):
        """set_name(SoftwareProvenance self, std::string a0)"""
        return _IMP_core.SoftwareProvenance_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(SoftwareProvenance self, IMP::CheckLevel a0)"""
        return _IMP_core.SoftwareProvenance_set_check_level(self, a0)


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


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(SoftwareProvenance self, FloatKey a0, bool a1)"""
        return _IMP_core.SoftwareProvenance_set_is_optimized(self, a0, a1)


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


    def get_check_level(self):
        """get_check_level(SoftwareProvenance self) -> IMP::CheckLevel"""
        return _IMP_core.SoftwareProvenance_get_check_level(self)


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


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


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


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


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


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


    def __hash__(self):
        """__hash__(SoftwareProvenance self) -> std::size_t"""
        return _IMP_core.SoftwareProvenance___hash__(self)


    def __str__(self):
        """__str__(SoftwareProvenance self) -> std::string"""
        return _IMP_core.SoftwareProvenance___str__(self)


    def __repr__(self):
        """__repr__(SoftwareProvenance self) -> std::string"""
        return _IMP_core.SoftwareProvenance___repr__(self)

    __swig_destroy__ = _IMP_core.delete_SoftwareProvenance
    __del__ = lambda self: None
SoftwareProvenance_swigregister = _IMP_core.SoftwareProvenance_swigregister
SoftwareProvenance_swigregister(SoftwareProvenance)

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

def SoftwareProvenance_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi, std::string name, std::string version, std::string location) -> SoftwareProvenance
    setup_particle(_ParticleAdaptor decorator, std::string name, std::string version, std::string location) -> SoftwareProvenance
    setup_particle(Model m, ParticleIndex pi, SoftwareProvenance o) -> SoftwareProvenance
    SoftwareProvenance_setup_particle(_ParticleAdaptor decorator, SoftwareProvenance o) -> SoftwareProvenance
    """
    return _IMP_core.SoftwareProvenance_setup_particle(*args)

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

    def get_provenance(self):
        """get_provenance(Provenanced self) -> Provenance"""
        return _IMP_core.Provenanced_get_provenance(self)


    def set_provenance(self, p):
        """set_provenance(Provenanced self, Provenance p)"""
        return _IMP_core.Provenanced_set_provenance(self, p)


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

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

    get_is_setup = staticmethod(get_is_setup)

    def show(self, *args):
        """
        show(Provenanced self, _ostream out)
        show(Provenanced self)
        """
        return _IMP_core.Provenanced_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi, Provenance p) -> Provenanced
        setup_particle(_ParticleAdaptor decorator, Provenance p) -> Provenanced
        """
        return _IMP_core.Provenanced_setup_particle(*args)

    setup_particle = staticmethod(setup_particle)

    def add_attribute(self, *args):
        """
        add_attribute(Provenanced self, FloatKey k, IMP::Float v, bool opt)
        add_attribute(Provenanced self, FloatKey a0, IMP::Float a1)
        add_attribute(Provenanced self, IntKey a0, IMP::Int a1)
        add_attribute(Provenanced self, FloatsKey a0, IMP::Floats a1)
        add_attribute(Provenanced self, IntsKey a0, IMP::Ints a1)
        add_attribute(Provenanced self, StringKey a0, IMP::String a1)
        add_attribute(Provenanced self, ParticleIndexKey a0, Particle a1)
        add_attribute(Provenanced self, ObjectKey a0, Object a1)
        """
        return _IMP_core.Provenanced_add_attribute(self, *args)


    def get_value(self, *args):
        """
        get_value(Provenanced self, FloatKey a0) -> IMP::Float
        get_value(Provenanced self, IntKey a0) -> IMP::Int
        get_value(Provenanced self, FloatsKey a0) -> IMP::Floats
        get_value(Provenanced self, IntsKey a0) -> IMP::Ints
        get_value(Provenanced self, StringKey a0) -> IMP::String
        get_value(Provenanced self, ParticleIndexKey a0) -> Particle
        get_value(Provenanced self, ObjectKey a0) -> Object
        """
        return _IMP_core.Provenanced_get_value(self, *args)


    def set_value(self, *args):
        """
        set_value(Provenanced self, FloatKey a0, IMP::Float a1)
        set_value(Provenanced self, IntKey a0, IMP::Int a1)
        set_value(Provenanced self, FloatsKey a0, IMP::Floats a1)
        set_value(Provenanced self, IntsKey a0, IMP::Ints a1)
        set_value(Provenanced self, StringKey a0, IMP::String a1)
        set_value(Provenanced self, ParticleIndexKey a0, Particle a1)
        set_value(Provenanced self, ObjectKey a0, Object a1)
        """
        return _IMP_core.Provenanced_set_value(self, *args)


    def remove_attribute(self, *args):
        """
        remove_attribute(Provenanced self, FloatKey a0)
        remove_attribute(Provenanced self, IntKey a0)
        remove_attribute(Provenanced self, FloatsKey a0)
        remove_attribute(Provenanced self, IntsKey a0)
        remove_attribute(Provenanced self, StringKey a0)
        remove_attribute(Provenanced self, ParticleIndexKey a0)
        remove_attribute(Provenanced self, ObjectKey a0)
        """
        return _IMP_core.Provenanced_remove_attribute(self, *args)


    def has_attribute(self, *args):
        """
        has_attribute(Provenanced self, FloatKey a0) -> bool
        has_attribute(Provenanced self, IntKey a0) -> bool
        has_attribute(Provenanced self, FloatsKey a0) -> bool
        has_attribute(Provenanced self, IntsKey a0) -> bool
        has_attribute(Provenanced self, StringKey a0) -> bool
        has_attribute(Provenanced self, ParticleIndexKey a0) -> bool
        has_attribute(Provenanced self, ObjectKey a0) -> bool
        """
        return _IMP_core.Provenanced_has_attribute(self, *args)


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


    def get_name(self):
        """get_name(Provenanced self) -> std::string"""
        return _IMP_core.Provenanced_get_name(self)


    def clear_caches(self):
        """clear_caches(Provenanced self)"""
        return _IMP_core.Provenanced_clear_caches(self)


    def set_name(self, a0):
        """set_name(Provenanced self, std::string a0)"""
        return _IMP_core.Provenanced_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(Provenanced self, IMP::CheckLevel a0)"""
        return _IMP_core.Provenanced_set_check_level(self, a0)


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


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(Provenanced self, FloatKey a0, bool a1)"""
        return _IMP_core.Provenanced_set_is_optimized(self, a0, a1)


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


    def get_check_level(self):
        """get_check_level(Provenanced self) -> IMP::CheckLevel"""
        return _IMP_core.Provenanced_get_check_level(self)


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


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


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


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


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


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


    def __hash__(self):
        """__hash__(Provenanced self) -> std::size_t"""
        return _IMP_core.Provenanced___hash__(self)


    def __str__(self):
        """__str__(Provenanced self) -> std::string"""
        return _IMP_core.Provenanced___str__(self)


    def __repr__(self):
        """__repr__(Provenanced self) -> std::string"""
        return _IMP_core.Provenanced___repr__(self)

    __swig_destroy__ = _IMP_core.delete_Provenanced
    __del__ = lambda self: None
Provenanced_swigregister = _IMP_core.Provenanced_swigregister
Provenanced_swigregister(Provenanced)

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

def Provenanced_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi, Provenance p) -> Provenanced
    Provenanced_setup_particle(_ParticleAdaptor decorator, Provenance p) -> Provenanced
    """
    return _IMP_core.Provenanced_setup_particle(*args)


def add_provenance(m, pi, p):
    """add_provenance(Model m, ParticleIndex pi, Provenance p)"""
    return _IMP_core.add_provenance(m, pi, p)

def create_clone(p):
    """create_clone(Provenance p) -> Provenance"""
    return _IMP_core.create_clone(p)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_TruncatedHarmonic(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_TruncatedHarmonic(o)

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)


    @staticmethod
    def get_from(o):
       return _object_cast_to_TruncatedHarmonic(o)

TruncatedHarmonicBound_swigregister = _IMP_core.TruncatedHarmonicBound_swigregister
TruncatedHarmonicBound_swigregister(TruncatedHarmonicBound)

class ParticleType(IMP._Value):
    """Proxy of C++ IMP::Key<(34897493)> 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)> self) -> ParticleType
        __init__(IMP::Key<(34897493)> self, std::string const & c, bool is_implicit_add_permitted=True) -> ParticleType
        __init__(IMP::Key<(34897493)> self, std::string const & c) -> ParticleType
        __init__(IMP::Key<(34897493)> 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_number_of_keys():
        """get_number_of_keys() -> unsigned int"""
        return _IMP_core.ParticleType_get_number_of_keys()

    get_number_of_keys = staticmethod(get_number_of_keys)

    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_get_number_of_keys():
    """ParticleType_get_number_of_keys() -> unsigned int"""
    return _IMP_core.ParticleType_get_number_of_keys()

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_unary_function(self):
        """get_unary_function(AttributeSingletonScore self) -> UnaryFunction"""
        return _IMP_core.AttributeSingletonScore_get_unary_function(self)


    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_generic_attribute_singleton_score(uf, k):
    """create_generic_attribute_singleton_score(UnaryFunction uf, FloatKey k) -> AttributeSingletonScore"""
    return _IMP_core.create_generic_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 BoundingSphere3DSingletonScore(IMP.SingletonScore):
    """Proxy of C++ IMP::core::GenericBoundingSphere3DSingletonScore<(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, sphere):
        """__init__(IMP::core::GenericBoundingSphere3DSingletonScore<(UnaryFunction)> self, UnaryFunction f, Sphere3D sphere) -> BoundingSphere3DSingletonScore"""
        this = _IMP_core.new_BoundingSphere3DSingletonScore(f, sphere)
        try:
            self.this.append(this)
        except:
            self.this = this

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


    def get_version_info(self):
        """get_version_info(BoundingSphere3DSingletonScore self) -> VersionInfo"""
        return _IMP_core.BoundingSphere3DSingletonScore_get_version_info(self)

BoundingSphere3DSingletonScore_swigregister = _IMP_core.BoundingSphere3DSingletonScore_swigregister
BoundingSphere3DSingletonScore_swigregister(BoundingSphere3DSingletonScore)


def create_bounding_sphere_3d_singleton_score(f, sphere):
    """create_bounding_sphere_3d_singleton_score(UnaryFunction f, Sphere3D sphere) -> BoundingSphere3DSingletonScore"""
    return _IMP_core.create_bounding_sphere_3d_singleton_score(f, sphere)
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_all_provenance(p, types=[StructureProvenance, SampleProvenance,
                                 CombineProvenance, FilterProvenance,
                                 ClusterProvenance, ScriptProvenance,
                                 SoftwareProvenance]):
    """Yield all provenance decorators of the given types for the particle.
       By default, all provenance types are returned. Provenance is returned
       in order, most recent first. If the particle has no provenance
       information, an empty generator is returned."""
    if Provenanced.get_is_setup(p):
        prov = Provenanced(p).get_provenance()
        while prov:
            for c in types:
                if c.get_is_setup(prov):
                    yield c(prov)
            prov = prov.get_previous()

def add_script_provenance(p):
   """Tag the given particle with the current Python script.
      This is a noop if the particle is already so tagged."""
   main = sys.modules['__main__']
# Can't do anything if running from an interactive interpreter
   if not hasattr(main, '__file__'):
       return
   f = IMP.get_absolute_path(main.__file__)
   for prov in get_all_provenance(p, types=[ScriptProvenance]):
       if prov.get_filename() == f:
           return
   m = p.get_model()
   provp = IMP.Particle(m)
   provp.set_name('script')
   prov = ScriptProvenance.setup_particle(provp, f)
   add_provenance(m, p, prov)

def add_software_provenance(p, name, version, location):
   """Tag the given particle with the software used to create it.
      This is a noop if the particle is already so tagged."""
   for prov in get_all_provenance(p, types=[SoftwareProvenance]):
       if prov.get_software_name() == name and prov.get_version() == version \
          and prov.get_location() == location:
           return
   m = p.get_model()
   provp = IMP.Particle(m)
   provp.set_name('software')
   prov = SoftwareProvenance.setup_particle(provp, name, version, location)
   add_provenance(m, p, prov)

def add_imp_provenance(p):
    """Tag the given particle as being created by the current version of IMP."""
    add_software_provenance(p, name="Integrative Modeling Platform (IMP)",
                            version=IMP.get_module_version(),
                            location="https://integrativemodeling.org")


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